@mysten-incubation/devstack 0.0.0

package/dist/substrate/runtime/artifact-publisher/index.mjs

@@ -0,0 +1,76 @@
+import { parseJsonTextSync } from "../runtime-decode.mjs";
+import { CacheService } from "../cache/service.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/substrate/runtime/artifact-publisher/index.ts
+/**
+* Substrate-level service projecting the
+* `ArtifactPublisher` primitive. Plugins yield this tag in
+* their acquire body; the supervisor's `pluginContext` carries it.
+*
+* The service is constructed once per stack (Layer-driven) and
+* closes over the per-stack Cache + StrategyRegistry. Parallel
+* stacks isolate by construction — each stack's Layer build is
+* independent.
+*/
+var ArtifactPublisherService = class extends Context.Service()("@devstack-rewrite/substrate/ArtifactPublisher") {};
+const encode = (value) => new TextEncoder().encode(JSON.stringify(value));
+const decode = (bytes) => {
+	try {
+		return parseJsonTextSync(new TextDecoder().decode(bytes), {
+			source: "artifact-publisher cache payload",
+			mkError: (issue) => issue
+		});
+	} catch {
+		return null;
+	}
+};
+const makePublisher = (cache) => ({ publish: (spec) => Effect.gen(function* () {
+	yield* Effect.annotateCurrentSpan({
+		"artifactPublisher.namespace": spec.namespace,
+		"artifactPublisher.chain": spec.chain,
+		"artifactPublisher.contentHash": spec.contentHash
+	});
+	const hit = yield* cache.lookup({
+		namespace: spec.namespace,
+		chain: spec.chain,
+		contentHash: spec.contentHash
+	}).pipe(Effect.catch(() => Effect.succeed(null)));
+	if (hit !== null) {
+		const cached = decode(hit.bytes);
+		if (cached !== null) {
+			if ((yield* spec.verify(cached)) !== null) {
+				const payload = cached;
+				yield* spec.register(payload);
+				yield* Effect.annotateCurrentSpan({ "artifactPublisher.path": "hit" });
+				return payload;
+			}
+		}
+	}
+	yield* Effect.annotateCurrentSpan({ "artifactPublisher.path": hit === null ? "miss" : "verify-failed" });
+	const produced = yield* spec.produce;
+	yield* cache.write({
+		namespace: spec.namespace,
+		chain: spec.chain,
+		contentHash: spec.contentHash
+	}, encode(produced)).pipe(Effect.catch(() => Effect.void));
+	yield* spec.register(produced);
+	return produced;
+}).pipe(Effect.withSpan("substrate.artifactPublisher.publish")) });
+/**
+* Layer that materializes the publisher from the substrate's
+* Cache service. Plugins yield `ArtifactPublisherService`;
+* the supervisor provides it via `pluginContext`.
+*
+* The publisher is service-name-blind: it reaches `CacheService`
+* via the Context, NOT through a hard-coded import edge with any
+* plugin. Chain-probe lookup is the caller's concern — the spec's
+* `verify` Effect closes over the probe.
+*/
+const layerArtifactPublisher = Layer.effect(ArtifactPublisherService, Effect.gen(function* () {
+	const cache = yield* CacheService;
+	return ArtifactPublisherService.of(makePublisher(cache));
+}));
+//#endregion
+export { ArtifactPublisherService, layerArtifactPublisher };
+
+//# sourceMappingURL=index.mjs.map

