@mysten-incubation/devstack 0.0.0

package/dist/substrate/runtime/projection/update.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.mjs","names":[],"sources":["../../../../src/substrate/runtime/projection/update.ts"],"sourcesContent":["// Projection updater.\n//\n// Architecture § Renderer § \"Subscribable projection — exact field\n// enumeration\" (G2). The updater is a typed event-handler: each\n// `EngineEvent` produces a structurally-typed projection mutation.\n// Renderers never see the event taxonomy here; they only see the\n// resulting state.\n//\n// The updater is *pure data*: it takes the old state + an event,\n// returns the new state. Atomicity comes from\n// `SubscriptionRef.update` at the call site.\n//\n// Discipline:\n//   - No display vocabulary (`title`, `primary`, `extras`) anywhere\n//     in the produced state.\n//   - All fields the architecture enumerates are reachable; new\n//     event tags are picked up via exhaustive `tag` match (the\n//     `_exhaustive: never` line will fail to type-check if a new\n//     tag is added without a handler here).\n\nimport { Effect, SubscriptionRef } from 'effect';\n\nimport type { PluginKey } from '../../brand.ts';\nimport type { EngineEvent } from '../../events.ts';\nimport type { LifecycleStatus } from '../../lifecycle.ts';\nimport type {\n\tAccountProjection,\n\tBuildEntry,\n\tEndpoint,\n\tPackageProjection,\n\tRow,\n\tStructuredError,\n\tSubscribableState,\n} from '../../projection.ts';\nimport { applyLifecycleFact, factFromEvent } from '../lifecycle/lifecycle-fact.ts';\n\n// -----------------------------------------------------------------------------\n// Capacity policy\n// -----------------------------------------------------------------------------\n\n/** Bounded buffer for the top-level errors list. */\nconst MAX_ERRORS_KEPT = 100;\n/** Bounded buffer for the top-level build-entries list. */\nconst MAX_BUILD_ENTRIES_KEPT = 200;\n/** Per-row bounded log-tail length. Architecture: default 100 lines. */\nconst MAX_ROW_LOG_LINES = 100;\n\n// -----------------------------------------------------------------------------\n// Pure reducer\n// -----------------------------------------------------------------------------\n\n/**\n * Pure projection reducer. One event in, one new state out. All field\n * writes preserve `readonly` invariants by constructing fresh\n * objects/arrays rather than mutating.\n *\n * The `tag` switch is exhaustive against `EngineEvent['tag']`; the\n * trailing `_exhaustive: never` causes TS to flag any new tag that\n * isn't handled here.\n */\nexport const applyEvent = (state: SubscribableState, event: EngineEvent): SubscribableState => {\n\t// Every event advances `lastEvent.at`. `lastEvent.seq` is bumped at\n\t// the `updateRef` wrapper, not here — this reducer is pure data.\n\tconst withTouched = (next: Partial<SubscribableState>): SubscribableState => ({\n\t\t...state,\n\t\t...next,\n\t\tlastEvent: { seq: state.lastEvent.seq, at: eventAt(event) ?? state.lastEvent.at },\n\t});\n\n\t// Lifecycle-shaped events flow through the typed `LifecycleFact`\n\t// bridge — the projection consumes the merge-not-replace fact\n\t// instead of writing each lifecycle field independently. Non-\n\t// lifecycle events take their original specialised paths below.\n\tconst fact = factFromEvent(event);\n\tif (fact !== null) {\n\t\treturn withTouched({\n\t\t\trows: upsertRow(state.rows, fact.pluginKey as PluginKey, (row) =>\n\t\t\t\tapplyLifecycleFact(row, fact.delta),\n\t\t\t),\n\t\t});\n\t}\n\n\tswitch (event.tag) {\n\t\tcase 'lifecycle.statusChanged':\n\t\tcase 'lifecycle.phaseSet':\n\t\t\t// Handled above via `factFromEvent` — kept in the switch for\n\t\t\t// `_exhaustive` discipline.\n\t\t\treturn withTouched({});\n\n\t\tcase 'log.appended':\n\t\t\treturn withTouched({\n\t\t\t\trows: upsertRow(state.rows, event.pluginKey, (row) =>\n\t\t\t\t\tappendLogLine(row, event.line, event.level),\n\t\t\t\t),\n\t\t\t});\n\n\t\tcase 'endpoint.registered':\n\t\t\treturn withTouched({\n\t\t\t\tendpoints: upsertEndpoint(state.endpoints, event.endpoint),\n\t\t\t\trows: attachEndpoint(state.rows, event.endpoint),\n\t\t\t});\n\n\t\tcase 'account.updated':\n\t\t\treturn withTouched({\n\t\t\t\taccounts: upsertAccount(state.accounts, event.account),\n\t\t\t});\n\n\t\tcase 'package.updated':\n\t\t\treturn withTouched({\n\t\t\t\tpackages: upsertPackage(state.packages, event.package),\n\t\t\t});\n\n\t\tcase 'endpoint.released':\n\t\t\t// Renderer projection keeps endpoint history as last-known\n\t\t\t// operator affordance. A released service may no longer be\n\t\t\t// reachable, but hiding the URL during shutdown/restart makes\n\t\t\t// the TUI lose the most useful debugging handle.\n\t\t\treturn withTouched({});\n\n\t\tcase 'strategy.registered':\n\t\tcase 'strategy.unregistered':\n\t\tcase 'manifest.flushed':\n\t\tcase 'codegen.emitted':\n\t\tcase 'snapshot.captureStarted':\n\t\tcase 'snapshot.captureProgress':\n\t\tcase 'snapshot.captureSkipped':\n\t\tcase 'snapshot.captureFailed':\n\t\tcase 'snapshot.captured':\n\t\tcase 'snapshot.restored':\n\t\t\t// Engine-internal events that don't carry a projection slice\n\t\t\t// — surfaced on the live event stream for renderers that care,\n\t\t\t// but contribute no field to the subscribable state. (Adding\n\t\t\t// a projection field for any of these requires an architecture\n\t\t\t// revision per G2.)\n\t\t\treturn withTouched({});\n\n\t\tcase 'shutdown.escalated':\n\t\t\treturn withTouched({\n\t\t\t\tcycle: { ...state.cycle, phase: 'shutting-down' },\n\t\t\t});\n\n\t\tcase 'error.reported':\n\t\t\treturn withTouched({\n\t\t\t\terrors: pushBounded(state.errors, event.error, MAX_ERRORS_KEPT),\n\t\t\t\trows: event.error.pluginKey\n\t\t\t\t\t? upsertRow(state.rows, event.error.pluginKey, (row) => ({\n\t\t\t\t\t\t\t...row,\n\t\t\t\t\t\t\tlastError: event.error,\n\t\t\t\t\t\t}))\n\t\t\t\t\t: state.rows,\n\t\t\t});\n\n\t\tcase 'build.statusChanged':\n\t\t\treturn withTouched({\n\t\t\t\tstackBuild: pushBounded(state.stackBuild, event.entry, MAX_BUILD_ENTRIES_KEPT),\n\t\t\t});\n\n\t\tcase 'restart.requested':\n\t\t\treturn withTouched({\n\t\t\t\tcycle: { ...state.cycle, phase: 'restarting' },\n\t\t\t\trows:\n\t\t\t\t\tevent.target === 'stack'\n\t\t\t\t\t\t? state.rows.map((r) => ({ ...r, selectiveRestartHighlight: false }))\n\t\t\t\t\t\t: state.rows.map((r) =>\n\t\t\t\t\t\t\t\tr.key === (event.target as { pluginKey: PluginKey }).pluginKey\n\t\t\t\t\t\t\t\t\t? { ...r, selectiveRestartHighlight: true }\n\t\t\t\t\t\t\t\t\t: r,\n\t\t\t\t\t\t\t),\n\t\t\t});\n\n\t\tcase 'restart.completed':\n\t\t\treturn withTouched({\n\t\t\t\tcycle: { ...state.cycle, phase: 'running' },\n\t\t\t\trows: state.rows.map((r) => ({ ...r, selectiveRestartHighlight: false })),\n\t\t\t});\n\n\t\tdefault: {\n\t\t\tconst _exhaustive: never = event;\n\t\t\tvoid _exhaustive;\n\t\t\treturn state;\n\t\t}\n\t}\n};\n\n// -----------------------------------------------------------------------------\n// Engine-side mutators (not driven by EngineEvent)\n// -----------------------------------------------------------------------------\n\n/**\n * Replace `identity` on the projection. Called once at boot per cycle;\n * does NOT change on hot-restart.\n */\nexport const setIdentity = (\n\tstate: SubscribableState,\n\tidentity: SubscribableState['identity'],\n): SubscribableState => ({ ...state, identity });\n\n/**\n * Bump the cycle counter. Called at the start of each engine cycle.\n * Resets only fields the architecture says are per-cycle:\n *   - `cycle.id`, `cycle.startedAt`, `cycle.phase`\n *   - per-row `selectiveRestartHighlight`\n * The error log, endpoints, build log, and `lastEvent.seq` are\n * intentionally preserved across cycles so the renderer sees\n * continuous history.\n */\nexport const bumpCycle = (\n\tstate: SubscribableState,\n\tnow: number,\n\tphase: SubscribableState['cycle']['phase'] = 'booting',\n): SubscribableState => ({\n\t...state,\n\tcycle: { id: state.cycle.id + 1, startedAt: now, phase },\n\trows: state.rows.map((r) => ({ ...r, selectiveRestartHighlight: false })),\n});\n\n/**\n * Register (or replace) a row in the projection. The supervisor wires\n * the call in.\n */\nexport const declareRow = (state: SubscribableState, row: Row): SubscribableState => {\n\tconst idx = state.rows.findIndex((r) => r.key === row.key);\n\tif (idx === -1) return { ...state, rows: [...state.rows, row] };\n\tconst next = state.rows.slice();\n\tnext[idx] = row;\n\treturn { ...state, rows: next };\n};\n\n/**\n * Drop a row. Used during selective-restart when a plugin is being\n * removed (rare; most restarts replay the same row).\n */\nexport const dropRow = (state: SubscribableState, key: PluginKey): SubscribableState => ({\n\t...state,\n\trows: state.rows.filter((r) => r.key !== key),\n});\n\nexport const declareAccount = (\n\tstate: SubscribableState,\n\taccount: AccountProjection,\n): SubscribableState => ({\n\t...state,\n\taccounts: upsertAccount(state.accounts, account),\n});\n\nexport const declarePackage = (\n\tstate: SubscribableState,\n\tpkg: PackageProjection,\n): SubscribableState => ({\n\t...state,\n\tpackages: upsertPackage(state.packages, pkg),\n});\n\n// -----------------------------------------------------------------------------\n// SubscriptionRef-driven updaters\n// -----------------------------------------------------------------------------\n\n/**\n * Apply an `EngineEvent` to the ref, bumping the sequence number\n * atomically. The seq is monotonic per process and survives cycle\n * boundaries.\n *\n * Uses `state.lastEvent.seq + 1` for monotonic per-process counts.\n */\nexport const updateRef = (\n\tref: SubscriptionRef.SubscriptionRef<SubscribableState>,\n\tevent: EngineEvent,\n): Effect.Effect<void> =>\n\tSubscriptionRef.update(ref, (state) => {\n\t\tconst next = applyEvent(state, event);\n\t\treturn {\n\t\t\t...next,\n\t\t\tlastEvent: { seq: state.lastEvent.seq + 1, at: next.lastEvent.at },\n\t\t};\n\t});\n\n// -----------------------------------------------------------------------------\n// Internals\n// -----------------------------------------------------------------------------\n\nconst eventAt = (event: EngineEvent): number | null => {\n\tif ('at' in event) return event.at;\n\t// Events whose payload nests `at` (endpoint, error, build): pull it\n\t// up. Discriminating purely on `tag` keeps this exhaustive.\n\tswitch (event.tag) {\n\t\tcase 'endpoint.registered':\n\t\t\treturn event.endpoint.registeredAt;\n\t\tcase 'error.reported':\n\t\t\treturn event.error.at;\n\t\tcase 'build.statusChanged':\n\t\t\treturn event.entry.startedAt;\n\t\tdefault:\n\t\t\treturn null;\n\t}\n};\n\nconst upsertRow = (\n\trows: ReadonlyArray<Row>,\n\tkey: PluginKey,\n\tupdate: (row: Row) => Row,\n): ReadonlyArray<Row> => {\n\tconst idx = rows.findIndex((r) => r.key === key);\n\tif (idx === -1) {\n\t\t// Row was never declared. We do NOT auto-create — declaration is\n\t\t// the plugin's job. Drop the event silently; the renderer can't\n\t\t// render a row it doesn't know about.\n\t\treturn rows;\n\t}\n\tconst next = rows.slice();\n\tnext[idx] = update(rows[idx]!);\n\treturn next;\n};\n\nconst appendLogLine = (row: Row, line: string, level: 'info' | 'warn' | 'error'): Row => {\n\tconst nextLines = [...row.logTail.lines, line];\n\tconst truncated = nextLines.length > MAX_ROW_LOG_LINES;\n\tconst trimmed = truncated ? nextLines.slice(-MAX_ROW_LOG_LINES) : nextLines;\n\treturn {\n\t\t...row,\n\t\tlogTail: {\n\t\t\tlines: trimmed,\n\t\t\tlevel: maxLevel(row.logTail.level, level),\n\t\t\ttruncated: row.logTail.truncated || truncated,\n\t\t},\n\t};\n};\n\nconst maxLevel = (\n\ta: 'info' | 'warn' | 'error',\n\tb: 'info' | 'warn' | 'error',\n): 'info' | 'warn' | 'error' => {\n\tconst rank = { info: 0, warn: 1, error: 2 } as const;\n\treturn rank[a] >= rank[b] ? a : b;\n};\n\nconst upsertEndpoint = (\n\tendpoints: ReadonlyArray<Endpoint>,\n\tendpoint: Endpoint,\n): ReadonlyArray<Endpoint> => {\n\tconst idx = endpoints.findIndex((e) => e.endpointKey === endpoint.endpointKey);\n\tif (idx === -1) return [...endpoints, endpoint];\n\tconst next = endpoints.slice();\n\tnext[idx] = endpoint;\n\treturn next;\n};\n\nconst upsertAccount = (\n\taccounts: ReadonlyArray<AccountProjection>,\n\taccount: AccountProjection,\n): ReadonlyArray<AccountProjection> => {\n\tconst idx = accounts.findIndex((entry) => entry.key === account.key);\n\tif (idx === -1) return [...accounts, account];\n\tconst next = accounts.slice();\n\tnext[idx] = {\n\t\t...accounts[idx]!,\n\t\t...account,\n\t\tfunding: {\n\t\t\t...accounts[idx]!.funding,\n\t\t\t...account.funding,\n\t\t},\n\t};\n\treturn next;\n};\n\nconst upsertPackage = (\n\tpackages: ReadonlyArray<PackageProjection>,\n\tpkg: PackageProjection,\n): ReadonlyArray<PackageProjection> => {\n\tconst idx = packages.findIndex((entry) => entry.key === pkg.key);\n\tif (idx === -1) return [...packages, pkg];\n\tconst next = packages.slice();\n\tnext[idx] = {\n\t\t...packages[idx]!,\n\t\t...pkg,\n\t};\n\treturn next;\n};\n\nconst attachEndpoint = (rows: ReadonlyArray<Row>, endpoint: Endpoint): ReadonlyArray<Row> => {\n\t// Endpoint -> Row link is `endpointKey` derived from `pluginKey` + dispatchId.\n\t// The plugin that owns the endpoint must have a row; we look it up by\n\t// the endpoint's pluginKey via a structured field. The current\n\t// `Endpoint` shape (from projection.ts) doesn't carry pluginKey in\n\t// the projection slice — it's derivable from `endpointKey` (prefix match).\n\tconst probableKey = endpoint.endpointKey;\n\treturn rows.map((row) =>\n\t\tprobableKey.startsWith(row.key)\n\t\t\t? row.endpoints.includes(probableKey)\n\t\t\t\t? row\n\t\t\t\t: { ...row, endpoints: [...row.endpoints, probableKey] }\n\t\t\t: row,\n\t);\n};\n\nconst pushBounded = <T>(xs: ReadonlyArray<T>, value: T, max: number): ReadonlyArray<T> => {\n\tconst next = [...xs, value];\n\treturn next.length > max ? next.slice(-max) : next;\n};\n\n// Re-export the bounded-capacity constants for tests / docs.\nexport const __capacities = {\n\tMAX_ERRORS_KEPT,\n\tMAX_BUILD_ENTRIES_KEPT,\n\tMAX_ROW_LOG_LINES,\n} as const;\n\n// Re-export referenced sub-types for downstream consumers (tests,\n// renderer-side wrappers) so they don't reach into substrate/\n// directly.\nexport type {\n\tAccountProjection,\n\tBuildEntry,\n\tEndpoint,\n\tLifecycleStatus,\n\tPackageProjection,\n\tRow,\n\tStructuredError,\n};\n"],"mappings":"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"}

