@mysten-incubation/devstack 0.0.0

package/dist/substrate/runtime/observability/pretty-error.mjs

@@ -0,0 +1,119 @@
+import { isTaggedError } from "./cascade-formatter.mjs";
+//#region src/substrate/runtime/observability/pretty-error.ts
+/**
+* Render a Cause as a `StructuredError` suitable for the projection's
+* `errors` field. The `chain` array carries the per-layer summaries
+* (header lines only — the full multi-line render is what `prettyCause`
+* returns).
+*
+* Use the projection-shaped variant when building an `error.reported`
+* event; use `prettyCause` when rendering for human display.
+*/
+const prettyErrorStructured = (cause, options) => {
+	const at = options?.at ?? Date.now();
+	const pluginKey = options?.pluginKey ?? null;
+	const severity = options?.severity ?? "error";
+	const { tag, summary } = extractHeadline(cause);
+	return {
+		at,
+		pluginKey,
+		tag,
+		summary,
+		chain: extractChain(cause),
+		severity
+	};
+};
+/** Walk the cause's first `Fail` reason and pull out the outermost
+*  tag + message for projection.summary. */
+const extractHeadline = (cause) => {
+	const reasons = cause.reasons;
+	for (const reason of reasons) {
+		if (reason._tag === "Fail") {
+			const error = reason.error;
+			if (isTaggedError(error)) return {
+				tag: error._tag,
+				summary: headlineText(error) ?? error._tag
+			};
+			if (error instanceof Error) return {
+				tag: error.name,
+				summary: error.message
+			};
+			return {
+				tag: "UnknownFailure",
+				summary: String(error)
+			};
+		}
+		if (reason._tag === "Die") {
+			const defect = reason.defect;
+			if (isTaggedError(defect)) return {
+				tag: `Defect[${defect._tag}]`,
+				summary: headlineText(defect) ?? defect._tag
+			};
+			if (defect instanceof Error) return {
+				tag: "Defect",
+				summary: defect.message
+			};
+			return {
+				tag: "Defect",
+				summary: String(defect)
+			};
+		}
+		if (reason._tag === "Interrupt") return {
+			tag: "Interrupt",
+			summary: "fiber interrupted"
+		};
+	}
+	return {
+		tag: "EmptyCause",
+		summary: "(empty cause)"
+	};
+};
+const headlineText = (value) => {
+	for (const key of [
+		"message",
+		"detail",
+		"stderr"
+	]) {
+		const field = value[key];
+		if (typeof field === "string" && field.trim().length > 0) return field.trim();
+	}
+	return null;
+};
+/** Walk every layer of the cause's outermost `Fail` chain and build a
+*  list of `<tag>: <message>` strings — one per nested layer. */
+const extractChain = (cause) => {
+	const reasons = cause.reasons;
+	const out = [];
+	for (const reason of reasons) walkChainFromReason(reason, out, /* @__PURE__ */ new WeakSet());
+	return out;
+};
+const walkChainFromReason = (reason, out, visited) => {
+	if (typeof reason !== "object" || reason === null) return;
+	const r = reason;
+	if (r._tag === "Fail") walkChainFromValue(r.error, out, visited);
+	else if (r._tag === "Die") walkChainFromValue(r.defect, out, visited);
+	else if (r._tag === "Interrupt") out.push("Interrupt");
+};
+const walkChainFromValue = (value, out, visited) => {
+	if (value === void 0 || value === null) return;
+	if (typeof value === "object") {
+		if (visited.has(value)) return;
+		visited.add(value);
+	}
+	if (isTaggedError(value)) {
+		const tag = value._tag;
+		const msg = headlineText(value) ?? "";
+		out.push(msg ? `${tag}: ${msg}` : tag);
+		if (value.cause !== void 0 && value.cause !== null) walkChainFromValue(value.cause, out, visited);
+		return;
+	}
+	if (value instanceof Error) {
+		out.push(`${value.name}: ${value.message}`);
+		return;
+	}
+	out.push(String(value));
+};
+//#endregion
+export { prettyErrorStructured };
+
+//# sourceMappingURL=pretty-error.mjs.map