package/dist/substrate/runtime/artifact-publisher/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/substrate/runtime/artifact-publisher/index.ts"],"sourcesContent":["// ArtifactPublisher — substrate-level service.\n//\n// Architecture §10: substrate primitive that orchestrates the\n// `cache → verify → produce → register` cycle every on-chain\n// produce/verify plugin (package, coin, walrus deploy, seal deploy,\n// deepbook deploy, etc.) flows through.\n//\n// Plugins call `publisher.publish(spec)` with their per-cycle\n// `ArtifactSpec<Produced, Verified>` (namespace, chain,\n// contentHash, verifySchema, verify, produce, register). The\n// substrate handles:\n//\n//   1. `cache.lookup({namespace, chain, contentHash})`. Hit AND\n//      `spec.verify` returns a non-null value → `register`(decoded\n//      cached payload) and return.\n//   2. Miss OR verify-returned-null → run `spec.produce` under the\n//      caller's Scope; on success, write the produced payload to\n//      the cache (best-effort, errors logged but not propagated);\n//      then `register(produced)`.\n//\n// The substrate carries the cache + chain-probe seams via Layers\n// (CacheService, StrategyRegistryService). Plugins yield this\n// service from their acquire body; the supervisor injects it via\n// pluginContext.\n//\n// Cache payload codec: we serialize `Produced` as JSON. The artifact publisher\n// spec doesn't bake a codec in (`Produced` is generic); JSON\n// round-trip matches existing plugin call sites\n// (`CachedPackageEntry`, `CachedMint`, etc. are JSON-shaped).\n\nimport { Context, Effect, Layer, Scope } from 'effect';\n\nimport type {\n\tArtifactPublishError,\n\tArtifactPublisher,\n\tArtifactSpec,\n} from '../../../primitives/artifact-publisher.ts';\nimport { CacheService } from '../cache/index.ts';\nimport { parseJsonTextSync } from '../runtime-decode.ts';\n\n// Re-export the ChainOperation typed seam — plugin authors compose\n// produce bodies via `compileChainOperation({...})` rather than\n// hand-rolling the `Effect<Produced, ArtifactPublishError, Scope>`.\n//\n// `ResolvedSigner` is intentionally NOT re-exported here — it is\n// owned by `sui-execute/` and reached via that module's barrel; both\n// modules share the single canonical shape.\nexport {\n\tcompileChainOperation,\n\ttype ChainOperation,\n\ttype OneShotRunner,\n\ttype OneShotSpec,\n\ttype SuiEffects,\n\ttype SuiTxBuilder,\n} from './chain-operation.ts';\n\n// ---------------------------------------------------------------------------\n// Service tag\n// ---------------------------------------------------------------------------\n\n/**\n * Substrate-level service projecting the\n * `ArtifactPublisher` primitive. Plugins yield this tag in\n * their acquire body; the supervisor's `pluginContext` carries it.\n *\n * The service is constructed once per stack (Layer-driven) and\n * closes over the per-stack Cache + StrategyRegistry. Parallel\n * stacks isolate by construction — each stack's Layer build is\n * independent.\n */\nexport class ArtifactPublisherService extends Context.Service<\n\tArtifactPublisherService,\n\tArtifactPublisher\n>()('@devstack-rewrite/substrate/ArtifactPublisher') {}\n\n// ---------------------------------------------------------------------------\n// Encode / decode the cached payload\n// ---------------------------------------------------------------------------\n\nconst encode = (value: unknown): Uint8Array => new TextEncoder().encode(JSON.stringify(value));\n\nconst decode = <Produced>(bytes: Uint8Array): Produced | null => {\n\ttry {\n\t\treturn parseJsonTextSync(new TextDecoder().decode(bytes), {\n\t\t\tsource: 'artifact-publisher cache payload',\n\t\t\tmkError: (issue) => issue,\n\t\t}) as Produced;\n\t} catch {\n\t\treturn null;\n\t}\n};\n\n// ---------------------------------------------------------------------------\n// Publish: cache → verify → produce → register\n// ---------------------------------------------------------------------------\n\nconst makePublisher = (cache: typeof CacheService.Service): ArtifactPublisher => ({\n\tpublish: <Produced, Verified>(\n\t\tspec: ArtifactSpec<Produced, Verified>,\n\t): Effect.Effect<Produced | Verified, ArtifactPublishError, Scope.Scope> =>\n\t\tEffect.gen(function* () {\n\t\t\tyield* Effect.annotateCurrentSpan({\n\t\t\t\t'artifactPublisher.namespace': spec.namespace,\n\t\t\t\t'artifactPublisher.chain': spec.chain,\n\t\t\t\t'artifactPublisher.contentHash': spec.contentHash,\n\t\t\t});\n\n\t\t\t// 1. Cache lookup. Best-effort: a CacheError on lookup\n\t\t\t//    surfaces as `cache-corrupt`; the substrate's contract\n\t\t\t//    is \"re-produce is always safe\", so we coerce read\n\t\t\t//    failures to a miss rather than abort the cycle.\n\t\t\tconst hit = yield* cache\n\t\t\t\t.lookup({\n\t\t\t\t\tnamespace: spec.namespace,\n\t\t\t\t\tchain: spec.chain,\n\t\t\t\t\tcontentHash: spec.contentHash,\n\t\t\t\t})\n\t\t\t\t.pipe(Effect.catch(() => Effect.succeed(null)));\n\n\t\t\tif (hit !== null) {\n\t\t\t\t// Decode the cached `Produced` BEFORE verify so the\n\t\t\t\t// plugin's verify Effect can key its on-chain probe\n\t\t\t\t// off a field of the cached payload (e.g. action's\n\t\t\t\t// `digest`, package's `packageId`). A decode failure\n\t\t\t\t// here is \"cache corruption\" — drop through to\n\t\t\t\t// re-produce so the cycle is still safe.\n\t\t\t\tconst cached = decode<Produced>(hit.bytes);\n\t\t\t\tif (cached !== null) {\n\t\t\t\t\t// 2. Verify (lenient — returns null on transient\n\t\t\t\t\t//    failure or not-found). Architecture §10:\n\t\t\t\t\t//    verify-on-hit covers chain-state drift.\n\t\t\t\t\tconst verified = yield* spec.verify(cached);\n\t\t\t\t\tif (verified !== null) {\n\t\t\t\t\t\tconst payload: Produced | Verified = cached;\n\t\t\t\t\t\tyield* spec.register(payload);\n\t\t\t\t\t\tyield* Effect.annotateCurrentSpan({ 'artifactPublisher.path': 'hit' });\n\t\t\t\t\t\treturn payload;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// 3. Miss or verify-failed → produce.\n\t\t\tyield* Effect.annotateCurrentSpan({\n\t\t\t\t'artifactPublisher.path': hit === null ? 'miss' : 'verify-failed',\n\t\t\t});\n\t\t\tconst produced = yield* spec.produce;\n\n\t\t\t// 4. Cache write — best-effort. Architecture: a write\n\t\t\t//    failure must NOT roll back the on-chain effect.\n\t\t\tyield* cache\n\t\t\t\t.write(\n\t\t\t\t\t{\n\t\t\t\t\t\tnamespace: spec.namespace,\n\t\t\t\t\t\tchain: spec.chain,\n\t\t\t\t\t\tcontentHash: spec.contentHash,\n\t\t\t\t\t},\n\t\t\t\t\tencode(produced),\n\t\t\t\t)\n\t\t\t\t.pipe(Effect.catch(() => Effect.void));\n\n\t\t\t// 5. Register — fires on EVERY cycle (architecture §10).\n\t\t\tyield* spec.register(produced);\n\t\t\treturn produced;\n\t\t}).pipe(Effect.withSpan('substrate.artifactPublisher.publish')),\n});\n\n// ---------------------------------------------------------------------------\n// Layer\n// ---------------------------------------------------------------------------\n\n/**\n * Layer that materializes the publisher from the substrate's\n * Cache service. Plugins yield `ArtifactPublisherService`;\n * the supervisor provides it via `pluginContext`.\n *\n * The publisher is service-name-blind: it reaches `CacheService`\n * via the Context, NOT through a hard-coded import edge with any\n * plugin. Chain-probe lookup is the caller's concern — the spec's\n * `verify` Effect closes over the probe.\n */\nexport const layerArtifactPublisher: Layer.Layer<ArtifactPublisherService, never, CacheService> =\n\tLayer.effect(\n\t\tArtifactPublisherService,\n\t\tEffect.gen(function* () {\n\t\t\tconst cache = yield* CacheService;\n\t\t\treturn ArtifactPublisherService.of(makePublisher(cache));\n\t\t}),\n\t);\n"],"mappings":";;;;;;;;;;;;;;AAsEA,IAAa,2BAAb,cAA8C,QAAQ,SAGnD,CAAC,gDAAgD,CAAC;AAMrD,MAAM,UAAU,UAA+B,IAAI,aAAa,CAAC,OAAO,KAAK,UAAU,MAAM,CAAC;AAE9F,MAAM,UAAoB,UAAuC;AAChE,KAAI;AACH,SAAO,kBAAkB,IAAI,aAAa,CAAC,OAAO,MAAM,EAAE;GACzD,QAAQ;GACR,UAAU,UAAU;GACpB,CAAC;SACK;AACP,SAAO;;;AAQT,MAAM,iBAAiB,WAA2D,EACjF,UACC,SAEA,OAAO,IAAI,aAAa;AACvB,QAAO,OAAO,oBAAoB;EACjC,+BAA+B,KAAK;EACpC,2BAA2B,KAAK;EAChC,iCAAiC,KAAK;EACtC,CAAC;CAMF,MAAM,MAAM,OAAO,MACjB,OAAO;EACP,WAAW,KAAK;EAChB,OAAO,KAAK;EACZ,aAAa,KAAK;EAClB,CAAC,CACD,KAAK,OAAO,YAAY,OAAO,QAAQ,KAAK,CAAC,CAAC;AAEhD,KAAI,QAAQ,MAAM;EAOjB,MAAM,SAAS,OAAiB,IAAI,MAAM;AAC1C,MAAI,WAAW;QAKV,OADoB,KAAK,OAAO,OAAO,MAC1B,MAAM;IACtB,MAAM,UAA+B;AACrC,WAAO,KAAK,SAAS,QAAQ;AAC7B,WAAO,OAAO,oBAAoB,EAAE,0BAA0B,OAAO,CAAC;AACtE,WAAO;;;;AAMV,QAAO,OAAO,oBAAoB,EACjC,0BAA0B,QAAQ,OAAO,SAAS,iBAClD,CAAC;CACF,MAAM,WAAW,OAAO,KAAK;AAI7B,QAAO,MACL,MACA;EACC,WAAW,KAAK;EAChB,OAAO,KAAK;EACZ,aAAa,KAAK;EAClB,EACD,OAAO,SAAS,CAChB,CACA,KAAK,OAAO,YAAY,OAAO,KAAK,CAAC;AAGvC,QAAO,KAAK,SAAS,SAAS;AAC9B,QAAO;EACN,CAAC,KAAK,OAAO,SAAS,sCAAsC,CAAC,EAChE;;;;;;;;;;;AAgBD,MAAa,yBACZ,MAAM,OACL,0BACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO;AACrB,QAAO,yBAAyB,GAAG,cAAc,MAAM,CAAC;EACvD,CACF"}

package/dist/substrate/runtime/atomic-write.mjs