package/dist/substrate/runtime/retry-policy.d.mts

@@ -0,0 +1,18 @@
+import { Schedule } from "effect";
+import * as _$effect_Duration0 from "effect/Duration";
+
+//#region src/substrate/runtime/retry-policy.d.ts
+declare namespace retry_policy_d_exports {
+  export { ExponentialRetryOptions, makeExponentialRetrySchedule, makeSpacedRetrySchedule };
+}
+interface ExponentialRetryOptions {
+  readonly initialDelayMs: number;
+  readonly maxRetries: number;
+  readonly factor?: number;
+  readonly jitter?: boolean;
+}
+declare const makeExponentialRetrySchedule: (options: ExponentialRetryOptions) => Schedule.Schedule<[_$effect_Duration0.Duration, number], unknown, never, never>;
+declare const makeSpacedRetrySchedule: (delayMs: number, maxRetries: number) => Schedule.Schedule<[number, number], unknown, never, never>;
+//#endregion
+export { retry_policy_d_exports };
+//# sourceMappingURL=retry-policy.d.mts.map

package/dist/substrate/runtime/retry-policy.mjs

@@ -0,0 +1,16 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
+import { Schedule } from "effect";
+//#region src/substrate/runtime/retry-policy.ts
+var retry_policy_exports = /* @__PURE__ */ __exportAll({
+	makeExponentialRetrySchedule: () => makeExponentialRetrySchedule,
+	makeSpacedRetrySchedule: () => makeSpacedRetrySchedule
+});
+const makeExponentialRetrySchedule = (options) => {
+	const schedule = Schedule.exponential(`${options.initialDelayMs} millis`, options.factor ?? 2);
+	return (options.jitter === false ? schedule : schedule.pipe(Schedule.jittered)).pipe(Schedule.both(Schedule.recurs(options.maxRetries)));
+};
+const makeSpacedRetrySchedule = (delayMs, maxRetries) => Schedule.spaced(`${delayMs} millis`).pipe(Schedule.both(Schedule.recurs(maxRetries)));
+//#endregion
+export { makeExponentialRetrySchedule, makeSpacedRetrySchedule, retry_policy_exports };
+
+//# sourceMappingURL=retry-policy.mjs.map

package/dist/substrate/runtime/retry-policy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-policy.mjs","names":[],"sources":["../../../src/substrate/runtime/retry-policy.ts"],"sourcesContent":["import { Schedule } from 'effect';\n\nexport interface ExponentialRetryOptions {\n\treadonly initialDelayMs: number;\n\treadonly maxRetries: number;\n\treadonly factor?: number;\n\treadonly jitter?: boolean;\n}\n\nexport const makeExponentialRetrySchedule = (options: ExponentialRetryOptions) => {\n\tconst schedule = Schedule.exponential(`${options.initialDelayMs} millis`, options.factor ?? 2);\n\tconst jittered = options.jitter === false ? schedule : schedule.pipe(Schedule.jittered);\n\treturn jittered.pipe(Schedule.both(Schedule.recurs(options.maxRetries)));\n};\n\nexport const makeSpacedRetrySchedule = (delayMs: number, maxRetries: number) =>\n\tSchedule.spaced(`${delayMs} millis`).pipe(Schedule.both(Schedule.recurs(maxRetries)));\n"],"mappings":";;;;;;;AASA,MAAa,gCAAgC,YAAqC;CACjF,MAAM,WAAW,SAAS,YAAY,GAAG,QAAQ,eAAe,UAAU,QAAQ,UAAU,EAAE;AAE9F,SADiB,QAAQ,WAAW,QAAQ,WAAW,SAAS,KAAK,SAAS,SAAS,EACvE,KAAK,SAAS,KAAK,SAAS,OAAO,QAAQ,WAAW,CAAC,CAAC;;AAGzE,MAAa,2BAA2B,SAAiB,eACxD,SAAS,OAAO,GAAG,QAAQ,SAAS,CAAC,KAAK,SAAS,KAAK,SAAS,OAAO,WAAW,CAAC,CAAC"}

package/dist/substrate/runtime/run.mjs