package/dist/substrate/runtime/observability/pretty-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pretty-error.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/pretty-error.ts"],"sourcesContent":["// Pretty-error renderer.\n//\n// Architecture § L0 Observability: one cause walker, shared with\n// renderers. The cascade-formatter is the pure walk; this module is\n// the IO + convenience layer:\n//   - `prettyError(unknown)`  — convenience for \"I have a thrown value\"\n//     and don't want to thread a Cause.\n//   - `prettyCause(cause)`    — the supervisor's path: the engine\n//     catches via `Effect.catchCause` and renders.\n//   - `prettyErrorStructured` — render to a `StructuredError` shape\n//     suitable for the projection's `errors` field.\n//\n// This module is *thin* — all real formatting logic is in\n// `cascade-formatter.ts`. Splitting them keeps the formatter pure\n// + reusable while letting this module evolve IO conventions.\n\nimport type { Cause } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { StructuredError } from '../../projection.ts';\n\nimport {\n\ttype FormatOptions,\n\ttype FormatterRegistry,\n\ttype TaggedErrorLike,\n\tformatCause,\n\tformatValue,\n\tisTaggedError,\n} from './cascade-formatter.ts';\n\nexport type { FormatOptions, FormatterRegistry, TaggedErrorLike };\n\n/** Render any value (Cause, tagged error, plain Error, anything)\n *  using the cascade rules. The pretty-error variant exists so\n *  callers don't have to know whether they have a Cause or an Error. */\nexport const prettyError = (value: unknown, options?: FormatOptions): string =>\n\tformatValue(value, options);\n\n/** Render an Effect `Cause.Cause<E>` directly. The supervisor's preferred\n *  entry point (it has a Cause from `Effect.catchCause`). */\nexport const prettyCause = <E>(cause: Cause.Cause<E>, options?: FormatOptions): string =>\n\tformatCause(cause, options);\n\n// -----------------------------------------------------------------------------\n// Structured projection\n// -----------------------------------------------------------------------------\n\nexport interface StructureOptions extends FormatOptions {\n\treadonly at?: number;\n\treadonly pluginKey?: PluginKey | null;\n\treadonly severity?: StructuredError['severity'];\n}\n\n/**\n * Render a Cause as a `StructuredError` suitable for the projection's\n * `errors` field. The `chain` array carries the per-layer summaries\n * (header lines only — the full multi-line render is what `prettyCause`\n * returns).\n *\n * Use the projection-shaped variant when building an `error.reported`\n * event; use `prettyCause` when rendering for human display.\n */\nexport const prettyErrorStructured = <E>(\n\tcause: Cause.Cause<E>,\n\toptions?: StructureOptions,\n): StructuredError => {\n\tconst at = options?.at ?? Date.now();\n\tconst pluginKey = options?.pluginKey ?? null;\n\tconst severity = options?.severity ?? 'error';\n\n\tconst { tag, summary } = extractHeadline(cause);\n\tconst chain = extractChain(cause);\n\n\treturn { at, pluginKey, tag, summary, chain, severity };\n};\n\n/** Walk the cause's first `Fail` reason and pull out the outermost\n *  tag + message for projection.summary. */\nconst extractHeadline = (cause: Cause.Cause<unknown>): { tag: string; summary: string } => {\n\tconst reasons = (cause as unknown as { reasons: ReadonlyArray<{ _tag: string }> }).reasons;\n\tfor (const reason of reasons) {\n\t\tif (reason._tag === 'Fail') {\n\t\t\tconst error = (reason as unknown as { error: unknown }).error;\n\t\t\tif (isTaggedError(error)) {\n\t\t\t\treturn {\n\t\t\t\t\ttag: error._tag,\n\t\t\t\t\tsummary: headlineText(error) ?? error._tag,\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (error instanceof Error) {\n\t\t\t\treturn { tag: error.name, summary: error.message };\n\t\t\t}\n\t\t\treturn { tag: 'UnknownFailure', summary: String(error) };\n\t\t}\n\t\tif (reason._tag === 'Die') {\n\t\t\tconst defect = (reason as unknown as { defect: unknown }).defect;\n\t\t\tif (isTaggedError(defect)) {\n\t\t\t\treturn {\n\t\t\t\t\ttag: `Defect[${defect._tag}]`,\n\t\t\t\t\tsummary: headlineText(defect) ?? defect._tag,\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (defect instanceof Error) {\n\t\t\t\treturn { tag: 'Defect', summary: defect.message };\n\t\t\t}\n\t\t\treturn { tag: 'Defect', summary: String(defect) };\n\t\t}\n\t\tif (reason._tag === 'Interrupt') {\n\t\t\treturn { tag: 'Interrupt', summary: 'fiber interrupted' };\n\t\t}\n\t}\n\treturn { tag: 'EmptyCause', summary: '(empty cause)' };\n};\n\nconst headlineText = (value: TaggedErrorLike): string | null => {\n\tfor (const key of ['message', 'detail', 'stderr'] as const) {\n\t\tconst field = value[key];\n\t\tif (typeof field === 'string' && field.trim().length > 0) return field.trim();\n\t}\n\treturn null;\n};\n\n/** Walk every layer of the cause's outermost `Fail` chain and build a\n *  list of `<tag>: <message>` strings — one per nested layer. */\nconst extractChain = (cause: Cause.Cause<unknown>): ReadonlyArray<string> => {\n\tconst reasons = (cause as unknown as { reasons: ReadonlyArray<unknown> }).reasons;\n\tconst out: Array<string> = [];\n\tfor (const reason of reasons) {\n\t\twalkChainFromReason(reason, out, new WeakSet());\n\t}\n\treturn out;\n};\n\nconst walkChainFromReason = (\n\treason: unknown,\n\tout: Array<string>,\n\tvisited: WeakSet<object>,\n): void => {\n\tif (typeof reason !== 'object' || reason === null) return;\n\tconst r = reason as { _tag?: unknown; error?: unknown; defect?: unknown; fiberId?: unknown };\n\tif (r._tag === 'Fail') walkChainFromValue(r.error, out, visited);\n\telse if (r._tag === 'Die') walkChainFromValue(r.defect, out, visited);\n\telse if (r._tag === 'Interrupt') out.push('Interrupt');\n};\n\nconst walkChainFromValue = (value: unknown, out: Array<string>, visited: WeakSet<object>): void => {\n\tif (value === undefined || value === null) return;\n\tif (typeof value === 'object') {\n\t\tif (visited.has(value as object)) return;\n\t\tvisited.add(value as object);\n\t}\n\tif (isTaggedError(value)) {\n\t\tconst tag = value._tag;\n\t\tconst msg = headlineText(value) ?? '';\n\t\tout.push(msg ? `${tag}: ${msg}` : tag);\n\t\tif (value.cause !== undefined && value.cause !== null) {\n\t\t\twalkChainFromValue(value.cause, out, visited);\n\t\t}\n\t\treturn;\n\t}\n\tif (value instanceof Error) {\n\t\tout.push(`${value.name}: ${value.message}`);\n\t\treturn;\n\t}\n\tout.push(String(value));\n};\n"],"mappings":";;;;;;;;;;;AA8DA,MAAa,yBACZ,OACA,YACqB;CACrB,MAAM,KAAK,SAAS,MAAM,KAAK,KAAK;CACpC,MAAM,YAAY,SAAS,aAAa;CACxC,MAAM,WAAW,SAAS,YAAY;CAEtC,MAAM,EAAE,KAAK,YAAY,gBAAgB,MAAM;AAG/C,QAAO;EAAE;EAAI;EAAW;EAAK;EAAS,OAFxB,aAAa,MAEgB;EAAE;EAAU;;;;AAKxD,MAAM,mBAAmB,UAAkE;CAC1F,MAAM,UAAW,MAAkE;AACnF,MAAK,MAAM,UAAU,SAAS;AAC7B,MAAI,OAAO,SAAS,QAAQ;GAC3B,MAAM,QAAS,OAAyC;AACxD,OAAI,cAAc,MAAM,CACvB,QAAO;IACN,KAAK,MAAM;IACX,SAAS,aAAa,MAAM,IAAI,MAAM;IACtC;AAEF,OAAI,iBAAiB,MACpB,QAAO;IAAE,KAAK,MAAM;IAAM,SAAS,MAAM;IAAS;AAEnD,UAAO;IAAE,KAAK;IAAkB,SAAS,OAAO,MAAM;IAAE;;AAEzD,MAAI,OAAO,SAAS,OAAO;GAC1B,MAAM,SAAU,OAA0C;AAC1D,OAAI,cAAc,OAAO,CACxB,QAAO;IACN,KAAK,UAAU,OAAO,KAAK;IAC3B,SAAS,aAAa,OAAO,IAAI,OAAO;IACxC;AAEF,OAAI,kBAAkB,MACrB,QAAO;IAAE,KAAK;IAAU,SAAS,OAAO;IAAS;AAElD,UAAO;IAAE,KAAK;IAAU,SAAS,OAAO,OAAO;IAAE;;AAElD,MAAI,OAAO,SAAS,YACnB,QAAO;GAAE,KAAK;GAAa,SAAS;GAAqB;;AAG3D,QAAO;EAAE,KAAK;EAAc,SAAS;EAAiB;;AAGvD,MAAM,gBAAgB,UAA0C;AAC/D,MAAK,MAAM,OAAO;EAAC;EAAW;EAAU;EAAS,EAAW;EAC3D,MAAM,QAAQ,MAAM;AACpB,MAAI,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC,SAAS,EAAG,QAAO,MAAM,MAAM;;AAE9E,QAAO;;;;AAKR,MAAM,gBAAgB,UAAuD;CAC5E,MAAM,UAAW,MAAyD;CAC1E,MAAM,MAAqB,EAAE;AAC7B,MAAK,MAAM,UAAU,QACpB,qBAAoB,QAAQ,qBAAK,IAAI,SAAS,CAAC;AAEhD,QAAO;;AAGR,MAAM,uBACL,QACA,KACA,YACU;AACV,KAAI,OAAO,WAAW,YAAY,WAAW,KAAM;CACnD,MAAM,IAAI;AACV,KAAI,EAAE,SAAS,OAAQ,oBAAmB,EAAE,OAAO,KAAK,QAAQ;UACvD,EAAE,SAAS,MAAO,oBAAmB,EAAE,QAAQ,KAAK,QAAQ;UAC5D,EAAE,SAAS,YAAa,KAAI,KAAK,YAAY;;AAGvD,MAAM,sBAAsB,OAAgB,KAAoB,YAAmC;AAClG,KAAI,UAAU,KAAA,KAAa,UAAU,KAAM;AAC3C,KAAI,OAAO,UAAU,UAAU;AAC9B,MAAI,QAAQ,IAAI,MAAgB,CAAE;AAClC,UAAQ,IAAI,MAAgB;;AAE7B,KAAI,cAAc,MAAM,EAAE;EACzB,MAAM,MAAM,MAAM;EAClB,MAAM,MAAM,aAAa,MAAM,IAAI;AACnC,MAAI,KAAK,MAAM,GAAG,IAAI,IAAI,QAAQ,IAAI;AACtC,MAAI,MAAM,UAAU,KAAA,KAAa,MAAM,UAAU,KAChD,oBAAmB,MAAM,OAAO,KAAK,QAAQ;AAE9C;;AAED,KAAI,iBAAiB,OAAO;AAC3B,MAAI,KAAK,GAAG,MAAM,KAAK,IAAI,MAAM,UAAU;AAC3C;;AAED,KAAI,KAAK,OAAO,MAAM,CAAC"}

package/dist/substrate/runtime/observability/process-lines.d.mts

@@ -0,0 +1,31 @@
+import { PluginKey } from "../../brand.mjs";
+import { LogLevel, LoggerShape } from "./logger.mjs";
+import { Effect, Scope, Stream } from "effect";
+
+//#region src/substrate/runtime/observability/process-lines.d.ts
+declare namespace process_lines_d_exports {
+  export { ObserveProcessLinesOptions, ObservedProcessLine, ProcessByteStream, ProcessOutputStream, observeProcessLines, readableToByteStream, splitUtf8Lines };
+}
+type ProcessOutputStream = 'stdout' | 'stderr';
+interface ObservedProcessLine {
+  readonly stream: ProcessOutputStream;
+  readonly line: string;
+}
+interface ObserveProcessLinesOptions {
+  readonly logger: LoggerShape;
+  readonly tag: string;
+  readonly pluginKey: PluginKey | null;
+  readonly fields?: Readonly<Record<string, unknown>>;
+  readonly onLine?: (line: ObservedProcessLine) => Effect.Effect<void>;
+  readonly levelForStream?: (stream: ProcessOutputStream) => LogLevel;
+}
+type ProcessByteStream<E = unknown, R = never> = Stream.Stream<Uint8Array, E, R>;
+declare const splitUtf8Lines: <E, R>(stream: ProcessByteStream<E, R>) => Stream.Stream<string, E, R>;
+declare const readableToByteStream: (stream: AsyncIterable<Uint8Array> | null | undefined, mapError?: (cause: unknown) => unknown) => ProcessByteStream;
+declare const observeProcessLines: (streams: {
+  readonly stdout?: ProcessByteStream | null;
+  readonly stderr?: ProcessByteStream | null;
+}, options: ObserveProcessLinesOptions) => Effect.Effect<void, never, Scope.Scope>;
+//#endregion
+export { ObserveProcessLinesOptions, ObservedProcessLine, ProcessByteStream, ProcessOutputStream, observeProcessLines, process_lines_d_exports, readableToByteStream, splitUtf8Lines };
+//# sourceMappingURL=process-lines.d.mts.map

package/dist/substrate/runtime/observability/process-lines.mjs

@@ -0,0 +1,40 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.mjs";
+import { Effect, Stream } from "effect";
+//#region src/substrate/runtime/observability/process-lines.ts
+var process_lines_exports = /* @__PURE__ */ __exportAll({
+	observeProcessLines: () => observeProcessLines,
+	readableToByteStream: () => readableToByteStream,
+	splitUtf8Lines: () => splitUtf8Lines
+});
+const splitUtf8Lines = (stream) => stream.pipe(Stream.decodeText(), Stream.splitLines);
+const readableToByteStream = (stream, mapError = (cause) => cause) => {
+	if (stream === null || stream === void 0) return Stream.empty;
+	return Stream.fromAsyncIterable(stream, mapError);
+};
+const defaultLevelForStream = (stream) => stream === "stderr" ? "warn" : "info";
+const drainLineStream = (stream, streamName, options) => {
+	const levelForStream = options.levelForStream ?? defaultLevelForStream;
+	const fields = options.fields ?? {};
+	return splitUtf8Lines(stream).pipe(Stream.tap((line) => Effect.gen(function* () {
+		yield* options.logger.log(options.tag, options.pluginKey, {
+			level: levelForStream(streamName),
+			message: line,
+			fields: {
+				...fields,
+				stream: streamName
+			}
+		}).pipe(Effect.ignore);
+		if (options.onLine !== void 0) yield* options.onLine({
+			stream: streamName,
+			line
+		}).pipe(Effect.ignore);
+	})), Stream.runDrain, Effect.ignore);
+};
+const observeProcessLines = (streams, options) => Effect.gen(function* () {
+	if (streams.stdout !== void 0 && streams.stdout !== null) yield* drainLineStream(streams.stdout, "stdout", options).pipe(Effect.forkScoped);
+	if (streams.stderr !== void 0 && streams.stderr !== null) yield* drainLineStream(streams.stderr, "stderr", options).pipe(Effect.forkScoped);
+});
+//#endregion
+export { observeProcessLines, process_lines_exports, readableToByteStream, splitUtf8Lines };
+
+//# sourceMappingURL=process-lines.mjs.map

