@mysten-incubation/devstack 0.0.0

package/dist/plugins/seal/routable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routable.mjs","names":[],"sources":["../../../src/plugins/seal/routable.ts"],"sourcesContent":["// Seal plugin — Routable contribution.\n//\n// Distilled-doc invariant #5: the seal port (2024) is INTENTIONALLY\n// shared across stacks. Traefik dispatches by Host: header from the\n// well-known `seal-key-server` entrypoint. No host-port publish —\n// two stacks of the same app coexist on the same well-known port.\n//\n// The substrate's router (architecture §4) mints the hostname from\n// `(app, stack, dispatch-id)`. We provide:\n//\n//   - `endpointName`  — the well-known string `'seal-key-server'`.\n//   - `dispatchId`    — `{serviceKey: 'seal:<name>', role: 'key-server'}`.\n//                        The service key folds the seal instance\n//                        name so multi-instance stacks (distilled-doc\n//                        Open Question #7) don't collide.\n//   - `upstream`      — container kind; the substrate resolves the\n//                        container name from the lifecycle row.\n//   - `cors: true`    — the @mysten/seal SDK's fetch calls require\n//                        CORS allowance (distilled doc: localnet\n//                        SDK browser flow).\n//\n// Distilled-doc invariant #1: the URL the router publishes for this\n// routable decl MUST equal the URL we register on chain. The\n// plugin's acquire body reads the router's published URL ONCE\n// and threads the same value into the Move register call.\n\nimport type { DispatchId, EntrypointDecl, RoutableDecl } from '../../contracts/routable.ts';\n\n/** Well-known endpoint name for the seal key-server. Conventional\n *  router entrypoint `'seal-key-server'` on port 2024. */\nexport const SEAL_KEY_SERVER_ENDPOINT_NAME = 'seal-key-server' as const;\nexport const SEAL_KEY_SERVER_ROUTE_ROLE = 'key-server' as const;\nexport const DEFAULT_KEY_SERVER_PORT = 2024 as const;\n\nexport const SEAL_ENTRYPOINTS: ReadonlyArray<EntrypointDecl> = [\n\t{ name: SEAL_KEY_SERVER_ENDPOINT_NAME, port: DEFAULT_KEY_SERVER_PORT, protocol: 'http' },\n];\n\nconst DEFAULT_STACK = 'main';\n\nconst normalizeRouteSegment = (raw: string): string => raw.toLowerCase().replace(/\\./g, '-');\n\n/** Build the DispatchId for a seal instance. The service key\n *  encodes the instance name so multi-instance seal in the same\n *  stack mints distinct dispatch files.\n *\n *  Note: distilled-doc Open Question #7 — multi-instance seal is\n *  structurally supported but untested. The two routable decls\n *  would both claim the `'seal-key-server'` entrypoint and the\n *  same `key-server.<stack>.<app>.localhost` hostname. Until v2\n *  plans canonicalize multi-instance routing, treat one-seal-per-stack\n *  as the safe default. */\nexport const buildSealDispatchId = (name: string): DispatchId => ({\n\tserviceKey: `seal:${name}`,\n\trole: SEAL_KEY_SERVER_ROUTE_ROLE,\n});\n\nexport const buildSealKeyServerPublicRoute = (inputs: {\n\treadonly app: string;\n\treadonly stack: string;\n\treadonly port: number;\n}): { readonly hostname: string; readonly url: string } => {\n\tconst role = normalizeRouteSegment(SEAL_KEY_SERVER_ROUTE_ROLE);\n\tconst app = normalizeRouteSegment(inputs.app);\n\tconst stack = normalizeRouteSegment(inputs.stack);\n\tconst hostname =\n\t\tstack === DEFAULT_STACK ? `${role}.${app}.localhost` : `${role}.${stack}.${app}.localhost`;\n\treturn {\n\t\thostname,\n\t\turl: `http://${hostname}:${inputs.port}`,\n\t};\n};\n\n/** Build the Routable contribution. The substrate's router\n *  orchestrator consumes this; the actual hostname / URL minting\n *  happens there (architecture: routes-by-key, no hardcoded\n *  service hostnames in router code). */\nexport const makeSealRoutable = (inputs: {\n\treadonly name: string;\n\treadonly containerName: string;\n}): RoutableDecl => ({\n\tkind: 'routable',\n\tendpointName: SEAL_KEY_SERVER_ENDPOINT_NAME,\n\tdispatchId: buildSealDispatchId(inputs.name),\n\tupstream: {\n\t\ttype: 'container',\n\t\tcontainerName: inputs.containerName,\n\t\tcontainerPort: DEFAULT_KEY_SERVER_PORT,\n\t},\n\tcors: true,\n\twireProtocol: 'http',\n});\n\n/** Known-deployment modes do NOT route through the local router —\n *  the URL points at a remote endpoint (Mysten's testnet key\n *  server). We expose a sentinel routable that the orchestrator\n *  skips (substrate-blind: the orchestrator filters by upstream\n *  type, not by service name). For now, known modes return `null`\n *  from this builder. */\nexport const KNOWN_MODE_ROUTABLE: null = null;\n"],"mappings":";;;AA8BA,MAAa,gCAAgC;AAC7C,MAAa,6BAA6B;AAC1C,MAAa,0BAA0B;AAEvC,MAAa,mBAAkD,CAC9D;CAAE,MAAM;CAA+B,MAAM;CAAyB,UAAU;CAAQ,CACxF;AAED,MAAM,gBAAgB;AAEtB,MAAM,yBAAyB,QAAwB,IAAI,aAAa,CAAC,QAAQ,OAAO,IAAI;;;;;;;;;;;AAY5F,MAAa,uBAAuB,UAA8B;CACjE,YAAY,QAAQ;CACpB,MAAM;CACN;AAED,MAAa,iCAAiC,WAIa;CAC1D,MAAM,OAAO,sBAAsB,2BAA2B;CAC9D,MAAM,MAAM,sBAAsB,OAAO,IAAI;CAC7C,MAAM,QAAQ,sBAAsB,OAAO,MAAM;CACjD,MAAM,WACL,UAAU,gBAAgB,GAAG,KAAK,GAAG,IAAI,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI;AAChF,QAAO;EACN;EACA,KAAK,UAAU,SAAS,GAAG,OAAO;EAClC;;;;;;AAOF,MAAa,oBAAoB,YAGZ;CACpB,MAAM;CACN,cAAc;CACd,YAAY,oBAAoB,OAAO,KAAK;CAC5C,UAAU;EACT,MAAM;EACN,eAAe,OAAO;EACtB,eAAe;EACf;CACD,MAAM;CACN,cAAc;CACd"}

package/dist/plugins/seal/service.mjs

@@ -0,0 +1,17 @@
+import { acquireLive } from "./mode/live.mjs";
+import { acquireForkKnown } from "./mode/fork-known.mjs";
+import "effect";
+//#region src/plugins/seal/service.ts
+/** Dispatch on the known-mode discriminator. The publisher argument
+*  is unused by the known paths (no on-chain artifact produce); it's
+*  accepted for shape uniformity with the local-keygen entry point. */
+const bootSealService = (_publisher, opts) => {
+	switch (opts.mode) {
+		case "live": return acquireLive(opts);
+		case "fork-known": return acquireForkKnown(opts);
+	}
+};
+//#endregion
+export { bootSealService };
+
+//# sourceMappingURL=service.mjs.map

package/dist/plugins/seal/service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.mjs","names":[],"sources":["../../../src/plugins/seal/service.ts"],"sourcesContent":["// Seal plugin — known-mode dispatch (live + fork-known).\n//\n// Local-keygen mode is dispatched directly from the plugin barrel\n// (`index.ts`) via `bootLocalKeygen` because it needs a\n// `LocalKeygenDeps` bundle (ContainerRuntime, paths, identity, …)\n// composed from substrate services. This file only routes the two\n// pure-value-producing modes that need no substrate plumbing.\n\nimport { Effect, type Scope } from 'effect';\n\nimport type {\n\tArtifactPublishError,\n\tArtifactPublisher,\n} from '../../primitives/artifact-publisher.ts';\nimport type { SealAnyError } from './errors.ts';\nimport { acquireForkKnown, type ForkKnownInputs } from './mode/fork-known.ts';\nimport { acquireLive, type LiveModeInputs } from './mode/live.ts';\nimport type { SealKnownResolved } from './registry-publish.ts';\n\n/** Known-mode discriminator — live + fork-known only. */\nexport type SealMode =\n\t| ({ readonly mode: 'live' } & LiveModeInputs)\n\t| ({ readonly mode: 'fork-known' } & ForkKnownInputs);\n\nexport type SealKnownBootResult = SealKnownResolved;\n\n/** Dispatch on the known-mode discriminator. The publisher argument\n *  is unused by the known paths (no on-chain artifact produce); it's\n *  accepted for shape uniformity with the local-keygen entry point. */\nexport const bootSealService = (\n\t_publisher: ArtifactPublisher,\n\topts: SealMode,\n): Effect.Effect<SealKnownBootResult, SealAnyError | ArtifactPublishError, Scope.Scope> => {\n\tswitch (opts.mode) {\n\t\tcase 'live':\n\t\t\treturn acquireLive(opts);\n\t\tcase 'fork-known':\n\t\t\treturn acquireForkKnown(opts);\n\t}\n};\n"],"mappings":";;;;;;;AA6BA,MAAa,mBACZ,YACA,SAC0F;AAC1F,SAAQ,KAAK,MAAb;EACC,KAAK,OACJ,QAAO,YAAY,KAAK;EACzB,KAAK,aACJ,QAAO,iBAAiB,KAAK"}