@@ -0,0 +1,86 @@
+import { IdentityContext, RuntimeRoot, StackPathsService, layerIdentity, layerRuntimeRoot, layerStackPaths } from "./paths.mjs";
+import { PortBrokerService, layerPortBroker } from "./port-broker/service.mjs";
+import { CacheService, layerCache } from "./cache/service.mjs";
+import { DockerSpawner, layerDockerHostDefault } from "../../runtime/docker/client.mjs";
+import { ContainerRuntimeService, layerContainerRuntimeDocker, layerDockerCycleInitial } from "../../runtime/docker/service.mjs";
+import { LeaseBrokerService, layerLeaseBroker } from "./lease-broker/service.mjs";
+import { Redactor, layerRedactor } from "./observability/redaction.mjs";
+import { Logger as Logger$1, layerLogger } from "./observability/logger.mjs";
+import { ArtifactPublisherService, layerArtifactPublisher } from "./artifact-publisher/index.mjs";
+import { StrategyRegistryService, layerStrategyRegistry } from "./strategy-registry/service.mjs";
+import { awaitAll } from "./lifecycle/ready-gate.mjs";
+import { PostAcquireTasksService, layerPostAcquireTasks } from "./post-acquire-tasks.mjs";
+import { startSupervisor } from "./supervisor.mjs";
+import { Context, Effect, Layer } from "effect";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
+import * as NodeChildProcessSpawner from "@effect/platform-node/NodeChildProcessSpawner";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+//#region src/substrate/runtime/run.ts
+/** Substrate Layer stack for a single supervised run. Composes every L0
+*  service the supervisor yields from its R-channel, plus the L1 Docker
+*  `ContainerRuntime`. Built-in plugin services are layered outside
+*  substrate and added through `extendContext`. */
+const buildSubstrateLayers = (identity, runtimeRoot) => {
+	const layerDockerSpawnerFromNode = Layer.effect(DockerSpawner, Effect.gen(function* () {
+		return yield* ChildProcessSpawner;
+	}));
+	const platformBase = Layer.mergeAll(layerIdentity(identity), layerRuntimeRoot(runtimeRoot), NodePath.layer, NodeFileSystem.layer, layerDockerHostDefault, layerDockerCycleInitial, layerStrategyRegistry);
+	const childProcessSpawnerWired = NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(platformBase));
+	const withStackPaths = layerStackPaths.pipe(Layer.provideMerge(childProcessSpawnerWired));
+	const withCache = layerCache.pipe(Layer.provideMerge(withStackPaths));
+	const withArtifactPublisher = layerArtifactPublisher.pipe(Layer.provideMerge(withCache));
+	const withPortBroker = layerPortBroker.pipe(Layer.provideMerge(withArtifactPublisher));
+	const withLeaseBroker = layerLeaseBroker.pipe(Layer.provideMerge(withPortBroker));
+	const withSpawnerAdapter = layerDockerSpawnerFromNode.pipe(Layer.provideMerge(withLeaseBroker));
+	const withContainerRuntime = layerContainerRuntimeDocker.pipe(Layer.provideMerge(withSpawnerAdapter));
+	const withPostAcquireTasks = layerPostAcquireTasks.pipe(Layer.provideMerge(withContainerRuntime));
+	const withRedactor = layerRedactor.pipe(Layer.provideMerge(withPostAcquireTasks));
+	return layerLogger.pipe(Layer.provideMerge(withRedactor));
+};
+/** Build the opaque `Context.Context<never>` the supervisor hands to
+*  every plugin's `acquire` body. Yields every substrate service the
+*  Docker-backed substrate layer stack provides; downstream callers
+*  may extend the context (e.g. layering a Logger or a
+*  `CapabilitySinksService`) before passing it to `supervise()`. */
+const buildPluginContext = () => Effect.gen(function* () {
+	const identityCtx = yield* IdentityContext;
+	const runtimeRootResolved = yield* RuntimeRoot;
+	const stackPaths = yield* StackPathsService;
+	const cache = yield* CacheService;
+	const registry = yield* StrategyRegistryService;
+	const containerRuntime = yield* ContainerRuntimeService;
+	const publisher = yield* ArtifactPublisherService;
+	const portBroker = yield* PortBrokerService;
+	const leaseBroker = yield* LeaseBrokerService;
+	const postAcquireTasks = yield* PostAcquireTasksService;
+	const logger = yield* Logger$1;
+	const redactor = yield* Redactor;
+	return Context.empty().pipe(Context.add(IdentityContext, identityCtx), Context.add(RuntimeRoot, runtimeRootResolved), Context.add(StackPathsService, stackPaths), Context.add(CacheService, cache), Context.add(StrategyRegistryService, registry), Context.add(ContainerRuntimeService, containerRuntime), Context.add(ArtifactPublisherService, publisher), Context.add(PortBrokerService, portBroker), Context.add(LeaseBrokerService, leaseBroker), Context.add(PostAcquireTasksService, postAcquireTasks), Context.add(Logger$1, logger), Context.add(Redactor, redactor));
+});
+/** Effect that boots the supervisor for `stack` and blocks on the
+*  supervisor's shutdown latch. Returns the final `SubscribableState`
+*  snapshot so callers (CLI, library handle) can inspect post-shutdown
+*  state. */
+const superviseStackEffect = (stack, identity, state, opts = {}) => Effect.gen(function* () {
+	const baseContext = yield* buildPluginContext();
+	const pluginContext = opts.extendContext === void 0 ? baseContext : yield* opts.extendContext(baseContext);
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const startup = yield* startSupervisor(stack, identity, state, pluginContext, opts.orchestratorSinks ?? [], opts.commandHandler, opts.postAcquireHook, { commandLoop: opts.lifetime !== "one-shot" });
+		const { handle } = startup;
+		if (opts.beforeInitialAcquire !== void 0) yield* opts.beforeInitialAcquire(handle);
+		if (opts.lifetime === "one-shot") {
+			yield* startup.runInitialAcquire;
+			yield* awaitAll(startup.handle.registry, [...startup.handle.graph.nodes.keys()]);
+			if (opts.withinScope !== void 0) yield* opts.withinScope(handle);
+			return;
+		}
+		if ((yield* Effect.raceFirst(startup.runInitialAcquire.pipe(Effect.as("booted")), handle.awaitShutdown.pipe(Effect.as("shutdown")))) === "shutdown") return;
+		if (opts.withinScope !== void 0) yield* opts.withinScope(handle);
+		yield* handle.awaitShutdown;
+	}));
+});
+//#endregion
+export { buildSubstrateLayers, superviseStackEffect };
+
+//# sourceMappingURL=run.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.mjs","names":["Logger"],"sources":["../../../src/substrate/runtime/run.ts"],"sourcesContent":["// Shared substrate-Layer composition + supervise() entrypoint.\n//\n// Single seam consumed by both the CLI bin entry (`cli/main.ts`) and the\n// library-facing programmatic surface (`api/run-stack.ts`). Composes the\n// substrate Layer stack, yields the substrate services into a\n// `Context.Context<never>` pluginContext, builds the projection ref,\n// and runs `supervise()` inside a scope.\n//\n// The CLI augments the supervised body with cross-process command\n// channel forwarding; the library surface passes a no-op augmentation\n// and exposes the handle's events / state / awaitShutdown directly.\n//\n// Architecture: this is L0 substrate. It names no plugin and no\n// capability declaration. Built-in plugin services are composed by the\n// higher-level runtime composition layer before the supervisor starts.\n\nimport { Context, Effect, Layer, Logger as EffectLogger, Scope, SubscriptionRef } from 'effect';\nimport * as NodeFileSystem from '@effect/platform-node/NodeFileSystem';\nimport * as NodePath from '@effect/platform-node/NodePath';\nimport * as NodeChildProcessSpawner from '@effect/platform-node/NodeChildProcessSpawner';\nimport { ChildProcessSpawner } from 'effect/unstable/process/ChildProcessSpawner';\n\nimport type { Identity } from '../identity.ts';\nimport { CacheService, layerCache } from './cache/index.ts';\nimport { LeaseBrokerService, layerLeaseBroker } from './lease-broker/index.ts';\nimport { ArtifactPublisherService, layerArtifactPublisher } from './artifact-publisher/index.ts';\nimport {\n\tIdentityContext,\n\tRuntimeRoot,\n\tStackPathsService,\n\tlayerIdentity,\n\tlayerRuntimeRoot,\n\tlayerStackPaths,\n} from './paths.ts';\nimport { PortBrokerService, layerPortBroker } from './port-broker/index.ts';\nimport { StrategyRegistryService, layerStrategyRegistry } from './strategy-registry/index.ts';\nimport {\n\tContainerRuntimeService,\n\tDockerSpawner,\n\tlayerContainerRuntimeDocker,\n\tlayerDockerCycleInitial,\n\tlayerDockerHostDefault,\n} from '../../runtime/docker/index.ts';\nimport { awaitAll } from './lifecycle/index.ts';\nimport { makeProjectionRef } from './projection/index.ts';\nimport { Logger, Redactor, layerLogger, layerRedactor } from './observability/index.ts';\nimport { PostAcquireTasksService, layerPostAcquireTasks } from './post-acquire-tasks.ts';\nimport {\n\tstartSupervisor,\n\ttype OrchestratorSinks,\n\ttype SupervisedStack,\n\ttype SupervisorCommandHandler,\n\ttype SupervisorHandle,\n\ttype SupervisorPostAcquireHook,\n} from './supervisor.ts';\n\n/** Substrate Layer stack for a single supervised run. Composes every L0\n *  service the supervisor yields from its R-channel, plus the L1 Docker\n *  `ContainerRuntime`. Built-in plugin services are layered outside\n *  substrate and added through `extendContext`. */\nexport const buildSubstrateLayers = (identity: Identity, runtimeRoot: string) => {\n\t// DockerSpawner adapts platform-node's ChildProcessSpawner tag onto\n\t// the docker subsystem's local DockerSpawner tag (same shape; the\n\t// indirection only lets tests inject a stub).\n\tconst layerDockerSpawnerFromNode: Layer.Layer<DockerSpawner, never, ChildProcessSpawner> =\n\t\tLayer.effect(\n\t\t\tDockerSpawner,\n\t\t\tEffect.gen(function* () {\n\t\t\t\treturn yield* ChildProcessSpawner;\n\t\t\t}),\n\t\t);\n\n\tconst platformBase = Layer.mergeAll(\n\t\tlayerIdentity(identity),\n\t\tlayerRuntimeRoot(runtimeRoot),\n\t\tNodePath.layer,\n\t\tNodeFileSystem.layer,\n\t\tlayerDockerHostDefault,\n\t\tlayerDockerCycleInitial,\n\t\tlayerStrategyRegistry,\n\t);\n\n\tconst childProcessSpawnerWired = NodeChildProcessSpawner.layer.pipe(\n\t\tLayer.provideMerge(platformBase),\n\t);\n\tconst withStackPaths = layerStackPaths.pipe(Layer.provideMerge(childProcessSpawnerWired));\n\tconst withCache = layerCache.pipe(Layer.provideMerge(withStackPaths));\n\tconst withArtifactPublisher = layerArtifactPublisher.pipe(Layer.provideMerge(withCache));\n\tconst withPortBroker = layerPortBroker.pipe(Layer.provideMerge(withArtifactPublisher));\n\tconst withLeaseBroker = layerLeaseBroker.pipe(Layer.provideMerge(withPortBroker));\n\tconst withSpawnerAdapter = layerDockerSpawnerFromNode.pipe(Layer.provideMerge(withLeaseBroker));\n\tconst withContainerRuntime = layerContainerRuntimeDocker.pipe(\n\t\tLayer.provideMerge(withSpawnerAdapter),\n\t);\n\tconst withPostAcquireTasks = layerPostAcquireTasks.pipe(Layer.provideMerge(withContainerRuntime));\n\tconst withRedactor = layerRedactor.pipe(Layer.provideMerge(withPostAcquireTasks));\n\treturn layerLogger.pipe(Layer.provideMerge(withRedactor));\n};\n\n/** Build the opaque `Context.Context<never>` the supervisor hands to\n *  every plugin's `acquire` body. Yields every substrate service the\n *  Docker-backed substrate layer stack provides; downstream callers\n *  may extend the context (e.g. layering a Logger or a\n *  `CapabilitySinksService`) before passing it to `supervise()`. */\nconst buildPluginContext = (): Effect.Effect<\n\tContext.Context<never>,\n\tnever,\n\t| IdentityContext\n\t| RuntimeRoot\n\t| StackPathsService\n\t| CacheService\n\t| StrategyRegistryService\n\t| ContainerRuntimeService\n\t| ArtifactPublisherService\n\t| PortBrokerService\n\t| LeaseBrokerService\n\t| PostAcquireTasksService\n\t| Logger\n\t| Redactor\n> =>\n\tEffect.gen(function* () {\n\t\tconst identityCtx = yield* IdentityContext;\n\t\tconst runtimeRootResolved = yield* RuntimeRoot;\n\t\tconst stackPaths = yield* StackPathsService;\n\t\tconst cache = yield* CacheService;\n\t\tconst registry = yield* StrategyRegistryService;\n\t\tconst containerRuntime = yield* ContainerRuntimeService;\n\t\tconst publisher = yield* ArtifactPublisherService;\n\t\tconst portBroker = yield* PortBrokerService;\n\t\tconst leaseBroker = yield* LeaseBrokerService;\n\t\tconst postAcquireTasks = yield* PostAcquireTasksService;\n\t\tconst logger = yield* Logger;\n\t\tconst redactor = yield* Redactor;\n\n\t\treturn Context.empty().pipe(\n\t\t\tContext.add(IdentityContext, identityCtx),\n\t\t\tContext.add(RuntimeRoot, runtimeRootResolved),\n\t\t\tContext.add(StackPathsService, stackPaths),\n\t\t\tContext.add(CacheService, cache),\n\t\t\tContext.add(StrategyRegistryService, registry),\n\t\t\tContext.add(ContainerRuntimeService, containerRuntime),\n\t\t\tContext.add(ArtifactPublisherService, publisher),\n\t\t\tContext.add(PortBrokerService, portBroker),\n\t\t\tContext.add(LeaseBrokerService, leaseBroker),\n\t\t\tContext.add(PostAcquireTasksService, postAcquireTasks),\n\t\t\tContext.add(Logger, logger),\n\t\t\tContext.add(Redactor, redactor),\n\t\t) as Context.Context<never>;\n\t});\n\n/** Options accepted by the supervised-run entrypoint. `lifetime`\n *  selects long-running supervision versus a one-shot acquire/codegen\n *  cycle. The `beforeInitialAcquire` hook runs inside the supervised\n *  scope before the first acquire starts; live renderers use it to\n *  subscribe to startup projection changes. The `withinScope` hook\n *  runs after the first acquire completes.\n *\n *  Generic `R` widens the hook R-channel so callers can yield\n *  substrate services (e.g. `StackPathsService`) that are in scope at\n *  the supervisor-boot site. */\nexport interface SuperviseStackOptions<R = Scope.Scope, ExtendR = never, HookE = never> {\n\treadonly lifetime?: 'long-running' | 'one-shot';\n\treadonly beforeInitialAcquire?: (handle: SupervisorHandle) => Effect.Effect<void, HookE, R>;\n\treadonly withinScope?: (handle: SupervisorHandle) => Effect.Effect<void, HookE, R>;\n\treadonly commandHandler?: SupervisorCommandHandler;\n\treadonly orchestratorSinks?: OrchestratorSinks;\n\treadonly postAcquireHook?: SupervisorPostAcquireHook;\n\t/** Caller-supplied extension layered into `pluginContext` after the\n\t *  default substrate context is built. Used by plugin-author Layer\n\t *  composition (ARCHITECTURE.md § Plugin-author extension) and by\n\t *  the CLI when it wants to inject a custom Logger / CapabilitySinks\n\t *  override. */\n\treadonly extendContext?: (\n\t\tctx: Context.Context<never>,\n\t) => Effect.Effect<Context.Context<never>, never, ExtendR>;\n}\n\n/** Effect that boots the supervisor for `stack` and blocks on the\n *  supervisor's shutdown latch. Returns the final `SubscribableState`\n *  snapshot so callers (CLI, library handle) can inspect post-shutdown\n *  state. */\nexport const superviseStackEffect = <R = Scope.Scope, ExtendR = never, HookE = never>(\n\tstack: SupervisedStack,\n\tidentity: Identity,\n\tstate: SubscriptionRef.SubscriptionRef<import('../projection.ts').SubscribableState>,\n\topts: SuperviseStackOptions<R, ExtendR, HookE> = {},\n) =>\n\tEffect.gen(function* () {\n\t\tconst baseContext = yield* buildPluginContext();\n\t\tconst pluginContext =\n\t\t\topts.extendContext === undefined ? baseContext : yield* opts.extendContext(baseContext);\n\n\t\treturn yield* Effect.scoped(\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst startup = yield* startSupervisor(\n\t\t\t\t\tstack,\n\t\t\t\t\tidentity,\n\t\t\t\t\tstate,\n\t\t\t\t\tpluginContext,\n\t\t\t\t\topts.orchestratorSinks ?? [],\n\t\t\t\t\topts.commandHandler,\n\t\t\t\t\topts.postAcquireHook,\n\t\t\t\t\t{ commandLoop: opts.lifetime !== 'one-shot' },\n\t\t\t\t);\n\t\t\t\tconst { handle } = startup;\n\t\t\t\tif (opts.beforeInitialAcquire !== undefined) {\n\t\t\t\t\tyield* opts.beforeInitialAcquire(handle);\n\t\t\t\t}\n\t\t\t\tif (opts.lifetime === 'one-shot') {\n\t\t\t\t\tyield* startup.runInitialAcquire;\n\t\t\t\t\tyield* awaitAll(startup.handle.registry, [...startup.handle.graph.nodes.keys()]);\n\t\t\t\t\tif (opts.withinScope !== undefined) {\n\t\t\t\t\t\tyield* opts.withinScope(handle);\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst outcome = yield* Effect.raceFirst(\n\t\t\t\t\tstartup.runInitialAcquire.pipe(Effect.as('booted' as const)),\n\t\t\t\t\thandle.awaitShutdown.pipe(Effect.as('shutdown' as const)),\n\t\t\t\t);\n\t\t\t\tif (outcome === 'shutdown') {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif (opts.withinScope !== undefined) {\n\t\t\t\t\tyield* opts.withinScope(handle);\n\t\t\t\t}\n\t\t\t\tyield* handle.awaitShutdown;\n\t\t\t}),\n\t\t);\n\t});\n\n/** End-to-end run: builds the substrate Layer stack, provides it to\n *  `superviseStackEffect`, applies a quiet Logger by default unless the\n *  caller passes one in `opts.loggerLayer`. The returned Effect has\n *  type `Effect<void, ..., never>` — all requirements are discharged\n *  by the layer stack composed here.\n *\n *  Callers that need to capture intermediate state (errors, terminal\n *  snapshot, etc.) supply `opts.withinScope` and read off the\n *  supervisor handle directly. */\nexport interface RunStackEffectOptions<\n\tR = Scope.Scope,\n\tExtendR = never,\n\tHookE = never,\n> extends SuperviseStackOptions<R, ExtendR, HookE> {\n\treadonly runtimeRoot: string;\n\treadonly loggerLayer?: Layer.Layer<never>;\n}\n\nexport const runStackEffect = <R = Scope.Scope, ExtendR = never, HookE = never>(\n\tstack: SupervisedStack,\n\tidentity: Identity,\n\topts: RunStackEffectOptions<R, ExtendR, HookE>,\n) => {\n\tconst substrate = buildSubstrateLayers(identity, opts.runtimeRoot);\n\tconst program = Effect.gen(function* () {\n\t\tconst state = yield* makeProjectionRef();\n\t\tyield* superviseStackEffect(stack, identity, state, opts);\n\t});\n\n\treturn program.pipe(\n\t\tEffect.provide(substrate),\n\t\tEffect.provide(opts.loggerLayer ?? EffectLogger.layer([])),\n\t);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4DA,MAAa,wBAAwB,UAAoB,gBAAwB;CAIhF,MAAM,6BACL,MAAM,OACL,eACA,OAAO,IAAI,aAAa;AACvB,SAAO,OAAO;GACb,CACF;CAEF,MAAM,eAAe,MAAM,SAC1B,cAAc,SAAS,EACvB,iBAAiB,YAAY,EAC7B,SAAS,OACT,eAAe,OACf,wBACA,yBACA,sBACA;CAED,MAAM,2BAA2B,wBAAwB,MAAM,KAC9D,MAAM,aAAa,aAAa,CAChC;CACD,MAAM,iBAAiB,gBAAgB,KAAK,MAAM,aAAa,yBAAyB,CAAC;CACzF,MAAM,YAAY,WAAW,KAAK,MAAM,aAAa,eAAe,CAAC;CACrE,MAAM,wBAAwB,uBAAuB,KAAK,MAAM,aAAa,UAAU,CAAC;CACxF,MAAM,iBAAiB,gBAAgB,KAAK,MAAM,aAAa,sBAAsB,CAAC;CACtF,MAAM,kBAAkB,iBAAiB,KAAK,MAAM,aAAa,eAAe,CAAC;CACjF,MAAM,qBAAqB,2BAA2B,KAAK,MAAM,aAAa,gBAAgB,CAAC;CAC/F,MAAM,uBAAuB,4BAA4B,KACxD,MAAM,aAAa,mBAAmB,CACtC;CACD,MAAM,uBAAuB,sBAAsB,KAAK,MAAM,aAAa,qBAAqB,CAAC;CACjG,MAAM,eAAe,cAAc,KAAK,MAAM,aAAa,qBAAqB,CAAC;AACjF,QAAO,YAAY,KAAK,MAAM,aAAa,aAAa,CAAC;;;;;;;AAQ1D,MAAM,2BAgBL,OAAO,IAAI,aAAa;CACvB,MAAM,cAAc,OAAO;CAC3B,MAAM,sBAAsB,OAAO;CACnC,MAAM,aAAa,OAAO;CAC1B,MAAM,QAAQ,OAAO;CACrB,MAAM,WAAW,OAAO;CACxB,MAAM,mBAAmB,OAAO;CAChC,MAAM,YAAY,OAAO;CACzB,MAAM,aAAa,OAAO;CAC1B,MAAM,cAAc,OAAO;CAC3B,MAAM,mBAAmB,OAAO;CAChC,MAAM,SAAS,OAAOA;CACtB,MAAM,WAAW,OAAO;AAExB,QAAO,QAAQ,OAAO,CAAC,KACtB,QAAQ,IAAI,iBAAiB,YAAY,EACzC,QAAQ,IAAI,aAAa,oBAAoB,EAC7C,QAAQ,IAAI,mBAAmB,WAAW,EAC1C,QAAQ,IAAI,cAAc,MAAM,EAChC,QAAQ,IAAI,yBAAyB,SAAS,EAC9C,QAAQ,IAAI,yBAAyB,iBAAiB,EACtD,QAAQ,IAAI,0BAA0B,UAAU,EAChD,QAAQ,IAAI,mBAAmB,WAAW,EAC1C,QAAQ,IAAI,oBAAoB,YAAY,EAC5C,QAAQ,IAAI,yBAAyB,iBAAiB,EACtD,QAAQ,IAAIA,UAAQ,OAAO,EAC3B,QAAQ,IAAI,UAAU,SAAS,CAC/B;EACA;;;;;AAiCH,MAAa,wBACZ,OACA,UACA,OACA,OAAiD,EAAE,KAEnD,OAAO,IAAI,aAAa;CACvB,MAAM,cAAc,OAAO,oBAAoB;CAC/C,MAAM,gBACL,KAAK,kBAAkB,KAAA,IAAY,cAAc,OAAO,KAAK,cAAc,YAAY;AAExF,QAAO,OAAO,OAAO,OACpB,OAAO,IAAI,aAAa;EACvB,MAAM,UAAU,OAAO,gBACtB,OACA,UACA,OACA,eACA,KAAK,qBAAqB,EAAE,EAC5B,KAAK,gBACL,KAAK,iBACL,EAAE,aAAa,KAAK,aAAa,YAAY,CAC7C;EACD,MAAM,EAAE,WAAW;AACnB,MAAI,KAAK,yBAAyB,KAAA,EACjC,QAAO,KAAK,qBAAqB,OAAO;AAEzC,MAAI,KAAK,aAAa,YAAY;AACjC,UAAO,QAAQ;AACf,UAAO,SAAS,QAAQ,OAAO,UAAU,CAAC,GAAG,QAAQ,OAAO,MAAM,MAAM,MAAM,CAAC,CAAC;AAChF,OAAI,KAAK,gBAAgB,KAAA,EACxB,QAAO,KAAK,YAAY,OAAO;AAEhC;;AAMD,OAAI,OAJmB,OAAO,UAC7B,QAAQ,kBAAkB,KAAK,OAAO,GAAG,SAAkB,CAAC,EAC5D,OAAO,cAAc,KAAK,OAAO,GAAG,WAAoB,CAAC,CACzD,MACe,WACf;AAED,MAAI,KAAK,gBAAgB,KAAA,EACxB,QAAO,KAAK,YAAY,OAAO;AAEhC,SAAO,OAAO;GACb,CACF;EACA"}

