@mysten-incubation/devstack 0.0.1 → 0.1.0

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

@@ -1 +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"}
+{"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, Scope } from 'effect';\n\nimport type { PluginErrorContribution } from '../../plugin.ts';\nimport { makeScopedMultimap } from '../scoped-multimap/index.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/substrate/FormatterRegistry') {}\n\n/** Layer constructing the per-stack formatter registry. Stateful;\n *  the substrate provides one per supervisor scope.\n *\n *  Storage is the shared scoped-multimap keyed by tag. The per-entry\n *  value is the (optional) formatter — the registry may track a tag\n *  with NO formatter (default rendering is enough), so `null` is a\n *  legitimate value and the seq still tracks the registration. */\nexport const layerFormatterRegistry: Layer.Layer<FormatterRegistryService> = Layer.effect(\n\tFormatterRegistryService,\n\tEffect.gen(function* () {\n\t\tconst store = yield* makeScopedMultimap<string, TagFormatter | null>();\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\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\t// One entry per declared tag, all sharing the multimap's\n\t\t\t\t// seq + finalizer — parallel plugin registrations stay\n\t\t\t\t// isolated and only drop what they added.\n\t\t\t\tyield* store.register(contribution.errorTags.map((tag) => ({ key: tag, value: fmt })));\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* store.snapshot;\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.value !== null && e.seq > chosenSeq) {\n\t\t\t\t\t\tchosen = e.value;\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>> = store.keys;\n\n\t\treturn FormatterRegistryService.of({ register, snapshot, tags });\n\t}),\n);\n"],"mappings":";;;;;AAgDA,IAAa,2BAAb,cAA8C,QAAQ,SAGnD,CAAC,wCAAwC,CAAC;;;;;;;;AAS7C,MAAa,yBAAgE,MAAM,OAClF,0BACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO,oBAAiD;CAEtE,MAAM,YACL,iBAEA,OAAO,IAAI,aAAa;EAIvB,MAAM,MACL,aAAa,cAAc,KAAA,KACvB,OAAO,YAAY,aAAa,UAAW,OAAO,QAAQ,GAC3D;AAIJ,SAAO,MAAM,SAAS,aAAa,UAAU,KAAK,SAAS;GAAE,KAAK;GAAK,OAAO;GAAK,EAAE,CAAC;GACrF,CAAC,KAAK,OAAO,SAAS,uCAAuC,CAAC;CAEjE,MAAM,WAA6C,OAAO,IAAI,aAAa;EAC1E,MAAM,UAAU,OAAO,MAAM;AAC7B,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,UAAU,QAAQ,EAAE,MAAM,WAAW;AAC1C,aAAS,EAAE;AACX,gBAAY,EAAE;;AAGhB,OAAI,WAAW,KAAM,KAAI,IAAI,KAAK,OAAO;;AAE1C,SAAO;GACN;CAEF,MAAM,OAA6C,MAAM;AAEzD,QAAO,yBAAyB,GAAG;EAAE;EAAU;EAAU;EAAM,CAAC;EAC/D,CACF"}

package/dist/substrate/runtime/observability/ignore-with-log.d.mts

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

package/dist/substrate/runtime/observability/ignore-with-log.mjs

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+//#region src/substrate/runtime/observability/ignore-with-log.ts
+const mergeAttrs = (attrs, cause) => attrs === void 0 ? { cause } : {
+	...attrs,
+	cause
+};
+/** Tap the cause through `Effect.logWarning`, then collapse to `void`.
+*  For best-effort cleanup that COULD indicate a real leak / drop. */
+const logWarningAndIgnore = (message, attrs) => (self) => self.pipe(Effect.tapCause((cause) => Effect.logWarning(message, mergeAttrs(attrs, cause))), Effect.ignore);
+/** Tap the cause through `Effect.logDebug`, then catch into a fallback
+*  value. For diagnostic-only failures whose downstream call needs a
+*  concrete value (e.g. roster read collapses to empty live-pid set). */
+const logDebugAndFallback = (fallback, message, attrs) => (self) => self.pipe(Effect.tapCause((cause) => Effect.logDebug(message, mergeAttrs(attrs, cause))), Effect.catch(() => Effect.succeed(fallback)));
+//#endregion
+export { logDebugAndFallback, logWarningAndIgnore };
+
+//# sourceMappingURL=ignore-with-log.mjs.map

package/dist/substrate/runtime/observability/ignore-with-log.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore-with-log.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/ignore-with-log.ts"],"sourcesContent":["// Best-effort with diagnostic breadcrumb — pipe-fn helpers.\n//\n// STYLE_GUIDE §18 calls out the \"best-effort cleanup must still leave\n// a visible breadcrumb\" rule:\n//\n//   `.pipe(Effect.ignore)` on a best-effort effect silently swallows\n//   the failure. Cleanup paths (router scope-close, lifecycle-prune\n//   roster reads, faucet warm-up retries) tolerate the failure but\n//   must NOT lose the cause — the cause has to land in the log\n//   stream so a leaked dispatch file / stale roster / dead faucet\n//   doesn't go silent.\n//\n// Two surfaces:\n//\n//   - `logWarningAndIgnore(message, attrs?)` — for failures that\n//     COULD indicate a real problem (a scope-close cleanup that\n//     could leak a file, contention on a lock we expected to hold)\n//     but which the local call site can't act on. Routes the cause\n//     through `Effect.logWarning` so it appears in operator output.\n//   - `logDebugAndFallback(fallback, message, attrs?)` — for\n//     diagnostic-only failures whose downstream call needs a concrete\n//     fallback value (e.g. roster read collapses to empty live-pid).\n//\n// Both helpers use `Effect.tapCause` so the full Cause (defects,\n// interruptions, error stacks) is preserved in the `cause` log\n// annotation; the underlying `Effect.ignore` / `Effect.catch` then\n// erases the error channel.\n\nimport { Effect } from 'effect';\n\ntype LogAttrs = Readonly<Record<string, unknown>>;\n\nconst mergeAttrs = (attrs: LogAttrs | undefined, cause: unknown): LogAttrs =>\n\tattrs === undefined ? { cause } : { ...attrs, cause };\n\n/** Tap the cause through `Effect.logWarning`, then collapse to `void`.\n *  For best-effort cleanup that COULD indicate a real leak / drop. */\nexport const logWarningAndIgnore =\n\t(message: string, attrs?: LogAttrs) =>\n\t<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, never, R> =>\n\t\tself.pipe(\n\t\t\tEffect.tapCause((cause) => Effect.logWarning(message, mergeAttrs(attrs, cause))),\n\t\t\tEffect.ignore,\n\t\t);\n\n/** Tap the cause through `Effect.logDebug`, then catch into a fallback\n *  value. For diagnostic-only failures whose downstream call needs a\n *  concrete value (e.g. roster read collapses to empty live-pid set). */\nexport const logDebugAndFallback =\n\t<F>(fallback: F, message: string, attrs?: LogAttrs) =>\n\t<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A | F, never, R> =>\n\t\tself.pipe(\n\t\t\tEffect.tapCause((cause) => Effect.logDebug(message, mergeAttrs(attrs, cause))),\n\t\t\tEffect.catch(() => Effect.succeed(fallback)),\n\t\t);\n"],"mappings":";;AAgCA,MAAM,cAAc,OAA6B,UAChD,UAAU,KAAA,IAAY,EAAE,OAAO,GAAG;CAAE,GAAG;CAAO;CAAO;;;AAItD,MAAa,uBACX,SAAiB,WACR,SACT,KAAK,KACJ,OAAO,UAAU,UAAU,OAAO,WAAW,SAAS,WAAW,OAAO,MAAM,CAAC,CAAC,EAChF,OAAO,OACP;;;;AAKH,MAAa,uBACR,UAAa,SAAiB,WACxB,SACT,KAAK,KACJ,OAAO,UAAU,UAAU,OAAO,SAAS,SAAS,WAAW,OAAO,MAAM,CAAC,CAAC,EAC9E,OAAO,YAAY,OAAO,QAAQ,SAAS,CAAC,CAC5C"}

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

