@mysten-incubation/devstack 0.1.1 → 0.2.0

package/dist/substrate/runtime/capability-sinks/layer.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"layer.mjs","names":[],"sources":["../../../../src/substrate/runtime/capability-sinks/layer.ts"],"sourcesContent":["// CapabilitySinks default layer.\n//\n// Composes the empty registry from `service.ts` with the substrate's\n// error-contribution sink and caller-supplied capability sinks. The\n// substrate does not name built-in capability contracts here; L3\n// orchestrator composition owns those registrations.\n\nimport { Context, Effect, Layer, Scope } from 'effect';\n\nimport type { PluginErrorContribution } from '../../plugin.ts';\nimport {\n\tFormatterRegistryService,\n\tlayerFormatterRegistry,\n} from '../observability/formatter-registry.ts';\nimport {\n\tCapabilitySinksService,\n\tlayerCapabilitySinks,\n\ttype CapabilitySink,\n\ttype ContributionKind,\n} from './service.ts';\n\n// -----------------------------------------------------------------------------\n// Orchestrator-supplied capability-decl registrations\n// -----------------------------------------------------------------------------\n\n/**\n * Orchestrator-side sink registrations. The supervisor accepts these\n * at boot and registers them by `kind`; the substrate does not expose\n * one callback slot per built-in capability contract.\n */\nexport type OrchestratorSinks = ReadonlyArray<CapabilitySink<ContributionKind, never>>;\n\n// -----------------------------------------------------------------------------\n// Built-in sink construction\n// -----------------------------------------------------------------------------\n\nconst errorContributionSink = (formatters: {\n\treadonly register: (c: PluginErrorContribution) => Effect.Effect<void, never, Scope.Scope>;\n}): CapabilitySink<'error-contribution', PluginErrorContribution> => ({\n\tkind: 'error-contribution',\n\taccept: (contribution, _ctx) => formatters.register(contribution),\n});\n\n// -----------------------------------------------------------------------------\n// Public layer factory\n// -----------------------------------------------------------------------------\n\n/**\n * Build the substrate's default CapabilitySinks layer. It supplies the\n * error-contribution sink and registers the caller's capability sinks\n * by kind. Unknown contribution kinds remain no-ops at the supervisor\n * call site unless a sink is registered.\n *\n * Plugin-author extension: provide an additional Layer that yields\n * `CapabilitySinksService` and calls `registerSink({ kind: 'my-kind', ... })`\n * before the supervisor starts harvesting. Last-write-wins on duplicate\n * kinds, with scope-bound restore — the built-in sink comes back when\n * the override's scope closes.\n */\nexport const layerCapabilitySinksDefault = (\n\torchestrator: OrchestratorSinks = [],\n): Layer.Layer<CapabilitySinksService | FormatterRegistryService, never, never> => {\n\tconst registerDefaults = Layer.effectDiscard(\n\t\tEffect.gen(function* () {\n\t\t\tconst sinks = yield* CapabilitySinksService;\n\t\t\tconst fmt = yield* FormatterRegistryService;\n\t\t\tconst defaults = [errorContributionSink(fmt), ...orchestrator];\n\t\t\tfor (const sink of defaults) {\n\t\t\t\tyield* sinks.registerSink(sink);\n\t\t\t}\n\t\t}),\n\t);\n\treturn registerDefaults.pipe(\n\t\tLayer.provideMerge(layerCapabilitySinks),\n\t\tLayer.provideMerge(layerFormatterRegistry),\n\t);\n};\n\n/** Re-exposed dependency: callers that want the formatter registry\n *  available downstream (e.g. CLI / TUI / cascade-formatter consumers)\n *  pull it from the default layer. */\nexport type CapabilitySinksRequirements = Context.Context<\n\tCapabilitySinksService | FormatterRegistryService\n>;\n"],"mappings":";;;;AAoCA,MAAM,yBAAyB,gBAEuC;CACrE,MAAM;CACN,SAAS,cAAc,SAAS,WAAW,SAAS,aAAa;CACjE;;;;;;;;;;;;;AAkBD,MAAa,+BACZ,eAAkC,EAAE,KAC8C;AAWlF,QAVyB,MAAM,cAC9B,OAAO,IAAI,aAAa;EACvB,MAAM,QAAQ,OAAO;EAErB,MAAM,WAAW,CAAC,sBAAsB,OADrB,yBACyB,EAAE,GAAG,aAAa;AAC9D,OAAK,MAAM,QAAQ,SAClB,QAAO,MAAM,aAAa,KAAK;GAE/B,CAEoB,CAAC,KACvB,MAAM,aAAa,qBAAqB,EACxC,MAAM,aAAa,uBAAuB,CAC1C"}

package/dist/substrate/runtime/capability-sinks/service.d.mts

@@ -1,95 +0,0 @@
-import { PluginKey } from "../../brand.mjs";
-import { EngineEvent } from "../../events.mjs";
-import { StrategyContributorDecl } from "../../../contracts/strategy-contributor.mjs";
-import { CapabilityDecl } from "../../../contracts/capability-decl.mjs";
-import { Identity } from "../../identity.mjs";
-import { PluginErrorContribution } from "../../plugin.mjs";
-import { Context, Effect, Layer, Scope } from "effect";
-import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Types0 from "effect/Types";
-
-//#region src/substrate/runtime/capability-sinks/service.d.ts
-/** A single harvested item — either a capability decl OR an error
- *  contribution. Discriminated by the literal `kind`. The supervisor
- *  produces one of these for each item it pulls off a plugin during
- *  the harvest loop. */
-type AnyContribution = {
-  readonly source: 'capability';
-  readonly decl: CapabilityDecl;
-} | {
-  readonly source: 'error';
-  readonly contribution: PluginErrorContribution;
-};
-/** The discriminator the sinks register against. Substrate-owned
- *  literal vocabulary — plugins authoring a custom contract add a new
- *  literal and a sink. */
-type ContributionKind = 'snapshotable' | 'routable' | 'codegenable' | 'projection' | 'strategy-contributor' | 'error-contribution' | (string & {
-  readonly __extensionKind?: never;
-});
-/** Context the harvest loop supplies to each sink invocation. Carries
- *  the plugin's key + identity so sinks can attribute their work
- *  without naming the plugin. `publish` is the supervisor-owned event
- *  path, so sink-emitted events keep the same ordering/projection
- *  semantics as lifecycle/log/error events. The plugin scope is
- *  exposed via `Scope.Scope` in the sink's R-channel — sinks
- *  `addFinalizer` lands on the plugin's scope so registrations reap
- *  on plugin teardown. */
-interface HarvestContext {
-  readonly pluginKey: PluginKey;
-  readonly identity: Identity;
-  readonly publish: (event: EngineEvent) => Effect.Effect<void, never, never>;
-  readonly registerStrategy: (decl: StrategyContributorDecl<string, unknown>) => Effect.Effect<void, never, Scope.Scope>;
-}
-/** A sink for a specific contribution kind. `accept` is the
- *  registration body — runs on the plugin's scope so its finalizers
- *  reap on plugin teardown. */
-interface CapabilitySink<K extends ContributionKind, TDecl> {
-  readonly kind: K;
-  readonly accept: (decl: TDecl, ctx: HarvestContext) => Effect.Effect<void, unknown, Scope.Scope>;
-}
-declare const UnknownContributionKind_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "UnknownContributionKind";
-} & Readonly<A>;
-/** Surfaced when `dispatch` receives a kind no sink is registered for.
- *  Substrate stays open by default — unknown kinds are no-ops at the
- *  supervisor's call site (see `dispatchOrIgnore`); but tests + custom
- *  callers can drive the strict surface via `dispatch`. */
-declare class UnknownContributionKind extends UnknownContributionKind_base<{
-  readonly kind: string;
-  readonly known: ReadonlyArray<string>;
-}> {}
-declare const ContributionSinkFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "ContributionSinkFailed";
-} & Readonly<A>;
-/** Surfaced when a registered sink rejects while handling a known
- *  contribution kind. The original failure stays attached as `cause`
- *  so the supervisor's structured error renderer shows the domain
- *  error, such as `RouteCollision`, underneath the dispatch wrapper. */
-declare class ContributionSinkFailed extends ContributionSinkFailed_base<{
-  readonly kind: string;
-  readonly message: string;
-  readonly cause: unknown;
-}> {}
-interface CapabilitySinksShape {
-  /** Register a sink for a contribution kind. Last-write-wins on
-   *  duplicate kinds: a plugin-author overlay shadows the built-in
-   *  (the highest-seq surviving registration wins at `dispatch`).
-   *  Scope-bound: registering inside a `Layer` and providing the
-   *  layer to the supervisor's scope reaps the sink on shutdown.
-   *  Closing an overlay's scope un-shadows the built-in WITHOUT
-   *  clobbering any newer sibling registration for the same kind —
-   *  the scoped-multimap drops only this registration's own entry. */
-  readonly registerSink: <K extends ContributionKind, TDecl>(sink: CapabilitySink<K, TDecl>) => Effect.Effect<void, never, Scope.Scope>;
-  /** Dispatch a contribution to its registered sink. Errors with
-   *  `UnknownContributionKind` when no sink matches; the supervisor's
-   *  loop catches and downgrades to a no-op (per the
-   *  substrate-open-by-default rule). */
-  readonly dispatch: (contribution: AnyContribution, ctx: HarvestContext) => Effect.Effect<void, UnknownContributionKind | ContributionSinkFailed, Scope.Scope>;
-  /** Snapshot the kinds the registry currently knows. Diagnostic. */
-  readonly knownKinds: Effect.Effect<ReadonlyArray<string>>;
-}
-declare const CapabilitySinksService_base: Context.ServiceClass<CapabilitySinksService, "@devstack/substrate/CapabilitySinks", CapabilitySinksShape>;
-declare class CapabilitySinksService extends CapabilitySinksService_base {}
-//#endregion
-export { AnyContribution, CapabilitySink, CapabilitySinksService, CapabilitySinksShape, ContributionKind, ContributionSinkFailed, HarvestContext, UnknownContributionKind };
-//# sourceMappingURL=service.d.mts.map