package/dist/substrate/runtime/runtime-decode.d.mts

@@ -0,0 +1,32 @@
+import { Effect, Schema } from "effect";
+
+//#region src/substrate/runtime/runtime-decode.d.ts
+declare namespace runtime_decode_d_exports {
+  export { DecodeOptions, JsonArrayElementDecodeOptions, RuntimeDecodeErrorFactory, RuntimeDecodeIssue, decodeJsonArrayElementSync, decodeJsonLines, decodeJsonText, decodeJsonTextSync, decodeUnknown, decodeUnknownSync, parseJsonText, parseJsonTextSync };
+}
+interface RuntimeDecodeIssue {
+  readonly source: string;
+  readonly message: string;
+  readonly cause?: unknown;
+}
+type RuntimeDecodeErrorFactory<E> = (issue: RuntimeDecodeIssue) => E;
+interface DecodeOptions<E> {
+  readonly source: string;
+  readonly mkError: RuntimeDecodeErrorFactory<E>;
+  readonly message?: string;
+}
+interface JsonArrayElementDecodeOptions<E> extends DecodeOptions<E> {
+  readonly index?: number;
+  readonly missingMessage?: string;
+}
+declare const parseJsonText: <E>(text: string, options: DecodeOptions<E>) => Effect.Effect<unknown, E>;
+declare const parseJsonTextSync: <E>(text: string, options: DecodeOptions<E>) => unknown;
+declare const decodeUnknown: <S extends Schema.Decoder<unknown>, E>(schema: S, value: unknown, options: DecodeOptions<E>) => Effect.Effect<S["Type"], E>;
+declare const decodeUnknownSync: <S extends Schema.Decoder<unknown>, E>(schema: S, value: unknown, options: DecodeOptions<E>) => S["Type"];
+declare const decodeJsonText: <S extends Schema.Decoder<unknown>, E>(schema: S, text: string, options: DecodeOptions<E>) => Effect.Effect<S["Type"], E>;
+declare const decodeJsonTextSync: <S extends Schema.Decoder<unknown>, E>(schema: S, text: string, options: DecodeOptions<E>) => S["Type"];
+declare const decodeJsonArrayElementSync: <S extends Schema.Decoder<unknown>, E>(schema: S, text: string, options: JsonArrayElementDecodeOptions<E>) => S["Type"];
+declare const decodeJsonLines: <S extends Schema.Decoder<unknown>, E>(schema: S, text: string, options: DecodeOptions<E>) => Effect.Effect<ReadonlyArray<S["Type"]>, E>;
+//#endregion
+export { runtime_decode_d_exports };
+//# sourceMappingURL=runtime-decode.d.mts.map