@@ -0,0 +1,106 @@
+import { AtomicWriteFailed } from "./errors.mjs";
+import { Effect, FileSystem, Schema } from "effect";
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, mkdirSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+//#region src/substrate/runtime/atomic-write.ts
+/** 8-hex tempfile suffix. `crypto.randomUUID()` is collision-safe under
+*  parallel callers within the same pid — replaces the
+*  `Math.random()`-based suffix flagged in STYLE_GUIDE §17. */
+const tempSuffix = () => randomUUID().replace(/-/g, "").slice(0, 8);
+const failStage = (path, stage) => (cause) => Effect.fail(new AtomicWriteFailed({
+	path,
+	stage,
+	cause
+}));
+/**
+* Atomically write `bytes` to `path`. The helper ensures
+* `dirname(path)` exists (recursive mkdir, idempotent).
+*
+* `mode` is the final file mode bits (default 0o600 — secret-safe
+* default; cache callers may bump to 0o644 if they want world-read).
+*/
+const atomicWriteFile = (path, bytes, options = {}) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const mode = options.mode ?? 384;
+	const parentMode = options.parentMode ?? 448;
+	const tmp = `${path}.tmp.${process.pid}.${tempSuffix()}`;
+	yield* fs.makeDirectory(dirname(path), {
+		recursive: true,
+		mode: parentMode
+	}).pipe(Effect.catch(failStage(path, "mkdir-parent")));
+	yield* Effect.scoped(Effect.gen(function* () {
+		const file = yield* fs.open(tmp, {
+			flag: "wx",
+			mode
+		}).pipe(Effect.catch(failStage(path, "open-temp")));
+		yield* file.writeAll(bytes).pipe(Effect.catch(failStage(path, "write")));
+		yield* file.sync.pipe(Effect.catch(failStage(path, "fsync")));
+	}));
+	yield* fs.rename(tmp, path).pipe(Effect.catch((cause) => fs.remove(tmp, { force: true }).pipe(Effect.ignore, Effect.andThen(failStage(path, "rename")(cause)))));
+}).pipe(Effect.withSpan("substrate.atomicWriteFile", { attributes: { path } }));
+/**
+* Atomically write a JSON value. Encodes via Schema (so the on-disk
+* shape is the schema's `Encoded` form, not the rich `Type`). Caller
+* supplies a schema whose `Type` matches `value`.
+*/
+const atomicWriteJson = (path, schema, value, options) => Effect.gen(function* () {
+	const encoded = yield* Schema.encodeUnknownEffect(schema)(value).pipe(Effect.catch(failStage(path, "encode")));
+	const json = JSON.stringify(encoded, null, 2);
+	yield* atomicWriteFile(path, new TextEncoder().encode(json), options);
+});
+/**
+* Synchronous atomic write. Same disk-side contract as
+* `atomicWriteFile` (mkdir-parent → O_EXCL temp → write → fsync →
+* rename). Returns `void` on success; throws on any failure with
+* `cause` set to the underlying `NodeJS.ErrnoException`.
+*
+* Used inside `Effect.try` by the cross-process modules; the caller
+* maps the thrown error to a typed plugin/runtime error
+* (`RosterIoError` / `SnapshotReservationIoError` / etc.).
+*/
+const atomicWriteFileSync = (path, bytes, options = {}) => {
+	const mode = options.mode ?? 384;
+	const parentMode = options.parentMode ?? 448;
+	const tmp = `${path}.tmp.${process.pid}.${tempSuffix()}`;
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: parentMode
+	});
+	writeFileSync(tmp, bytes, {
+		flag: "wx",
+		mode
+	});
+	let fd = null;
+	try {
+		fd = openSync(tmp, "r");
+		fsyncSync(fd);
+	} finally {
+		if (fd !== null) closeSync(fd);
+	}
+	try {
+		renameSync(tmp, path);
+	} catch (cause) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw cause;
+	}
+};
+/**
+* Synchronous atomic JSON write. Stringifies `value` and routes
+* through `atomicWriteFileSync`. No Schema encoding here — the
+* cross-process modules round-trip plain JSON (their schemas are
+* Schema.Struct of primitives; `JSON.stringify` is sufficient and
+* keeps the sync path dependency-free of Effect's Schema effects).
+*/
+const atomicWriteJsonSync = (path, value, options) => {
+	atomicWriteFileSync(path, JSON.stringify(value), options);
+};
+const dirname = (p) => {
+	const i = p.lastIndexOf("/");
+	return i <= 0 ? "/" : p.slice(0, i);
+};
+//#endregion
+export { atomicWriteFile, atomicWriteJson, atomicWriteJsonSync };
+
+//# sourceMappingURL=atomic-write.mjs.map