package/dist/substrate/runtime/observability/process-lines.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-lines.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/process-lines.ts"],"sourcesContent":["import { Effect, Stream } from 'effect';\nimport type { Scope } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { LoggerShape, LogLevel } from './logger.ts';\n\nexport type ProcessOutputStream = 'stdout' | 'stderr';\n\nexport interface ObservedProcessLine {\n\treadonly stream: ProcessOutputStream;\n\treadonly line: string;\n}\n\nexport interface ObserveProcessLinesOptions {\n\treadonly logger: LoggerShape;\n\treadonly tag: string;\n\treadonly pluginKey: PluginKey | null;\n\treadonly fields?: Readonly<Record<string, unknown>>;\n\treadonly onLine?: (line: ObservedProcessLine) => Effect.Effect<void>;\n\treadonly levelForStream?: (stream: ProcessOutputStream) => LogLevel;\n}\n\nexport type ProcessByteStream<E = unknown, R = never> = Stream.Stream<Uint8Array, E, R>;\n\nexport const splitUtf8Lines = <E, R>(\n\tstream: ProcessByteStream<E, R>,\n): Stream.Stream<string, E, R> => stream.pipe(Stream.decodeText(), Stream.splitLines);\n\nexport const readableToByteStream = (\n\tstream: AsyncIterable<Uint8Array> | null | undefined,\n\tmapError: (cause: unknown) => unknown = (cause) => cause,\n): ProcessByteStream => {\n\tif (stream === null || stream === undefined) return Stream.empty;\n\treturn Stream.fromAsyncIterable(stream, mapError);\n};\n\nconst defaultLevelForStream = (stream: ProcessOutputStream): LogLevel =>\n\tstream === 'stderr' ? 'warn' : 'info';\n\nconst drainLineStream = (\n\tstream: ProcessByteStream,\n\tstreamName: ProcessOutputStream,\n\toptions: ObserveProcessLinesOptions,\n): Effect.Effect<void, never> => {\n\tconst levelForStream = options.levelForStream ?? defaultLevelForStream;\n\tconst fields = options.fields ?? {};\n\tconst drain = splitUtf8Lines(stream).pipe(\n\t\tStream.tap((line) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tyield* options.logger\n\t\t\t\t\t.log(options.tag, options.pluginKey, {\n\t\t\t\t\t\tlevel: levelForStream(streamName),\n\t\t\t\t\t\tmessage: line,\n\t\t\t\t\t\tfields: { ...fields, stream: streamName },\n\t\t\t\t\t})\n\t\t\t\t\t.pipe(Effect.ignore);\n\t\t\t\tif (options.onLine !== undefined) {\n\t\t\t\t\tyield* options.onLine({ stream: streamName, line }).pipe(Effect.ignore);\n\t\t\t\t}\n\t\t\t}),\n\t\t),\n\t\tStream.runDrain,\n\t\tEffect.ignore,\n\t);\n\treturn drain;\n};\n\nexport const observeProcessLines = (\n\tstreams: {\n\t\treadonly stdout?: ProcessByteStream | null;\n\t\treadonly stderr?: ProcessByteStream | null;\n\t},\n\toptions: ObserveProcessLinesOptions,\n): Effect.Effect<void, never, Scope.Scope> =>\n\tEffect.gen(function* () {\n\t\tif (streams.stdout !== undefined && streams.stdout !== null) {\n\t\t\tyield* drainLineStream(streams.stdout, 'stdout', options).pipe(Effect.forkScoped);\n\t\t}\n\t\tif (streams.stderr !== undefined && streams.stderr !== null) {\n\t\t\tyield* drainLineStream(streams.stderr, 'stderr', options).pipe(Effect.forkScoped);\n\t\t}\n\t});\n"],"mappings":";;;;;;;;AAwBA,MAAa,kBACZ,WACiC,OAAO,KAAK,OAAO,YAAY,EAAE,OAAO,WAAW;AAErF,MAAa,wBACZ,QACA,YAAyC,UAAU,UAC5B;AACvB,KAAI,WAAW,QAAQ,WAAW,KAAA,EAAW,QAAO,OAAO;AAC3D,QAAO,OAAO,kBAAkB,QAAQ,SAAS;;AAGlD,MAAM,yBAAyB,WAC9B,WAAW,WAAW,SAAS;AAEhC,MAAM,mBACL,QACA,YACA,YACgC;CAChC,MAAM,iBAAiB,QAAQ,kBAAkB;CACjD,MAAM,SAAS,QAAQ,UAAU,EAAE;AAmBnC,QAlBc,eAAe,OAAO,CAAC,KACpC,OAAO,KAAK,SACX,OAAO,IAAI,aAAa;AACvB,SAAO,QAAQ,OACb,IAAI,QAAQ,KAAK,QAAQ,WAAW;GACpC,OAAO,eAAe,WAAW;GACjC,SAAS;GACT,QAAQ;IAAE,GAAG;IAAQ,QAAQ;IAAY;GACzC,CAAC,CACD,KAAK,OAAO,OAAO;AACrB,MAAI,QAAQ,WAAW,KAAA,EACtB,QAAO,QAAQ,OAAO;GAAE,QAAQ;GAAY;GAAM,CAAC,CAAC,KAAK,OAAO,OAAO;GAEvE,CACF,EACD,OAAO,UACP,OAAO,OAEI;;AAGb,MAAa,uBACZ,SAIA,YAEA,OAAO,IAAI,aAAa;AACvB,KAAI,QAAQ,WAAW,KAAA,KAAa,QAAQ,WAAW,KACtD,QAAO,gBAAgB,QAAQ,QAAQ,UAAU,QAAQ,CAAC,KAAK,OAAO,WAAW;AAElF,KAAI,QAAQ,WAAW,KAAA,KAAa,QAAQ,WAAW,KACtD,QAAO,gBAAgB,QAAQ,QAAQ,UAAU,QAAQ,CAAC,KAAK,OAAO,WAAW;EAEjF"}

package/dist/substrate/runtime/observability/redaction.d.mts

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer } from "effect";
+
+//#region src/substrate/runtime/observability/redaction.d.ts
+declare namespace redaction_d_exports {
+  export { RedactionRule, Redactor, RedactorShape, layerRedactor, redactText, redactValue };
+}
+type RedactionRule = {
+  readonly kind: 'literal';
+  readonly value: string;
+  readonly replacement?: string;
+} | {
+  readonly kind: 'pattern';
+  readonly pattern: RegExp;
+  readonly replacement?: string;
+};
+interface RedactorShape {
+  readonly register: (rule: RedactionRule) => Effect.Effect<void>;
+  readonly redact: (text: string) => Effect.Effect<string>;
+  readonly rules: Effect.Effect<ReadonlyArray<RedactionRule>>;
+}
+declare const Redactor_base: Context.ServiceClass<Redactor, "@devstack-rewrite/substrate/Redactor", RedactorShape>;
+declare class Redactor extends Redactor_base {}
+declare const redactText: (text: string, rules: ReadonlyArray<RedactionRule>) => string;
+declare const redactValue: (value: unknown, rules: ReadonlyArray<RedactionRule>, visited?: WeakSet<object>) => unknown;
+declare const layerRedactor: Layer.Layer<Redactor>;
+//#endregion
+export { RedactionRule, Redactor, RedactorShape, layerRedactor, redactText, redactValue, redaction_d_exports };
+//# sourceMappingURL=redaction.d.mts.map

package/dist/substrate/runtime/observability/redaction.mjs

@@ -0,0 +1,45 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.mjs";
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/substrate/runtime/observability/redaction.ts
+var redaction_exports = /* @__PURE__ */ __exportAll({
+	Redactor: () => Redactor,
+	layerRedactor: () => layerRedactor,
+	redactText: () => redactText,
+	redactValue: () => redactValue
+});
+var Redactor = class extends Context.Service()("@devstack-rewrite/substrate/Redactor") {};
+const DEFAULT_REPLACEMENT = "<redacted>";
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+const redactText = (text, rules) => {
+	let next = text;
+	for (const rule of rules) {
+		const replacement = rule.replacement ?? DEFAULT_REPLACEMENT;
+		if (rule.kind === "literal") {
+			if (rule.value.length === 0) continue;
+			next = next.replace(new RegExp(escapeRegExp(rule.value), "gu"), replacement);
+		} else next = next.replace(rule.pattern, replacement);
+	}
+	return next;
+};
+const redactValue = (value, rules, visited = /* @__PURE__ */ new WeakSet()) => {
+	if (typeof value === "string") return redactText(value, rules);
+	if (typeof value !== "object" || value === null) return value;
+	if (visited.has(value)) return value;
+	visited.add(value);
+	if (Array.isArray(value)) return value.map((entry) => redactValue(entry, rules, visited));
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) out[key] = redactValue(entry, rules, visited);
+	return out;
+};
+const layerRedactor = Layer.effect(Redactor, Effect.gen(function* () {
+	const ref = yield* Ref.make([]);
+	return Redactor.of({
+		register: (rule) => Ref.update(ref, (rules) => [...rules, rule]),
+		redact: (text) => Ref.get(ref).pipe(Effect.map((rules) => redactText(text, rules))),
+		rules: Ref.get(ref)
+	});
+}));
+//#endregion
+export { Redactor, layerRedactor, redactText, redactValue, redaction_exports };
+
+//# sourceMappingURL=redaction.mjs.map