package/dist/substrate/runtime/runtime-decode.mjs

@@ -0,0 +1,53 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
+import { Effect, Schema } from "effect";
+//#region src/substrate/runtime/runtime-decode.ts
+var runtime_decode_exports = /* @__PURE__ */ __exportAll({
+	decodeJsonArrayElementSync: () => decodeJsonArrayElementSync,
+	decodeJsonLines: () => decodeJsonLines,
+	decodeJsonText: () => decodeJsonText,
+	decodeJsonTextSync: () => decodeJsonTextSync,
+	decodeUnknown: () => decodeUnknown,
+	decodeUnknownSync: () => decodeUnknownSync,
+	parseJsonText: () => parseJsonText,
+	parseJsonTextSync: () => parseJsonTextSync
+});
+const issue = (options, message, cause) => ({
+	source: options.source,
+	message: options.message ?? message,
+	...cause === void 0 ? {} : { cause }
+});
+const parseJsonText = (text, options) => Effect.try({
+	try: () => JSON.parse(text),
+	catch: (cause) => options.mkError(issue(options, "failed to parse JSON", cause))
+});
+const parseJsonTextSync = (text, options) => {
+	try {
+		return JSON.parse(text);
+	} catch (cause) {
+		throw options.mkError(issue(options, "failed to parse JSON", cause));
+	}
+};
+const decodeUnknown = (schema, value, options) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => options.mkError(issue(options, "failed to decode value", cause))));
+const decodeUnknownSync = (schema, value, options) => {
+	try {
+		return Schema.decodeUnknownSync(schema)(value);
+	} catch (cause) {
+		throw options.mkError(issue(options, "failed to decode value", cause));
+	}
+};
+const decodeJsonText = (schema, text, options) => parseJsonText(text, options).pipe(Effect.flatMap((value) => decodeUnknown(schema, value, options)));
+const decodeJsonTextSync = (schema, text, options) => decodeUnknownSync(schema, parseJsonTextSync(text, options), options);
+const decodeJsonArrayElementSync = (schema, text, options) => {
+	const index = options.index ?? 0;
+	const value = parseJsonTextSync(text, options);
+	if (!Array.isArray(value) || value[index] === void 0) throw options.mkError(issue(options, options.missingMessage ?? `expected JSON array element at index ${index}`, value));
+	return decodeUnknownSync(schema, value[index], options);
+};
+const decodeJsonLines = (schema, text, options) => Effect.forEach(text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0), (line, index) => decodeJsonText(schema, line, {
+	...options,
+	source: `${options.source}:${index + 1}`
+}));
+//#endregion
+export { decodeJsonArrayElementSync, decodeJsonText, decodeJsonTextSync, decodeUnknown, decodeUnknownSync, parseJsonText, parseJsonTextSync, runtime_decode_exports };
+
+//# sourceMappingURL=runtime-decode.mjs.map