package/dist/substrate/runtime/atomic-write.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.mjs","names":[],"sources":["../../../src/substrate/runtime/atomic-write.ts"],"sourcesContent":["// Atomic write primitive — ONE canonical implementation.\n//\n// Architecture § \"What's collapsed\" — three tempfile+rename impls\n// (atomic-write, state-store, global registry) collapse to one. This\n// is that one.\n//\n// Contract:\n//   1. Ensure parent directory exists.\n//   2. Open `<final>.tmp.<pid>.<rand>` with `wx` (O_EXCL) — refuse\n//      to clobber a half-written sibling from a crashed earlier\n//      writer in the same pid.\n//   3. Write bytes.\n//   4. `fsync` the file.\n//   5. Rename tempfile → final. Rename on POSIX is atomic w.r.t.\n//      `open` of the final path.\n//   6. On any failure mid-flight, unlink the tempfile. Best-effort:\n//      a tempfile-cleanup failure does NOT mask the original error.\n//\n// Two surfaces:\n//   - `atomicWriteFile` / `atomicWriteJson` — Effect/FileSystem-based,\n//     used by every async write site (manifest, state-store, cache).\n//   - `atomicWriteFileSync` / `atomicWriteJsonSync` — node:fs-sync,\n//     used by the cross-process modules (roster, snapshot-reservation,\n//     stack-lock) that hold `stack.lock` and must keep their critical\n//     section non-yielding. Substrate-fix-plan #11 tracks unifying\n//     these onto Effect FS once we lift the cross-process modules off\n//     `node:fs`; until then both surfaces share THIS file (and only\n//     this file) so the tempfile dance has ONE owner.\n//\n// What we do NOT do here:\n//   - fsync the parent directory. Linux's man fsync(2) suggests it\n//     for full durability after rename(); the Effect platform layer\n//     does not expose dir-fsync. Documented limitation — recoverable\n//     on crash because the state-store rewrites on every change and\n//     cache misses re-produce.\n\nimport {\n\tcloseSync,\n\tfsyncSync,\n\tmkdirSync,\n\topenSync,\n\trenameSync,\n\tunlinkSync,\n\twriteFileSync,\n} from 'node:fs';\nimport { randomUUID } from 'node:crypto';\n\nimport { Effect, FileSystem, Schema } from 'effect';\n\nimport { AtomicWriteFailed } from './errors.ts';\n\n/** 8-hex tempfile suffix. `crypto.randomUUID()` is collision-safe under\n *  parallel callers within the same pid — replaces the\n *  `Math.random()`-based suffix flagged in STYLE_GUIDE §17. */\nconst tempSuffix = (): string => randomUUID().replace(/-/g, '').slice(0, 8);\n\nconst failStage =\n\t(\n\t\tpath: string,\n\t\tstage: AtomicWriteFailed['stage'],\n\t): ((cause: unknown) => Effect.Effect<never, AtomicWriteFailed>) =>\n\t(cause) =>\n\t\tEffect.fail(new AtomicWriteFailed({ path, stage, cause }));\n\n/**\n * Atomically write `bytes` to `path`. The helper ensures\n * `dirname(path)` exists (recursive mkdir, idempotent).\n *\n * `mode` is the final file mode bits (default 0o600 — secret-safe\n * default; cache callers may bump to 0o644 if they want world-read).\n */\nexport const atomicWriteFile = (\n\tpath: string,\n\tbytes: Uint8Array,\n\toptions: { readonly mode?: number; readonly parentMode?: number } = {},\n): Effect.Effect<void, AtomicWriteFailed, FileSystem.FileSystem> =>\n\tEffect.gen(function* () {\n\t\tconst fs = yield* FileSystem.FileSystem;\n\t\tconst mode = options.mode ?? 0o600;\n\t\tconst parentMode = options.parentMode ?? 0o700;\n\t\tconst tmp = `${path}.tmp.${process.pid}.${tempSuffix()}`;\n\t\t// 1. Ensure parent. recursive: true is idempotent under\n\t\t//    concurrent callers — `mkdir -p` semantics.\n\t\tyield* fs\n\t\t\t.makeDirectory(dirname(path), { recursive: true, mode: parentMode })\n\t\t\t.pipe(Effect.catch(failStage(path, 'mkdir-parent')));\n\t\t// 2-4. Open tempfile with `wx` (O_EXCL), write, fsync, all\n\t\t//      inside a Scope so the file handle closes on any path.\n\t\tyield* Effect.scoped(\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst file = yield* fs\n\t\t\t\t\t.open(tmp, { flag: 'wx', mode })\n\t\t\t\t\t.pipe(Effect.catch(failStage(path, 'open-temp')));\n\t\t\t\tyield* file.writeAll(bytes).pipe(Effect.catch(failStage(path, 'write')));\n\t\t\t\t// fsync — durability boundary. Without this the\n\t\t\t\t// rename can land but bytes can stay in the page\n\t\t\t\t// cache through a power loss.\n\t\t\t\tyield* file.sync.pipe(Effect.catch(failStage(path, 'fsync')));\n\t\t\t}),\n\t\t);\n\t\t// 5. Atomic rename. On failure unlink the tempfile so we\n\t\t//    don't leak; unlink failure is ignored (the original\n\t\t//    rename failure is the one that matters).\n\t\tyield* fs\n\t\t\t.rename(tmp, path)\n\t\t\t.pipe(\n\t\t\t\tEffect.catch((cause) =>\n\t\t\t\t\tfs\n\t\t\t\t\t\t.remove(tmp, { force: true })\n\t\t\t\t\t\t.pipe(Effect.ignore, Effect.andThen(failStage(path, 'rename')(cause))),\n\t\t\t\t),\n\t\t\t);\n\t}).pipe(Effect.withSpan('substrate.atomicWriteFile', { attributes: { path } }));\n\n/**\n * Atomically write a JSON value. Encodes via Schema (so the on-disk\n * shape is the schema's `Encoded` form, not the rich `Type`). Caller\n * supplies a schema whose `Type` matches `value`.\n */\nexport const atomicWriteJson = <A, I>(\n\tpath: string,\n\tschema: Schema.Codec<A, I>,\n\tvalue: A,\n\toptions?: { readonly mode?: number; readonly parentMode?: number },\n): Effect.Effect<void, AtomicWriteFailed, FileSystem.FileSystem> =>\n\tEffect.gen(function* () {\n\t\tconst encoded = yield* Schema.encodeUnknownEffect(schema)(value).pipe(\n\t\t\tEffect.catch(failStage(path, 'encode')),\n\t\t);\n\t\tconst json = JSON.stringify(encoded, null, 2);\n\t\tconst bytes = new TextEncoder().encode(json);\n\t\tyield* atomicWriteFile(path, bytes, options);\n\t});\n\n// -----------------------------------------------------------------------------\n// Sync surface — for the cross-process modules that hold `stack.lock`\n// and must keep their critical section non-yielding. Same contract as\n// the Effect surface above.\n// -----------------------------------------------------------------------------\n\n/**\n * Synchronous atomic write. Same disk-side contract as\n * `atomicWriteFile` (mkdir-parent → O_EXCL temp → write → fsync →\n * rename). Returns `void` on success; throws on any failure with\n * `cause` set to the underlying `NodeJS.ErrnoException`.\n *\n * Used inside `Effect.try` by the cross-process modules; the caller\n * maps the thrown error to a typed plugin/runtime error\n * (`RosterIoError` / `SnapshotReservationIoError` / etc.).\n */\nexport const atomicWriteFileSync = (\n\tpath: string,\n\tbytes: Uint8Array | string,\n\toptions: { readonly mode?: number; readonly parentMode?: number } = {},\n): void => {\n\tconst mode = options.mode ?? 0o600;\n\tconst parentMode = options.parentMode ?? 0o700;\n\tconst tmp = `${path}.tmp.${process.pid}.${tempSuffix()}`;\n\tmkdirSync(dirname(path), { recursive: true, mode: parentMode });\n\t// O_EXCL via `flag: 'wx'`. writeFileSync handles open + write +\n\t// close in one call but does NOT fsync; do it manually so we\n\t// preserve the durability boundary the Effect surface has.\n\twriteFileSync(tmp, bytes, { flag: 'wx', mode });\n\t// fsync — open the file just to fsync the bytes through the page\n\t// cache. `writeFileSync` already closed the original fd.\n\tlet fd: number | null = null;\n\ttry {\n\t\tfd = openSync(tmp, 'r');\n\t\tfsyncSync(fd);\n\t} finally {\n\t\tif (fd !== null) closeSync(fd);\n\t}\n\ttry {\n\t\trenameSync(tmp, path);\n\t} catch (cause) {\n\t\t// Best-effort tempfile cleanup; the original rename failure is\n\t\t// the one we re-throw to the caller.\n\t\ttry {\n\t\t\tunlinkSync(tmp);\n\t\t} catch {\n\t\t\t// ignore\n\t\t}\n\t\tthrow cause;\n\t}\n};\n\n/**\n * Synchronous atomic JSON write. Stringifies `value` and routes\n * through `atomicWriteFileSync`. No Schema encoding here — the\n * cross-process modules round-trip plain JSON (their schemas are\n * Schema.Struct of primitives; `JSON.stringify` is sufficient and\n * keeps the sync path dependency-free of Effect's Schema effects).\n */\nexport const atomicWriteJsonSync = (\n\tpath: string,\n\tvalue: unknown,\n\toptions?: { readonly mode?: number; readonly parentMode?: number },\n): void => {\n\tconst json = JSON.stringify(value);\n\tatomicWriteFileSync(path, json, options);\n};\n\n// Local dirname — we don't yield Path service here because\n// atomic-write may be called outside of a path-service-having\n// context (tests, recovery scripts). Posix-only; devstack is\n// posix-only in practice.\nconst dirname = (p: string): string => {\n\tconst i = p.lastIndexOf('/');\n\treturn i <= 0 ? '/' : p.slice(0, i);\n};\n"],"mappings":";;;;;;;;AAsDA,MAAM,mBAA2B,YAAY,CAAC,QAAQ,MAAM,GAAG,CAAC,MAAM,GAAG,EAAE;AAE3E,MAAM,aAEJ,MACA,WAEA,UACA,OAAO,KAAK,IAAI,kBAAkB;CAAE;CAAM;CAAO;CAAO,CAAC,CAAC;;;;;;;;AAS5D,MAAa,mBACZ,MACA,OACA,UAAoE,EAAE,KAEtE,OAAO,IAAI,aAAa;CACvB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,MAAM,GAAG,KAAK,OAAO,QAAQ,IAAI,GAAG,YAAY;AAGtD,QAAO,GACL,cAAc,QAAQ,KAAK,EAAE;EAAE,WAAW;EAAM,MAAM;EAAY,CAAC,CACnE,KAAK,OAAO,MAAM,UAAU,MAAM,eAAe,CAAC,CAAC;AAGrD,QAAO,OAAO,OACb,OAAO,IAAI,aAAa;EACvB,MAAM,OAAO,OAAO,GAClB,KAAK,KAAK;GAAE,MAAM;GAAM;GAAM,CAAC,CAC/B,KAAK,OAAO,MAAM,UAAU,MAAM,YAAY,CAAC,CAAC;AAClD,SAAO,KAAK,SAAS,MAAM,CAAC,KAAK,OAAO,MAAM,UAAU,MAAM,QAAQ,CAAC,CAAC;AAIxE,SAAO,KAAK,KAAK,KAAK,OAAO,MAAM,UAAU,MAAM,QAAQ,CAAC,CAAC;GAC5D,CACF;AAID,QAAO,GACL,OAAO,KAAK,KAAK,CACjB,KACA,OAAO,OAAO,UACb,GACE,OAAO,KAAK,EAAE,OAAO,MAAM,CAAC,CAC5B,KAAK,OAAO,QAAQ,OAAO,QAAQ,UAAU,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC,CACvE,CACD;EACD,CAAC,KAAK,OAAO,SAAS,6BAA6B,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC;;;;;;AAOhF,MAAa,mBACZ,MACA,QACA,OACA,YAEA,OAAO,IAAI,aAAa;CACvB,MAAM,UAAU,OAAO,OAAO,oBAAoB,OAAO,CAAC,MAAM,CAAC,KAChE,OAAO,MAAM,UAAU,MAAM,SAAS,CAAC,CACvC;CACD,MAAM,OAAO,KAAK,UAAU,SAAS,MAAM,EAAE;AAE7C,QAAO,gBAAgB,MADT,IAAI,aAAa,CAAC,OAAO,KACL,EAAE,QAAQ;EAC3C;;;;;;;;;;;AAkBH,MAAa,uBACZ,MACA,OACA,UAAoE,EAAE,KAC5D;CACV,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,MAAM,GAAG,KAAK,OAAO,QAAQ,IAAI,GAAG,YAAY;AACtD,WAAU,QAAQ,KAAK,EAAE;EAAE,WAAW;EAAM,MAAM;EAAY,CAAC;AAI/D,eAAc,KAAK,OAAO;EAAE,MAAM;EAAM;EAAM,CAAC;CAG/C,IAAI,KAAoB;AACxB,KAAI;AACH,OAAK,SAAS,KAAK,IAAI;AACvB,YAAU,GAAG;WACJ;AACT,MAAI,OAAO,KAAM,WAAU,GAAG;;AAE/B,KAAI;AACH,aAAW,KAAK,KAAK;UACb,OAAO;AAGf,MAAI;AACH,cAAW,IAAI;UACR;AAGR,QAAM;;;;;;;;;;AAWR,MAAa,uBACZ,MACA,OACA,YACU;AAEV,qBAAoB,MADP,KAAK,UAAU,MACE,EAAE,QAAQ;;AAOzC,MAAM,WAAW,MAAsB;CACtC,MAAM,IAAI,EAAE,YAAY,IAAI;AAC5B,QAAO,KAAK,IAAI,MAAM,EAAE,MAAM,GAAG,EAAE"}

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

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