package/dist/substrate/runtime/capability-sinks/service.mjs

@@ -1,69 +0,0 @@
-import { SpanAttr } from "../observability/spans.mjs";
-import { makeScopedMultimap } from "../scoped-multimap/service.mjs";
-import "../scoped-multimap/index.mjs";
-import { Context, Data, Effect, Layer } from "effect";
-//#region src/substrate/runtime/capability-sinks/service.ts
-/** Surfaced when `dispatch` receives a kind no sink is registered for.
-*  Substrate stays open by default — unknown kinds are no-ops at the
-*  supervisor's call site (see `dispatchOrIgnore`); but tests + custom
-*  callers can drive the strict surface via `dispatch`. */
-var UnknownContributionKind = class extends Data.TaggedError("UnknownContributionKind") {};
-/** Surfaced when a registered sink rejects while handling a known
-*  contribution kind. The original failure stays attached as `cause`
-*  so the supervisor's structured error renderer shows the domain
-*  error, such as `RouteCollision`, underneath the dispatch wrapper. */
-var ContributionSinkFailed = class extends Data.TaggedError("ContributionSinkFailed") {};
-var CapabilitySinksService = class extends Context.Service()("@devstack/substrate/CapabilitySinks") {};
-/** Derive the discriminator literal from a harvested contribution.
-*  Substrate name-blindness: this is the ONE place the substrate
-*  reads a `kind` off a decl — every other site routes through the
-*  registered sink, which interprets the payload. */
-const kindOf = (contribution) => {
-	if (contribution.source === "error") return "error-contribution";
-	return contribution.decl.kind;
-};
-/** Layer constructing an empty registry. Built-in sinks ship via the
-*  composed `layerCapabilitySinksDefault` (see `layer.ts`); plugin-
-*  authored sinks compose by providing a Layer that yields the
-*  service and calls `registerSink`. */
-const layerCapabilitySinks = Layer.effect(CapabilitySinksService, Effect.gen(function* () {
-	const store = yield* makeScopedMultimap();
-	const registerSink = (sink) => Effect.gen(function* () {
-		const accept = sink.accept;
-		yield* store.register([{
-			key: sink.kind,
-			value: accept
-		}]);
-		yield* Effect.annotateCurrentSpan({ [SpanAttr.capabilitySinksKind]: sink.kind });
-	}).pipe(Effect.withSpan("substrate.capabilitySinks.registerSink"));
-	const dispatch = (contribution, ctx) => Effect.gen(function* () {
-		const kind = kindOf(contribution);
-		const entries = yield* store.entriesFor(kind);
-		if (entries.length === 0) return yield* new UnknownContributionKind({
-			kind,
-			known: yield* store.keys
-		});
-		let chosen = entries[0];
-		for (let i = 1; i < entries.length; i++) if (entries[i].seq > chosen.seq) chosen = entries[i];
-		const accept = chosen.value;
-		yield* accept(contribution.source === "error" ? contribution.contribution : contribution.decl, ctx).pipe(Effect.mapError((cause) => new ContributionSinkFailed({
-			kind,
-			message: `capability sink '${kind}' failed`,
-			cause
-		})));
-		yield* Effect.annotateCurrentSpan({
-			[SpanAttr.capabilitySinksKind]: kind,
-			[SpanAttr.plugin]: ctx.pluginKey
-		});
-	}).pipe(Effect.withSpan("substrate.capabilitySinks.dispatch"));
-	const knownKinds = store.keys;
-	return CapabilitySinksService.of({
-		registerSink,
-		dispatch,
-		knownKinds
-	});
-}));
-//#endregion
-export { CapabilitySinksService, ContributionSinkFailed, UnknownContributionKind, kindOf, layerCapabilitySinks };
-
-//# sourceMappingURL=service.mjs.map