package/dist/substrate/runtime/runtime-decode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-decode.mjs","names":[],"sources":["../../../src/substrate/runtime/runtime-decode.ts"],"sourcesContent":["import { Effect, Schema } from 'effect';\n\nexport interface RuntimeDecodeIssue {\n\treadonly source: string;\n\treadonly message: string;\n\treadonly cause?: unknown;\n}\n\nexport type RuntimeDecodeErrorFactory<E> = (issue: RuntimeDecodeIssue) => E;\n\nexport interface DecodeOptions<E> {\n\treadonly source: string;\n\treadonly mkError: RuntimeDecodeErrorFactory<E>;\n\treadonly message?: string;\n}\n\nexport interface JsonArrayElementDecodeOptions<E> extends DecodeOptions<E> {\n\treadonly index?: number;\n\treadonly missingMessage?: string;\n}\n\nconst issue = <E>(\n\toptions: DecodeOptions<E>,\n\tmessage: string,\n\tcause?: unknown,\n): RuntimeDecodeIssue => ({\n\tsource: options.source,\n\tmessage: options.message ?? message,\n\t...(cause === undefined ? {} : { cause }),\n});\n\nexport const parseJsonText = <E>(\n\ttext: string,\n\toptions: DecodeOptions<E>,\n): Effect.Effect<unknown, E> =>\n\tEffect.try({\n\t\ttry: () => JSON.parse(text) as unknown,\n\t\tcatch: (cause) => options.mkError(issue(options, 'failed to parse JSON', cause)),\n\t});\n\nexport const parseJsonTextSync = <E>(text: string, options: DecodeOptions<E>): unknown => {\n\ttry {\n\t\treturn JSON.parse(text) as unknown;\n\t} catch (cause) {\n\t\tthrow options.mkError(issue(options, 'failed to parse JSON', cause));\n\t}\n};\n\nexport const decodeUnknown = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\tvalue: unknown,\n\toptions: DecodeOptions<E>,\n): Effect.Effect<S['Type'], E> =>\n\tSchema.decodeUnknownEffect(schema)(value).pipe(\n\t\tEffect.mapError((cause) => options.mkError(issue(options, 'failed to decode value', cause))),\n\t);\n\nexport const decodeUnknownSync = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\tvalue: unknown,\n\toptions: DecodeOptions<E>,\n): S['Type'] => {\n\ttry {\n\t\treturn Schema.decodeUnknownSync(schema)(value);\n\t} catch (cause) {\n\t\tthrow options.mkError(issue(options, 'failed to decode value', cause));\n\t}\n};\n\nexport const decodeJsonText = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\ttext: string,\n\toptions: DecodeOptions<E>,\n): Effect.Effect<S['Type'], E> =>\n\tparseJsonText(text, options).pipe(\n\t\tEffect.flatMap((value) => decodeUnknown(schema, value, options)),\n\t);\n\nexport const decodeJsonTextSync = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\ttext: string,\n\toptions: DecodeOptions<E>,\n): S['Type'] => decodeUnknownSync(schema, parseJsonTextSync(text, options), options);\n\nexport const decodeJsonArrayElementSync = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\ttext: string,\n\toptions: JsonArrayElementDecodeOptions<E>,\n): S['Type'] => {\n\tconst index = options.index ?? 0;\n\tconst value = parseJsonTextSync(text, options);\n\tif (!Array.isArray(value) || value[index] === undefined) {\n\t\tthrow options.mkError(\n\t\t\tissue(\n\t\t\t\toptions,\n\t\t\t\toptions.missingMessage ?? `expected JSON array element at index ${index}`,\n\t\t\t\tvalue,\n\t\t\t),\n\t\t);\n\t}\n\treturn decodeUnknownSync(schema, value[index], options);\n};\n\nexport const decodeJsonLines = <S extends Schema.Decoder<unknown>, E>(\n\tschema: S,\n\ttext: string,\n\toptions: DecodeOptions<E>,\n): Effect.Effect<ReadonlyArray<S['Type']>, E> =>\n\tEffect.forEach(\n\t\ttext\n\t\t\t.split(/\\r?\\n/u)\n\t\t\t.map((line) => line.trim())\n\t\t\t.filter((line) => line.length > 0),\n\t\t(line, index) =>\n\t\t\tdecodeJsonText(schema, line, {\n\t\t\t\t...options,\n\t\t\t\tsource: `${options.source}:${index + 1}`,\n\t\t\t}),\n\t);\n"],"mappings":";;;;;;;;;;;;;AAqBA,MAAM,SACL,SACA,SACA,WACyB;CACzB,QAAQ,QAAQ;CAChB,SAAS,QAAQ,WAAW;CAC5B,GAAI,UAAU,KAAA,IAAY,EAAE,GAAG,EAAE,OAAO;CACxC;AAED,MAAa,iBACZ,MACA,YAEA,OAAO,IAAI;CACV,WAAW,KAAK,MAAM,KAAK;CAC3B,QAAQ,UAAU,QAAQ,QAAQ,MAAM,SAAS,wBAAwB,MAAM,CAAC;CAChF,CAAC;AAEH,MAAa,qBAAwB,MAAc,YAAuC;AACzF,KAAI;AACH,SAAO,KAAK,MAAM,KAAK;UACf,OAAO;AACf,QAAM,QAAQ,QAAQ,MAAM,SAAS,wBAAwB,MAAM,CAAC;;;AAItE,MAAa,iBACZ,QACA,OACA,YAEA,OAAO,oBAAoB,OAAO,CAAC,MAAM,CAAC,KACzC,OAAO,UAAU,UAAU,QAAQ,QAAQ,MAAM,SAAS,0BAA0B,MAAM,CAAC,CAAC,CAC5F;AAEF,MAAa,qBACZ,QACA,OACA,YACe;AACf,KAAI;AACH,SAAO,OAAO,kBAAkB,OAAO,CAAC,MAAM;UACtC,OAAO;AACf,QAAM,QAAQ,QAAQ,MAAM,SAAS,0BAA0B,MAAM,CAAC;;;AAIxE,MAAa,kBACZ,QACA,MACA,YAEA,cAAc,MAAM,QAAQ,CAAC,KAC5B,OAAO,SAAS,UAAU,cAAc,QAAQ,OAAO,QAAQ,CAAC,CAChE;AAEF,MAAa,sBACZ,QACA,MACA,YACe,kBAAkB,QAAQ,kBAAkB,MAAM,QAAQ,EAAE,QAAQ;AAEpF,MAAa,8BACZ,QACA,MACA,YACe;CACf,MAAM,QAAQ,QAAQ,SAAS;CAC/B,MAAM,QAAQ,kBAAkB,MAAM,QAAQ;AAC9C,KAAI,CAAC,MAAM,QAAQ,MAAM,IAAI,MAAM,WAAW,KAAA,EAC7C,OAAM,QAAQ,QACb,MACC,SACA,QAAQ,kBAAkB,wCAAwC,SAClE,MACA,CACD;AAEF,QAAO,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ;;AAGxD,MAAa,mBACZ,QACA,MACA,YAEA,OAAO,QACN,KACE,MAAM,SAAS,CACf,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,QAAQ,SAAS,KAAK,SAAS,EAAE,GAClC,MAAM,UACN,eAAe,QAAQ,MAAM;CAC5B,GAAG;CACH,QAAQ,GAAG,QAAQ,OAAO,GAAG,QAAQ;CACrC,CAAC,CACH"}

package/dist/substrate/runtime/scoped-http-server.mjs

@@ -0,0 +1,36 @@
+import { Effect } from "effect";
+import { createServer } from "node:http";
+//#region src/substrate/runtime/scoped-http-server.ts
+/** Best-effort graceful close. `closeAllConnections()` drops idle
+*  keepalive sockets so `close()` resolves; older Node versions
+*  without `closeAllConnections` rely on `close()` alone. */
+const gracefulCloseHttpServer = (server) => Effect.callback((resume) => {
+	try {
+		server.closeAllConnections();
+	} catch {}
+	server.close(() => resume(Effect.void));
+});
+const listenScopedHttpServer = (options) => Effect.gen(function* () {
+	const server = yield* Effect.tryPromise({
+		try: () => new Promise((resolve, reject) => {
+			const srv = createServer(options.listener);
+			const onError = (err) => reject(err);
+			srv.once("error", onError);
+			srv.listen(options.port, options.bindAddress, () => {
+				srv.removeListener("error", onError);
+				resolve(srv);
+			});
+		}),
+		catch: options.onListenError
+	});
+	yield* Effect.addFinalizer(() => gracefulCloseHttpServer(server).pipe(Effect.uninterruptible));
+	return {
+		url: `http://${options.bindAddress}:${options.port}`,
+		server,
+		close: () => gracefulCloseHttpServer(server)
+	};
+});
+//#endregion
+export { listenScopedHttpServer };
+
+//# sourceMappingURL=scoped-http-server.mjs.map

package/dist/substrate/runtime/scoped-http-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-http-server.mjs","names":[],"sources":["../../../src/substrate/runtime/scoped-http-server.ts"],"sourcesContent":["// Scoped host HTTP server primitive.\n//\n// Generic ownership for in-process host HTTP listeners: bind, surface\n// listen failures through a caller-owned error mapper, and install a\n// scope finalizer that drops idle keepalive sockets before awaiting\n// close. Domain routing stays with the plugin that supplies the\n// Node request listener.\n\nimport { Effect } from 'effect';\nimport type { Scope } from 'effect';\nimport { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';\n\nexport type HttpRequestListener = (req: IncomingMessage, res: ServerResponse) => void;\n\nexport interface ScopedHttpServerOptions<E> {\n\treadonly bindAddress: string;\n\treadonly port: number;\n\treadonly listener: HttpRequestListener;\n\treadonly onListenError: (cause: unknown) => E;\n}\n\nexport interface ScopedHttpServerHandle {\n\treadonly url: string;\n\treadonly server: Server;\n\treadonly close: () => Effect.Effect<void>;\n}\n\n/** Best-effort graceful close. `closeAllConnections()` drops idle\n *  keepalive sockets so `close()` resolves; older Node versions\n *  without `closeAllConnections` rely on `close()` alone. */\nexport const gracefulCloseHttpServer = (server: Server): Effect.Effect<void> =>\n\tEffect.callback<void>((resume) => {\n\t\ttry {\n\t\t\tserver.closeAllConnections();\n\t\t} catch {\n\t\t\t// Older Node versions don't expose closeAllConnections;\n\t\t\t// `close()` alone will still terminate.\n\t\t}\n\t\tserver.close(() => resume(Effect.void));\n\t});\n\nexport const listenScopedHttpServer = <E>(\n\toptions: ScopedHttpServerOptions<E>,\n): Effect.Effect<ScopedHttpServerHandle, E, Scope.Scope> =>\n\tEffect.gen(function* () {\n\t\tconst server = yield* Effect.tryPromise({\n\t\t\ttry: () =>\n\t\t\t\tnew Promise<Server>((resolve, reject) => {\n\t\t\t\t\tconst srv = createServer(options.listener);\n\t\t\t\t\tconst onError = (err: Error) => reject(err);\n\t\t\t\t\tsrv.once('error', onError);\n\t\t\t\t\tsrv.listen(options.port, options.bindAddress, () => {\n\t\t\t\t\t\tsrv.removeListener('error', onError);\n\t\t\t\t\t\tresolve(srv);\n\t\t\t\t\t});\n\t\t\t\t}),\n\t\t\tcatch: options.onListenError,\n\t\t});\n\n\t\tyield* Effect.addFinalizer(() => gracefulCloseHttpServer(server).pipe(Effect.uninterruptible));\n\n\t\treturn {\n\t\t\turl: `http://${options.bindAddress}:${options.port}`,\n\t\t\tserver,\n\t\t\tclose: () => gracefulCloseHttpServer(server),\n\t\t};\n\t});\n"],"mappings":";;;;;;AA8BA,MAAa,2BAA2B,WACvC,OAAO,UAAgB,WAAW;AACjC,KAAI;AACH,SAAO,qBAAqB;SACrB;AAIR,QAAO,YAAY,OAAO,OAAO,KAAK,CAAC;EACtC;AAEH,MAAa,0BACZ,YAEA,OAAO,IAAI,aAAa;CACvB,MAAM,SAAS,OAAO,OAAO,WAAW;EACvC,WACC,IAAI,SAAiB,SAAS,WAAW;GACxC,MAAM,MAAM,aAAa,QAAQ,SAAS;GAC1C,MAAM,WAAW,QAAe,OAAO,IAAI;AAC3C,OAAI,KAAK,SAAS,QAAQ;AAC1B,OAAI,OAAO,QAAQ,MAAM,QAAQ,mBAAmB;AACnD,QAAI,eAAe,SAAS,QAAQ;AACpC,YAAQ,IAAI;KACX;IACD;EACH,OAAO,QAAQ;EACf,CAAC;AAEF,QAAO,OAAO,mBAAmB,wBAAwB,OAAO,CAAC,KAAK,OAAO,gBAAgB,CAAC;AAE9F,QAAO;EACN,KAAK,UAAU,QAAQ,YAAY,GAAG,QAAQ;EAC9C;EACA,aAAa,wBAAwB,OAAO;EAC5C;EACA"}