package/dist/substrate/runtime/observability/redaction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/redaction.ts"],"sourcesContent":["import { Context, Effect, Layer, Ref } from 'effect';\n\nexport type RedactionRule =\n\t| {\n\t\t\treadonly kind: 'literal';\n\t\t\treadonly value: string;\n\t\t\treadonly replacement?: string;\n\t  }\n\t| {\n\t\t\treadonly kind: 'pattern';\n\t\t\treadonly pattern: RegExp;\n\t\t\treadonly replacement?: string;\n\t  };\n\nexport interface RedactorShape {\n\treadonly register: (rule: RedactionRule) => Effect.Effect<void>;\n\treadonly redact: (text: string) => Effect.Effect<string>;\n\treadonly rules: Effect.Effect<ReadonlyArray<RedactionRule>>;\n}\n\nexport class Redactor extends Context.Service<Redactor, RedactorShape>()(\n\t'@devstack-rewrite/substrate/Redactor',\n) {}\n\nconst DEFAULT_REPLACEMENT = '<redacted>';\n\nconst escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\\]\\\\]/gu, '\\\\$&');\n\nexport const redactText = (text: string, rules: ReadonlyArray<RedactionRule>): string => {\n\tlet next = text;\n\tfor (const rule of rules) {\n\t\tconst replacement = rule.replacement ?? DEFAULT_REPLACEMENT;\n\t\tif (rule.kind === 'literal') {\n\t\t\tif (rule.value.length === 0) continue;\n\t\t\tnext = next.replace(new RegExp(escapeRegExp(rule.value), 'gu'), replacement);\n\t\t} else {\n\t\t\tnext = next.replace(rule.pattern, replacement);\n\t\t}\n\t}\n\treturn next;\n};\n\nexport const redactValue = (\n\tvalue: unknown,\n\trules: ReadonlyArray<RedactionRule>,\n\tvisited: WeakSet<object> = new WeakSet(),\n): unknown => {\n\tif (typeof value === 'string') return redactText(value, rules);\n\tif (typeof value !== 'object' || value === null) return value;\n\tif (visited.has(value)) return value;\n\tvisited.add(value);\n\tif (Array.isArray(value)) return value.map((entry) => redactValue(entry, rules, visited));\n\tconst out: Record<string, unknown> = {};\n\tfor (const [key, entry] of Object.entries(value)) {\n\t\tout[key] = redactValue(entry, rules, visited);\n\t}\n\treturn out;\n};\n\nexport const layerRedactor: Layer.Layer<Redactor> = Layer.effect(\n\tRedactor,\n\tEffect.gen(function* () {\n\t\tconst ref = yield* Ref.make<ReadonlyArray<RedactionRule>>([]);\n\t\treturn Redactor.of({\n\t\t\tregister: (rule) => Ref.update(ref, (rules) => [...rules, rule]),\n\t\t\tredact: (text) => Ref.get(ref).pipe(Effect.map((rules) => redactText(text, rules))),\n\t\t\trules: Ref.get(ref),\n\t\t});\n\t}),\n);\n"],"mappings":";;;;;;;;;AAoBA,IAAa,WAAb,cAA8B,QAAQ,SAAkC,CACvE,uCACA,CAAC;AAEF,MAAM,sBAAsB;AAE5B,MAAM,gBAAgB,UAA0B,MAAM,QAAQ,wBAAwB,OAAO;AAE7F,MAAa,cAAc,MAAc,UAAgD;CACxF,IAAI,OAAO;AACX,MAAK,MAAM,QAAQ,OAAO;EACzB,MAAM,cAAc,KAAK,eAAe;AACxC,MAAI,KAAK,SAAS,WAAW;AAC5B,OAAI,KAAK,MAAM,WAAW,EAAG;AAC7B,UAAO,KAAK,QAAQ,IAAI,OAAO,aAAa,KAAK,MAAM,EAAE,KAAK,EAAE,YAAY;QAE5E,QAAO,KAAK,QAAQ,KAAK,SAAS,YAAY;;AAGhD,QAAO;;AAGR,MAAa,eACZ,OACA,OACA,0BAA2B,IAAI,SAAS,KAC3B;AACb,KAAI,OAAO,UAAU,SAAU,QAAO,WAAW,OAAO,MAAM;AAC9D,KAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,KAAI,QAAQ,IAAI,MAAM,CAAE,QAAO;AAC/B,SAAQ,IAAI,MAAM;AAClB,KAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,MAAM,KAAK,UAAU,YAAY,OAAO,OAAO,QAAQ,CAAC;CACzF,MAAM,MAA+B,EAAE;AACvC,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC/C,KAAI,OAAO,YAAY,OAAO,OAAO,QAAQ;AAE9C,QAAO;;AAGR,MAAa,gBAAuC,MAAM,OACzD,UACA,OAAO,IAAI,aAAa;CACvB,MAAM,MAAM,OAAO,IAAI,KAAmC,EAAE,CAAC;AAC7D,QAAO,SAAS,GAAG;EAClB,WAAW,SAAS,IAAI,OAAO,MAAM,UAAU,CAAC,GAAG,OAAO,KAAK,CAAC;EAChE,SAAS,SAAS,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,UAAU,WAAW,MAAM,MAAM,CAAC,CAAC;EACnF,OAAO,IAAI,IAAI,IAAI;EACnB,CAAC;EACD,CACF"}

package/dist/substrate/runtime/observability/spans.d.mts

@@ -0,0 +1 @@
+import { Effect } from "effect";

package/dist/substrate/runtime/observability/spans.mjs

@@ -0,0 +1,87 @@
+import { Effect } from "effect";
+//#region src/substrate/runtime/observability/spans.ts
+/** Canonical span-attribute keys. Single source of truth for the
+*  observability vocabulary. */
+const SpanAttr = {
+	accountFundingFrom: "account.funding.from",
+	accountFundingTo: "account.funding.to",
+	accountName: "account.name",
+	app: "devstack.app",
+	stack: "devstack.stack",
+	network: "devstack.network",
+	coinType: "coin.type",
+	plugin: "devstack.plugin",
+	role: "devstack.role",
+	phase: "devstack.phase",
+	containerName: "container.name",
+	containerRole: "container.role",
+	event: "event.name",
+	errorCode: "error.code",
+	errorCause: "error.cause",
+	errorMessage: "error.message",
+	exitCode: "process.exit.code",
+	exitSignal: "process.exit.signal",
+	exitStatus: "process.exit.status",
+	endpointKey: "devstack.endpoint.key",
+	httpMethod: "http.method",
+	httpPath: "http.path",
+	httpUrl: "http.url",
+	host: "server.address",
+	logTag: "log.tag",
+	port: "server.port",
+	cycleId: "devstack.cycle.id",
+	op: "devstack.op",
+	requestId: "devstack.request.id",
+	rosterHeartbeatIntervalMs: "roster.heartbeat.intervalMs",
+	serviceName: "devstack.service.name",
+	stageAndSwapStagingPath: "stageAndSwap.stagingPath",
+	stageAndSwapTargetPath: "stageAndSwap.targetPath",
+	suiAutoTickIntervalMs: "sui.autoTick.intervalMs",
+	suiMode: "sui.mode",
+	walletToken: "wallet.token",
+	walletBearerValid: "wallet.auth.bearerValid",
+	walletLocalhostViteEnabled: "wallet.localhostViteEnabled",
+	walletOrigin: "wallet.origin",
+	walletTokenFile: "wallet.tokenFile",
+	walletUrl: "wallet.url"
+};
+/**
+* Wrap an Effect in a stack-scoped span. Sets `devstack.app`,
+* `devstack.stack`, `devstack.network` attributes. Use at the
+* top-level engine entry points (boot, cycle start, supervisor
+* loop) — not inside per-plugin code (use `withPluginSpan` for that).
+*/
+const withStackSpan = (name, ctx) => (effect) => effect.pipe(Effect.withSpan(name, { attributes: {
+	[SpanAttr.app]: ctx.app,
+	[SpanAttr.stack]: ctx.stack,
+	[SpanAttr.network]: ctx.network
+} }));
+/**
+* Wrap an Effect in a plugin-scoped span. Inherits stack identity from
+* the surrounding Context (callers should compose with
+* `withStackSpan` at the top so the stack identity propagates).
+*/
+const withPluginSpan = (name, ctx) => (effect) => effect.pipe(Effect.withSpan(name, { attributes: {
+	[SpanAttr.app]: ctx.app,
+	[SpanAttr.stack]: ctx.stack,
+	[SpanAttr.network]: ctx.network,
+	[SpanAttr.plugin]: ctx.pluginKey,
+	[SpanAttr.role]: ctx.role
+} }));
+/**
+* Annotate the current span with a phase marker. Cheap; safe to call
+* from anywhere. Used by the supervisor when transitioning a plugin
+* through acquire phases so the OTEL trace correlates with the
+* lifecycle stream.
+*/
+const annotatePhase = (phase) => Effect.annotateCurrentSpan({ [SpanAttr.phase]: phase });
+/**
+* Annotate the current span with a subprocess `op` tag. Mirrors the
+* `CaptureError.op` field so a failure that originates in a captured
+* subprocess can be traced back to its span by `devstack.op`.
+*/
+const annotateOp = (op) => Effect.annotateCurrentSpan({ [SpanAttr.op]: op });
+//#endregion
+export { SpanAttr, annotateOp, annotatePhase, withPluginSpan, withStackSpan };
+
+//# sourceMappingURL=spans.mjs.map