package/dist/plugins/seal/snapshot.mjs

@@ -0,0 +1,51 @@
+import { Effect } from "effect";
+//#region src/plugins/seal/snapshot.ts
+/** Build the Snapshotable contribution for the local-keygen mode.
+*
+*  Inputs threaded by the barrel from acquire-time substrate
+*  identity. Distilled-doc invariant #4: `master-key.env` MUST
+*  survive snapshot. `missingTolerance: 'fatal'` because the file's
+*  absence on restore would silently re-derive a fresh keypair
+*  against a stale on-chain public key. */
+const makeLocalKeygenSnapshotable = (inputs) => {
+	return {
+		kind: "snapshotable",
+		subtrees: [`seal`],
+		managedContainers: [{
+			app: inputs.app,
+			stack: inputs.stack,
+			plugin: "seal",
+			role: "key-server"
+		}],
+		quiesce: Effect.void,
+		preRestore: Effect.succeed({
+			kind: "seal",
+			name: inputs.name
+		}),
+		postRestore: Effect.void,
+		missingTolerance: "fatal",
+		secretMaterial: true
+	};
+};
+/** Build the Snapshotable contribution for the known-deployment
+*  modes (live / fork-known). No managed container, no on-disk
+*  state — we only need the orchestrator to see the plugin's
+*  identity for the manifest sidecar.
+*
+*  `missingTolerance: 'fine'` because the known-deployment mode
+*  has no host-side state to lose. */
+const makeKnownSnapshotable = (inputs) => ({
+	kind: "snapshotable",
+	subtrees: [],
+	missingTolerance: "fine",
+	preRestore: Effect.succeed({
+		kind: "seal",
+		name: inputs.name
+	}),
+	postRestore: Effect.void,
+	secretMaterial: false
+});
+//#endregion
+export { makeKnownSnapshotable, makeLocalKeygenSnapshotable };
+
+//# sourceMappingURL=snapshot.mjs.map

package/dist/plugins/seal/snapshot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.mjs","names":[],"sources":["../../../src/plugins/seal/snapshot.ts"],"sourcesContent":["// Seal plugin — Snapshotable contribution.\n//\n// Distilled-doc §\"What survives snapshot\":\n//\n//   - `runtime/seal/master-key.env`              (0o600 — SECRET MATERIAL)\n//   - `runtime/seal/local-keygen-state.v1.json`  (public key metadata)\n//   - `runtime/seal/key-server-config.yaml`\n//   - State-store entries (under runtime/state-store/, auto-captured\n//     by the substrate — we don't declare a subtree for those).\n//   - Managed container — labeled tuple drives the docker commit +\n//     save path.\n//\n// Distilled-doc invariant: the master-key file is the LOAD-BEARING\n// piece — losing it on resume means the on-chain `KeyServer.url`'s\n// public key would mismatch a fresh keygen. The substrate's\n// `secretMaterial: true` flag drives the mode-bit round-trip (0o600\n// inside 0o700 parent preserved through the snapshot tar).\n//\n// Architecture: the orchestrator is service-name-blind — it walks\n// the Snapshotable decls, sees `runtime/seal/` as just a subtree\n// path, and treats the secret flag as an opaque mode-bit directive.\n\nimport { Effect } from 'effect';\n\nimport type { ContainerLabelTuple, SnapshotableDecl } from '../../contracts/snapshotable.ts';\n\n/** Build the Snapshotable contribution for the local-keygen mode.\n *\n *  Inputs threaded by the barrel from acquire-time substrate\n *  identity. Distilled-doc invariant #4: `master-key.env` MUST\n *  survive snapshot. `missingTolerance: 'fatal'` because the file's\n *  absence on restore would silently re-derive a fresh keypair\n *  against a stale on-chain public key. */\nexport const makeLocalKeygenSnapshotable = (inputs: {\n\treadonly name: string;\n\treadonly app: string;\n\treadonly stack: string;\n}): SnapshotableDecl => {\n\tconst labelTuple: ContainerLabelTuple = {\n\t\tapp: inputs.app,\n\t\tstack: inputs.stack,\n\t\tplugin: 'seal',\n\t\trole: 'key-server',\n\t};\n\treturn {\n\t\tkind: 'snapshotable',\n\t\t// Subtree under runtime/. The substrate roots this under the\n\t\t// per-stack runtime-dir; `seal` is plugin-blind from the\n\t\t// orchestrator's POV (just a path segment).\n\t\tsubtrees: [`seal`],\n\t\tmanagedContainers: [labelTuple],\n\t\t// The key-server's Docker stop grace is owned by key-server.ts.\n\t\tquiesce: Effect.void,\n\t\tpreRestore: Effect.succeed({\n\t\t\tkind: 'seal' as const,\n\t\t\tname: inputs.name,\n\t\t}),\n\t\tpostRestore: Effect.void,\n\t\tmissingTolerance: 'fatal',\n\t\t// Distilled-doc §Hard requirements #2 + #4: master-key.env is\n\t\t// secret material (0o600). The substrate's tar handler\n\t\t// preserves the mode bits on round-trip.\n\t\tsecretMaterial: true,\n\t};\n};\n\n/** Build the Snapshotable contribution for the known-deployment\n *  modes (live / fork-known). No managed container, no on-disk\n *  state — we only need the orchestrator to see the plugin's\n *  identity for the manifest sidecar.\n *\n *  `missingTolerance: 'fine'` because the known-deployment mode\n *  has no host-side state to lose. */\nexport const makeKnownSnapshotable = (inputs: { readonly name: string }): SnapshotableDecl => ({\n\tkind: 'snapshotable',\n\tsubtrees: [],\n\tmissingTolerance: 'fine',\n\tpreRestore: Effect.succeed({ kind: 'seal' as const, name: inputs.name }),\n\tpostRestore: Effect.void,\n\tsecretMaterial: false,\n});\n"],"mappings":";;;;;;;;;AAiCA,MAAa,+BAA+B,WAIpB;AAOvB,QAAO;EACN,MAAM;EAIN,UAAU,CAAC,OAAO;EAClB,mBAAmB,CAAC;GAXpB,KAAK,OAAO;GACZ,OAAO,OAAO;GACd,QAAQ;GACR,MAAM;GAQwB,CAAC;EAE/B,SAAS,OAAO;EAChB,YAAY,OAAO,QAAQ;GAC1B,MAAM;GACN,MAAM,OAAO;GACb,CAAC;EACF,aAAa,OAAO;EACpB,kBAAkB;EAIlB,gBAAgB;EAChB;;;;;;;;;AAUF,MAAa,yBAAyB,YAAyD;CAC9F,MAAM;CACN,UAAU,EAAE;CACZ,kBAAkB;CAClB,YAAY,OAAO,QAAQ;EAAE,MAAM;EAAiB,MAAM,OAAO;EAAM,CAAC;CACxE,aAAa,OAAO;CACpB,gBAAgB;CAChB"}

package/dist/plugins/sui/auto-tick.mjs