package/dist/substrate/runtime/scoped-ref-map/service.mjs

@@ -0,0 +1,83 @@
+import { Context, Effect, Layer, Schema, SubscriptionRef } from "effect";
+//#region src/substrate/runtime/scoped-ref-map/service.ts
+/** Lookup failure for a missing key. Schema-tagged so consumers
+*  may `Effect.catchTag('ScopedRefMapKeyMissingError', ...)` and
+*  the cascade-formatter can render it without importing the class. */
+var ScopedRefMapKeyMissingError = class extends Schema.TaggedErrorClass()("ScopedRefMapKeyMissingError", {
+	registryName: Schema.String,
+	key: Schema.String
+}) {};
+/**
+* Factory: declare a typed `K -> V` scoped ref-map service.
+*
+* The `name` becomes both the human-readable registry name (used
+* in `ScopedRefMapKeyMissingError.registryName`) and the
+* Context.Service identifier (prefixed with the substrate
+* namespace). Each call returns a fresh Service class; calling
+* twice with the same name produces two distinct services
+* (Context.Service identity is per-class, not per-id-string —
+* the id string is a debugging aid).
+*
+* Return shape — typed via inference so the inner Service class's
+* identity flows through to callers:
+*   - `Service` — the `Context.Service` tag class. Plugin authors
+*     yield this from their `acquire` body via `yield* MyRegistry.Service`.
+*   - `layer` — scope-bound Layer constructing one ref-map per
+*     stack scope.
+*   - `changes` — stream helper mirroring `routesStream(router)`.
+*
+* Example (in an L2 plugin):
+*
+* ```ts
+* const PackageRegistry = defineScopedRefMap<PackageKey, PackageRecord>('PackageRegistry');
+*
+* // In the plugin's acquire body:
+* const registry = yield* PackageRegistry.Service;
+* yield* registry.set(name, resolved);
+*
+* // In the boot Layer:
+* Layer.mergeAll(PackageRegistry.layer, ...)
+* ```
+*/
+const defineScopedRefMap = (name) => {
+	const serviceId = `@devstack-rewrite/substrate/ScopedRefMap/${name}`;
+	class Service extends Context.Service()(serviceId) {}
+	const layer = Layer.effect(Service, Effect.gen(function* () {
+		const ref = yield* SubscriptionRef.make([]);
+		const set = (key, value) => SubscriptionRef.update(ref, (current) => {
+			return [...current.filter(([k]) => k !== key), [key, value]];
+		});
+		const find = (key) => SubscriptionRef.get(ref).pipe(Effect.map((current) => {
+			const hit = current.find(([k]) => k === key);
+			return hit ? hit[1] : null;
+		}));
+		const get = (key) => Effect.gen(function* () {
+			const value = yield* find(key);
+			if (value === null) return yield* new ScopedRefMapKeyMissingError({
+				registryName: name,
+				key
+			});
+			return value;
+		});
+		const has = (key) => SubscriptionRef.get(ref).pipe(Effect.map((current) => current.some(([k]) => k === key)));
+		const entries = () => SubscriptionRef.get(ref);
+		return Service.of({
+			set,
+			get,
+			find,
+			has,
+			entries,
+			changes: SubscriptionRef.changes(ref)
+		});
+	}));
+	const changes = (svc) => svc.changes;
+	return {
+		Service,
+		layer,
+		changes
+	};
+};
+//#endregion
+export { defineScopedRefMap };
+
+//# sourceMappingURL=service.mjs.map

package/dist/substrate/runtime/scoped-ref-map/service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.mjs","names":[],"sources":["../../../../src/substrate/runtime/scoped-ref-map/service.ts"],"sourcesContent":["// Generic scoped Ref-Map registry primitive.\n//\n// Architecture (ARCHITECTURE.md § Substrate primitives roster /\n// § Substrate name-blindness): a name-blind, per-stack-scoped\n// in-memory `K -> V` lookup table. Substrate exposes ONLY the\n// generic primitive; L2 plugins (Sui-coin, Move-package, future\n// chain plugins) instantiate it with their domain-specific\n// `K` and `V` shapes to author their own typed Context.Service.\n//\n// Why the factory `defineScopedRefMap<K, V>(name)` shape rather\n// than a single `ScopedRefMapService` tag:\n//\n//   - One service per plugin domain — `PackageRegistry`,\n//     `CoinRegistry`, etc. — gives each plugin its own typed\n//     tag instead of every consumer reaching into a single map\n//     and narrowing.\n//   - Substrate stays name-blind: it doesn't know `coin` or\n//     `package`; it only knows \"give me a Layer + Service for\n//     `<K, V>`\". The plugin chooses the name.\n//   - The substrate Service-class identity is the namespace —\n//     two `defineScopedRefMap('Foo')` and `defineScopedRefMap('Bar')`\n//     calls return distinct services that can coexist in the\n//     same scope.\n//\n// Lifetime: each instantiated service is materialized by a\n// Layer that lives for the stack scope. When the scope closes,\n// the in-memory `SubscriptionRef` drops with it — the ref is\n// closure-private to the Layer's build effect, so the GC\n// reclaims it once no subscribers hold the stream.\n\nimport { Context, Effect, Layer, Schema, Stream, SubscriptionRef } from 'effect';\n\n/** Lookup failure for a missing key. Schema-tagged so consumers\n *  may `Effect.catchTag('ScopedRefMapKeyMissingError', ...)` and\n *  the cascade-formatter can render it without importing the class. */\nexport class ScopedRefMapKeyMissingError extends Schema.TaggedErrorClass<ScopedRefMapKeyMissingError>()(\n\t'ScopedRefMapKeyMissingError',\n\t{\n\t\tregistryName: Schema.String,\n\t\tkey: Schema.String,\n\t},\n) {}\n\n/** Operations on a scoped `K -> V` ref-map. Generic over `K`\n *  (constrained to `string`-shaped brands so it can be used as\n *  a Map key) and `V` (fully opaque to substrate). */\nexport interface ScopedRefMap<K extends string, V> {\n\t/** Insert / overwrite. Last-write-wins on `K`. */\n\treadonly set: (key: K, value: V) => Effect.Effect<void>;\n\t/** Strict lookup. Fails with `ScopedRefMapKeyMissingError`\n\t *  when the key isn't present. */\n\treadonly get: (key: K) => Effect.Effect<V, ScopedRefMapKeyMissingError>;\n\t/** Non-failing lookup — `null` when absent. */\n\treadonly find: (key: K) => Effect.Effect<V | null>;\n\t/** Presence check without an error projection. */\n\treadonly has: (key: K) => Effect.Effect<boolean>;\n\t/** Snapshot of all `(key, value)` pairs. Iteration order is\n\t *  insertion order. */\n\treadonly entries: () => Effect.Effect<ReadonlyArray<readonly [K, V]>>;\n\t/** Stream of full-snapshot states. Each emission is the\n\t *  current `entries` array; consumers diff if they need\n\t *  incremental updates. */\n\treadonly changes: Stream.Stream<ReadonlyArray<readonly [K, V]>>;\n}\n\n/**\n * Factory: declare a typed `K -> V` scoped ref-map service.\n *\n * The `name` becomes both the human-readable registry name (used\n * in `ScopedRefMapKeyMissingError.registryName`) and the\n * Context.Service identifier (prefixed with the substrate\n * namespace). Each call returns a fresh Service class; calling\n * twice with the same name produces two distinct services\n * (Context.Service identity is per-class, not per-id-string —\n * the id string is a debugging aid).\n *\n * Return shape — typed via inference so the inner Service class's\n * identity flows through to callers:\n *   - `Service` — the `Context.Service` tag class. Plugin authors\n *     yield this from their `acquire` body via `yield* MyRegistry.Service`.\n *   - `layer` — scope-bound Layer constructing one ref-map per\n *     stack scope.\n *   - `changes` — stream helper mirroring `routesStream(router)`.\n *\n * Example (in an L2 plugin):\n *\n * ```ts\n * const PackageRegistry = defineScopedRefMap<PackageKey, PackageRecord>('PackageRegistry');\n *\n * // In the plugin's acquire body:\n * const registry = yield* PackageRegistry.Service;\n * yield* registry.set(name, resolved);\n *\n * // In the boot Layer:\n * Layer.mergeAll(PackageRegistry.layer, ...)\n * ```\n */\nexport const defineScopedRefMap = <K extends string, V>(name: string) => {\n\tconst serviceId = `@devstack-rewrite/substrate/ScopedRefMap/${name}`;\n\n\tclass Service extends Context.Service<Service, ScopedRefMap<K, V>>()(serviceId) {}\n\n\tconst layer: Layer.Layer<Service> = Layer.effect(\n\t\tService,\n\t\tEffect.gen(function* () {\n\t\t\tconst ref = yield* SubscriptionRef.make<ReadonlyArray<readonly [K, V]>>([]);\n\n\t\t\tconst set: ScopedRefMap<K, V>['set'] = (key, value) =>\n\t\t\t\tSubscriptionRef.update(ref, (current) => {\n\t\t\t\t\tconst filtered = current.filter(([k]) => k !== key);\n\t\t\t\t\treturn [...filtered, [key, value] as const];\n\t\t\t\t});\n\n\t\t\tconst find: ScopedRefMap<K, V>['find'] = (key) =>\n\t\t\t\tSubscriptionRef.get(ref).pipe(\n\t\t\t\t\tEffect.map((current) => {\n\t\t\t\t\t\tconst hit = current.find(([k]) => k === key);\n\t\t\t\t\t\treturn hit ? hit[1] : null;\n\t\t\t\t\t}),\n\t\t\t\t);\n\n\t\t\tconst get: ScopedRefMap<K, V>['get'] = (key) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst value = yield* find(key);\n\t\t\t\t\tif (value === null) {\n\t\t\t\t\t\treturn yield* new ScopedRefMapKeyMissingError({\n\t\t\t\t\t\t\tregistryName: name,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t});\n\n\t\t\tconst has: ScopedRefMap<K, V>['has'] = (key) =>\n\t\t\t\tSubscriptionRef.get(ref).pipe(Effect.map((current) => current.some(([k]) => k === key)));\n\n\t\t\tconst entries: ScopedRefMap<K, V>['entries'] = () => SubscriptionRef.get(ref);\n\n\t\t\treturn Service.of({\n\t\t\t\tset,\n\t\t\t\tget,\n\t\t\t\tfind,\n\t\t\t\thas,\n\t\t\t\tentries,\n\t\t\t\tchanges: SubscriptionRef.changes(ref),\n\t\t\t});\n\t\t}),\n\t);\n\n\tconst changes = (svc: ScopedRefMap<K, V>): Stream.Stream<ReadonlyArray<readonly [K, V]>> =>\n\t\tsvc.changes;\n\n\treturn {\n\t\tService,\n\t\tlayer,\n\t\tchanges,\n\t} as const;\n};\n"],"mappings":";;;;;AAmCA,IAAa,8BAAb,cAAiD,OAAO,kBAA+C,CACtG,+BACA;CACC,cAAc,OAAO;CACrB,KAAK,OAAO;CACZ,CACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDF,MAAa,sBAA2C,SAAiB;CACxE,MAAM,YAAY,4CAA4C;CAE9D,MAAM,gBAAgB,QAAQ,SAAsC,CAAC,UAAU,CAAC;CAEhF,MAAM,QAA8B,MAAM,OACzC,SACA,OAAO,IAAI,aAAa;EACvB,MAAM,MAAM,OAAO,gBAAgB,KAAqC,EAAE,CAAC;EAE3E,MAAM,OAAkC,KAAK,UAC5C,gBAAgB,OAAO,MAAM,YAAY;AAExC,UAAO,CAAC,GADS,QAAQ,QAAQ,CAAC,OAAO,MAAM,IAC5B,EAAE,CAAC,KAAK,MAAM,CAAU;IAC1C;EAEH,MAAM,QAAoC,QACzC,gBAAgB,IAAI,IAAI,CAAC,KACxB,OAAO,KAAK,YAAY;GACvB,MAAM,MAAM,QAAQ,MAAM,CAAC,OAAO,MAAM,IAAI;AAC5C,UAAO,MAAM,IAAI,KAAK;IACrB,CACF;EAEF,MAAM,OAAkC,QACvC,OAAO,IAAI,aAAa;GACvB,MAAM,QAAQ,OAAO,KAAK,IAAI;AAC9B,OAAI,UAAU,KACb,QAAO,OAAO,IAAI,4BAA4B;IAC7C,cAAc;IACd;IACA,CAAC;AAEH,UAAO;IACN;EAEH,MAAM,OAAkC,QACvC,gBAAgB,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,YAAY,QAAQ,MAAM,CAAC,OAAO,MAAM,IAAI,CAAC,CAAC;EAEzF,MAAM,gBAA+C,gBAAgB,IAAI,IAAI;AAE7E,SAAO,QAAQ,GAAG;GACjB;GACA;GACA;GACA;GACA;GACA,SAAS,gBAAgB,QAAQ,IAAI;GACrC,CAAC;GACD,CACF;CAED,MAAM,WAAW,QAChB,IAAI;AAEL,QAAO;EACN;EACA;EACA;EACA"}