package/dist/substrate/runtime/cache/schema.d.mts

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

package/dist/substrate/runtime/cache/schema.mjs

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+//#region src/substrate/runtime/cache/schema.ts
+/** Versioned envelope. Schema-decode failure on read is treated as
+*  a cache MISS (best-effort cache contract — corruption recovers
+*  by re-producing the artifact). */
+const CacheEntryDoc = Schema.Struct({
+	version: Schema.Literal(1),
+	/** Bytes, base64-encoded. Chosen over hex because typical
+	*  artifacts are larger (image manifests, package digests) and
+	*  base64 is 33% overhead vs hex's 100%. */
+	bytes: Schema.String,
+	/** Unix millis of the write. Renderers may show "produced 5s
+	*  ago"; substrate uses it only for diagnostics. */
+	writtenAt: Schema.Number,
+	/** Optional namespace-private hint (e.g. "image-tag the cached
+	*  blob refers to"). Substrate stores opaquely. */
+	hint: Schema.optional(Schema.String)
+});
+//#endregion
+export { CacheEntryDoc };
+
+//# sourceMappingURL=schema.mjs.map

package/dist/substrate/runtime/cache/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../../../src/substrate/runtime/cache/schema.ts"],"sourcesContent":["// On-disk shape for one cache entry.\n//\n// One file per `(namespace, chain, contentHash)` triple, at\n// `<runtime-root>/stacks/<stack>/cache/<namespace>/<chain>/<contentHash>.json`.\n//\n// The entry envelope wraps the bytes (base64-encoded — JSON has no\n// binary literal) and the metadata renderer / verify needs. Cache\n// callers don't see the envelope; they only see `CacheEntry` from\n// `primitives/cache.ts` (bytes + writtenAt).\n\nimport { Schema } from 'effect';\n\n/** Versioned envelope. Schema-decode failure on read is treated as\n *  a cache MISS (best-effort cache contract — corruption recovers\n *  by re-producing the artifact). */\nexport const CacheEntryDoc = Schema.Struct({\n\tversion: Schema.Literal(1),\n\t/** Bytes, base64-encoded. Chosen over hex because typical\n\t *  artifacts are larger (image manifests, package digests) and\n\t *  base64 is 33% overhead vs hex's 100%. */\n\tbytes: Schema.String,\n\t/** Unix millis of the write. Renderers may show \"produced 5s\n\t *  ago\"; substrate uses it only for diagnostics. */\n\twrittenAt: Schema.Number,\n\t/** Optional namespace-private hint (e.g. \"image-tag the cached\n\t *  blob refers to\"). Substrate stores opaquely. */\n\thint: Schema.optional(Schema.String),\n});\nexport type CacheEntryDoc = typeof CacheEntryDoc.Type;\n"],"mappings":";;;;;AAeA,MAAa,gBAAgB,OAAO,OAAO;CAC1C,SAAS,OAAO,QAAQ,EAAE;;;;CAI1B,OAAO,OAAO;;;CAGd,WAAW,OAAO;;;CAGlB,MAAM,OAAO,SAAS,OAAO,OAAO;CACpC,CAAC"}

package/dist/substrate/runtime/cache/service.d.mts

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

package/dist/substrate/runtime/cache/service.mjs

@@ -0,0 +1,89 @@
+import { StackPathsService } from "../paths.mjs";
+import { CacheError } from "../errors.mjs";
+import { decodeJsonText } from "../runtime-decode.mjs";
+import { CacheEntryDoc } from "./schema.mjs";
+import { atomicWriteJson } from "../atomic-write.mjs";
+import { Context, Effect, FileSystem, Layer } from "effect";
+//#region src/substrate/runtime/cache/service.ts
+const base64Encode = (bytes) => Buffer.from(bytes).toString("base64");
+const base64Decode = (s) => new Uint8Array(Buffer.from(s, "base64"));
+var CacheService = class extends Context.Service()("@devstack-rewrite/substrate/Cache") {};
+/**
+* Cache Layer. Stateless beyond the path resolver and the platform
+* FileSystem — every read goes to disk (no in-memory hot cache; the
+* OS page cache is enough). If a future perf pass shows the
+* substrate is hot-path-reading the same entries repeatedly, fold
+* an LRU in here; today's call-sites read once at acquire and never
+* again.
+*/
+const layerCache = Layer.effect(CacheService, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* StackPathsService;
+	const lookup = (key) => Effect.gen(function* () {
+		const { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);
+		if (!(yield* fs.exists(file).pipe(Effect.catch((cause) => Effect.fail(new CacheError({
+			reason: "io-failed",
+			detail: `failed to stat cache entry: ${file}`,
+			cause
+		})))))) return null;
+		const text = yield* fs.readFileString(file).pipe(Effect.catch((cause) => Effect.fail(new CacheError({
+			reason: "io-failed",
+			detail: `failed to read cache entry: ${file}`,
+			cause
+		}))));
+		const annotateCorruption = Effect.annotateCurrentSpan({ "cache.corruption": true });
+		const doc = yield* decodeJsonText(CacheEntryDoc, text, {
+			source: file,
+			mkError: (issue) => issue
+		}).pipe(Effect.catch(() => annotateCorruption.pipe(Effect.as(null))));
+		if (doc === null) return null;
+		return {
+			bytes: base64Decode(doc.bytes),
+			writtenAt: doc.writtenAt
+		};
+	}).pipe(Effect.withSpan("substrate.cache.lookup", { attributes: {
+		namespace: key.namespace,
+		chain: key.chain,
+		contentHash: key.contentHash
+	} }));
+	const write = (key, bytes) => Effect.gen(function* () {
+		const { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);
+		yield* atomicWriteJson(file, CacheEntryDoc, {
+			version: 1,
+			bytes: base64Encode(bytes),
+			writtenAt: Date.now()
+		}, {
+			mode: 420,
+			parentMode: 493
+		}).pipe(Effect.catch((cause) => Effect.fail(new CacheError({
+			reason: "io-failed",
+			detail: `cache write failed: ${file}`,
+			cause
+		}))), Effect.provideService(FileSystem.FileSystem, fs));
+	}).pipe(Effect.withSpan("substrate.cache.write", { attributes: {
+		namespace: key.namespace,
+		chain: key.chain,
+		contentHash: key.contentHash
+	} }));
+	const remove = (key) => Effect.gen(function* () {
+		const { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);
+		yield* fs.remove(file, { force: true }).pipe(Effect.catch((cause) => Effect.fail(new CacheError({
+			reason: "io-failed",
+			detail: `cache delete failed: ${file}`,
+			cause
+		}))));
+	}).pipe(Effect.withSpan("substrate.cache.delete", { attributes: {
+		namespace: key.namespace,
+		chain: key.chain,
+		contentHash: key.contentHash
+	} }));
+	return CacheService.of({
+		lookup,
+		write,
+		delete: remove
+	});
+}));
+//#endregion
+export { CacheService, layerCache };
+
+//# sourceMappingURL=service.mjs.map