@@ -0,0 +1,45 @@
+import { SpanAttr } from "../../substrate/runtime/observability/spans.mjs";
+import { expectPositiveFiniteNumber } from "../../substrate/runtime/config-validation.mjs";
+import { suiConfigError } from "./errors.mjs";
+import { Effect, Schedule } from "effect";
+//#region src/plugins/sui/auto-tick.ts
+/** Default cadence when caller passes `autoTick: true`. */
+const DEFAULT_AUTO_TICK_INTERVAL_MS = 1e3;
+/** Resolve the public option to a numeric interval. Returns
+*  `undefined` when auto-tick is OFF. Throws on a misconfigured
+*  option (0 / negative / non-finite) — the substrate's
+*  acquire-time validation catches this before any I/O. */
+const resolveAutoTickIntervalMs = (option) => {
+	if (option === void 0 || option === false) return void 0;
+	if (option === true) return DEFAULT_AUTO_TICK_INTERVAL_MS;
+	return expectPositiveFiniteNumber(option.intervalMs, {
+		field: "autoTick.intervalMs",
+		message: `sui: autoTick.intervalMs must be a positive finite number (got ${String(option.intervalMs)})`,
+		mkError: suiConfigError
+	});
+};
+/**
+* Fork a scope-bound fiber that calls `advanceClock(intervalMs)` on
+* a `Schedule.spaced(intervalMs)` cadence. The fiber dies on the
+* surrounding scope's close (wipe / restart / Ctrl-C).
+*
+* Returns the fiber handle. Today's code discards the handle — the
+* distilled doc flags a designed-for-but-not-landed re-config path
+* (`engine/sui-fork/control.ts` opportunity). We keep the handle
+* returned so a future cadence-change surface has a join point.
+*/
+const runAutoTickClock = (advancer, intervalMs) => Effect.gen(function* () {
+	return yield* advancer.advanceClock(intervalMs).pipe(Effect.catch((err) => Effect.logWarning("sui auto-tick advance failed; next tick will retry").pipe(Effect.annotateLogs({
+		[SpanAttr.suiAutoTickIntervalMs]: intervalMs,
+		[SpanAttr.phase]: err.phase,
+		[SpanAttr.errorMessage]: err.message
+	})))).pipe(Effect.repeat(Schedule.spaced(`${intervalMs} millis`)), Effect.forkScoped);
+});
+/** Build a no-op advancer for local mode. Localnet's validator
+*  drives consensus on its own; the auto-tick fiber surface exists
+*  for symmetry but doesn't have anything to advance. */
+const noopClockAdvancer = { advanceClock: () => Effect.void };
+//#endregion
+export { noopClockAdvancer, resolveAutoTickIntervalMs, runAutoTickClock };
+
+//# sourceMappingURL=auto-tick.mjs.map

package/dist/plugins/sui/auto-tick.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-tick.mjs","names":[],"sources":["../../../src/plugins/sui/auto-tick.ts"],"sourcesContent":["// Auto-tick clock — local-mode-only.\n//\n// Architecture invariant: \"Auto-tick is local-mode-only\" — the\n// public option is exposed only on fork (where it advances the\n// fork binary's clock + checkpoint) AND local (where it nudges\n// localnet's consensus to commit pending txs in tests that don't\n// produce traffic).\n//\n// The fiber is `forkScoped` against the plugin's acquire scope:\n// teardown happens automatically on wipe/restart/Ctrl-C. Failure\n// policy is **log-warn-and-continue** — a single advance-clock\n// RPC failure must not break the supervisor.\n\nimport { Effect, Schedule, type Fiber, type Scope } from 'effect';\n\nimport { expectPositiveFiniteNumber } from '../../substrate/runtime/config-validation.ts';\nimport { SpanAttr } from '../../substrate/runtime/observability/spans.ts';\nimport { suiConfigError } from './errors.ts';\nimport type { SuiPluginError } from './errors.ts';\n\n/** Public knob shape mirroring the user-facing API. */\nexport type AutoTickOption = boolean | { readonly intervalMs: number };\n\n/** Default cadence when caller passes `autoTick: true`. */\nexport const DEFAULT_AUTO_TICK_INTERVAL_MS = 1000;\n\n/** Resolve the public option to a numeric interval. Returns\n *  `undefined` when auto-tick is OFF. Throws on a misconfigured\n *  option (0 / negative / non-finite) — the substrate's\n *  acquire-time validation catches this before any I/O. */\nexport const resolveAutoTickIntervalMs = (option?: AutoTickOption): number | undefined => {\n\tif (option === undefined || option === false) return undefined;\n\tif (option === true) return DEFAULT_AUTO_TICK_INTERVAL_MS;\n\treturn expectPositiveFiniteNumber(option.intervalMs, {\n\t\tfield: 'autoTick.intervalMs',\n\t\tmessage: `sui: autoTick.intervalMs must be a positive finite number (got ${String(\n\t\t\toption.intervalMs,\n\t\t)})`,\n\t\tmkError: suiConfigError,\n\t});\n};\n\n/** Plugin-internal shim — the minimal admin surface the auto-tick\n *  fiber needs. Local-mode wires this to a no-op (localnet's\n *  validator advances its own clock); fork-mode wires it to the\n *  `ForkingService.advanceClock` gRPC method. Stub: the concrete\n *  gRPC binding lands when the Mysten Sui SDK is introduced. */\nexport interface ClockAdvancer {\n\treadonly advanceClock: (intervalMs: number) => Effect.Effect<void, SuiPluginError>;\n}\n\n/**\n * Fork a scope-bound fiber that calls `advanceClock(intervalMs)` on\n * a `Schedule.spaced(intervalMs)` cadence. The fiber dies on the\n * surrounding scope's close (wipe / restart / Ctrl-C).\n *\n * Returns the fiber handle. Today's code discards the handle — the\n * distilled doc flags a designed-for-but-not-landed re-config path\n * (`engine/sui-fork/control.ts` opportunity). We keep the handle\n * returned so a future cadence-change surface has a join point.\n */\nexport const runAutoTickClock = (\n\tadvancer: ClockAdvancer,\n\tintervalMs: number,\n): Effect.Effect<Fiber.Fiber<void>, never, Scope.Scope> =>\n\tEffect.gen(function* () {\n\t\tconst tick = advancer.advanceClock(intervalMs).pipe(\n\t\t\tEffect.catch((err) =>\n\t\t\t\tEffect.logWarning('sui auto-tick advance failed; next tick will retry').pipe(\n\t\t\t\t\tEffect.annotateLogs({\n\t\t\t\t\t\t[SpanAttr.suiAutoTickIntervalMs]: intervalMs,\n\t\t\t\t\t\t[SpanAttr.phase]: err.phase,\n\t\t\t\t\t\t[SpanAttr.errorMessage]: err.message,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t),\n\t\t);\n\t\tconst fiber = yield* tick.pipe(\n\t\t\tEffect.repeat(Schedule.spaced(`${intervalMs} millis`)),\n\t\t\tEffect.forkScoped,\n\t\t);\n\t\treturn fiber as Fiber.Fiber<void>;\n\t});\n\n/** Build a no-op advancer for local mode. Localnet's validator\n *  drives consensus on its own; the auto-tick fiber surface exists\n *  for symmetry but doesn't have anything to advance. */\nexport const noopClockAdvancer: ClockAdvancer = {\n\tadvanceClock: () => Effect.void as Effect.Effect<void, SuiPluginError>,\n};\n"],"mappings":";;;;;;AAwBA,MAAa,gCAAgC;;;;;AAM7C,MAAa,6BAA6B,WAAgD;AACzF,KAAI,WAAW,KAAA,KAAa,WAAW,MAAO,QAAO,KAAA;AACrD,KAAI,WAAW,KAAM,QAAO;AAC5B,QAAO,2BAA2B,OAAO,YAAY;EACpD,OAAO;EACP,SAAS,kEAAkE,OAC1E,OAAO,WACP,CAAC;EACF,SAAS;EACT,CAAC;;;;;;;;;;;;AAsBH,MAAa,oBACZ,UACA,eAEA,OAAO,IAAI,aAAa;AAgBvB,QAAO,OAfM,SAAS,aAAa,WAAW,CAAC,KAC9C,OAAO,OAAO,QACb,OAAO,WAAW,qDAAqD,CAAC,KACvE,OAAO,aAAa;GAClB,SAAS,wBAAwB;GACjC,SAAS,QAAQ,IAAI;GACrB,SAAS,eAAe,IAAI;EAC7B,CAAC,CACF,CACD,CAEuB,CAAC,KACzB,OAAO,OAAO,SAAS,OAAO,GAAG,WAAW,SAAS,CAAC,EACtD,OAAO,WACP;EAEA;;;;AAKH,MAAa,oBAAmC,EAC/C,oBAAoB,OAAO,MAC3B"}

package/dist/plugins/sui/chain-build-container.d.mts

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

package/dist/plugins/sui/chain-probe.d.mts