package/dist/substrate/runtime/observability/spans.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spans.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/spans.ts"],"sourcesContent":["// Span propagation wrappers.\n//\n// Architecture § L0 Observability: \"span/annotation conventions\".\n// Centralises the attribute keys so every wrapped span uses the same\n// vocabulary — OTEL consumers can filter by `devstack.app`,\n// `devstack.stack`, `devstack.plugin`, `devstack.role` reliably.\n//\n// Discipline: no service names appear anywhere; only the four\n// engine-level dimensions. Plugins call `withPluginSpan` and pass\n// their `pluginKey` + `role`.\n\nimport { Effect } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { PluginRole } from '../../lifecycle.ts';\n\n/** Canonical span-attribute keys. Single source of truth for the\n *  observability vocabulary. */\nexport const SpanAttr = {\n\taccountFundingFrom: 'account.funding.from',\n\taccountFundingTo: 'account.funding.to',\n\taccountName: 'account.name',\n\tapp: 'devstack.app',\n\tstack: 'devstack.stack',\n\tnetwork: 'devstack.network',\n\tcoinType: 'coin.type',\n\tplugin: 'devstack.plugin',\n\trole: 'devstack.role',\n\tphase: 'devstack.phase',\n\tcontainerName: 'container.name',\n\tcontainerRole: 'container.role',\n\tevent: 'event.name',\n\terrorCode: 'error.code',\n\terrorCause: 'error.cause',\n\terrorMessage: 'error.message',\n\texitCode: 'process.exit.code',\n\texitSignal: 'process.exit.signal',\n\texitStatus: 'process.exit.status',\n\tendpointKey: 'devstack.endpoint.key',\n\thttpMethod: 'http.method',\n\thttpPath: 'http.path',\n\thttpUrl: 'http.url',\n\thost: 'server.address',\n\tlogTag: 'log.tag',\n\tport: 'server.port',\n\tcycleId: 'devstack.cycle.id',\n\top: 'devstack.op',\n\trequestId: 'devstack.request.id',\n\trosterHeartbeatIntervalMs: 'roster.heartbeat.intervalMs',\n\tserviceName: 'devstack.service.name',\n\tstageAndSwapStagingPath: 'stageAndSwap.stagingPath',\n\tstageAndSwapTargetPath: 'stageAndSwap.targetPath',\n\tsuiAutoTickIntervalMs: 'sui.autoTick.intervalMs',\n\tsuiMode: 'sui.mode',\n\twalletToken: 'wallet.token',\n\twalletBearerValid: 'wallet.auth.bearerValid',\n\twalletLocalhostViteEnabled: 'wallet.localhostViteEnabled',\n\twalletOrigin: 'wallet.origin',\n\twalletTokenFile: 'wallet.tokenFile',\n\twalletUrl: 'wallet.url',\n} as const;\n\nexport interface StackSpanContext {\n\treadonly app: string;\n\treadonly stack: string;\n\treadonly network: string;\n}\n\nexport interface PluginSpanContext extends StackSpanContext {\n\treadonly pluginKey: PluginKey;\n\treadonly role: PluginRole;\n}\n\n/**\n * Wrap an Effect in a stack-scoped span. Sets `devstack.app`,\n * `devstack.stack`, `devstack.network` attributes. Use at the\n * top-level engine entry points (boot, cycle start, supervisor\n * loop) — not inside per-plugin code (use `withPluginSpan` for that).\n */\nexport const withStackSpan =\n\t(name: string, ctx: StackSpanContext) =>\n\t<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n\t\teffect.pipe(\n\t\t\tEffect.withSpan(name, {\n\t\t\t\tattributes: {\n\t\t\t\t\t[SpanAttr.app]: ctx.app,\n\t\t\t\t\t[SpanAttr.stack]: ctx.stack,\n\t\t\t\t\t[SpanAttr.network]: ctx.network,\n\t\t\t\t},\n\t\t\t}),\n\t\t);\n\n/**\n * Wrap an Effect in a plugin-scoped span. Inherits stack identity from\n * the surrounding Context (callers should compose with\n * `withStackSpan` at the top so the stack identity propagates).\n */\nexport const withPluginSpan =\n\t(name: string, ctx: PluginSpanContext) =>\n\t<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n\t\teffect.pipe(\n\t\t\tEffect.withSpan(name, {\n\t\t\t\tattributes: {\n\t\t\t\t\t[SpanAttr.app]: ctx.app,\n\t\t\t\t\t[SpanAttr.stack]: ctx.stack,\n\t\t\t\t\t[SpanAttr.network]: ctx.network,\n\t\t\t\t\t[SpanAttr.plugin]: ctx.pluginKey,\n\t\t\t\t\t[SpanAttr.role]: ctx.role,\n\t\t\t\t},\n\t\t\t}),\n\t\t);\n\n/**\n * Annotate the current span with a phase marker. Cheap; safe to call\n * from anywhere. Used by the supervisor when transitioning a plugin\n * through acquire phases so the OTEL trace correlates with the\n * lifecycle stream.\n */\nexport const annotatePhase = (phase: string): Effect.Effect<void> =>\n\tEffect.annotateCurrentSpan({ [SpanAttr.phase]: phase });\n\n/**\n * Annotate the current span with the engine cycle id. Called once per\n * cycle at supervisor entry.\n */\nexport const annotateCycle = (cycleId: number): Effect.Effect<void> =>\n\tEffect.annotateCurrentSpan({ [SpanAttr.cycleId]: cycleId });\n\n/**\n * Annotate the current span with a subprocess `op` tag. Mirrors the\n * `CaptureError.op` field so a failure that originates in a captured\n * subprocess can be traced back to its span by `devstack.op`.\n */\nexport const annotateOp = (op: string): Effect.Effect<void> =>\n\tEffect.annotateCurrentSpan({ [SpanAttr.op]: op });\n"],"mappings":";;;;AAkBA,MAAa,WAAW;CACvB,oBAAoB;CACpB,kBAAkB;CAClB,aAAa;CACb,KAAK;CACL,OAAO;CACP,SAAS;CACT,UAAU;CACV,QAAQ;CACR,MAAM;CACN,OAAO;CACP,eAAe;CACf,eAAe;CACf,OAAO;CACP,WAAW;CACX,YAAY;CACZ,cAAc;CACd,UAAU;CACV,YAAY;CACZ,YAAY;CACZ,aAAa;CACb,YAAY;CACZ,UAAU;CACV,SAAS;CACT,MAAM;CACN,QAAQ;CACR,MAAM;CACN,SAAS;CACT,IAAI;CACJ,WAAW;CACX,2BAA2B;CAC3B,aAAa;CACb,yBAAyB;CACzB,wBAAwB;CACxB,uBAAuB;CACvB,SAAS;CACT,aAAa;CACb,mBAAmB;CACnB,4BAA4B;CAC5B,cAAc;CACd,iBAAiB;CACjB,WAAW;CACX;;;;;;;AAmBD,MAAa,iBACX,MAAc,SACL,WACT,OAAO,KACN,OAAO,SAAS,MAAM,EACrB,YAAY;EACV,SAAS,MAAM,IAAI;EACnB,SAAS,QAAQ,IAAI;EACrB,SAAS,UAAU,IAAI;CACxB,EACD,CAAC,CACF;;;;;;AAOH,MAAa,kBACX,MAAc,SACL,WACT,OAAO,KACN,OAAO,SAAS,MAAM,EACrB,YAAY;EACV,SAAS,MAAM,IAAI;EACnB,SAAS,QAAQ,IAAI;EACrB,SAAS,UAAU,IAAI;EACvB,SAAS,SAAS,IAAI;EACtB,SAAS,OAAO,IAAI;CACrB,EACD,CAAC,CACF;;;;;;;AAQH,MAAa,iBAAiB,UAC7B,OAAO,oBAAoB,GAAG,SAAS,QAAQ,OAAO,CAAC;;;;;;AAcxD,MAAa,cAAc,OAC1B,OAAO,oBAAoB,GAAG,SAAS,KAAK,IAAI,CAAC"}

package/dist/substrate/runtime/observability/subprocess-capture.d.mts

@@ -0,0 +1,2 @@
+import { Effect } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";

package/dist/substrate/runtime/observability/subprocess-capture.mjs