package/dist/substrate/runtime/capability-sinks/service.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"service.mjs","names":[],"sources":["../../../../src/substrate/runtime/capability-sinks/service.ts"],"sourcesContent":["// CapabilitySinks — kind→sink registry.\n//\n// Architecture § Substrate name-blindness (STYLE_GUIDE Open slot O6):\n// the supervisor used to import a hardcoded list of capability-decl\n// modules and dispatch by name on a switch. This module inverts that:\n// the substrate exposes an Effect.Service the supervisor consults\n// once per harvested contribution; plugin-authored kinds can be\n// registered via the same surface that ships the built-ins. Adding a\n// new capability contract is `registerSink({ kind, accept })` — no\n// supervisor edit required.\n//\n// The dispatch is structural on the `kind` literal of the contribution.\n// The substrate never inspects the contribution's payload; the sink's\n// `accept` body owns interpretation. The substrate never imports a\n// concrete plugin module.\n\nimport { Context, Data, Effect, Layer, Scope } from 'effect';\n\nimport type { CapabilityDecl } from '../../../contracts/capability-decl.ts';\nimport type { StrategyContributorDecl } from '../../../contracts/strategy-contributor.ts';\nimport type { PluginKey } from '../../brand.ts';\nimport type { EngineEvent } from '../../events.ts';\nimport type { Identity } from '../../identity.ts';\nimport type { PluginErrorContribution } from '../../plugin.ts';\nimport { SpanAttr } from '../observability/spans.ts';\nimport { makeScopedMultimap } from '../scoped-multimap/index.ts';\n\n// -----------------------------------------------------------------------------\n// Contribution surface\n// -----------------------------------------------------------------------------\n\n/** A single harvested item — either a capability decl OR an error\n *  contribution. Discriminated by the literal `kind`. The supervisor\n *  produces one of these for each item it pulls off a plugin during\n *  the harvest loop. */\nexport type AnyContribution =\n\t| { readonly source: 'capability'; readonly decl: CapabilityDecl }\n\t| { readonly source: 'error'; readonly contribution: PluginErrorContribution };\n\n/** The discriminator the sinks register against. Substrate-owned\n *  literal vocabulary — plugins authoring a custom contract add a new\n *  literal and a sink. */\nexport type ContributionKind =\n\t| 'snapshotable'\n\t| 'routable'\n\t| 'codegenable'\n\t| 'projection'\n\t| 'strategy-contributor'\n\t| 'error-contribution'\n\t| (string & { readonly __extensionKind?: never });\n\n// -----------------------------------------------------------------------------\n// Harvest context\n// -----------------------------------------------------------------------------\n\n/** Context the harvest loop supplies to each sink invocation. Carries\n *  the plugin's key + identity so sinks can attribute their work\n *  without naming the plugin. `publish` is the supervisor-owned event\n *  path, so sink-emitted events keep the same ordering/projection\n *  semantics as lifecycle/log/error events. The plugin scope is\n *  exposed via `Scope.Scope` in the sink's R-channel — sinks\n *  `addFinalizer` lands on the plugin's scope so registrations reap\n *  on plugin teardown. */\nexport interface HarvestContext {\n\treadonly pluginKey: PluginKey;\n\treadonly identity: Identity;\n\treadonly publish: (event: EngineEvent) => Effect.Effect<void, never, never>;\n\treadonly registerStrategy: (\n\t\tdecl: StrategyContributorDecl<string, unknown>,\n\t) => Effect.Effect<void, never, Scope.Scope>;\n}\n\n// -----------------------------------------------------------------------------\n// Sink shape\n// -----------------------------------------------------------------------------\n\n/** A sink for a specific contribution kind. `accept` is the\n *  registration body — runs on the plugin's scope so its finalizers\n *  reap on plugin teardown. */\nexport interface CapabilitySink<K extends ContributionKind, TDecl> {\n\treadonly kind: K;\n\treadonly accept: (decl: TDecl, ctx: HarvestContext) => Effect.Effect<void, unknown, Scope.Scope>;\n}\n\n// -----------------------------------------------------------------------------\n// Dispatch errors\n// -----------------------------------------------------------------------------\n\n/** Surfaced when `dispatch` receives a kind no sink is registered for.\n *  Substrate stays open by default — unknown kinds are no-ops at the\n *  supervisor's call site (see `dispatchOrIgnore`); but tests + custom\n *  callers can drive the strict surface via `dispatch`. */\nexport class UnknownContributionKind extends Data.TaggedError('UnknownContributionKind')<{\n\treadonly kind: string;\n\treadonly known: ReadonlyArray<string>;\n}> {}\n\n/** Surfaced when a registered sink rejects while handling a known\n *  contribution kind. The original failure stays attached as `cause`\n *  so the supervisor's structured error renderer shows the domain\n *  error, such as `RouteCollision`, underneath the dispatch wrapper. */\nexport class ContributionSinkFailed extends Data.TaggedError('ContributionSinkFailed')<{\n\treadonly kind: string;\n\treadonly message: string;\n\treadonly cause: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Public service shape\n// -----------------------------------------------------------------------------\n\nexport interface CapabilitySinksShape {\n\t/** Register a sink for a contribution kind. Last-write-wins on\n\t *  duplicate kinds: a plugin-author overlay shadows the built-in\n\t *  (the highest-seq surviving registration wins at `dispatch`).\n\t *  Scope-bound: registering inside a `Layer` and providing the\n\t *  layer to the supervisor's scope reaps the sink on shutdown.\n\t *  Closing an overlay's scope un-shadows the built-in WITHOUT\n\t *  clobbering any newer sibling registration for the same kind —\n\t *  the scoped-multimap drops only this registration's own entry. */\n\treadonly registerSink: <K extends ContributionKind, TDecl>(\n\t\tsink: CapabilitySink<K, TDecl>,\n\t) => Effect.Effect<void, never, Scope.Scope>;\n\t/** Dispatch a contribution to its registered sink. Errors with\n\t *  `UnknownContributionKind` when no sink matches; the supervisor's\n\t *  loop catches and downgrades to a no-op (per the\n\t *  substrate-open-by-default rule). */\n\treadonly dispatch: (\n\t\tcontribution: AnyContribution,\n\t\tctx: HarvestContext,\n\t) => Effect.Effect<void, UnknownContributionKind | ContributionSinkFailed, Scope.Scope>;\n\t/** Snapshot the kinds the registry currently knows. Diagnostic. */\n\treadonly knownKinds: Effect.Effect<ReadonlyArray<string>>;\n}\n\nexport class CapabilitySinksService extends Context.Service<\n\tCapabilitySinksService,\n\tCapabilitySinksShape\n>()('@devstack/substrate/CapabilitySinks') {}\n\n// -----------------------------------------------------------------------------\n// Implementation helper — kind extraction\n// -----------------------------------------------------------------------------\n\n/** Derive the discriminator literal from a harvested contribution.\n *  Substrate name-blindness: this is the ONE place the substrate\n *  reads a `kind` off a decl — every other site routes through the\n *  registered sink, which interprets the payload. */\nexport const kindOf = (contribution: AnyContribution): ContributionKind => {\n\tif (contribution.source === 'error') return 'error-contribution';\n\t// `decl.kind` is a literal on every CapabilityDecl variant; we\n\t// trust the substrate-owned contract here.\n\treturn contribution.decl.kind;\n};\n\n// -----------------------------------------------------------------------------\n// Layer\n// -----------------------------------------------------------------------------\n\ntype SinkAccept = (decl: unknown, ctx: HarvestContext) => Effect.Effect<void, unknown, Scope.Scope>;\n\n/** Layer constructing an empty registry. Built-in sinks ship via the\n *  composed `layerCapabilitySinksDefault` (see `layer.ts`); plugin-\n *  authored sinks compose by providing a Layer that yields the\n *  service and calls `registerSink`. */\nexport const layerCapabilitySinks: Layer.Layer<CapabilitySinksService> = Layer.effect(\n\tCapabilitySinksService,\n\tEffect.gen(function* () {\n\t\t// Seq-tagged multimap, NOT a single-value-per-kind map. The old\n\t\t// shape stored one accept per kind and restored a captured\n\t\t// `prior` on scope close — correct only under strict LIFO. With\n\t\t// sibling scopes (an overlay registered while another overlay for\n\t\t// the same kind is still live) the first to close would restore\n\t\t// ITS stale `prior` and clobber the live sibling. The multimap's\n\t\t// drop-by-seq finalizer removes only this registration's entry,\n\t\t// so the surviving highest-seq sink keeps winning regardless of\n\t\t// close order.\n\t\tconst store = yield* makeScopedMultimap<string, SinkAccept>();\n\n\t\tconst registerSink = <K extends ContributionKind, TDecl>(\n\t\t\tsink: CapabilitySink<K, TDecl>,\n\t\t): Effect.Effect<void, never, Scope.Scope> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst accept = sink.accept as SinkAccept;\n\t\t\t\t// The multimap's register is already uninterruptible and\n\t\t\t\t// wires the drop-by-seq finalizer atomically with the\n\t\t\t\t// append (mirrors `leaseBroker.tryAcquire`).\n\t\t\t\tyield* store.register([{ key: sink.kind, value: accept }]);\n\t\t\t\tyield* Effect.annotateCurrentSpan({\n\t\t\t\t\t[SpanAttr.capabilitySinksKind]: sink.kind,\n\t\t\t\t});\n\t\t\t}).pipe(Effect.withSpan('substrate.capabilitySinks.registerSink'));\n\n\t\tconst dispatch = (\n\t\t\tcontribution: AnyContribution,\n\t\t\tctx: HarvestContext,\n\t\t): Effect.Effect<void, UnknownContributionKind | ContributionSinkFailed, Scope.Scope> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst kind = kindOf(contribution);\n\t\t\t\tconst entries = yield* store.entriesFor(kind);\n\t\t\t\tif (entries.length === 0) {\n\t\t\t\t\tconst known = yield* store.keys;\n\t\t\t\t\treturn yield* new UnknownContributionKind({ kind, known });\n\t\t\t\t}\n\t\t\t\t// Last-write-wins: the highest-seq surviving registration\n\t\t\t\t// is the active sink for this kind.\n\t\t\t\tlet chosen = entries[0]!;\n\t\t\t\tfor (let i = 1; i < entries.length; i++) {\n\t\t\t\t\tif (entries[i]!.seq > chosen.seq) chosen = entries[i]!;\n\t\t\t\t}\n\t\t\t\tconst accept = chosen.value;\n\t\t\t\tconst payload: unknown =\n\t\t\t\t\tcontribution.source === 'error' ? contribution.contribution : contribution.decl;\n\t\t\t\tyield* accept(payload, ctx).pipe(\n\t\t\t\t\tEffect.mapError(\n\t\t\t\t\t\t(cause) =>\n\t\t\t\t\t\t\tnew ContributionSinkFailed({\n\t\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\t\tmessage: `capability sink '${kind}' failed`,\n\t\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t\tyield* Effect.annotateCurrentSpan({\n\t\t\t\t\t[SpanAttr.capabilitySinksKind]: kind,\n\t\t\t\t\t[SpanAttr.plugin]: ctx.pluginKey,\n\t\t\t\t});\n\t\t\t}).pipe(Effect.withSpan('substrate.capabilitySinks.dispatch'));\n\n\t\tconst knownKinds: Effect.Effect<ReadonlyArray<string>> = store.keys;\n\n\t\treturn CapabilitySinksService.of({ registerSink, dispatch, knownKinds });\n\t}),\n);\n"],"mappings":";;;;;;;;;AA4FA,IAAa,0BAAb,cAA6C,KAAK,YAAY,0BAA0B,CAGrF;;;;;AAMH,IAAa,yBAAb,cAA4C,KAAK,YAAY,yBAAyB,CAInF;AA8BH,IAAa,yBAAb,cAA4C,QAAQ,SAGjD,CAAC,sCAAsC,CAAC;;;;;AAU3C,MAAa,UAAU,iBAAoD;AAC1E,KAAI,aAAa,WAAW,QAAS,QAAO;AAG5C,QAAO,aAAa,KAAK;;;;;;AAa1B,MAAa,uBAA4D,MAAM,OAC9E,wBACA,OAAO,IAAI,aAAa;CAUvB,MAAM,QAAQ,OAAO,oBAAwC;CAE7D,MAAM,gBACL,SAEA,OAAO,IAAI,aAAa;EACvB,MAAM,SAAS,KAAK;AAIpB,SAAO,MAAM,SAAS,CAAC;GAAE,KAAK,KAAK;GAAM,OAAO;GAAQ,CAAC,CAAC;AAC1D,SAAO,OAAO,oBAAoB,GAChC,SAAS,sBAAsB,KAAK,MACrC,CAAC;GACD,CAAC,KAAK,OAAO,SAAS,yCAAyC,CAAC;CAEnE,MAAM,YACL,cACA,QAEA,OAAO,IAAI,aAAa;EACvB,MAAM,OAAO,OAAO,aAAa;EACjC,MAAM,UAAU,OAAO,MAAM,WAAW,KAAK;AAC7C,MAAI,QAAQ,WAAW,EAEtB,QAAO,OAAO,IAAI,wBAAwB;GAAE;GAAM,OAAA,OAD7B,MAAM;GAC8B,CAAC;EAI3D,IAAI,SAAS,QAAQ;AACrB,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,IACnC,KAAI,QAAQ,GAAI,MAAM,OAAO,IAAK,UAAS,QAAQ;EAEpD,MAAM,SAAS,OAAO;AAGtB,SAAO,OADN,aAAa,WAAW,UAAU,aAAa,eAAe,aAAa,MACrD,IAAI,CAAC,KAC3B,OAAO,UACL,UACA,IAAI,uBAAuB;GAC1B;GACA,SAAS,oBAAoB,KAAK;GAClC;GACA,CAAC,CACH,CACD;AACD,SAAO,OAAO,oBAAoB;IAChC,SAAS,sBAAsB;IAC/B,SAAS,SAAS,IAAI;GACvB,CAAC;GACD,CAAC,KAAK,OAAO,SAAS,qCAAqC,CAAC;CAE/D,MAAM,aAAmD,MAAM;AAE/D,QAAO,uBAAuB,GAAG;EAAE;EAAc;EAAU;EAAY,CAAC;EACvE,CACF"}