package/dist/substrate/runtime/cache/service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.mjs","names":[],"sources":["../../../../src/substrate/runtime/cache/service.ts"],"sourcesContent":["// Cache implementation.\n//\n// Universal artifact cache, content-addressed by\n// `(namespace, chainId, contentHash)`. Per-plugin namespace; the\n// substrate folds chainId in.\n//\n// Semantics:\n//\n//   - `lookup` is the precise \"is the entry present?\" query. Hit\n//     returns `CacheEntry`; miss returns `null`. Schema-decode\n//     failure (corruption) is treated as a MISS, not an error —\n//     re-producing the artifact is always safe; surfacing decode\n//     failures would force every caller to handle a recovery path\n//     they don't need. The corruption is logged via the span.\n//   - `write` is best-effort. The architecture is explicit: an\n//     ArtifactPublisher commits the on-chain effect, THEN\n//     writes the cache; a cache-write IO failure must NOT roll back\n//     the on-chain effect. We surface write failures via the\n//     `CacheError` channel so callers can opt into reporting them,\n//     but the typical caller pipes `Effect.ignore` over the write.\n//   - `delete` is a best-effort sweep.\n//\n// Tombstones: the cache does NOT use tombstones. Missing-vs-deleted\n// is meaningless for a content-addressed best-effort store —\n// re-producing the artifact has the same effect either way.\n\nimport { Context, Effect, FileSystem, Layer } from 'effect';\n\nimport type { Cache, CacheEntry, CacheKey } from '../../../primitives/cache.ts';\nimport { atomicWriteJson } from '../atomic-write.ts';\nimport { CacheError } from '../errors.ts';\nimport { StackPathsService } from '../paths.ts';\nimport { decodeJsonText } from '../runtime-decode.ts';\nimport { CacheEntryDoc } from './schema.ts';\n\nconst base64Encode = (bytes: Uint8Array): string => Buffer.from(bytes).toString('base64');\nconst base64Decode = (s: string): Uint8Array => new Uint8Array(Buffer.from(s, 'base64'));\n\nexport class CacheService extends Context.Service<CacheService, Cache>()(\n\t'@devstack-rewrite/substrate/Cache',\n) {}\n\n/**\n * Cache Layer. Stateless beyond the path resolver and the platform\n * FileSystem — every read goes to disk (no in-memory hot cache; the\n * OS page cache is enough). If a future perf pass shows the\n * substrate is hot-path-reading the same entries repeatedly, fold\n * an LRU in here; today's call-sites read once at acquire and never\n * again.\n */\nexport const layerCache: Layer.Layer<\n\tCacheService,\n\tnever,\n\tFileSystem.FileSystem | StackPathsService\n> = Layer.effect(\n\tCacheService,\n\tEffect.gen(function* () {\n\t\tconst fs = yield* FileSystem.FileSystem;\n\t\tconst paths = yield* StackPathsService;\n\n\t\tconst lookup = (key: CacheKey): Effect.Effect<CacheEntry | null, CacheError> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);\n\t\t\t\tconst exists = yield* fs.exists(file).pipe(\n\t\t\t\t\tEffect.catch((cause) =>\n\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\tnew CacheError({\n\t\t\t\t\t\t\t\treason: 'io-failed',\n\t\t\t\t\t\t\t\tdetail: `failed to stat cache entry: ${file}`,\n\t\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t\tif (!exists) return null;\n\t\t\t\tconst text = yield* fs.readFileString(file).pipe(\n\t\t\t\t\tEffect.catch((cause) =>\n\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\tnew CacheError({\n\t\t\t\t\t\t\t\treason: 'io-failed',\n\t\t\t\t\t\t\t\tdetail: `failed to read cache entry: ${file}`,\n\t\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t\t// Corruption = miss. The cache contract is\n\t\t\t\t// best-effort; surfacing decode failures would force\n\t\t\t\t// every caller to handle a recovery path that's\n\t\t\t\t// already implicit (re-produce). We do annotate the\n\t\t\t\t// span so the substrate's observability still\n\t\t\t\t// surfaces the rare corruption.\n\t\t\t\tconst annotateCorruption = Effect.annotateCurrentSpan({\n\t\t\t\t\t'cache.corruption': true,\n\t\t\t\t});\n\t\t\t\tconst doc = yield* decodeJsonText(CacheEntryDoc, text, {\n\t\t\t\t\tsource: file,\n\t\t\t\t\tmkError: (issue) => issue,\n\t\t\t\t}).pipe(\n\t\t\t\t\tEffect.catch(() => annotateCorruption.pipe(Effect.as(null as CacheEntryDoc | null))),\n\t\t\t\t);\n\t\t\t\tif (doc === null) return null;\n\t\t\t\treturn {\n\t\t\t\t\tbytes: base64Decode(doc.bytes),\n\t\t\t\t\twrittenAt: doc.writtenAt,\n\t\t\t\t};\n\t\t\t}).pipe(\n\t\t\t\tEffect.withSpan('substrate.cache.lookup', {\n\t\t\t\t\tattributes: {\n\t\t\t\t\t\tnamespace: key.namespace,\n\t\t\t\t\t\tchain: key.chain,\n\t\t\t\t\t\tcontentHash: key.contentHash,\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t);\n\n\t\tconst write = (key: CacheKey, bytes: Uint8Array): Effect.Effect<void, CacheError> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);\n\t\t\t\tconst doc: CacheEntryDoc = {\n\t\t\t\t\tversion: 1,\n\t\t\t\t\tbytes: base64Encode(bytes),\n\t\t\t\t\twrittenAt: Date.now(),\n\t\t\t\t};\n\t\t\t\tyield* atomicWriteJson(file, CacheEntryDoc, doc, {\n\t\t\t\t\tmode: 0o644,\n\t\t\t\t\tparentMode: 0o755,\n\t\t\t\t}).pipe(\n\t\t\t\t\tEffect.catch((cause) =>\n\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\tnew CacheError({\n\t\t\t\t\t\t\t\treason: 'io-failed',\n\t\t\t\t\t\t\t\tdetail: `cache write failed: ${file}`,\n\t\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t\tEffect.provideService(FileSystem.FileSystem, fs),\n\t\t\t\t);\n\t\t\t}).pipe(\n\t\t\t\tEffect.withSpan('substrate.cache.write', {\n\t\t\t\t\tattributes: {\n\t\t\t\t\t\tnamespace: key.namespace,\n\t\t\t\t\t\tchain: key.chain,\n\t\t\t\t\t\tcontentHash: key.contentHash,\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t);\n\n\t\tconst remove = (key: CacheKey): Effect.Effect<void, CacheError> =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst { file } = paths.cacheEntry(key.namespace, key.chain, key.contentHash);\n\t\t\t\tyield* fs.remove(file, { force: true }).pipe(\n\t\t\t\t\tEffect.catch((cause) =>\n\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\tnew CacheError({\n\t\t\t\t\t\t\t\treason: 'io-failed',\n\t\t\t\t\t\t\t\tdetail: `cache delete failed: ${file}`,\n\t\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t}).pipe(\n\t\t\t\tEffect.withSpan('substrate.cache.delete', {\n\t\t\t\t\tattributes: {\n\t\t\t\t\t\tnamespace: key.namespace,\n\t\t\t\t\t\tchain: key.chain,\n\t\t\t\t\t\tcontentHash: key.contentHash,\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t);\n\n\t\treturn CacheService.of({\n\t\t\tlookup,\n\t\t\twrite,\n\t\t\tdelete: remove,\n\t\t});\n\t}),\n);\n"],"mappings":";;;;;;;AAmCA,MAAM,gBAAgB,UAA8B,OAAO,KAAK,MAAM,CAAC,SAAS,SAAS;AACzF,MAAM,gBAAgB,MAA0B,IAAI,WAAW,OAAO,KAAK,GAAG,SAAS,CAAC;AAExF,IAAa,eAAb,cAAkC,QAAQ,SAA8B,CACvE,oCACA,CAAC;;;;;;;;;AAUF,MAAa,aAIT,MAAM,OACT,cACA,OAAO,IAAI,aAAa;CACvB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,QAAQ,OAAO;CAErB,MAAM,UAAU,QACf,OAAO,IAAI,aAAa;EACvB,MAAM,EAAE,SAAS,MAAM,WAAW,IAAI,WAAW,IAAI,OAAO,IAAI,YAAY;AAY5E,MAAI,EAAC,OAXiB,GAAG,OAAO,KAAK,CAAC,KACrC,OAAO,OAAO,UACb,OAAO,KACN,IAAI,WAAW;GACd,QAAQ;GACR,QAAQ,+BAA+B;GACvC;GACA,CAAC,CACF,CACD,CACD,EACY,QAAO;EACpB,MAAM,OAAO,OAAO,GAAG,eAAe,KAAK,CAAC,KAC3C,OAAO,OAAO,UACb,OAAO,KACN,IAAI,WAAW;GACd,QAAQ;GACR,QAAQ,+BAA+B;GACvC;GACA,CAAC,CACF,CACD,CACD;EAOD,MAAM,qBAAqB,OAAO,oBAAoB,EACrD,oBAAoB,MACpB,CAAC;EACF,MAAM,MAAM,OAAO,eAAe,eAAe,MAAM;GACtD,QAAQ;GACR,UAAU,UAAU;GACpB,CAAC,CAAC,KACF,OAAO,YAAY,mBAAmB,KAAK,OAAO,GAAG,KAA6B,CAAC,CAAC,CACpF;AACD,MAAI,QAAQ,KAAM,QAAO;AACzB,SAAO;GACN,OAAO,aAAa,IAAI,MAAM;GAC9B,WAAW,IAAI;GACf;GACA,CAAC,KACF,OAAO,SAAS,0BAA0B,EACzC,YAAY;EACX,WAAW,IAAI;EACf,OAAO,IAAI;EACX,aAAa,IAAI;EACjB,EACD,CAAC,CACF;CAEF,MAAM,SAAS,KAAe,UAC7B,OAAO,IAAI,aAAa;EACvB,MAAM,EAAE,SAAS,MAAM,WAAW,IAAI,WAAW,IAAI,OAAO,IAAI,YAAY;AAM5E,SAAO,gBAAgB,MAAM,eAAe;GAJ3C,SAAS;GACT,OAAO,aAAa,MAAM;GAC1B,WAAW,KAAK,KAAK;GAEyB,EAAE;GAChD,MAAM;GACN,YAAY;GACZ,CAAC,CAAC,KACF,OAAO,OAAO,UACb,OAAO,KACN,IAAI,WAAW;GACd,QAAQ;GACR,QAAQ,uBAAuB;GAC/B;GACA,CAAC,CACF,CACD,EACD,OAAO,eAAe,WAAW,YAAY,GAAG,CAChD;GACA,CAAC,KACF,OAAO,SAAS,yBAAyB,EACxC,YAAY;EACX,WAAW,IAAI;EACf,OAAO,IAAI;EACX,aAAa,IAAI;EACjB,EACD,CAAC,CACF;CAEF,MAAM,UAAU,QACf,OAAO,IAAI,aAAa;EACvB,MAAM,EAAE,SAAS,MAAM,WAAW,IAAI,WAAW,IAAI,OAAO,IAAI,YAAY;AAC5E,SAAO,GAAG,OAAO,MAAM,EAAE,OAAO,MAAM,CAAC,CAAC,KACvC,OAAO,OAAO,UACb,OAAO,KACN,IAAI,WAAW;GACd,QAAQ;GACR,QAAQ,wBAAwB;GAChC;GACA,CAAC,CACF,CACD,CACD;GACA,CAAC,KACF,OAAO,SAAS,0BAA0B,EACzC,YAAY;EACX,WAAW,IAAI;EACf,OAAO,IAAI;EACX,aAAa,IAAI;EACjB,EACD,CAAC,CACF;AAEF,QAAO,aAAa,GAAG;EACtB;EACA;EACA,QAAQ;EACR,CAAC;EACD,CACF"}

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