package/dist/substrate/runtime/stage-and-swap/index.d.mts

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

package/dist/substrate/runtime/stage-and-swap/index.mjs

@@ -0,0 +1,131 @@
+import { SpanAttr } from "../observability/spans.mjs";
+import { acquireStackLock } from "../cross-process/stack-lock.mjs";
+import { Effect, FileSystem, Schema } from "effect";
+import { dirname, isAbsolute, join, normalize, sep } from "node:path";
+//#region src/substrate/runtime/stage-and-swap/index.ts
+/** Tagged failure during a stage-and-swap step. `stage` discriminates
+*  the precise failing step; the caller's underlying tag is preserved
+*  via `cause` (the primitive does NOT wrap the user's error). */
+var StageAndSwapError = class extends Schema.TaggedErrorClass()("StageAndSwapError", {
+	stage: Schema.Literals([
+		"mkdir-staging",
+		"mkdir-backup",
+		"build",
+		"acquire-publish-lock",
+		"backup-current",
+		"preserve-target-paths",
+		"rename-into-target",
+		"restore-backup",
+		"cleanup-staging",
+		"cross-filesystem-fallback"
+	]),
+	targetPath: Schema.String,
+	stagingPath: Schema.String,
+	cause: Schema.optional(Schema.Defect)
+}) {};
+const failStage = (stage, targetPath, stagingPath) => (cause) => Effect.fail(new StageAndSwapError({
+	stage,
+	targetPath,
+	stagingPath,
+	cause
+}));
+const normalizePreservedRelativePath = (relativePath) => {
+	const normalized = normalize(relativePath);
+	if (relativePath.length === 0 || isAbsolute(relativePath) || normalized === "." || normalized === ".." || normalized.startsWith(`..${sep}`)) return null;
+	return normalized;
+};
+const preserveTargetPaths = (args) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	for (const preserved of args.preservedPaths) {
+		const relativePath = normalizePreservedRelativePath(preserved.relativePath);
+		if (relativePath === null) return yield* failStage("preserve-target-paths", args.targetPath, args.stagingPath)(/* @__PURE__ */ new Error(`unsafe preserved path: ${preserved.relativePath}`));
+		const source = join(args.backupPath, relativePath);
+		if (!(yield* fs.exists(source).pipe(Effect.catch(() => Effect.succeed(false))))) continue;
+		const target = join(args.stagingPath, relativePath);
+		yield* fs.makeDirectory(dirname(target), { recursive: true }).pipe(Effect.catch(failStage("preserve-target-paths", args.targetPath, args.stagingPath)));
+		yield* fs.copy(source, target, { overwrite: true }).pipe(Effect.catch(failStage("preserve-target-paths", args.targetPath, args.stagingPath)));
+	}
+});
+/**
+* Build-then-swap. `build` is a user effect that populates `stagingPath`;
+* on success the helper:
+*
+*   - backs up the current `targetPath` (if any) to `<targetPath>.bak.<pid>`,
+*   - copies any selected `preserveFromTarget` paths from that backup
+*     into staging,
+*   - renames `stagingPath` → `targetPath`,
+*   - removes the backup.
+*
+* On any failure the helper removes `stagingPath` and, if the backup
+* was taken, renames it back to `targetPath` so the world looks
+* exactly as it did at entry.
+*
+* The build effect's error type passes through unchanged — the
+* primitive returns `E | StageAndSwapError`. This is the
+* "preserve the caller's error tag" rule from distilled §17.
+*
+* IMPORTANT: stagingPath MUST be on the same filesystem as
+* targetPath. The helper picks it as a sibling under the same parent
+* (caller passes `parentDir`, we mint the names) — this is enforced
+* by the helper's signature shape.
+*/
+const stageAndSwap = (args) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const { targetPath, stagingPath, backupPath, build, preserveFromTarget = [], publishLockPath } = args;
+	yield* Effect.annotateCurrentSpan({
+		"devstack.stage-and-swap.target": targetPath,
+		"devstack.stage-and-swap.staging": stagingPath
+	});
+	yield* fs.remove(stagingPath, {
+		recursive: true,
+		force: true
+	}).pipe(Effect.ignore);
+	yield* fs.makeDirectory(stagingPath, { recursive: true }).pipe(Effect.catch(failStage("mkdir-staging", targetPath, stagingPath)));
+	const result = yield* build.pipe(Effect.onError(() => fs.remove(stagingPath, {
+		recursive: true,
+		force: true
+	}).pipe(Effect.ignore)));
+	if (yield* Effect.scoped(Effect.gen(function* () {
+		if (publishLockPath !== void 0) yield* acquireStackLock(publishLockPath).pipe(Effect.catch(failStage("acquire-publish-lock", targetPath, stagingPath)));
+		const targetExists = yield* fs.exists(targetPath).pipe(Effect.catch(() => Effect.succeed(false)));
+		if (targetExists) {
+			yield* fs.rename(targetPath, backupPath).pipe(Effect.catch(failStage("backup-current", targetPath, stagingPath)));
+			yield* preserveTargetPaths({
+				backupPath,
+				targetPath,
+				stagingPath,
+				preservedPaths: preserveFromTarget
+			}).pipe(Effect.catch((error) => Effect.gen(function* () {
+				yield* fs.rename(backupPath, targetPath).pipe(Effect.catch(failStage("restore-backup", targetPath, stagingPath)));
+				return yield* Effect.fail(error);
+			})));
+		}
+		yield* fs.rename(stagingPath, targetPath).pipe(Effect.catch((cause) => {
+			if (cause.code === "EXDEV") return Effect.gen(function* () {
+				yield* Effect.logWarning("stage-and-swap cross-filesystem fallback").pipe(Effect.annotateLogs({
+					[SpanAttr.stageAndSwapTargetPath]: targetPath,
+					[SpanAttr.stageAndSwapStagingPath]: stagingPath,
+					[SpanAttr.errorCode]: "EXDEV"
+				}));
+				yield* fs.copy(stagingPath, targetPath, { overwrite: false }).pipe(Effect.catch(failStage("cross-filesystem-fallback", targetPath, stagingPath)));
+				yield* fs.remove(stagingPath, {
+					recursive: true,
+					force: true
+				}).pipe(Effect.ignore);
+			});
+			return Effect.gen(function* () {
+				if (targetExists) yield* fs.rename(backupPath, targetPath).pipe(Effect.catch(failStage("restore-backup", targetPath, stagingPath)));
+				return yield* failStage("rename-into-target", targetPath, stagingPath)(cause);
+			});
+		}));
+		return targetExists;
+	}))) yield* fs.remove(backupPath, {
+		recursive: true,
+		force: true
+	}).pipe(Effect.ignore);
+	return result;
+}).pipe(Effect.withSpan("substrate.stage-and-swap"));
+//#endregion
+export { stageAndSwap };
+
+//# sourceMappingURL=index.mjs.map