package/dist/substrate/runtime/cross-process/lock.d.mts

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

package/dist/substrate/runtime/cross-process/lock.mjs

@@ -1,23 +0,0 @@
-import { StackPathsService } from "../paths.mjs";
-import { underLiveClock } from "./live-clock.mjs";
-import { acquireStackLock } from "./stack-lock.mjs";
-import { Context, Effect, Layer, Semaphore } from "effect";
-//#region src/substrate/runtime/cross-process/lock.ts
-var CrossProcessLock = class extends Context.Service()("@devstack/substrate/CrossProcessLock") {};
-Layer.effect(CrossProcessLock, Effect.gen(function* () {
-	const paths = yield* StackPathsService;
-	const semaphore = yield* Semaphore.make(1);
-	const lockPath = paths.stackLockFile;
-	return CrossProcessLock.of({ withLock: (effect) => semaphore.withPermits(1)(Effect.scoped(Effect.gen(function* () {
-		yield* underLiveClock(acquireStackLock(lockPath));
-		return yield* effect;
-	}))) });
-}));
-Layer.effect(CrossProcessLock, Effect.gen(function* () {
-	const semaphore = yield* Semaphore.make(1);
-	return CrossProcessLock.of({ withLock: (effect) => semaphore.withPermits(1)(effect) });
-}));
-//#endregion
-export { CrossProcessLock };
-
-//# sourceMappingURL=lock.mjs.map

package/dist/substrate/runtime/cross-process/lock.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lock.mjs","names":[],"sources":["../../../../src/substrate/runtime/cross-process/lock.ts"],"sourcesContent":["// Cross-process advisory lock — typed service + two Layers.\n//\n// Architecture § \"What's collapsed\" — three different locks in the\n// old codebase consolidate to ONE lock primitive. The on-disk\n// implementation (`stack.lock` via O_EXCL + PID/start-time liveness)\n// lives at `./stack-lock.ts` as a free function; THIS module wraps\n// it in a Layer satisfying the typed `CrossProcessLock` service so\n// consumers (state-store, cache, etc.) yield ONE name and let\n// wiring decide whether they get the OS-advisory implementation or\n// the in-process semaphore.\n//\n// The state-store uses this for read-modify-write critical sections\n// where two processes might race to mutate the JSON. The lock is\n// SHORT-CRITICAL-SECTION: hold across read+modify+atomic-write,\n// release immediately. Long lifetimes (whole-stack lifecycle) belong\n// to a separate lease, not this lock.\n\nimport { Context, Effect, Layer, Semaphore } from 'effect';\n\nimport { StackPathsService } from '../paths.ts';\nimport { underLiveClock } from './live-clock.ts';\nimport {\n\tacquireStackLock,\n\ttype StackLockIoError,\n\ttype StackLockTimeoutError,\n} from './stack-lock.ts';\n\n/**\n * Cross-process exclusive lock. `withLock(effect)` runs `effect`\n * with the lock held — semantically `Semaphore.withPermits(1)` plus\n * cross-process fanout via the OS.\n *\n * Acquisition is cancellable: an interrupt while waiting for the\n * lock unwinds without acquiring. Acquisition while another holder\n * dies (PID cleanup) is the lock primitive's job, not the\n * state-store's.\n *\n * Acquisition surfaces `StackLockTimeoutError` (peer contention\n * exceeded the acquire window) and `StackLockIoError` (disk failure\n * during acquire) in the `E` channel alongside the body's own errors.\n * Consumers MUST handle these typed failures — either degrade\n * gracefully via `Effect.catchTag` or widen their own `E` channel.\n * Surfacing them as defects (the prior `Effect.orDie` shape) was a\n * bug: a busy peer should not crash the supervisor's fiber. The\n * in-process Layer's typed `E` channel matches `never` for the\n * acquire surface so test wiring stays interchangeable with prod\n * (the union absorbs `never` cleanly).\n */\nexport interface CrossProcessLockShape {\n\treadonly withLock: <A, E, R>(\n\t\teffect: Effect.Effect<A, E, R>,\n\t) => Effect.Effect<A, E | StackLockTimeoutError | StackLockIoError, R>;\n}\n\nexport class CrossProcessLock extends Context.Service<CrossProcessLock, CrossProcessLockShape>()(\n\t'@devstack/substrate/CrossProcessLock',\n) {}\n\n/**\n * Production Layer — backed by `stack.lock` (O_EXCL + PID/start-time\n * liveness) per architecture § Cross-process safety protocol. Yields\n * `StackPathsService` to know which on-disk lock file represents\n * this stack; every `withLock` runs the body inside an\n * `Effect.scoped` that acquires + releases the OS-advisory lock.\n *\n * An in-process `Semaphore` sits in front of the disk acquire so\n * SAME-process concurrent yielders of `CrossProcessLock` serialize\n * before competing for the disk artifact. Without this, two fibers\n * in the same process race each other to `O_EXCL`-write the same\n * path; one wins, the other times out unnecessarily after backoff.\n *\n * Acquisition surfaces `StackLockTimeoutError` / `StackLockIoError`\n * in the `E` channel per `CrossProcessLockShape`; consumers catch\n * via `Effect.catchTag` or widen their own surface. The earlier\n * `Effect.orDie` here converted legitimate peer-contention timeouts\n * into supervisor defects — that was wrong; busy peers must be\n * recoverable through the typed channel.\n */\nexport const layerCrossProcessLockFlock: Layer.Layer<CrossProcessLock, never, StackPathsService> =\n\tLayer.effect(\n\t\tCrossProcessLock,\n\t\tEffect.gen(function* () {\n\t\t\tconst paths = yield* StackPathsService;\n\t\t\tconst semaphore = yield* Semaphore.make(1);\n\t\t\tconst lockPath = paths.stackLockFile;\n\t\t\treturn CrossProcessLock.of({\n\t\t\t\twithLock: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n\t\t\t\t\t// Acquire/release infrastructure runs under live clock\n\t\t\t\t\t// (OS-advisory lock retry backoff needs wall time — see\n\t\t\t\t\t// LIVE_CLOCK). The user body inherits the caller's\n\t\t\t\t\t// clock so TestClock-driven tests can virtualize\n\t\t\t\t\t// `Effect.sleep` inside the critical section.\n\t\t\t\t\t//\n\t\t\t\t\t// `semaphore.withPermits(1)` keeps SAME-process fibers\n\t\t\t\t\t// serialized before they race for the on-disk artifact;\n\t\t\t\t\t// permit release fires on body completion, failure, AND\n\t\t\t\t\t// interrupt via the semaphore's own finalizer.\n\t\t\t\t\t// `Effect.scoped` owns the on-disk acquire so its\n\t\t\t\t\t// finalizer (registered by `acquireStackLock`) unlinks\n\t\t\t\t\t// `stack.lock` on the same lifecycle.\n\t\t\t\t\tsemaphore.withPermits(1)(\n\t\t\t\t\t\tEffect.scoped(\n\t\t\t\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\t\t\t\tyield* underLiveClock(acquireStackLock(lockPath));\n\t\t\t\t\t\t\t\treturn yield* effect;\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t});\n\t\t}),\n\t);\n\n/**\n * In-process-only fallback. Useful for tests and single-process dev\n * loops where no other OS process can interleave with this\n * supervisor. Production wiring uses `layerCrossProcessLockFlock`.\n *\n * Documented in the architecture as acceptable for \"no cross-process\n * safety needed\" use cases (one-shot CLI invocations, unit tests\n * with a tmpdir per-test, etc.). NOT safe under `pnpm dev` where\n * A dev server and devstack share a runtime root.\n */\nexport const layerCrossProcessLockInProcess: Layer.Layer<CrossProcessLock> = Layer.effect(\n\tCrossProcessLock,\n\tEffect.gen(function* () {\n\t\tconst semaphore = yield* Semaphore.make(1);\n\t\treturn CrossProcessLock.of({\n\t\t\t// No on-disk acquire here, so there's no wall-time backoff to\n\t\t\t// pin — `semaphore.withPermits(1)` parks on a queue without\n\t\t\t// `Effect.sleep`, so it tolerates TestClock natively. The\n\t\t\t// body inherits the caller's clock by construction; no\n\t\t\t// `underLiveClock` wrap.\n\t\t\twithLock: (effect) => semaphore.withPermits(1)(effect),\n\t\t});\n\t}),\n);\n"],"mappings":";;;;;AAsDA,IAAa,mBAAb,cAAsC,QAAQ,SAAkD,CAC/F,uCACA,CAAC;AAuBD,MAAM,OACL,kBACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO;CACrB,MAAM,YAAY,OAAO,UAAU,KAAK,EAAE;CAC1C,MAAM,WAAW,MAAM;AACvB,QAAO,iBAAiB,GAAG,EAC1B,WAAoB,WAcnB,UAAU,YAAY,EAAE,CACvB,OAAO,OACN,OAAO,IAAI,aAAa;AACvB,SAAO,eAAe,iBAAiB,SAAS,CAAC;AACjD,SAAO,OAAO;GACb,CACF,CACD,EACF,CAAC;EACD,CACF;AAY2E,MAAM,OAClF,kBACA,OAAO,IAAI,aAAa;CACvB,MAAM,YAAY,OAAO,UAAU,KAAK,EAAE;AAC1C,QAAO,iBAAiB,GAAG,EAM1B,WAAW,WAAW,UAAU,YAAY,EAAE,CAAC,OAAO,EACtD,CAAC;EACD,CACF"}

