@sealant/sdk 0.3.0 → 0.4.0

package/dist/effect/operations.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { SealantApiClient } from "./api-client.js";
-export declare const createSandboxOp: (payload: {
+export declare const createWorkspaceOp: (payload: {
     readonly ownerUserId: string;
     readonly registryId: string;
     readonly repository: string;
@@ -26,15 +26,15 @@ export declare const createSandboxOp: (payload: {
     } | undefined;
     readonly spec: unknown;
 }, idempotencyKey?: string | undefined) => Effect.Effect<{
-    readonly sandboxId: string;
+    readonly workspaceId: 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;
+}, import("effect/unstable/http/HttpClientError").HttpClientError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError, SealantApiClient>;
+export declare const getWorkspaceOp: (workspaceId: string) => Effect.Effect<{
+    readonly workspaceId: string;
     readonly name: string;
     readonly ownerUserId: string;
     readonly status: "cancelled" | "failed" | "queued" | "ready" | "running";
@@ -63,13 +63,13 @@ export declare const getSandboxOp: (sandboxId: string) => Effect.Effect<{
     readonly finishedAt?: string | undefined;
     readonly spec?: unknown;
 }, unknown, SealantApiClient>;
-export declare const listSandboxesOp: (query: {
+export declare const listWorkspacesOp: (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 workspaceId: string;
         readonly name: string;
         readonly ownerUserId: string;
         readonly status: "cancelled" | "failed" | "queued" | "ready" | "running";
@@ -97,9 +97,9 @@ export declare const listSandboxesOp: (query: {
         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>;
+}, import("effect/unstable/http/HttpClientError").HttpClientError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError, SealantApiClient>;
 export declare const createRunOp: (payload: {
-    readonly sandboxId: string;
+    readonly workspaceId: string;
     readonly harnessId: string;
     readonly ownerUserId: string;
     readonly mode?: "interactive" | "one-shot" | undefined;
@@ -112,7 +112,7 @@ export declare const createRunOp: (payload: {
     } | undefined;
 }) => Effect.Effect<{
     readonly runId: string;
-    readonly sandboxId: string;
+    readonly workspaceId: string;
     readonly attemptId?: string | undefined;
     readonly ownerUserId: string;
     readonly harnessId: string;
@@ -128,7 +128,7 @@ export declare const createRunOp: (payload: {
 }, unknown, SealantApiClient>;
 export declare const getRunOp: (runId: string) => Effect.Effect<{
     readonly runId: string;
-    readonly sandboxId: string;
+    readonly workspaceId: string;
     readonly attemptId?: string | undefined;
     readonly ownerUserId: string;
     readonly harnessId: string;
@@ -143,14 +143,14 @@ export declare const getRunOp: (runId: string) => Effect.Effect<{
     readonly updatedAt: string;
 }, unknown, SealantApiClient>;
 export declare const listRunsOp: (query: {
-    readonly sandboxId?: string | undefined;
+    readonly workspaceId?: 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 workspaceId: string;
         readonly attemptId?: string | undefined;
         readonly ownerUserId: string;
         readonly harnessId: string;
@@ -177,7 +177,7 @@ export declare const updateRunOp: (runId: string, payload: {
     }[] | undefined;
 }) => Effect.Effect<{
     readonly runId: string;
-    readonly sandboxId: string;
+    readonly workspaceId: string;
     readonly attemptId?: string | undefined;
     readonly ownerUserId: string;
     readonly harnessId: string;

package/dist/effect/operations.js

@@ -1,12 +1,12 @@
 import { Effect } from "effect";
 import { SealantApiClient } from "./api-client.js";
-// ---- sandboxes ----
-export const createSandboxOp = (payload, idempotencyKey) => Effect.flatMap(SealantApiClient, (client) => client.sandboxes.createSandbox({
+// ---- workspaces ----
+export const createWorkspaceOp = (payload, idempotencyKey) => Effect.flatMap(SealantApiClient, (client) => client.workspaces.createWorkspace({
     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 }));
+export const getWorkspaceOp = (workspaceId) => Effect.flatMap(SealantApiClient, (client) => client.workspaces.getWorkspace({ params: { workspaceId } }));
+export const listWorkspacesOp = (query) => Effect.flatMap(SealantApiClient, (client) => client.workspaces.listWorkspaces({ 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 } }));

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

@@ -1,5 +1,5 @@
-import type { RunHarnessFn } from "../facade/sandbox.js";
-/** The BLOCKING `harness.run()` implementation, registered into the Sandbox facade by the client. */
+import type { RunHarnessFn } from "../facade/workspace.js";
+/** The BLOCKING `harness.run()` implementation, registered into the Workspace facade by the client. */
 export declare const runHarness: RunHarnessFn;
 /**
  * The NON-BLOCKING `harness.start()` implementation: register the run and return the live handle

package/dist/effect/run-harness.js

@@ -17,16 +17,16 @@ 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.
+ * docker-execs it and ingests telemetry). The cwd is the workspace 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" }));
+        return yield* Effect.fail(new SealantError("This workspace handle has no harness; use the handle returned by workspaces.create().", { code: "harness_required" }));
     }
     const command = harness.buildRunCommand(prompt);
     return yield* createRunOp({
-        sandboxId: init.id,
+        workspaceId: init.id,
         ownerUserId: ctx.config.hostLocal.ownerUserId,
         harnessId: harness.id,
         mode: "one-shot",
@@ -53,7 +53,7 @@ const runHarnessEffect = (ctx, init, prompt) => Effect.gen(function* () {
     const changes = toRunChangesData(yield* getRunChangesOp(runId));
     return makeRun(ctx, { wire, changes });
 });
-/** The BLOCKING `harness.run()` implementation, registered into the Sandbox facade by the client. */
+/** The BLOCKING `harness.run()` implementation, registered into the Workspace 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

package/dist/errors.d.ts

@@ -13,7 +13,7 @@ export declare class SealantError extends Error {
         readonly cause?: unknown;
     });
 }
-/** A typed control/transport failure from the sandbox runtime daemon. */
+/** A typed control/transport failure from the workspace runtime daemon. */
 export declare class SealantRuntimeError extends SealantError {
     readonly name = "SealantRuntimeError";
     constructor(message: string, options?: {

package/dist/errors.js

@@ -13,7 +13,7 @@ export class SealantError extends Error {
         this.code = options?.code ?? "sealant_error";
     }
 }
-/** A typed control/transport failure from the sandbox runtime daemon. */
+/** A typed control/transport failure from the workspace runtime daemon. */
 export class SealantRuntimeError extends SealantError {
     name = "SealantRuntimeError";
     constructor(message, options) {

package/dist/facade/run.d.ts

@@ -1,6 +1,6 @@
 /**
  * The `Run` facade — one harness execution as the SDK exposes it. Built from a `runs.get` lookup
- * (read a past run, record outlives the sandbox), from `harness.run()` (which also captures the file
+ * (read a past run, record outlives the workspace), from `harness.run()` (which also captures the file
  * changes inline), or from `harness.start()` (a live handle; `wait()` settles it). `result` is
  * derived from the wire status; `changes` is captured inline by `run()` and fetched by `wait()` once
  * the run is terminal (the event-sourced fileChange projection that backs reads arrives in Phase 1);

package/dist/facade/{sandbox.d.ts → workspace.d.ts}

@@ -1,18 +1,18 @@
-import type { Harness, Sandbox, SandboxStatus } from "../types.js";
+import type { Harness, Workspace, WorkspaceStatus } from "../types.js";
 import type { SdkContext } from "./context.js";
-export interface SandboxInit {
+export interface WorkspaceInit {
     readonly id: string;
     readonly name: string;
-    readonly status: SandboxStatus;
+    readonly status: WorkspaceStatus;
     /** Present when the handle came from `create()` (needed by `harness.run()`). */
     readonly harness?: Harness;
 }
 /**
  * The `harness.run()`/`harness.start()` implementations are injected by the run-execution module to
- * avoid a static dependency cycle (sandbox <-> run execution). Until they are registered, both
+ * avoid a static dependency cycle (workspace <-> run execution). Until they are registered, both
  * report that the feature is not wired in this build.
  */
-export type RunHarnessFn = (ctx: SdkContext, init: SandboxInit, prompt: string, options?: import("../types.js").RunOptions) => Promise<import("../types.js").Run>;
+export type RunHarnessFn = (ctx: SdkContext, init: WorkspaceInit, prompt: string, options?: import("../types.js").RunOptions) => Promise<import("../types.js").Run>;
 export interface HarnessExecutors {
     /** BLOCKING `harness.run()`: resolves once the run is terminal. */
     readonly run: RunHarnessFn;
@@ -20,4 +20,4 @@ export interface HarnessExecutors {
     readonly start: RunHarnessFn;
 }
 export declare const registerHarnessExecutors: (executors: HarnessExecutors) => void;
-export declare const makeSandbox: (ctx: SdkContext, init: SandboxInit) => Sandbox;
+export declare const makeWorkspace: (ctx: SdkContext, init: WorkspaceInit) => Workspace;

package/dist/facade/{sandbox.js → workspace.js}

@@ -1,4 +1,4 @@
-import { getSandboxOp } from "../effect/operations.js";
+import { getWorkspaceOp } from "../effect/operations.js";
 import { SealantError, SealantNotImplementedError } from "../errors.js";
 const FAILED_STATUSES = new Set(["failed", "cancelled"]);
 const READY_POLL_INTERVAL_MS = 2_000;
@@ -8,7 +8,7 @@ let harnessExecutors;
 export const registerHarnessExecutors = (executors) => {
     harnessExecutors = executors;
 };
-export const makeSandbox = (ctx, init) => {
+export const makeWorkspace = (ctx, init) => {
     const harness = {
         run: (prompt, options) => {
             if (harnessExecutors === undefined) {
@@ -24,36 +24,36 @@ export const makeSandbox = (ctx, init) => {
         },
         session: () => Promise.reject(new SealantNotImplementedError("harness.session (interactive, Phase 3)")),
     };
-    const sandbox = {
+    const workspace = {
         id: init.id,
         name: init.name,
         status: async () => {
-            const details = await ctx.runtime.run(getSandboxOp(init.id));
+            const details = await ctx.runtime.run(getWorkspaceOp(init.id));
             return details.status;
         },
         ready: async () => {
             const deadline = Date.now() + READY_TIMEOUT_MS;
             for (;;) {
-                const details = await ctx.runtime.run(getSandboxOp(init.id));
+                const details = await ctx.runtime.run(getWorkspaceOp(init.id));
                 // Gate on the coarse "ready" status, which the control plane now emits ONLY after the
-                // in-sandbox daemon's control socket is accepting (readiness probe in the launch path).
+                // in-workspace daemon's control socket is accepting (readiness probe in the launch path).
                 // This is honest: when ready() resolves, harness.run() can connect without racing the socket.
                 if (details.status === "ready") {
-                    return sandbox;
+                    return workspace;
                 }
                 if (FAILED_STATUSES.has(details.status)) {
-                    throw new SealantError(`Sandbox ${init.id} reached terminal status "${details.status}" before becoming ready.`, { code: "sandbox_not_ready" });
+                    throw new SealantError(`Workspace ${init.id} reached terminal status "${details.status}" before becoming ready.`, { code: "workspace_not_ready" });
                 }
                 if (Date.now() > deadline) {
-                    throw new SealantError(`Timed out waiting for sandbox ${init.id} to become ready.`, {
-                        code: "sandbox_ready_timeout",
+                    throw new SealantError(`Timed out waiting for workspace ${init.id} to become ready.`, {
+                        code: "workspace_ready_timeout",
                     });
                 }
                 await delay(READY_POLL_INTERVAL_MS);
             }
         },
         harness,
-        // Poll-backed lifecycle stream: emit a coarse event on each status transition until the sandbox
+        // Poll-backed lifecycle stream: emit a coarse event on each status transition until the workspace
         // reaches a terminal/ready state. Swaps to SSE over Postgres LISTEN/NOTIFY in Stage 5 (same shape).
         events: () => {
             const ctxRun = ctx.runtime;
@@ -61,13 +61,13 @@ export const makeSandbox = (ctx, init) => {
                 let lastStatus;
                 const deadline = Date.now() + READY_TIMEOUT_MS;
                 for (;;) {
-                    const details = await ctxRun.run(getSandboxOp(init.id));
+                    const details = await ctxRun.run(getWorkspaceOp(init.id));
                     if (details.status !== lastStatus) {
                         lastStatus = details.status;
                         yield {
                             type: `status.${details.status}`,
                             occurredAt: new Date().toISOString(),
-                            message: `Sandbox status: ${details.status}`,
+                            message: `Workspace status: ${details.status}`,
                         };
                     }
                     if (details.status === "ready" || FAILED_STATUSES.has(details.status)) {
@@ -81,9 +81,9 @@ export const makeSandbox = (ctx, init) => {
             }
             return iterate();
         },
-        stop: () => Promise.reject(new SealantNotImplementedError("sandbox.stop (lifecycle, Phase 3)")),
-        restart: () => Promise.reject(new SealantNotImplementedError("sandbox.restart (lifecycle, Phase 3)")),
-        expire: () => Promise.reject(new SealantNotImplementedError("sandbox.expire (lifecycle, Phase 3)")),
+        stop: () => Promise.reject(new SealantNotImplementedError("workspace.stop (lifecycle, Phase 3)")),
+        restart: () => Promise.reject(new SealantNotImplementedError("workspace.restart (lifecycle, Phase 3)")),
+        expire: () => Promise.reject(new SealantNotImplementedError("workspace.expire (lifecycle, Phase 3)")),
     };
-    return sandbox;
+    return workspace;
 };

package/dist/harness.d.ts

@@ -4,7 +4,7 @@
  *
  * NOTE — the one-shot invocation forms below (`opencode run <prompt>`, `codex exec <prompt>`,
  * `claude -p <prompt>`) are the expected headless shapes but are PENDING live verification against
- * the baked sandbox image (see the SDK plan's task #2, "verify harness one-shot CLI semantics").
+ * the baked workspace image (see the SDK plan's task #2, "verify harness one-shot CLI semantics").
  * Until that is confirmed, only `opencode()` is exercised end-to-end; the others are provided for the
  * typed surface and adjusted once verified.
  */

package/dist/index.d.ts

@@ -1,17 +1,17 @@
 /**
  * @sealant/sdk — the fluent public SDK for Sealant.
  *
- * Create a live sandbox around a real repository, run the harness you already use, stream progress
- * while it works, and keep the replayable execution record after the sandbox is gone:
+ * Create a live workspace around a real repository, run the harness you already use, stream progress
+ * while it works, and keep the replayable execution record after the workspace is gone:
  *
  *   import { Sealant, opencode } from "@sealant/sdk"
  *
  *   const sealant = new Sealant({ baseUrl: "http://localhost:8080" })
- *   const sandbox = await sealant.sandboxes.create({
+ *   const workspace = await sealant.workspaces.create({
  *     repository: "github.com/acme/billing-service",
  *     harness: opencode(),
  *   })
- *   const run = await sandbox.harness.run("Round invoice totals once, after applying the discount.")
+ *   const run = await workspace.harness.run("Round invoice totals once, after applying the discount.")
  *   await run.record.replay()
  */
 export { Sealant } from "./client.js";

package/dist/index.js

@@ -1,17 +1,17 @@
 /**
  * @sealant/sdk — the fluent public SDK for Sealant.
  *
- * Create a live sandbox around a real repository, run the harness you already use, stream progress
- * while it works, and keep the replayable execution record after the sandbox is gone:
+ * Create a live workspace around a real repository, run the harness you already use, stream progress
+ * while it works, and keep the replayable execution record after the workspace is gone:
  *
  *   import { Sealant, opencode } from "@sealant/sdk"
  *
  *   const sealant = new Sealant({ baseUrl: "http://localhost:8080" })
- *   const sandbox = await sealant.sandboxes.create({
+ *   const workspace = await sealant.workspaces.create({
  *     repository: "github.com/acme/billing-service",
  *     harness: opencode(),
  *   })
- *   const run = await sandbox.harness.run("Round invoice totals once, after applying the discount.")
+ *   const run = await workspace.harness.run("Round invoice totals once, after applying the discount.")
  *   await run.record.replay()
  */
 export { Sealant } from "./client.js";

package/dist/internal/blueprint.d.ts

@@ -1,6 +1,6 @@
 import type { CreateOptions } from "../types.js";
 import type { SealantInternalConfig } from "./config.js";
-export declare const buildCreateSandboxRequest: (options: CreateOptions, config: SealantInternalConfig) => {
+export declare const buildCreateWorkspaceRequest: (options: CreateOptions, config: SealantInternalConfig) => {
     readonly payload: {
         readonly ownerUserId: string;
         readonly registryId: string;

package/dist/internal/blueprint.js

@@ -1,17 +1,17 @@
 /**
  * Lowers the fluent `create({ repository, harness })` options into the existing
- * `createSandboxRequestSchema` the control plane accepts — entirely client-side, so the slice needs
+ * `createWorkspaceRequestSchema` the control plane accepts — entirely client-side, so the slice needs
  * no contract change. The public `repository` is the SOURCE git repo (it becomes
- * `spec.sources.sandbox.url`); the contract's `repository`/`tag` are the OCI push coordinates, which
+ * `spec.sources.workspace.url`); the contract's `repository`/`tag` are the OCI push coordinates, which
  * we derive. `customization.enableSealantd` is forced on (it bakes + launches the daemon the run path
  * connects to), the runtime target is pinned to docker (the only bridgeable adapter today), and the
- * foreground is a keepalive so the sandbox idles with the daemon up and the harness is exec'd on
+ * foreground is a keepalive so the workspace idles with the daemon up and the harness is exec'd on
  * demand by `run()` rather than launched at boot. `options.credentials`, if present, is lowered via
- * `mapSandboxCredentials` (see `./credentials.js`) and folded into `spec.credentials`; the control
+ * `mapWorkspaceCredentials` (see `./credentials.js`) and folded into `spec.credentials`; the control
  * plane resolves those account references server-side (never secret material over this path).
  */
 import { randomUUID } from "node:crypto";
-import { mapSandboxCredentials } from "./credentials.js";
+import { mapWorkspaceCredentials } from "./credentials.js";
 const sanitizeRepoSlug = (value) => {
     const slug = value
         .toLowerCase()
@@ -26,16 +26,16 @@ const toGitUrl = (repository) => {
     }
     return `https://${repository}.git`;
 };
-export const buildCreateSandboxRequest = (options, config) => {
+export const buildCreateWorkspaceRequest = (options, config) => {
     const tail = options.repository
         .split("/")
         .filter((s) => s.length > 0)
         .pop() ?? options.repository;
-    const credentials = mapSandboxCredentials(options.credentials);
+    const credentials = mapWorkspaceCredentials(options.credentials);
     const spec = {
         version: "1",
         sources: {
-            sandbox: {
+            workspace: {
                 kind: "git",
                 provider: "generic",
                 url: toGitUrl(options.repository),

package/dist/internal/config.d.ts

@@ -9,9 +9,9 @@
  */
 import type { SealantConfig } from "../types.js";
 export interface SealantHostLocalConfig {
-    /** Owner principal the control plane attributes sandboxes/runs to (pre-auth). */
+    /** Owner principal the control plane attributes workspaces/runs to (pre-auth). */
     readonly ownerUserId: string;
-    /** Registry the sandbox image is published to and launched from. */
+    /** Registry the workspace image is published to and launched from. */
     readonly registryId: string;
 }
 export interface SealantInternalConfig {

package/dist/internal/credentials.d.ts

@@ -1,22 +1,22 @@
 /**
- * Lowers the public `SandboxCredentialsOptions` onto the control-plane's sandbox-create payload
- * shape. Pure and side-effect free so it is unit-testable on its own; `buildCreateSandboxRequest`
+ * Lowers the public `WorkspaceCredentialsOptions` onto the control-plane's workspace-create payload
+ * shape. Pure and side-effect free so it is unit-testable on its own; `buildCreateWorkspaceRequest`
  * calls it and folds the result into the request it builds.
  *
  * SECURITY: this only ever moves account **references** (booleans/names/ids) — never token values or
  * other secret material. `true` resolves to the literal account name `"default"`; a string passes
  * through as the named account; `profile` becomes `profileId`.
  */
-import type { SandboxCredentialsOptions } from "../types.js";
-/** The control-plane's sandbox-create payload shape for connected-account credentials. */
-export interface SandboxCredentialsPayload {
+import type { WorkspaceCredentialsOptions } from "../types.js";
+/** The control-plane's workspace-create payload shape for connected-account credentials. */
+export interface WorkspaceCredentialsPayload {
     readonly profileId?: string;
     readonly claude?: string;
     readonly codex?: string;
     readonly github?: string;
 }
 /**
- * Maps `SandboxCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
+ * Maps `WorkspaceCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
  * requested (omitted entirely, rather than serialized as an empty object).
  */
-export declare const mapSandboxCredentials: (options: SandboxCredentialsOptions | undefined) => SandboxCredentialsPayload | undefined;
+export declare const mapWorkspaceCredentials: (options: WorkspaceCredentialsOptions | undefined) => WorkspaceCredentialsPayload | undefined;

package/dist/internal/credentials.js

@@ -6,10 +6,10 @@ const mapAccountRef = (value) => {
     return value === true ? DEFAULT_ACCOUNT_NAME : value;
 };
 /**
- * Maps `SandboxCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
+ * Maps `WorkspaceCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
  * requested (omitted entirely, rather than serialized as an empty object).
  */
-export const mapSandboxCredentials = (options) => {
+export const mapWorkspaceCredentials = (options) => {
     if (options === undefined) {
         return undefined;
     }

package/dist/internal/map-error.d.ts

@@ -1,6 +1,6 @@
 /**
  * Maps any failure crossing the Effect boundary onto a plain public `SealantError`. The Effect core
- * fails with `@sealant/api-contracts` tagged errors (e.g. `SandboxNotFoundError`), Effect HTTP-client
+ * fails with `@sealant/api-contracts` tagged errors (e.g. `WorkspaceNotFoundError`), Effect HTTP-client
  * errors, or schema decode errors; the runtime squashes the `Cause` to its failure value and hands it
  * here. This is the single funnel that keeps Effect internals out of the public, Promise-based API.
  */

package/dist/internal/map-error.js

@@ -1,6 +1,6 @@
 /**
  * Maps any failure crossing the Effect boundary onto a plain public `SealantError`. The Effect core
- * fails with `@sealant/api-contracts` tagged errors (e.g. `SandboxNotFoundError`), Effect HTTP-client
+ * fails with `@sealant/api-contracts` tagged errors (e.g. `WorkspaceNotFoundError`), Effect HTTP-client
  * errors, or schema decode errors; the runtime squashes the `Cause` to its failure value and hands it
  * here. This is the single funnel that keeps Effect internals out of the public, Promise-based API.
  */