@mysten-incubation/devstack 0.0.0

package/dist/contracts/container-runtime.d.mts

@@ -0,0 +1,245 @@
+import { ContainerLabelTuple } from "./snapshotable.mjs";
+import { Duration, Effect, Scope, Stream } from "effect";
+
+//#region src/contracts/container-runtime.d.ts
+type RecreatePolicy = 'on-failure' | 'never' | 'on-config-change';
+/** Content-addressed image reference. Substrate folds builds into
+ *  the cache via this. */
+interface ImageRef {
+  readonly digest: string;
+  readonly tag?: string;
+}
+interface TaggedImageRef extends ImageRef {
+  readonly tag: string;
+}
+interface LoadedImageBundle {
+  readonly refs: ReadonlyArray<ImageRef>;
+}
+interface SaveImageOptions {
+  readonly removeAfterSave?: boolean;
+}
+interface TagImageOptions {
+  readonly removeSourceAfterTag?: boolean;
+}
+interface ContainerBuildContext {
+  readonly contextPath: string;
+  readonly dockerfile?: string;
+  /** Optional context-relative paths that define this image's cache
+   *  identity. Omitted or empty means fingerprint the whole Docker build
+   *  context. Use this when Docker needs a shared parent context only to
+   *  copy a small set of files; unrelated sibling image edits must not
+   *  retag stateful containers. */
+  readonly fingerprintPaths?: ReadonlyArray<string>;
+  /** Optional Docker build platform, for example `linux/amd64`.
+   *  Omitted means Docker uses the host/default platform. */
+  readonly platform?: string;
+  readonly buildArgs?: Readonly<Record<string, string>>;
+}
+interface ContainerPortPublish {
+  readonly containerPort: number;
+  readonly hostPort: number;
+  readonly hostIp?: string;
+}
+type PortBindingReconciliation = 'exact' | 'adopt-existing';
+interface EnsureContainerSpec {
+  readonly name: string;
+  readonly image: ImageRef;
+  readonly labels: ContainerLabelTuple;
+  readonly recreate: RecreatePolicy;
+  /** Optional caller-owned fingerprint for config that Docker cannot
+   *  infer from image or port bindings (for example files behind a
+   *  bind mount). When set, `on-config-change` recreates an existing
+   *  container whose recorded fingerprint differs. */
+  readonly configHash?: string;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly ports?: ReadonlyArray<ContainerPortPublish>;
+  /** Grace window, in seconds, used by the scope finalizer before
+   *  Docker escalates container stop to SIGKILL. Stateful containers
+   *  with RocksDB/WAL-backed data should request enough time to flush
+   *  cleanly; the runtime default is 10 seconds. */
+  readonly stopGraceSeconds?: number;
+  /** How published host ports participate in existing-container
+   *  reconciliation. Default `exact` treats a binding mismatch as
+   *  config drift. `adopt-existing` lets a same-name, image-matching
+   *  container keep its current published ports; callers must read
+   *  the returned `ContainerHandle.ports` before constructing URLs. */
+  readonly portBindingReconciliation?: PortBindingReconciliation;
+  readonly networkAttach?: ReadonlyArray<string>;
+  /** Bind mounts. The build-container path lives here: source dir →
+   *  container path. `readonly: true` flips on the docker mount
+   *  read-only flag. */
+  readonly mounts?: ReadonlyArray<{
+    readonly source: string;
+    readonly target: string;
+    readonly readonly?: boolean;
+  }>;
+  /** Optional `--entrypoint <bin>` override. The Move build container
+   *  uses `sh` so its long-lived sleeper can trap Docker stop signals. */
+  readonly entrypoint?: string;
+  /** Optional positional argv appended after the image. Used to set the
+   *  sleeper command without changing the image. */
+  readonly command?: ReadonlyArray<string>;
+  /** Extra `<host>:<ip>` entries to inject into /etc/hosts via
+   *  `docker run --add-host`. The literal `host-gateway` is supported
+   *  on every modern Docker daemon (DfM/DfW + Docker Engine since
+   *  20.10) and resolves to the container's view of the host
+   *  loopback — necessary for in-container processes to reach
+   *  host-published ports on native Linux where `host.docker.internal`
+   *  isn't auto-installed. Walrus uses this to reach sui's host-bound
+   *  RPC + faucet from inside its own per-stack network. */
+  readonly extraHosts?: Readonly<Record<string, string>>;
+}
+/** Spec for `ContainerRuntime.runOneShot` — a transient
+ *  `docker run --rm` container. Path (b) in `runMoveBuild`'s
+ *  three-way dispatch. */
+interface OneShotSpec {
+  readonly image: ImageRef;
+  readonly argv?: ReadonlyArray<string>;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly mounts?: ReadonlyArray<{
+    readonly source: string;
+    readonly target: string;
+    readonly readonly?: boolean;
+  }>;
+  readonly network?: string;
+  readonly entrypoint?: string;
+  /** Optional numeric or named user for `docker run --user`.
+   *  Use for one-shots that write into host bind mounts so Linux
+   *  Docker does not leave root-owned files behind. */
+  readonly user?: string;
+  /** Wall-clock timeout. After this the subprocess is killed; a
+   *  belt-and-suspenders `rm -f` finalizer catches containers that
+   *  outlived the foreground subprocess. */
+  readonly timeoutMillis?: number;
+  /** Extra `<host>:<ip>` entries injected via `docker run --add-host`.
+   *  See `EnsureContainerSpec.extraHosts`. */
+  readonly extraHosts?: Readonly<Record<string, string>>;
+}
+interface ContainerHandle {
+  readonly id: string;
+  readonly name: string;
+  /** Exact ownership tuple stamped on the current Docker resource.
+   *  Runtime operations that mutate by stable name use this to
+   *  re-check the live labels before exec/pause/commit/unpause/stop. */
+  readonly labels?: ContainerLabelTuple;
+  /** Image ref Docker recorded at container creation time. This is
+   *  the same string `ensureContainer` compares against on adoption,
+   *  so snapshot restore must re-tag loaded images to this ref. */
+  readonly imageName: string;
+  readonly status: 'running' | 'exited' | 'paused' | 'created';
+  readonly ips: ReadonlyArray<string>;
+  readonly ports?: ReadonlyArray<ContainerPortPublish>;
+}
+/** Captured stdout/stderr/exit code from a one-shot `exec` invocation
+ *  inside a running container. */
+interface ExecResult {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+/** Optional knobs for `ContainerRuntime.exec`. */
+interface ExecOptions {
+  readonly user?: string;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly workdir?: string;
+}
+/** Spec for the idempotent per-stack network create. */
+interface EnsureNetworkSpec {
+  readonly name: string;
+  readonly app: string;
+  readonly stack: string;
+  /** Optional IPAM subnet (`10.42.7.0/24`) for callers that own
+   *  deterministic in-network addresses and must not consume Docker's
+   *  default bridge address pools. */
+  readonly subnet?: string;
+  /** Optional gateway inside `subnet` (`10.42.7.1`). */
+  readonly gateway?: string;
+}
+/** The substrate-facing runtime adapter. Implementation lives in
+ *  `runtime/docker/`. */
+interface ContainerRuntime {
+  readonly ensureImage: (build: ContainerBuildContext, expected?: ImageRef) => Effect.Effect<ImageRef, ContainerRuntimeError>;
+  readonly pullImage?: (ref: string) => Effect.Effect<ImageRef, ContainerRuntimeError>;
+  /** Idempotently create a docker network. Returns the network's id.
+   *  No-op (returns existing id) if the network already exists.
+   *  Networks outlive container scopes — there is NO finalizer; the
+   *  network is reaped by `wipe` / `prune`, not by the supervisor. */
+  readonly ensureNetwork: (spec: EnsureNetworkSpec) => Effect.Effect<string, ContainerRuntimeError>;
+  readonly ensureContainer: (spec: EnsureContainerSpec) => Effect.Effect<ContainerHandle, ContainerRuntimeError, Scope.Scope>;
+  /** Run a one-shot command inside a running container and capture
+   *  its output. The runtime does NOT promote a non-zero exit to
+   *  failure — the caller is the policy holder (the postgres plugin
+   *  treats non-zero from `pg_isready` as "retry", but non-zero from
+   *  `createdb` as a typed plugin error). Only daemon-level failures
+   *  (no such container, daemon unreachable) surface as
+   *  `ContainerRuntimeError`. */
+  readonly exec: (handle: ContainerHandle, argv: ReadonlyArray<string>, opts?: ExecOptions) => Effect.Effect<ExecResult, ContainerRuntimeError>;
+  /** Run a one-shot `docker run --rm` container and capture stdout +
+   *  stderr + exit code. Used by `runMoveBuild`'s path (b) — fresh
+   *  ephemeral container per build when no long-lived build container
+   *  is available. Belt-and-suspenders `rm -f` finalizer fires on
+   *  scope close to catch containers that survived a foreground kill. */
+  readonly runOneShot: (spec: OneShotSpec) => Effect.Effect<ExecResult, ContainerRuntimeError, Scope.Scope>;
+  readonly inspectByLabels: (labels: ContainerLabelTuple) => Effect.Effect<ReadonlyArray<ContainerHandle>, ContainerRuntimeError>;
+  readonly followLogs: (handle: ContainerHandle) => Stream.Stream<string, ContainerRuntimeError>;
+  /** Pause a running container. Snapshot capture uses this to establish
+   *  one stack-wide quiescence window before any artifact is written. */
+  readonly pause: (handle: ContainerHandle) => Effect.Effect<void, ContainerRuntimeError>;
+  /** Commit a container's writable layer to a snapshot image. Running
+   *  containers are paused first; paused, exited, and created
+   *  containers are already quiescent and are committed as-is. */
+  readonly pauseAndCommit: (handle: ContainerHandle) => Effect.Effect<TaggedImageRef, ContainerRuntimeError>;
+  /** Stream an image's bytes as if produced by `docker save <ref>`.
+   *  Used by the snapshot orchestrator to persist committed images to
+   *  tar files; consumers compose with a file-write sink so large
+   *  images don't materialise in memory. */
+  readonly saveImage: (ref: ImageRef, opts?: SaveImageOptions) => Stream.Stream<Uint8Array, ContainerRuntimeError>;
+  /** Stream a deduplicated `docker save <ref...>` bundle. Snapshot
+   *  capture uses this for multi-container stacks so shared base layers
+   *  are written once per snapshot instead of once per container. */
+  readonly saveImages: (refs: ReadonlyArray<ImageRef>, opts?: SaveImageOptions) => Stream.Stream<Uint8Array, ContainerRuntimeError>;
+  /** Load one `docker save`-shaped tar stream. Returns the refs Docker
+   *  reported loading from that stream so restore can prove expected
+   *  snapshot tags came from the artifact before it retags them. */
+  readonly loadImage: (tar: Stream.Stream<Uint8Array, unknown>) => Effect.Effect<LoadedImageBundle, ContainerRuntimeError>;
+  /** Move/copy a tag onto a source image. After this returns,
+   *  `<newTag>` resolves to the same image as `src`. Used by snapshot
+   *  restore to alias a freshly-loaded image back to the originally-
+   *  recorded name. */
+  readonly tagImage: (src: ImageRef, newTag: string, opts?: TagImageOptions) => Effect.Effect<void, ContainerRuntimeError>;
+  /** Remove one image ref/tag. Snapshot capture uses this only for
+   *  committed temp tags when capture fails before `saveImages` takes
+   *  ownership of cleanup via `removeAfterSave`. Missing refs are
+   *  treated as already-cleaned. */
+  readonly removeImage: (ref: ImageRef) => Effect.Effect<void, ContainerRuntimeError>;
+  readonly unpause: (handle: ContainerHandle) => Effect.Effect<void, ContainerRuntimeError>;
+  readonly stop: (handle: ContainerHandle, grace: Duration.Duration) => Effect.Effect<void, ContainerRuntimeError>;
+  /** Boot-time orphan cleanup. This is container-only and skips names
+   *  still present in the cross-process claim ledger. */
+  readonly sweepOrphans: (labelMatch: Partial<ContainerLabelTuple>) => Effect.Effect<number, ContainerRuntimeError>;
+  /** Force-remove managed containers matching the partial label tuple,
+   *  regardless of claim-ledger entries. Wipe uses this for explicit
+   *  teardown; restore uses it before the next `ensureContainer`
+   *  recreates names from restored image tags. */
+  readonly removeManagedContainers: (labelMatch: Partial<ContainerLabelTuple>) => Effect.Effect<number, ContainerRuntimeError>;
+  /** Remove managed Docker images matching the partial label tuple.
+   *  Implementations must enumerate by ownership labels, never by tag
+   *  prefix alone. */
+  readonly removeManagedImages: (labelMatch: Partial<ContainerLabelTuple>) => Effect.Effect<number, ContainerRuntimeError>;
+  /** Remove managed Docker networks matching the partial label tuple.
+   *  Implementations must enumerate by ownership labels and must not
+   *  remove unlabelled or foreign resources. */
+  readonly removeManagedNetworks: (labelMatch: Partial<ContainerLabelTuple>) => Effect.Effect<number, ContainerRuntimeError>;
+  /** Remove managed Docker volumes matching the partial label tuple.
+   *  Implementations must enumerate by ownership labels and must not
+   *  remove unlabelled or foreign resources. */
+  readonly removeManagedVolumes: (labelMatch: Partial<ContainerLabelTuple>) => Effect.Effect<number, ContainerRuntimeError>;
+}
+interface ContainerRuntimeError {
+  readonly _tag: 'ContainerRuntimeError';
+  readonly reason: 'daemon-unreachable' | 'image-build-failed' | 'image-save-failed' | 'image-load-failed' | 'image-tag-failed' | 'docker-inspect-failed' | 'foreign-resource' | 'container-replace-failed' | 'name-collision' | 'publish-port-conflict' | 'network-address-pool-exhausted' | 'ip-readback-timeout' | 'ready-probe-failed' | 'recreate-refused' | 'image-remove-failed';
+  readonly detail: string;
+}
+//#endregion
+export { ContainerHandle, ContainerRuntime, ContainerRuntimeError, EnsureContainerSpec, ImageRef, LoadedImageBundle, TaggedImageRef };
+//# sourceMappingURL=container-runtime.d.mts.map

package/dist/contracts/liveness-classifier.d.mts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+
+//#region src/contracts/liveness-classifier.d.ts
+type LivenessClassification = 'alive' | 'dormant' | 'stale' | 'abandoned';
+/** Per-entry hints persisted in `~/.devstack/registry.json`. The L3
+ *  orchestrator passes them to the plugin's classifier. */
+interface LivenessHints {
+  readonly heartbeatAt: number | null;
+  readonly claimPid: number | null;
+  readonly claimStartTime: number | null;
+  readonly pluginHints: Readonly<Record<string, unknown>>;
+}
+interface LivenessClassifierDecl {
+  readonly kind: 'liveness-classifier';
+  readonly classify: (hints: LivenessHints) => Effect.Effect<LivenessClassification>;
+}
+//#endregion
+export { LivenessClassification, LivenessClassifierDecl, LivenessHints };
+//# sourceMappingURL=liveness-classifier.d.mts.map

package/dist/contracts/network-resolver.d.mts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+
+//#region src/contracts/network-resolver.d.ts
+/** The funds-ready strategy shape. A trivially-succeeding default
+ *  is registered when no contributor is present (e.g. live mode). */
+interface FundsReadyStrategy {
+  readonly waitFundsReady: Effect.Effect<void, FundsReadyError>;
+}
+interface FundsReadyError {
+  readonly _tag: 'FundsReadyError';
+  readonly reason: string;
+}
+//#endregion
+export { FundsReadyError, FundsReadyStrategy };
+//# sourceMappingURL=network-resolver.d.mts.map

package/dist/contracts/network-resolver.mjs

@@ -0,0 +1,7 @@
+//#region src/contracts/network-resolver.ts
+/** Capability-key constant for the funds-ready gate strategy. */
+const FUNDS_READY_GATE_KEY = "gate:funds-ready";
+//#endregion
+export { FUNDS_READY_GATE_KEY };
+
+//# sourceMappingURL=network-resolver.mjs.map

package/dist/contracts/network-resolver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-resolver.mjs","names":[],"sources":["../../src/contracts/network-resolver.ts"],"sourcesContent":["// NetworkResolver capability contract (architecture §5).\n//\n// Provides one consistent answer to \"what network am I on?\" for\n// every plugin. The resolver is consulted once per acquire; the\n// answer is threaded as Context.\n//\n// Funds-ready is NOT engine-generic. It's a typed StrategyContributor\n// capability key (`gate:funds-ready`); plugins that need to wait on\n// funds read from the strategy registry. Architecture explicitly\n// removed the previous \"L0 exposes awaitFunds\" wording.\n\nimport type { Effect } from 'effect';\n\nimport type { NetworkConfig } from '../substrate/network.ts';\n\n/** Capability-key constant for the funds-ready gate strategy. */\nexport const FUNDS_READY_GATE_KEY = 'gate:funds-ready' as const;\n\n/** The funds-ready strategy shape. A trivially-succeeding default\n *  is registered when no contributor is present (e.g. live mode). */\nexport interface FundsReadyStrategy {\n\treadonly waitFundsReady: Effect.Effect<void, FundsReadyError>;\n}\n\nexport interface FundsReadyError {\n\treadonly _tag: 'FundsReadyError';\n\treadonly reason: string;\n}\n\n/**\n * The substrate-facing resolver service. One resolution per\n * acquire; CLI > env > config > default precedence.\n */\nexport interface NetworkResolver {\n\treadonly resolve: Effect.Effect<NetworkConfig, NetworkResolutionError>;\n}\n\nexport interface NetworkResolutionError {\n\treadonly _tag: 'NetworkResolutionError';\n\treadonly reason: 'invalid-mode' | 'unknown-chain' | 'rpc-unreachable';\n\treadonly detail: string;\n}\n"],"mappings":";;AAgBA,MAAa,uBAAuB"}

package/dist/contracts/projection.d.mts

@@ -0,0 +1,15 @@
+import { EngineEvent } from "../substrate/events.mjs";
+
+//#region src/contracts/projection.d.ts
+type ProjectionEvent = Extract<EngineEvent, {
+  readonly tag: 'account.updated';
+}> | Extract<EngineEvent, {
+  readonly tag: 'package.updated';
+}>;
+interface ProjectionDecl {
+  readonly kind: 'projection';
+  readonly event: ProjectionEvent;
+}
+//#endregion
+export { ProjectionDecl, ProjectionEvent };
+//# sourceMappingURL=projection.d.mts.map

package/dist/contracts/routable.d.mts

@@ -0,0 +1,53 @@
+//#region src/contracts/routable.d.ts
+/** A plugin-provided dispatch identity. The router combines this with
+ *  the runtime identity `(app, stack)` before minting the file-provider
+ *  id, so the dispatch id itself does not need to encode app/stack. */
+interface DispatchId {
+  readonly serviceKey: string;
+  readonly role: string;
+}
+/** Upstream target registry. Module augmentation can add router-owned
+ *  target types without widening the built-in payloads. */
+interface DevstackRoutableUpstreamRegistry {
+  readonly container: {
+    readonly containerName: string;
+    readonly containerPort: number;
+  };
+  readonly 'host-loopback': {
+    readonly port: number;
+  };
+}
+type RoutableUpstreamKind = keyof DevstackRoutableUpstreamRegistry & string;
+/** Upstream target type. Built-ins are container-on-router-network and
+ *  host-process-on-loopback. The router resolves URL. */
+type RoutableUpstream<Kind extends string = RoutableUpstreamKind> = string extends Kind ? { readonly [K in RoutableUpstreamKind]: Readonly<{
+  readonly type: K;
+} & DevstackRoutableUpstreamRegistry[K]> }[RoutableUpstreamKind] : Kind extends RoutableUpstreamKind ? Readonly<{
+  readonly type: Kind;
+} & DevstackRoutableUpstreamRegistry[Kind]> : Readonly<{
+  readonly type: Kind;
+} & object>;
+/** Shared fields across both wire-protocol variants. */
+interface RoutableBase {
+  readonly kind: 'routable';
+  readonly endpointName: string;
+  readonly dispatchId: DispatchId;
+  readonly upstream: RoutableUpstream;
+}
+/** HTTP variant — Host-header dispatched, CORS-aware. */
+interface RoutableHttpDecl extends RoutableBase {
+  readonly wireProtocol: 'http' | 'h2c';
+  readonly cors: boolean;
+}
+/** TCP variant — entrypoint-port dispatched, no Host header, no CORS.
+ *  Each TCP backend MUST reference an entrypoint whose protocol is
+ *  `'tcp'` in the registry; parallel stacks of TCP backends cannot
+ *  share one entrypoint port (TCP has no virtual-host fan-out). */
+interface RoutableTcpDecl extends RoutableBase {
+  readonly wireProtocol: 'tcp';
+}
+/** Routable declaration. Plugin emits one per endpoint it serves. */
+type RoutableDecl = RoutableHttpDecl | RoutableTcpDecl;
+//#endregion
+export { DevstackRoutableUpstreamRegistry, DispatchId, RoutableDecl, RoutableHttpDecl, RoutableTcpDecl, RoutableUpstream, RoutableUpstreamKind };
+//# sourceMappingURL=routable.d.mts.map

package/dist/contracts/snapshotable.d.mts

@@ -0,0 +1,39 @@
+import { Effect, Scope } from "effect";
+
+//#region src/contracts/snapshotable.d.ts
+/** Label tuple identifying managed containers. The orchestrator
+ *  filters the runtime adapter by this tuple. */
+interface ContainerLabelTuple {
+  readonly app: string;
+  readonly stack: string;
+  readonly plugin: string;
+  readonly role: string;
+}
+/** Capture descriptor: zero or more subtrees + managed containers +
+ *  optional typed metadata slice. */
+interface SnapshotableDecl {
+  readonly kind: 'snapshotable';
+  /** Host-tree subtrees, relative to the substrate's runtime-dir
+   *  root. Auto-included subtrees under `runtime/<plugin-key>/`
+   *  are added by the substrate; this list is opt-in extras. */
+  readonly subtrees: ReadonlyArray<string>;
+  /** Managed containers identified by label tuples — orchestrator
+   *  is name-blind. */
+  readonly managedContainers?: ReadonlyArray<ContainerLabelTuple>;
+  /** Quiescence hook: how to make state consistent before commit.
+   *  Default is "pause container"; postgres / RocksDB declare
+   *  longer grace. */
+  readonly quiesce?: Effect.Effect<void, never, Scope.Scope>;
+  /** Pre-restore hook: contribute to the identity guard. */
+  readonly preRestore?: Effect.Effect<unknown, never>;
+  /** Post-restore hook. */
+  readonly postRestore?: Effect.Effect<void, never>;
+  /** Missing-tolerance flag: is absence on restore fatal or fine? */
+  readonly missingTolerance: 'fatal' | 'fine';
+  /** Secret-material declaration drives mode bits (0o600 inside
+   *  0o700 parent). Substrate preserves on round-trip. */
+  readonly secretMaterial?: boolean;
+}
+//#endregion
+export { ContainerLabelTuple, SnapshotableDecl };
+//# sourceMappingURL=snapshotable.d.mts.map

package/dist/contracts/strategy-contributor.d.mts

@@ -0,0 +1,26 @@
+import { Effect, Scope } from "effect";
+
+//#region src/contracts/strategy-contributor.d.ts
+/**
+ * Contribution declaration. `Key` is the literal capability key
+ * (preserved as a string-literal type so consumers picking by key
+ * recover the strategy's value shape). `Strategy` is the closed-over
+ * value (already-bound dependencies; dispatch site is
+ * context-free).
+ */
+interface StrategyContributorDecl<Key extends string = string, Strategy = unknown> {
+  readonly kind: 'strategy-contributor';
+  readonly capabilityKey: Key;
+  readonly strategy: Strategy;
+  /** Auto-mounted contributors are hidden from renderer rows by
+   *  default. User-supplied contributors are visible. */
+  readonly autoMounted: boolean;
+  /** Optional priority — last-write-wins on tie. */
+  readonly priority?: number;
+}
+/** Type-level extraction of strategy by capability key from a
+ *  member's caps tuple. */
+type StrategyFor<Caps extends ReadonlyArray<unknown>, Key extends string> = Extract<Caps[number], StrategyContributorDecl<Key, unknown>> extends StrategyContributorDecl<Key, infer S> ? S : never;
+//#endregion
+export { StrategyContributorDecl, StrategyFor };
+//# sourceMappingURL=strategy-contributor.d.mts.map

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+import { AppName, Brand, ChainId, ContentHash, EndpointKey, StackName, appName, chainId, contentHash, endpointKey, stackName } from "./substrate/brand.mjs";
+import { ManifestExtras, ManifestExtrasContext, ManifestExtrasInput } from "./substrate/manifest.mjs";
+import { CodegenEmitContext, CodegenEmitDone, CodegenableDecl } from "./contracts/codegenable.mjs";
+import { LivenessClassification, LivenessClassifierDecl, LivenessHints } from "./contracts/liveness-classifier.mjs";
+import { LifecycleStatus, PhaseNarration, PluginRole } from "./substrate/lifecycle.mjs";
+import { ProjectionDecl, ProjectionEvent } from "./contracts/projection.mjs";
+import { DevstackRoutableUpstreamRegistry, DispatchId, RoutableDecl, RoutableHttpDecl, RoutableTcpDecl, RoutableUpstream, RoutableUpstreamKind } from "./contracts/routable.mjs";
+import { ContainerLabelTuple, SnapshotableDecl } from "./contracts/snapshotable.mjs";
+import { StrategyContributorDecl, StrategyFor } from "./contracts/strategy-contributor.mjs";
+import { CapabilityDecl, CapabilityKind, CapabilityPayloadFor, DevstackCapabilityRegistry, ExactCapabilityPayload } from "./contracts/capability-decl.mjs";
+import { AnyPlugin, AnyResourceRef, DependencyInput, DependencyList, Plugin, PluginSpec, ResolvedDependencies, ResourceIdOf, ResourceRef, ResourceValueOf, defineId, definePlugin, resource } from "./substrate/plugin.mjs";
+import { DefaultNetwork, DevstackNetworkModeRegistry, NetworkConfig, NetworkMode } from "./substrate/network.mjs";
+import { DevstackOptions } from "./substrate/options.mjs";
+import { Stack, defineDevstack } from "./api/define-devstack.mjs";
+import { BuildCtx, DevstackOptionsWith, defineDevstackWith } from "./api/define-devstack-with.mjs";
+import { ContainerHandle, ContainerRuntime, ContainerRuntimeError, ImageRef, LoadedImageBundle, TaggedImageRef } from "./contracts/container-runtime.mjs";
+import { IdentityContext } from "./substrate/runtime/paths.mjs";
+import { ContainerRuntimeService } from "./runtime/docker/service.mjs";
+import { http_probe_d_exports } from "./substrate/runtime/http-probe.mjs";
+import { RedactionRule, Redactor, redaction_d_exports } from "./substrate/runtime/observability/redaction.mjs";
+import { BootError, RunHandle, RunStackIdentityOptions, RunStackOptions, runStack } from "./api/run-stack.mjs";
+import { capability, capabilitySink, codegenable, defineCapability, projection, routable, snapshotable, strategyContributor } from "./api/define-capabilities.mjs";
+import { FactoriesByMode, FactoriesFor, ModeNamespace, defineModeNamespace } from "./api/mode-narrowed-factory.mjs";
+import { config_validation_d_exports } from "./substrate/runtime/config-validation.mjs";
+import { managed_container_d_exports } from "./substrate/runtime/managed-container.mjs";
+import { LogLevel, LogLine, LogPayload, Logger, LoggerShape, TagBuffer } from "./substrate/runtime/observability/logger.mjs";
+import { process_lines_d_exports } from "./substrate/runtime/observability/process-lines.mjs";
+import { process_supervisor_d_exports } from "./substrate/runtime/process-supervisor.mjs";
+import { probes_d_exports } from "./substrate/runtime/probes.mjs";
+import { retry_policy_d_exports } from "./substrate/runtime/retry-policy.mjs";
+import { runtime_decode_d_exports } from "./substrate/runtime/runtime-decode.mjs";
+import { ChainProbe, ChainProbeError, ChainProbeMode } from "./contracts/chain-probe.mjs";
+import { FaucetBodyError, FaucetConfigError, FaucetError, FaucetExhausted, FaucetUnreachable } from "./plugins/faucet/errors.mjs";
+import { FaucetStrategy } from "./plugins/faucet/strategies/sui-local.mjs";
+import { FaucetStrategyContribution } from "./plugins/faucet/service.mjs";
+import { defineFaucetStrategy } from "./plugins/faucet/index.mjs";
+import { ForkUnsupportedError, SeedManifestMismatchError, SuiCliError, SuiConfigError, SuiError, SuiFundsReadyError, SuiPluginError } from "./plugins/sui/errors.mjs";
+import { SuiForkOptions, SuiLiveOptions, SuiLocalOptions, SuiLocalRpcOptions, SuiOptions } from "./plugins/sui/mode/spec.mjs";
+import { FundsReadyError, FundsReadyStrategy } from "./contracts/network-resolver.mjs";
+import { ResolvedSuiNetwork } from "./plugins/sui/network-resolver.mjs";
+import { SuiNetworkBindings } from "./plugins/sui/codegen.mjs";
+import { sui, suiFor } from "./plugins/sui/index.mjs";
+import { CoinError, CoinPhase } from "./plugins/coin/errors.mjs";
+import { isBareCoinType, validateBareCoinType } from "./plugins/coin/metadata.mjs";
+import { BUILTIN_COINS, BuiltinCoinName, ResolvedCoin } from "./plugins/coin/address-resolution.mjs";
+import { CoinAddressForm, CoinValue } from "./plugins/coin/service.mjs";
+import { CoinBindings } from "./plugins/coin/codegen.mjs";
+import { DiscoveredCoin } from "./plugins/coin/discovery.mjs";
+import { PackageMember, coin } from "./plugins/coin/index.mjs";
+import { AccountAcquireError, AccountAcquirePhase, AccountError, AccountSignError, AccountSignPhase, AccountVariantKind } from "./plugins/account/errors.mjs";
+import { AccountOptions, AccountValue, TxResult } from "./plugins/account/service.mjs";
+import { AccountFunding, AccountFundingCoinValue, AccountFundingEntry, AccountFundingRequest, AccountFundingResult, AccountFundingStrategy, CoinMember, CrossCuttingFundingEntry, CrossCuttingFundingProvider, DEFAULT_EPHEMERAL_FUND_MIST, SUI_FULL_COIN_TYPE, SuiFundingEntry } from "./plugins/account/funding.mjs";
+import { AccountBindings } from "./plugins/account/codegen.mjs";
+import { ResolvedKeypair, SignatureScheme } from "./plugins/account/keypair.mjs";
+import { SyntheticImpersonationSigner } from "./plugins/account/variants/impersonate.mjs";
+import { account } from "./plugins/account/index.mjs";
+import { ResolvedKnownPackage, ResolvedLocalPackage } from "./plugins/package/registry.mjs";
+import { PublishError } from "./plugins/package/errors.mjs";
+import { PackageBindings } from "./plugins/package/codegen.mjs";
+import { KnownPackageOptions, KnownPackageResolved, LocalPackageOptions, LocalPackageResolved, PackageCapture, PackageResolved, PublisherAccountMember, knownPackage, localPackage } from "./plugins/package/index.mjs";
+import { WalletBootError, WalletBootPhase, WalletError, WalletRequestError, WalletRequestPhase } from "./plugins/wallet/errors.mjs";
+import { WalletAccountMember, WalletOptions, WalletValue } from "./plugins/wallet/service.mjs";
+import { wallet } from "./plugins/wallet/index.mjs";
+import { HostServiceError } from "./plugins/host-service/errors.mjs";
+import { HOST_SERVICE_PORT_TOKEN, HostServiceOptions, HostServiceReadyProbe, HostServiceValue } from "./plugins/host-service/service.mjs";
+import { hostService } from "./plugins/host-service/index.mjs";
+import { DatabaseCreateFailed, PostgresConfigError, PostgresConnectionTimeout, PostgresError, PostgresPhase, PostgresPluginError } from "./plugins/postgres/errors.mjs";
+import { Postgres, PostgresServiceOptions } from "./plugins/postgres/service.mjs";
+import { PostgresConnectionBindings, PostgresConnectionParts } from "./plugins/postgres/connection.mjs";
+import { PostgresPluginOptions, postgres } from "./plugins/postgres/index.mjs";
+import { ActionError, ActionPhase } from "./plugins/action/errors.mjs";
+import { ActionReceipt } from "./plugins/action/service.mjs";
+import { ActionBuildContext } from "./plugins/action/build-context.mjs";
+import { ActionOptions, ActionUpstreamRef, action } from "./plugins/action/index.mjs";
+import { WalrusConfigError, WalrusError, WalrusPhase, WalrusPluginError } from "./plugins/walrus/errors.mjs";
+import { WalrusStorageNode } from "./plugins/walrus/storage-nodes.mjs";
+import { WalrusLocalClusterOptions } from "./plugins/walrus/mode/local-cluster.mjs";
+import { WalrusKnownDeploymentOptions, WalrusKnownNetwork } from "./plugins/walrus/mode/known-deploy.mjs";
+import { WalrusBindings, WalrusNodeBinding } from "./plugins/walrus/codegen.mjs";
+import { WalCoinValue, WalrusResolved, walCoin, walrus, walrusFor } from "./plugins/walrus/index.mjs";
+import { SealAnyError, SealConfigError, SealError } from "./plugins/seal/errors.mjs";
+import { SealKeyServer, SealKeyServerEntry, SealKnownResolved, SealLocalKeygenResolved, SealResolved } from "./plugins/seal/registry-publish.mjs";
+import { SealBindings } from "./plugins/seal/codegen.mjs";
+import { SealCommonOptions, SealForkKnownOptions, SealLiveOptions, SealLocalKeygenOptions, SealOptions, seal, sealFor } from "./plugins/seal/index.mjs";
+import { DeepbookConfigError, DeepbookError, DeepbookPhase, DeepbookPluginError } from "./plugins/deepbook/errors.mjs";
+import { AccountMemberAlias, CoinMemberAlias, DEEP_PRICE_FEED_ID, DeepbookPackageMember, DeepbookPool, DeepbookPoolCoin, DeepbookPoolSeedLiquidity, DeepbookPoolSeedOrder, DeepbookPoolSpec, PythFeed, PythHandle, PythOptions, PythPackageMember, PythPriceFeedId, SUI_PRICE_FEED_ID, USDC_PRICE_FEED_ID, pythPriceFeedId } from "./plugins/deepbook/types.mjs";
+import { DeepbookBindings, DeepbookPoolBinding } from "./plugins/deepbook/codegen.mjs";
+import { DeepbookCommonOptions, DeepbookKnownNetwork, DeepbookKnownOptions, DeepbookOptions, DeepbookOverrideOptions, DeepbookResolved, deepbookCore, deepbookFor } from "./plugins/deepbook/index.mjs";
+export { type AccountAcquireError, type AccountAcquirePhase, type AccountBindings, type AccountError, type AccountFunding, type AccountFundingCoinValue, type AccountFundingEntry, type AccountFundingRequest, type AccountFundingResult, type AccountFundingStrategy, type AccountMemberAlias, type AccountOptions, type AccountSignError, type AccountSignPhase, type AccountValue, type AccountVariantKind, type ActionBuildContext, type ActionError, type ActionOptions, type ActionPhase, type ActionReceipt, type ActionUpstreamRef, type AnyPlugin, type AnyResourceRef, type AppName, BUILTIN_COINS, type BootError, type Brand, type BuildCtx, type BuiltinCoinName, type CapabilityDecl, type CapabilityKind, type CapabilityPayloadFor, type ChainId, type ChainProbe, type ChainProbeError, type ChainProbeMode, type CodegenEmitContext, type CodegenEmitDone, type CodegenableDecl, type CoinAddressForm, type CoinBindings, type CoinError, type CoinMember, type CoinMemberAlias, type CoinPhase, type CoinValue, config_validation_d_exports as ConfigValidation, type ContainerHandle, type ContainerLabelTuple, type ContainerRuntime, type ContainerRuntimeError, ContainerRuntimeService, type ContentHash, type CrossCuttingFundingEntry, type CrossCuttingFundingProvider, DEEP_PRICE_FEED_ID, DEFAULT_EPHEMERAL_FUND_MIST, type DatabaseCreateFailed, type DeepbookBindings, type DeepbookCommonOptions, type DeepbookConfigError, type DeepbookError, type DeepbookKnownNetwork, type DeepbookKnownOptions, type DeepbookOptions, type DeepbookOverrideOptions, type DeepbookPackageMember, type DeepbookPhase, type DeepbookPluginError, type DeepbookPool, type DeepbookPoolBinding, type DeepbookPoolCoin, type DeepbookPoolSeedLiquidity, type DeepbookPoolSeedOrder, type DeepbookPoolSpec, type DeepbookResolved, type DefaultNetwork, type DependencyInput, type DependencyList, type DevstackCapabilityRegistry, type DevstackNetworkModeRegistry, type DevstackOptions, type DevstackOptionsWith, type DevstackRoutableUpstreamRegistry, type DiscoveredCoin, type DispatchId, type EndpointKey, type ExactCapabilityPayload, type FactoriesByMode, type FactoriesFor, type FaucetBodyError, type FaucetConfigError, type FaucetError, type FaucetExhausted, type FaucetStrategy, type FaucetStrategyContribution, type FaucetUnreachable, type ForkUnsupportedError, type FundsReadyError, type FundsReadyStrategy, HOST_SERVICE_PORT_TOKEN, type HostServiceError, type HostServiceOptions, type HostServiceReadyProbe, type HostServiceValue, http_probe_d_exports as HttpProbes, IdentityContext, type ImageRef, type KnownPackageOptions, type KnownPackageResolved, type LifecycleStatus, type LivenessClassification, type LivenessClassifierDecl, type LivenessHints, type LoadedImageBundle, type LocalPackageOptions, type LocalPackageResolved, type LogLevel, type LogLine, type LogPayload, Logger, type LoggerShape, managed_container_d_exports as ManagedContainers, type ManifestExtras, type ManifestExtrasContext, type ManifestExtrasInput, type ModeNamespace, type NetworkConfig, type NetworkMode, type PackageBindings, type PackageCapture, type PackageMember, type PackageResolved, type PhaseNarration, type Plugin, type PluginRole, type PluginSpec, type Postgres, type PostgresConfigError, type PostgresConnectionBindings, type PostgresConnectionParts, type PostgresConnectionTimeout, type PostgresError, type PostgresPhase, type PostgresPluginError, type PostgresPluginOptions, type PostgresServiceOptions, probes_d_exports as Probes, process_lines_d_exports as ProcessLines, process_supervisor_d_exports as ProcessSupervisor, type ProjectionDecl, type ProjectionEvent, type PublishError, type PublisherAccountMember, type PythFeed, type PythHandle, type PythOptions, type PythPackageMember, type PythPriceFeedId, redaction_d_exports as Redaction, type RedactionRule, Redactor, type ResolvedCoin, type ResolvedDependencies, type ResolvedKeypair, type ResolvedKnownPackage, type ResolvedLocalPackage, type ResolvedSuiNetwork, type ResourceIdOf, type ResourceRef, type ResourceValueOf, retry_policy_d_exports as RetryPolicy, type RoutableDecl, type RoutableHttpDecl, type RoutableTcpDecl, type RoutableUpstream, type RoutableUpstreamKind, type RunHandle, type RunStackIdentityOptions, type RunStackOptions, runtime_decode_d_exports as RuntimeDecode, SUI_FULL_COIN_TYPE, SUI_PRICE_FEED_ID, type SealError as SealAcquireError, type SealAnyError, type SealBindings, type SealCommonOptions, type SealConfigError, type SealError, type SealForkKnownOptions, type SealKeyServer, type SealKeyServerEntry, type SealKnownResolved, type SealLiveOptions, type SealLocalKeygenOptions, type SealLocalKeygenResolved, type SealOptions, type SealResolved, type SeedManifestMismatchError, type SignatureScheme, type SnapshotableDecl, type Stack, type StackName, type StrategyContributorDecl, type StrategyFor, type SuiCliError, type SuiConfigError, type SuiError, type SuiForkOptions, type SuiFundingEntry, type SuiFundsReadyError, type SuiLiveOptions, type SuiLocalOptions, type SuiLocalRpcOptions, type SuiNetworkBindings, type SuiOptions, type SuiPluginError, type SyntheticImpersonationSigner, type TagBuffer, type TaggedImageRef, type TxResult, USDC_PRICE_FEED_ID, type WalCoinValue, type WalletAccountMember, type WalletBootError, type WalletBootPhase, type WalletError, type WalletOptions, type WalletRequestError, type WalletRequestPhase, type WalletValue, type WalrusBindings, type WalrusConfigError, type WalrusError, type WalrusKnownDeploymentOptions, type WalrusKnownNetwork, type WalrusLocalClusterOptions, type WalrusNodeBinding, type WalrusPhase, type WalrusPluginError, type WalrusResolved, type WalrusStorageNode, account, action, appName, capability, capabilitySink, chainId, codegenable, coin, contentHash, deepbookCore as deepbook, deepbookFor, defineCapability, defineDevstack, defineDevstackWith, defineFaucetStrategy, defineId, defineModeNamespace, definePlugin, endpointKey, hostService, isBareCoinType, knownPackage, localPackage, postgres, projection, pythPriceFeedId, resource, routable, runStack, seal, sealFor, snapshotable, stackName, strategyContributor, sui, suiFor, validateBareCoinType, walCoin, wallet, walrus, walrusFor };

package/dist/index.mjs

@@ -0,0 +1,37 @@
+import { defineId, definePlugin, resource } from "./substrate/plugin.mjs";
+import { IdentityContext } from "./substrate/runtime/paths.mjs";
+import { runtime_decode_exports } from "./substrate/runtime/runtime-decode.mjs";
+import { defineModeNamespace } from "./api/mode-narrowed-factory.mjs";
+import { appName, chainId, contentHash, endpointKey, stackName } from "./substrate/brand.mjs";
+import { process_lines_exports } from "./substrate/runtime/observability/process-lines.mjs";
+import { probes_exports } from "./substrate/runtime/probes.mjs";
+import { ContainerRuntimeService } from "./runtime/docker/service.mjs";
+import { config_validation_exports } from "./substrate/runtime/config-validation.mjs";
+import { http_probe_exports } from "./substrate/runtime/http-probe.mjs";
+import { managed_container_exports } from "./substrate/runtime/managed-container.mjs";
+import { retry_policy_exports } from "./substrate/runtime/retry-policy.mjs";
+import { sui, suiFor } from "./plugins/sui/index.mjs";
+import { Redactor, redaction_exports } from "./substrate/runtime/observability/redaction.mjs";
+import { Logger } from "./substrate/runtime/observability/logger.mjs";
+import { wallet } from "./plugins/wallet/index.mjs";
+import { defineDevstack } from "./api/define-devstack.mjs";
+import { defineDevstackWith } from "./api/define-devstack-with.mjs";
+import { process_supervisor_exports } from "./substrate/runtime/process-supervisor.mjs";
+import { runStack } from "./api/run-stack.mjs";
+import { capability, capabilitySink, codegenable, defineCapability, projection, routable, snapshotable, strategyContributor } from "./api/define-capabilities.mjs";
+import { DEFAULT_EPHEMERAL_FUND_MIST, SUI_FULL_COIN_TYPE } from "./plugins/account/funding.mjs";
+import { account } from "./plugins/account/index.mjs";
+import { knownPackage, localPackage } from "./plugins/package/index.mjs";
+import { isBareCoinType, validateBareCoinType } from "./plugins/coin/metadata.mjs";
+import { BUILTIN_COINS } from "./plugins/coin/address-resolution.mjs";
+import { coin } from "./plugins/coin/index.mjs";
+import { HOST_SERVICE_PORT_TOKEN } from "./plugins/host-service/service.mjs";
+import { hostService } from "./plugins/host-service/index.mjs";
+import { postgres } from "./plugins/postgres/index.mjs";
+import { defineFaucetStrategy } from "./plugins/faucet/index.mjs";
+import { action } from "./plugins/action/index.mjs";
+import { walCoin, walrus, walrusFor } from "./plugins/walrus/index.mjs";
+import { seal, sealFor } from "./plugins/seal/index.mjs";
+import { DEEP_PRICE_FEED_ID, SUI_PRICE_FEED_ID, USDC_PRICE_FEED_ID, pythPriceFeedId } from "./plugins/deepbook/types.mjs";
+import { deepbookCore, deepbookFor } from "./plugins/deepbook/index.mjs";
+export { BUILTIN_COINS, config_validation_exports as ConfigValidation, ContainerRuntimeService, DEEP_PRICE_FEED_ID, DEFAULT_EPHEMERAL_FUND_MIST, HOST_SERVICE_PORT_TOKEN, http_probe_exports as HttpProbes, IdentityContext, Logger, managed_container_exports as ManagedContainers, probes_exports as Probes, process_lines_exports as ProcessLines, process_supervisor_exports as ProcessSupervisor, redaction_exports as Redaction, Redactor, retry_policy_exports as RetryPolicy, runtime_decode_exports as RuntimeDecode, SUI_FULL_COIN_TYPE, SUI_PRICE_FEED_ID, USDC_PRICE_FEED_ID, account, action, appName, capability, capabilitySink, chainId, codegenable, coin, contentHash, deepbookCore as deepbook, deepbookFor, defineCapability, defineDevstack, defineDevstackWith, defineFaucetStrategy, defineId, defineModeNamespace, definePlugin, endpointKey, hostService, isBareCoinType, knownPackage, localPackage, postgres, projection, pythPriceFeedId, resource, routable, runStack, seal, sealFor, snapshotable, stackName, strategyContributor, sui, suiFor, validateBareCoinType, walCoin, wallet, walrus, walrusFor };

package/dist/orchestrators/codegen/bindings.d.mts

@@ -0,0 +1,2 @@
+import { Context, Effect, FileSystem, Layer } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";