@@ -0,0 +1,82 @@
+import { splitUtf8Lines } from "./process-lines.mjs";
+import { Data, Effect, Stream } from "effect";
+import "effect/unstable/process";
+//#region src/substrate/runtime/observability/subprocess-capture.ts
+/**
+* The one subprocess-capture error class. Two failure modes:
+*
+*   (a) Spawner failure (binary missing, fork limit, pipe setup). The
+*       `cause` field carries the spawner's raw failure; `exitCode` is
+*       undefined.
+*   (b) Non-zero exit when `opts.nonZeroIsFailure` was true. The
+*       `exitCode`, `stdout`, `stderr` fields are populated;
+*       `cause` is undefined.
+*
+* Downstream wrappers (plugins) wrap this with their own envelopes via
+* `Effect.mapError`. The `op` field carries through so the failure
+* attribution survives.
+*/
+var CaptureError = class extends Data.TaggedError("CaptureError") {};
+const DEFAULT_STDERR_TRUNC = 500;
+const truncateTo = (text, limit) => {
+	if (!Number.isFinite(limit) || text.length <= limit) return text;
+	return `${text.slice(0, limit)}…[truncated]`;
+};
+const opOf = (cmd, override) => {
+	if (override !== void 0) return override;
+	if (cmd._tag === "StandardCommand") return cmd.command;
+	return "piped-command";
+};
+const drainObserved = (stream, observer) => {
+	if (!observer) return Stream.mkString(Stream.decodeText(stream));
+	const lines = splitUtf8Lines(stream).pipe(Stream.tap((line) => observer(line).pipe(Effect.ignore)));
+	return Stream.runFold(lines, () => "", (acc, line) => acc.length === 0 ? line : `${acc}\n${line}`);
+};
+/**
+* Spawn `cmd`, drain stdout + stderr + exit code concurrently. Returns
+* the captured result, or fails with `CaptureError` if the spawner
+* itself failed (or if `nonZeroIsFailure` was set and the child exited
+* non-zero).
+*
+* One function. One error class. Stream observers are opt-in via
+* `opts.onStdoutLine` / `opts.onStderrLine` — the streaming and
+* non-streaming variants are no longer separate functions.
+*/
+const capture = (spawner, cmd, opts) => {
+	const op = opOf(cmd, opts?.op);
+	const stderrLimit = opts?.stderrTruncate ?? DEFAULT_STDERR_TRUNC;
+	const stdoutLimit = opts?.stdoutTruncate ?? Infinity;
+	const nonZeroIsFailure = opts?.nonZeroIsFailure ?? false;
+	const onStdoutLine = opts?.onStdoutLine;
+	const onStderrLine = opts?.onStderrLine;
+	const mapSpawn = (cause) => new CaptureError({
+		op,
+		stdout: "",
+		stderr: "",
+		cause
+	});
+	return Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(cmd).pipe(Effect.mapError(mapSpawn));
+		const [stdoutText, stderrText, code] = yield* Effect.all([
+			drainObserved(handle.stdout, onStdoutLine).pipe(Effect.mapError(mapSpawn)),
+			drainObserved(handle.stderr, onStderrLine).pipe(Effect.mapError(mapSpawn)),
+			handle.exitCode.pipe(Effect.mapError(mapSpawn))
+		], { concurrency: "unbounded" });
+		const result = {
+			exitCode: code,
+			stdout: truncateTo(stdoutText, stdoutLimit),
+			stderr: truncateTo(stderrText, stderrLimit)
+		};
+		if (nonZeroIsFailure && result.exitCode !== 0) return yield* Effect.fail(new CaptureError({
+			op,
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr
+		}));
+		return result;
+	}));
+};
+//#endregion
+export { capture };
+
+//# sourceMappingURL=subprocess-capture.mjs.map

package/dist/substrate/runtime/observability/subprocess-capture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess-capture.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/subprocess-capture.ts"],"sourcesContent":["// Subprocess output capture — one variant, one error.\n//\n// Architecture § Collapsed: the legacy package shipped per-service\n// per-line docker log sinks and four spawn-and-capture helpers\n// (`captureCommand`, `captureCommandOrFail`, `captureCommandStreaming`,\n// `captureCommandStreamingOrFail`); this module collapses them to one\n// shape parameterised by options.\n//\n// Surface:\n//\n//   capture(spawner, cmd, opts) -> Effect<CaptureResult, CaptureError>\n//\n//   - Always returns `CaptureResult` for zero AND non-zero exits when\n//     `opts.nonZeroIsFailure` is unset (or `false`). The caller decides.\n//   - With `opts.nonZeroIsFailure: true` the Effect fails with\n//     `CaptureError` carrying `exitCode` on non-zero exit.\n//   - With `opts.onStdoutLine` set, each stdout line is emitted to the\n//     callback as it arrives (line-buffered across chunk boundaries).\n//     The full stdout is still returned in `CaptureResult.stdout` so\n//     the error envelope downstream stays uniform.\n//   - With `opts.onStderrLine` set, same shape for stderr (motivated\n//     by the L1 per-line sink that promotes WARN/ERROR markers — see\n//     architecture L1 § \"Shared per-line streaming sink\").\n//\n// One error class for every failure mode (spawner failure, non-zero\n// exit when promoted). The `op` tag attributes the failure to a\n// specific subprocess invocation; downstream wrappers route this into\n// their own envelopes via `Effect.mapError`.\n\nimport { Effect, Stream } from 'effect';\nimport { Data } from 'effect';\nimport type { ChildProcess } from 'effect/unstable/process';\nimport { ChildProcessSpawner } from 'effect/unstable/process';\n\nimport { splitUtf8Lines } from './process-lines.ts';\n\n// -----------------------------------------------------------------------------\n// Single error class\n// -----------------------------------------------------------------------------\n\n/**\n * The one subprocess-capture error class. Two failure modes:\n *\n *   (a) Spawner failure (binary missing, fork limit, pipe setup). The\n *       `cause` field carries the spawner's raw failure; `exitCode` is\n *       undefined.\n *   (b) Non-zero exit when `opts.nonZeroIsFailure` was true. The\n *       `exitCode`, `stdout`, `stderr` fields are populated;\n *       `cause` is undefined.\n *\n * Downstream wrappers (plugins) wrap this with their own envelopes via\n * `Effect.mapError`. The `op` field carries through so the failure\n * attribution survives.\n */\nexport class CaptureError extends Data.TaggedError('CaptureError')<{\n\treadonly op: string;\n\treadonly exitCode?: number;\n\treadonly stdout: string;\n\treadonly stderr: string;\n\treadonly cause?: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Public types\n// -----------------------------------------------------------------------------\n\nexport interface CaptureResult {\n\treadonly exitCode: number;\n\treadonly stdout: string;\n\treadonly stderr: string;\n}\n\nexport interface CaptureOptions {\n\t/**\n\t * Caller-supplied tag identifying the subprocess invocation. Embedded\n\t * in any `CaptureError` so downstream envelopes have stable\n\t * attribution. Defaults to the command's `command` field when absent.\n\t */\n\treadonly op?: string;\n\t/**\n\t * Maximum stderr bytes preserved on a captured-error path. Past the\n\t * limit, the surplus is dropped and `…[truncated]` is appended.\n\t * Default 500 (tightest of the historical policies; common case is\n\t * a TUI row that must fit one line).\n\t */\n\treadonly stderrTruncate?: number;\n\t/**\n\t * Maximum stdout bytes preserved on a captured-error path. Default\n\t * `Infinity` — most callers want full stdout for parsing.\n\t */\n\treadonly stdoutTruncate?: number;\n\t/**\n\t * Promote a non-zero exit code into a `CaptureError`. The error\n\t * carries the captured stdout/stderr verbatim. Default `false` (the\n\t * caller decides).\n\t */\n\treadonly nonZeroIsFailure?: boolean;\n\t/**\n\t * Per-line stdout observer. Lines are buffered across chunk boundaries\n\t * via `Stream.splitLines`. Callback errors are ignored (the capture\n\t * must never abort because narration failed).\n\t */\n\treadonly onStdoutLine?: (line: string) => Effect.Effect<void>;\n\t/**\n\t * Per-line stderr observer. Same semantics as `onStdoutLine`. The L1\n\t * shared per-line sink (level promotion: stderr lines containing\n\t * `WARN`/`ERROR` markers) routes through here.\n\t */\n\treadonly onStderrLine?: (line: string) => Effect.Effect<void>;\n}\n\n// -----------------------------------------------------------------------------\n// Constants\n// -----------------------------------------------------------------------------\n\nconst DEFAULT_STDERR_TRUNC = 500;\n\n// -----------------------------------------------------------------------------\n// Helpers\n// -----------------------------------------------------------------------------\n\nconst truncateTo = (text: string, limit: number): string => {\n\tif (!Number.isFinite(limit) || text.length <= limit) return text;\n\treturn `${text.slice(0, limit)}…[truncated]`;\n};\n\nconst opOf = (cmd: ChildProcess.Command, override: string | undefined): string => {\n\tif (override !== undefined) return override;\n\tif (cmd._tag === 'StandardCommand') return cmd.command;\n\treturn 'piped-command';\n};\n\ntype SpawnerService = ReturnType<typeof ChildProcessSpawner.make>;\n\nconst drainObserved = <E>(\n\tstream: Stream.Stream<Uint8Array, E>,\n\tobserver: ((line: string) => Effect.Effect<void>) | undefined,\n): Effect.Effect<string, E> => {\n\tif (!observer) {\n\t\treturn Stream.mkString(Stream.decodeText(stream));\n\t}\n\tconst lines = splitUtf8Lines(stream).pipe(\n\t\tStream.tap((line) => observer(line).pipe(Effect.ignore)),\n\t);\n\t// Re-fold lines into the full stdout/stderr string. We don't append\n\t// a trailing newline — mirrors the non-observed path so the captured\n\t// error shape is uniform regardless of whether an observer was set.\n\treturn Stream.runFold(\n\t\tlines,\n\t\t() => '',\n\t\t(acc, line) => (acc.length === 0 ? line : `${acc}\\n${line}`),\n\t);\n};\n\n// -----------------------------------------------------------------------------\n// The one capture function\n// -----------------------------------------------------------------------------\n\n/**\n * Spawn `cmd`, drain stdout + stderr + exit code concurrently. Returns\n * the captured result, or fails with `CaptureError` if the spawner\n * itself failed (or if `nonZeroIsFailure` was set and the child exited\n * non-zero).\n *\n * One function. One error class. Stream observers are opt-in via\n * `opts.onStdoutLine` / `opts.onStderrLine` — the streaming and\n * non-streaming variants are no longer separate functions.\n */\nexport const capture = (\n\tspawner: SpawnerService,\n\tcmd: ChildProcess.Command,\n\topts?: CaptureOptions,\n): Effect.Effect<CaptureResult, CaptureError> => {\n\tconst op = opOf(cmd, opts?.op);\n\tconst stderrLimit = opts?.stderrTruncate ?? DEFAULT_STDERR_TRUNC;\n\tconst stdoutLimit = opts?.stdoutTruncate ?? Infinity;\n\tconst nonZeroIsFailure = opts?.nonZeroIsFailure ?? false;\n\tconst onStdoutLine = opts?.onStdoutLine;\n\tconst onStderrLine = opts?.onStderrLine;\n\tconst mapSpawn = (cause: unknown): CaptureError =>\n\t\tnew CaptureError({ op, stdout: '', stderr: '', cause });\n\n\treturn Effect.scoped(\n\t\tEffect.gen(function* () {\n\t\t\tconst handle = yield* spawner.spawn(cmd).pipe(Effect.mapError(mapSpawn));\n\t\t\tconst [stdoutText, stderrText, code] = yield* Effect.all(\n\t\t\t\t[\n\t\t\t\t\tdrainObserved(handle.stdout, onStdoutLine).pipe(Effect.mapError(mapSpawn)),\n\t\t\t\t\tdrainObserved(handle.stderr, onStderrLine).pipe(Effect.mapError(mapSpawn)),\n\t\t\t\t\thandle.exitCode.pipe(Effect.mapError(mapSpawn)),\n\t\t\t\t],\n\t\t\t\t{ concurrency: 'unbounded' },\n\t\t\t);\n\t\t\tconst result: CaptureResult = {\n\t\t\t\texitCode: code as number,\n\t\t\t\tstdout: truncateTo(stdoutText, stdoutLimit),\n\t\t\t\tstderr: truncateTo(stderrText, stderrLimit),\n\t\t\t};\n\t\t\tif (nonZeroIsFailure && result.exitCode !== 0) {\n\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\tnew CaptureError({\n\t\t\t\t\t\top,\n\t\t\t\t\t\texitCode: result.exitCode,\n\t\t\t\t\t\tstdout: result.stdout,\n\t\t\t\t\t\tstderr: result.stderr,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn result;\n\t\t}),\n\t);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsDA,IAAa,eAAb,cAAkC,KAAK,YAAY,eAAe,CAM/D;AAuDH,MAAM,uBAAuB;AAM7B,MAAM,cAAc,MAAc,UAA0B;AAC3D,KAAI,CAAC,OAAO,SAAS,MAAM,IAAI,KAAK,UAAU,MAAO,QAAO;AAC5D,QAAO,GAAG,KAAK,MAAM,GAAG,MAAM,CAAC;;AAGhC,MAAM,QAAQ,KAA2B,aAAyC;AACjF,KAAI,aAAa,KAAA,EAAW,QAAO;AACnC,KAAI,IAAI,SAAS,kBAAmB,QAAO,IAAI;AAC/C,QAAO;;AAKR,MAAM,iBACL,QACA,aAC8B;AAC9B,KAAI,CAAC,SACJ,QAAO,OAAO,SAAS,OAAO,WAAW,OAAO,CAAC;CAElD,MAAM,QAAQ,eAAe,OAAO,CAAC,KACpC,OAAO,KAAK,SAAS,SAAS,KAAK,CAAC,KAAK,OAAO,OAAO,CAAC,CACxD;AAID,QAAO,OAAO,QACb,aACM,KACL,KAAK,SAAU,IAAI,WAAW,IAAI,OAAO,GAAG,IAAI,IAAI,OACrD;;;;;;;;;;;;AAiBF,MAAa,WACZ,SACA,KACA,SACgD;CAChD,MAAM,KAAK,KAAK,KAAK,MAAM,GAAG;CAC9B,MAAM,cAAc,MAAM,kBAAkB;CAC5C,MAAM,cAAc,MAAM,kBAAkB;CAC5C,MAAM,mBAAmB,MAAM,oBAAoB;CACnD,MAAM,eAAe,MAAM;CAC3B,MAAM,eAAe,MAAM;CAC3B,MAAM,YAAY,UACjB,IAAI,aAAa;EAAE;EAAI,QAAQ;EAAI,QAAQ;EAAI;EAAO,CAAC;AAExD,QAAO,OAAO,OACb,OAAO,IAAI,aAAa;EACvB,MAAM,SAAS,OAAO,QAAQ,MAAM,IAAI,CAAC,KAAK,OAAO,SAAS,SAAS,CAAC;EACxE,MAAM,CAAC,YAAY,YAAY,QAAQ,OAAO,OAAO,IACpD;GACC,cAAc,OAAO,QAAQ,aAAa,CAAC,KAAK,OAAO,SAAS,SAAS,CAAC;GAC1E,cAAc,OAAO,QAAQ,aAAa,CAAC,KAAK,OAAO,SAAS,SAAS,CAAC;GAC1E,OAAO,SAAS,KAAK,OAAO,SAAS,SAAS,CAAC;GAC/C,EACD,EAAE,aAAa,aAAa,CAC5B;EACD,MAAM,SAAwB;GAC7B,UAAU;GACV,QAAQ,WAAW,YAAY,YAAY;GAC3C,QAAQ,WAAW,YAAY,YAAY;GAC3C;AACD,MAAI,oBAAoB,OAAO,aAAa,EAC3C,QAAO,OAAO,OAAO,KACpB,IAAI,aAAa;GAChB;GACA,UAAU,OAAO;GACjB,QAAQ,OAAO;GACf,QAAQ,OAAO;GACf,CAAC,CACF;AAEF,SAAO;GACN,CACF"}