@@ -0,0 +1,85 @@
+import { Schema } from "effect";
+
+//#region src/plugins/sui/chain-probe.d.ts
+/**
+ * Sui's chain-key shape — discriminated so the probe can dispatch
+ * between object reads, tx reads, and the (forthcoming) batch
+ * variant on one method.
+ */
+type SuiProbeKey = {
+  readonly kind: 'object';
+  readonly objectId: string;
+} | {
+  readonly kind: 'transaction';
+  readonly digest: string;
+};
+/** Plugin-internal SDK shim — the type the plugin's acquire body
+ *  hands to the probe factory + the account's sign/execute closure.
+ *  Kept narrow so we don't pull `@mysten/sui` types into the substrate.
+ *
+ *  Exposes the four surfaces consumers actually use:
+ *
+ *    - `getObject` / `getTransaction` — the lenient chain probe.
+ *    - `executeTransaction` — the account plugin's submit path
+ *      (txBytes + caller-signed signatures).
+ *    - `waitForTransaction` — post-submit finality wait.
+ *
+ *  Plus an OPAQUE `client` field — the underlying `SuiGrpcClient`
+ *  reference. The package plugin's publish-tx builder hands this to
+ *  `Transaction.build({ client })` (the SDK resolves gas + object
+ *  versions through it). We type as `unknown` so the substrate stays
+ *  free of a direct `@mysten/sui/client` type import; the consumer
+ *  casts at the boundary (mirrors the same opacity decision in the
+ *  Coin plugin's `MintSdkShim.client`). */
+interface SuiSdkShim {
+  readonly core: {
+    readonly getObject: (args: {
+      readonly objectId: string;
+      readonly include?: {
+        readonly content?: boolean;
+        readonly json?: boolean;
+      };
+    }) => Promise<unknown>;
+    readonly getTransaction: (args: {
+      readonly digest: string;
+    }) => Promise<unknown>;
+    readonly getBalance: (args: {
+      readonly owner: string;
+      readonly coinType?: string;
+    }) => Promise<unknown>;
+    readonly listCoins: (args: {
+      readonly owner: string;
+      readonly coinType?: string;
+      readonly limit?: number;
+      readonly cursor?: string | null;
+    }) => Promise<{
+      readonly objects: ReadonlyArray<{
+        readonly objectId: string;
+        readonly version: string;
+        readonly digest: string;
+        readonly balance: string;
+      }>;
+      readonly hasNextPage: boolean;
+      readonly cursor: string | null;
+    }>;
+    readonly executeTransaction: (args: {
+      readonly transaction: Uint8Array;
+      readonly signatures: ReadonlyArray<string>;
+      readonly include?: {
+        readonly effects?: boolean;
+        readonly objectTypes?: boolean;
+      };
+    }) => Promise<unknown>;
+    readonly waitForTransaction: (args: {
+      readonly digest: string;
+      readonly timeout?: number;
+    }) => Promise<unknown>;
+  };
+  /** Opaque client reference for `Transaction.build({ client })`.
+   *  The Sui barrel wires the resolved `SuiGrpcClient` through; the
+   *  shim layer doesn't type-narrow it (mirrors `MintSdkShim.client`). */
+  readonly client: unknown;
+}
+//#endregion
+export { SuiProbeKey, SuiSdkShim };
+//# sourceMappingURL=chain-probe.d.mts.map

package/dist/plugins/sui/chain-probe.mjs

@@ -0,0 +1,104 @@
+import { decodeUnknown } from "../../substrate/runtime/runtime-decode.mjs";
+import { Effect, Schema } from "effect";
+//#region src/plugins/sui/chain-probe.ts
+/** Validated subset of `client.core.getObject(...).object`. We
+*  narrow to the fields verify probes actually consult — the SDK
+*  exposes more (digest, content, json, display) but those are
+*  out of scope here. */
+const ObjectOwnerSchema = Schema.Union([
+	Schema.Struct({
+		$kind: Schema.Literal("AddressOwner"),
+		AddressOwner: Schema.String
+	}),
+	Schema.Struct({
+		$kind: Schema.Literal("Shared"),
+		Shared: Schema.Struct({ initialSharedVersion: Schema.String })
+	}),
+	Schema.Struct({
+		$kind: Schema.Literal("Immutable"),
+		Immutable: Schema.Literal(true)
+	}),
+	Schema.Struct({
+		$kind: Schema.Literal("ConsensusAddressOwner"),
+		ConsensusAddressOwner: Schema.Unknown
+	}),
+	Schema.Struct({
+		$kind: Schema.Literal("Parent"),
+		Parent: Schema.Unknown
+	}),
+	Schema.Struct({
+		$kind: Schema.Literal("Unknown"),
+		Unknown: Schema.Unknown
+	})
+]);
+/** Validated SDK response shape: `{ object: { objectId, type, ... } }`.
+*  Substrate-redesign note: today's code validates `version` as a
+*  string but it's semantically a bigint — branded type recommendation
+*  carried in the Opportunities section. */
+const SuiObjectShapeSchema = Schema.Struct({
+	objectId: Schema.String,
+	type: Schema.String,
+	version: Schema.String,
+	owner: ObjectOwnerSchema
+});
+Schema.Struct({ object: SuiObjectShapeSchema });
+/** Construct the chain-probe instance for a resolved Sui client +
+*  chain id. The result implements the contract's `ChainProbe<Key>`
+*  shape; the Sui plugin emits this via a StrategyContributorDecl
+*  keyed by `chain-probe:<chainId>`. */
+const makeSuiChainProbe = (sdk, chain) => ({ get: (key, schema, mode) => Effect.gen(function* () {
+	const raw = yield* Effect.tryPromise({
+		try: () => key.kind === "object" ? sdk.core.getObject({ objectId: key.objectId }) : sdk.core.getTransaction({ digest: key.digest }),
+		catch: (cause) => ({
+			_tag: "ChainProbeError",
+			reason: isNotFound(cause) ? "not-found" : "transient",
+			chain,
+			detail: stringifyCause(cause)
+		})
+	}).pipe(Effect.catch((err) => mode === "lenient" && (err.reason === "not-found" || err.reason === "transient") ? Effect.succeed(null) : Effect.fail(err)));
+	if (raw === null) return null;
+	const payload = projectProbePayload(key, raw);
+	if (payload === null) return null;
+	return yield* decodeUnknown(schema, payload, {
+		source: `chain probe ${chain}`,
+		mkError: (issue) => ({
+			_tag: "ChainProbeError",
+			reason: "decode-failed",
+			chain,
+			detail: stringifyCause(issue.cause ?? issue)
+		})
+	});
+}) });
+const projectProbePayload = (key, raw) => {
+	if (key.kind === "transaction") return projectTransactionPayload(raw);
+	if (typeof raw !== "object" || raw === null || !("object" in raw)) return raw;
+	return raw.object ?? null;
+};
+const projectTransactionPayload = (raw) => {
+	if (typeof raw !== "object" || raw === null) return raw;
+	const envelope = raw;
+	if (envelope.$kind === "Transaction") return envelope.Transaction ?? null;
+	if (envelope.$kind === "FailedTransaction") return envelope.FailedTransaction ?? null;
+	return raw;
+};
+/** Heuristic: SDK errors carrying "not found" / "Not exist" in
+*  the message are treated as not-found; everything else is
+*  transient. The substrate's lenient-retry profile re-runs the
+*  probe on a transient bucket; not-found is terminal. */
+const isNotFound = (cause) => {
+	const msg = cause?.message?.toLowerCase() ?? "";
+	return msg.includes("not found") || msg.includes("does not exist") || msg.includes("no such object") || msg.includes("not exist");
+};
+const stringifyCause = (cause) => {
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "string") return cause;
+	try {
+		return JSON.stringify(cause);
+	} catch {
+		return String(cause);
+	}
+};
+//#endregion
+export { makeSuiChainProbe };
+
+//# sourceMappingURL=chain-probe.mjs.map

