@mysten-incubation/devstack 0.1.1 → 0.3.0

package/dist/orchestrators/codegen/service.mjs

@@ -1,23 +1,45 @@
 import { acquireStackLock } from "../../substrate/runtime/cross-process/stack-lock.mjs";
 import { mintRandomSuffix } from "../../substrate/runtime/random-suffix.mjs";
 import { StageAndSwapError, stageAndSwap } from "../../substrate/runtime/stage-and-swap/index.mjs";
-import { CodegenEmitFailed, CodegenEmitterCollision, CodegenPathConflict, CodegenWriteFailed } from "./errors.mjs";
+import { CodegenAggregateConflict, CodegenEmitFailed, CodegenEmitterCollision, CodegenPathConflict, CodegenWriteFailed } from "./errors.mjs";
 import { emitOne } from "./emit.mjs";
 import { dirModeFor, modeFor } from "./permissions.mjs";
-import { MoveCodegenService, MoveSummaryRunnerService, emitBindings } from "./bindings.mjs";
+import { MoveCodegenService, MoveSummaryRunnerService, emitBindings, isPackageBindings } from "./bindings.mjs";
 import { CodegenPathsService } from "./paths.mjs";
+import { isRawExpr } from "../../contracts/codegenable.mjs";
+import { CONFIG_RUNTIME_OUTPUT_PATH, CONFIG_RUNTIME_SOURCE } from "./config-runtime.mjs";
 import { renderFile } from "./format.mjs";
 import { writeGitignore } from "./gitignore.mjs";
+import { UNRESOLVED_ID } from "./id-config.mjs";
 import { Context, Effect, Layer, Order, Ref } from "effect";
 import { dirname } from "node:path";
 //#region src/orchestrators/codegen/service.ts
-const buildParentModeResolver = (paths, decls) => Effect.gen(function* () {
+/** Resolve a decl/aggregate's absolute output path against the tree
+*  selected by its `outputLocation`. `'generated-extras'` routes
+*  through `paths.resolveExtras` (the gitignored dev tree); everything
+*  else through `paths.resolve` (the staging-and-swapped runtime tree). */
+const resolveAt = (paths, location, outputPath) => location === "generated-extras" ? paths.resolveExtras(outputPath) : paths.resolve(outputPath);
+const declLocation = (decl) => decl.outputLocation ?? "generated";
+/** A decl belongs to the `emitExtras` flush IFF it writes ONLY into the
+*  dev-only `generated-extras` tree. INVARIANT: `emitExtras` must NEVER
+*  touch the committed `src/generated` tree (it runs without stage-and-swap),
+*  so a decl that would emit any file into `generated` is excluded.
+*
+*  - `aggregateOnly` decls write only their aggregate file: include iff the
+*    aggregate's location is `generated-extras` (e.g. each account folding
+*    into the gitignored `accounts.ts`).
+*  - standalone decls write a per-decl file (and possibly an aggregate):
+*    include iff that standalone file lands in `generated-extras` (e.g. the
+*    wallet's `dev-wallet.ts`). A standalone-in-`generated` decl is excluded
+*    even if its aggregate targets `generated-extras`. */
+const isExtrasDecl = (decl) => decl.aggregateOnly === true ? (decl.aggregate?.outputLocation ?? "generated") === "generated-extras" : declLocation(decl) === "generated-extras";
+const buildParentModeResolver = (paths, entries) => Effect.gen(function* () {
 	const byParent = /* @__PURE__ */ new Map();
-	for (const decl of decls) {
-		const parent = dirname(yield* paths.resolve(decl.outputPath));
+	for (const entry of entries) {
+		const parent = dirname(yield* resolveAt(paths, entry.location, entry.outputPath));
 		const current = byParent.get(parent);
-		if (current === void 0) byParent.set(parent, [decl]);
-		else current.push(decl);
+		if (current === void 0) byParent.set(parent, [{ sensitive: entry.sensitive }]);
+		else current.push({ sensitive: entry.sensitive });
 	}
 	const modes = /* @__PURE__ */ new Map();
 	for (const [parent, parentDecls] of byParent) modes.set(parent, dirModeFor(parentDecls));
@@ -62,11 +84,7 @@ const runEmitCycleLocked = (input) => Effect.gen(function* () {
 			cause: e
 		});
 		return e;
-	}), Effect.withSpan("codegen.runEmitCycle", { attributes: {
-		"codegen.contributions": input.contributions.length,
-		"codegen.cycleId": cycleId,
-		"codegen.stagingDir": stagingPaths.outputDir
-	} }));
+	}));
 });
 /**
 * Project a staging-rooted `RunEmitCycleResult` back into the user-
@@ -95,14 +113,20 @@ const rewriteResultPaths = (result, stagingDir, outputDir) => {
 * this function so callers know the contribution set is well-formed.
 */
 const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
