@mysten-incubation/devstack 0.0.0

package/dist/substrate/runtime/manifest/manifest.mjs

@@ -0,0 +1,73 @@
+import { atomicWriteFile } from "../atomic-write.mjs";
+import "../../manifest.mjs";
+import { Data, Effect } from "effect";
+/** One error class for every manifest IO failure. */
+var ManifestError = class extends Data.TaggedError("ManifestError") {};
+/**
+* Build the envelope from per-plugin contributions. Pure; the writer
+* calls this and then atomically writes the JSON.
+*
+* `pluginKey` collisions are an error — two contributions for the
+* same plugin would silently overwrite. Endpoint-key collisions also
+* error: every endpoint has a unique `(pluginKey, dispatchId)` digest
+* by construction; a duplicate means a substrate bug.
+*/
+const buildEnvelope = (input) => Effect.gen(function* () {
+	const services = {};
+	const endpoints = {};
+	const extras = { ...input.extras };
+	for (const contribution of input.contributions) {
+		const key = contribution.pluginKey;
+		if (key in services) return yield* Effect.fail(new ManifestError({
+			reason: "duplicate-contribution",
+			path: "(in-memory envelope)",
+			detail: `pluginKey ${key} contributed twice`
+		}));
+		services[key] = contribution.services;
+		if (contribution.extras !== void 0) for (const [extraKey, extraValue] of Object.entries(contribution.extras)) {
+			if (extraKey in extras) return yield* Effect.fail(new ManifestError({
+				reason: "duplicate-contribution",
+				path: "(in-memory envelope)",
+				detail: `extras key ${extraKey} contributed twice`
+			}));
+			extras[extraKey] = extraValue;
+		}
+		for (const ep of contribution.endpoints) {
+			const ek = ep.endpointKey;
+			if (ek in endpoints) return yield* Effect.fail(new ManifestError({
+				reason: "duplicate-contribution",
+				path: "(in-memory envelope)",
+				detail: `endpointKey ${ek} contributed twice`
+			}));
+			endpoints[ek] = ep;
+		}
+	}
+	return {
+		identity: input.identity,
+		manifestVersion: 1,
+		services,
+		endpoints,
+		extras
+	};
+});
+/**
+* Serialize and write the envelope at `path` atomically. Routes
+* through the canonical `atomicWriteFile` primitive (mkdir-parent →
+* O_EXCL temp → write → fsync → rename), so the manifest writer
+* shares ONE owner of the tempfile dance with the state-store and
+* cache.
+*/
+const writeManifest = (envelope, path) => Effect.gen(function* () {
+	const json = serializeEnvelope(envelope);
+	yield* atomicWriteFile(path, new TextEncoder().encode(json)).pipe(Effect.mapError((cause) => new ManifestError({
+		reason: "write-failed",
+		path,
+		detail: `atomic write failed at stage ${cause.stage}`,
+		cause
+	})));
+}).pipe(Effect.withSpan("Manifest.writeManifest", { attributes: { "devstack.manifest.path": path } }));
+const serializeEnvelope = (envelope) => JSON.stringify(envelope, null, 2);
+//#endregion
+export { buildEnvelope, writeManifest };
+
+//# sourceMappingURL=manifest.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.mjs","names":[],"sources":["../../../../src/substrate/runtime/manifest/manifest.ts"],"sourcesContent":["// Manifest emitter — endpoint-keyed envelope, atomic write.\n//\n// Architecture § Manifest data model. The envelope is L0 (`identity`\n// tuple, `manifestVersion`, `services` slot, `endpoints` lookup,\n// `extras`). The per-service projection lives in each plugin's\n// Codegenable contribution and is consumed by codegen output, not by\n// the manifest envelope itself.\n//\n// The emitter:\n//   - Accepts per-plugin contributions through a `contribute` Effect.\n//   - Walks endpoint contributions to build the flat `endpoints`\n//     lookup keyed by `endpointKey`. Entries still carry the declared\n//     endpoint `name` for build-integration lookup.\n//   - Writes atomically via tempfile + fsync + rename. The atomic-\n//     write primitive lives in L0 (per architecture § Collapsed:\n//     \"Three tempfile+rename impls → one atomic-write primitive\").\n//   - Validates the envelope against `ManifestEnvelopeSchema` on read.\n//   - Pins `manifestVersion` so future-proofing migrations have a\n//     compatibility seam. The pinned version is `1` for the post-\n//     rewrite envelope. (The old devstack used unversioned manifests\n//     plus a hash field; the rewrite's clean break is `version 1`.)\n//\n// Discipline: zero service names. The writer iterates `pluginKey`-\n// indexed contributions and copies the bytes through. The schema\n// validates the envelope shape, not the per-plugin contents (which\n// are `Schema.Unknown`).\n\nimport { Effect } from 'effect';\nimport { Data } from 'effect';\nimport { FileSystem } from 'effect';\n\nimport type { EndpointKey, PluginKey } from '../../brand.ts';\nimport {\n\ttype EndpointEntry,\n\ttype ManifestExtras,\n\ttype ManifestEnvelope,\n\tManifestEnvelopeSchema,\n} from '../../manifest.ts';\nimport { atomicWriteFile } from '../atomic-write.ts';\nimport { decodeJsonText } from '../runtime-decode.ts';\n\n// -----------------------------------------------------------------------------\n// Pinned schema version\n// -----------------------------------------------------------------------------\n\n/**\n * Schema version pinned at the envelope level. Bump only on a\n * breaking shape change to the envelope (NOT to a per-plugin service\n * slice — those carry their own version via Codegenable contribution).\n *\n * Reader policy:\n *   - Equal version: accept.\n *   - Older version: refuse (advise user to re-run `up`).\n *   - Newer version: refuse (build integration is out of date).\n */\nexport const CURRENT_MANIFEST_VERSION = 1 as const;\n\n// -----------------------------------------------------------------------------\n// Errors\n// -----------------------------------------------------------------------------\n\n/** One error class for every manifest IO failure. */\nexport class ManifestError extends Data.TaggedError('ManifestError')<{\n\treadonly reason:\n\t\t| 'write-failed'\n\t\t| 'read-failed'\n\t\t| 'decode-failed'\n\t\t| 'version-mismatch'\n\t\t| 'duplicate-contribution';\n\treadonly path: string;\n\treadonly detail?: string;\n\treadonly cause?: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Contribution shape\n// -----------------------------------------------------------------------------\n\n/**\n * One plugin's contribution to the manifest. Keyed by `pluginKey`\n * (branded), opaque `services` blob, plus a flat list of endpoint\n * entries the plugin owns.\n *\n * The writer copies `services` through to\n * `envelope.services[pluginKey]`. The renderer of the typed shape\n * lives in the plugin's Codegenable contribution — the manifest\n * doesn't decode it.\n */\nexport interface PluginManifestContribution {\n\treadonly pluginKey: PluginKey;\n\t/** Plugin's structured slice — opaque to the writer. */\n\treadonly services: unknown;\n\t/** Endpoints owned by this plugin. The writer indexes these by\n\t *  `endpointKey` into the flat top-level lookup. */\n\treadonly endpoints: ReadonlyArray<EndpointEntry>;\n\t/** Optional app-facing extras merged into the top-level extras slot. */\n\treadonly extras?: ManifestExtras;\n}\n\n// -----------------------------------------------------------------------------\n// Public writer interface\n// -----------------------------------------------------------------------------\n\nexport interface WriteManifestInput {\n\treadonly identity: ManifestEnvelope['identity'];\n\treadonly contributions: ReadonlyArray<PluginManifestContribution>;\n\treadonly extras?: ManifestExtras;\n}\n\n/**\n * Build the envelope from per-plugin contributions. Pure; the writer\n * calls this and then atomically writes the JSON.\n *\n * `pluginKey` collisions are an error — two contributions for the\n * same plugin would silently overwrite. Endpoint-key collisions also\n * error: every endpoint has a unique `(pluginKey, dispatchId)` digest\n * by construction; a duplicate means a substrate bug.\n */\nexport const buildEnvelope = (\n\tinput: WriteManifestInput,\n): Effect.Effect<ManifestEnvelope, ManifestError> =>\n\tEffect.gen(function* () {\n\t\tconst services: Record<string, unknown> = {};\n\t\tconst endpoints: Record<string, EndpointEntry> = {};\n\t\tconst extras: Record<string, unknown> = { ...input.extras };\n\n\t\tfor (const contribution of input.contributions) {\n\t\t\tconst key = contribution.pluginKey as string;\n\t\t\tif (key in services) {\n\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\tnew ManifestError({\n\t\t\t\t\t\treason: 'duplicate-contribution',\n\t\t\t\t\t\tpath: '(in-memory envelope)',\n\t\t\t\t\t\tdetail: `pluginKey ${key} contributed twice`,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t}\n\t\t\tservices[key] = contribution.services;\n\t\t\tif (contribution.extras !== undefined) {\n\t\t\t\tfor (const [extraKey, extraValue] of Object.entries(contribution.extras)) {\n\t\t\t\t\tif (extraKey in extras) {\n\t\t\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\t\t\tnew ManifestError({\n\t\t\t\t\t\t\t\treason: 'duplicate-contribution',\n\t\t\t\t\t\t\t\tpath: '(in-memory envelope)',\n\t\t\t\t\t\t\t\tdetail: `extras key ${extraKey} contributed twice`,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\textras[extraKey] = extraValue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (const ep of contribution.endpoints) {\n\t\t\t\tconst ek = ep.endpointKey as string;\n\t\t\t\tif (ek in endpoints) {\n\t\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\t\tnew ManifestError({\n\t\t\t\t\t\t\treason: 'duplicate-contribution',\n\t\t\t\t\t\t\tpath: '(in-memory envelope)',\n\t\t\t\t\t\t\tdetail: `endpointKey ${ek} contributed twice`,\n\t\t\t\t\t\t}),\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tendpoints[ek] = ep;\n\t\t\t}\n\t\t}\n\n\t\treturn {\n\t\t\tidentity: input.identity,\n\t\t\tmanifestVersion: CURRENT_MANIFEST_VERSION,\n\t\t\tservices,\n\t\t\tendpoints,\n\t\t\textras,\n\t\t};\n\t});\n\n// -----------------------------------------------------------------------------\n// Atomic write — delegates to the canonical primitive.\n// -----------------------------------------------------------------------------\n\n/**\n * Serialize and write the envelope at `path` atomically. Routes\n * through the canonical `atomicWriteFile` primitive (mkdir-parent →\n * O_EXCL temp → write → fsync → rename), so the manifest writer\n * shares ONE owner of the tempfile dance with the state-store and\n * cache.\n */\nexport const writeManifest = (\n\tenvelope: ManifestEnvelope,\n\tpath: string,\n): Effect.Effect<void, ManifestError, FileSystem.FileSystem> =>\n\tEffect.gen(function* () {\n\t\tconst json = serializeEnvelope(envelope);\n\t\tconst bytes = new TextEncoder().encode(json);\n\t\tyield* atomicWriteFile(path, bytes).pipe(\n\t\t\tEffect.mapError(\n\t\t\t\t(cause) =>\n\t\t\t\t\tnew ManifestError({\n\t\t\t\t\t\treason: 'write-failed',\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tdetail: `atomic write failed at stage ${cause.stage}`,\n\t\t\t\t\t\tcause,\n\t\t\t\t\t}),\n\t\t\t),\n\t\t);\n\t}).pipe(\n\t\tEffect.withSpan('Manifest.writeManifest', { attributes: { 'devstack.manifest.path': path } }),\n\t);\n\nconst serializeEnvelope = (envelope: ManifestEnvelope): string =>\n\t// Stable key ordering, deterministic re-emit. `JSON.stringify` with\n\t// 2-space indent is reproducible byte-for-byte given the same\n\t// input object.\n\tJSON.stringify(envelope, null, 2);\n\n// -----------------------------------------------------------------------------\n// Read + decode\n// -----------------------------------------------------------------------------\n\n/**\n * Read and decode the manifest at `path`. Validates against\n * `ManifestEnvelopeSchema` and the pinned `CURRENT_MANIFEST_VERSION`.\n *\n * Used by:\n *   - Codegen (architecture §6) — consumes plugin slices off\n *     `envelope.services[pluginKey]`.\n *   - Build integrations (Vitest, Playwright, generated app code) — consumes\n *     `envelope.endpoints` lookup.\n *\n * The reader is read-only; no mutation, no IO beyond the single read.\n */\nexport const readManifest = (\n\tpath: string,\n): Effect.Effect<ManifestEnvelope, ManifestError, FileSystem.FileSystem> =>\n\tEffect.gen(function* () {\n\t\tconst fs = yield* FileSystem.FileSystem;\n\t\tconst text = yield* fs\n\t\t\t.readFileString(path)\n\t\t\t.pipe(Effect.mapError((cause) => new ManifestError({ reason: 'read-failed', path, cause })));\n\t\tconst decoded = yield* decodeJsonText(ManifestEnvelopeSchema, text, {\n\t\t\tsource: path,\n\t\t\tmkError: (issue) =>\n\t\t\t\tnew ManifestError({ reason: 'decode-failed', path, cause: issue.cause ?? issue }),\n\t\t});\n\t\tif (decoded.manifestVersion !== CURRENT_MANIFEST_VERSION) {\n\t\t\treturn yield* Effect.fail(\n\t\t\t\tnew ManifestError({\n\t\t\t\t\treason: 'version-mismatch',\n\t\t\t\t\tpath,\n\t\t\t\t\tdetail: `expected ${CURRENT_MANIFEST_VERSION}, got ${decoded.manifestVersion}`,\n\t\t\t\t}),\n\t\t\t);\n\t\t}\n\t\treturn decoded as ManifestEnvelope;\n\t}).pipe(\n\t\tEffect.withSpan('Manifest.readManifest', { attributes: { 'devstack.manifest.path': path } }),\n\t);\n\n// -----------------------------------------------------------------------------\n// Re-export the envelope + endpoint types so downstream substrate\n// modules (codegen, build integrations) don't reach into substrate/\n// directly.\n// -----------------------------------------------------------------------------\n\nexport type { EndpointEntry, EndpointKey, ManifestEnvelope, PluginKey };\nexport { ManifestEnvelopeSchema };\n"],"mappings":";;;;AA8DA,IAAa,gBAAb,cAAmC,KAAK,YAAY,gBAAgB,CAUjE;;;;;;;;;;AA8CH,MAAa,iBACZ,UAEA,OAAO,IAAI,aAAa;CACvB,MAAM,WAAoC,EAAE;CAC5C,MAAM,YAA2C,EAAE;CACnD,MAAM,SAAkC,EAAE,GAAG,MAAM,QAAQ;AAE3D,MAAK,MAAM,gBAAgB,MAAM,eAAe;EAC/C,MAAM,MAAM,aAAa;AACzB,MAAI,OAAO,SACV,QAAO,OAAO,OAAO,KACpB,IAAI,cAAc;GACjB,QAAQ;GACR,MAAM;GACN,QAAQ,aAAa,IAAI;GACzB,CAAC,CACF;AAEF,WAAS,OAAO,aAAa;AAC7B,MAAI,aAAa,WAAW,KAAA,EAC3B,MAAK,MAAM,CAAC,UAAU,eAAe,OAAO,QAAQ,aAAa,OAAO,EAAE;AACzE,OAAI,YAAY,OACf,QAAO,OAAO,OAAO,KACpB,IAAI,cAAc;IACjB,QAAQ;IACR,MAAM;IACN,QAAQ,cAAc,SAAS;IAC/B,CAAC,CACF;AAEF,UAAO,YAAY;;AAGrB,OAAK,MAAM,MAAM,aAAa,WAAW;GACxC,MAAM,KAAK,GAAG;AACd,OAAI,MAAM,UACT,QAAO,OAAO,OAAO,KACpB,IAAI,cAAc;IACjB,QAAQ;IACR,MAAM;IACN,QAAQ,eAAe,GAAG;IAC1B,CAAC,CACF;AAEF,aAAU,MAAM;;;AAIlB,QAAO;EACN,UAAU,MAAM;EAChB,iBAAA;EACA;EACA;EACA;EACA;EACA;;;;;;;;AAaH,MAAa,iBACZ,UACA,SAEA,OAAO,IAAI,aAAa;CACvB,MAAM,OAAO,kBAAkB,SAAS;AAExC,QAAO,gBAAgB,MADT,IAAI,aAAa,CAAC,OAAO,KACL,CAAC,CAAC,KACnC,OAAO,UACL,UACA,IAAI,cAAc;EACjB,QAAQ;EACR;EACA,QAAQ,gCAAgC,MAAM;EAC9C;EACA,CAAC,CACH,CACD;EACA,CAAC,KACF,OAAO,SAAS,0BAA0B,EAAE,YAAY,EAAE,0BAA0B,MAAM,EAAE,CAAC,CAC7F;AAEF,MAAM,qBAAqB,aAI1B,KAAK,UAAU,UAAU,MAAM,EAAE"}