package/dist/plugins/sui/chain-probe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-probe.mjs","names":[],"sources":["../../../src/plugins/sui/chain-probe.ts"],"sourcesContent":["// Sui plugin — ChainProbe capability implementation.\n//\n// Architecture §9: ChainProbe is a contract, NOT a primitive. Sui\n// provides the only in-tree implementation; the substrate dispatches\n// to it via the StrategyContributor registry under\n// `chain-probe:<chainId>`.\n//\n// Lenient mode: returns null for both \"not found\" AND transient RPC\n// failure — verify pipelines re-derive on the next cycle rather than\n// fail boot. Strict mode: distinguishes via tagged error.\n//\n// Why lenient is the default in this plugin's wiring: artifact publisher verify is\n// the dominant consumer; artifact publisher's lenient-retry profile (15 attempts,\n// 90s budget) is calibrated against lenient semantics. A strict\n// surface exists for explicit \"I want to know if the chain is\n// reachable\" callers (the doctor command, debugging).\n\nimport { Effect, Schema } from 'effect';\n\nimport type {\n\tChainProbe,\n\tChainProbeError,\n\tChainProbeMode,\n\tChainProbeSchema,\n} from '../../contracts/chain-probe.ts';\nimport { decodeUnknown } from '../../substrate/runtime/runtime-decode.ts';\n\n/**\n * Sui's chain-key shape — discriminated so the probe can dispatch\n * between object reads, tx reads, and the (forthcoming) batch\n * variant on one method.\n */\nexport type SuiProbeKey =\n\t| { readonly kind: 'object'; readonly objectId: string }\n\t| { readonly kind: 'transaction'; readonly digest: string };\n\n/** Validated subset of `client.core.getObject(...).object`. We\n *  narrow to the fields verify probes actually consult — the SDK\n *  exposes more (digest, content, json, display) but those are\n *  out of scope here. */\nconst ObjectOwnerSchema = Schema.Union([\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('AddressOwner'),\n\t\tAddressOwner: Schema.String,\n\t}),\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('Shared'),\n\t\tShared: Schema.Struct({ initialSharedVersion: Schema.String }),\n\t}),\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('Immutable'),\n\t\tImmutable: Schema.Literal(true),\n\t}),\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('ConsensusAddressOwner'),\n\t\tConsensusAddressOwner: Schema.Unknown,\n\t}),\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('Parent'),\n\t\tParent: Schema.Unknown,\n\t}),\n\tSchema.Struct({\n\t\t$kind: Schema.Literal('Unknown'),\n\t\tUnknown: Schema.Unknown,\n\t}),\n]);\n\n/** Validated SDK response shape: `{ object: { objectId, type, ... } }`.\n *  Substrate-redesign note: today's code validates `version` as a\n *  string but it's semantically a bigint — branded type recommendation\n *  carried in the Opportunities section. */\nexport const SuiObjectShapeSchema = Schema.Struct({\n\tobjectId: Schema.String,\n\ttype: Schema.String,\n\tversion: Schema.String,\n\towner: ObjectOwnerSchema,\n});\n\nexport const SuiGetObjectResponseSchema = Schema.Struct({\n\tobject: SuiObjectShapeSchema,\n});\n\n/** Plugin-internal SDK shim — the type the plugin's acquire body\n *  hands to the probe factory + the account's sign/execute closure.\n *  Kept narrow so we don't pull `@mysten/sui` types into the substrate.\n *\n *  Exposes the four surfaces consumers actually use:\n *\n *    - `getObject` / `getTransaction` — the lenient chain probe.\n *    - `executeTransaction` — the account plugin's submit path\n *      (txBytes + caller-signed signatures).\n *    - `waitForTransaction` — post-submit finality wait.\n *\n *  Plus an OPAQUE `client` field — the underlying `SuiGrpcClient`\n *  reference. The package plugin's publish-tx builder hands this to\n *  `Transaction.build({ client })` (the SDK resolves gas + object\n *  versions through it). We type as `unknown` so the substrate stays\n *  free of a direct `@mysten/sui/client` type import; the consumer\n *  casts at the boundary (mirrors the same opacity decision in the\n *  Coin plugin's `MintSdkShim.client`). */\nexport interface SuiSdkShim {\n\treadonly core: {\n\t\treadonly getObject: (args: {\n\t\t\treadonly objectId: string;\n\t\t\treadonly include?: {\n\t\t\t\treadonly content?: boolean;\n\t\t\t\treadonly json?: boolean;\n\t\t\t};\n\t\t}) => Promise<unknown>;\n\t\treadonly getTransaction: (args: { readonly digest: string }) => Promise<unknown>;\n\t\treadonly getBalance: (args: {\n\t\t\treadonly owner: string;\n\t\t\treadonly coinType?: string;\n\t\t}) => Promise<unknown>;\n\t\treadonly listCoins: (args: {\n\t\t\treadonly owner: string;\n\t\t\treadonly coinType?: string;\n\t\t\treadonly limit?: number;\n\t\t\treadonly cursor?: string | null;\n\t\t}) => Promise<{\n\t\t\treadonly objects: ReadonlyArray<{\n\t\t\t\treadonly objectId: string;\n\t\t\t\treadonly version: string;\n\t\t\t\treadonly digest: string;\n\t\t\t\treadonly balance: string;\n\t\t\t}>;\n\t\t\treadonly hasNextPage: boolean;\n\t\t\treadonly cursor: string | null;\n\t\t}>;\n\t\treadonly executeTransaction: (args: {\n\t\t\treadonly transaction: Uint8Array;\n\t\t\treadonly signatures: ReadonlyArray<string>;\n\t\t\treadonly include?: {\n\t\t\t\treadonly effects?: boolean;\n\t\t\t\treadonly objectTypes?: boolean;\n\t\t\t};\n\t\t}) => Promise<unknown>;\n\t\treadonly waitForTransaction: (args: {\n\t\t\treadonly digest: string;\n\t\t\treadonly timeout?: number;\n\t\t}) => Promise<unknown>;\n\t};\n\t/** Opaque client reference for `Transaction.build({ client })`.\n\t *  The Sui barrel wires the resolved `SuiGrpcClient` through; the\n\t *  shim layer doesn't type-narrow it (mirrors `MintSdkShim.client`). */\n\treadonly client: unknown;\n}\n\n/** Construct the chain-probe instance for a resolved Sui client +\n *  chain id. The result implements the contract's `ChainProbe<Key>`\n *  shape; the Sui plugin emits this via a StrategyContributorDecl\n *  keyed by `chain-probe:<chainId>`. */\nexport const makeSuiChainProbe = (sdk: SuiSdkShim, chain: string): ChainProbe<SuiProbeKey> => ({\n\tget: <Shape>(\n\t\tkey: SuiProbeKey,\n\t\tschema: ChainProbeSchema<Shape>,\n\t\tmode: ChainProbeMode,\n\t): Effect.Effect<Shape | null, ChainProbeError> =>\n\t\tEffect.gen(function* () {\n\t\t\tconst raw: unknown = yield* Effect.tryPromise({\n\t\t\t\ttry: () =>\n\t\t\t\t\tkey.kind === 'object'\n\t\t\t\t\t\t? sdk.core.getObject({ objectId: key.objectId })\n\t\t\t\t\t\t: sdk.core.getTransaction({ digest: key.digest }),\n\t\t\t\tcatch: (cause): ChainProbeError => ({\n\t\t\t\t\t_tag: 'ChainProbeError',\n\t\t\t\t\treason: isNotFound(cause) ? 'not-found' : 'transient',\n\t\t\t\t\tchain,\n\t\t\t\t\tdetail: stringifyCause(cause),\n\t\t\t\t}),\n\t\t\t}).pipe(\n\t\t\t\t// Lenient mode coerces both not-found and transient into a\n\t\t\t\t// null result. Strict mode lets the error propagate.\n\t\t\t\tEffect.catch(\n\t\t\t\t\t(err): Effect.Effect<unknown, ChainProbeError> =>\n\t\t\t\t\t\tmode === 'lenient' && (err.reason === 'not-found' || err.reason === 'transient')\n\t\t\t\t\t\t\t? Effect.succeed(null)\n\t\t\t\t\t\t\t: Effect.fail(err),\n\t\t\t\t),\n\t\t\t);\n\t\t\tif (raw === null) return null;\n\t\t\tconst payload = projectProbePayload(key, raw);\n\t\t\tif (payload === null) return null;\n\n\t\t\t// Decode against the caller-supplied Schema. A decode failure\n\t\t\t// is structured (NOT silent undefined) — this is the\n\t\t\t// load-bearing learning from deepbook.\n\t\t\tconst decoded = yield* decodeUnknown(schema, payload, {\n\t\t\t\tsource: `chain probe ${chain}`,\n\t\t\t\tmkError: (issue): ChainProbeError => ({\n\t\t\t\t\t_tag: 'ChainProbeError',\n\t\t\t\t\treason: 'decode-failed',\n\t\t\t\t\tchain,\n\t\t\t\t\tdetail: stringifyCause(issue.cause ?? issue),\n\t\t\t\t}),\n\t\t\t});\n\t\t\treturn decoded;\n\t\t}),\n});\n\nconst projectProbePayload = (key: SuiProbeKey, raw: unknown): unknown | null => {\n\tif (key.kind === 'transaction') return projectTransactionPayload(raw);\n\tif (typeof raw !== 'object' || raw === null || !('object' in raw)) return raw;\n\n\treturn (raw as { readonly object?: unknown }).object ?? null;\n};\n\nconst projectTransactionPayload = (raw: unknown): unknown | null => {\n\tif (typeof raw !== 'object' || raw === null) return raw;\n\tconst envelope = raw as {\n\t\treadonly $kind?: 'Transaction' | 'FailedTransaction';\n\t\treadonly Transaction?: unknown;\n\t\treadonly FailedTransaction?: unknown;\n\t};\n\tif (envelope.$kind === 'Transaction') return envelope.Transaction ?? null;\n\tif (envelope.$kind === 'FailedTransaction') return envelope.FailedTransaction ?? null;\n\treturn raw;\n};\n\n/** Heuristic: SDK errors carrying \"not found\" / \"Not exist\" in\n *  the message are treated as not-found; everything else is\n *  transient. The substrate's lenient-retry profile re-runs the\n *  probe on a transient bucket; not-found is terminal. */\nconst isNotFound = (cause: unknown): boolean => {\n\tconst msg = (cause as { message?: string })?.message?.toLowerCase() ?? '';\n\treturn (\n\t\tmsg.includes('not found') ||\n\t\tmsg.includes('does not exist') ||\n\t\tmsg.includes('no such object') ||\n\t\tmsg.includes('not exist')\n\t);\n};\n\nconst stringifyCause = (cause: unknown): string => {\n\tif (cause instanceof Error) return cause.message;\n\tif (typeof cause === 'string') return cause;\n\ttry {\n\t\treturn JSON.stringify(cause);\n\t} catch {\n\t\treturn String(cause);\n\t}\n};\n"],"mappings":";;;;;;;AAwCA,MAAM,oBAAoB,OAAO,MAAM;CACtC,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,eAAe;EACrC,cAAc,OAAO;EACrB,CAAC;CACF,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,SAAS;EAC/B,QAAQ,OAAO,OAAO,EAAE,sBAAsB,OAAO,QAAQ,CAAC;EAC9D,CAAC;CACF,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,YAAY;EAClC,WAAW,OAAO,QAAQ,KAAK;EAC/B,CAAC;CACF,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,wBAAwB;EAC9C,uBAAuB,OAAO;EAC9B,CAAC;CACF,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,SAAS;EAC/B,QAAQ,OAAO;EACf,CAAC;CACF,OAAO,OAAO;EACb,OAAO,OAAO,QAAQ,UAAU;EAChC,SAAS,OAAO;EAChB,CAAC;CACF,CAAC;;;;;AAMF,MAAa,uBAAuB,OAAO,OAAO;CACjD,UAAU,OAAO;CACjB,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,OAAO;CACP,CAAC;AAEwC,OAAO,OAAO,EACvD,QAAQ,sBACR,CAAC;;;;;AAwEF,MAAa,qBAAqB,KAAiB,WAA4C,EAC9F,MACC,KACA,QACA,SAEA,OAAO,IAAI,aAAa;CACvB,MAAM,MAAe,OAAO,OAAO,WAAW;EAC7C,WACC,IAAI,SAAS,WACV,IAAI,KAAK,UAAU,EAAE,UAAU,IAAI,UAAU,CAAC,GAC9C,IAAI,KAAK,eAAe,EAAE,QAAQ,IAAI,QAAQ,CAAC;EACnD,QAAQ,WAA4B;GACnC,MAAM;GACN,QAAQ,WAAW,MAAM,GAAG,cAAc;GAC1C;GACA,QAAQ,eAAe,MAAM;GAC7B;EACD,CAAC,CAAC,KAGF,OAAO,OACL,QACA,SAAS,cAAc,IAAI,WAAW,eAAe,IAAI,WAAW,eACjE,OAAO,QAAQ,KAAK,GACpB,OAAO,KAAK,IAAI,CACpB,CACD;AACD,KAAI,QAAQ,KAAM,QAAO;CACzB,MAAM,UAAU,oBAAoB,KAAK,IAAI;AAC7C,KAAI,YAAY,KAAM,QAAO;AAc7B,QAAO,OATgB,cAAc,QAAQ,SAAS;EACrD,QAAQ,eAAe;EACvB,UAAU,WAA4B;GACrC,MAAM;GACN,QAAQ;GACR;GACA,QAAQ,eAAe,MAAM,SAAS,MAAM;GAC5C;EACD,CAAC;EAED,EACH;AAED,MAAM,uBAAuB,KAAkB,QAAiC;AAC/E,KAAI,IAAI,SAAS,cAAe,QAAO,0BAA0B,IAAI;AACrE,KAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,EAAE,YAAY,KAAM,QAAO;AAE1E,QAAQ,IAAsC,UAAU;;AAGzD,MAAM,6BAA6B,QAAiC;AACnE,KAAI,OAAO,QAAQ,YAAY,QAAQ,KAAM,QAAO;CACpD,MAAM,WAAW;AAKjB,KAAI,SAAS,UAAU,cAAe,QAAO,SAAS,eAAe;AACrE,KAAI,SAAS,UAAU,oBAAqB,QAAO,SAAS,qBAAqB;AACjF,QAAO;;;;;;AAOR,MAAM,cAAc,UAA4B;CAC/C,MAAM,MAAO,OAAgC,SAAS,aAAa,IAAI;AACvE,QACC,IAAI,SAAS,YAAY,IACzB,IAAI,SAAS,iBAAiB,IAC9B,IAAI,SAAS,iBAAiB,IAC9B,IAAI,SAAS,YAAY;;AAI3B,MAAM,kBAAkB,UAA2B;AAClD,KAAI,iBAAiB,MAAO,QAAO,MAAM;AACzC,KAAI,OAAO,UAAU,SAAU,QAAO;AACtC,KAAI;AACH,SAAO,KAAK,UAAU,MAAM;SACrB;AACP,SAAO,OAAO,MAAM"}