+	yield* Effect.logInfo(`codegen: emitting projection (trackTree=${input.trackTree === true}).`);
 	const fileEmitters = [...input.contributions];
 	const filesWritten = [];
 	const filesUnchanged = [];
 	const filesChmod = [];
 	const aggregates = /* @__PURE__ */ new Map();
+	const aggregateMeta = /* @__PURE__ */ new Map();
 	const packageContribs = [];
 	const sortedDecls = [...fileEmitters].sort(Order.mapInput(Order.String, (d) => d.outputPath));
-	const parentModeFor = yield* buildParentModeResolver(paths, fileEmitters);
+	const parentModeFor = yield* buildParentModeResolver(paths, fileEmitters.filter((d) => d.aggregateOnly !== true).map((d) => ({
+		outputPath: d.outputPath,
+		location: declLocation(d),
+		sensitive: d.sensitive === true
+	})));
 	for (const decl of sortedDecls) {
 		const emission = yield* runEmitter(decl);
 		const exported = emission.exports;
@@ -110,11 +134,36 @@ const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
 			const projected = decl.aggregate.project(exported);
 			if (projected !== null) {
 				const bucket = aggregates.get(decl.aggregate.bucket) ?? {};
-				Object.assign(bucket, projected);
+				deepMerge(bucket, projected);
 				aggregates.set(decl.aggregate.bucket, bucket);
+				const declLoc = decl.aggregate.outputLocation ?? "generated";
+				const declSensitive = decl.aggregate.sensitive === true;
+				const established = aggregateMeta.get(decl.aggregate.bucket);
+				if (established === void 0) aggregateMeta.set(decl.aggregate.bucket, {
+					location: declLoc,
+					sensitive: declSensitive,
+					establishedBy: decl.emitterName
+				});
+				else {
+					if (established.location !== declLoc) return yield* Effect.fail(new CodegenAggregateConflict({
+						bucket: decl.aggregate.bucket,
+						field: "outputLocation",
+						established: established.location,
+						conflicting: declLoc,
+						emitters: [established.establishedBy, decl.emitterName]
+					}));
+					if (established.sensitive !== declSensitive) return yield* Effect.fail(new CodegenAggregateConflict({
+						bucket: decl.aggregate.bucket,
+						field: "sensitive",
+						established: String(established.sensitive),
+						conflicting: String(declSensitive),
+						emitters: [established.establishedBy, decl.emitterName]
+					}));
+				}
 			}
 		}
 		for (const value of Object.values(exported)) if (isPackageBindings(value)) packageContribs.push(value);
+		if (decl.aggregateOnly === true) continue;
 		const rendered = renderFile({
 			emitterName: decl.emitterName,
 			outputPath: decl.outputPath,
@@ -123,7 +172,7 @@ const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
 			imports: emission.imports
 		});
 		if (!rendered.ok) return yield* Effect.fail(rendered.error);