package/dist/substrate/runtime/cross-process/snapshot-reservation.mjs

@@ -1,113 +0,0 @@
-import { SpanAttr } from "../observability/spans.mjs";
-import { selfPid } from "./self-pid.mjs";
-import { SnapshotReservationSchema } from "../../cross-process.mjs";
-import { parseVersionedDocumentBodyOrNull } from "../../versioned-doc-sync.mjs";
-import { checkHolderLiveness } from "./liveness.mjs";
-import { reclaimUnparseableStaleFile } from "./reclaim-stale-file.mjs";
-import { Data, Effect } from "effect";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { hostname } from "node:os";
-//#region src/substrate/runtime/cross-process/snapshot-reservation.ts
-var SnapshotReservationHeldError = class extends Data.TaggedError("SnapshotReservationHeldError") {};
-var SnapshotReservationIoError = class extends Data.TaggedError("SnapshotReservationIoError") {};
-const parseReservation = (raw) => parseVersionedDocumentBodyOrNull(raw, SnapshotReservationSchema, "snapshot.reservation");
-const ownReservation = (startTime) => ({
-	version: 1,
-	creatorPid: selfPid(),
-	creatorStartTime: startTime,
-	createdAt: Date.now(),
-	hostname: hostname()
-});
-/**
-* Sweep an orphaned reservation. If the file exists AND its creator is
-* dead, unlink it. Returns whether a sweep happened so callers can
-* observe / report.
-*
-* Architecture § Concurrent snapshot last paragraph:
-*   "If the snapshotting process crashes mid-snapshot, the reservation
-*    file persists. The next process's claim-protocol sweep detects an
-*    orphan reservation (the holder whose pid matches the
-*    reservation's creator entry is dead) and unlinks it."
-*/
-const sweepOrphan = (path) => Effect.gen(function* () {
-	yield* Effect.annotateCurrentSpan({ [SpanAttr.snapshotReservationPath]: path });
-	if (!existsSync(path)) return { swept: false };
-	const reservation = parseReservation(yield* Effect.try({
-		try: () => readFileSync(path, "utf8"),
-		catch: (cause) => new SnapshotReservationIoError({
-			path,
-			cause
-		})
-	}));
-	if (reservation === null) return { swept: (yield* Effect.try({
-		try: () => reclaimUnparseableStaleFile(path, parseReservation),
-		catch: (cause) => new SnapshotReservationIoError({
-			path,
-			cause
-		})
-	})) === "reclaimed" };
-	const ownHost = hostname();
-	if (reservation.hostname !== ownHost) return { swept: false };
-	if ((yield* checkHolderLiveness({
-		pid: reservation.creatorPid,
-		startTime: reservation.creatorStartTime,
-		hostname: reservation.hostname,
-		claimedAt: reservation.createdAt,
-		heartbeatAt: reservation.createdAt,
-		intent: "snapshot"
-	}, ownHost).pipe(Effect.catch(() => Effect.succeed("alive")))) === "alive") return { swept: false };
-	yield* Effect.try({
-		try: () => unlinkSync(path),
-		catch: (cause) => new SnapshotReservationIoError({
-			path,
-			cause
-		})
-	});
-	return { swept: true };
-}).pipe(Effect.withSpan("cross-process.snapshot-reservation.sweepOrphan"));
-/**
-* Acquire the snapshot reservation as a scoped resource. The
-* reservation is unlinked when the surrounding Scope closes.
-*
-* Architecture § Concurrent snapshot step 1: O_EXCL create, no retry.
-* Callers that fail with `SnapshotReservationHeldError` propagate the
-* structured "snapshot in progress" error to the user — the typical
-* `Effect.catchTag` shape.
-*
-* `startTime` is the same value the roster carries for THIS process so
-* the orphan sweep's pid-startTime check resolves identically.
-*/
-const acquireReservation = (path, startTime) => Effect.gen(function* () {
-	yield* Effect.annotateCurrentSpan({ [SpanAttr.snapshotReservationPath]: path });
-	yield* sweepOrphan(path);
-	const body = ownReservation(startTime);
-	yield* Effect.try({
-		try: () => writeFileSync(path, JSON.stringify(body), { flag: "wx" }),
-		catch: (cause) => {
-			if (cause.code === "EEXIST") {
-				let holder = null;
-				try {
-					holder = parseReservation(readFileSync(path, "utf8"));
-				} catch {}
-				return new SnapshotReservationHeldError({
-					path,
-					holder
-				});
-			}
-			return new SnapshotReservationIoError({
-				path,
-				cause
-			});
-		}
-	});
-	yield* Effect.addFinalizer(() => Effect.sync(() => {
-		try {
-			unlinkSync(path);
-		} catch {}
-	}));
-	return body;
-}).pipe(Effect.withSpan("cross-process.snapshot-reservation.acquire"));
-//#endregion
-export { SnapshotReservationHeldError, SnapshotReservationIoError, acquireReservation, sweepOrphan };
-
-//# sourceMappingURL=snapshot-reservation.mjs.map