@@ -0,0 +1 @@
+import { CapabilitySink, ContributionKind, HarvestContext } from "./service.mjs";

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

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

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

@@ -0,0 +1,31 @@
+import { FormatterRegistryService, layerFormatterRegistry } from "../observability/formatter-registry.mjs";
+import { CapabilitySinksService, layerCapabilitySinks } from "./service.mjs";
+import { Effect, Layer } from "effect";
+//#region src/substrate/runtime/capability-sinks/layer.ts
+const errorContributionSink = (formatters) => ({
+	kind: "error-contribution",
+	accept: (contribution, _ctx) => formatters.register(contribution)
+});
+/**
+* Build the substrate's default CapabilitySinks layer. It supplies the
+* error-contribution sink and registers the caller's capability sinks
+* by kind. Unknown contribution kinds remain no-ops at the supervisor
+* call site unless a sink is registered.
+*
+* Plugin-author extension: provide an additional Layer that yields
+* `CapabilitySinksService` and calls `registerSink({ kind: 'my-kind', ... })`
+* before the supervisor starts harvesting. Last-write-wins on duplicate
+* kinds, with scope-bound restore — the built-in sink comes back when
+* the override's scope closes.
+*/
+const layerCapabilitySinksDefault = (orchestrator = []) => {
+	return Layer.effectDiscard(Effect.gen(function* () {
+		const sinks = yield* CapabilitySinksService;
+		const defaults = [errorContributionSink(yield* FormatterRegistryService), ...orchestrator];
+		for (const sink of defaults) yield* sinks.registerSink(sink);
+	})).pipe(Layer.provideMerge(layerCapabilitySinks), Layer.provideMerge(layerFormatterRegistry));
+};
+//#endregion
+export { layerCapabilitySinksDefault };
+
+//# sourceMappingURL=layer.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+import { PluginKey } from "../../brand.mjs";
+import { EngineEvent } from "../../events.mjs";
+import { StrategyContributorDecl } from "../../../contracts/strategy-contributor.mjs";
+import { Identity } from "../../identity.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+//#region src/substrate/runtime/capability-sinks/service.d.ts
+/** 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' | 'liveness-classifier' | '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>;
+}
+//#endregion
+export { CapabilitySink, ContributionKind, HarvestContext };
+//# sourceMappingURL=service.d.mts.map

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

@@ -0,0 +1,74 @@
+import { Context, Data, Effect, Layer, Ref } 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-rewrite/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 sinksRef = yield* Ref.make(/* @__PURE__ */ new Map());
+	const registerSink = (sink) => Effect.gen(function* () {
+		const accept = sink.accept;
+		const prior = yield* Ref.modify(sinksRef, (current) => {
+			const next = new Map(current);
+			const had = next.get(sink.kind) ?? null;
+			next.set(sink.kind, accept);
+			return [had, next];
+		});
+		yield* Effect.addFinalizer((_exit) => Ref.update(sinksRef, (current) => {
+			const next = new Map(current);
+			if (prior === null) next.delete(sink.kind);
+			else next.set(sink.kind, prior);
+			return next;
+		}));
+		yield* Effect.annotateCurrentSpan({ "capability-sinks.kind": sink.kind });
+	}).pipe(Effect.withSpan("substrate.capabilitySinks.registerSink"));
+	const dispatch = (contribution, ctx) => Effect.gen(function* () {
+		const kind = kindOf(contribution);
+		const sinks = yield* Ref.get(sinksRef);
+		const accept = sinks.get(kind);
+		if (accept === void 0) return yield* new UnknownContributionKind({
+			kind,
+			known: [...sinks.keys()]
+		});
+		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({
+			"capability-sinks.kind": kind,
+			"devstack.plugin": ctx.pluginKey
+		});
+	}).pipe(Effect.withSpan("substrate.capabilitySinks.dispatch"));
+	const knownKinds = Effect.gen(function* () {
+		return [...(yield* Ref.get(sinksRef)).keys()];
+	});
+	return CapabilitySinksService.of({
+		registerSink,
+		dispatch,
+		knownKinds
+	});
+}));
+//#endregion
+export { CapabilitySinksService, layerCapabilitySinks };
+
+//# sourceMappingURL=service.mjs.map

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