package/dist/substrate/runtime/mode-errors.d.mts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/substrate/runtime/mode-errors.d.ts
+declare const ForkIncompatibleError_base: Schema.Class<ForkIncompatibleError, Schema.TaggedStruct<"ForkIncompatibleError", {
+  /** Refusing factory variant — e.g. `'walrusLocalCluster'`,
+   *  `'sealLocalKeygen'`. Lets multiple plugin factories share
+   *  this shape without losing the call-site distinction. */
+  readonly variant: Schema.String; /** Resolved network the composition refused under. */
+  readonly network: Schema.String; /** Imperative one-liner suitable for stderr. */
+  readonly message: Schema.String; /** Actionable next step (the known-deployment alternative). */
+  readonly hint: Schema.optional<Schema.String>;
+  /** Optional original cause when the refusal wraps an underlying
+   *  fault (rare — typical use is a pure factory-time refusal). */
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, _$effect_Cause0.YieldableError>;
+/**
+ * Synchronous factory-time refusal raised by a plugin factory
+ * variant when composed against a network the variant cannot serve
+ * (canonically: a `*-fork` chain that doesn't expose the fullnode
+ * surface the variant requires).
+ *
+ * Architecture (Tension 11): primary refusal is TYPE-LEVEL via
+ * mode-narrowed factory namespaces — `walrusFor(forkNet).<mode>` only
+ * exposes `.known`. This runtime shape is defense-in-depth for
+ * callers that bypass the type-level narrowing (env-driven factories,
+ * plugin composition through resolved values).
+ *
+ * Used by walrus (`local-cluster` variant) and seal (`local-keygen`
+ * variant) today; future plugin factories refusing on a network
+ * predicate share this single shape.
+ */
+declare class ForkIncompatibleError extends ForkIncompatibleError_base {}
+//#endregion
+export { ForkIncompatibleError };
+//# sourceMappingURL=mode-errors.d.mts.map

package/dist/substrate/runtime/observability/cascade-formatter.d.mts

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

package/dist/substrate/runtime/observability/cascade-formatter.mjs

@@ -0,0 +1,135 @@
+import { redactText, redactValue } from "./redaction.mjs";
+//#region src/substrate/runtime/observability/cascade-formatter.ts
+/** Empty registry — the formatter falls back to the default
+*  rendering for every value. */
+const emptyFormatterRegistry = /* @__PURE__ */ new Map();
+const DEFAULT_FIELD_TRUNCATE = 8192;
+const DEFAULT_MAX_DEPTH = 12;
+const isTaggedError = (value) => typeof value === "object" && value !== null && typeof value._tag === "string";
+const isCauseLike = (value) => typeof value === "object" && value !== null && Array.isArray(value.reasons);
+/**
+* Format an Effect `Cause<E>` as a multi-line cascade string. Pure.
+*
+* Multiple `Fail` reasons render as separate blocks joined by
+* `--- (also)` so parallel failures are visible. Defects render with
+* a `DEFECT` prefix. Interrupts render with `INTERRUPT[<fiberId>]`.
+*
+* Cyclic `cause` chains are broken with `…[cycle]`.
+*/
+const formatCause = (cause, options) => {
+	const opts = {
+		formatters: options?.formatters ?? emptyFormatterRegistry,
+		fieldTruncate: options?.fieldTruncate ?? DEFAULT_FIELD_TRUNCATE,
+		maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,
+		redactions: options?.redactions ?? []
+	};
+	const visited = /* @__PURE__ */ new WeakSet();
+	const reasons = cause.reasons;
+	if (reasons.length === 0) return "(empty cause)";
+	return reasons.map((reason) => formatReason(reason, opts, visited, 0)).join("\n--- (also)\n");
+};
+/**
+* Format an arbitrary value (a `Cause`, a tagged error, a plain
+* `Error`, or anything else) using the cascade rules. Pure.
+*
+* The pretty-error renderer (`pretty-error.ts`) is a thin wrapper
+* over this — it just sets the IO conventions (where to write,
+* what to truncate per-context). The formatting logic lives here.
+*/
+const formatValue = (value, options) => {
+	return formatAny(value, {
+		formatters: options?.formatters ?? emptyFormatterRegistry,
+		fieldTruncate: options?.fieldTruncate ?? DEFAULT_FIELD_TRUNCATE,
+		maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,
+		redactions: options?.redactions ?? []
+	}, /* @__PURE__ */ new WeakSet(), 0);
+};
+const truncate = (s, limit, redactions) => {
+	const redacted = redactText(s, redactions);
+	return redacted.length > limit ? `${redacted.slice(0, limit)}…[truncated]` : redacted;
+};
+const indent = (s, prefix) => s.split("\n").map((line) => `${prefix}${line}`).join("\n");
+const formatReason = (reason, opts, visited, depth) => {
+	switch (reason._tag) {
+		case "Fail": return formatAny(reason.error, opts, visited, depth);
+		case "Die": return `DEFECT:\n${indent(formatAny(reason.defect, opts, visited, depth), "  ")}`;
+		case "Interrupt": return `INTERRUPT[${reason.fiberId ?? "unknown"}]`;
+	}
+};
+const formatAny = (value, opts, visited, depth) => {
+	if (value === void 0 || value === null) return "";
+	if (depth > opts.maxDepth) return "…[max depth]";
+	if (typeof value === "object") {
+		if (visited.has(value)) return "…[cycle]";
+		visited.add(value);
+	}
+	if (isCauseLike(value)) {
+		const rs = value.reasons;
+		if (rs.length === 0) return "(empty cause)";
+		return rs.map((r) => formatReason(r, opts, visited, depth)).join("\n--- (also)\n");
+	}
+	if (isTaggedError(value)) return formatTagged(value, opts, visited, depth);
+	if (value instanceof Error) {
+		const header = `${value.name}: ${value.message}`;
+		if (value.stack && value.stack !== header) return value.stack;
+		return header;
+	}
+	if (typeof value === "string") return redactText(value, opts.redactions);
+	try {
+		return JSON.stringify(redactValue(value, opts.redactions));
+	} catch {
+		return String(value);
+	}
+};
+const formatTagged = (value, opts, visited, depth) => {
+	const override = opts.formatters.get(value._tag);
+	if (override) {
+		const result = override(value, (inner) => formatAny(inner, opts, visited, depth + 1));
+		if (result !== null) return result;
+	}
+	const qualifier = typeof value.phase === "string" ? `(${value.phase})` : typeof value.op === "string" ? `(${value.op})` : "";
+	const message = typeof value.message === "string" ? redactText(value.message, opts.redactions) : "";
+	const header = qualifier ? `${value._tag} ${qualifier}: ${message}` : `${value._tag}: ${message}`;
+	const lines = [header];
+	if (typeof value.exitCode === "number") lines.push(`  exitCode: ${value.exitCode}`);
+	if (typeof value.stderr === "string" && value.stderr.trim().length > 0) lines.push(`  stderr: ${truncate(value.stderr.trim(), opts.fieldTruncate, opts.redactions)}`);
+	if (typeof value.stdout === "string" && value.stdout.trim().length > 0) lines.push(`  stdout: ${truncate(value.stdout.trim(), opts.fieldTruncate, opts.redactions)}`);
+	if (typeof value.detail === "string" && value.detail.trim().length > 0) lines.push(`  detail: ${truncate(value.detail.trim(), opts.fieldTruncate, opts.redactions)}`);
+	const conventional = new Set([
+		"_tag",
+		"message",
+		"cause",
+		"phase",
+		"stderr",
+		"stdout",
+		"exitCode",
+		"detail",
+		"op"
+	]);
+	for (const key of Object.keys(value)) {
+		if (conventional.has(key)) continue;
+		const v = value[key];
+		if (v === void 0 || v === null) continue;
+		const rendered = typeof v === "string" ? truncate(v, opts.fieldTruncate, opts.redactions) : typeof v === "number" || typeof v === "boolean" ? String(v) : safeJson(v, opts.fieldTruncate, opts.redactions);
+		lines.push(`  ${key}: ${rendered}`);
+	}
+	if (value.cause !== void 0 && value.cause !== null) {
+		const rendered = formatAny(value.cause, opts, visited, depth + 1);
+		if (rendered.trim().length > 0 && rendered.trim() !== header.trim()) {
+			lines.push("  caused by:");
+			lines.push(indent(rendered, "    "));
+		}
+	}
+	return lines.join("\n");
+};
+const safeJson = (value, limit, redactions) => {
+	try {
+		return truncate(JSON.stringify(redactValue(value, redactions)), limit, redactions);
+	} catch {
+		return "[unserializable]";
+	}
+};
+//#endregion
+export { emptyFormatterRegistry, formatCause, formatValue, isTaggedError };
+
+//# sourceMappingURL=cascade-formatter.mjs.map

package/dist/substrate/runtime/observability/cascade-formatter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade-formatter.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/cascade-formatter.ts"],"sourcesContent":["// L0 cascade formatter.\n//\n// Architecture § Substrate violations § \"C2 — relocate cause walker\n// from the renderer\". The cascade formatter walks an Effect `Cause`\n// and returns a stringified cascade of taxonomy-aware lines. Called\n// from CLI, TUI, prune — anywhere a failure surfaces.\n//\n// Hard rules:\n//   - PURE. No IO, no Effect, no clocks. Input → string.\n//   - No service names: the formatter inspects `_tag` strings and\n//     structured fields verbatim, never branches on a specific\n//     concrete plugin error class.\n//   - Pluggable per-error-class formatters via a `formatters` map\n//     keyed by `_tag`. The default formatter handles tagged errors,\n//     plain `Error`, defects, and Interrupts.\n//\n// Output shape:\n//\n//   <Tag> (<phase?>): <message>\n//     exitCode: <n>\n//     stderr: <text…[truncated]>\n//     <field>: <value>\n//     caused by:\n//       <recursive render, indented by 2 spaces>\n//\n// Multi-`Fail` causes (parallel failures) render with a `--- (also)`\n// separator. Defects (`Die`) render with `DEFECT (<tag>?)` prefix so\n// the operator can tell programmer errors from typed failures at a\n// glance. Interrupts render as `INTERRUPT[<fiberId>]`.\n\nimport type { Cause } from 'effect';\n\nimport { redactText, redactValue, type RedactionRule } from './redaction.ts';\n\n// `Cause` is a namespace in effect v4; the actual cause type is\n// `Cause.Cause<E>`. We re-alias here so call sites read naturally.\ntype CauseT<E> = Cause.Cause<E>;\n\n// -----------------------------------------------------------------------------\n// Plug-in formatter API\n// -----------------------------------------------------------------------------\n\n/**\n * Per-tag formatter override. Receives the tagged-error-like value\n * and the default formatter (so a plugin formatter can recurse on a\n * nested `cause` field without re-implementing the walk).\n *\n * Return `null` to fall back to the default rendering.\n *\n * Architecture: the formatter registry is keyed by `_tag` string —\n * the substrate never imports a concrete plugin error class. Plugins\n * register their custom renderer via the supervisor harvest loop over\n * `errorContributions` (see `substrate/plugin.ts:PluginErrorContribution`).\n */\nexport type TagFormatter = (\n\tvalue: TaggedErrorLike,\n\trecurse: (inner: unknown) => string,\n) => string | null;\n\n/** Per-tag formatter map. */\nexport type FormatterRegistry = ReadonlyMap<string, TagFormatter>;\n\n/** Empty registry — the formatter falls back to the default\n *  rendering for every value. */\nexport const emptyFormatterRegistry: FormatterRegistry = new Map();\n\n// -----------------------------------------------------------------------------\n// Render budget\n// -----------------------------------------------------------------------------\n\nconst DEFAULT_FIELD_TRUNCATE = 8192;\nconst DEFAULT_MAX_DEPTH = 12;\n\nexport interface FormatOptions {\n\t/** Per-tag override registry. Defaults to the empty registry. */\n\treadonly formatters?: FormatterRegistry;\n\t/** Truncate individual fields (stderr/stdout/detail) past this\n\t *  length. Default 8 KiB. */\n\treadonly fieldTruncate?: number;\n\t/** Hard recursion cap. Cyclic graphs are detected separately by\n\t *  visit-set; this guards against pathological cause chains.\n\t *  Default 12. */\n\treadonly maxDepth?: number;\n\t/** Optional redaction rules applied before rendering string fields. */\n\treadonly redactions?: ReadonlyArray<RedactionRule>;\n}\n\n// -----------------------------------------------------------------------------\n// Type guards (structural — no imports of concrete classes)\n// -----------------------------------------------------------------------------\n\n/** Shape of a `Schema.TaggedError` / `Data.TaggedError` instance.\n *  The cascade formatter never imports a concrete class — it dispatches\n *  on `_tag`. */\nexport interface TaggedErrorLike {\n\treadonly _tag: string;\n\treadonly message?: unknown;\n\treadonly cause?: unknown;\n\treadonly phase?: unknown;\n\treadonly stderr?: unknown;\n\treadonly stdout?: unknown;\n\treadonly exitCode?: unknown;\n\treadonly [key: string]: unknown;\n\treadonly detail?: unknown;\n\treadonly op?: unknown;\n}\n\nexport const isTaggedError = (value: unknown): value is TaggedErrorLike =>\n\ttypeof value === 'object' &&\n\tvalue !== null &&\n\ttypeof (value as { _tag?: unknown })._tag === 'string';\n\ninterface CauseLike {\n\treadonly reasons: ReadonlyArray<ReasonLike>;\n}\n\ninterface FailReasonLike {\n\treadonly _tag: 'Fail';\n\treadonly error: unknown;\n}\ninterface DieReasonLike {\n\treadonly _tag: 'Die';\n\treadonly defect: unknown;\n}\ninterface InterruptReasonLike {\n\treadonly _tag: 'Interrupt';\n\treadonly fiberId: number | undefined;\n}\ntype ReasonLike = FailReasonLike | DieReasonLike | InterruptReasonLike;\n\nconst isCauseLike = (value: unknown): value is CauseLike =>\n\ttypeof value === 'object' &&\n\tvalue !== null &&\n\tArray.isArray((value as { reasons?: unknown }).reasons);\n\n// -----------------------------------------------------------------------------\n// Public entry points\n// -----------------------------------------------------------------------------\n\n/**\n * Format an Effect `Cause<E>` as a multi-line cascade string. Pure.\n *\n * Multiple `Fail` reasons render as separate blocks joined by\n * `--- (also)` so parallel failures are visible. Defects render with\n * a `DEFECT` prefix. Interrupts render with `INTERRUPT[<fiberId>]`.\n *\n * Cyclic `cause` chains are broken with `…[cycle]`.\n */\nexport const formatCause = <E>(cause: CauseT<E>, options?: FormatOptions): string => {\n\tconst opts: Required<FormatOptions> = {\n\t\tformatters: options?.formatters ?? emptyFormatterRegistry,\n\t\tfieldTruncate: options?.fieldTruncate ?? DEFAULT_FIELD_TRUNCATE,\n\t\tmaxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,\n\t\tredactions: options?.redactions ?? [],\n\t};\n\tconst visited = new WeakSet<object>();\n\tconst reasons = (cause as unknown as CauseLike).reasons;\n\tif (reasons.length === 0) return '(empty cause)';\n\tconst rendered = reasons.map((reason) => formatReason(reason, opts, visited, 0));\n\treturn rendered.join('\\n--- (also)\\n');\n};\n\n/**\n * Format an arbitrary value (a `Cause`, a tagged error, a plain\n * `Error`, or anything else) using the cascade rules. Pure.\n *\n * The pretty-error renderer (`pretty-error.ts`) is a thin wrapper\n * over this — it just sets the IO conventions (where to write,\n * what to truncate per-context). The formatting logic lives here.\n */\nexport const formatValue = (value: unknown, options?: FormatOptions): string => {\n\tconst opts: Required<FormatOptions> = {\n\t\tformatters: options?.formatters ?? emptyFormatterRegistry,\n\t\tfieldTruncate: options?.fieldTruncate ?? DEFAULT_FIELD_TRUNCATE,\n\t\tmaxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,\n\t\tredactions: options?.redactions ?? [],\n\t};\n\treturn formatAny(value, opts, new WeakSet(), 0);\n};\n\n// -----------------------------------------------------------------------------\n// Internals\n// -----------------------------------------------------------------------------\n\nconst truncate = (s: string, limit: number, redactions: ReadonlyArray<RedactionRule>): string => {\n\tconst redacted = redactText(s, redactions);\n\treturn redacted.length > limit ? `${redacted.slice(0, limit)}…[truncated]` : redacted;\n};\n\nconst indent = (s: string, prefix: string): string =>\n\ts\n\t\t.split('\\n')\n\t\t.map((line) => `${prefix}${line}`)\n\t\t.join('\\n');\n\nconst formatReason = (\n\treason: ReasonLike,\n\topts: Required<FormatOptions>,\n\tvisited: WeakSet<object>,\n\tdepth: number,\n): string => {\n\tswitch (reason._tag) {\n\t\tcase 'Fail':\n\t\t\treturn formatAny(reason.error, opts, visited, depth);\n\t\tcase 'Die': {\n\t\t\tconst inner = formatAny(reason.defect, opts, visited, depth);\n\t\t\treturn `DEFECT:\\n${indent(inner, '  ')}`;\n\t\t}\n\t\tcase 'Interrupt':\n\t\t\treturn `INTERRUPT[${reason.fiberId ?? 'unknown'}]`;\n\t}\n};\n\nconst formatAny = (\n\tvalue: unknown,\n\topts: Required<FormatOptions>,\n\tvisited: WeakSet<object>,\n\tdepth: number,\n): string => {\n\tif (value === undefined || value === null) return '';\n\tif (depth > opts.maxDepth) return '…[max depth]';\n\tif (typeof value === 'object') {\n\t\tif (visited.has(value as object)) return '…[cycle]';\n\t\tvisited.add(value as object);\n\t}\n\tif (isCauseLike(value)) {\n\t\tconst rs = value.reasons;\n\t\tif (rs.length === 0) return '(empty cause)';\n\t\treturn rs.map((r) => formatReason(r, opts, visited, depth)).join('\\n--- (also)\\n');\n\t}\n\tif (isTaggedError(value)) {\n\t\treturn formatTagged(value, opts, visited, depth);\n\t}\n\tif (value instanceof Error) {\n\t\tconst header = `${value.name}: ${value.message}`;\n\t\tif (value.stack && value.stack !== header) return value.stack;\n\t\treturn header;\n\t}\n\tif (typeof value === 'string') return redactText(value, opts.redactions);\n\ttry {\n\t\treturn JSON.stringify(redactValue(value, opts.redactions));\n\t} catch {\n\t\treturn String(value);\n\t}\n};\n\nconst formatTagged = (\n\tvalue: TaggedErrorLike,\n\topts: Required<FormatOptions>,\n\tvisited: WeakSet<object>,\n\tdepth: number,\n): string => {\n\tconst override = opts.formatters.get(value._tag);\n\tif (override) {\n\t\tconst result = override(value, (inner) => formatAny(inner, opts, visited, depth + 1));\n\t\tif (result !== null) return result;\n\t}\n\n\tconst qualifier =\n\t\ttypeof value.phase === 'string'\n\t\t\t? `(${value.phase})`\n\t\t\t: typeof value.op === 'string'\n\t\t\t\t? `(${value.op})`\n\t\t\t\t: '';\n\tconst message =\n\t\ttypeof value.message === 'string' ? redactText(value.message, opts.redactions) : '';\n\tconst header = qualifier ? `${value._tag} ${qualifier}: ${message}` : `${value._tag}: ${message}`;\n\n\tconst lines: Array<string> = [header];\n\tif (typeof value.exitCode === 'number') lines.push(`  exitCode: ${value.exitCode}`);\n\tif (typeof value.stderr === 'string' && value.stderr.trim().length > 0) {\n\t\tlines.push(`  stderr: ${truncate(value.stderr.trim(), opts.fieldTruncate, opts.redactions)}`);\n\t}\n\tif (typeof value.stdout === 'string' && value.stdout.trim().length > 0) {\n\t\tlines.push(`  stdout: ${truncate(value.stdout.trim(), opts.fieldTruncate, opts.redactions)}`);\n\t}\n\tif (typeof value.detail === 'string' && value.detail.trim().length > 0) {\n\t\tlines.push(`  detail: ${truncate(value.detail.trim(), opts.fieldTruncate, opts.redactions)}`);\n\t}\n\n\t// Surface any extra plain-data fields the tagged error carries.\n\t// We skip the conventional ones already rendered above plus `_tag`,\n\t// `cause`. This makes the formatter discover-by-shape: a plugin\n\t// adding `path` or `kind` to its error gets it rendered for free.\n\tconst conventional = new Set([\n\t\t'_tag',\n\t\t'message',\n\t\t'cause',\n\t\t'phase',\n\t\t'stderr',\n\t\t'stdout',\n\t\t'exitCode',\n\t\t'detail',\n\t\t'op',\n\t]);\n\tfor (const key of Object.keys(value)) {\n\t\tif (conventional.has(key)) continue;\n\t\tconst v = (value as unknown as Record<string, unknown>)[key];\n\t\tif (v === undefined || v === null) continue;\n\t\tconst rendered =\n\t\t\ttypeof v === 'string'\n\t\t\t\t? truncate(v, opts.fieldTruncate, opts.redactions)\n\t\t\t\t: typeof v === 'number' || typeof v === 'boolean'\n\t\t\t\t\t? String(v)\n\t\t\t\t\t: safeJson(v, opts.fieldTruncate, opts.redactions);\n\t\tlines.push(`  ${key}: ${rendered}`);\n\t}\n\n\tif (value.cause !== undefined && value.cause !== null) {\n\t\tconst rendered = formatAny(value.cause, opts, visited, depth + 1);\n\t\tif (rendered.trim().length > 0 && rendered.trim() !== header.trim()) {\n\t\t\tlines.push('  caused by:');\n\t\t\tlines.push(indent(rendered, '    '));\n\t\t}\n\t}\n\treturn lines.join('\\n');\n};\n\nconst safeJson = (\n\tvalue: unknown,\n\tlimit: number,\n\tredactions: ReadonlyArray<RedactionRule>,\n): string => {\n\ttry {\n\t\treturn truncate(JSON.stringify(redactValue(value, redactions)), limit, redactions);\n\t} catch {\n\t\treturn '[unserializable]';\n\t}\n};\n"],"mappings":"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"}

package/dist/substrate/runtime/observability/formatter-registry.d.mts

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

package/dist/substrate/runtime/observability/formatter-registry.mjs

@@ -0,0 +1,65 @@
+import { emptyFormatterRegistry } from "./cascade-formatter.mjs";
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/substrate/runtime/observability/formatter-registry.ts
+var FormatterRegistryService = class extends Context.Service()("@devstack-rewrite/substrate/FormatterRegistry") {};
+/** Layer constructing the per-stack formatter registry. Stateful;
+*  the substrate provides one per supervisor scope. */
+const layerFormatterRegistry = Layer.effect(FormatterRegistryService, Effect.gen(function* () {
+	const state = yield* Ref.make(/* @__PURE__ */ new Map());
+	const seqRef = yield* Ref.make(0);
+	const register = (contribution) => Effect.gen(function* () {
+		const baseSeq = yield* Ref.updateAndGet(seqRef, (n) => n + 1);
+		const fmt = contribution.formatter !== void 0 ? (value, recurse) => contribution.formatter(value, recurse) : null;
+		const newEntries = contribution.errorTags.map((tag) => ({
+			tag,
+			formatter: fmt,
+			seq: baseSeq
+		}));
+		yield* Ref.update(state, (current) => {
+			const next = new Map(current);
+			for (const e of newEntries) {
+				const existing = next.get(e.tag) ?? [];
+				next.set(e.tag, [...existing, e]);
+			}
+			return next;
+		});
+		yield* Effect.addFinalizer((_exit) => Ref.update(state, (current) => {
+			const next = new Map(current);
+			for (const e of newEntries) {
+				const existing = next.get(e.tag);
+				if (!existing) continue;
+				const filtered = existing.filter((x) => x.seq !== e.seq);
+				if (filtered.length === 0) next.delete(e.tag);
+				else next.set(e.tag, filtered);
+			}
+			return next;
+		}));
+	}).pipe(Effect.withSpan("substrate.formatterRegistry.register"));
+	const snapshot = Effect.gen(function* () {
+		const current = yield* Ref.get(state);
+		if (current.size === 0) return emptyFormatterRegistry;
+		const out = /* @__PURE__ */ new Map();
+		for (const [tag, entries] of current) {
+			let chosen = null;
+			let chosenSeq = -1;
+			for (const e of entries) if (e.formatter !== null && e.seq > chosenSeq) {
+				chosen = e.formatter;
+				chosenSeq = e.seq;
+			}
+			if (chosen !== null) out.set(tag, chosen);
+		}
+		return out;
+	});
+	const tags = Effect.gen(function* () {
+		return [...(yield* Ref.get(state)).keys()];
+	});
+	return FormatterRegistryService.of({
+		register,
+		snapshot,
+		tags
+	});
+}));
+//#endregion
+export { FormatterRegistryService, layerFormatterRegistry };
+
+//# sourceMappingURL=formatter-registry.mjs.map

package/dist/substrate/runtime/observability/formatter-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter-registry.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/formatter-registry.ts"],"sourcesContent":["// Formatter registry service.\n//\n// Architecture § L0 Observability: the cascade formatter consults a\n// per-tag `FormatterRegistry` for custom renderers. The registry is\n// substrate-owned and populated by the supervisor's harvest loop from\n// each acquired plugin's `errorContributions` field. The substrate\n// stays name-blind: it dispatches on `_tag` strings the plugins\n// declare, never on plugin identifiers.\n//\n// Two surfaces:\n//   - `register(contribution)` — adds tags + optional formatter for a\n//     single `PluginErrorContribution`. Idempotent on the tag set\n//     when no formatter is provided; last-write-wins on the formatter\n//     slot when one is.\n//   - `snapshot()` — returns an immutable `FormatterRegistry` the\n//     cascade formatter consumes.\n//\n// Scope-bound: callers `register` inside a plugin's scope so the\n// contribution dies with the plugin (selective restart, shutdown).\n// The supervisor uses `Effect.addFinalizer` at the dispatch site;\n// this service exposes the unregister side as a complement.\n\nimport { Context, Effect, Layer, Ref, Scope } from 'effect';\n\nimport type { PluginErrorContribution } from '../../plugin.ts';\nimport {\n\temptyFormatterRegistry,\n\ttype FormatterRegistry,\n\ttype TagFormatter,\n} from './cascade-formatter.ts';\n\n/** Public shape of the formatter-registry service. */\nexport interface FormatterRegistryShape {\n\t/** Register a plugin's contribution. Scope-bound: the contribution\n\t *  is reaped when the surrounding `Scope` closes. The supervisor\n\t *  calls this inside each plugin's scope so selective-restart\n\t *  cleans up the plugin's formatters automatically. */\n\treadonly register: (\n\t\tcontribution: PluginErrorContribution,\n\t) => Effect.Effect<void, never, Scope.Scope>;\n\t/** Snapshot the live registry as an immutable `FormatterRegistry`\n\t *  the cascade formatter consumes. */\n\treadonly snapshot: Effect.Effect<FormatterRegistry>;\n\t/** Diagnostic: list every tag the registry currently tracks. */\n\treadonly tags: Effect.Effect<ReadonlyArray<string>>;\n}\n\nexport class FormatterRegistryService extends Context.Service<\n\tFormatterRegistryService,\n\tFormatterRegistryShape\n>()('@devstack-rewrite/substrate/FormatterRegistry') {}\n\n/** Per-tag entry. The registry may track a tag with no formatter\n *  (default rendering is enough) — that's why `formatter` is\n *  optional. We keep a sequence number so multi-plugin registrations\n *  for the same tag can dedup deterministically on scope close. */\ninterface Entry {\n\treadonly tag: string;\n\treadonly formatter: TagFormatter | null;\n\treadonly seq: number;\n}\n\ntype State = ReadonlyMap<string, ReadonlyArray<Entry>>;\n\n/** Layer constructing the per-stack formatter registry. Stateful;\n *  the substrate provides one per supervisor scope. */\nexport const layerFormatterRegistry: Layer.Layer<FormatterRegistryService> = Layer.effect(\n\tFormatterRegistryService,\n\tEffect.gen(function* () {\n\t\tconst state = yield* Ref.make<State>(new Map());\n\t\tconst seqRef = yield* Ref.make(0);\n\n\t\tconst register = (\n\t\t\tcontribution: PluginErrorContribution,\n\t\t): Effect.Effect<void, never, Scope.Scope> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst baseSeq = yield* Ref.updateAndGet(seqRef, (n) => n + 1);\n\t\t\t\t// Wrap the optional formatter so the cascade-formatter's\n\t\t\t\t// `TagFormatter` shape is consistent regardless of whether\n\t\t\t\t// the plugin provided one.\n\t\t\t\tconst fmt: TagFormatter | null =\n\t\t\t\t\tcontribution.formatter !== undefined\n\t\t\t\t\t\t? (value, recurse) => contribution.formatter!(value, recurse)\n\t\t\t\t\t\t: null;\n\t\t\t\tconst newEntries: ReadonlyArray<Entry> = contribution.errorTags.map((tag) => ({\n\t\t\t\t\ttag,\n\t\t\t\t\tformatter: fmt,\n\t\t\t\t\tseq: baseSeq,\n\t\t\t\t}));\n\t\t\t\tyield* Ref.update(state, (current) => {\n\t\t\t\t\tconst next = new Map(current);\n\t\t\t\t\tfor (const e of newEntries) {\n\t\t\t\t\t\tconst existing = next.get(e.tag) ?? [];\n\t\t\t\t\t\tnext.set(e.tag, [...existing, e]);\n\t\t\t\t\t}\n\t\t\t\t\treturn next;\n\t\t\t\t});\n\t\t\t\t// Scope finalizer: drop these entries on scope close.\n\t\t\t\t// Sequence-number match keeps parallel plugin\n\t\t\t\t// registrations isolated — we only drop the entries this\n\t\t\t\t// registration added.\n\t\t\t\tyield* Effect.addFinalizer((_exit) =>\n\t\t\t\t\tRef.update(state, (current) => {\n\t\t\t\t\t\tconst next = new Map(current);\n\t\t\t\t\t\tfor (const e of newEntries) {\n\t\t\t\t\t\t\tconst existing = next.get(e.tag);\n\t\t\t\t\t\t\tif (!existing) continue;\n\t\t\t\t\t\t\tconst filtered = existing.filter((x) => x.seq !== e.seq);\n\t\t\t\t\t\t\tif (filtered.length === 0) next.delete(e.tag);\n\t\t\t\t\t\t\telse next.set(e.tag, filtered);\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn next;\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t}).pipe(Effect.withSpan('substrate.formatterRegistry.register'));\n\n\t\tconst snapshot: Effect.Effect<FormatterRegistry> = Effect.gen(function* () {\n\t\t\tconst current = yield* Ref.get(state);\n\t\t\tif (current.size === 0) return emptyFormatterRegistry;\n\t\t\tconst out = new Map<string, TagFormatter>();\n\t\t\tfor (const [tag, entries] of current) {\n\t\t\t\t// Last registration wins on the formatter slot — tags\n\t\t\t\t// without a custom formatter are still tracked so callers\n\t\t\t\t// can introspect via `tags()` even when no override is\n\t\t\t\t// registered.\n\t\t\t\tlet chosen: TagFormatter | null = null;\n\t\t\t\tlet chosenSeq = -1;\n\t\t\t\tfor (const e of entries) {\n\t\t\t\t\tif (e.formatter !== null && e.seq > chosenSeq) {\n\t\t\t\t\t\tchosen = e.formatter;\n\t\t\t\t\t\tchosenSeq = e.seq;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (chosen !== null) out.set(tag, chosen);\n\t\t\t}\n\t\t\treturn out as FormatterRegistry;\n\t\t});\n\n\t\tconst tags: Effect.Effect<ReadonlyArray<string>> = Effect.gen(function* () {\n\t\t\tconst current = yield* Ref.get(state);\n\t\t\treturn [...current.keys()];\n\t\t});\n\n\t\treturn FormatterRegistryService.of({ register, snapshot, tags });\n\t}),\n);\n"],"mappings":";;;AA+CA,IAAa,2BAAb,cAA8C,QAAQ,SAGnD,CAAC,gDAAgD,CAAC;;;AAgBrD,MAAa,yBAAgE,MAAM,OAClF,0BACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO,IAAI,qBAAY,IAAI,KAAK,CAAC;CAC/C,MAAM,SAAS,OAAO,IAAI,KAAK,EAAE;CAEjC,MAAM,YACL,iBAEA,OAAO,IAAI,aAAa;EACvB,MAAM,UAAU,OAAO,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE;EAI7D,MAAM,MACL,aAAa,cAAc,KAAA,KACvB,OAAO,YAAY,aAAa,UAAW,OAAO,QAAQ,GAC3D;EACJ,MAAM,aAAmC,aAAa,UAAU,KAAK,SAAS;GAC7E;GACA,WAAW;GACX,KAAK;GACL,EAAE;AACH,SAAO,IAAI,OAAO,QAAQ,YAAY;GACrC,MAAM,OAAO,IAAI,IAAI,QAAQ;AAC7B,QAAK,MAAM,KAAK,YAAY;IAC3B,MAAM,WAAW,KAAK,IAAI,EAAE,IAAI,IAAI,EAAE;AACtC,SAAK,IAAI,EAAE,KAAK,CAAC,GAAG,UAAU,EAAE,CAAC;;AAElC,UAAO;IACN;AAKF,SAAO,OAAO,cAAc,UAC3B,IAAI,OAAO,QAAQ,YAAY;GAC9B,MAAM,OAAO,IAAI,IAAI,QAAQ;AAC7B,QAAK,MAAM,KAAK,YAAY;IAC3B,MAAM,WAAW,KAAK,IAAI,EAAE,IAAI;AAChC,QAAI,CAAC,SAAU;IACf,MAAM,WAAW,SAAS,QAAQ,MAAM,EAAE,QAAQ,EAAE,IAAI;AACxD,QAAI,SAAS,WAAW,EAAG,MAAK,OAAO,EAAE,IAAI;QACxC,MAAK,IAAI,EAAE,KAAK,SAAS;;AAE/B,UAAO;IACN,CACF;GACA,CAAC,KAAK,OAAO,SAAS,uCAAuC,CAAC;CAEjE,MAAM,WAA6C,OAAO,IAAI,aAAa;EAC1E,MAAM,UAAU,OAAO,IAAI,IAAI,MAAM;AACrC,MAAI,QAAQ,SAAS,EAAG,QAAO;EAC/B,MAAM,sBAAM,IAAI,KAA2B;AAC3C,OAAK,MAAM,CAAC,KAAK,YAAY,SAAS;GAKrC,IAAI,SAA8B;GAClC,IAAI,YAAY;AAChB,QAAK,MAAM,KAAK,QACf,KAAI,EAAE,cAAc,QAAQ,EAAE,MAAM,WAAW;AAC9C,aAAS,EAAE;AACX,gBAAY,EAAE;;AAGhB,OAAI,WAAW,KAAM,KAAI,IAAI,KAAK,OAAO;;AAE1C,SAAO;GACN;CAEF,MAAM,OAA6C,OAAO,IAAI,aAAa;AAE1E,SAAO,CAAC,IAAG,OADY,IAAI,IAAI,MAAM,EAClB,MAAM,CAAC;GACzB;AAEF,QAAO,yBAAyB,GAAG;EAAE;EAAU;EAAU;EAAM,CAAC;EAC/D,CACF"}

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

@@ -0,0 +1,3 @@
+import { RedactionRule, Redactor, RedactorShape, layerRedactor, redactText, redactValue } from "./redaction.mjs";
+import { LogLevel, LogLine, LogPayload, Logger, LoggerShape, TagBuffer } from "./logger.mjs";
+import { ObserveProcessLinesOptions, ObservedProcessLine, ProcessByteStream, ProcessOutputStream, observeProcessLines, readableToByteStream, splitUtf8Lines } from "./process-lines.mjs";

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

@@ -0,0 +1,58 @@
+import { PluginKey } from "../../brand.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/substrate/runtime/observability/logger.d.ts
+/** Closed level set. Mirrors the projection's row.logTail.level
+ *  vocabulary, plus `debug` / `trace` for lifecycle diagnostics that
+ *  should stay in buffers / Effect logs rather than the renderer's
+ *  operator event stream. */
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/** A buffered log line. Plain data; the projection's `Row.logTail`
+ *  derives from this. Structured fields live in `fields` for
+ *  observability consumers that want richer than a string. */
+interface LogLine {
+  readonly tag: string;
+  readonly pluginKey: PluginKey | null;
+  readonly level: LogLevel;
+  readonly message: string;
+  readonly fields: Readonly<Record<string, unknown>>;
+  readonly at: number;
+}
+interface LogPayload {
+  readonly level: LogLevel;
+  readonly message: string;
+  readonly fields?: Readonly<Record<string, unknown>>;
+}
+/** Bounded ring-buffer for a single tag. */
+interface TagBuffer {
+  readonly lines: ReadonlyArray<LogLine>;
+  readonly truncated: boolean;
+}
+/**
+ * Structured per-tag logger. One instance per stack (or per process —
+ * provided via `layerLogger`). Plugins acquire it from Context.
+ *
+ * Discipline:
+ *   - The tag is the only thing the logger discriminates on. It is
+ *     not a service name; it's whatever the publishing fiber picked
+ *     (typically `pluginKey + '/' + sub-tag`).
+ *   - Atomic per-tag writes: `Ref.update` on a `ReadonlyMap` of
+ *     `tag → TagBuffer`. Two fibers logging to the same tag interleave
+ *     by Ref linearization, not by lost updates.
+ *   - Structured fields: anything serializable. The cascade formatter
+ *     (see `cascade-formatter.ts`) renders the fields verbatim.
+ */
+/**
+ * Public shape of the Logger service. Plugins / supervisor depend on
+ * this interface; the concrete Layer below builds an instance.
+ */
+interface LoggerShape {
+  readonly log: (tag: string, pluginKey: PluginKey | null, payload: LogPayload) => Effect.Effect<void>;
+  readonly readTag: (tag: string) => Effect.Effect<TagBuffer>;
+  readonly readAll: Effect.Effect<ReadonlyMap<string, TagBuffer>>;
+  readonly clearTag: (tag: string) => Effect.Effect<void>;
+}
+declare const Logger_base: Context.ServiceClass<Logger$1, "@devstack-rewrite/substrate/Logger", LoggerShape>;
+declare class Logger$1 extends Logger_base {}
+//#endregion
+export { LogLevel, LogLine, LogPayload, Logger$1 as Logger, LoggerShape, TagBuffer };
+//# sourceMappingURL=logger.d.mts.map

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

@@ -0,0 +1,89 @@
+import { SpanAttr } from "./spans.mjs";
+import { Redactor, redactValue } from "./redaction.mjs";
+import { Context, Data, Effect, Layer, Ref } from "effect";
+Data.TaggedError("LoggerError");
+/** Hard cap on a single log line in bytes (UTF-8). Lines past this
+*  are truncated with an ellipsis. */
+const MAX_LINE_BYTES = 16 * 1024;
+var Logger$1 = class extends Context.Service()("@devstack-rewrite/substrate/Logger") {};
+/** Layer that constructs the per-stack Logger. Stateful (holds the
+*  per-tag ring buffers in a Ref); the substrate provides one per
+*  stack-scope. */
+const layerLogger = Layer.effect(Logger$1, Effect.gen(function* () {
+	const redactor = yield* Redactor;
+	const buffers = yield* Ref.make(/* @__PURE__ */ new Map());
+	const truncateLine = (s) => s.length > 16384 ? `${s.slice(0, MAX_LINE_BYTES)}…[truncated]` : s;
+	const appendInternal = (line) => Ref.update(buffers, (map) => {
+		const prev = map.get(line.tag) ?? {
+			lines: [],
+			truncated: false
+		};
+		const nextLines = [...prev.lines, line];
+		const overflow = nextLines.length > 100;
+		const trimmed = overflow ? nextLines.slice(-100) : nextLines;
+		const nextMap = new Map(map);
+		nextMap.set(line.tag, {
+			lines: trimmed,
+			truncated: prev.truncated || overflow
+		});
+		return nextMap;
+	});
+	/** Log a line under `tag`. Atomic per-tag. */
+	const log = Effect.fn("Logger.log")(function* (tag, pluginKey, payload) {
+		const redactionRules = yield* redactor.rules;
+		const line = {
+			tag,
+			pluginKey,
+			level: payload.level,
+			message: truncateLine(yield* redactor.redact(payload.message)),
+			fields: redactValue(payload.fields ?? {}, redactionRules),
+			at: Date.now()
+		};
+		yield* appendInternal(line);
+		yield* logViaEffect(line);
+	});
+	/** Read the current snapshot of a single tag's buffer. Used by
+	*  the projection updater when a row is created mid-stack. */
+	const readTag = (tag) => Ref.get(buffers).pipe(Effect.map((map) => map.get(tag) ?? {
+		lines: [],
+		truncated: false
+	}));
+	/** Read every tag's current snapshot. Used by snapshot capture
+	*  + diagnostics. Bounded by aggregate retention. */
+	const readAll = Ref.get(buffers);
+	/** Drop the buffer for a tag. Used when a plugin row is removed. */
+	const clearTag = (tag) => Ref.update(buffers, (map) => {
+		if (!map.has(tag)) return map;
+		const next = new Map(map);
+		next.delete(tag);
+		return next;
+	});
+	return Logger$1.of({
+		log,
+		readTag,
+		readAll,
+		clearTag
+	});
+}));
+const logViaEffect = (line) => {
+	const annotated = Effect.annotateLogs({
+		[SpanAttr.logTag]: line.tag,
+		[SpanAttr.plugin]: line.pluginKey ?? "(none)",
+		...line.fields
+	});
+	switch (line.level) {
+		case "trace": return Effect.logTrace(line.message).pipe(annotated);
+		case "debug": return Effect.logDebug(line.message).pipe(annotated);
+		case "info": return Effect.logInfo(line.message).pipe(annotated);
+		case "warn": return Effect.logWarning(line.message).pipe(annotated);
+		case "error": return Effect.logError(line.message).pipe(annotated);
+		case "fatal": return Effect.logFatal(line.message).pipe(annotated);
+		default:
+			line.level;
+			return Effect.void;
+	}
+};
+//#endregion
+export { Logger$1 as Logger, layerLogger };
+
+//# sourceMappingURL=logger.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":["Logger"],"sources":["../../../../src/substrate/runtime/observability/logger.ts"],"sourcesContent":["// Structured per-tag log buffer.\n//\n// Architecture § L0 Observability primitives: \"structured log buffer,\n// span/annotation conventions, cause walker (shared with renderers,\n// not duplicated)\".\n//\n// Replaces the ad-hoc `appendTagLog` shape on the legacy `EngineHandle`\n// with a typed Service. Plugins acquire a `Logger` and publish lines;\n// the substrate keeps each line in a bounded per-tag ring buffer and\n// mirrors it into Effect's structured logging via `Effect.log*`.\n// Operator-level lines are also projected into the typed event stream\n// by the supervisor wrapper.\n//\n// Per-tag atomicity is guaranteed by `Ref.update` on the per-tag\n// buffer — single-fiber updates are linearizable and the buffer\n// reads are snapshot-consistent. Cross-process atomicity (when the\n// same log lands in two devstack processes via a shared file)\n// is delegated to the cross-process lock primitive in\n// `../cross-process-lock.ts`.\n\nimport { Context, Effect, Layer, Ref } from 'effect';\nimport { Data } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport { Redactor, redactValue } from './redaction.ts';\nimport { SpanAttr } from './spans.ts';\n\n// -----------------------------------------------------------------------------\n// Errors\n// -----------------------------------------------------------------------------\n\n/** Single tagged error class for every logger failure mode.\n *\n *  The architecture says service-specific errors do NOT live in L0\n *  (§ L0). `LoggerError` is engine-level — the only failure modes are\n *  buffer-write contention (defected up) and over-large lines that\n *  the bounded buffer refused to truncate. */\nexport class LoggerError extends Data.TaggedError('LoggerError')<{\n\treadonly reason: 'buffer-write-failed' | 'line-too-large';\n\treadonly tag: string;\n\treadonly cause?: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Public types\n// -----------------------------------------------------------------------------\n\n/** Closed level set. Mirrors the projection's row.logTail.level\n *  vocabulary, plus `debug` / `trace` for lifecycle diagnostics that\n *  should stay in buffers / Effect logs rather than the renderer's\n *  operator event stream. */\nexport type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';\n\n/** A buffered log line. Plain data; the projection's `Row.logTail`\n *  derives from this. Structured fields live in `fields` for\n *  observability consumers that want richer than a string. */\nexport interface LogLine {\n\treadonly tag: string;\n\treadonly pluginKey: PluginKey | null;\n\treadonly level: LogLevel;\n\treadonly message: string;\n\treadonly fields: Readonly<Record<string, unknown>>;\n\treadonly at: number;\n}\n\nexport interface LogPayload {\n\treadonly level: LogLevel;\n\treadonly message: string;\n\treadonly fields?: Readonly<Record<string, unknown>>;\n}\n\n/** Bounded ring-buffer for a single tag. */\nexport interface TagBuffer {\n\treadonly lines: ReadonlyArray<LogLine>;\n\treadonly truncated: boolean;\n}\n\n// -----------------------------------------------------------------------------\n// Capacity policy\n// -----------------------------------------------------------------------------\n\n/** Per-tag retention. Matches the projection's\n *  `MAX_ROW_LOG_LINES` default. */\nexport const DEFAULT_MAX_LINES_PER_TAG = 100;\n\n/** Hard cap on a single log line in bytes (UTF-8). Lines past this\n *  are truncated with an ellipsis. */\nexport const MAX_LINE_BYTES = 16 * 1024;\n\n// -----------------------------------------------------------------------------\n// Logger service\n// -----------------------------------------------------------------------------\n\n/**\n * Structured per-tag logger. One instance per stack (or per process —\n * provided via `layerLogger`). Plugins acquire it from Context.\n *\n * Discipline:\n *   - The tag is the only thing the logger discriminates on. It is\n *     not a service name; it's whatever the publishing fiber picked\n *     (typically `pluginKey + '/' + sub-tag`).\n *   - Atomic per-tag writes: `Ref.update` on a `ReadonlyMap` of\n *     `tag → TagBuffer`. Two fibers logging to the same tag interleave\n *     by Ref linearization, not by lost updates.\n *   - Structured fields: anything serializable. The cascade formatter\n *     (see `cascade-formatter.ts`) renders the fields verbatim.\n */\n/**\n * Public shape of the Logger service. Plugins / supervisor depend on\n * this interface; the concrete Layer below builds an instance.\n */\nexport interface LoggerShape {\n\treadonly log: (\n\t\ttag: string,\n\t\tpluginKey: PluginKey | null,\n\t\tpayload: LogPayload,\n\t) => Effect.Effect<void>;\n\treadonly readTag: (tag: string) => Effect.Effect<TagBuffer>;\n\treadonly readAll: Effect.Effect<ReadonlyMap<string, TagBuffer>>;\n\treadonly clearTag: (tag: string) => Effect.Effect<void>;\n}\n\nexport class Logger extends Context.Service<Logger, LoggerShape>()(\n\t'@devstack-rewrite/substrate/Logger',\n) {}\n\n/** Layer that constructs the per-stack Logger. Stateful (holds the\n *  per-tag ring buffers in a Ref); the substrate provides one per\n *  stack-scope. */\nexport const layerLogger: Layer.Layer<Logger, never, Redactor> = Layer.effect(\n\tLogger,\n\tEffect.gen(function* () {\n\t\tconst redactor = yield* Redactor;\n\t\tconst buffers = yield* Ref.make<ReadonlyMap<string, TagBuffer>>(new Map());\n\n\t\tconst truncateLine = (s: string): string =>\n\t\t\ts.length > MAX_LINE_BYTES ? `${s.slice(0, MAX_LINE_BYTES)}…[truncated]` : s;\n\n\t\tconst appendInternal = (line: LogLine): Effect.Effect<void> =>\n\t\t\tRef.update(buffers, (map) => {\n\t\t\t\tconst prev = map.get(line.tag) ?? { lines: [], truncated: false };\n\t\t\t\tconst nextLines = [...prev.lines, line];\n\t\t\t\tconst overflow = nextLines.length > DEFAULT_MAX_LINES_PER_TAG;\n\t\t\t\tconst trimmed = overflow ? nextLines.slice(-DEFAULT_MAX_LINES_PER_TAG) : nextLines;\n\t\t\t\tconst nextMap = new Map(map);\n\t\t\t\tnextMap.set(line.tag, { lines: trimmed, truncated: prev.truncated || overflow });\n\t\t\t\treturn nextMap;\n\t\t\t});\n\n\t\t/** Log a line under `tag`. Atomic per-tag. */\n\t\tconst log = Effect.fn('Logger.log')(function* (\n\t\t\ttag: string,\n\t\t\tpluginKey: PluginKey | null,\n\t\t\tpayload: LogPayload,\n\t\t) {\n\t\t\tconst redactionRules = yield* redactor.rules;\n\t\t\tconst line: LogLine = {\n\t\t\t\ttag,\n\t\t\t\tpluginKey,\n\t\t\t\tlevel: payload.level,\n\t\t\t\tmessage: truncateLine(yield* redactor.redact(payload.message)),\n\t\t\t\tfields: redactValue(payload.fields ?? {}, redactionRules) as Readonly<\n\t\t\t\t\tRecord<string, unknown>\n\t\t\t\t>,\n\t\t\t\tat: Date.now(),\n\t\t\t};\n\t\t\tyield* appendInternal(line);\n\t\t\t// Mirror to Effect's structured logger so OTEL exporters see\n\t\t\t// the line too. The bounded buffer is the renderer-facing\n\t\t\t// surface; Effect's logger is the observability-pipeline\n\t\t\t// surface.\n\t\t\tyield* logViaEffect(line);\n\t\t});\n\n\t\t/** Read the current snapshot of a single tag's buffer. Used by\n\t\t *  the projection updater when a row is created mid-stack. */\n\t\tconst readTag = (tag: string): Effect.Effect<TagBuffer> =>\n\t\t\tRef.get(buffers).pipe(Effect.map((map) => map.get(tag) ?? { lines: [], truncated: false }));\n\n\t\t/** Read every tag's current snapshot. Used by snapshot capture\n\t\t *  + diagnostics. Bounded by aggregate retention. */\n\t\tconst readAll = Ref.get(buffers);\n\n\t\t/** Drop the buffer for a tag. Used when a plugin row is removed. */\n\t\tconst clearTag = (tag: string): Effect.Effect<void> =>\n\t\t\tRef.update(buffers, (map) => {\n\t\t\t\tif (!map.has(tag)) return map;\n\t\t\t\tconst next = new Map(map);\n\t\t\t\tnext.delete(tag);\n\t\t\t\treturn next;\n\t\t\t});\n\n\t\treturn Logger.of({ log, readTag, readAll, clearTag });\n\t}),\n);\n\n// -----------------------------------------------------------------------------\n// Effect-logger bridge\n// -----------------------------------------------------------------------------\n\nconst logViaEffect = (line: LogLine): Effect.Effect<void> => {\n\tconst annotated = Effect.annotateLogs({\n\t\t[SpanAttr.logTag]: line.tag,\n\t\t[SpanAttr.plugin]: line.pluginKey ?? '(none)',\n\t\t...line.fields,\n\t});\n\tswitch (line.level) {\n\t\tcase 'trace':\n\t\t\treturn Effect.logTrace(line.message).pipe(annotated);\n\t\tcase 'debug':\n\t\t\treturn Effect.logDebug(line.message).pipe(annotated);\n\t\tcase 'info':\n\t\t\treturn Effect.logInfo(line.message).pipe(annotated);\n\t\tcase 'warn':\n\t\t\treturn Effect.logWarning(line.message).pipe(annotated);\n\t\tcase 'error':\n\t\t\treturn Effect.logError(line.message).pipe(annotated);\n\t\tcase 'fatal':\n\t\t\treturn Effect.logFatal(line.message).pipe(annotated);\n\t\tdefault: {\n\t\t\tconst _exhaustive: never = line.level;\n\t\t\tvoid _exhaustive;\n\t\t\treturn Effect.void;\n\t\t}\n\t}\n};\n"],"mappings":";;;AAqCiC,KAAK,YAAY,cAAc;;;AAkDhE,MAAa,iBAAiB,KAAK;AAmCnC,IAAaA,WAAb,cAA4B,QAAQ,SAA8B,CACjE,qCACA,CAAC;;;;AAKF,MAAa,cAAoD,MAAM,OACtEA,UACA,OAAO,IAAI,aAAa;CACvB,MAAM,WAAW,OAAO;CACxB,MAAM,UAAU,OAAO,IAAI,qBAAqC,IAAI,KAAK,CAAC;CAE1E,MAAM,gBAAgB,MACrB,EAAE,SAAA,QAA0B,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC,gBAAgB;CAE3E,MAAM,kBAAkB,SACvB,IAAI,OAAO,UAAU,QAAQ;EAC5B,MAAM,OAAO,IAAI,IAAI,KAAK,IAAI,IAAI;GAAE,OAAO,EAAE;GAAE,WAAW;GAAO;EACjE,MAAM,YAAY,CAAC,GAAG,KAAK,OAAO,KAAK;EACvC,MAAM,WAAW,UAAU,SAAA;EAC3B,MAAM,UAAU,WAAW,UAAU,MAAM,KAA2B,GAAG;EACzE,MAAM,UAAU,IAAI,IAAI,IAAI;AAC5B,UAAQ,IAAI,KAAK,KAAK;GAAE,OAAO;GAAS,WAAW,KAAK,aAAa;GAAU,CAAC;AAChF,SAAO;GACN;;CAGH,MAAM,MAAM,OAAO,GAAG,aAAa,CAAC,WACnC,KACA,WACA,SACC;EACD,MAAM,iBAAiB,OAAO,SAAS;EACvC,MAAM,OAAgB;GACrB;GACA;GACA,OAAO,QAAQ;GACf,SAAS,aAAa,OAAO,SAAS,OAAO,QAAQ,QAAQ,CAAC;GAC9D,QAAQ,YAAY,QAAQ,UAAU,EAAE,EAAE,eAAe;GAGzD,IAAI,KAAK,KAAK;GACd;AACD,SAAO,eAAe,KAAK;AAK3B,SAAO,aAAa,KAAK;GACxB;;;CAIF,MAAM,WAAW,QAChB,IAAI,IAAI,QAAQ,CAAC,KAAK,OAAO,KAAK,QAAQ,IAAI,IAAI,IAAI,IAAI;EAAE,OAAO,EAAE;EAAE,WAAW;EAAO,CAAC,CAAC;;;CAI5F,MAAM,UAAU,IAAI,IAAI,QAAQ;;CAGhC,MAAM,YAAY,QACjB,IAAI,OAAO,UAAU,QAAQ;AAC5B,MAAI,CAAC,IAAI,IAAI,IAAI,CAAE,QAAO;EAC1B,MAAM,OAAO,IAAI,IAAI,IAAI;AACzB,OAAK,OAAO,IAAI;AAChB,SAAO;GACN;AAEH,QAAOA,SAAO,GAAG;EAAE;EAAK;EAAS;EAAS;EAAU,CAAC;EACpD,CACF;AAMD,MAAM,gBAAgB,SAAuC;CAC5D,MAAM,YAAY,OAAO,aAAa;GACpC,SAAS,SAAS,KAAK;GACvB,SAAS,SAAS,KAAK,aAAa;EACrC,GAAG,KAAK;EACR,CAAC;AACF,SAAQ,KAAK,OAAb;EACC,KAAK,QACJ,QAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,KAAK,UAAU;EACrD,KAAK,QACJ,QAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,KAAK,UAAU;EACrD,KAAK,OACJ,QAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC,KAAK,UAAU;EACpD,KAAK,OACJ,QAAO,OAAO,WAAW,KAAK,QAAQ,CAAC,KAAK,UAAU;EACvD,KAAK,QACJ,QAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,KAAK,UAAU;EACrD,KAAK,QACJ,QAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,KAAK,UAAU;EACrD;AAC4B,QAAK;AAEhC,UAAO,OAAO"}

package/dist/substrate/runtime/observability/pretty-error.d.mts

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