package/dist/substrate/runtime/cross-process/snapshot-reservation.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-reservation.mjs","names":["nodeHostname"],"sources":["../../../../src/substrate/runtime/cross-process/snapshot-reservation.ts"],"sourcesContent":["// `snapshot.reservation` — presence-or-absence semaphore.\n//\n// Architecture § Cross-process safety protocol § Concurrent snapshot:\n//   \"Snapshot requires exclusive control of the stack's container set\n//   (pause-around-commit means peer processes' ready-probes would fail\n//   if uncoordinated). The snapshotting process acquires\n//   `snapshot.reservation` via O_EXCL create. If creation fails (peer\n//   holds it), the snapshot refuses with a structured 'snapshot in\n//   progress by peer pid X' error.\"\n//\n// Discipline:\n//   - Acquire is atomic O_EXCL create with a JSON body carrying\n//     `{ version: 1, creatorPid, creatorStartTime, createdAt, hostname }`.\n//   - Release is `unlink`.\n//   - Orphan sweep: on the next claim, the body's `hostname` is checked\n//     first. Foreign-host reservations short-circuit as alive (NFS-safe\n//     conservative default — `kill(pid, 0)` is meaningless on a remote\n//     kernel). Same-host reservations fall through to the PID +\n//     start-time check, which mirrors the roster's stale-PID reclaim.\n//   - Acquire DOES NOT retry — snapshot is a one-shot intent; the\n//     caller surfaces the structured error to the user immediately.\n\nimport { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { hostname as nodeHostname } from 'node:os';\n\nimport { Data, Effect, Scope } from 'effect';\n\nimport { type SnapshotReservation, SnapshotReservationSchema } from '../../cross-process.ts';\nimport { parseVersionedDocumentBodyOrNull } from '../../versioned-doc-sync.ts';\nimport { SpanAttr } from '../observability/spans.ts';\nimport { checkHolderLiveness } from './liveness.ts';\nimport { reclaimUnparseableStaleFile } from './reclaim-stale-file.ts';\nimport { selfPid } from './self-pid.ts';\n\n// -----------------------------------------------------------------------------\n// Errors\n// -----------------------------------------------------------------------------\n\nexport class SnapshotReservationHeldError extends Data.TaggedError('SnapshotReservationHeldError')<{\n\treadonly path: string;\n\treadonly holder: SnapshotReservation | null;\n}> {}\n\nexport class SnapshotReservationIoError extends Data.TaggedError('SnapshotReservationIoError')<{\n\treadonly path: string;\n\treadonly cause: unknown;\n}> {}\n\nexport type SnapshotReservationError = SnapshotReservationHeldError | SnapshotReservationIoError;\n\n// -----------------------------------------------------------------------------\n// Codec\n// -----------------------------------------------------------------------------\n\nconst parseReservation = (raw: string): SnapshotReservation | null =>\n\tparseVersionedDocumentBodyOrNull(raw, SnapshotReservationSchema, 'snapshot.reservation');\n\n// -----------------------------------------------------------------------------\n// Acquire / release\n// -----------------------------------------------------------------------------\n\nconst ownReservation = (startTime: number | null): SnapshotReservation => ({\n\tversion: 1,\n\tcreatorPid: selfPid(),\n\tcreatorStartTime: startTime,\n\tcreatedAt: Date.now(),\n\thostname: nodeHostname(),\n});\n\n/**\n * Sweep an orphaned reservation. If the file exists AND its creator is\n * dead, unlink it. Returns whether a sweep happened so callers can\n * observe / report.\n *\n * Architecture § Concurrent snapshot last paragraph:\n *   \"If the snapshotting process crashes mid-snapshot, the reservation\n *    file persists. The next process's claim-protocol sweep detects an\n *    orphan reservation (the holder whose pid matches the\n *    reservation's creator entry is dead) and unlinks it.\"\n */\nexport const sweepOrphan = (\n\tpath: string,\n): Effect.Effect<{ readonly swept: boolean }, SnapshotReservationError> =>\n\tEffect.gen(function* () {\n\t\tyield* Effect.annotateCurrentSpan({ [SpanAttr.snapshotReservationPath]: path });\n\t\tif (!existsSync(path)) return { swept: false };\n\t\tconst raw = yield* Effect.try({\n\t\t\ttry: () => readFileSync(path, 'utf8'),\n\t\t\tcatch: (cause) => new SnapshotReservationIoError({ path, cause }),\n\t\t});\n\t\tconst reservation = parseReservation(raw);\n\t\tif (reservation === null) {\n\t\t\t// Malformed body — the creator may have written a half-written\n\t\t\t// file. Reclaim ONLY through the shared re-stat guard: gating a\n\t\t\t// bare mtime read + unlink races a competitor who legitimately\n\t\t\t// reclaims the garbage and writes a fresh valid O_EXCL body in\n\t\t\t// the window — the unlink would clobber that LIVE reservation.\n\t\t\t// `reclaimUnparseableStaleFile` honors the SAME mtime staleness\n\t\t\t// window stack-lock uses (a body younger than the window is\n\t\t\t// presumed mid-write and left alone) AND re-confirms the file\n\t\t\t// is still the same stale, unparseable inode immediately before\n\t\t\t// unlinking.\n\t\t\tconst outcome = yield* Effect.try({\n\t\t\t\ttry: () => reclaimUnparseableStaleFile(path, parseReservation),\n\t\t\t\tcatch: (cause) => new SnapshotReservationIoError({ path, cause }),\n\t\t\t});\n\t\t\treturn { swept: outcome === 'reclaimed' };\n\t\t}\n\t\t// Foreign-host reservation: NFS-safe — we cannot probe a remote\n\t\t// kernel for pid liveness, so treat the peer as alive (matches\n\t\t// the roster's `trustForeignHosts` policy). Before adding the\n\t\t// `hostname` field we synthesized a holder with hostname='' and\n\t\t// passed ownHost='', which bypassed the foreign-host fast-path\n\t\t// in `checkHolderLiveness` and probed PID/startTime locally — a\n\t\t// live remote process could be declared dead and its reservation\n\t\t// unlinked. The fix is to short-circuit here.\n\t\tconst ownHost = nodeHostname();\n\t\tif (reservation.hostname !== ownHost) return { swept: false };\n\t\t// PID-liveness check: synthesize a roster-shaped holder so the\n\t\t// shared liveness predicate applies.\n\t\tconst liveness = yield* checkHolderLiveness(\n\t\t\t{\n\t\t\t\tpid: reservation.creatorPid,\n\t\t\t\tstartTime: reservation.creatorStartTime,\n\t\t\t\thostname: reservation.hostname,\n\t\t\t\tclaimedAt: reservation.createdAt,\n\t\t\t\theartbeatAt: reservation.createdAt,\n\t\t\t\tintent: 'snapshot',\n\t\t\t},\n\t\t\townHost,\n\t\t).pipe(Effect.catch(() => Effect.succeed('alive' as const)));\n\t\tif (liveness === 'alive') return { swept: false };\n\t\tyield* Effect.try({\n\t\t\ttry: () => unlinkSync(path),\n\t\t\tcatch: (cause) => new SnapshotReservationIoError({ path, cause }),\n\t\t});\n\t\treturn { swept: true };\n\t}).pipe(Effect.withSpan('cross-process.snapshot-reservation.sweepOrphan'));\n\n/**\n * Acquire the snapshot reservation as a scoped resource. The\n * reservation is unlinked when the surrounding Scope closes.\n *\n * Architecture § Concurrent snapshot step 1: O_EXCL create, no retry.\n * Callers that fail with `SnapshotReservationHeldError` propagate the\n * structured \"snapshot in progress\" error to the user — the typical\n * `Effect.catchTag` shape.\n *\n * `startTime` is the same value the roster carries for THIS process so\n * the orphan sweep's pid-startTime check resolves identically.\n */\nexport const acquireReservation = (\n\tpath: string,\n\tstartTime: number | null,\n): Effect.Effect<SnapshotReservation, SnapshotReservationError, Scope.Scope> =>\n\tEffect.gen(function* () {\n\t\tyield* Effect.annotateCurrentSpan({ [SpanAttr.snapshotReservationPath]: path });\n\t\t// One-shot orphan sweep before our O_EXCL attempt. The sweep is\n\t\t// idempotent: if a peer just wrote the reservation while we ran\n\t\t// the sweep, the O_EXCL create fails below and we surface the\n\t\t// structured \"held\" error.\n\t\tyield* sweepOrphan(path);\n\t\tconst body = ownReservation(startTime);\n\t\tyield* Effect.try({\n\t\t\ttry: () => writeFileSync(path, JSON.stringify(body), { flag: 'wx' }),\n\t\t\tcatch: (cause) => {\n\t\t\t\tconst code = (cause as NodeJS.ErrnoException).code;\n\t\t\t\tif (code === 'EEXIST') {\n\t\t\t\t\tlet holder: SnapshotReservation | null = null;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tholder = parseReservation(readFileSync(path, 'utf8'));\n\t\t\t\t\t} catch {\n\t\t\t\t\t\t// Body unreadable; leave holder as null.\n\t\t\t\t\t}\n\t\t\t\t\treturn new SnapshotReservationHeldError({ path, holder });\n\t\t\t\t}\n\t\t\t\treturn new SnapshotReservationIoError({ path, cause });\n\t\t\t},\n\t\t});\n\t\t// Finalizer: best-effort unlink on scope close. Architecture §\n\t\t// Concurrent snapshot step 5: \"It unlinks `snapshot.reservation`.\"\n\t\tyield* Effect.addFinalizer(() =>\n\t\t\tEffect.sync(() => {\n\t\t\t\ttry {\n\t\t\t\t\tunlinkSync(path);\n\t\t\t\t} catch {\n\t\t\t\t\t// Already gone — ok. A peer's sweep may have unlinked our\n\t\t\t\t\t// stale reservation if we somehow lost the process between\n\t\t\t\t\t// acquire and the finalizer fire.\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\t\treturn body;\n\t}).pipe(Effect.withSpan('cross-process.snapshot-reservation.acquire'));\n\n/** Inspect (without acquiring) the current reservation. Returns the\n *  parsed body or `null` if absent / malformed. Used by the supervisor\n *  to decide whether to apply the \"snapshot-in-progress\" tolerance\n *  window to ready probes. Architecture § Concurrent snapshot step 3. */\nexport const peekReservation = (\n\tpath: string,\n): Effect.Effect<SnapshotReservation | null, SnapshotReservationError> =>\n\tEffect.gen(function* () {\n\t\tif (!existsSync(path)) return null;\n\t\tconst raw = yield* Effect.try({\n\t\t\ttry: () => readFileSync(path, 'utf8'),\n\t\t\tcatch: (cause) => new SnapshotReservationIoError({ path, cause }),\n\t\t});\n\t\treturn parseReservation(raw);\n\t}).pipe(Effect.withSpan('cross-process.snapshot-reservation.peek'));\n"],"mappings":";;;;;;;;;;AAsCA,IAAa,+BAAb,cAAkD,KAAK,YAAY,+BAA+B,CAG/F;AAEH,IAAa,6BAAb,cAAgD,KAAK,YAAY,6BAA6B,CAG3F;AAQH,MAAM,oBAAoB,QACzB,iCAAiC,KAAK,2BAA2B,uBAAuB;AAMzF,MAAM,kBAAkB,eAAmD;CAC1E,SAAS;CACT,YAAY,SAAS;CACrB,kBAAkB;CAClB,WAAW,KAAK,KAAK;CACrB,UAAUA,UAAc;CACxB;;;;;;;;;;;;AAaD,MAAa,eACZ,SAEA,OAAO,IAAI,aAAa;AACvB,QAAO,OAAO,oBAAoB,GAAG,SAAS,0BAA0B,MAAM,CAAC;AAC/E,KAAI,CAAC,WAAW,KAAK,CAAE,QAAO,EAAE,OAAO,OAAO;CAK9C,MAAM,cAAc,iBAAiB,OAJlB,OAAO,IAAI;EAC7B,WAAW,aAAa,MAAM,OAAO;EACrC,QAAQ,UAAU,IAAI,2BAA2B;GAAE;GAAM;GAAO,CAAC;EACjE,CAAC,CACuC;AACzC,KAAI,gBAAgB,KAenB,QAAO,EAAE,QAAO,OAJO,OAAO,IAAI;EACjC,WAAW,4BAA4B,MAAM,iBAAiB;EAC9D,QAAQ,UAAU,IAAI,2BAA2B;GAAE;GAAM;GAAO,CAAC;EACjE,CAAC,MAC0B,aAAa;CAU1C,MAAM,UAAUA,UAAc;AAC9B,KAAI,YAAY,aAAa,QAAS,QAAO,EAAE,OAAO,OAAO;AAc7D,MAAI,OAXoB,oBACvB;EACC,KAAK,YAAY;EACjB,WAAW,YAAY;EACvB,UAAU,YAAY;EACtB,WAAW,YAAY;EACvB,aAAa,YAAY;EACzB,QAAQ;EACR,EACD,QACA,CAAC,KAAK,OAAO,YAAY,OAAO,QAAQ,QAAiB,CAAC,CAAC,MAC3C,QAAS,QAAO,EAAE,OAAO,OAAO;AACjD,QAAO,OAAO,IAAI;EACjB,WAAW,WAAW,KAAK;EAC3B,QAAQ,UAAU,IAAI,2BAA2B;GAAE;GAAM;GAAO,CAAC;EACjE,CAAC;AACF,QAAO,EAAE,OAAO,MAAM;EACrB,CAAC,KAAK,OAAO,SAAS,iDAAiD,CAAC;;;;;;;;;;;;;AAc3E,MAAa,sBACZ,MACA,cAEA,OAAO,IAAI,aAAa;AACvB,QAAO,OAAO,oBAAoB,GAAG,SAAS,0BAA0B,MAAM,CAAC;AAK/E,QAAO,YAAY,KAAK;CACxB,MAAM,OAAO,eAAe,UAAU;AACtC,QAAO,OAAO,IAAI;EACjB,WAAW,cAAc,MAAM,KAAK,UAAU,KAAK,EAAE,EAAE,MAAM,MAAM,CAAC;EACpE,QAAQ,UAAU;AAEjB,OADc,MAAgC,SACjC,UAAU;IACtB,IAAI,SAAqC;AACzC,QAAI;AACH,cAAS,iBAAiB,aAAa,MAAM,OAAO,CAAC;YAC9C;AAGR,WAAO,IAAI,6BAA6B;KAAE;KAAM;KAAQ,CAAC;;AAE1D,UAAO,IAAI,2BAA2B;IAAE;IAAM;IAAO,CAAC;;EAEvD,CAAC;AAGF,QAAO,OAAO,mBACb,OAAO,WAAW;AACjB,MAAI;AACH,cAAW,KAAK;UACT;GAKP,CACF;AACD,QAAO;EACN,CAAC,KAAK,OAAO,SAAS,6CAA6C,CAAC"}

