fun declareLocal(
        localValue: LocalValue,
        assignedObjectOrigin: ObjectOrigin,
        reportError: ErrorCollector
    ) {
        val name = localValue.name
        if (name in ownLocalsByName) {
            reportError.collect(ResolutionError(localValue, ErrorReason.DuplicateLocalValue(name)))
        }

	bar.ReportProgress()
	bar.ReportProgress()

	bar.ReportWaiting([]string{"deployment"})
	expect(`- Processing resources for ` + cnbo + `, ` + cnpo + `. Waiting for deployment`)

	bar.ReportError("some error")
	expect(`❌ ` + cnbo + ` encountered an error: some error`)

	foo.ReportProgress()
	expect(`- Processing resources for ` + cnpo + `.`)

	foo.ReportFinished()
	expect(`🧠 ` + cnpo + ` installed`)

	finished bool
	waiting  []string
	mu       sync.Mutex
}

func (p *ManifestLog) ReportProgress() {
	if p == nil {
		return
	}
	p.report()
}

func (p *ManifestLog) ReportError(err string) {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.err = err
	p.mu.Unlock()
	p.report()
}

func (p *ManifestLog) ReportFinished() {
	if p == nil {
		return
	}

				packages, err := r.matchInModule(ctx, q.pattern, curM)
				if len(packages) == 0 {
					if err != nil {
						reportError(q, err)
					}
					continue // curM is not relevant to q.
				}
			}

			rev, err := r.queryModule(ctx, curM.Path, q.version, r.initialSelected)
			if err != nil {
				reportError(q, err)
				continue
			}
			if rev.Version == curM.Version {
				continue // curM already matches q.
			}

        "Coordination service is not enabled.");
    return;
  }
  tensorflow::Status s(static_cast<absl::StatusCode>(error_code),
                       error_message);
  status->status = coord_agent->ReportError(s);
}

void TFE_GetTaskStates(TFE_Context* ctx, const TF_Buffer& tasks, void* states,
                       TF_Status* status) {
  tensorflow::ImmediateExecutionDistributedManager* dist_mgr =