@sealant/sdk 0.0.0

package/dist/effect/api-client.js

@@ -0,0 +1,29 @@
+/**
+ * The control-plane wire client — DERIVED, never hand-written.
+ *
+ * `HttpApiClient.make(ControlPlaneAPI)` generates a fully-typed client directly from the
+ * `@sealant/api-contracts` Effect `HttpApi` definition (the single source of truth): requests are
+ * encoded and responses decoded by the SAME `Schema`s, and the typed error channel carries the same
+ * `TaggedError`s the server declares. No codegen step, no generated artifact, no drift — change the
+ * contract and these call sites move with it. (OpenAPI/`buf generate` is reserved for non-TypeScript
+ * clients, per SEALANT-PLAN §8.)
+ */
+import { ControlPlaneAPI } from "@sealant/api-contracts";
+import { Context, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { HttpApiClient } from "effect/unstable/httpapi";
+/** Builds the contract-derived client. Requires an `HttpClient` in context (provided by the layer). */
+const buildControlPlaneClient = (config) => {
+    const { apiKey } = config;
+    if (apiKey === undefined) {
+        return HttpApiClient.make(ControlPlaneAPI, { baseUrl: config.baseUrl });
+    }
+    return HttpApiClient.make(ControlPlaneAPI, {
+        baseUrl: config.baseUrl,
+        transformClient: (client) => HttpClient.mapRequest(client, HttpClientRequest.bearerToken(apiKey)),
+    });
+};
+export class SealantApiClient extends Context.Service()("@sealant/sdk/SealantApiClient") {
+}
+/** Live layer: derives the client over the global-fetch `HttpClient`, with an optional bearer token. */
+export const sealantApiClientLayer = (config) => Layer.effect(SealantApiClient, buildControlPlaneClient(config)).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/effect/operations.d.ts

@@ -0,0 +1,236 @@
+import { Effect } from "effect";
+import { SealantApiClient } from "./api-client.js";
+export declare const createSandboxOp: (payload: {
+    readonly ownerUserId: string;
+    readonly registryId: string;
+    readonly repository: string;
+    readonly tag: string;
+    readonly name?: string | undefined;
+    readonly sourceSelection?: {
+        readonly provider: "github";
+        readonly installationId: string;
+        readonly installationRepositoryId: string;
+        readonly ref?: string | undefined;
+    } | undefined;
+    readonly dotfilesSelection?: {
+        readonly provider: "github";
+        readonly installationId: string;
+        readonly installationRepositoryId: string;
+        readonly ref?: string | undefined;
+    } | undefined;
+    readonly credentials?: {
+        readonly profileId?: string | undefined;
+        readonly claude?: string | undefined;
+        readonly codex?: string | undefined;
+        readonly github?: string | undefined;
+    } | undefined;
+    readonly spec: unknown;
+}, idempotencyKey?: string | undefined) => Effect.Effect<{
+    readonly sandboxId: string;
+    readonly name: string;
+    readonly status: "cancelled" | "failed" | "queued" | "ready" | "running";
+    readonly registryId: string;
+    readonly repository: string;
+    readonly tag: string;
+}, import("effect/unstable/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").SandboxBadGatewayError | import("@sealant/api-contracts").SandboxBadRequestError | import("@sealant/api-contracts").SandboxConflictError | import("@sealant/api-contracts").SandboxForbiddenError | import("@sealant/api-contracts").SandboxInternalServerError | import("@sealant/api-contracts").SandboxNotFoundError | import("@sealant/api-contracts").SandboxServiceUnavailableError | import("effect/Schema").SchemaError, SealantApiClient>;
+export declare const getSandboxOp: (sandboxId: string) => Effect.Effect<{
+    readonly sandboxId: string;
+    readonly name: string;
+    readonly ownerUserId: string;
+    readonly status: "cancelled" | "failed" | "queued" | "ready" | "running";
+    readonly registryId?: string | undefined;
+    readonly repository?: string | undefined;
+    readonly tag?: string | undefined;
+    readonly runtime?: {
+        readonly adapter: "docker" | "k3s" | "k8s";
+        readonly resourceId: string;
+        readonly reference: string;
+        readonly status: "failed" | "pending" | "ready" | "running" | "stopped";
+        readonly endpoint?: string | undefined;
+    } | undefined;
+    readonly publishedImage?: {
+        readonly reference: string;
+        readonly digestReference: string;
+        readonly digest: string;
+    } | undefined;
+    readonly error?: {
+        readonly message: string;
+        readonly code?: string | undefined;
+    } | undefined;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly startedAt?: string | undefined;
+    readonly finishedAt?: string | undefined;
+    readonly spec?: unknown;
+}, unknown, SealantApiClient>;
+export declare const listSandboxesOp: (query: {
+    readonly ownerUserId: string;
+    readonly status?: "cancelled" | "failed" | "queued" | "ready" | "running" | undefined;
+    readonly limit?: string | undefined;
+}) => Effect.Effect<{
+    readonly items: readonly {
+        readonly sandboxId: string;
+        readonly name: string;
+        readonly ownerUserId: string;
+        readonly status: "cancelled" | "failed" | "queued" | "ready" | "running";
+        readonly registryId?: string | undefined;
+        readonly repository?: string | undefined;
+        readonly tag?: string | undefined;
+        readonly runtime?: {
+            readonly adapter: "docker" | "k3s" | "k8s";
+            readonly resourceId: string;
+            readonly reference: string;
+            readonly status: "failed" | "pending" | "ready" | "running" | "stopped";
+            readonly endpoint?: string | undefined;
+        } | undefined;
+        readonly publishedImage?: {
+            readonly reference: string;
+            readonly digestReference: string;
+            readonly digest: string;
+        } | undefined;
+        readonly error?: {
+            readonly message: string;
+            readonly code?: string | undefined;
+        } | undefined;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly startedAt?: string | undefined;
+        readonly finishedAt?: string | undefined;
+    }[];
+}, import("effect/unstable/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").SandboxBadRequestError | import("@sealant/api-contracts").SandboxInternalServerError | import("effect/Schema").SchemaError, SealantApiClient>;
+export declare const createRunOp: (payload: {
+    readonly sandboxId: string;
+    readonly harnessId: string;
+    readonly ownerUserId: string;
+    readonly mode?: "interactive" | "one-shot" | undefined;
+    readonly prompt?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly command?: {
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly cwd?: string | undefined;
+    } | undefined;
+}) => Effect.Effect<{
+    readonly runId: string;
+    readonly sandboxId: string;
+    readonly attemptId?: string | undefined;
+    readonly ownerUserId: string;
+    readonly harnessId: string;
+    readonly mode: "interactive" | "one-shot";
+    readonly status: "cancelled" | "completed" | "failed" | "queued" | "running";
+    readonly prompt?: string | undefined;
+    readonly exitCode?: number | undefined;
+    readonly errorMessage?: string | undefined;
+    readonly startedAt?: string | undefined;
+    readonly finishedAt?: string | undefined;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}, unknown, SealantApiClient>;
+export declare const getRunOp: (runId: string) => Effect.Effect<{
+    readonly runId: string;
+    readonly sandboxId: string;
+    readonly attemptId?: string | undefined;
+    readonly ownerUserId: string;
+    readonly harnessId: string;
+    readonly mode: "interactive" | "one-shot";
+    readonly status: "cancelled" | "completed" | "failed" | "queued" | "running";
+    readonly prompt?: string | undefined;
+    readonly exitCode?: number | undefined;
+    readonly errorMessage?: string | undefined;
+    readonly startedAt?: string | undefined;
+    readonly finishedAt?: string | undefined;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}, unknown, SealantApiClient>;
+export declare const listRunsOp: (query: {
+    readonly sandboxId?: string | undefined;
+    readonly ownerUserId?: string | undefined;
+    readonly status?: "cancelled" | "completed" | "failed" | "queued" | "running" | undefined;
+    readonly limit?: string | undefined;
+}) => Effect.Effect<{
+    readonly items: readonly {
+        readonly runId: string;
+        readonly sandboxId: string;
+        readonly attemptId?: string | undefined;
+        readonly ownerUserId: string;
+        readonly harnessId: string;
+        readonly mode: "interactive" | "one-shot";
+        readonly status: "cancelled" | "completed" | "failed" | "queued" | "running";
+        readonly prompt?: string | undefined;
+        readonly exitCode?: number | undefined;
+        readonly errorMessage?: string | undefined;
+        readonly startedAt?: string | undefined;
+        readonly finishedAt?: string | undefined;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    }[];
+}, import("effect/unstable/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("effect/Schema").SchemaError, SealantApiClient>;
+export declare const updateRunOp: (runId: string, payload: {
+    readonly status?: "cancelled" | "completed" | "failed" | "queued" | "running" | undefined;
+    readonly exitCode?: number | undefined;
+    readonly errorMessage?: string | undefined;
+}) => Effect.Effect<{
+    readonly runId: string;
+    readonly sandboxId: string;
+    readonly attemptId?: string | undefined;
+    readonly ownerUserId: string;
+    readonly harnessId: string;
+    readonly mode: "interactive" | "one-shot";
+    readonly status: "cancelled" | "completed" | "failed" | "queued" | "running";
+    readonly prompt?: string | undefined;
+    readonly exitCode?: number | undefined;
+    readonly errorMessage?: string | undefined;
+    readonly startedAt?: string | undefined;
+    readonly finishedAt?: string | undefined;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}, unknown, SealantApiClient>;
+export declare const getRunTimelineOp: (runId: string, query: {
+    readonly fromSequence?: string | undefined;
+    readonly toSequence?: string | undefined;
+    readonly limit?: string | undefined;
+    readonly kinds?: string | undefined;
+}) => Effect.Effect<readonly {
+    readonly eventId: string;
+    readonly sequence: string;
+    readonly kind: string;
+    readonly occurredAt: string;
+    readonly summary: string;
+    readonly ref?: unknown;
+    readonly processId?: string | undefined;
+    readonly captureMethod: number;
+    readonly confidence: number;
+}[], unknown, SealantApiClient>;
+export declare const getRunScrollbackOp: (runId: string, query: {
+    readonly processId: string;
+    readonly stream: "stderr" | "stdout";
+    readonly atSequence?: string | undefined;
+}) => Effect.Effect<{
+    readonly processId: string;
+    readonly stream: "stderr" | "stdout";
+    readonly byteCount: number;
+    readonly contentBase64: string;
+}, unknown, SealantApiClient>;
+export declare const getRunLossOp: (runId: string) => Effect.Effect<{
+    readonly runId: string;
+    readonly droppedEventCount: string;
+    readonly sequenceGapCount: number;
+    readonly watchOverflowCount: number;
+    readonly earlyClose: boolean;
+    readonly spans: readonly {
+        readonly kind: "dropped_event" | "early_close" | "sequence_gap" | "watch_overflow";
+        readonly fromSequence?: string | undefined;
+        readonly toSequence?: string | undefined;
+        readonly droppedCount?: string | undefined;
+        readonly detectedVia: "gap" | "marker";
+        readonly reason?: string | undefined;
+    }[];
+}, unknown, SealantApiClient>;
+export declare const getRunChangesOp: (runId: string) => Effect.Effect<{
+    readonly files: readonly {
+        readonly path: string;
+        readonly change: "added" | "deleted" | "modified" | "renamed";
+        readonly oldPath?: string | undefined;
+    }[];
+    readonly diff: string;
+}, unknown, SealantApiClient>;

package/dist/effect/operations.js

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { SealantApiClient } from "./api-client.js";
+// ---- sandboxes ----
+export const createSandboxOp = (payload, idempotencyKey) => Effect.flatMap(SealantApiClient, (client) => client.sandboxes.createSandbox({
+    payload,
+    headers: idempotencyKey === undefined ? {} : { "idempotency-key": idempotencyKey },
+}));
+export const getSandboxOp = (sandboxId) => Effect.flatMap(SealantApiClient, (client) => client.sandboxes.getSandbox({ params: { sandboxId } }));
+export const listSandboxesOp = (query) => Effect.flatMap(SealantApiClient, (client) => client.sandboxes.listSandboxes({ query }));
+// ---- runs ----
+export const createRunOp = (payload) => Effect.flatMap(SealantApiClient, (client) => client.runs.createRun({ payload }));
+export const getRunOp = (runId) => Effect.flatMap(SealantApiClient, (client) => client.runs.getRun({ params: { runId } }));
+export const listRunsOp = (query) => Effect.flatMap(SealantApiClient, (client) => client.runs.listRuns({ query }));
+export const updateRunOp = (runId, payload) => Effect.flatMap(SealantApiClient, (client) => client.runs.updateRun({ params: { runId }, payload }));
+export const getRunTimelineOp = (runId, query) => Effect.flatMap(SealantApiClient, (client) => Effect.map(client.runs.getRunTimeline({ params: { runId }, query }), (r) => r.items));
+export const getRunScrollbackOp = (runId, query) => Effect.flatMap(SealantApiClient, (client) => client.runs.getRunScrollback({ params: { runId }, query }));
+export const getRunLossOp = (runId) => Effect.flatMap(SealantApiClient, (client) => client.runs.getRunLoss({ params: { runId } }));
+export const getRunChangesOp = (runId) => Effect.flatMap(SealantApiClient, (client) => client.runs.getRunChanges({ params: { runId } }));

package/dist/effect/run-harness.d.ts

@@ -0,0 +1,9 @@
+import type { RunHarnessFn } from "../facade/sandbox.js";
+/** The BLOCKING `harness.run()` implementation, registered into the Sandbox facade by the client. */
+export declare const runHarness: RunHarnessFn;
+/**
+ * The NON-BLOCKING `harness.start()` implementation: register the run and return the live handle
+ * immediately. Callers stream progress via `run.record.stream()` and settle via `run.wait()` (which
+ * fetches the captured changes once terminal).
+ */
+export declare const startHarness: RunHarnessFn;

package/dist/effect/run-harness.js

@@ -0,0 +1,63 @@
+/**
+ * `harness.run()` / `harness.start()` — the one-shot execution paths, THIN HTTP CLIENTS.
+ *
+ * The SDK no longer execs the harness or writes telemetry itself (that moved server-side into the
+ * worker). Both paths register a run via the control plane WITH the harness command (so the control
+ * plane executes it). `run()` then polls until the run reaches a terminal status and reads the
+ * captured changes; `start()` returns the live handle immediately (stream via `run.record.stream()`,
+ * settle via `run.wait()`). No Postgres pool, no docker-exec, no telemetry sink: this is what makes
+ * @sealant/sdk a plain client that runs anywhere.
+ */
+import { Effect } from "effect";
+import { SealantError } from "../errors.js";
+import { makeRun, toRunChangesData } from "../facade/run.js";
+import { createRunOp, getRunChangesOp, getRunOp } from "./operations.js";
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled"]);
+const POLL_INTERVAL = "500 millis";
+const RUN_TIMEOUT_MS = 30 * 60 * 1_000;
+/**
+ * Registers the run WITH the harness command — the control plane executes it server-side (the worker
+ * docker-execs it and ingests telemetry). The cwd is the sandbox repo, which the worker defaults to.
+ */
+const createHarnessRunEffect = (ctx, init, prompt) => Effect.gen(function* () {
+    const harness = init.harness;
+    if (harness === undefined) {
+        return yield* Effect.fail(new SealantError("This sandbox handle has no harness; use the handle returned by sandboxes.create().", { code: "harness_required" }));
+    }
+    const command = harness.buildRunCommand(prompt);
+    return yield* createRunOp({
+        sandboxId: init.id,
+        ownerUserId: ctx.config.hostLocal.ownerUserId,
+        harnessId: harness.id,
+        mode: "one-shot",
+        prompt,
+        command: { executable: command.executable, args: [...command.args] },
+    });
+});
+const runHarnessEffect = (ctx, init, prompt) => Effect.gen(function* () {
+    const created = yield* createHarnessRunEffect(ctx, init, prompt);
+    const runId = created.runId;
+    // Block until the run is terminal, polling the control plane.
+    const deadline = Date.now() + RUN_TIMEOUT_MS;
+    let wire = created;
+    while (!TERMINAL_STATUSES.has(wire.status)) {
+        if (Date.now() > deadline) {
+            return yield* Effect.fail(new SealantError(`Timed out waiting for run ${runId} to complete.`, {
+                code: "run_timeout",
+            }));
+        }
+        yield* Effect.sleep(POLL_INTERVAL);
+        wire = yield* getRunOp(runId);
+    }
+    // Read the changes the run produced (captured server-side).
+    const changes = toRunChangesData(yield* getRunChangesOp(runId));
+    return makeRun(ctx, { wire, changes });
+});
+/** The BLOCKING `harness.run()` implementation, registered into the Sandbox facade by the client. */
+export const runHarness = (ctx, init, prompt) => ctx.runtime.run(runHarnessEffect(ctx, init, prompt));
+/**
+ * The NON-BLOCKING `harness.start()` implementation: register the run and return the live handle
+ * immediately. Callers stream progress via `run.record.stream()` and settle via `run.wait()` (which
+ * fetches the captured changes once terminal).
+ */
+export const startHarness = (ctx, init, prompt) => ctx.runtime.run(Effect.map(createHarnessRunEffect(ctx, init, prompt), (created) => makeRun(ctx, { wire: created })));

package/dist/effect/runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The SDK runtime — the Effect-core boundary the Promise facade runs against.
+ *
+ * The app `Layer` is built ONCE into a process-lifetime `Scope`, lazily and memoized. It provides a
+ * single service — `SealantApiClient`, the contract-derived control-plane client — so the SDK is a
+ * THIN HTTP CLIENT: every operation (create/run/read) is an HTTP call to `baseUrl`. Run execution and
+ * telemetry ingest moved SERVER-SIDE (the worker), so the SDK no longer opens a Postgres pool, spawns
+ * docker, or writes telemetry. Every operation surfaces a plain `SealantError` (the typed Effect
+ * failure is squashed and mapped here). `dispose()` closes the scope (the HTTP client) and is idempotent.
+ */
+import { Effect } from "effect";
+import type { SealantInternalConfig } from "../internal/config.js";
+import { SealantApiClient } from "./api-client.js";
+/** Services the SDK runtime provides to operation effects. */
+export type SdkServices = SealantApiClient;
+export interface SdkRuntime {
+    /** Provide the app context and run an operation effect, surfacing plain `SealantError`s. */
+    readonly run: <A, E, R extends SdkServices>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+    /** Dispose the runtime scope (the HTTP client). Idempotent. */
+    readonly dispose: () => Promise<void>;
+}
+export declare const makeSdkRuntime: (config: SealantInternalConfig) => SdkRuntime;

package/dist/effect/runtime.js

@@ -0,0 +1,63 @@
+/**
+ * The SDK runtime — the Effect-core boundary the Promise facade runs against.
+ *
+ * The app `Layer` is built ONCE into a process-lifetime `Scope`, lazily and memoized. It provides a
+ * single service — `SealantApiClient`, the contract-derived control-plane client — so the SDK is a
+ * THIN HTTP CLIENT: every operation (create/run/read) is an HTTP call to `baseUrl`. Run execution and
+ * telemetry ingest moved SERVER-SIDE (the worker), so the SDK no longer opens a Postgres pool, spawns
+ * docker, or writes telemetry. Every operation surfaces a plain `SealantError` (the typed Effect
+ * failure is squashed and mapped here). `dispose()` closes the scope (the HTTP client) and is idempotent.
+ */
+import { Cause, Context, Effect, Exit, Layer, Scope } from "effect";
+import { toSealantError } from "../internal/map-error.js";
+import { SealantApiClient, sealantApiClientLayer } from "./api-client.js";
+// A single service: the contract-derived HTTP client. No DB pool, no docker-exec, no telemetry sink.
+const makeAppLayer = (config) => sealantApiClientLayer(config);
+export const makeSdkRuntime = (config) => {
+    const appLayer = makeAppLayer(config);
+    let built;
+    const build = () => {
+        if (built === undefined) {
+            built = Effect.runPromiseExit(Effect.gen(function* () {
+                const scope = yield* Scope.make();
+                const context = yield* Layer.buildWithScope(appLayer, scope);
+                // The layer provides a superset of SdkServices; narrow to the surfaced services.
+                return { context: context, scope };
+            })).then((exit) => {
+                if (Exit.isSuccess(exit)) {
+                    return exit.value;
+                }
+                // The layer's error channel is non-`never` (e.g. SqlError: the DB pool can fail to construct),
+                // so route a build failure through the SAME funnel as operations instead of leaking a raw
+                // Effect/SQL error out of the public Promise API. Reset memoization so a transient first-build
+                // failure (DB momentarily down) can be retried instead of poisoning the runtime forever.
+                built = undefined;
+                throw toSealantError(Cause.squash(exit.cause));
+            });
+        }
+        return built;
+    };
+    return {
+        run: async (effect) => {
+            const { context } = await build();
+            // R extends SdkServices and the context provides SdkServices, so all requirements are met
+            // (TS can't reduce Exclude<R, SdkServices> to never for a generic R).
+            const provided = Effect.provide(effect, context);
+            const exit = await Effect.runPromiseExit(provided);
+            if (Exit.isSuccess(exit)) {
+                return exit.value;
+            }
+            // Squash the Cause to its underlying failure/defect value, then map to a plain error.
+            throw toSealantError(Cause.squash(exit.cause));
+        },
+        dispose: async () => {
+            if (built === undefined) {
+                return;
+            }
+            const current = built;
+            built = undefined;
+            const { scope } = await current;
+            await Effect.runPromise(Scope.close(scope, Exit.succeed(undefined)));
+        },
+    };
+};

package/dist/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Public SDK errors. The Effect core fails on a typed `Schema.TaggedError` channel; the facade maps
+ * every tagged failure onto one of these PLAIN `Error` subclasses (a single `_tag` switch) so the
+ * public, Promise-based surface never leaks Effect internals. Consumers `catch` ordinary `Error`s.
+ */
+/** Base class for every error the SDK throws. */
+export declare class SealantError extends Error {
+    readonly name: string;
+    /** Stable, machine-readable code for branching on the failure. */
+    readonly code: string;
+    constructor(message: string, options?: {
+        readonly code?: string;
+        readonly cause?: unknown;
+    });
+}
+/** A typed control/transport failure from the sandbox runtime daemon. */
+export declare class SealantRuntimeError extends SealantError {
+    readonly name = "SealantRuntimeError";
+    constructor(message: string, options?: {
+        readonly code?: string;
+        readonly cause?: unknown;
+    });
+}
+/** A control-plane API request failed (HTTP-level or typed API error). */
+export declare class SealantApiError extends SealantError {
+    readonly name = "SealantApiError";
+    /** HTTP status, when the failure came from a response. */
+    readonly status?: number;
+    constructor(message: string, options?: {
+        readonly code?: string;
+        readonly status?: number;
+        readonly cause?: unknown;
+    });
+}
+/** The requested operation is part of the public surface but not yet implemented in this slice. */
+export declare class SealantNotImplementedError extends SealantError {
+    readonly name = "SealantNotImplementedError";
+    constructor(operation: string);
+}

package/dist/errors.js

@@ -0,0 +1,47 @@
+/**
+ * Public SDK errors. The Effect core fails on a typed `Schema.TaggedError` channel; the facade maps
+ * every tagged failure onto one of these PLAIN `Error` subclasses (a single `_tag` switch) so the
+ * public, Promise-based surface never leaks Effect internals. Consumers `catch` ordinary `Error`s.
+ */
+/** Base class for every error the SDK throws. */
+export class SealantError extends Error {
+    name = "SealantError";
+    /** Stable, machine-readable code for branching on the failure. */
+    code;
+    constructor(message, options) {
+        super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.code = options?.code ?? "sealant_error";
+    }
+}
+/** A typed control/transport failure from the sandbox runtime daemon. */
+export class SealantRuntimeError extends SealantError {
+    name = "SealantRuntimeError";
+    constructor(message, options) {
+        super(message, {
+            code: options?.code ?? "runtime_error",
+            ...(options?.cause === undefined ? {} : { cause: options.cause }),
+        });
+    }
+}
+/** A control-plane API request failed (HTTP-level or typed API error). */
+export class SealantApiError extends SealantError {
+    name = "SealantApiError";
+    /** HTTP status, when the failure came from a response. */
+    status;
+    constructor(message, options) {
+        super(message, {
+            code: options?.code ?? "api_error",
+            ...(options?.cause === undefined ? {} : { cause: options.cause }),
+        });
+        if (options?.status !== undefined) {
+            this.status = options.status;
+        }
+    }
+}
+/** The requested operation is part of the public surface but not yet implemented in this slice. */
+export class SealantNotImplementedError extends SealantError {
+    name = "SealantNotImplementedError";
+    constructor(operation) {
+        super(`${operation} is part of the Sealant SDK surface but is not implemented in this build yet.`, { code: "not_implemented" });
+    }
+}

package/dist/facade/context.d.ts

@@ -0,0 +1,9 @@
+import type { SdkRuntime } from "../effect/runtime.js";
+import type { SealantInternalConfig } from "../internal/config.js";
+/** What every facade object needs: the execution boundary and the resolved (host-local) config. */
+export interface SdkContext {
+    readonly runtime: SdkRuntime;
+    readonly config: SealantInternalConfig;
+}
+/** An AsyncIterable whose iteration rejects — for surface that is typed now but not yet implemented. */
+export declare const notImplementedAsyncIterable: <A>(operation: string, error: Error) => AsyncIterable<A>;

package/dist/facade/context.js

@@ -0,0 +1,9 @@
+/** An AsyncIterable whose iteration rejects — for surface that is typed now but not yet implemented. */
+export const notImplementedAsyncIterable = (operation, error) => ({
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => Promise.reject(error),
+            return: () => Promise.resolve({ done: true, value: undefined }),
+        };
+    },
+});

package/dist/facade/record.d.ts

@@ -0,0 +1,20 @@
+import type { RunCommand, RunRecord } from "../types.js";
+import type { SdkContext } from "./context.js";
+/**
+ * Folds the timeline into the ordered list of terminal commands. Process boundaries are
+ * `processStarted`/`processExited`; `ioChunk` byte counts accrue to the current command. Daemon noise
+ * (`runtimeStateChanged`, and the boot foreground we never `processStarted`) is skipped naturally.
+ */
+export declare const reconstructCommands: (entries: readonly {
+    readonly eventId: string;
+    readonly sequence: string;
+    readonly kind: string;
+    readonly occurredAt: string;
+    readonly summary: string;
+    readonly ref?: unknown;
+    readonly processId?: string | undefined;
+    readonly captureMethod: number;
+    readonly confidence: number;
+}[]) => RunCommand[];
+export declare const renderTranscript: (commands: readonly RunCommand[]) => string;
+export declare const makeRunRecord: (ctx: SdkContext, runId: string) => RunRecord;