package/dist/substrate/runtime/lifecycle/lifecycle-fact.mjs

@@ -1,31 +0,0 @@
-//#region src/substrate/runtime/lifecycle/lifecycle-fact.ts
-/** Project a lifecycle-shaped `EngineEvent` into a per-plugin delta.
-*  Returns `null` for events that don't carry lifecycle information so
-*  the reducer can short-circuit. The substrate stays event-name-blind
-*  by routing through this single mapping table. */
-const factFromEvent = (event) => {
-	switch (event.tag) {
-		case "lifecycle.statusChanged": return {
-			pluginKey: event.pluginKey,
-			delta: { status: event.to }
-		};
-		case "lifecycle.phaseSet": return {
-			pluginKey: event.pluginKey,
-			delta: { phase: event.phase }
-		};
-		default: return null;
-	}
-};
-/** Apply a fact delta to a row. Pure. Fields not in the delta are
-*  preserved verbatim — the merge-not-replace shape `LifecycleFact`
-*  promises. */
-const applyLifecycleFact = (row, delta) => ({
-	...row,
-	...delta.status !== void 0 ? { status: delta.status } : {},
-	...delta.phase !== void 0 ? { phase: delta.phase } : {},
-	...delta.selectiveRestartHighlight !== void 0 ? { selectiveRestartHighlight: delta.selectiveRestartHighlight } : {}
-});
-//#endregion
-export { applyLifecycleFact, factFromEvent };
-
-//# sourceMappingURL=lifecycle-fact.mjs.map

package/dist/substrate/runtime/lifecycle/lifecycle-fact.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle-fact.mjs","names":[],"sources":["../../../../src/substrate/runtime/lifecycle/lifecycle-fact.ts"],"sourcesContent":["// LifecycleFact bridge.\n//\n// `substrate/lifecycle.ts` declares `LifecycleFact` — the merge-not-\n// replace per-plugin lifecycle slice the projection consumes. Until\n// now the projection updater consumed raw `EngineEvent` cases directly\n// and the `LifecycleFact` type was orphan.\n//\n// This module is the typed bridge: it projects an `EngineEvent` into a\n// `LifecycleFact` delta (when the event represents a lifecycle change)\n// and exposes a single applier `applyLifecycleFact(row, fact)` the\n// projection updater calls instead of writing out each\n// status / phase / restart field independently. The reducer for non-\n// lifecycle events is unchanged.\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { Row } from '../../projection.ts';\nimport type { LifecycleFact, LifecycleStatus } from '../../lifecycle.ts';\nimport type { EngineEvent } from '../../events.ts';\n\n/** Per-plugin fact delta. Each field is optional — only the fields the\n *  source event carries are populated. The projection's `applyLifecycleFact`\n *  merges a delta into the existing `Row`. */\nexport interface LifecycleFactDelta {\n\treadonly status?: LifecycleStatus;\n\treadonly phase?: LifecycleFact['phase'];\n\treadonly selectiveRestartHighlight?: boolean;\n}\n\n/** Project a lifecycle-shaped `EngineEvent` into a per-plugin delta.\n *  Returns `null` for events that don't carry lifecycle information so\n *  the reducer can short-circuit. The substrate stays event-name-blind\n *  by routing through this single mapping table. */\nexport const factFromEvent = (\n\tevent: EngineEvent,\n): { readonly pluginKey: PluginKey; readonly delta: LifecycleFactDelta } | null => {\n\tswitch (event.tag) {\n\t\tcase 'lifecycle.statusChanged':\n\t\t\treturn {\n\t\t\t\tpluginKey: event.pluginKey,\n\t\t\t\tdelta: { status: event.to },\n\t\t\t};\n\t\tcase 'lifecycle.phaseSet':\n\t\t\treturn {\n\t\t\t\tpluginKey: event.pluginKey,\n\t\t\t\tdelta: { phase: event.phase },\n\t\t\t};\n\t\tdefault:\n\t\t\t// `restart.requested` ALSO updates cycle.phase + clears\n\t\t\t// other rows' highlights — that's a multi-row reducer\n\t\t\t// concern the projection handles directly. We deliberately\n\t\t\t// keep the bridge scoped to the closed `LifecycleFact`\n\t\t\t// shape (status / phase / selectiveRestartHighlight) so\n\t\t\t// callers can derive per-plugin facts without rebuilding\n\t\t\t// the cycle phase too.\n\t\t\treturn null;\n\t}\n};\n\n/** Apply a fact delta to a row. Pure. Fields not in the delta are\n *  preserved verbatim — the merge-not-replace shape `LifecycleFact`\n *  promises. */\nexport const applyLifecycleFact = (row: Row, delta: LifecycleFactDelta): Row => ({\n\t...row,\n\t...(delta.status !== undefined ? { status: delta.status } : {}),\n\t...(delta.phase !== undefined ? { phase: delta.phase } : {}),\n\t...(delta.selectiveRestartHighlight !== undefined\n\t\t? { selectiveRestartHighlight: delta.selectiveRestartHighlight }\n\t\t: {}),\n});\n\n/** Reconstruct the closed `LifecycleFact` shape from a `Row`. Used by\n *  diagnostic surfaces that want the typed fact instead of the wider\n *  display Row. */\nexport const factFromRow = (row: Row): LifecycleFact => ({\n\tstatus: row.status,\n\tphase: row.phase,\n\tselectiveRestartHighlight: row.selectiveRestartHighlight,\n});\n"],"mappings":";;;;;AAgCA,MAAa,iBACZ,UACkF;AAClF,SAAQ,MAAM,KAAd;EACC,KAAK,0BACJ,QAAO;GACN,WAAW,MAAM;GACjB,OAAO,EAAE,QAAQ,MAAM,IAAI;GAC3B;EACF,KAAK,qBACJ,QAAO;GACN,WAAW,MAAM;GACjB,OAAO,EAAE,OAAO,MAAM,OAAO;GAC7B;EACF,QAQC,QAAO;;;;;;AAOV,MAAa,sBAAsB,KAAU,WAAoC;CAChF,GAAG;CACH,GAAI,MAAM,WAAW,KAAA,IAAY,EAAE,QAAQ,MAAM,QAAQ,GAAG,EAAE;CAC9D,GAAI,MAAM,UAAU,KAAA,IAAY,EAAE,OAAO,MAAM,OAAO,GAAG,EAAE;CAC3D,GAAI,MAAM,8BAA8B,KAAA,IACrC,EAAE,2BAA2B,MAAM,2BAA2B,GAC9D,EAAE;CACL"}

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

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

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