@@ -0,0 +1 @@
+{"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, Ref, 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';\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| 'liveness-classifier'\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 replaces the built-in.\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\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-rewrite/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\tconst sinksRef = yield* Ref.make<ReadonlyMap<string, SinkAccept>>(new Map());\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\tconst prior = yield* Ref.modify(sinksRef, (current) => {\n\t\t\t\t\tconst next = new Map(current);\n\t\t\t\t\tconst had = next.get(sink.kind) ?? null;\n\t\t\t\t\tnext.set(sink.kind, accept);\n\t\t\t\t\treturn [had, next];\n\t\t\t\t});\n\t\t\t\t// Scope finalizer: restore the prior sink (or remove\n\t\t\t\t// entirely) on scope close. Symmetric semantics — a\n\t\t\t\t// plugin-author overlay's scope close restores the\n\t\t\t\t// built-in.\n\t\t\t\tyield* Effect.addFinalizer((_exit) =>\n\t\t\t\t\tRef.update(sinksRef, (current) => {\n\t\t\t\t\t\tconst next = new Map(current);\n\t\t\t\t\t\tif (prior === null) next.delete(sink.kind);\n\t\t\t\t\t\telse next.set(sink.kind, prior);\n\t\t\t\t\t\treturn next;\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t\tyield* Effect.annotateCurrentSpan({\n\t\t\t\t\t'capability-sinks.kind': 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 sinks = yield* Ref.get(sinksRef);\n\t\t\t\tconst accept = sinks.get(kind);\n\t\t\t\tif (accept === undefined) {\n\t\t\t\t\treturn yield* new UnknownContributionKind({\n\t\t\t\t\t\tkind,\n\t\t\t\t\t\tknown: [...sinks.keys()],\n\t\t\t\t\t});\n\t\t\t\t}\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'capability-sinks.kind': kind,\n\t\t\t\t\t'devstack.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>> = Effect.gen(function* () {\n\t\t\tconst sinks = yield* Ref.get(sinksRef);\n\t\t\treturn [...sinks.keys()];\n\t\t});\n\n\t\treturn CapabilitySinksService.of({ registerSink, dispatch, knownKinds });\n\t}),\n);\n"],"mappings":";;;;;;AA2FA,IAAa,0BAAb,cAA6C,KAAK,YAAY,0BAA0B,CAGrF;;;;;AAMH,IAAa,yBAAb,cAA4C,KAAK,YAAY,yBAAyB,CAInF;AA0BH,IAAa,yBAAb,cAA4C,QAAQ,SAGjD,CAAC,8CAA8C,CAAC;;;;;AAUnD,MAAa,UAAU,iBAAoD;AAC1E,KAAI,aAAa,WAAW,QAAS,QAAO;AAG5C,QAAO,aAAa,KAAK;;;;;;AAa1B,MAAa,uBAA4D,MAAM,OAC9E,wBACA,OAAO,IAAI,aAAa;CACvB,MAAM,WAAW,OAAO,IAAI,qBAAsC,IAAI,KAAK,CAAC;CAE5E,MAAM,gBACL,SAEA,OAAO,IAAI,aAAa;EACvB,MAAM,SAAS,KAAK;EACpB,MAAM,QAAQ,OAAO,IAAI,OAAO,WAAW,YAAY;GACtD,MAAM,OAAO,IAAI,IAAI,QAAQ;GAC7B,MAAM,MAAM,KAAK,IAAI,KAAK,KAAK,IAAI;AACnC,QAAK,IAAI,KAAK,MAAM,OAAO;AAC3B,UAAO,CAAC,KAAK,KAAK;IACjB;AAKF,SAAO,OAAO,cAAc,UAC3B,IAAI,OAAO,WAAW,YAAY;GACjC,MAAM,OAAO,IAAI,IAAI,QAAQ;AAC7B,OAAI,UAAU,KAAM,MAAK,OAAO,KAAK,KAAK;OACrC,MAAK,IAAI,KAAK,MAAM,MAAM;AAC/B,UAAO;IACN,CACF;AACD,SAAO,OAAO,oBAAoB,EACjC,yBAAyB,KAAK,MAC9B,CAAC;GACD,CAAC,KAAK,OAAO,SAAS,yCAAyC,CAAC;CAEnE,MAAM,YACL,cACA,QAEA,OAAO,IAAI,aAAa;EACvB,MAAM,OAAO,OAAO,aAAa;EACjC,MAAM,QAAQ,OAAO,IAAI,IAAI,SAAS;EACtC,MAAM,SAAS,MAAM,IAAI,KAAK;AAC9B,MAAI,WAAW,KAAA,EACd,QAAO,OAAO,IAAI,wBAAwB;GACzC;GACA,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC;GACxB,CAAC;AAIH,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;GACjC,yBAAyB;GACzB,mBAAmB,IAAI;GACvB,CAAC;GACD,CAAC,KAAK,OAAO,SAAS,qCAAqC,CAAC;CAE/D,MAAM,aAAmD,OAAO,IAAI,aAAa;AAEhF,SAAO,CAAC,IAAG,OADU,IAAI,IAAI,SAAS,EACrB,MAAM,CAAC;GACvB;AAEF,QAAO,uBAAuB,GAAG;EAAE;EAAc;EAAU;EAAY,CAAC;EACvE,CACF"}

package/dist/substrate/runtime/config-validation.d.mts

@@ -0,0 +1,38 @@
+import { Effect, Schema } from "effect";
+
+//#region src/substrate/runtime/config-validation.d.ts
+declare namespace config_validation_d_exports {
+  export { ConfigErrorFactory, ConfigIssue, decodeConfig, decodeConfigSync, defineConfigError, expectNonEmptyArray, expectNonEmptyString, expectOneOf, expectOptionalNonEmptyString, expectOptionalPort, expectOptionalPositiveInteger, expectPattern, expectPort, expectPositiveFiniteNumber, expectPositiveInteger, expectStringRecord };
+}
+interface ConfigIssue {
+  readonly field: string;
+  readonly message: string;
+  readonly hint?: string;
+  readonly cause?: unknown;
+}
+type ConfigErrorFactory<E> = (issue: ConfigIssue) => E;
+declare const defineConfigError: <const Tag extends string>(tag: Tag) => (issue: ConfigIssue) => ConfigIssue & {
+  readonly _tag: Tag;
+};
+interface ValidatorOptions<E> {
+  readonly field: string;
+  readonly mkError: ConfigErrorFactory<E>;
+  readonly message?: string;
+  readonly hint?: string;
+}
+declare const expectNonEmptyString: <E>(value: unknown, options: ValidatorOptions<E>) => string;
+declare const expectOptionalNonEmptyString: <E>(value: unknown, options: ValidatorOptions<E>) => string | undefined;
+declare const expectPositiveInteger: <E>(value: unknown, options: ValidatorOptions<E>) => number;
+declare const expectOptionalPositiveInteger: <E>(value: unknown, options: ValidatorOptions<E>) => number | undefined;
+declare const expectPositiveFiniteNumber: <E>(value: unknown, options: ValidatorOptions<E>) => number;
+declare const expectPort: <E>(value: unknown, options: ValidatorOptions<E>) => number;
+declare const expectOptionalPort: <E>(value: unknown, options: ValidatorOptions<E>) => number | undefined;
+declare const expectStringRecord: <E>(value: unknown, options: ValidatorOptions<E>) => Readonly<Record<string, string>>;
+declare const expectOneOf: <const Values extends ReadonlyArray<string>, E>(value: unknown, values: Values, options: ValidatorOptions<E>) => Values[number];
+declare const expectNonEmptyArray: <T, E>(value: ReadonlyArray<T> | undefined, options: ValidatorOptions<E>) => ReadonlyArray<T>;
+declare const expectPattern: <E>(value: string, pattern: RegExp, options: ValidatorOptions<E>) => string;
+declare const decodeConfig: <S extends Schema.Decoder<unknown>, E>(schema: S, value: unknown, options: ValidatorOptions<E>) => Effect.Effect<S["Type"], E>;
+declare const decodeConfigSync: <S extends Schema.Decoder<unknown>, E>(schema: S, value: unknown, options: ValidatorOptions<E>) => S["Type"];
+//#endregion
+export { ConfigIssue, config_validation_d_exports };
+//# sourceMappingURL=config-validation.d.mts.map