package/dist/substrate/runtime/paths.d.mts

@@ -0,0 +1,17 @@
+import { Identity } from "../identity.mjs";
+import { Context, Layer, Path } from "effect";
+
+//#region src/substrate/runtime/paths.d.ts
+declare const IdentityContext_base: Context.ServiceClass<IdentityContext, "@devstack-rewrite/substrate/Identity", Identity>;
+/**
+ * Identity-bound. Same shape as `substrate/identity.ts`'s `Identity`,
+ * but lifted into a Context service so path resolution can yield it
+ * without taking it as a function argument.
+ *
+ * Boot wires this once (Identity is validated up front); the
+ * resolver and every consumer reads from this single source.
+ */
+declare class IdentityContext extends IdentityContext_base {}
+//#endregion
+export { IdentityContext };
+//# sourceMappingURL=paths.d.mts.map

package/dist/substrate/runtime/paths.mjs

@@ -0,0 +1,61 @@
+import { Context, Effect, Layer, Path } from "effect";
+//#region src/substrate/runtime/paths.ts
+var RuntimeRoot = class extends Context.Service()("@devstack-rewrite/substrate/RuntimeRoot") {};
+/** Build a `RuntimeRoot` layer pinned to a literal path. */
+const layerRuntimeRoot = (root) => Layer.succeed(RuntimeRoot)({ root });
+/**
+* Identity-bound. Same shape as `substrate/identity.ts`'s `Identity`,
+* but lifted into a Context service so path resolution can yield it
+* without taking it as a function argument.
+*
+* Boot wires this once (Identity is validated up front); the
+* resolver and every consumer reads from this single source.
+*/
+var IdentityContext = class extends Context.Service()("@devstack-rewrite/substrate/Identity") {};
+const layerIdentity = (identity) => Layer.succeed(IdentityContext)(identity);
+/**
+* The path resolver service. Yields `StackPaths` once per stack —
+* `Effect.cached`-friendly since `Identity` + `RuntimeRoot` are
+* boot-immutable.
+*/
+var StackPathsService = class extends Context.Service()("@devstack-rewrite/substrate/StackPaths") {};
+/**
+* Layer that materializes the resolver from `RuntimeRoot` +
+* `IdentityContext` + the Effect `Path` service. The cache helper
+* uses `Path.join` so OS-correct separators round-trip on Windows
+* (defense-in-depth — devstack is posix-only in practice but the
+* cost of `Path.join` over template strings is zero).
+*/
+const layerStackPaths = Layer.effect(StackPathsService, Effect.gen(function* () {
+	const { root } = yield* RuntimeRoot;
+	const identity = yield* IdentityContext;
+	const path = yield* Path.Path;
+	const stackRoot = path.join(root, "stacks", identity.stack);
+	const cacheDir = path.join(stackRoot, "cache");
+	const cacheNamespaceDir = (namespace) => path.join(cacheDir, namespace);
+	const cacheChainDir = (namespace, chain) => path.join(cacheNamespaceDir(namespace), chain);
+	const cacheEntry = (namespace, chain, contentHash) => {
+		const dir = cacheChainDir(namespace, chain);
+		return {
+			dir,
+			file: path.join(dir, `${contentHash}.json`)
+		};
+	};
+	return StackPathsService.of({
+		stackRoot,
+		stateFile: path.join(stackRoot, "state.json"),
+		stateLockHint: path.join(stackRoot, "state.json.lock"),
+		cacheDir,
+		snapshotDir: path.join(stackRoot, "snapshots"),
+		stackLockFile: path.join(stackRoot, "stack.lock"),
+		rosterFile: path.join(stackRoot, "roster.json"),
+		snapshotReservationFile: path.join(stackRoot, "snapshot.reservation"),
+		cacheEntry,
+		cacheChainDir,
+		cacheNamespaceDir
+	});
+}));
+//#endregion
+export { IdentityContext, RuntimeRoot, StackPathsService, layerIdentity, layerRuntimeRoot, layerStackPaths };
+
+//# sourceMappingURL=paths.mjs.map