-		const abs = yield* paths.resolve(decl.outputPath);
+		const abs = yield* resolveAt(paths, declLocation(decl), decl.outputPath);
 		switch ((yield* emitOne({
 			path: abs,
 			content: rendered.text,
@@ -141,18 +190,42 @@ const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
 				break;
 		}
 	}
-	for (const aggregate of buildAggregateFiles(aggregates)) {
+	const aggregateFiles = buildAggregateFiles(aggregates, aggregateMeta);
+	let needsConfigRuntime = false;
+	for (const aggregate of aggregateFiles) {
+		const resolvers = resolversUsedBy(aggregate.exports);
+		if (resolvers.length > 0) needsConfigRuntime = true;
 		const rendered = renderFile({
 			emitterName: aggregate.emitterName,
 			outputPath: aggregate.outputPath,
-			sensitive: false,
-			exports: aggregate.exports
+			sensitive: aggregate.sensitive,
+			exports: aggregate.exports,
+			...resolvers.length > 0 ? { imports: [`import { ${resolvers.join(", ")} } from './config-runtime.js';`] } : {}
 		});
 		if (!rendered.ok) return yield* Effect.fail(rendered.error);
-		const abs = yield* paths.resolve(aggregate.outputPath);
+		const abs = yield* resolveAt(paths, aggregate.location, aggregate.outputPath);
 		switch ((yield* emitOne({
 			path: abs,
 			content: rendered.text,
+			mode: aggregate.sensitive ? 384 : 420,
+			parentMode: parentModeFor(abs)
+		})).outcome) {
+			case "wrote":
+				filesWritten.push(abs);
+				break;
+			case "unchanged":
+				filesUnchanged.push(abs);
+				break;
+			case "chmod-only":
+				filesChmod.push(abs);
+				break;
+		}
+	}
+	if (needsConfigRuntime) {
+		const abs = yield* paths.resolve(CONFIG_RUNTIME_OUTPUT_PATH);
+		switch ((yield* emitOne({
+			path: abs,
+			content: CONFIG_RUNTIME_SOURCE,
 			mode: 420,
 			parentMode: parentModeFor(abs)
 		})).outcome) {
@@ -174,12 +247,15 @@ const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
 		importExtension: input.bindingsImportExtension
 	});
 	else yield* Effect.logInfo("codegen: no package contributions; skipping Move-to-TS bindings step.");
-	const sensitivePaths = fileEmitters.filter((d) => d.sensitive === true).map((d) => d.outputPath);
-	yield* writeGitignore({
-		path: paths.gitignoreFile,
-		sensitivePaths,
-		parentMode: parentModeFor(paths.gitignoreFile)
-	});
+	if (fileEmitters.some((d) => d.aggregateOnly !== true && declLocation(d) === "generated") || aggregateFiles.some((a) => a.location === "generated")) {
+		const sensitivePaths = [...fileEmitters.filter((d) => d.sensitive === true && d.aggregateOnly !== true && declLocation(d) === "generated").map((d) => d.outputPath), ...aggregateFiles.filter((a) => a.sensitive && a.location === "generated").map((a) => a.outputPath)];
+		yield* writeGitignore({
+			path: paths.gitignoreFile,
+			sensitivePaths,
+			parentMode: parentModeFor(paths.gitignoreFile),
+			trackTree: input.trackTree === true
+		});
+	}
 	return {
 		filesWritten,
 		filesUnchanged,
@@ -188,6 +264,8 @@ const runEmitCycleInner = (input, paths) => Effect.gen(function* () {
 	};
 });
 const runEmitter = (decl) => Effect.gen(function* () {
+	const kind = decl.aggregate?.kind;
+	if (kind !== void 0) yield* Effect.annotateCurrentSpan("codegen.kind", kind);
 	const exports = {};
 	const imports = [];
 	const done = { _tag: "CodegenEmitDone" };
@@ -208,7 +286,7 @@ const runEmitter = (decl) => Effect.gen(function* () {
 		exports,
 		imports
 	};
-});
+}).pipe(Effect.withSpan("codegen.emit", { attributes: { "codegen.emitter": decl.emitterName } }));
 /**
 * Uniqueness check: emitter name (literal) must be unique unless
 * the decl opts into repetition via `allowEmitterNameRepetition`
@@ -220,17 +298,20 @@ const validateUniqueness = (decls) => Effect.gen(function* () {
 	const byPath = /* @__PURE__ */ new Map();
 	const byName = /* @__PURE__ */ new Map();
 	for (const d of decls) {
-		const ps = byPath.get(d.outputPath) ?? [];
-		ps.push(d.emitterName);
-		byPath.set(d.outputPath, ps);
+		if (d.aggregateOnly !== true) {
+			const pathKey = `${declLocation(d)} ${d.outputPath}`;
+			const ps = byPath.get(pathKey) ?? [];
+			ps.push(d.emitterName);
+			byPath.set(pathKey, ps);
+		}
 		if (d.allowEmitterNameRepetition === true) continue;
 		const ns = byName.get(d.emitterName) ?? [];
 		ns.push(d.outputPath);
 		byName.set(d.emitterName, ns);
 	}
-	for (const [path, emitters] of byPath) if (emitters.length > 1) return yield* Effect.fail(new CodegenPathConflict({
+	for (const [pathKey, emitters] of byPath) if (emitters.length > 1) return yield* Effect.fail(new CodegenPathConflict({
 		kind: "duplicate",
-		outputPath: path,
+		outputPath: pathKey.slice(pathKey.indexOf(" ") + 1),
 		emitters
 	}));
 	for (const [name, outputPaths] of byName) if (outputPaths.length > 1) return yield* Effect.fail(new CodegenEmitterCollision({
@@ -245,50 +326,166 @@ const validateUniqueness = (decls) => Effect.gen(function* () {
 * it does not enumerate or recognize plugin identities here.
 */
 const validateAggregatePathAvailability = (decls) => Effect.gen(function* () {
-	const aggregatePaths = /* @__PURE__ */ new Set();
-	for (const decl of decls) if (decl.aggregate !== void 0) aggregatePaths.add(decl.aggregate.bucket);
-	for (const path of aggregatePaths) {
-		const colliding = decls.filter((decl) => decl.outputPath === path);
+	const aggregatePaths = /* @__PURE__ */ new Map();
+	for (const decl of decls) if (decl.aggregate !== void 0) {
+		const location = decl.aggregate.outputLocation ?? "generated";
+		aggregatePaths.set(`${location} ${decl.aggregate.bucket}`, decl.aggregate.bucket);
+	}
+	for (const [key, bucket] of aggregatePaths) {
+		const location = key.slice(0, key.indexOf(" "));
+		const colliding = decls.filter((decl) => decl.aggregateOnly !== true && declLocation(decl) === location && decl.outputPath === bucket);
 		if (colliding.length > 0) return yield* Effect.fail(new CodegenPathConflict({
 			kind: "duplicate",
-			outputPath: path,
-			emitters: [...colliding.map((decl) => decl.emitterName), `aggregate/${path}`]
+			outputPath: bucket,
+			emitters: [...colliding.map((decl) => decl.emitterName), `aggregate/${bucket}`]
 		}));
 	}
 });
 /**
+* Recursively merge `source` into `target`. Distinct buckets are
+* shallow records keyed by name, but a single bucket (e.g. `config.ts`)
+* accumulates contributions from MANY plugins into nested sub-records
+* (`networks.localnet` from sui, `packages.<name>` / `objects.<name>`
+* from each package). A shallow `Object.assign` would have the last
+* package's `{packages:{...}}` clobber the prior ones. Deep-merge so
+* sibling keys at every level coexist.
+*
+* Arrays and non-plain values overwrite (no element-wise merge — a
+* plugin that re-emits a bucket key owns its full value). Only plain
+* objects recurse.
+*/
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const deepMerge = (target, source) => {
+	for (const [key, value] of Object.entries(source)) {
+		const existing = target[key];
+		if (isPlainObject(existing) && isPlainObject(value)) deepMerge(existing, value);
+		else target[key] = isPlainObject(value) || Array.isArray(value) ? structuredClone(value) : value;
+	}
+};
+/**
 * Synthesize one `AggregateFile` per non-empty bucket. The exports
 * map is keyed by the bucket's stem (e.g. `accounts.ts` → `accounts`)
 * so the rendered file exports `export const <stem> = { ... }`. The
 * orchestrator picks the export key from the bucket filename; the
 * stem itself is not a plugin identifier — it is the filename
-* without the `.ts` extension, derived mechanically.
+* without the `.ts` extension, derived mechanically. The bucket's
+* `location`/`sensitive` (from the first contributing decl) drive
+* which tree the file lands in and its mode.
 */
-const buildAggregateFiles = (buckets) => {
+const buildAggregateFiles = (buckets, meta) => {
 	const files = [];
 	const sortedEntries = [...buckets.entries()].sort(([a], [b]) => a.localeCompare(b));
 	for (const [bucket, contents] of sortedEntries) {
 		if (Object.keys(contents).length === 0) continue;
 		const stem = bucketStem(bucket);
+		const bucketMeta = meta.get(bucket) ?? {
+			location: "generated",
+			sensitive: false,
+			establishedBy: `aggregate/${stem}`
+		};
 		files.push({
 			emitterName: `aggregate/${stem}`,
 			outputPath: bucket,
-			exports: { [stem]: contents }
+			exports: { [stem]: contents },
+			location: bucketMeta.location,
+			sensitive: bucketMeta.sensitive
 		});
 	}
 	return files;
 };
 const bucketStem = (bucket) => bucket.replace(/\.ts$/, "").replace(/^.*\//, "");
+/** The config-runtime resolver names a committed `config.ts` aggregate may
+*  reference as raw expressions. Each is imported from `./config-runtime.js`
+*  only when the aggregate actually calls it (oxlint flags unused imports). */
+const CONFIG_RUNTIME_RESOLVERS = [
+	"resolveId",
+	"resolveNetwork",
+	"resolveNetworks",
+	"resolveValue"
+];
+/** Recursively collect which `config-runtime.ts` resolvers an exports map
+*  references via raw expressions — i.e. the committed `config.ts` needs each
+*  imported + the fixed `config-runtime.ts` emitted alongside it. */
+const collectResolversInValue = (value, found) => {
+	if (isRawExpr(value)) {
+		for (const name of CONFIG_RUNTIME_RESOLVERS) if (value.expr.includes(`${name}(`)) found.add(name);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const v of value) collectResolversInValue(v, found);
+		return;
+	}
+	if (isPlainObject(value)) for (const v of Object.values(value)) collectResolversInValue(v, found);
+};
+/** The ordered set of config-runtime resolvers an aggregate's exports use
+*  (empty when none — the aggregate needs no resolver import). */
+const resolversUsedBy = (exports) => {
+	const found = /* @__PURE__ */ new Set();
+	for (const v of Object.values(exports)) collectResolversInValue(v, found);
+	return CONFIG_RUNTIME_RESOLVERS.filter((name) => found.has(name));
+};
+var CodegenOrchestratorService = class extends Context.Service()("@devstack/orchestrators/Codegen") {};
 /**
-* Consumer-side shape guard: does this aggregated value look like a
-* Move-bindings contribution that `emitBindings` knows how to
-* consume? This is structural validation of the orchestrator's own
-* input contract, NOT a plugin-name match. Any plugin whose
-* `aggregate.project` returns objects with this shape will be
-* forwarded to the Move bindings emitter.
+* Slice the deep-merged `config.ts` aggregate bucket into the loadable
+* `IdConfig` interchange shape. The bucket is the live codegen
+* accumulation (sui `networks`, per-package `packages`/`objects`/
+* `mvrOverrides`, account `accounts`); this picks the id-bearing fields
+* the Vite plugin injects. Reads are defensive — any missing slice
+* collapses to an empty record so a partial stack still writes a valid
+* (if sparse) id-config.
 */
-const isPackageBindings = (v) => typeof v === "object" && v !== null && "name" in v && "packageId" in v && "mvrPlaceholder" in v && "sourcePath" in v;
-var CodegenOrchestratorService = class extends Context.Service()("@devstack/orchestrators/Codegen") {};
+const idConfigFromBucket = (bucket, network, values) => {
+	const asRecord = (v) => isPlainObject(v) ? v : {};
+	const asString = (v) => typeof v === "string" ? v : void 0;
+	const networks = {};
+	for (const [name, raw] of Object.entries(asRecord(bucket["networks"]))) {
+		const entry = asRecord(raw);
+		const rpc = asString(entry["rpc"]);
+		if (rpc === void 0) continue;
+		networks[name] = {
+			rpc,
+			...asString(entry["chainId"]) !== void 0 ? { chainId: asString(entry["chainId"]) } : {},
+			...entry["faucet"] !== void 0 ? { faucet: asString(entry["faucet"]) ?? null } : {},
+			...entry["graphql"] !== void 0 ? { graphql: asString(entry["graphql"]) ?? null } : {}
+		};
+	}
+	const packages = {};
+	for (const [name, raw] of Object.entries(asRecord(bucket["packages"]))) {
+		const entry = asRecord(raw);
+		const rawId = asString(entry["packageId"]);
+		const id = rawId === void 0 || rawId === "" ? UNRESOLVED_ID : rawId;
+		const objectsRaw = asRecord(entry["objects"]);
+		const objects = {};
+		for (const [k, v] of Object.entries(objectsRaw)) {
+			const s = asString(v);
+			if (s !== void 0) objects[k] = s;
+		}
+		packages[name] = {
+			id,
+			...Object.keys(objects).length > 0 ? { objects } : {}
+		};
+	}
+	const accounts = {};
+	for (const [name, v] of Object.entries(asRecord(bucket["accounts"]))) {
+		const address = asString(v) ?? asString(asRecord(v)["address"]);
+		if (address !== void 0) accounts[name] = address;
+	}
+	const mvrOverrides = {};
+	for (const [mvr, v] of Object.entries(asRecord(bucket["mvrOverrides"]))) {
+		const s = asString(v);
+		if (s !== void 0) mvrOverrides[mvr] = s;
+	}
+	const networkKeys = Object.keys(networks);
+	const bucketNetwork = asString(bucket["network"]);
+	return {
+		network: bucketNetwork !== void 0 && networkKeys.includes(bucketNetwork) ? bucketNetwork : networkKeys.includes(network) ? network : networkKeys.length === 1 ? networkKeys[0] : bucketNetwork ?? network,
+		networks,
+		packages,
+		accounts,
+		mvrOverrides,
+		...Object.keys(values).length > 0 ? { values } : {}
+	};
+};
 /** Layer-wired codegen orchestrator. No upstream requirements at boot
 *  time — the per-cycle effect carries the `FileSystem` + Move-codegen
 *  service requirements through to the caller. */
@@ -304,25 +501,71 @@ const layerCodegenOrchestrator = Layer.effect(CodegenOrchestratorService, Effect
 		};
 		yield* Ref.update(contributionsRef, (xs) => [...xs, entry]);
 		yield* Effect.addFinalizer(() => Ref.update(contributionsRef, (xs) => xs.filter((e) => e.seq !== seq)));
-		yield* Effect.annotateCurrentSpan({
-			"codegen.contribution.plugin": pluginKey,
-			"codegen.contribution.emitter": decl.emitterName,
-			"codegen.contribution.outputPath": decl.outputPath
-		});
-	}).pipe(Effect.withSpan("orchestrator.codegen.registerContribution"));
-	const runCycle = (args) => Effect.gen(function* () {
+	});
+	const assembleIdConfig = (network) => Effect.gen(function* () {
 		const registered = (yield* Ref.get(contributionsRef)).map((e) => e.decl);
+		const bucket = {};
+		const accounts = {};
+		const values = {};
+		for (const decl of registered) {
+			if (decl.aggregate === void 0) continue;
+			if (decl.aggregate.idConfigValues !== void 0) deepMerge(values, decl.aggregate.idConfigValues);
+			if (decl.aggregate.bucket === "config.ts") {
+				const emission = yield* runEmitter(decl);
+				const projected = decl.aggregate.project(emission.exports);
+				if (projected !== null) deepMerge(bucket, projected);
+			} else if (decl.aggregate.bucket === "accounts.ts") {
+				const emission = yield* runEmitter(decl);
+				const projected = decl.aggregate.project(emission.exports);
+				if (projected !== null) deepMerge(accounts, projected);
+			}
+		}
+		bucket["accounts"] = accounts;
+		return idConfigFromBucket(bucket, network, values);
+	});
+	const emitExtras = () => Effect.gen(function* () {
+		const extras = (yield* Ref.get(contributionsRef)).map((e) => e.decl).filter(isExtrasDecl);
+		if (extras.length === 0) return {
+			filesWritten: [],
+			filesUnchanged: [],
+			filesChmod: [],
+			bindings: null
+		};
+		yield* validateUniqueness(extras);
+		yield* validateAggregatePathAvailability(extras);
+		const paths = yield* CodegenPathsService;
+		return yield* Effect.scoped(Effect.gen(function* () {
+			yield* acquireStackLock(paths.codegenLockFile, CODEGEN_CYCLE_LOCK_TIMEOUT_MS).pipe(Effect.mapError((cause) => new CodegenWriteFailed({
+				outputPath: paths.codegenLockFile,
+				stage: "write",
+				cause
+			})));
+			return yield* runEmitCycleInner({
+				contributions: extras,
+				trackTree: false
+			}, paths);
+		}));
+	});
+	const emitBindings = (contributions) => Effect.gen(function* () {
+		if (contributions.length === 0) return {
+			filesWritten: [],
+			filesUnchanged: [],
+			filesChmod: [],
+			bindings: null
+		};
 		return yield* runEmitCycle({
-			contributions: args?.extraContributions ? [...registered, ...args.extraContributions] : registered,
-			bindingsImportExtension: args?.bindingsImportExtension
+			contributions,
+			trackTree: true
 		});
-	}).pipe(Effect.withSpan("orchestrator.codegen.runCycle"));
+	});
 	return CodegenOrchestratorService.of({
 		registerContribution,
-		runCycle
+		assembleIdConfig,
+		emitExtras,
+		emitBindings
 	});
 }));
 //#endregion
-export { CodegenOrchestratorService, layerCodegenOrchestrator };
+export { CodegenOrchestratorService, layerCodegenOrchestrator, runEmitCycle };
 
 //# sourceMappingURL=service.mjs.map