@@ -1,3 +1,3 @@
-import { RedactionRule, Redactor, RedactorShape, layerRedactor, redactText, redactValue } from "./redaction.mjs";
+import { RedactionRule, 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/index.mjs

@@ -0,0 +1,13 @@
+import "./spans.mjs";
+import "./redaction.mjs";
+import "./cascade-formatter.mjs";
+import "./formatter-registry.mjs";
+import "./ignore-with-log.mjs";
+import "./logger.mjs";
+import "./log-store.mjs";
+import "./span-store.mjs";
+import "./pretty-error.mjs";
+import "./process-lines.mjs";
+import "./subprocess-capture.mjs";
+import "./output-truncate.mjs";
+export {};

package/dist/substrate/runtime/observability/log-store.d.mts

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

package/dist/substrate/runtime/observability/log-store.mjs

@@ -0,0 +1,175 @@
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/substrate/runtime/observability/log-store.ts
+/** Per-service retention. Each service ring keeps at most this many records;
+*  a chatty service evicts only its own oldest lines. */
+const DEFAULT_PER_SERVICE_CAPACITY = 2e3;
+/** Env-var names for zero-config tuning. Read once when `makeLogStore` is
+*  called with no explicit config (the supervisor wiring site). Non-numeric
+*  or non-positive values fall back to the defaults. */
+const ENV_PER_SERVICE_CAPACITY = "DEVSTACK_DASHBOARD_LOG_CAPACITY";
+const ENV_MAX_SERVICES = "DEVSTACK_DASHBOARD_LOG_MAX_SERVICES";
+const positiveIntOr = (raw, fallback) => {
+	if (raw === void 0) return fallback;
+	const n = Number(raw);
+	return Number.isFinite(n) && n >= 1 ? Math.floor(n) : fallback;
+};
+/** Resolve the effective config: explicit options win, then env vars, then
+*  module defaults. Pure given an `env` bag (defaults to `process.env`). */
+const resolveLogStoreConfig = (config = {}, env = process.env) => ({
+	perServiceCapacity: config.perServiceCapacity !== void 0 && config.perServiceCapacity >= 1 ? Math.floor(config.perServiceCapacity) : positiveIntOr(env[ENV_PER_SERVICE_CAPACITY], DEFAULT_PER_SERVICE_CAPACITY),
+	maxServices: config.maxServices !== void 0 && config.maxServices >= 1 ? Math.floor(config.maxServices) : positiveIntOr(env[ENV_MAX_SERVICES], 256)
+});
+var LogStore = class extends Context.Service()("@devstack/substrate/LogStore") {};
+const isErrorLevel = (level) => level === "error" || level === "fatal";
+/** Choose which service ring to evict when `maxServices` is reached and a new
+*  service appears. Policy (documented in the file header):
+*    1. Prefer to RETAIN rings that hold an `error`/`fatal` record — never
+*       drop a crashed/quiet service's only error trail while a chatty
+*       all-`info` ring exists. So victims are drawn from the error-free
+*       rings first; only if EVERY ring carries an error do we consider
+*       error-bearing ones.
+*    2. Within the candidate pool, evict the ring whose NEWEST record is
+*       oldest (LRU on most-recent activity) — the least recently active
+*       service. Ties broken by lowest newest-seq.
+*  Returns the service key to drop, or null when there are no rings. */
+const pickEvictionVictim = (rings) => {
+	let victim = null;
+	let victimNewestMillis = Number.POSITIVE_INFINITY;
+	let victimNewestSeq = Number.POSITIVE_INFINITY;
+	let victimHasError = true;
+	for (const [service, ring] of rings) {
+		const newest = ring.records[ring.records.length - 1];
+		const newestMillis = newest?.timestampMillis ?? Number.NEGATIVE_INFINITY;
+		const newestSeq = newest?.seq ?? Number.NEGATIVE_INFINITY;
+		const hasError = ring.hasError;
+		if (victimHasError && !hasError) {
+			victim = service;
+			victimNewestMillis = newestMillis;
+			victimNewestSeq = newestSeq;
+			victimHasError = hasError;
+			continue;
+		}
+		if (!victimHasError && hasError) continue;
+		if (newestMillis < victimNewestMillis || newestMillis === victimNewestMillis && newestSeq < victimNewestSeq) {
+			victim = service;
+			victimNewestMillis = newestMillis;
+			victimNewestSeq = newestSeq;
+			victimHasError = hasError;
+		}
+	}
+	return victim;
+};
+/** Build a `LogStoreShape` over a freshly-created `Ref`. The supervisor calls
+*  this (not the Layer) so the rings are process-scoped alongside the
+*  projection ref. `config` is injectable for tests; with no `config` the
+*  env-var defaults apply. */
+const makeLogStore = (config = {}) => Effect.gen(function* () {
+	const { perServiceCapacity, maxServices } = resolveLogStoreConfig(config);
+	const ref = yield* Ref.make({
+		rings: /* @__PURE__ */ new Map(),
+		nextSeq: 0
+	});
+	const append = (record) => Ref.update(ref, (state) => {
+		const next = {
+			seq: state.nextSeq,
+			timestampMillis: record.timestampMillis ?? Date.now(),
+			level: record.level,
+			service: record.service,
+			message: record.message,
+			fields: record.fields ?? {}
+		};
+		const rings = new Map(state.rings);
+		const existing = rings.get(record.service);
+		if (existing === void 0) {
+			if (rings.size >= maxServices) {
+				const victim = pickEvictionVictim(rings);
+				if (victim !== null) rings.delete(victim);
+			}
+			rings.set(record.service, {
+				records: [next],
+				hasError: isErrorLevel(next.level)
+			});
+		} else {
+			const merged = [...existing.records, next];
+			const trimmed = merged.length > perServiceCapacity ? merged.slice(-perServiceCapacity) : merged;
+			const hasError = trimmed.length < merged.length ? trimmed.some((r) => isErrorLevel(r.level)) : existing.hasError || isErrorLevel(next.level);
+			rings.set(record.service, {
+				records: trimmed,
+				hasError
+			});
+		}
+		return {
+			rings,
+			nextSeq: state.nextSeq + 1
+		};
+	});
+	const query = (filter) => Ref.get(ref).pipe(Effect.map((state) => queryRings(state.rings, filter, perServiceCapacity)));
+	const services = Ref.get(ref).pipe(Effect.map((state) => [...state.rings.keys()].sort()));
+	return LogStore.of({
+		append,
+		query,
+		services
+	});
+});
+const compileFilter = (filter, defaultLimit) => {
+	const search = filter?.search?.trim().toLowerCase();
+	return {
+		serviceSet: filter?.services && filter.services.length > 0 ? new Set(filter.services) : null,
+		levelSet: filter?.levels && filter.levels.length > 0 ? new Set(filter.levels) : null,
+		search: search !== void 0 && search.length > 0 ? search : null,
+		since: filter?.sinceMillis,
+		limit: filter?.limit ?? defaultLimit
+	};
+};
+const matches = (r, f) => {
+	if (f.serviceSet !== null && !f.serviceSet.has(r.service)) return false;
+	if (f.levelSet !== null && !f.levelSet.has(r.level)) return false;
+	if (f.since !== void 0 && r.timestampMillis < f.since) return false;
+	if (f.search !== null && !r.message.toLowerCase().includes(f.search) && !r.service.toLowerCase().includes(f.search)) return false;
+	return true;
+};
+/** Merge all per-service rings into a single newest-first result. Each ring
+*  is oldest-first, so we run a k-way merge from the tail of each ring,
+*  emitting the globally-highest `seq` first and stopping once `limit` is
+*  filled. This is O(matched-prefix × ringCount) without materializing the
+*  whole universe — important when `limit` is small relative to total volume.
+*  Exported for tests. */
+const queryRings = (rings, filter, perServiceCapacity) => {
+	const f = compileFilter(filter, perServiceCapacity * Math.max(rings.size, 1));
+	if (f.limit <= 0) return [];
+	const arrays = [];
+	const cursors = [];
+	for (const ring of rings.values()) if (ring.records.length > 0) {
+		arrays.push(ring.records);
+		cursors.push(ring.records.length - 1);
+	}
+	const out = [];
+	while (out.length < f.limit) {
+		let bestRing = -1;
+		let bestSeq = Number.NEGATIVE_INFINITY;
+		for (let k = 0; k < arrays.length; k += 1) {
+			const c = cursors[k];
+			if (c < 0) continue;
+			const seq = arrays[k][c].seq;
+			if (seq > bestSeq) {
+				bestSeq = seq;
+				bestRing = k;
+			}
+		}
+		if (bestRing === -1) break;
+		const c = cursors[bestRing];
+		const r = arrays[bestRing][c];
+		cursors[bestRing] = c - 1;
+		if (matches(r, f)) out.push(r);
+	}
+	return out;
+};
+Layer.effect(LogStore, makeLogStore());
+/** Coerce an arbitrary `pluginKey` (the upstream `Logger.log` tag carries an
+*  optional `PluginKey`) to the store's `service` string, falling back to the
+*  bare log tag when no plugin key is present. */
+const serviceKeyFor = (tag, pluginKey) => pluginKey === null ? tag : String(pluginKey);
+//#endregion
+export { DEFAULT_PER_SERVICE_CAPACITY, ENV_MAX_SERVICES, ENV_PER_SERVICE_CAPACITY, LogStore, makeLogStore, pickEvictionVictim, queryRings, resolveLogStoreConfig, serviceKeyFor };
+
+//# sourceMappingURL=log-store.mjs.map

package/dist/substrate/runtime/observability/log-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-store.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/log-store.ts"],"sourcesContent":["// Cross-service queryable log store.\n//\n// The `Logger` service (logger.ts) keeps a bounded PER-TAG ring buffer that\n// feeds the projection's per-row `logTail`. That surface is renderer-facing:\n// one short tail per plugin row, no cross-service merge, no history, no\n// server-side level/source filtering. The dashboard's Console \"Logs\" tab\n// needs the opposite shape — a single append-only, cross-service stream the\n// browser can filter by service / level / substring / time window.\n//\n// This store is that second surface. It is fed from the SAME source as the\n// projection tail (the supervisor's `withEventPublishingLogger` wrapper taps\n// every `Logger.log` call into here), so we do NOT double-spawn log readers\n// or re-capture container output: there is one log-production path\n// (`Logger.log`) and two consumers hang off it.\n//\n// Shape: ONE BOUNDED RING PER SERVICE, keyed by the `service` string, plus a\n// shared monotonic `seq` counter so cross-service queries order correctly.\n// A single global ring (the previous design) let a chatty service evict\n// everyone else — a crash loop spamming retries would push a quiet service's\n// only error line out of the buffer before anyone could read it. Per-service\n// rings give every service an independent retention window: a noisy service\n// can only ever evict ITS OWN old lines.\n//\n// To keep total memory bounded under an unbounded set of distinct service\n// keys, the number of rings is capped (`maxServices`). When that cap is hit\n// and a brand-new service appears, one existing ring is evicted. Eviction is\n// ERROR-AWARE: rings that contain an `error`/`fatal` record are preferred for\n// RETENTION, so a crashed service's error trail is the last thing dropped.\n// Among equally-(un)important rings we evict the one whose NEWEST record is\n// oldest (LRU on most-recent activity). See `pickEvictionVictim`.\n//\n// Process-scoped — the backing `Ref` is created in the supervisor alongside\n// `hub`/`commands`, so it survives `stack.restart` (only `cycle.id` bumps)\n// exactly like the projection ref.\n//\n// Hot-path discipline: append is a single `Ref.update` that pushes onto the\n// target service's array and trims when it overflows. No I/O, no redaction\n// (the upstream `Logger.log` already redacted the message + fields before\n// calling here). Ring eviction only runs on the FIRST sight of a new service\n// once the cap is reached — not per-append.\n\nimport { Context, Effect, Layer, Ref } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { LogLevel } from './logger.ts';\n\n// -----------------------------------------------------------------------------\n// Record shape\n// -----------------------------------------------------------------------------\n\n/** One queryable, cross-service log record. Plain data — the dashboard\n *  schema projects this directly. `service` is the resource/plugin key the\n *  line was logged under (or the bare tag when no plugin key was attached,\n *  e.g. the supervisor's own lines). */\nexport interface LogRecord {\n\t/** Monotonic per-process sequence. Stable cursor for the dashboard. */\n\treadonly seq: number;\n\treadonly timestampMillis: number;\n\treadonly level: LogLevel;\n\t/** Resource/plugin key (`postgres`, `deepbook/SUI_USDC`, …) or the bare\n\t *  log tag when the line carried no plugin key. */\n\treadonly service: string;\n\treadonly message: string;\n\t/** Structured fields (already redacted upstream). */\n\treadonly fields: Readonly<Record<string, unknown>>;\n}\n\n/** Filter applied server-side before the records cross to the browser. Every\n *  field is optional; an absent field means \"don't constrain on this axis\". */\nexport interface LogFilter {\n\t/** Keep only records whose `service` is in this set (exact match). */\n\treadonly services?: ReadonlyArray<string>;\n\t/** Keep only records at one of these levels. */\n\treadonly levels?: ReadonlyArray<LogLevel>;\n\t/** Case-insensitive substring match against the message (and service). */\n\treadonly search?: string;\n\t/** Keep only records at/after this epoch-ms. */\n\treadonly sinceMillis?: number;\n\t/** Cap on returned records (most recent first). Defaults to the merged\n\t *  capacity (perServiceCapacity × maxServices). */\n\treadonly limit?: number;\n}\n\n// -----------------------------------------------------------------------------\n// Capacity policy\n// -----------------------------------------------------------------------------\n\n/** Per-service retention. Each service ring keeps at most this many records;\n *  a chatty service evicts only its own oldest lines. */\nexport const DEFAULT_PER_SERVICE_CAPACITY = 2000;\n\n/** Max distinct service rings kept simultaneously. Caps total memory at\n *  `perServiceCapacity × maxServices` records. When exceeded, one ring is\n *  evicted (error-bearing rings preferred for retention — see\n *  `pickEvictionVictim`). */\nexport const DEFAULT_MAX_SERVICES = 256;\n\n/** Env-var names for zero-config tuning. Read once when `makeLogStore` is\n *  called with no explicit config (the supervisor wiring site). Non-numeric\n *  or non-positive values fall back to the defaults. */\nexport const ENV_PER_SERVICE_CAPACITY = 'DEVSTACK_DASHBOARD_LOG_CAPACITY';\nexport const ENV_MAX_SERVICES = 'DEVSTACK_DASHBOARD_LOG_MAX_SERVICES';\n\n/** Tunables for the per-service log store. Both optional; absent fields take\n *  the module defaults (or the corresponding env var, when resolved via\n *  `resolveLogStoreConfig`). */\nexport interface LogStoreConfig {\n\t/** Max records kept per service ring. Default {@link DEFAULT_PER_SERVICE_CAPACITY}. */\n\treadonly perServiceCapacity?: number;\n\t/** Max distinct service rings. Default {@link DEFAULT_MAX_SERVICES}. */\n\treadonly maxServices?: number;\n}\n\ninterface ResolvedLogStoreConfig {\n\treadonly perServiceCapacity: number;\n\treadonly maxServices: number;\n}\n\nconst positiveIntOr = (raw: string | undefined, fallback: number): number => {\n\tif (raw === undefined) return fallback;\n\tconst n = Number(raw);\n\treturn Number.isFinite(n) && n >= 1 ? Math.floor(n) : fallback;\n};\n\n/** Resolve the effective config: explicit options win, then env vars, then\n *  module defaults. Pure given an `env` bag (defaults to `process.env`). */\nexport const resolveLogStoreConfig = (\n\tconfig: LogStoreConfig = {},\n\tenv: Record<string, string | undefined> = process.env,\n): ResolvedLogStoreConfig => ({\n\tperServiceCapacity:\n\t\tconfig.perServiceCapacity !== undefined && config.perServiceCapacity >= 1\n\t\t\t? Math.floor(config.perServiceCapacity)\n\t\t\t: positiveIntOr(env[ENV_PER_SERVICE_CAPACITY], DEFAULT_PER_SERVICE_CAPACITY),\n\tmaxServices:\n\t\tconfig.maxServices !== undefined && config.maxServices >= 1\n\t\t\t? Math.floor(config.maxServices)\n\t\t\t: positiveIntOr(env[ENV_MAX_SERVICES], DEFAULT_MAX_SERVICES),\n});\n\n// -----------------------------------------------------------------------------\n// Service\n// -----------------------------------------------------------------------------\n\nexport interface LogStoreShape {\n\t/** Append a record. Called from the supervisor's logger tap on the hot\n\t *  path — a single `Ref.update`, no I/O. Routes to the per-service ring\n\t *  (created on first sight of a service). */\n\treadonly append: (record: {\n\t\treadonly level: LogLevel;\n\t\treadonly service: string;\n\t\treadonly message: string;\n\t\treadonly fields?: Readonly<Record<string, unknown>>;\n\t\treadonly timestampMillis?: number;\n\t}) => Effect.Effect<void>;\n\t/** Query across all per-service rings with a filter. Returns\n\t *  most-recent-first by `seq`, capped by `filter.limit`. Never fails. */\n\treadonly query: (filter?: LogFilter) => Effect.Effect<ReadonlyArray<LogRecord>>;\n\t/** Distinct service keys with a live ring (for filter dropdowns). */\n\treadonly services: Effect.Effect<ReadonlyArray<string>>;\n}\n\nexport class LogStore extends Context.Service<LogStore, LogStoreShape>()(\n\t'@devstack/substrate/LogStore',\n) {}\n\n/** One service's bounded ring. `records` is oldest-first; `hasError` is a\n *  cached flag so eviction doesn't rescan the array (set when any\n *  `error`/`fatal` record is present after trimming). */\ninterface ServiceRing {\n\treadonly records: ReadonlyArray<LogRecord>;\n\treadonly hasError: boolean;\n}\n\ninterface StoreState {\n\t/** Per-service rings. A `Map` so first-sight insertion / eviction is O(1)\n\t *  and iteration order is insertion order (irrelevant — query sorts by\n\t *  seq). */\n\treadonly rings: ReadonlyMap<string, ServiceRing>;\n\treadonly nextSeq: number;\n}\n\nconst isErrorLevel = (level: LogLevel): boolean => level === 'error' || level === 'fatal';\n\n/** Choose which service ring to evict when `maxServices` is reached and a new\n *  service appears. Policy (documented in the file header):\n *    1. Prefer to RETAIN rings that hold an `error`/`fatal` record — never\n *       drop a crashed/quiet service's only error trail while a chatty\n *       all-`info` ring exists. So victims are drawn from the error-free\n *       rings first; only if EVERY ring carries an error do we consider\n *       error-bearing ones.\n *    2. Within the candidate pool, evict the ring whose NEWEST record is\n *       oldest (LRU on most-recent activity) — the least recently active\n *       service. Ties broken by lowest newest-seq.\n *  Returns the service key to drop, or null when there are no rings. */\nexport const pickEvictionVictim = (rings: ReadonlyMap<string, ServiceRing>): string | null => {\n\tlet victim: string | null = null;\n\tlet victimNewestMillis = Number.POSITIVE_INFINITY;\n\tlet victimNewestSeq = Number.POSITIVE_INFINITY;\n\tlet victimHasError = true;\n\n\tfor (const [service, ring] of rings) {\n\t\tconst newest = ring.records[ring.records.length - 1];\n\t\t// An empty ring should never exist (we only create on append), but be\n\t\t// defensive: treat it as the most-evictable.\n\t\tconst newestMillis = newest?.timestampMillis ?? Number.NEGATIVE_INFINITY;\n\t\tconst newestSeq = newest?.seq ?? Number.NEGATIVE_INFINITY;\n\t\tconst hasError = ring.hasError;\n\n\t\t// An error-free ring always beats an error-bearing one as a victim.\n\t\tif (victimHasError && !hasError) {\n\t\t\tvictim = service;\n\t\t\tvictimNewestMillis = newestMillis;\n\t\t\tvictimNewestSeq = newestSeq;\n\t\t\tvictimHasError = hasError;\n\t\t\tcontinue;\n\t\t}\n\t\t// Don't replace an error-free candidate with an error-bearing one.\n\t\tif (!victimHasError && hasError) continue;\n\n\t\t// Same error-class: prefer the one whose newest record is oldest.\n\t\tif (\n\t\t\tnewestMillis < victimNewestMillis ||\n\t\t\t(newestMillis === victimNewestMillis && newestSeq < victimNewestSeq)\n\t\t) {\n\t\t\tvictim = service;\n\t\t\tvictimNewestMillis = newestMillis;\n\t\t\tvictimNewestSeq = newestSeq;\n\t\t\tvictimHasError = hasError;\n\t\t}\n\t}\n\treturn victim;\n};\n\n/** Build a `LogStoreShape` over a freshly-created `Ref`. The supervisor calls\n *  this (not the Layer) so the rings are process-scoped alongside the\n *  projection ref. `config` is injectable for tests; with no `config` the\n *  env-var defaults apply. */\nexport const makeLogStore = (config: LogStoreConfig = {}): Effect.Effect<LogStoreShape> =>\n\tEffect.gen(function* () {\n\t\tconst { perServiceCapacity, maxServices } = resolveLogStoreConfig(config);\n\t\tconst ref = yield* Ref.make<StoreState>({ rings: new Map(), nextSeq: 0 });\n\n\t\tconst append: LogStoreShape['append'] = (record) =>\n\t\t\tRef.update(ref, (state) => {\n\t\t\t\tconst next: LogRecord = {\n\t\t\t\t\tseq: state.nextSeq,\n\t\t\t\t\ttimestampMillis: record.timestampMillis ?? Date.now(),\n\t\t\t\t\tlevel: record.level,\n\t\t\t\t\tservice: record.service,\n\t\t\t\t\tmessage: record.message,\n\t\t\t\t\tfields: record.fields ?? {},\n\t\t\t\t};\n\n\t\t\t\tconst rings = new Map(state.rings);\n\t\t\t\tconst existing = rings.get(record.service);\n\n\t\t\t\tif (existing === undefined) {\n\t\t\t\t\t// First sight of this service — may need to evict to stay\n\t\t\t\t\t// under `maxServices`. Eviction runs ONLY here, not per\n\t\t\t\t\t// append.\n\t\t\t\t\tif (rings.size >= maxServices) {\n\t\t\t\t\t\tconst victim = pickEvictionVictim(rings);\n\t\t\t\t\t\tif (victim !== null) rings.delete(victim);\n\t\t\t\t\t}\n\t\t\t\t\trings.set(record.service, {\n\t\t\t\t\t\trecords: [next],\n\t\t\t\t\t\thasError: isErrorLevel(next.level),\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tconst merged = [...existing.records, next];\n\t\t\t\t\tconst trimmed =\n\t\t\t\t\t\tmerged.length > perServiceCapacity ? merged.slice(-perServiceCapacity) : merged;\n\t\t\t\t\t// Recompute `hasError` only when the trim could have dropped\n\t\t\t\t\t// the last error (i.e. an actual trim happened); otherwise the\n\t\t\t\t\t// flag only ever grows true.\n\t\t\t\t\tconst hasError =\n\t\t\t\t\t\ttrimmed.length < merged.length\n\t\t\t\t\t\t\t? trimmed.some((r) => isErrorLevel(r.level))\n\t\t\t\t\t\t\t: existing.hasError || isErrorLevel(next.level);\n\t\t\t\t\trings.set(record.service, { records: trimmed, hasError });\n\t\t\t\t}\n\n\t\t\t\treturn { rings, nextSeq: state.nextSeq + 1 };\n\t\t\t});\n\n\t\tconst query: LogStoreShape['query'] = (filter) =>\n\t\t\tRef.get(ref).pipe(Effect.map((state) => queryRings(state.rings, filter, perServiceCapacity)));\n\n\t\tconst services: LogStoreShape['services'] = Ref.get(ref).pipe(\n\t\t\tEffect.map((state) => [...state.rings.keys()].sort()),\n\t\t);\n\n\t\treturn LogStore.of({ append, query, services });\n\t});\n\n// -----------------------------------------------------------------------------\n// Query\n// -----------------------------------------------------------------------------\n\ninterface CompiledFilter {\n\treadonly serviceSet: ReadonlySet<string> | null;\n\treadonly levelSet: ReadonlySet<LogLevel> | null;\n\treadonly search: string | null;\n\treadonly since: number | undefined;\n\treadonly limit: number;\n}\n\nconst compileFilter = (filter: LogFilter | undefined, defaultLimit: number): CompiledFilter => {\n\tconst search = filter?.search?.trim().toLowerCase();\n\treturn {\n\t\tserviceSet:\n\t\t\tfilter?.services && filter.services.length > 0 ? new Set(filter.services) : null,\n\t\tlevelSet: filter?.levels && filter.levels.length > 0 ? new Set(filter.levels) : null,\n\t\tsearch: search !== undefined && search.length > 0 ? search : null,\n\t\tsince: filter?.sinceMillis,\n\t\tlimit: filter?.limit ?? defaultLimit,\n\t};\n};\n\nconst matches = (r: LogRecord, f: CompiledFilter): boolean => {\n\tif (f.serviceSet !== null && !f.serviceSet.has(r.service)) return false;\n\tif (f.levelSet !== null && !f.levelSet.has(r.level)) return false;\n\tif (f.since !== undefined && r.timestampMillis < f.since) return false;\n\tif (\n\t\tf.search !== null &&\n\t\t!r.message.toLowerCase().includes(f.search) &&\n\t\t!r.service.toLowerCase().includes(f.search)\n\t) {\n\t\treturn false;\n\t}\n\treturn true;\n};\n\n/** Merge all per-service rings into a single newest-first result. Each ring\n *  is oldest-first, so we run a k-way merge from the tail of each ring,\n *  emitting the globally-highest `seq` first and stopping once `limit` is\n *  filled. This is O(matched-prefix × ringCount) without materializing the\n *  whole universe — important when `limit` is small relative to total volume.\n *  Exported for tests. */\nexport const queryRings = (\n\trings: ReadonlyMap<string, ServiceRing>,\n\tfilter: LogFilter | undefined,\n\tperServiceCapacity: number,\n): ReadonlyArray<LogRecord> => {\n\tconst f = compileFilter(filter, perServiceCapacity * Math.max(rings.size, 1));\n\tif (f.limit <= 0) return [];\n\n\t// Cursor per ring, walking newest→oldest (from the end of each array).\n\tconst arrays: ReadonlyArray<LogRecord>[] = [];\n\tconst cursors: number[] = [];\n\tfor (const ring of rings.values()) {\n\t\tif (ring.records.length > 0) {\n\t\t\tarrays.push(ring.records);\n\t\t\tcursors.push(ring.records.length - 1);\n\t\t}\n\t}\n\n\tconst out: LogRecord[] = [];\n\twhile (out.length < f.limit) {\n\t\t// Find the ring whose current cursor points at the highest seq.\n\t\tlet bestRing = -1;\n\t\tlet bestSeq = Number.NEGATIVE_INFINITY;\n\t\tfor (let k = 0; k < arrays.length; k += 1) {\n\t\t\tconst c = cursors[k]!;\n\t\t\tif (c < 0) continue;\n\t\t\tconst seq = arrays[k]![c]!.seq;\n\t\t\tif (seq > bestSeq) {\n\t\t\t\tbestSeq = seq;\n\t\t\t\tbestRing = k;\n\t\t\t}\n\t\t}\n\t\tif (bestRing === -1) break; // all rings exhausted\n\n\t\tconst c = cursors[bestRing]!;\n\t\tconst r = arrays[bestRing]![c]!;\n\t\tcursors[bestRing] = c - 1;\n\t\tif (matches(r, f)) out.push(r);\n\t}\n\treturn out;\n};\n\n/** Pure filter application over a flat oldest-first record array — retained\n *  for direct use / tests. Returns newest-first, capped to `limit`. */\nexport const applyLogFilter = (\n\trecords: ReadonlyArray<LogRecord>,\n\tfilter: LogFilter | undefined,\n\tcapacity: number,\n): ReadonlyArray<LogRecord> => {\n\tconst f = compileFilter(filter, capacity);\n\tconst out: LogRecord[] = [];\n\tfor (let i = records.length - 1; i >= 0 && out.length < f.limit; i -= 1) {\n\t\tconst r = records[i]!;\n\t\tif (matches(r, f)) out.push(r);\n\t}\n\treturn out;\n};\n\n/** Layer form (for any caller that wants the store via a Layer rather than\n *  the supervisor-scoped `makeLogStore`). Uses the default/env config. */\nexport const layerLogStore: Layer.Layer<LogStore> = Layer.effect(LogStore, makeLogStore());\n\n/** Coerce an arbitrary `pluginKey` (the upstream `Logger.log` tag carries an\n *  optional `PluginKey`) to the store's `service` string, falling back to the\n *  bare log tag when no plugin key is present. */\nexport const serviceKeyFor = (tag: string, pluginKey: PluginKey | null): string =>\n\tpluginKey === null ? tag : String(pluginKey);\n"],"mappings":";;;;AAyFA,MAAa,+BAA+B;;;;AAW5C,MAAa,2BAA2B;AACxC,MAAa,mBAAmB;AAiBhC,MAAM,iBAAiB,KAAyB,aAA6B;AAC5E,KAAI,QAAQ,KAAA,EAAW,QAAO;CAC9B,MAAM,IAAI,OAAO,IAAI;AACrB,QAAO,OAAO,SAAS,EAAE,IAAI,KAAK,IAAI,KAAK,MAAM,EAAE,GAAG;;;;AAKvD,MAAa,yBACZ,SAAyB,EAAE,EAC3B,MAA0C,QAAQ,SACrB;CAC7B,oBACC,OAAO,uBAAuB,KAAA,KAAa,OAAO,sBAAsB,IACrE,KAAK,MAAM,OAAO,mBAAmB,GACrC,cAAc,IAAI,2BAA2B,6BAA6B;CAC9E,aACC,OAAO,gBAAgB,KAAA,KAAa,OAAO,eAAe,IACvD,KAAK,MAAM,OAAO,YAAY,GAC9B,cAAc,IAAI,mBAAA,IAAwC;CAC9D;AAwBD,IAAa,WAAb,cAA8B,QAAQ,SAAkC,CACvE,+BACA,CAAC;AAkBF,MAAM,gBAAgB,UAA6B,UAAU,WAAW,UAAU;;;;;;;;;;;;AAalF,MAAa,sBAAsB,UAA2D;CAC7F,IAAI,SAAwB;CAC5B,IAAI,qBAAqB,OAAO;CAChC,IAAI,kBAAkB,OAAO;CAC7B,IAAI,iBAAiB;AAErB,MAAK,MAAM,CAAC,SAAS,SAAS,OAAO;EACpC,MAAM,SAAS,KAAK,QAAQ,KAAK,QAAQ,SAAS;EAGlD,MAAM,eAAe,QAAQ,mBAAmB,OAAO;EACvD,MAAM,YAAY,QAAQ,OAAO,OAAO;EACxC,MAAM,WAAW,KAAK;AAGtB,MAAI,kBAAkB,CAAC,UAAU;AAChC,YAAS;AACT,wBAAqB;AACrB,qBAAkB;AAClB,oBAAiB;AACjB;;AAGD,MAAI,CAAC,kBAAkB,SAAU;AAGjC,MACC,eAAe,sBACd,iBAAiB,sBAAsB,YAAY,iBACnD;AACD,YAAS;AACT,wBAAqB;AACrB,qBAAkB;AAClB,oBAAiB;;;AAGnB,QAAO;;;;;;AAOR,MAAa,gBAAgB,SAAyB,EAAE,KACvD,OAAO,IAAI,aAAa;CACvB,MAAM,EAAE,oBAAoB,gBAAgB,sBAAsB,OAAO;CACzE,MAAM,MAAM,OAAO,IAAI,KAAiB;EAAE,uBAAO,IAAI,KAAK;EAAE,SAAS;EAAG,CAAC;CAEzE,MAAM,UAAmC,WACxC,IAAI,OAAO,MAAM,UAAU;EAC1B,MAAM,OAAkB;GACvB,KAAK,MAAM;GACX,iBAAiB,OAAO,mBAAmB,KAAK,KAAK;GACrD,OAAO,OAAO;GACd,SAAS,OAAO;GAChB,SAAS,OAAO;GAChB,QAAQ,OAAO,UAAU,EAAE;GAC3B;EAED,MAAM,QAAQ,IAAI,IAAI,MAAM,MAAM;EAClC,MAAM,WAAW,MAAM,IAAI,OAAO,QAAQ;AAE1C,MAAI,aAAa,KAAA,GAAW;AAI3B,OAAI,MAAM,QAAQ,aAAa;IAC9B,MAAM,SAAS,mBAAmB,MAAM;AACxC,QAAI,WAAW,KAAM,OAAM,OAAO,OAAO;;AAE1C,SAAM,IAAI,OAAO,SAAS;IACzB,SAAS,CAAC,KAAK;IACf,UAAU,aAAa,KAAK,MAAM;IAClC,CAAC;SACI;GACN,MAAM,SAAS,CAAC,GAAG,SAAS,SAAS,KAAK;GAC1C,MAAM,UACL,OAAO,SAAS,qBAAqB,OAAO,MAAM,CAAC,mBAAmB,GAAG;GAI1E,MAAM,WACL,QAAQ,SAAS,OAAO,SACrB,QAAQ,MAAM,MAAM,aAAa,EAAE,MAAM,CAAC,GAC1C,SAAS,YAAY,aAAa,KAAK,MAAM;AACjD,SAAM,IAAI,OAAO,SAAS;IAAE,SAAS;IAAS;IAAU,CAAC;;AAG1D,SAAO;GAAE;GAAO,SAAS,MAAM,UAAU;GAAG;GAC3C;CAEH,MAAM,SAAiC,WACtC,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,UAAU,WAAW,MAAM,OAAO,QAAQ,mBAAmB,CAAC,CAAC;CAE9F,MAAM,WAAsC,IAAI,IAAI,IAAI,CAAC,KACxD,OAAO,KAAK,UAAU,CAAC,GAAG,MAAM,MAAM,MAAM,CAAC,CAAC,MAAM,CAAC,CACrD;AAED,QAAO,SAAS,GAAG;EAAE;EAAQ;EAAO;EAAU,CAAC;EAC9C;AAcH,MAAM,iBAAiB,QAA+B,iBAAyC;CAC9F,MAAM,SAAS,QAAQ,QAAQ,MAAM,CAAC,aAAa;AACnD,QAAO;EACN,YACC,QAAQ,YAAY,OAAO,SAAS,SAAS,IAAI,IAAI,IAAI,OAAO,SAAS,GAAG;EAC7E,UAAU,QAAQ,UAAU,OAAO,OAAO,SAAS,IAAI,IAAI,IAAI,OAAO,OAAO,GAAG;EAChF,QAAQ,WAAW,KAAA,KAAa,OAAO,SAAS,IAAI,SAAS;EAC7D,OAAO,QAAQ;EACf,OAAO,QAAQ,SAAS;EACxB;;AAGF,MAAM,WAAW,GAAc,MAA+B;AAC7D,KAAI,EAAE,eAAe,QAAQ,CAAC,EAAE,WAAW,IAAI,EAAE,QAAQ,CAAE,QAAO;AAClE,KAAI,EAAE,aAAa,QAAQ,CAAC,EAAE,SAAS,IAAI,EAAE,MAAM,CAAE,QAAO;AAC5D,KAAI,EAAE,UAAU,KAAA,KAAa,EAAE,kBAAkB,EAAE,MAAO,QAAO;AACjE,KACC,EAAE,WAAW,QACb,CAAC,EAAE,QAAQ,aAAa,CAAC,SAAS,EAAE,OAAO,IAC3C,CAAC,EAAE,QAAQ,aAAa,CAAC,SAAS,EAAE,OAAO,CAE3C,QAAO;AAER,QAAO;;;;;;;;AASR,MAAa,cACZ,OACA,QACA,uBAC8B;CAC9B,MAAM,IAAI,cAAc,QAAQ,qBAAqB,KAAK,IAAI,MAAM,MAAM,EAAE,CAAC;AAC7E,KAAI,EAAE,SAAS,EAAG,QAAO,EAAE;CAG3B,MAAM,SAAqC,EAAE;CAC7C,MAAM,UAAoB,EAAE;AAC5B,MAAK,MAAM,QAAQ,MAAM,QAAQ,CAChC,KAAI,KAAK,QAAQ,SAAS,GAAG;AAC5B,SAAO,KAAK,KAAK,QAAQ;AACzB,UAAQ,KAAK,KAAK,QAAQ,SAAS,EAAE;;CAIvC,MAAM,MAAmB,EAAE;AAC3B,QAAO,IAAI,SAAS,EAAE,OAAO;EAE5B,IAAI,WAAW;EACf,IAAI,UAAU,OAAO;AACrB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,GAAG;GAC1C,MAAM,IAAI,QAAQ;AAClB,OAAI,IAAI,EAAG;GACX,MAAM,MAAM,OAAO,GAAI,GAAI;AAC3B,OAAI,MAAM,SAAS;AAClB,cAAU;AACV,eAAW;;;AAGb,MAAI,aAAa,GAAI;EAErB,MAAM,IAAI,QAAQ;EAClB,MAAM,IAAI,OAAO,UAAW;AAC5B,UAAQ,YAAY,IAAI;AACxB,MAAI,QAAQ,GAAG,EAAE,CAAE,KAAI,KAAK,EAAE;;AAE/B,QAAO;;AAqB4C,MAAM,OAAO,UAAU,cAAc,CAAC;;;;AAK1F,MAAa,iBAAiB,KAAa,cAC1C,cAAc,OAAO,MAAM,OAAO,UAAU"}

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

@@ -1,5 +1,6 @@
 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
@@ -51,7 +52,7 @@ interface LoggerShape {
   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 const Logger_base: Context.ServiceClass<Logger$1, "@devstack/substrate/Logger", LoggerShape>;
 declare class Logger$1 extends Logger_base {}
 //#endregion
 export { LogLevel, LogLine, LogPayload, Logger$1 as Logger, LoggerShape, TagBuffer };

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

@@ -1,16 +1,13 @@
 import { SpanAttr } from "./spans.mjs";
-import { Redactor, redactValue } from "./redaction.mjs";
-import { Context, Data, Effect, Layer, Ref } from "effect";
-Data.TaggedError("LoggerError");
+import { Context, Effect, Layer, Ref } from "effect";
 /** 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") {};
+var Logger$1 = class extends Context.Service()("@devstack/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) => {
@@ -30,13 +27,12 @@ const layerLogger = Layer.effect(Logger$1, Effect.gen(function* () {
 	});
 	/** 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),
+			message: truncateLine(payload.message),
+			fields: payload.fields ?? {},
 			at: Date.now()
 		};
 		yield* appendInternal(line);
@@ -84,6 +80,6 @@ const logViaEffect = (line) => {
 	}
 };
 //#endregion
-export { Logger$1 as Logger, layerLogger };
+export { Logger$1 as Logger, MAX_LINE_BYTES, layerLogger };
 
 //# sourceMappingURL=logger.mjs.map

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

@@ -1 +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"}
+{"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';\n\nimport type { PluginKey } from '../../brand.ts';\nimport { SpanAttr } from './spans.ts';\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>()('@devstack/substrate/Logger') {}\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> = Layer.effect(\n\tLogger,\n\tEffect.gen(function* () {\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 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(payload.message),\n\t\t\t\tfields: payload.fields ?? {},\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":";;;;AAqEA,MAAa,iBAAiB,KAAK;AAmCnC,IAAaA,WAAb,cAA4B,QAAQ,SAA8B,CAAC,6BAA6B,CAAC;;;;AAKjG,MAAa,cAAmC,MAAM,OACrDA,UACA,OAAO,IAAI,aAAa;CACvB,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,OAAgB;GACrB;GACA;GACA,OAAO,QAAQ;GACf,SAAS,aAAa,QAAQ,QAAQ;GACtC,QAAQ,QAAQ,UAAU,EAAE;GAC5B,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/output-truncate.mjs

@@ -0,0 +1,35 @@
+//#region src/substrate/runtime/observability/output-truncate.ts
+/** Return the trailing `maxChars` characters of `value`, or `value`
+*  unchanged if shorter. Used at error-construction sites that want to
+*  surface the most-recent output (typically where the failure cause
+*  appears at the END of a long stream — e.g. a git clone trace whose
+*  fatal line is the last one). Defaults to 1000 chars, the source-fetch
+*  call sites' original budget. */
+const tailOutput = (value, maxChars = 1e3) => value.length > maxChars ? value.slice(-maxChars) : value;
+/** Render `value` as a labelled, JSON-quoted suffix (` <label>=<json>`)
+*  for inline error messages. Empty / whitespace-only input collapses to
+*  the empty string so the caller can unconditionally concatenate the
+*  result without producing dangling labels.
+*
+*  Oversize input is mid-truncated: a head slice + literal
+*  `...<truncated N chars>...` + a tail slice, keeping both the leading
+*  context (which often identifies the command) AND the trailing context
+*  (which often identifies the cause). Defaults size the output so a
+*  combined stdout + stderr fits inside an L4-level log line without
+*  overflowing typical terminal scroll buffers.
+*
+*  @param maxChars - total budget before mid-truncation kicks in (default
+*    2400). Below this the body is emitted verbatim.
+*  @param windowChars - per-side window kept when truncating (default
+*    1100). Total kept output is roughly `2 * windowChars` plus the
+*    truncation marker. */
+const labelledExcerpt = (label, value, maxChars = 2400, windowChars = 1100) => {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return "";
+	const body = trimmed.length > maxChars ? `${trimmed.slice(0, windowChars)}...<truncated ${trimmed.length - 2 * windowChars} chars>...${trimmed.slice(-windowChars)}` : trimmed;
+	return ` ${label}=${JSON.stringify(body)}`;
+};
+//#endregion
+export { labelledExcerpt, tailOutput };
+
+//# sourceMappingURL=output-truncate.mjs.map

package/dist/substrate/runtime/observability/output-truncate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-truncate.mjs","names":[],"sources":["../../../../src/substrate/runtime/observability/output-truncate.ts"],"sourcesContent":["// Bounded stdout/stderr trimming for error-message tails.\n//\n// Two failure-message shapes converged on the same primitive:\n//   - `walrus/deploy.ts::excerpt` — emit a labelled, JSON-quoted body\n//     (` stdout=\"...\"`) with mid-truncation when oversize (head + tail\n//     window with a `<truncated N chars>` marker), elided when empty.\n//   - `seal/bootstrap-assets/source-fetch.ts::outputTail` — emit just\n//     the last N chars of the raw stream, passed as the `stdout:` /\n//     `stderr:` field of a typed error.\n//\n// Both are stdout/stderr bound-the-blast-radius helpers. Both used to\n// inline ad-hoc constants. Folded into one module so the\n// boundedness-policy lives in ONE place and the per-call-site shape\n// (label-wrapped vs raw tail) is just an output decision.\n\n/** Return the trailing `maxChars` characters of `value`, or `value`\n *  unchanged if shorter. Used at error-construction sites that want to\n *  surface the most-recent output (typically where the failure cause\n *  appears at the END of a long stream — e.g. a git clone trace whose\n *  fatal line is the last one). Defaults to 1000 chars, the source-fetch\n *  call sites' original budget. */\nexport const tailOutput = (value: string, maxChars: number = 1_000): string =>\n\tvalue.length > maxChars ? value.slice(-maxChars) : value;\n\n/** Render `value` as a labelled, JSON-quoted suffix (` <label>=<json>`)\n *  for inline error messages. Empty / whitespace-only input collapses to\n *  the empty string so the caller can unconditionally concatenate the\n *  result without producing dangling labels.\n *\n *  Oversize input is mid-truncated: a head slice + literal\n *  `...<truncated N chars>...` + a tail slice, keeping both the leading\n *  context (which often identifies the command) AND the trailing context\n *  (which often identifies the cause). Defaults size the output so a\n *  combined stdout + stderr fits inside an L4-level log line without\n *  overflowing typical terminal scroll buffers.\n *\n *  @param maxChars - total budget before mid-truncation kicks in (default\n *    2400). Below this the body is emitted verbatim.\n *  @param windowChars - per-side window kept when truncating (default\n *    1100). Total kept output is roughly `2 * windowChars` plus the\n *    truncation marker. */\nexport const labelledExcerpt = (\n\tlabel: string,\n\tvalue: string,\n\tmaxChars: number = 2_400,\n\twindowChars: number = 1_100,\n): string => {\n\tconst trimmed = value.trim();\n\tif (trimmed.length === 0) return '';\n\tconst body =\n\t\ttrimmed.length > maxChars\n\t\t\t? `${trimmed.slice(0, windowChars)}...<truncated ${trimmed.length - 2 * windowChars} chars>...${trimmed.slice(-windowChars)}`\n\t\t\t: trimmed;\n\treturn ` ${label}=${JSON.stringify(body)}`;\n};\n"],"mappings":";;;;;;;AAqBA,MAAa,cAAc,OAAe,WAAmB,QAC5D,MAAM,SAAS,WAAW,MAAM,MAAM,CAAC,SAAS,GAAG;;;;;;;;;;;;;;;;;;AAmBpD,MAAa,mBACZ,OACA,OACA,WAAmB,MACnB,cAAsB,SACV;CACZ,MAAM,UAAU,MAAM,MAAM;AAC5B,KAAI,QAAQ,WAAW,EAAG,QAAO;CACjC,MAAM,OACL,QAAQ,SAAS,WACd,GAAG,QAAQ,MAAM,GAAG,YAAY,CAAC,gBAAgB,QAAQ,SAAS,IAAI,YAAY,YAAY,QAAQ,MAAM,CAAC,YAAY,KACzH;AACJ,QAAO,IAAI,MAAM,GAAG,KAAK,UAAU,KAAK"}

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

@@ -1,4 +1,5 @@
 import { isTaggedError } from "./cascade-formatter.mjs";
+import { Cause } from "effect";
 //#region src/substrate/runtime/observability/pretty-error.ts
 /**
 * Render a Cause as a `StructuredError` suitable for the projection's
@@ -26,9 +27,8 @@ const prettyErrorStructured = (cause, options) => {
 /** 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") {
+	for (const reason of cause.reasons) {
+		if (Cause.isFailReason(reason)) {
 			const error = reason.error;
 			if (isTaggedError(error)) return {
 				tag: error._tag,
@@ -43,7 +43,7 @@ const extractHeadline = (cause) => {
 				summary: String(error)
 			};
 		}
-		if (reason._tag === "Die") {
+		if (Cause.isDieReason(reason)) {
 			const defect = reason.defect;
 			if (isTaggedError(defect)) return {
 				tag: `Defect[${defect._tag}]`,
@@ -58,7 +58,7 @@ const extractHeadline = (cause) => {
 				summary: String(defect)
 			};
 		}
-		if (reason._tag === "Interrupt") return {
+		return {
 			tag: "Interrupt",
 			summary: "fiber interrupted"
 		};
@@ -82,17 +82,14 @@ const headlineText = (value) => {
 /** 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());
+	for (const reason of cause.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");
+	if (Cause.isFailReason(reason)) walkChainFromValue(reason.error, out, visited);
+	else if (Cause.isDieReason(reason)) walkChainFromValue(reason.defect, out, visited);
+	else out.push("Interrupt");
 };
 const walkChainFromValue = (value, out, visited) => {
 	if (value === void 0 || value === null) return;

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

@@ -1 +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"}
+{"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 { 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\tfor (const reason of cause.reasons) {\n\t\tif (Cause.isFailReason(reason)) {\n\t\t\tconst error = reason.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 (Cause.isDieReason(reason)) {\n\t\t\tconst defect = reason.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\t// Cause.isInterruptReason(reason)\n\t\treturn { tag: 'Interrupt', summary: 'fiber interrupted' };\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 out: Array<string> = [];\n\tfor (const reason of cause.reasons) {\n\t\twalkChainFromReason(reason, out, new WeakSet());\n\t}\n\treturn out;\n};\n\nconst walkChainFromReason = (\n\treason: Cause.Reason<unknown>,\n\tout: Array<string>,\n\tvisited: WeakSet<object>,\n): void => {\n\tif (Cause.isFailReason(reason)) walkChainFromValue(reason.error, out, visited);\n\telse if (Cause.isDieReason(reason)) walkChainFromValue(reason.defect, out, visited);\n\telse 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;AAC1F,MAAK,MAAM,UAAU,MAAM,SAAS;AACnC,MAAI,MAAM,aAAa,OAAO,EAAE;GAC/B,MAAM,QAAQ,OAAO;AACrB,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,MAAM,YAAY,OAAO,EAAE;GAC9B,MAAM,SAAS,OAAO;AACtB,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;;AAGlD,SAAO;GAAE,KAAK;GAAa,SAAS;GAAqB;;AAE1D,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,MAAqB,EAAE;AAC7B,MAAK,MAAM,UAAU,MAAM,QAC1B,qBAAoB,QAAQ,qBAAK,IAAI,SAAS,CAAC;AAEhD,QAAO;;AAGR,MAAM,uBACL,QACA,KACA,YACU;AACV,KAAI,MAAM,aAAa,OAAO,CAAE,oBAAmB,OAAO,OAAO,KAAK,QAAQ;UACrE,MAAM,YAAY,OAAO,CAAE,oBAAmB,OAAO,QAAQ,KAAK,QAAQ;KAC9E,KAAI,KAAK,YAAY;;AAG3B,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/redaction.d.mts

@@ -1,8 +1,5 @@
-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 };
+  export { RedactionRule, redactText, redactValue };
 }
 type RedactionRule = {
   readonly kind: 'literal';
@@ -13,16 +10,8 @@ type RedactionRule = {
   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 };
+export { RedactionRule, redactText, redactValue, redaction_d_exports };
 //# sourceMappingURL=redaction.d.mts.map