package/dist/substrate/runtime/paths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.mjs","names":[],"sources":["../../../src/substrate/runtime/paths.ts"],"sourcesContent":["// Unified path resolver.\n//\n// Architecture § \"What's collapsed\" — three path resolvers\n// (state-store, service-paths, snapshot) consolidate to one. This is\n// the L0 helper every disk-touching subsystem reaches for; nothing\n// else in the runtime package may compose `<root>/stacks/<stack>/...`\n// by hand.\n//\n// The resolver is a typed bundle: given an `Identity` and the\n// `RuntimeRoot`, it returns the closed set of paths the substrate\n// understands. Subsystems that need a sub-path inside one of those\n// (e.g. cache namespace + chain + content-hash) compose ON TOP of the\n// bundle's `cacheDir`, but they NEVER reach for\n// `path.join(root, 'stacks', stack)` themselves.\n\nimport { Context, Effect, Layer, Path } from 'effect';\n\nimport type { Identity } from '../identity.ts';\n\n/**\n * Runtime root — the on-disk base under which every stack's state\n * lives. Defaults to `.devstack`, but is injectable so tests pin to\n * a tempdir and parallel-stack tests pin to per-test prefixes.\n *\n * Held as a tagged service so the rest of the substrate can request\n * it without threading the string through every signature.\n */\nexport interface RuntimeRootShape {\n\treadonly root: string;\n}\n\nexport class RuntimeRoot extends Context.Service<RuntimeRoot, RuntimeRootShape>()(\n\t'@devstack-rewrite/substrate/RuntimeRoot',\n) {}\n\n/** Build a `RuntimeRoot` layer pinned to a literal path. */\nexport const layerRuntimeRoot = (root: string): Layer.Layer<RuntimeRoot> =>\n\tLayer.succeed(RuntimeRoot)({ root });\n\n/**\n * Identity-bound. Same shape as `substrate/identity.ts`'s `Identity`,\n * but lifted into a Context service so path resolution can yield it\n * without taking it as a function argument.\n *\n * Boot wires this once (Identity is validated up front); the\n * resolver and every consumer reads from this single source.\n */\nexport class IdentityContext extends Context.Service<IdentityContext, Identity>()(\n\t'@devstack-rewrite/substrate/Identity',\n) {}\n\nexport const layerIdentity = (identity: Identity): Layer.Layer<IdentityContext> =>\n\tLayer.succeed(IdentityContext)(identity);\n\n/**\n * Closed bundle the resolver returns. Three groups of paths:\n *\n *   - `stackRoot` and the cross-process artifacts (lock, roster,\n *     command channel, snapshot reservation) live directly under the stack\n *     directory. Cross-process safety lives here.\n *   - `stateFile` is the per-stack state-store JSON. ONE file per\n *     stack — schema-validated on read.\n *   - `cacheDir` is the parent directory; the cache subsystem\n *     composes `<cacheDir>/<namespace>/<chainId>/<contentHash>.json`\n *     via a helper on this resolver. Subsystems do NOT reach into\n *     `cacheDir` with their own `path.join` calls.\n */\nexport interface StackPaths {\n\treadonly stackRoot: string;\n\treadonly stateFile: string;\n\treadonly stateLockHint: string;\n\treadonly cacheDir: string;\n\treadonly snapshotDir: string;\n\treadonly stackLockFile: string;\n\treadonly rosterFile: string;\n\treadonly snapshotReservationFile: string;\n\t/**\n\t * Helper that composes the cache entry path from cache-key\n\t * components. The substrate folds the components together here so\n\t * that nothing else in the runtime tree builds cache paths.\n\t */\n\treadonly cacheEntry: (\n\t\tnamespace: string,\n\t\tchain: string,\n\t\tcontentHash: string,\n\t) => { readonly dir: string; readonly file: string };\n\t/** Helper that returns the cache namespace directory for a given\n\t *  namespace + chain — for `readDirectory` enumeration. */\n\treadonly cacheChainDir: (namespace: string, chain: string) => string;\n\t/** Helper that returns the cache namespace directory (across all\n\t *  chains) — for namespace-scoped enumeration. */\n\treadonly cacheNamespaceDir: (namespace: string) => string;\n}\n\n/**\n * The path resolver service. Yields `StackPaths` once per stack —\n * `Effect.cached`-friendly since `Identity` + `RuntimeRoot` are\n * boot-immutable.\n */\nexport class StackPathsService extends Context.Service<StackPathsService, StackPaths>()(\n\t'@devstack-rewrite/substrate/StackPaths',\n) {}\n\n/**\n * Layer that materializes the resolver from `RuntimeRoot` +\n * `IdentityContext` + the Effect `Path` service. The cache helper\n * uses `Path.join` so OS-correct separators round-trip on Windows\n * (defense-in-depth — devstack is posix-only in practice but the\n * cost of `Path.join` over template strings is zero).\n */\nexport const layerStackPaths: Layer.Layer<\n\tStackPathsService,\n\tnever,\n\tRuntimeRoot | IdentityContext | Path.Path\n> = Layer.effect(\n\tStackPathsService,\n\tEffect.gen(function* () {\n\t\tconst { root } = yield* RuntimeRoot;\n\t\tconst identity = yield* IdentityContext;\n\t\tconst path = yield* Path.Path;\n\t\tconst stackRoot = path.join(root, 'stacks', identity.stack);\n\t\tconst cacheDir = path.join(stackRoot, 'cache');\n\t\tconst cacheNamespaceDir = (namespace: string): string => path.join(cacheDir, namespace);\n\t\tconst cacheChainDir = (namespace: string, chain: string): string =>\n\t\t\tpath.join(cacheNamespaceDir(namespace), chain);\n\t\tconst cacheEntry = (\n\t\t\tnamespace: string,\n\t\t\tchain: string,\n\t\t\tcontentHash: string,\n\t\t): { readonly dir: string; readonly file: string } => {\n\t\t\tconst dir = cacheChainDir(namespace, chain);\n\t\t\treturn { dir, file: path.join(dir, `${contentHash}.json`) };\n\t\t};\n\t\treturn StackPathsService.of({\n\t\t\tstackRoot,\n\t\t\tstateFile: path.join(stackRoot, 'state.json'),\n\t\t\tstateLockHint: path.join(stackRoot, 'state.json.lock'),\n\t\t\tcacheDir,\n\t\t\tsnapshotDir: path.join(stackRoot, 'snapshots'),\n\t\t\tstackLockFile: path.join(stackRoot, 'stack.lock'),\n\t\t\trosterFile: path.join(stackRoot, 'roster.json'),\n\t\t\tsnapshotReservationFile: path.join(stackRoot, 'snapshot.reservation'),\n\t\t\tcacheEntry,\n\t\t\tcacheChainDir,\n\t\t\tcacheNamespaceDir,\n\t\t});\n\t}),\n);\n"],"mappings":";;AA+BA,IAAa,cAAb,cAAiC,QAAQ,SAAwC,CAChF,0CACA,CAAC;;AAGF,MAAa,oBAAoB,SAChC,MAAM,QAAQ,YAAY,CAAC,EAAE,MAAM,CAAC;;;;;;;;;AAUrC,IAAa,kBAAb,cAAqC,QAAQ,SAAoC,CAChF,uCACA,CAAC;AAEF,MAAa,iBAAiB,aAC7B,MAAM,QAAQ,gBAAgB,CAAC,SAAS;;;;;;AA+CzC,IAAa,oBAAb,cAAuC,QAAQ,SAAwC,CACtF,yCACA,CAAC;;;;;;;;AASF,MAAa,kBAIT,MAAM,OACT,mBACA,OAAO,IAAI,aAAa;CACvB,MAAM,EAAE,SAAS,OAAO;CACxB,MAAM,WAAW,OAAO;CACxB,MAAM,OAAO,OAAO,KAAK;CACzB,MAAM,YAAY,KAAK,KAAK,MAAM,UAAU,SAAS,MAAM;CAC3D,MAAM,WAAW,KAAK,KAAK,WAAW,QAAQ;CAC9C,MAAM,qBAAqB,cAA8B,KAAK,KAAK,UAAU,UAAU;CACvF,MAAM,iBAAiB,WAAmB,UACzC,KAAK,KAAK,kBAAkB,UAAU,EAAE,MAAM;CAC/C,MAAM,cACL,WACA,OACA,gBACqD;EACrD,MAAM,MAAM,cAAc,WAAW,MAAM;AAC3C,SAAO;GAAE;GAAK,MAAM,KAAK,KAAK,KAAK,GAAG,YAAY,OAAO;GAAE;;AAE5D,QAAO,kBAAkB,GAAG;EAC3B;EACA,WAAW,KAAK,KAAK,WAAW,aAAa;EAC7C,eAAe,KAAK,KAAK,WAAW,kBAAkB;EACtD;EACA,aAAa,KAAK,KAAK,WAAW,YAAY;EAC9C,eAAe,KAAK,KAAK,WAAW,aAAa;EACjD,YAAY,KAAK,KAAK,WAAW,cAAc;EAC/C,yBAAyB,KAAK,KAAK,WAAW,uBAAuB;EACrE;EACA;EACA;EACA,CAAC;EACD,CACF"}

package/dist/substrate/runtime/port-broker/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/substrate/runtime/port-broker/service.d.mts

@@ -0,0 +1 @@
+import { Context, Effect, Layer, Scope } from "effect";