package/dist/plugins/sui/codegen.d.mts

@@ -0,0 +1,14 @@
+//#region src/plugins/sui/codegen.d.ts
+/** The typed shape the emitted file exports. */
+interface SuiNetworkBindings {
+  readonly chain: string;
+  readonly mode: 'local' | 'local-rpc' | 'live' | 'fork';
+  readonly rpcUrl: string;
+  readonly faucetUrl: string | null;
+  readonly graphqlUrl: string | null;
+  /** Fork-only — upstream identity for known-package lookups. */
+  readonly forkUpstream: string | null;
+}
+//#endregion
+export { SuiNetworkBindings };
+//# sourceMappingURL=codegen.d.mts.map

package/dist/plugins/sui/codegen.mjs

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+//#region src/plugins/sui/codegen.ts
+/** Construct the Codegenable contribution. Emit is byte-deterministic
+*  on unchanged input (architecture: no mtime churn on no-op
+*  cycles). */
+const makeCodegenable = (resolved) => ({
+	kind: "codegenable",
+	emitterName: "sui-network",
+	outputPath: "sui/network.ts",
+	emit: (ctx) => Effect.sync(() => {
+		const bindings = {
+			chain: resolved.chain,
+			mode: resolved.mode,
+			rpcUrl: resolved.rpc,
+			faucetUrl: resolved.faucet ?? null,
+			graphqlUrl: resolved.graphql ?? null,
+			forkUpstream: resolved.forkUpstream ?? null
+		};
+		ctx.exportConst("suiNetwork", bindings);
+		return ctx.done();
+	})
+});
+//#endregion
+export { makeCodegenable };
+
+//# sourceMappingURL=codegen.mjs.map

package/dist/plugins/sui/codegen.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.mjs","names":[],"sources":["../../../src/plugins/sui/codegen.ts"],"sourcesContent":["// Sui plugin — Codegenable contribution.\n//\n// Architecture §6: plugins emit typed `CodegenableDecl`s; the\n// codegen orchestrator stages files into the user's source tree\n// WITHOUT naming the plugin. Sui's contribution is network\n// metadata: the active RPC endpoint, the chain id, and (when\n// applicable) the resolved known-package ids.\n//\n// Downstream consumers — chain-aware code (e.g. SDK boots, wallet\n// pickers, frontend RPC selectors) — `import { suiNetwork } from\n// '<staging>/sui/network'`; the generated module owns that exported\n// value's type.\n\nimport { Effect } from 'effect';\n\nimport type { CodegenableDecl } from '../../contracts/codegenable.ts';\nimport type { ResolvedSuiNetwork } from './network-resolver.ts';\n\n/** The typed shape the emitted file exports. */\nexport interface SuiNetworkBindings {\n\treadonly chain: string;\n\treadonly mode: 'local' | 'local-rpc' | 'live' | 'fork';\n\treadonly rpcUrl: string;\n\treadonly faucetUrl: string | null;\n\treadonly graphqlUrl: string | null;\n\t/** Fork-only — upstream identity for known-package lookups. */\n\treadonly forkUpstream: string | null;\n}\n\n/** Construct the Codegenable contribution. Emit is byte-deterministic\n *  on unchanged input (architecture: no mtime churn on no-op\n *  cycles). */\nexport const makeCodegenable = (resolved: ResolvedSuiNetwork): CodegenableDecl<'sui-network'> => ({\n\tkind: 'codegenable',\n\temitterName: 'sui-network',\n\toutputPath: 'sui/network.ts',\n\temit: (ctx) =>\n\t\tEffect.sync(() => {\n\t\t\tconst bindings: SuiNetworkBindings = {\n\t\t\t\tchain: resolved.chain,\n\t\t\t\tmode: resolved.mode,\n\t\t\t\trpcUrl: resolved.rpc,\n\t\t\t\tfaucetUrl: resolved.faucet ?? null,\n\t\t\t\tgraphqlUrl: resolved.graphql ?? null,\n\t\t\t\tforkUpstream: resolved.forkUpstream ?? null,\n\t\t\t};\n\t\t\tctx.exportConst('suiNetwork', bindings);\n\t\t\treturn ctx.done();\n\t\t}),\n});\n"],"mappings":";;;;;AAgCA,MAAa,mBAAmB,cAAkE;CACjG,MAAM;CACN,aAAa;CACb,YAAY;CACZ,OAAO,QACN,OAAO,WAAW;EACjB,MAAM,WAA+B;GACpC,OAAO,SAAS;GAChB,MAAM,SAAS;GACf,QAAQ,SAAS;GACjB,WAAW,SAAS,UAAU;GAC9B,YAAY,SAAS,WAAW;GAChC,cAAc,SAAS,gBAAgB;GACvC;AACD,MAAI,YAAY,cAAc,SAAS;AACvC,SAAO,IAAI,MAAM;GAChB;CACH"}