@@ -1,48 +0,0 @@
-import { makeScopedMultimap } from "../scoped-multimap/service.mjs";
-import "../scoped-multimap/index.mjs";
-import { emptyFormatterRegistry } from "./cascade-formatter.mjs";
-import { Context, Effect, Layer } from "effect";
-//#region src/substrate/runtime/observability/formatter-registry.ts
-var FormatterRegistryService = class extends Context.Service()("@devstack/substrate/FormatterRegistry") {};
-/** Layer constructing the per-stack formatter registry. Stateful;
-*  the substrate provides one per supervisor scope.
-*
-*  Storage is the shared scoped-multimap keyed by tag. The per-entry
-*  value is the (optional) formatter — the registry may track a tag
-*  with NO formatter (default rendering is enough), so `null` is a
-*  legitimate value and the seq still tracks the registration. */
-const layerFormatterRegistry = Layer.effect(FormatterRegistryService, Effect.gen(function* () {
-	const store = yield* makeScopedMultimap();
-	const register = (contribution) => Effect.gen(function* () {
-		const fmt = contribution.formatter !== void 0 ? (value, recurse) => contribution.formatter(value, recurse) : null;
-		yield* store.register(contribution.errorTags.map((tag) => ({
-			key: tag,
-			value: fmt
-		})));
-	}).pipe(Effect.withSpan("substrate.formatterRegistry.register"));
-	const snapshot = Effect.gen(function* () {
-		const current = yield* store.snapshot;
-		if (current.size === 0) return emptyFormatterRegistry;
-		const out = /* @__PURE__ */ new Map();
-		for (const [tag, entries] of current) {
-			let chosen = null;
-			let chosenSeq = -1;
-			for (const e of entries) if (e.value !== null && e.seq > chosenSeq) {
-				chosen = e.value;
-				chosenSeq = e.seq;
-			}
-			if (chosen !== null) out.set(tag, chosen);
-		}
-		return out;
-	});
-	const tags = store.keys;
-	return FormatterRegistryService.of({
-		register,
-		snapshot,
-		tags
-	});
-}));
-//#endregion
-export { FormatterRegistryService, layerFormatterRegistry };
-
-//# sourceMappingURL=formatter-registry.mjs.map

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

@@ -1 +0,0 @@
-{"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/span-store.d.mts

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

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

@@ -1,110 +0,0 @@
-import { SpanAttr } from "./spans.mjs";
-import { Context, Effect, Exit, Layer, Option, Tracer } from "effect";
-//#region src/substrate/runtime/observability/span-store.ts
-/** Completed-span retention. Bounded so a long-lived stack stays flat. */
-const DEFAULT_SPAN_CAPACITY = 2e3;
-var SpanStore = class extends Context.Service()("@devstack/substrate/SpanStore") {};
-const pushRecord = (ring, record) => {
-	ring.records.push(record);
-	if (ring.records.length > ring.capacity) ring.records.shift();
-};
-const NANOS_PER_MILLI = 1000000n;
-const nanosToMillis = (n) => Number(n / NANOS_PER_MILLI);
-/** Derive the dashboard `service` for a span: prefer the canonical
-*  `devstack.plugin` attribute, else fall back to the span name. Plugin
-*  spans without the attribute use the dotted `devstack.plugin.<name>.…`
-*  convention, so we special-case that prefix to recover `<name>` (e.g.
-*  `devstack.plugin.postgres.acquire` → `postgres`) instead of bucketing
-*  every plugin span under the shared `devstack` head. Other namespaced
-*  spans fall back to the leading dotted/slashed segment
-*  (`lifecycle.supervisor.runCommand` → `lifecycle`). `null` when neither
-*  is informative. */
-const PLUGIN_SPAN_PREFIX = "devstack.plugin.";
-const deriveService = (name, attributes) => {
-	const plugin = attributes.get(SpanAttr.plugin);
-	if (typeof plugin === "string" && plugin.length > 0) return plugin;
-	if (name.startsWith(PLUGIN_SPAN_PREFIX)) {
-		const pluginName = name.slice(16).split(/[./]/, 1)[0];
-		if (pluginName !== void 0 && pluginName.length > 0) return pluginName;
-	}
-	const head = name.split(/[./]/, 1)[0];
-	return head !== void 0 && head.length > 0 && head !== name ? head : null;
-};
-const flattenAttributes = (attributes) => {
-	const out = {};
-	for (const [k, v] of attributes) out[k] = typeof v === "string" ? v : String(v);
-	return out;
-};
-/** Build the recording span from the native span at end time. */
-const recordFrom = (span, endTime, exit) => {
-	const parent = Option.getOrUndefined(span.parent);
-	const startMillis = nanosToMillis(span.startTime);
-	return {
-		traceId: span.traceId,
-		spanId: span.spanId,
-		parentId: parent?.spanId ?? null,
-		name: span.name,
-		service: deriveService(span.name, span.attributes),
-		startMillis,
-		durationMillis: Math.max(0, nanosToMillis(endTime) - startMillis),
-		status: Exit.isSuccess(exit) ? "ok" : "error",
-		attributes: flattenAttributes(span.attributes)
-	};
-};
-/** A `Tracer` that builds Effect's `NativeSpan` (so parent/trace propagation
-*  and attribute capture behave exactly like the default) and records each
-*  span into `ring` when it ends. */
-const recordingTracer = (ring) => Tracer.make({ span: (options) => {
-	const span = new Tracer.NativeSpan(options);
-	const originalEnd = span.end.bind(span);
-	span.end = (endTime, exit) => {
-		originalEnd(endTime, exit);
-		try {
-			pushRecord(ring, recordFrom(span, endTime, exit));
-		} catch {}
-	};
-	return span;
-} });
-/** Build a `SpanStoreShape` over a fresh ring. The supervisor calls this so
-*  the ring is process-scoped. `capacity` is injectable for tests. */
-const makeSpanStore = (capacity = DEFAULT_SPAN_CAPACITY) => Effect.sync(() => {
-	const ring = {
-		records: [],
-		capacity
-	};
-	const query = (filter) => Effect.sync(() => applySpanFilter(ring.records, filter, capacity));
-	const services = Effect.sync(() => {
-		const seen = /* @__PURE__ */ new Set();
-		for (const r of ring.records) if (r.service !== null) seen.add(r.service);
-		return [...seen].sort();
-	});
-	return SpanStore.of({
-		query,
-		services,
-		tracer: recordingTracer(ring)
-	});
-});
-/** Pure filter application — exported for tests. Stored oldest-first; we
-*  return newest-first and cap to `limit`. */
-const applySpanFilter = (records, filter, capacity) => {
-	const serviceSet = filter?.services && filter.services.length > 0 ? new Set(filter.services) : null;
-	const statusSet = filter?.statuses && filter.statuses.length > 0 ? new Set(filter.statuses) : null;
-	const search = filter?.search?.trim().toLowerCase();
-	const since = filter?.sinceMillis;
-	const limit = filter?.limit ?? capacity;
-	const out = [];
-	for (let i = records.length - 1; i >= 0 && out.length < limit; i -= 1) {
-		const r = records[i];
-		if (serviceSet !== null && (r.service === null || !serviceSet.has(r.service))) continue;
-		if (statusSet !== null && !statusSet.has(r.status)) continue;
-		if (since !== void 0 && r.startMillis < since) continue;
-		if (search !== void 0 && search.length > 0 && !r.name.toLowerCase().includes(search) && !(r.service ?? "").toLowerCase().includes(search)) continue;
-		out.push(r);
-	}
-	return out;
-};
-Layer.effect(SpanStore, makeSpanStore());
-//#endregion
-export { DEFAULT_SPAN_CAPACITY, SpanStore, applySpanFilter, makeSpanStore };
-
-//# sourceMappingURL=span-store.mjs.map