package/dist/plugins/sui/errors.d.mts

@@ -0,0 +1,74 @@
+import { ConfigIssue } from "../../substrate/runtime/config-validation.mjs";
+
+//#region src/plugins/sui/errors.d.ts
+/** Phases for `SuiError`. Closed sum — keeps the cause-walker's
+ *  display table small. Add a phase only after editing the
+ *  catalog in the plugin doc. */
+type SuiPhase = 'image-build' | 'port-allocate' | 'container-start' | 'rpc-probe' | 'faucet-probe' | 'graphql-probe' | 'fork-status-probe' | 'chain-id-fetch' | 'wait-funds-ready' | 'fork-impersonate' | 'fork-advance-clock' | 'fork-advance-checkpoint' | 'fork-lock' | 'fork-data-dir' | 'move-build' | 'move-publish';
+/** Generic Sui plugin error. Raised by the plugin's acquire body
+ *  and its admin surface (`advanceClock`, `impersonate`, …). */
+interface SuiPluginError {
+  readonly _tag: 'SuiPluginError';
+  readonly phase: SuiPhase;
+  readonly message: string;
+  readonly cause?: unknown;
+}
+interface SuiConfigError extends ConfigIssue {
+  readonly _tag: 'SuiConfigError';
+}
+/** Move-build / sui-cli error. Carries the sub-process capture
+ *  envelope (exit + stderr + stdout). The plugin doc lists 11
+ *  shell-shaped phases today; we tighten to a much smaller set
+ *  and use `op` as a free-form column.
+ *
+ *  Stub: the closed-vs-open phase decision is deferred to the
+ *  cli-driver implementation pass. */
+interface SuiCliError {
+  readonly _tag: 'SuiCliError';
+  readonly op: 'build' | 'publish' | 'summary' | 'scrub' | 'spawn';
+  readonly exitCode?: number;
+  readonly stderr?: string;
+  readonly stdout?: string;
+  readonly cause?: unknown;
+}
+/** Synchronous refusal raised by the fork SDK guard. The guard
+ *  intercepts at property-access time so the wire call never
+ *  happens — failing fast lets callers branch on this without
+ *  awaiting a transport-level reject. */
+interface ForkUnsupportedError {
+  readonly _tag: 'ForkUnsupportedError';
+  readonly surface: string;
+  readonly hint: string;
+}
+/** Raised when fork meta-config drifts between supervisor boots.
+ *  Carries previous + current snapshots so the doctor / TUI can
+ *  diff them. Consumed inside Sui's fork acquire — does NOT cross
+ *  plugin boundaries (the recipe is "wipe and re-apply"). */
+interface SeedManifestMismatchError {
+  readonly _tag: 'SeedManifestMismatchError';
+  readonly previous: {
+    readonly upstream: string;
+    readonly checkpoint?: string;
+    readonly configHash: string;
+  };
+  readonly current: {
+    readonly upstream: string;
+    readonly checkpoint?: string;
+    readonly configHash: string;
+  };
+  readonly hint: string;
+}
+/** Raised when the funds-ready gate times out against a real
+ *  faucet. Plugin-internal — Sui contributes this strategy and
+ *  consumes its own error. */
+interface SuiFundsReadyError {
+  readonly _tag: 'SuiFundsReadyError';
+  readonly attempts: number;
+  readonly lastBody?: string;
+  readonly hint: string;
+}
+/** Union of every error a Sui-plugin caller may encounter. */
+type SuiError = SuiPluginError | SuiCliError | SuiConfigError | ForkUnsupportedError | SeedManifestMismatchError | SuiFundsReadyError;
+//#endregion
+export { ForkUnsupportedError, SeedManifestMismatchError, SuiCliError, SuiConfigError, SuiError, SuiFundsReadyError, SuiPluginError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/plugins/sui/errors.mjs

@@ -0,0 +1,28 @@
+import { defineConfigError } from "../../substrate/runtime/config-validation.mjs";
+//#region src/plugins/sui/errors.ts
+const suiPluginError = (phase, message, cause) => ({
+	_tag: "SuiPluginError",
+	phase,
+	message,
+	cause
+});
+const suiConfigError = defineConfigError("SuiConfigError");
+const forkUnsupportedError = (surface, hint) => ({
+	_tag: "ForkUnsupportedError",
+	surface,
+	hint
+});
+/** Error tags this plugin contributes — surfaced to the cause
+*  walker via `PluginErrorContribution`. */
+const SUI_ERROR_TAGS = [
+	"SuiPluginError",
+	"SuiCliError",
+	"SuiConfigError",
+	"ForkUnsupportedError",
+	"SeedManifestMismatchError",
+	"SuiFundsReadyError"
+];
+//#endregion
+export { SUI_ERROR_TAGS, forkUnsupportedError, suiConfigError, suiPluginError };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/plugins/sui/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../src/plugins/sui/errors.ts"],"sourcesContent":["// Sui plugin — typed errors.\n//\n// Distilled-doc finding: today's codebase centralises EVERY tagged\n// error in one engine file, but consumer boundaries cross service\n// lines. The architecture lets us redistribute: errors raised AND\n// consumed inside the Sui plugin live here. Cross-service errors\n// (`ForkIncompatibleError`, `SeedManifestMismatchError`) live with\n// the plugin that consumes them — Walrus/Seal/Deepbook own\n// `ForkIncompatibleError`; the seed-manifest error stays here\n// because Sui's fork acquire is the only raise site AND the only\n// consumer.\n//\n// Effect v4: errors are plain interfaces with a `_tag` discriminator\n// — we don't subclass an Effect base class; `Effect.catchTag` /\n// `catchTags` match on `_tag` literal. See architecture § Effect.\n\nimport { defineConfigError, type ConfigIssue } from '../../substrate/runtime/config-validation.ts';\n\n/** Phases for `SuiError`. Closed sum — keeps the cause-walker's\n *  display table small. Add a phase only after editing the\n *  catalog in the plugin doc. */\nexport type SuiPhase =\n\t| 'image-build'\n\t| 'port-allocate'\n\t| 'container-start'\n\t| 'rpc-probe'\n\t| 'faucet-probe'\n\t| 'graphql-probe'\n\t| 'fork-status-probe'\n\t| 'chain-id-fetch'\n\t| 'wait-funds-ready'\n\t| 'fork-impersonate'\n\t| 'fork-advance-clock'\n\t| 'fork-advance-checkpoint'\n\t| 'fork-lock'\n\t| 'fork-data-dir'\n\t| 'move-build'\n\t| 'move-publish';\n\n/** Generic Sui plugin error. Raised by the plugin's acquire body\n *  and its admin surface (`advanceClock`, `impersonate`, …). */\nexport interface SuiPluginError {\n\treadonly _tag: 'SuiPluginError';\n\treadonly phase: SuiPhase;\n\treadonly message: string;\n\treadonly cause?: unknown;\n}\n\nexport const suiPluginError = (\n\tphase: SuiPhase,\n\tmessage: string,\n\tcause?: unknown,\n): SuiPluginError => ({ _tag: 'SuiPluginError', phase, message, cause });\n\nexport interface SuiConfigError extends ConfigIssue {\n\treadonly _tag: 'SuiConfigError';\n}\n\nexport const suiConfigError = defineConfigError('SuiConfigError');\n\n/** Move-build / sui-cli error. Carries the sub-process capture\n *  envelope (exit + stderr + stdout). The plugin doc lists 11\n *  shell-shaped phases today; we tighten to a much smaller set\n *  and use `op` as a free-form column.\n *\n *  Stub: the closed-vs-open phase decision is deferred to the\n *  cli-driver implementation pass. */\nexport interface SuiCliError {\n\treadonly _tag: 'SuiCliError';\n\treadonly op: 'build' | 'publish' | 'summary' | 'scrub' | 'spawn';\n\treadonly exitCode?: number;\n\treadonly stderr?: string;\n\treadonly stdout?: string;\n\treadonly cause?: unknown;\n}\n\nexport const suiCliError = (\n\top: SuiCliError['op'],\n\tparts: Omit<SuiCliError, '_tag' | 'op'>,\n): SuiCliError => ({ _tag: 'SuiCliError', op, ...parts });\n\n/** Synchronous refusal raised by the fork SDK guard. The guard\n *  intercepts at property-access time so the wire call never\n *  happens — failing fast lets callers branch on this without\n *  awaiting a transport-level reject. */\nexport interface ForkUnsupportedError {\n\treadonly _tag: 'ForkUnsupportedError';\n\treadonly surface: string;\n\treadonly hint: string;\n}\n\nexport const forkUnsupportedError = (surface: string, hint: string): ForkUnsupportedError => ({\n\t_tag: 'ForkUnsupportedError',\n\tsurface,\n\thint,\n});\n\n/** Raised when fork meta-config drifts between supervisor boots.\n *  Carries previous + current snapshots so the doctor / TUI can\n *  diff them. Consumed inside Sui's fork acquire — does NOT cross\n *  plugin boundaries (the recipe is \"wipe and re-apply\"). */\nexport interface SeedManifestMismatchError {\n\treadonly _tag: 'SeedManifestMismatchError';\n\treadonly previous: {\n\t\treadonly upstream: string;\n\t\treadonly checkpoint?: string;\n\t\treadonly configHash: string;\n\t};\n\treadonly current: {\n\t\treadonly upstream: string;\n\t\treadonly checkpoint?: string;\n\t\treadonly configHash: string;\n\t};\n\treadonly hint: string;\n}\n\n/** Raised when the funds-ready gate times out against a real\n *  faucet. Plugin-internal — Sui contributes this strategy and\n *  consumes its own error. */\nexport interface SuiFundsReadyError {\n\treadonly _tag: 'SuiFundsReadyError';\n\treadonly attempts: number;\n\treadonly lastBody?: string;\n\treadonly hint: string;\n}\n\n/** Union of every error a Sui-plugin caller may encounter. */\nexport type SuiError =\n\t| SuiPluginError\n\t| SuiCliError\n\t| SuiConfigError\n\t| ForkUnsupportedError\n\t| SeedManifestMismatchError\n\t| SuiFundsReadyError;\n\n/** Error tags this plugin contributes — surfaced to the cause\n *  walker via `PluginErrorContribution`. */\nexport const SUI_ERROR_TAGS: ReadonlyArray<SuiError['_tag']> = [\n\t'SuiPluginError',\n\t'SuiCliError',\n\t'SuiConfigError',\n\t'ForkUnsupportedError',\n\t'SeedManifestMismatchError',\n\t'SuiFundsReadyError',\n] as const;\n"],"mappings":";;AAgDA,MAAa,kBACZ,OACA,SACA,WACqB;CAAE,MAAM;CAAkB;CAAO;CAAS;CAAO;AAMvE,MAAa,iBAAiB,kBAAkB,iBAAiB;AAiCjE,MAAa,wBAAwB,SAAiB,UAAwC;CAC7F,MAAM;CACN;CACA;CACA;;;AA0CD,MAAa,iBAAkD;CAC9D;CACA;CACA;CACA;CACA;CACA;CACA"}

package/dist/plugins/sui/fork-orchestration.mjs

@@ -0,0 +1,24 @@
+import { forkUnsupportedError } from "./errors.mjs";
+//#region src/plugins/sui/fork-orchestration.ts
+/** Surfaces that the sui-fork binary explicitly panics on. New
+*  upstream additions fail OPEN by default — architecture
+*  invariant. */
+const FORK_UNSUPPORTED_SURFACES = [
+	"getBalance",
+	"listBalances",
+	"getCoinInfo"
+];
+const wrapWithForkGuard = (sdk) => {
+	const guardedCore = new Proxy(sdk.core, { get(target, prop, receiver) {
+		if (typeof prop === "string" && FORK_UNSUPPORTED_SURFACES.includes(prop)) throw forkUnsupportedError(`client.core.${prop}`, "fork mode does not implement this SDK surface — use the impersonation helper or read state via ChainProbe.");
+		return Reflect.get(target, prop, receiver);
+	} });
+	return {
+		...sdk,
+		core: guardedCore
+	};
+};
+//#endregion
+export { FORK_UNSUPPORTED_SURFACES, wrapWithForkGuard };
+
+//# sourceMappingURL=fork-orchestration.mjs.map

package/dist/plugins/sui/fork-orchestration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-orchestration.mjs","names":[],"sources":["../../../src/plugins/sui/fork-orchestration.ts"],"sourcesContent":["// Fork-mode orchestration helpers.\n//\n// Owns the runtime SDK guard for surfaces the sui-fork binary panics\n// on. The data-dir lock + seed-manifest meta gate live in the\n// fork-mode builder once that wiring lands; they belong to the same\n// file once they have real implementations to anchor on.\n\nimport { forkUnsupportedError, type ForkUnsupportedError } from './errors.ts';\n\n/** Lock-holder identity persisted alongside the data-dir lock file.\n *  Two fork acquires against the same data dir surface this; one\n *  wins, the other gets an actionable error. */\nexport interface ForkLockHolder {\n\treadonly pid: number;\n\treadonly host: string;\n\treadonly instanceId: string;\n\treadonly startedAt: number;\n}\n\n/** On-disk seed-manifest snapshot. */\nexport interface ForkMeta {\n\treadonly version: number;\n\treadonly createdAt: number;\n\treadonly upstream: string;\n\treadonly checkpoint?: string;\n\t/** Lowercased + sorted (architecture invariant: configHash MUST\n\t *  be stable across orderings). */\n\treadonly seedAddresses: ReadonlyArray<string>;\n\t/** Lowercased + sorted, same invariant. */\n\treadonly seedObjects: ReadonlyArray<string>;\n\t/** Digest of the above four fields. `autoTickMs` is NOT folded\n\t *  in (architecture invariant). */\n\treadonly configHash: string;\n\treadonly runtime?: { readonly autoTickMs?: number };\n}\n\n/** Surfaces that the sui-fork binary explicitly panics on. New\n *  upstream additions fail OPEN by default — architecture\n *  invariant. */\nexport const FORK_UNSUPPORTED_SURFACES: ReadonlyArray<string> = [\n\t// `client.core.*` methods that hit `simulate_transaction` /\n\t// balance-derivation paths the fork binary doesn't implement.\n\t'getBalance',\n\t'listBalances',\n\t'getCoinInfo',\n] as const;\n\n/** Wrap a Sui SDK shim with the fork guard. Property access for a\n *  blocklisted surface SYNCHRONOUSLY throws — the wire call never\n *  happens, so the fork binary stays up. */\nexport type ForkGuardedSdk<Sdk extends { readonly core: object }> = Omit<Sdk, 'core'> & {\n\treadonly core: Sdk['core'];\n};\n\nexport const wrapWithForkGuard = <Sdk extends { readonly core: object }>(\n\tsdk: Sdk,\n): ForkGuardedSdk<Sdk> => {\n\tconst guardedCore = new Proxy(sdk.core as Record<string, unknown>, {\n\t\tget(target, prop, receiver) {\n\t\t\tif (typeof prop === 'string' && FORK_UNSUPPORTED_SURFACES.includes(prop)) {\n\t\t\t\tconst err: ForkUnsupportedError = forkUnsupportedError(\n\t\t\t\t\t`client.core.${prop}`,\n\t\t\t\t\t'fork mode does not implement this SDK surface — use the impersonation helper ' +\n\t\t\t\t\t\t'or read state via ChainProbe.',\n\t\t\t\t);\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t\treturn Reflect.get(target, prop, receiver);\n\t\t},\n\t}) as Sdk['core'];\n\t// Preserve all SDK fields (e.g. SuiSdkShim's opaque `client` for\n\t// Transaction.build) — only the `core` proxy intercepts; siblings\n\t// like `client` flow through unchanged.\n\treturn { ...sdk, core: guardedCore };\n};\n"],"mappings":";;;;;AAuCA,MAAa,4BAAmD;CAG/D;CACA;CACA;CACA;AASD,MAAa,qBACZ,QACyB;CACzB,MAAM,cAAc,IAAI,MAAM,IAAI,MAAiC,EAClE,IAAI,QAAQ,MAAM,UAAU;AAC3B,MAAI,OAAO,SAAS,YAAY,0BAA0B,SAAS,KAAK,CAMvE,OALkC,qBACjC,eAAe,QACf,6GAGQ;AAEV,SAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;IAE3C,CAAC;AAIF,QAAO;EAAE,GAAG;EAAK,MAAM;EAAa"}