@claxedo/sandbox-manager 0.9.0 → 0.10.0

package/dist/index.mjs

@@ -1,21 +1,649 @@
 // src/constants.ts
 var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 
+// src/contract.ts
+function validateSandboxPersistenceCapabilities(input) {
+  if (input.resume === "replacement-restore" && input.capture === "none") {
+    return { valid: false, reason: "replacement restore requires a capture source" };
+  }
+  if (input.capture === "none" && input.captureSource !== "not-applicable") {
+    return { valid: false, reason: "capture source behavior requires capture support" };
+  }
+  if (input.capture !== "none" && input.captureSource === "not-applicable") {
+    return { valid: false, reason: "capture support requires source behavior" };
+  }
+  if (input.capture === "same-resource" && input.restoreMount !== "same-resource") {
+    return { valid: false, reason: "same-resource capture requires same-resource restore" };
+  }
+  return { valid: true };
+}
+function sandboxLeaseHeldHost(lease) {
+  return lease?.sandboxId !== void 0 && (lease.status === "stopped" || lease.status === "unavailable") ? lease : void 0;
+}
+function applySandboxLeasePatch(current, patch, updatedAt) {
+  return {
+    ...current,
+    ...patch.status === void 0 ? {} : { status: patch.status },
+    ...patch.retryCount === void 0 ? {} : { retryCount: patch.retryCount },
+    ...patch.lastHeartbeatAt === void 0 ? {} : { lastHeartbeatAt: patch.lastHeartbeatAt },
+    ...patch.lastActivityAt === void 0 ? {} : { lastActivityAt: patch.lastActivityAt },
+    ...patch.lastHealthFailureAt === void 0 ? {} : { lastHealthFailureAt: patch.lastHealthFailureAt },
+    ...patch.nextRetryAt === void 0 ? {} : { nextRetryAt: patch.nextRetryAt ?? void 0 },
+    ...patch.lastError === void 0 ? {} : { lastError: patch.lastError ?? void 0 },
+    ...patch.checkpoint === void 0 ? {} : { checkpoint: patch.checkpoint ?? void 0 },
+    ...patch.restore === void 0 ? {} : { restore: patch.restore ?? void 0 },
+    ...patch.start === void 0 ? {} : { start: patch.start },
+    updatedAt
+  };
+}
+function applySandboxLeaseFailure(current, error, nextRetryAt, failedAt) {
+  return {
+    ...current,
+    status: "unavailable",
+    retryCount: current.retryCount + 1,
+    lastError: error,
+    nextRetryAt,
+    lastHealthFailureAt: failedAt,
+    updatedAt: failedAt,
+    ...current.start ? { start: { ...current.start, failures: [...current.start.failures ?? [], { epoch: current.epoch, failedAt, error }] } } : {}
+  };
+}
+function applySandboxProvisionedTarget(current, target, updatedAt) {
+  const sameTarget = current.status === "ready" && current.url === target.url && current.sandboxId === target.sandboxId && current.hostId === target.hostId && current.driverResourceId === target.driverResourceId;
+  return {
+    ...current,
+    status: target.url === void 0 ? "acquiring" : "ready",
+    routingId: sameTarget && current.routingId ? current.routingId : crypto.randomUUID(),
+    sandboxId: target.sandboxId,
+    url: target.url,
+    hostId: target.hostId,
+    driverResourceId: target.driverResourceId,
+    labels: target.labels,
+    ...target.persistence === void 0 ? {} : { persistence: target.persistence },
+    retryCount: 0,
+    nextRetryAt: void 0,
+    lastError: void 0,
+    updatedAt
+  };
+}
+var SANDBOX_IMAGE_LABEL = "image";
+function isSandboxListingUnsupported(err) {
+  return !!err && typeof err === "object" && err.listingUnsupported === true;
+}
+
+// src/egress-policy.ts
+function sandboxNetworkPolicyWithBrokeredHosts(policy, secrets) {
+  if (policy.mode !== "restricted" || !secrets?.length) return policy;
+  const hosts = [.../* @__PURE__ */ new Set([
+    ...policy.hosts ?? [],
+    ...secrets.flatMap((secret) => secret.hosts)
+  ])].toSorted();
+  return {
+    ...policy,
+    ...hosts.length ? { hosts } : {}
+  };
+}
+function sandboxEgressDisposition(control, net) {
+  if (!net || net.mode === "allow-all") return { action: "enforce" };
+  if (control === "none") return { action: "withhold", reason: "sandbox_egress_uncontained" };
+  const hosts = net.hosts?.length ?? 0;
+  const cidrs = net.cidrs?.length ?? 0;
+  if (hosts === 0 && cidrs === 0) return { action: "enforce" };
+  if (hosts > 0) return { action: "enforce" };
+  return control === "hosts-and-cidrs" ? { action: "enforce" } : { action: "refuse", reason: "sandbox_egress_policy_unenforceable" };
+}
+function brokeredSecretPlaceholder(name) {
+  return `claxedo-broker:${name}`;
+}
+function brokeredPlaceholderEnv(secrets) {
+  return Object.fromEntries((secrets ?? []).map((secret) => [secret.name, brokeredSecretPlaceholder(secret.name)]));
+}
+
+// src/driver-billing.ts
+var HOUR_SECONDS = 3600;
+var boatBilling = {
+  source: { url: "https://docs.boat.dev/pricing", readOn: "2026-10-12" },
+  meter: "Boat bills machine time per second while a sandbox runs, at an hourly rate per size; a stopped sandbox costs nothing.",
+  rates: {
+    small: { size: "small", vcpu: 2, memoryGb: 4, usdPerHour: 0.018 },
+    default: { size: "default", vcpu: 4, memoryGb: 8, usdPerHour: 0.036 },
+    large: { size: "large", vcpu: 8, memoryGb: 16, usdPerHour: 0.072 }
+  }
+};
+var CLOUDFLARE_USD_PER_GIB_SECOND_MEMORY = 25e-7;
+var CLOUDFLARE_USD_PER_GB_SECOND_DISK = 7e-8;
+var CLOUDFLARE_USD_PER_VCPU_SECOND_ACTIVE = 2e-5;
+var CLOUDFLARE_STANDARD_1 = { size: "standard-1", vcpu: 0.5, memoryGb: 4, diskGb: 8 };
+var cloudflareBilling = {
+  source: { url: "https://developers.cloudflare.com/containers/pricing/", readOn: "2026-10-12" },
+  meter: "Cloudflare bills a container for every 10 ms it runs: memory at $0.0000025 per GiB-second and disk at $0.00000007 per GB-second for the whole run, plus CPU at $0.00002 per vCPU-second of active use.",
+  rates: {
+    default: {
+      size: CLOUDFLARE_STANDARD_1.size,
+      vcpu: CLOUDFLARE_STANDARD_1.vcpu,
+      memoryGb: CLOUDFLARE_STANDARD_1.memoryGb,
+      usdPerHour: (CLOUDFLARE_STANDARD_1.memoryGb * CLOUDFLARE_USD_PER_GIB_SECOND_MEMORY + CLOUDFLARE_STANDARD_1.diskGb * CLOUDFLARE_USD_PER_GB_SECOND_DISK) * HOUR_SECONDS
+    }
+  },
+  excludes: `active CPU, billed at $${CLOUDFLARE_USD_PER_VCPU_SECOND_ACTIVE} per vCPU-second and not measured by Claxedo, and the monthly allowance a Workers Paid plan includes`
+};
+function sandboxMachineRate(billing, machineClass) {
+  if (!billing) return void 0;
+  return billing.rates[machineClass ?? "default"] ?? (Object.keys(billing.rates).length === 1 ? billing.rates.default : void 0);
+}
+function sandboxMachineCostUsd(rate, activeMs) {
+  return rate.usdPerHour * activeMs / (HOUR_SECONDS * 1e3);
+}
+
+// ../sandbox-contract/dist/index.mjs
+function ipv4Number(part) {
+  let value;
+  if (/^0[xX][0-9a-fA-F]+$/.test(part))
+    value = Number.parseInt(part.slice(2), 16);
+  else if (/^0[0-7]+$/.test(part))
+    value = Number.parseInt(part.slice(1), 8);
+  else if (/^\d+$/.test(part))
+    value = Number.parseInt(part, 10);
+  else
+    return;
+  return Number.isSafeInteger(value) ? value : void 0;
+}
+function parseIpv4(input) {
+  const parts = input.split(".");
+  if (parts.length > 1 && parts[parts.length - 1] === "")
+    parts.pop();
+  if (parts.length < 1 || parts.length > 4)
+    return;
+  const numbers = [];
+  for (const part of parts) {
+    const value = ipv4Number(part);
+    if (value === void 0)
+      return;
+    numbers.push(value);
+  }
+  const last = numbers[numbers.length - 1];
+  if (last >= 256 ** (5 - numbers.length))
+    return;
+  for (const value of numbers.slice(0, -1))
+    if (value > 255)
+      return;
+  let address = last;
+  for (let i = 0; i < numbers.length - 1; i++)
+    address += numbers[i] * 256 ** (3 - i);
+  return address >>> 0;
+}
+function hextet(part) {
+  return /^[0-9a-fA-F]{1,4}$/.test(part) ? Number.parseInt(part, 16) : void 0;
+}
+function embeddedQuad(input) {
+  const parts = input.split(".");
+  if (parts.length !== 4)
+    return;
+  const octets = [];
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part))
+      return;
+    const value = Number.parseInt(part, 10);
+    if (value > 255)
+      return;
+    octets.push(value);
+  }
+  return octets;
+}
+function parseIpv6(input) {
+  let body = input;
+  let tail;
+  const lastColon = body.lastIndexOf(":");
+  if (lastColon >= 0 && body.includes(".")) {
+    tail = embeddedQuad(body.slice(lastColon + 1));
+    if (!tail)
+      return;
+    body = body.slice(0, lastColon + 1) + "0:0";
+  }
+  if ((body.match(/::/g) ?? []).length > 1)
+    return;
+  let halves;
+  if (body.includes("::")) {
+    const [left = "", right = ""] = body.split("::");
+    const leftParts = left === "" ? [] : left.split(":");
+    const rightParts = right === "" ? [] : right.split(":");
+    const missing = 8 - leftParts.length - rightParts.length;
+    if (missing < 1)
+      return;
+    halves = [...leftParts, ...Array.from({ length: missing }, () => "0"), ...rightParts];
+  } else {
+    halves = body.split(":");
+    if (halves.length !== 8)
+      return;
+  }
+  if (halves.length !== 8)
+    return;
+  const segments = [];
+  for (const part of halves) {
+    const value = hextet(part);
+    if (value === void 0)
+      return;
+    segments.push(value);
+  }
+  if (tail) {
+    segments[6] = tail[0] * 256 + tail[1];
+    segments[7] = tail[2] * 256 + tail[3];
+  }
+  return segments;
+}
+function parseIpAddress(input) {
+  if (!input)
+    return;
+  let host = input.trim().toLowerCase();
+  if (host.startsWith("[") && host.endsWith("]") && host.includes(":"))
+    host = host.slice(1, -1);
+  if (host.includes(":")) {
+    const segments = parseIpv6(host);
+    return segments ? { kind: "v6", segments } : void 0;
+  }
+  const value = parseIpv4(host);
+  return value === void 0 ? void 0 : { kind: "v4", value };
+}
+var V4_PRIVATE = [
+  [0, 8],
+  [167772160, 8],
+  [1681915904, 10],
+  [2130706432, 8],
+  [2851995648, 16],
+  [2886729728, 12],
+  [3221225472, 24],
+  [3221225984, 24],
+  [3223307264, 24],
+  [3224682752, 24],
+  [3227017984, 24],
+  [3232235520, 16],
+  [3232706560, 24],
+  [3323068416, 15],
+  [3325256704, 24],
+  [3405803776, 24],
+  [3758096384, 4],
+  [4026531840, 4]
+];
+function inCidr(value, base, bits) {
+  return (value ^ base) >>> 32 - bits === 0;
+}
+function isPrivateIpv4(value) {
+  return V4_PRIVATE.some(([base, bits]) => inCidr(value, base, bits));
+}
+function embeddedIpv4(segments) {
+  const [a, b, c, d, e, f, g, h] = segments;
+  if (a === 0 && b === 0 && c === 0 && d === 0 && e === 0) {
+    if (f === 65535 || f === 0)
+      return g * 65536 + h >>> 0;
+  }
+  if (a === 100 && b === 65435 && c === 0 && d === 0 && e === 0 && f === 0)
+    return g * 65536 + h >>> 0;
+  if (a === 8194)
+    return b * 65536 + c >>> 0;
+  if (a === 8193 && b === 0)
+    return (g ^ 65535) * 65536 + (h ^ 65535) >>> 0;
+  return;
+}
+function isUnspecified(segments) {
+  return segments.every((segment) => segment === 0);
+}
+function isIpv6Loopback(segments) {
+  return segments.slice(0, 7).every((segment) => segment === 0) && segments[7] === 1;
+}
+function isPrivateIpAddress(ip) {
+  if (ip.kind === "v4")
+    return isPrivateIpv4(ip.value);
+  const segments = ip.segments;
+  if (isUnspecified(segments) || isIpv6Loopback(segments))
+    return true;
+  const first = segments[0];
+  if ((first & 65280) === 65280)
+    return true;
+  if ((first & 65024) === 64512)
+    return true;
+  if ((first & 65472) === 65152)
+    return true;
+  if ((first & 65472) === 65216)
+    return true;
+  if (first === 256 && segments[1] === 0 && segments[2] === 0 && segments[3] === 0)
+    return true;
+  if (first === 8193 && segments[1] === 3512)
+    return true;
+  const embedded = embeddedIpv4(segments);
+  if (embedded !== void 0)
+    return isPrivateIpv4(embedded);
+  return false;
+}
+var sandboxCheckpointUnusableCauses = ["expired", "runtime_outdated", "runtime_modified", "not_restorable"];
+function isSandboxCheckpointUnusableCause(value) {
+  return sandboxCheckpointUnusableCauses.some((cause) => cause === value);
+}
+var sandboxDriverIds = ["modal", "vercel", "cloudflare", "boat", "docker"];
+var sandboxDriverLabels = {
+  modal: "Modal",
+  vercel: "Vercel",
+  cloudflare: "Cloudflare",
+  boat: "Boat",
+  docker: "Docker"
+};
+function isSandboxDriverID(input) {
+  return !!input && sandboxDriverIds.includes(input);
+}
+function safeRepoUrl(input) {
+  try {
+    const url = new URL(input);
+    return url.protocol === "https:" || url.protocol === "http:" || url.protocol === "ssh:" ? input : void 0;
+  } catch {
+    return /^[\w.-]+@[\w.-]+:[\w./-]+$/.test(input) ? input : void 0;
+  }
+}
+function repoUrlHost(input) {
+  if (!safeRepoUrl(input))
+    return;
+  try {
+    const host = new URL(input).hostname;
+    return host || void 0;
+  } catch {
+    return /^[\w.-]+@([\w.-]+):[\w./-]+$/.exec(input)?.[1]?.toLowerCase();
+  }
+}
+function bareRepoHost(host) {
+  const bare = host.trim().toLowerCase();
+  return bare.startsWith("[") && bare.endsWith("]") && bare.includes(":") ? bare.slice(1, -1) : bare;
+}
+function loopbackRepoName(bare) {
+  return bare === "localhost" || bare.endsWith(".localhost");
+}
+function publicRepoHost(repoUrl) {
+  const host = repoUrlHost(repoUrl);
+  if (!host)
+    return;
+  const bare = bareRepoHost(host);
+  if (loopbackRepoName(bare))
+    return;
+  const ip = parseIpAddress(bare);
+  if (ip && isPrivateIpAddress(ip))
+    return;
+  return host;
+}
+
+// src/lease-failure.ts
+function isSandboxRuntimeBootFailure(err) {
+  return !!err && typeof err === "object" && err.runtimeBootFailed === true;
+}
+var SandboxRuntimeBootError = class extends Error {
+  runtimeBootFailed = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxRuntimeBootError";
+  }
+};
+function isSandboxCheckpointUnusable(err) {
+  return !!err && typeof err === "object" && isSandboxCheckpointUnusableCause(err.checkpointUnusable);
+}
+var SandboxCheckpointUnusableError = class extends Error {
+  constructor(checkpointUnusable, reason) {
+    super(reason);
+    this.checkpointUnusable = checkpointUnusable;
+    this.name = "SandboxCheckpointUnusableError";
+  }
+};
+function isSandboxHostGone(err) {
+  return !!err && typeof err === "object" && err.hostGone === true;
+}
+var SandboxHostGoneError = class extends Error {
+  hostGone = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxHostGoneError";
+  }
+};
+function isSandboxProviderKeyRefused(err) {
+  return !!err && typeof err === "object" && err.providerKeyRefused === true;
+}
+var SandboxProviderKeyRefusedError = class extends Error {
+  providerKeyRefused = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxProviderKeyRefusedError";
+  }
+};
+function isSandboxStartRefusal(err) {
+  return !!err && typeof err === "object" && err.startRefused === true;
+}
+var SandboxStartRefusedError = class extends Error {
+  startRefused = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxStartRefusedError";
+  }
+};
+function sandboxDriverLabel(driver) {
+  return isSandboxDriverID(driver) ? sandboxDriverLabels[driver] : driver;
+}
+var PROVIDER_KEY_REFUSED = "provider_key_refused:";
+var PROVIDER_FAILED = "provider_failed:";
+function sandboxProviderKeyRefusedError(driver, message) {
+  return `${PROVIDER_KEY_REFUSED}${driver}: ${message}`;
+}
+function sandboxProviderFailedError(driver, message) {
+  return `${PROVIDER_FAILED}${driver}: ${message}`;
+}
+function codedDriver(error, prefix) {
+  if (!error.startsWith(prefix)) return void 0;
+  const rest = error.slice(prefix.length);
+  const end = rest.indexOf(": ");
+  return end < 0 ? rest : rest.slice(0, end);
+}
+var SANDBOX_START_WINDOWS = ["minute", "hour", "day"];
+function isSandboxProviderRateLimited(err) {
+  const limit = !!err && typeof err === "object" ? err.providerRateLimited : void 0;
+  return !!limit && typeof limit === "object" && SANDBOX_START_WINDOWS.some((window) => window === limit.window);
+}
+var SandboxProviderRateLimitedError = class extends Error {
+  constructor(providerRateLimited, reason) {
+    super(reason);
+    this.providerRateLimited = providerRateLimited;
+    this.name = "SandboxProviderRateLimitedError";
+  }
+};
+function sandboxStartLimitRetryMs(window) {
+  return window === "minute" ? 6e4 : window === "hour" ? 36e5 : void 0;
+}
+var PROVIDER_RATE_LIMITED = "provider_rate_limited:";
+var START_LIMIT_NAMES = { minute: "per-minute", hour: "hourly", day: "daily" };
+function sandboxProviderRateLimitedError(driver, limit) {
+  const used = `${sandboxDriverLabel(driver)}'s ${START_LIMIT_NAMES[limit.window]} start limit (${limit.limit}) is used up`;
+  return `${PROVIDER_RATE_LIMITED}${limit.window}: ${limit.window === "day" ? `${used}; try again later.` : `${used}.`}`;
+}
+function sandboxProviderRateLimit(error) {
+  if (!error?.startsWith(PROVIDER_RATE_LIMITED)) return void 0;
+  const window = error.slice(PROVIDER_RATE_LIMITED.length).split(":", 1)[0];
+  return SANDBOX_START_WINDOWS.find((name) => name === window);
+}
+function providerRateLimitedReason(error) {
+  return sandboxProviderRateLimit(error) === void 0 ? void 0 : error.slice(error.indexOf(": ") + 2);
+}
+var RUNTIME_BOOT_FAILED = "runtime_boot_failed: ";
+var CHECKPOINT_UNUSABLE = "checkpoint_unusable:";
+var RUNTIME_HOST_GONE = "runtime_host_gone: ";
+function sandboxRuntimeBootFailedError(reason) {
+  return `${RUNTIME_BOOT_FAILED}${reason}`;
+}
+function sandboxCheckpointUnusableError(cause, reason) {
+  return `${CHECKPOINT_UNUSABLE}${cause}: ${reason}`;
+}
+function sandboxCheckpointUnusable(error) {
+  if (!error?.startsWith(CHECKPOINT_UNUSABLE)) return void 0;
+  const rest = error.slice(CHECKPOINT_UNUSABLE.length);
+  const end = rest.indexOf(": ");
+  const cause = end < 0 ? void 0 : rest.slice(0, end);
+  return isSandboxCheckpointUnusableCause(cause) ? { cause, message: rest.slice(end + 2) } : void 0;
+}
+function sandboxHostGoneError(reason) {
+  return `${RUNTIME_HOST_GONE}${reason}`;
+}
+var RUNTIME_UNRESPONSIVE = "runtime_unresponsive:";
+function sandboxRuntimeUnresponsiveError(forMs) {
+  return `${RUNTIME_UNRESPONSIVE}${Math.max(1, Math.round(forMs / 6e4))}`;
+}
+function sandboxStopReason(error) {
+  if (!error?.startsWith(RUNTIME_UNRESPONSIVE)) return void 0;
+  const minutes = Number(error.slice(RUNTIME_UNRESPONSIVE.length));
+  return `The workspace's runtime stopped answering; it was stopped after ${minutes} ${minutes === 1 ? "minute" : "minutes"}.`;
+}
+var WORKSPACE_RUNTIME_BOOT_FAILED_LINE = "workspace_runtime_boot_failed: ";
+function workspaceRuntimeBootReason(diagnostic) {
+  const at = diagnostic.lastIndexOf(WORKSPACE_RUNTIME_BOOT_FAILED_LINE);
+  if (at < 0) return void 0;
+  const [reason = ""] = diagnostic.slice(at + WORKSPACE_RUNTIME_BOOT_FAILED_LINE.length).split(/\n\s+at /);
+  return reason.trim().replace(/^Error: /, "") || void 0;
+}
+function runtimeBootDiagnostic(log, maxChars) {
+  const trimmed = log.trim();
+  const reason = workspaceRuntimeBootReason(trimmed);
+  if (reason === void 0) return trimmed.slice(-maxChars);
+  return `${WORKSPACE_RUNTIME_BOOT_FAILED_LINE}${reason}`.slice(0, maxChars);
+}
+function sandboxRuntimeBootFailure(error) {
+  const unusable = sandboxCheckpointUnusable(error);
+  if (unusable) return unusable.message;
+  if (!error?.startsWith(RUNTIME_BOOT_FAILED)) return void 0;
+  const diagnostic = error.slice(RUNTIME_BOOT_FAILED.length);
+  return workspaceRuntimeBootReason(diagnostic) ?? diagnostic;
+}
+var SANDBOX_RUNTIME_UNHEALTHY = "runtime_unhealthy";
+var SANDBOX_RETRY_CAP_EXCEEDED = "runtime_retry_cap_exceeded";
+var CODED_REASONS = /* @__PURE__ */ new Map([
+  [SANDBOX_RUNTIME_UNHEALTHY, "The workspace machine stopped answering."],
+  [SANDBOX_RETRY_CAP_EXCEEDED, "Several tries in a row failed; try again later."]
+]);
+function firstLine(text) {
+  return text.split("\n", 1)[0]?.trim() ?? text;
+}
+function sandboxStartFailureReason(error) {
+  const boot = sandboxRuntimeBootFailure(error);
+  if (boot !== void 0) return firstLine(boot);
+  const limited = providerRateLimitedReason(error);
+  if (limited !== void 0) return limited;
+  const keyRefused = codedDriver(error, PROVIDER_KEY_REFUSED);
+  if (keyRefused !== void 0) return `${sandboxDriverLabel(keyRefused)} refused the sandbox provider key; fix it in Settings \u2192 Sandbox providers.`;
+  const failed = codedDriver(error, PROVIDER_FAILED);
+  if (failed !== void 0) return `${sandboxDriverLabel(failed)} returned an error.`;
+  return CODED_REASONS.get(error) ?? firstLine(error);
+}
+var LEASE_ENDED_ERRORS = /* @__PURE__ */ new Set(["runtime_lease_changed", "runtime_lease_stopped", "runtime_lease_destroyed"]);
+function sandboxLeaseEndedUnderStart(error) {
+  return error !== void 0 && LEASE_ENDED_ERRORS.has(error);
+}
+function sandboxLeaseFailure(lease, input) {
+  if (lease.status !== "unavailable" || !lease.lastError) return void 0;
+  const unusable = sandboxCheckpointUnusable(lease.lastError);
+  if (unusable) return { kind: "checkpoint_unusable", cause: unusable.cause, message: firstLine(unusable.message), retrying: false };
+  const kind = sandboxRuntimeBootFailure(lease.lastError) !== void 0 ? "boot" : lease.lastError === SANDBOX_RUNTIME_UNHEALTHY ? "unhealthy" : "provider";
+  const retrying = kind !== "boot" && lease.retryCount < input.maxRetryCount && lease.nextRetryAt !== void 0 && lease.nextRetryAt > input.now;
+  return { kind, message: sandboxStartFailureReason(lease.lastError), retrying };
+}
+
+// src/lease-retry-wait.ts
+async function liftSandboxRetryWait(leaseStore, workspaceId) {
+  const lease = await leaseStore.get(workspaceId);
+  if (lease?.status !== "unavailable" || lease.retryCount === 0 && lease.nextRetryAt === void 0) return false;
+  return !!await leaseStore.update(workspaceId, lease.epoch, { retryCount: 0, nextRetryAt: null }, "unavailable");
+}
+
+// ../claxedo-helpers/dist/api-error.mjs
+var PUBLIC_API_ERRORS = {
+  repository_provider_unauthorized: { status: 502, message: "Repository provider refused authorization" },
+  repository_provider_unavailable: { status: 502, message: "Repository provider is unavailable" },
+  host_tunnel_timeout: { status: 503, retryable: true, message: "Host tunnel timed out" },
+  host_tunnel_response_body_too_large: { status: 413, message: "Host tunnel response body exceeds the relay limit" },
+  host_tunnel_unavailable: { status: 503, retryable: true, message: "Host tunnel is unavailable" },
+  workspace_checkpoint_unavailable: { status: 503, retryable: true, message: "Workspace checkpoint is unavailable" },
+  workspace_checkpoint_conflict: { status: 409, message: "Workspace checkpoint conflicted" },
+  invalid_input: { family: "access", status: 400, message: "The request names an invalid value" },
+  organization_policy_denied: { family: "access", status: 403, message: "Organization creation is disabled for this deployment" },
+  org_admin_required: { family: "access", status: 403, message: "Organization administrator authority is required" },
+  org_owner_required: { family: "access", status: 403, message: "Only an organization owner may grant, change or remove the owner role" },
+  org_owner_protected: { family: "access", status: 409, message: "The organization's founding owner cannot be removed or demoted" },
+  team_member_org_membership_required: { family: "access", status: 403, message: "The team member must belong to the team organization" },
+  project_member_org_membership_required: { family: "access", status: 403, message: "The project member must belong to the project organization" },
+  org_membership_required: { family: "access", status: 403, message: "Organization membership is required" },
+  project_admin_required: { family: "access", status: 403, message: "Project administrator authority is required" },
+  team_not_allowed_on_personal_org: { family: "access", status: 400, message: "Personal organizations cannot contain teams" },
+  team_member_target_required: { family: "access", status: 400, message: "Exactly one team member target is required" },
+  org_invitation_invalid: { family: "access", status: 409, message: "Invitation is invalid or unavailable" },
+  org_invitation_pending: { family: "access", status: 409, message: "An invitation to this address is already pending" },
+  org_invitation_rate_limited: { family: "access", status: 429, message: "Organization invitation limit exceeded" },
+  org_invitation_email_mismatch: { family: "access", status: 403, message: "Sign in with the invited verified email address" },
+  org_invitation_delivery_unavailable: { family: "access", status: 503, message: "Invitation delivery is unavailable" },
+  team_not_found: { family: "access", status: 404, message: "Team not found" },
+  team_member_not_found: { family: "access", status: 404, message: "Team member not found" },
+  org_member_not_found: { family: "access", status: 404, message: "Organization member not found" },
+  project_not_found: { family: "access", status: 404, message: "Project not found" },
+  project_member_not_found: { family: "access", status: 404, message: "Project member not found" },
+  project_member_owner_immutable: { family: "access", status: 409, message: "The project owner's access cannot be changed" },
+  resource_conflict: { family: "access", status: 409, message: "Organization or team authority changed concurrently" },
+  session_not_found: { family: "session_share", status: 404, message: "This session is not on the control plane, so it cannot be shared from People yet." },
+  session_share_admin_required: { family: "session_share", status: 403, message: "Only the person who started this session can manage its People." },
+  session_share_target_required: { family: "session_share", status: 400, message: "A session is shared with exactly one person" },
+  session_share_target_not_found: { family: "session_share", status: 404, message: "That person was not found in this organization." },
+  session_share_level_invalid: { family: "session_share", status: 400, message: "A share level is either follow or send." },
+  workspace_backing_conflict: { status: 409, message: "Workspace is provisioned in the cloud and cannot be placed on a machine" },
+  invalid_session_list_cursor: { status: 400, message: "Session list cursor does not match this query" },
+  BAD_REQUEST: { status: 400, message: "Invalid request" },
+  INTERNAL_SERVER_ERROR: { status: 500, message: "Internal error" },
+  CONTROL_PLANE_UNAVAILABLE: { status: 503, message: "Control Plane services are not configured" },
+  credential_verification_unsupported: { status: 400, message: "Credential provider does not support verification" },
+  credential_shape_invalid: { status: 400, message: "Credential secret has an unsupported shape" },
+  credential_provider_unavailable: { status: 502, retryable: true, message: "Credential provider request failed" },
+  credential_verification_failed: { status: 502, message: "Credential provider verification failed" },
+  credential_redirect_denied: { status: 502, message: "Sandbox provider redirects are not allowed" },
+  credential_endpoint_invalid: { status: 400, message: "Invalid credential provider endpoint" },
+  host_attestation_denied: { status: 403, message: "host_attestation_denied" },
+  signature_replayed: { status: 409, message: "signature_replayed" },
+  host_enrollment_not_found: { status: 404, message: "host_enrollment_not_found" },
+  enrollment_revoked: { status: 403, message: "enrollment_revoked" },
+  enrollment_paused: { status: 403, message: "enrollment_paused" },
+  enrollment_owner_ineligible: { status: 403, message: "enrollment_owner_ineligible" },
+  enrollment_key_version_mismatch: { status: 403, message: "enrollment_key_version_mismatch" },
+  invitation_invalid: { status: 403, message: "invitation_invalid" },
+  invitation_expired: { status: 410, message: "invitation_expired" },
+  invitation_revoked: { status: 410, message: "invitation_revoked" },
+  invitation_redeemed: { status: 409, message: "invitation_redeemed" },
+  invitation_host_conflict: { status: 409, message: "invitation_host_conflict" },
+  enrollment_generation_superseded: { status: 409, message: "enrollment_generation_superseded" },
+  host_assignment_outside_scope: { status: 400, message: "host_assignment_outside_scope" },
+  host_sealing_key_undeclared: { status: 409, message: "host_sealing_key_undeclared" },
+  host_provider_config_revision_stale: { status: 409, message: "host_provider_config_revision_stale" },
+  identity_conflict: { status: 409, message: "identity_conflict" },
+  registration_transition_denied: { status: 403, message: "registration_transition_denied" },
+  session_reservation_spent: { status: 409, message: "This session's create was undone; reserve it again to retry" },
+  actor_authorization_denied: { status: 403, message: "actor_authorization_denied" }
+};
+function publicApiErrorShape(code) {
+  const entry = PUBLIC_API_ERRORS[code];
+  return { status: entry.status, retryable: entry.retryable === true };
+}
+function publicApiFailure(code, message = PUBLIC_API_ERRORS[code].message) {
+  return Object.assign(new Error(message), { code, ...publicApiErrorShape(code) });
+}
+
 // src/checkpoint-manager.ts
 async function captureSandboxCheckpoint(input) {
   const lease = await requireLease(input.leaseStore, input.workspaceId);
-  if (lease.status !== "ready") throw new Error("workspace_checkpoint_lease_not_ready");
+  if (lease.status !== "ready") throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_lease_not_ready");
   const persistence = lease.persistence;
-  if (!persistence || persistence.capture === "none") throw new Error("workspace_checkpoint_unsupported");
+  if (!persistence || persistence.capture === "none") throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_unsupported");
   const target = await input.target(input.workspaceId);
-  if (target.status !== "ready") throw new Error(target.reason);
-  await input.request.runtime.freeze(input.request.policy ?? "drain");
+  if (target.status !== "ready") throw publicApiFailure("workspace_checkpoint_unavailable", target.reason);
+  const discard = persistence.capture === "same-resource" ? void 0 : input.deleteSnapshot;
   let capturedSource = false;
+  let result;
   try {
-    await input.request.runtime.flush();
-    await input.request.runtime.scrub();
-    const captured = persistence.capture === "same-resource" ? { ok: true, snapshotId: target.driverResourceId ?? target.sandboxId } : await input.snapshot(input.workspaceId);
-    if (!captured.ok) throw new Error(captured.reason);
+    const frozen = await freezeForCapture(input.request, input.endsLease !== void 0, input.workspaceId);
+    const captured = persistence.capture === "same-resource" ? { ok: true, snapshotId: target.driverResourceId ?? target.sandboxId } : await input.snapshot(input.workspaceId, (await input.leaseStore.get(input.workspaceId))?.checkpoint?.providerReference);
+    if (!captured.ok) throw publicApiFailure("workspace_checkpoint_conflict", captured.reason);
     capturedSource = true;
     const capturedAt = (input.now ?? Date.now)();
     const checkpoint = {
@@ -26,28 +654,59 @@ async function captureSandboxCheckpoint(input) {
       metadata: {
         scope: persistence.capture,
         sourceBehavior: requireCaptureSource(persistence.captureSource),
-        ...input.request.retentionExpiresAt === void 0 ? {} : { retentionExpiresAt: input.request.retentionExpiresAt },
-        restoreMount: requireRestoreMount(persistence.restoreMount)
+        restoreMount: requireRestoreMount(persistence.restoreMount),
+        ...frozen ? {} : { unfrozen: true }
       }
     };
+    const replaced = (await input.leaseStore.get(input.workspaceId))?.checkpoint;
     const updated = await input.leaseStore.update(input.workspaceId, lease.epoch, {
       checkpoint,
       restore: null,
-      ...persistence.captureSource === "stopped" || persistence.captureSource === "deleted" ? { status: "stopped" } : {}
+      ...input.endsLease?.stoppedError ? { lastError: input.endsLease.stoppedError } : {},
+      ...input.endsLease || persistence.captureSource === "stopped" || persistence.captureSource === "deleted" ? { status: "stopped" } : {}
     });
-    if (!updated) throw new Error("workspace_checkpoint_epoch_fenced");
-    return { status: "ready", lease: updated, checkpoint };
-  } finally {
-    if (!capturedSource || persistence.captureSource === "preserved") {
-      await input.request.runtime.resume();
+    if (!updated) {
+      await discardSnapshot(discard, target, captured.snapshotId);
+      throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_epoch_fenced");
+    }
+    if (replaced && replaced.providerReference !== captured.snapshotId) {
+      await discardSnapshot(discard, target, replaced.providerReference);
     }
+    result = { status: "ready", lease: updated, checkpoint };
+  } catch (error) {
+    if (!capturedSource || persistence.captureSource === "preserved") await thawAfterFailure(input.request.runtime, input.workspaceId);
+    throw error;
+  }
+  if (!input.endsLease && persistence.captureSource === "preserved") await input.request.runtime.resume();
+  return result;
+}
+async function freezeForCapture(request, endsLease, workspaceId) {
+  try {
+    await request.runtime.freeze(request.policy ?? "drain", { idleBefore: request.idleBefore });
+    await request.runtime.flush();
+    await request.runtime.scrub();
+    return true;
+  } catch (error) {
+    if (!endsLease || request.idleBefore !== void 0) throw error;
+    console.warn("A stopping sandbox's runtime did not freeze; its files are captured as they are", { workspaceId, error: String(error) });
+    return false;
   }
 }
+async function thawAfterFailure(runtime, workspaceId) {
+  await runtime.resume().catch((error) => {
+    console.warn("A runtime was not thawed after its capture failed", { workspaceId, error: String(error) });
+  });
+}
+async function discardSnapshot(discard, target, snapshotId) {
+  await discard?.(target, snapshotId).catch((error) => {
+    console.warn("A superseded sandbox snapshot could not be deleted", { workspaceId: target.workspaceId, snapshotId, error: String(error) });
+  });
+}
 async function restoreSandboxCheckpoint(input) {
   const lease = await requireLease(input.leaseStore, input.workspaceId);
   const checkpoint = lease.checkpoint;
   if (!checkpoint || input.request.checkpointId && checkpoint.id !== input.request.checkpointId) {
-    throw new Error("workspace_checkpoint_not_found");
+    throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_not_found");
   }
   if (lease.restore?.state === "ready" && lease.restore.checkpointId === checkpoint.id) {
     return { status: "ready", lease, checkpoint };
@@ -61,7 +720,7 @@ async function restoreSandboxCheckpoint(input) {
     startedAt: (input.now ?? Date.now)()
   };
   const staged = lease.status === "ready" && lease.epoch === checkpoint.sourceEpoch ? await input.leaseStore.update(input.workspaceId, lease.epoch, { status: "stopped", restore: restoring }) : await input.leaseStore.update(input.workspaceId, lease.epoch, { restore: restoring });
-  if (!staged) throw new Error("workspace_restore_epoch_fenced");
+  if (!staged) throw publicApiFailure("workspace_checkpoint_conflict", "workspace_restore_epoch_fenced");
   const result = await input.ensure(input.workspaceId, {
     homeRegion: staged.homeRegion,
     ...input.request.ensure,
@@ -84,7 +743,7 @@ async function restoreSandboxCheckpoint(input) {
         error: result.error ?? "workspace_restore_unavailable"
       }
     });
-    throw new Error(result.error ?? "workspace_restore_unavailable");
+    throw publicApiFailure("workspace_checkpoint_unavailable", result.error ?? "workspace_restore_unavailable");
   }
   await input.request.runtime.reconcile({ epoch: result.epoch, checkpointId: checkpoint.id });
   const ready = await input.leaseStore.update(input.workspaceId, result.epoch, {
@@ -97,21 +756,21 @@ async function restoreSandboxCheckpoint(input) {
       completedAt: (input.now ?? Date.now)()
     }
   });
-  if (!ready) throw new Error("workspace_restore_epoch_fenced");
+  if (!ready) throw publicApiFailure("workspace_checkpoint_conflict", "workspace_restore_epoch_fenced");
   return { status: "ready", lease: ready, checkpoint };
 }
 async function requireLease(store, workspaceId) {
   const lease = await store.get(workspaceId);
-  if (!lease) throw new Error("workspace_checkpoint_lease_missing");
+  if (!lease) throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_lease_missing");
   return lease;
 }
 function requireCaptureSource(value) {
   if (value === "preserved" || value === "stopped" || value === "deleted") return value;
-  throw new Error("workspace_checkpoint_capabilities_invalid");
+  throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_capabilities_invalid");
 }
 function requireRestoreMount(value) {
-  if (value === "same-resource" || value === "copy-on-write" || value === "new-resource") return value;
-  throw new Error("workspace_checkpoint_capabilities_invalid");
+  if (value === "same-resource" || value === "new-resource") return value;
+  throw publicApiFailure("workspace_checkpoint_conflict", "workspace_checkpoint_capabilities_invalid");
 }
 
 // src/hosted-network-policy.ts
@@ -151,7 +810,7 @@ function hostOf(value) {
 }
 function sandboxSourceHost(source) {
   if (!source || source.kind !== "git") return void 0;
-  return hostOf(source.repoUrl);
+  return publicRepoHost(source.repoUrl);
 }
 function hostedSandboxNetworkPolicy(input) {
   const hosts = /* @__PURE__ */ new Set();
@@ -169,87 +828,319 @@ function hostedSandboxNetworkPolicy(input) {
   return { mode: "restricted", hosts: [...hosts] };
 }
 
-// src/index.ts
-function validateSandboxPersistenceCapabilities(input) {
-  if (input.resume === "replacement-restore" && input.capture === "none") {
-    return { valid: false, reason: "replacement restore requires a capture source" };
-  }
-  if (input.capture === "none" && input.captureSource !== "not-applicable") {
-    return { valid: false, reason: "capture source behavior requires capture support" };
-  }
-  if (input.capture !== "none" && input.captureSource === "not-applicable") {
-    return { valid: false, reason: "capture support requires source behavior" };
-  }
-  if (input.capture === "same-resource" && input.restoreMount !== "same-resource") {
-    return { valid: false, reason: "same-resource capture requires same-resource restore" };
+// src/runtime-snapshot.ts
+async function applySandboxRuntimeSnapshot(input) {
+  const { leaseStore, workspaceId, snapshot } = input;
+  const liveness = input.liveness ?? { kind: "demote" };
+  const current = await leaseStore.get(workspaceId);
+  if (!current) return { ok: false, reason: "runtime_lease_missing" };
+  if (current.epoch !== snapshot.epoch) return { ok: false, reason: "runtime_lease_epoch_mismatch" };
+  if (!current.sandboxId || !current.url || !current.hostId) {
+    return { ok: false, reason: "runtime_lease_not_provisioned" };
   }
-  if (input.restoreMount === "copy-on-write" && input.capture !== "directories") {
-    return { valid: false, reason: "copy-on-write restore requires directory capture" };
+  if (current.status === "stopped" || current.status === "destroyed") {
+    return { ok: false, reason: "runtime_lease_not_serving" };
   }
-  return { valid: true };
+  const timestamp = snapshot.now ?? (input.now ?? Date.now)();
+  const retry = liveness.kind === "retry-budget";
+  const updated = await leaseStore.update(workspaceId, snapshot.epoch, {
+    status: snapshot.ok ? "ready" : "unavailable",
+    lastHeartbeatAt: timestamp,
+    ...snapshot.active ? { lastActivityAt: timestamp } : {},
+    ...snapshot.ok ? { lastError: null } : {},
+    ...retry && snapshot.ok ? { retryCount: 0, nextRetryAt: null } : {},
+    ...retry && !snapshot.ok ? {
+      retryCount: current.retryCount + 1,
+      nextRetryAt: liveness.nextRetryAt({ retryCount: current.retryCount + 1, now: timestamp }) ?? null,
+      lastError: SANDBOX_RUNTIME_UNHEALTHY
+    } : {}
+  }, current.status);
+  if (!updated) return { ok: false, reason: await refusedReason(leaseStore, workspaceId, snapshot.epoch) };
+  return { ok: true, status: updated.status };
 }
-function sandboxEgressDisposition(control, net) {
-  if (!net || net.mode === "allow-all") return { action: "enforce" };
-  if (control === "none") return { action: "withhold", reason: "sandbox_egress_uncontained" };
-  const hosts = net.hosts?.length ?? 0;
-  const cidrs = net.cidrs?.length ?? 0;
-  if (hosts === 0 && cidrs === 0) return { action: "enforce" };
-  if (hosts > 0) return { action: "enforce" };
-  return control === "hosts-and-cidrs" ? { action: "enforce" } : { action: "refuse", reason: "sandbox_egress_policy_unenforceable" };
+async function refusedReason(leaseStore, workspaceId, epoch) {
+  const current = await leaseStore.get(workspaceId);
+  if (!current) return "runtime_lease_missing";
+  if (current.epoch !== epoch) return "runtime_lease_epoch_mismatch";
+  return "runtime_lease_not_serving";
 }
+
+// src/egress-warnings.ts
 function egressUnenforcedMessage(input) {
   const scope = input.workspaceId ? `workspace ${input.workspaceId}` : "every sandbox it provisions";
   const withheld = input.requested ? ` The requested allowlist (${(input.requested.hosts ?? []).length} host(s), ${(input.requested.cidrs ?? []).length} cidr(s)) was withheld, not applied.` : "";
-  return `[sandbox-manager] SANDBOX EGRESS IS UNRESTRICTED: driver "${input.driver}" declares egressControl: "none", so ${scope} can reach ANY host on the internet, including attacker-controlled buckets \u2014 agent-authored code inside the sandbox has an unmonitored exfiltration path.${withheld} Select a driver that can enforce egress (daytona, vercel) to close it. See public-docs/sandbox-egress.md.`;
+  return `[sandbox-manager] SANDBOX EGRESS IS UNRESTRICTED: driver "${input.driver}" declares egressControl: "none", so ${scope} can reach ANY host on the internet, including attacker-controlled buckets \u2014 agent-authored code inside the sandbox has an unmonitored exfiltration path.${withheld} Select a driver that can enforce egress (vercel) to close it. See public-docs/sandbox-egress.md.`;
 }
 var compositionEgressWarnings = /* @__PURE__ */ new Set();
+var ensureEgressWarnings = /* @__PURE__ */ new Set();
 function defaultEgressUnenforcedSink(event) {
   console.warn(event.message);
 }
-function brokeredSecretPlaceholder(name) {
-  return `claxedo-broker:${name}`;
+function createEgressWarnings(input) {
+  const { id, egressControl } = input.driver;
+  const sink = input.sink ?? defaultEgressUnenforcedSink;
+  const key = `${id}|${egressControl}`;
+  if (egressControl === "none" && !compositionEgressWarnings.has(key)) {
+    compositionEgressWarnings.add(key);
+    sink({
+      phase: "composition",
+      reason: "sandbox_egress_uncontained",
+      driver: id,
+      egressControl,
+      message: egressUnenforcedMessage({ phase: "composition", driver: id })
+    });
+  }
+  return {
+    withheld(start) {
+      if (ensureEgressWarnings.has(key)) return;
+      ensureEgressWarnings.add(key);
+      sink({
+        phase: "ensure",
+        reason: "sandbox_egress_uncontained",
+        driver: id,
+        egressControl,
+        message: egressUnenforcedMessage({ phase: "ensure", driver: id, workspaceId: start.workspaceId, requested: start.requested }),
+        workspaceId: start.workspaceId,
+        ...start.labels ? { labels: start.labels } : {},
+        requested: start.requested
+      });
+    }
+  };
 }
-function brokeredPlaceholderEnv(secrets) {
-  return Object.fromEntries((secrets ?? []).map((secret) => [secret.name, brokeredSecretPlaceholder(secret.name)]));
+
+// src/garbage-collect.ts
+async function sweepSandboxes(input) {
+  const { driver, leaseStore, appLabel } = input;
+  const blind = { destroyed: [], kept: [], skipped: [], failed: [], listingUnsupported: true, driver: driver.id };
+  if (!driver.list) return blind;
+  let listed;
+  try {
+    listed = await driver.list();
+  } catch (err) {
+    if (!isSandboxListingUnsupported(err)) throw err;
+    return blind;
+  }
+  const leases = new Map((await leaseStore.list()).map((lease) => [lease.workspaceId, lease]));
+  const result = { destroyed: [], kept: [], skipped: [], failed: [] };
+  for (const target of listed) {
+    if (target.labels?.app !== appLabel) {
+      result.skipped.push({ target, reason: "unmanaged_app_label" });
+      continue;
+    }
+    const workspaceId = target.labels.workspaceId;
+    const epoch = target.labels.epoch;
+    if (!workspaceId || !epoch) {
+      result.skipped.push({ target, reason: "missing_runtime_labels" });
+      continue;
+    }
+    const lease = leases.get(workspaceId);
+    const leaseOwnsResource = lease !== void 0 && lease.status !== "destroyed" && (lease.sandboxId === target.sandboxId || lease.driverResourceId !== void 0 && lease.driverResourceId === target.driverResourceId);
+    if (leaseOwnsResource) {
+      result.kept.push(target);
+      continue;
+    }
+    if (lease?.status === "acquiring" && String(lease.epoch) === epoch) {
+      result.kept.push(target);
+      continue;
+    }
+    if (!driver.destroy) {
+      result.skipped.push({ target, reason: "destroy_unsupported" });
+      continue;
+    }
+    try {
+      await driver.destroy(target);
+      result.destroyed.push(target);
+    } catch (err) {
+      result.failed.push({ target, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return result;
 }
-function applySandboxLeasePatch(current, patch, updatedAt) {
+
+// src/start-telemetry.ts
+function createSandboxStartRecorder(options) {
+  function emit(lease, progress, timing, extra) {
+    try {
+      options.onStartPhase?.({
+        ...timing,
+        sinceStartMs: Math.max(0, options.now() - progress.requestedAt),
+        workspaceId: lease.workspaceId,
+        epoch: lease.epoch,
+        driver: options.driver,
+        homeRegion: lease.homeRegion,
+        bootMode: progress.bootMode,
+        labels: extra.labels,
+        ...extra.repoSizeBytes === void 0 ? {} : { repoSizeBytes: extra.repoSizeBytes }
+      });
+    } catch {
+    }
+  }
+  async function append(lease, progress, timings, extra) {
+    const fresh = timings.filter((timing, index) => !progress.phases.includes(timing.phase) && timings.findIndex((other) => other.phase === timing.phase) === index);
+    if (!fresh.length) return void 0;
+    const next = {
+      ...progress,
+      markedAt: extra.markedAt ?? progress.markedAt,
+      phases: [...progress.phases, ...fresh.map((timing) => timing.phase)]
+    };
+    if (!await options.leaseStore.update(lease.workspaceId, lease.epoch, { start: next })) return void 0;
+    for (const timing of fresh) emit(lease, next, timing, extra);
+    return next;
+  }
+  async function started(workspaceId, epoch) {
+    const lease = await options.leaseStore.get(workspaceId);
+    return lease?.epoch === epoch && lease.start ? { lease, progress: lease.start } : void 0;
+  }
   return {
-    ...current,
-    ...patch.status === void 0 ? {} : { status: patch.status },
-    ...patch.sandboxId === void 0 ? {} : { sandboxId: patch.sandboxId },
-    ...patch.url === void 0 ? {} : { url: patch.url },
-    ...patch.hostId === void 0 ? {} : { hostId: patch.hostId },
-    ...patch.driverResourceId === void 0 ? {} : { driverResourceId: patch.driverResourceId },
-    ...patch.retryCount === void 0 ? {} : { retryCount: patch.retryCount },
-    ...patch.lastHeartbeatAt === void 0 ? {} : { lastHeartbeatAt: patch.lastHeartbeatAt },
-    ...patch.lastActivityAt === void 0 ? {} : { lastActivityAt: patch.lastActivityAt },
-    ...patch.labels === void 0 ? {} : { labels: patch.labels },
-    ...patch.nextRetryAt === void 0 ? {} : { nextRetryAt: patch.nextRetryAt ?? void 0 },
-    ...patch.lastError === void 0 ? {} : { lastError: patch.lastError ?? void 0 },
-    ...patch.checkpoint === void 0 ? {} : { checkpoint: patch.checkpoint ?? void 0 },
-    ...patch.persistence === void 0 ? {} : { persistence: patch.persistence ?? void 0 },
-    ...patch.restore === void 0 ? {} : { restore: patch.restore ?? void 0 },
-    updatedAt
+    /**
+     * The phases one provision call observes, each timed and written into the
+     * lease as it ends, so a poller reading the lease mid-boot sees how far the
+     * start has come. `opened` writes the epoch's `lease_decision` before the
+     * driver runs, so a stop that lands mid-boot finds the boot it ends on the
+     * row. A serving lease is not starting. An epoch acquired with a start it
+     * continues has that start and no phase yet; one acquired without begins
+     * its own here.
+     */
+    observe(lease, input) {
+      if (lease.status === "ready") return void 0;
+      let progress = lease.start ?? { requestedAt: input.enteredAt, startedAt: input.enteredAt, bootMode: input.bootMode, markedAt: input.enteredAt, phases: [] };
+      const ended = [];
+      let markedAt = progress.markedAt;
+      const mark = (phase) => {
+        if (progress.phases.includes(phase) || ended.some((timing) => timing.phase === phase)) return;
+        const at = options.now();
+        ended.push({ phase, durationMs: Math.max(0, at - markedAt) });
+        markedAt = at;
+      };
+      const write = async () => {
+        const written = await append(lease, progress, ended.splice(0), { labels: input.labels, markedAt }).catch(() => void 0);
+        if (written) progress = written;
+      };
+      if (!progress.phases.length) mark("lease_decision");
+      return {
+        opened: write,
+        end: async (phase) => {
+          mark(phase);
+          await write();
+        }
+      };
+    },
+    async report(workspaceId, input) {
+      const start = await started(workspaceId, input.epoch);
+      if (!start) return;
+      await append(start.lease, start.progress, input.phases, {
+        labels: start.lease.labels ?? {},
+        ...input.repoSizeBytes === void 0 ? {} : { repoSizeBytes: input.repoSizeBytes }
+      });
+    },
+    async markAfter(workspaceId, input) {
+      const start = await started(workspaceId, input.epoch);
+      if (!start || input.notBefore < start.progress.startedAt) return;
+      const at = options.now();
+      await append(start.lease, start.progress, [{ phase: input.phase, durationMs: Math.max(0, at - start.progress.markedAt) }], {
+        labels: start.lease.labels ?? {},
+        markedAt: at
+      });
+    }
   };
 }
-function sandboxNetworkPolicyWithBrokeredHosts(policy, secrets) {
-  if (policy.mode !== "restricted" || !secrets?.length) return policy;
-  const hosts = [.../* @__PURE__ */ new Set([
-    ...policy.hosts ?? [],
-    ...secrets.flatMap((secret) => secret.hosts)
-  ])].toSorted();
+
+// src/lease-lifecycle.ts
+function createLifecycleReporter(sink, now) {
+  const base = (lease) => ({ workspaceId: lease.workspaceId, epoch: lease.epoch, driver: lease.driver, labels: lease.labels ?? {} });
+  const active = (lease, endedAt = now()) => lease.status === "ready" && lease.start ? { activeMs: Math.max(0, endedAt - lease.start.startedAt) } : {};
+  const report = (event) => {
+    try {
+      sink?.(event);
+    } catch {
+    }
+  };
   return {
-    ...policy,
-    ...hosts.length ? { hosts } : {}
+    stopped: (lease, cause, outcome = {}) => report({ ...base(lease), kind: "stopped", cause, ...active(lease), ...outcome }),
+    /** `endedAt` is when the host was last proven serving: a stop the provider made on its own is learned after the fact. */
+    hostStopped: (lease, endedAt) => report({ ...base(lease), kind: "stopped", cause: "provider", ...active(lease, endedAt) }),
+    destroyed: (lease) => report({ ...base(lease), kind: "destroyed", hostGone: false, ...active(lease) }),
+    /** `endedAt` is when the host was last proven serving: the provider's loss is learned after the fact. */
+    hostGone: (lease, endedAt) => report({ ...base(lease), kind: "destroyed", hostGone: true, ...active(lease, endedAt) }),
+    failed: (lease, failure) => report({ ...base(lease), kind: "failed", ...failure }),
+    startedFresh: (lease, checkpointUnusable) => report({ ...base(lease), kind: "startedFresh", ...checkpointUnusable ? { checkpointUnusable } : {} })
   };
 }
-function isSandboxListingUnsupported(err) {
-  return !!err && typeof err === "object" && err.listingUnsupported === true;
+
+// src/lease-start.ts
+function leaseBootMode(lease, driver) {
+  const restoring = Boolean(lease.checkpoint) && lease.status !== "ready" && driver.metadata.persistence.resume === "replacement-restore";
+  if (restoring) return "restore";
+  if (lease.sandboxId && lease.url && driver.resumeHost) return "resume";
+  return "cold-start";
+}
+function continuedStart(lease, input) {
+  if (!lease?.start) return void 0;
+  const failure = sandboxLeaseFailure(lease, input);
+  const continued = lease.status === "acquiring" || failure?.kind === "provider" && lease.nextRetryAt !== void 0 && lease.retryCount < input.maxRetryCount;
+  if (!continued) return void 0;
+  const { requestedAt, bootMode, failures } = lease.start;
+  return { requestedAt, bootMode, startedAt: input.now, markedAt: input.now, phases: [], ...failures ? { failures } : {} };
 }
+
+// src/start-fresh.ts
+function startsFreshFromImage(persistence) {
+  return persistence.capture === "filesystem" && persistence.restoreMount === "new-resource";
+}
+async function startSandboxFresh(input) {
+  if (!startsFreshFromImage(input.driver.metadata.persistence)) return { ok: false, reason: "start_fresh_unsupported" };
+  const lease = await input.leaseStore.get(input.workspaceId);
+  if (!lease) return { ok: false, reason: "runtime_lease_missing" };
+  const failure = sandboxLeaseFailure(lease, { now: input.now, maxRetryCount: input.maxRetryCount });
+  if (lease.status === "ready" || lease.status === "acquiring" || failure?.retrying) return { ok: false, reason: "workspace_running" };
+  const status = lease.status === "destroyed" ? "destroyed" : "stopped";
+  const updated = await input.leaseStore.update(input.workspaceId, lease.epoch, {
+    status,
+    checkpoint: null,
+    restore: null,
+    lastError: null,
+    nextRetryAt: null,
+    retryCount: 0
+  }, lease.status);
+  if (!updated) return { ok: false, reason: "runtime_lease_changed" };
+  const resource = input.resource(lease);
+  if (lease.checkpoint && resource) await discardSnapshot(input.driver.deleteSnapshot, resource, lease.checkpoint.providerReference);
+  input.lifecycle.startedFresh(lease, failure?.kind === "checkpoint_unusable" ? failure.cause : void 0);
+  return { ok: true, status };
+}
+
+// src/runtime-env.ts
+var WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS = [
+  "WORKSPACE_RUNTIME_WORKSPACE_ID",
+  "WORKSPACE_RUNTIME_HOST_ID",
+  "WORKSPACE_RUNTIME_RELAY_WORKSPACE_IDS"
+];
+function workspaceRuntimeIdentityEnvConflicts(env) {
+  if (!env) return [];
+  return WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS.filter((key) => env[key] !== void 0);
+}
+var WORKSPACE_RUNTIME_PUBLIC_ENV_KEYS = /* @__PURE__ */ new Set([
+  ...WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS,
+  "WORKSPACE_RUNTIME_DIRECTORY",
+  "WORKSPACE_RUNTIME_PORT",
+  "WORKSPACE_RUNTIME_HOST",
+  "WORKSPACE_RUNTIME_SOURCE_KIND",
+  "WORKSPACE_RUNTIME_GIT_REPO_URL",
+  "WORKSPACE_RUNTIME_GIT_BRANCH",
+  "WORKSPACE_RUNTIME_NATIVE_HARNESS",
+  "WORKSPACE_RUNTIME_RELAY_JWKS_URL",
+  "WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL",
+  "WORKSPACE_RUNTIME_SESSION_AUTHORITY_URL"
+]);
+
+// src/manager.ts
 var DEFAULT_APP_LABEL = "claxedo";
 function sandboxId(driver, workspaceId) {
   return `${driver}-${workspaceId}`;
 }
+function leaseHostId(driver, workspaceId, lease, managerInput) {
+  return managerInput?.hostId ?? lease.hostId ?? sandboxId(driver.id, workspaceId);
+}
 function ensureHostInput(input) {
   const egress = sandboxEgressDisposition(input.driver.metadata.egressControl, input.managerInput?.net);
   const labels = {
@@ -261,7 +1152,7 @@ function ensureHostInput(input) {
   };
   return {
     workspaceId: input.workspaceId,
-    hostId: input.managerInput?.hostId ?? input.lease.hostId ?? sandboxId(input.driver.id, input.workspaceId),
+    hostId: leaseHostId(input.driver, input.workspaceId, input.lease, input.managerInput),
     homeRegion: input.homeRegion,
     epoch: input.lease.epoch,
     labels,
@@ -269,13 +1160,14 @@ function ensureHostInput(input) {
     workspaceRoot: input.managerInput?.workspaceRoot ?? "/workspace",
     runtimeCwd: input.managerInput?.runtimeCwd,
     workspaceRuntimePort: input.managerInput?.workspaceRuntimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT,
-    env: input.managerInput?.env ?? {},
+    env: { ...input.managerInput?.env, ...input.leaseEnv },
     // Brokered secrets ride their own channel — NEVER merged into labels or env.
     // Presence of the key, not its length, is the signal: `[]` is the caller
     // withdrawing every brokered secret, and dropping it would reach the driver
     // as "preserve what you have".
     ...input.managerInput?.secrets ? { secrets: input.managerInput.secrets } : {},
     source: input.managerInput?.source,
+    ...input.lease.machineClass ?? input.managerInput?.machineClass ? { machineClass: input.lease.machineClass ?? input.managerInput?.machineClass } : {},
     exposure: input.managerInput?.exposure ?? (input.driver.metadata.targetAccess === "loopback" ? { kind: "loopback" } : { kind: "relay" }),
     // Withheld, never downgraded: `undefined` here is the same shape a caller
     // that asked for no containment produces, so the throwing drivers take
@@ -294,38 +1186,18 @@ function createSandboxManager(options) {
   const retryDelayMs = options.retryDelayMs ?? ((retryCount) => Math.min(6e4, 1e3 * 2 ** Math.max(0, retryCount - 1)));
   const maxRetryCount = options.maxRetryCount ?? Number.POSITIVE_INFINITY;
   const retryCapCooldownMs = options.retryCapCooldownMs ?? 10 * 6e4;
-  const egressControl = options.driver.metadata.egressControl;
-  const onEgressUnenforced = options.onEgressUnenforced ?? defaultEgressUnenforcedSink;
+  const egressWarnings = createEgressWarnings({
+    driver: { id: options.driver.id, egressControl: options.driver.metadata.egressControl },
+    ...options.onEgressUnenforced ? { sink: options.onEgressUnenforced } : {}
+  });
   const lifecycleOperations = /* @__PURE__ */ new Map();
-  function reportEgressUnenforced(input) {
-    onEgressUnenforced({
-      phase: "ensure",
-      reason: "sandbox_egress_uncontained",
-      driver: options.driver.id,
-      egressControl,
-      message: egressUnenforcedMessage({
-        phase: "ensure",
-        driver: options.driver.id,
-        workspaceId: input.workspaceId,
-        requested: input.requested
-      }),
-      workspaceId: input.workspaceId,
-      requested: input.requested
-    });
-  }
-  if (egressControl === "none") {
-    const key = `${options.driver.id}|${egressControl}`;
-    if (!compositionEgressWarnings.has(key)) {
-      compositionEgressWarnings.add(key);
-      onEgressUnenforced({
-        phase: "composition",
-        reason: "sandbox_egress_uncontained",
-        driver: options.driver.id,
-        egressControl,
-        message: egressUnenforcedMessage({ phase: "composition", driver: options.driver.id })
-      });
-    }
-  }
+  const lifecycle = createLifecycleReporter(options.onLifecycle, now);
+  const starts = createSandboxStartRecorder({
+    leaseStore: options.leaseStore,
+    driver: options.driver.id,
+    now,
+    ...options.onStartPhase ? { onStartPhase: options.onStartPhase } : {}
+  });
   function lifecycleQueue(current) {
     return current?.promise.catch(() => void 0) ?? Promise.resolve();
   }
@@ -347,43 +1219,64 @@ function createSandboxManager(options) {
     const operation = lifecycleQueue(current).then(run);
     return lifecycleSettle(workspaceId, { kind, promise: operation }, operation);
   }
-  async function leaseTarget(lease) {
-    if (lease.status !== "ready" || !lease.sandboxId || !lease.url || !lease.hostId) {
-      return { status: "unavailable", reason: "runtime_lease_not_ready" };
-    }
+  function leaseResource(lease) {
+    if (!lease.sandboxId || !lease.hostId) return void 0;
     return {
-      status: "ready",
       sandboxId: lease.sandboxId,
       url: lease.url,
       workspaceId: lease.workspaceId,
       hostId: lease.hostId,
       driverResourceId: lease.driverResourceId,
       labels: lease.labels,
-      driver: {
-        id: lease.driver,
-        resourceId: lease.driverResourceId ?? lease.sandboxId
-      },
+      driver: { id: lease.driver, resourceId: lease.driverResourceId ?? lease.sandboxId },
       epoch: lease.epoch,
       homeRegion: lease.homeRegion
     };
   }
-  function leaseBootMode(lease) {
-    const restoring = Boolean(lease.checkpoint) && lease.status !== "ready" && options.driver.metadata.persistence.resume === "replacement-restore";
-    if (restoring) return "restore";
-    if (lease.sandboxId && options.driver.resumeHost) return "resume";
-    return "cold-start";
+  async function leaseTarget(lease) {
+    const resource = leaseResource(lease);
+    if (lease.status !== "ready" || !resource || !resource.url || !lease.routingId) {
+      const failure = sandboxLeaseFailure(lease, { now: now(), maxRetryCount });
+      const stopReason = lease.status === "stopped" ? sandboxStopReason(lease.lastError) : void 0;
+      return {
+        status: "unavailable",
+        reason: "runtime_lease_not_ready",
+        leaseStatus: lease.status,
+        ...lease.nextRetryAt !== void 0 ? { retryAfterMs: Math.max(0, lease.nextRetryAt - now()) } : {},
+        ...failure ? { failure } : {},
+        ...stopReason ? { stopReason } : {},
+        ...lease.start && (lease.status === "acquiring" || lease.status === "unavailable") ? { start: { ...lease.start, epoch: lease.epoch } } : {},
+        ...lease.status === "acquiring" && lease.hostId ? { booting: { epoch: lease.epoch, hostId: lease.hostId } } : {}
+      };
+    }
+    const booted = resource.labels?.[SANDBOX_IMAGE_LABEL];
+    const imageOutdated = options.driver.image !== void 0 && booted !== void 0 && booted !== options.driver.image;
+    return {
+      ...resource,
+      status: "ready",
+      url: resource.url,
+      routingId: lease.routingId,
+      ...imageOutdated ? { imageOutdated: true } : {},
+      ...lease.start ? { start: { ...lease.start, epoch: lease.epoch } } : {}
+    };
   }
-  async function provision(workspaceId, lease, homeRegion, managerInput) {
+  async function provisionLease(workspaceId, lease, homeRegion, managerInput, enteredAt) {
     try {
+      const leaseEnv = await managerInput.leaseEnv?.({ epoch: lease.epoch, hostId: leaseHostId(options.driver, workspaceId, lease, managerInput) });
+      const identityConflicts = workspaceRuntimeIdentityEnvConflicts(leaseEnv);
+      if (identityConflicts.length) {
+        return { status: "unavailable", error: `sandbox env cannot set runtime identity: ${identityConflicts.join(", ")}`, epoch: lease.epoch, homeRegion };
+      }
       const ensure = ensureHostInput({
         driver: options.driver,
         workspaceId,
         homeRegion,
         lease,
         managerInput,
+        ...leaseEnv ? { leaseEnv } : {},
         appLabel: options.appLabel ?? DEFAULT_APP_LABEL
       });
-      if (ensure.secrets?.length && options.driver.metadata.secretBrokering === "none") {
+      if (ensure.secrets?.length && options.driver.metadata.secretBrokering !== "native") {
         return {
           status: "unavailable",
           error: "secret_brokering_unsupported",
@@ -392,12 +1285,27 @@ function createSandboxManager(options) {
         };
       }
       const resuming = Boolean(lease.sandboxId && ensure.bootSource?.kind === "default" && options.driver.resumeHost);
+      const bootMode = resuming && lease.url ? "resume" : ensure.bootSource?.kind === "driver-snapshot" ? "restore" : "cold-start";
+      const start = starts.observe(lease, { bootMode, enteredAt, labels: ensure.labels });
+      await start?.opened();
+      ensure.onResource = async (resource) => {
+        const recorded = await options.leaseStore.recordTarget(workspaceId, lease.epoch, {
+          ...resource,
+          labels: { ...resource.labels, ...ensure.labels },
+          persistence: options.driver.metadata.persistence
+        });
+        if (!recorded) throw new Error("runtime_lease_changed");
+        await start?.end("provider_ready");
+      };
+      ensure.onMachineReady = async () => start?.end("machine_ready");
+      ensure.onImageReady = async () => start?.end("image_ready");
       const target = resuming ? await options.driver.resumeHost({ lease, ensure }) : await options.driver.ensureHost(ensure);
       if ("provisioning" in target) {
-        await options.leaseStore.update(workspaceId, lease.epoch, {
+        const updated2 = await options.leaseStore.update(workspaceId, lease.epoch, {
           status: "acquiring",
           nextRetryAt: now() + target.retryAfterMs
-        });
+        }, lease.status);
+        if (!updated2) return { status: "unavailable", error: "runtime_lease_changed", epoch: lease.epoch, homeRegion };
         return {
           status: "provisioning",
           retryAfterMs: target.retryAfterMs,
@@ -406,23 +1314,27 @@ function createSandboxManager(options) {
           // Honest progress for the connect UI: which of the three boot paths
           // this cycle is on. Derived from the same inputs that CHOSE the path
           // above, so it cannot drift from what actually ran.
-          bootMode: resuming ? "resume" : ensure.bootSource?.kind === "driver-snapshot" ? "restore" : "cold-start"
+          bootMode
         };
       }
-      const updated = await options.leaseStore.update(workspaceId, lease.epoch, {
-        status: "ready",
+      const updated = await options.leaseStore.recordTarget(workspaceId, lease.epoch, {
         sandboxId: target.sandboxId,
         url: target.url,
         hostId: target.hostId,
         driverResourceId: target.driverResourceId,
-        retryCount: 0,
-        nextRetryAt: null,
-        lastError: null,
-        labels: target.labels ?? ensure.labels,
+        // The placement labels win over anything the driver echoed back: `app`,
+        // `workspaceId` and `epoch` are what garbage collection reads to decide
+        // whether a live sandbox belongs to this deployment, and a driver that
+        // returned its own label set would otherwise decide that answer.
+        labels: { ...target.labels, ...ensure.labels },
         persistence: options.driver.metadata.persistence
       });
-      const resolved = await leaseTarget(updated ?? lease);
-      if (resolved.status === "ready") return resolved;
+      if (!updated) return { status: "unavailable", error: "runtime_lease_changed", epoch: lease.epoch, homeRegion };
+      const resolved = await leaseTarget(updated);
+      if (resolved.status === "ready") {
+        await start?.end("runtime_ready");
+        return resolved;
+      }
       return {
         status: "unavailable",
         error: resolved.reason,
@@ -430,93 +1342,211 @@ function createSandboxManager(options) {
         homeRegion
       };
     } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      if (lease.status === "ready") {
-        const updated = await options.leaseStore.update(workspaceId, lease.epoch, { lastError: error });
-        const resolved = await leaseTarget(updated ?? lease);
-        if (resolved.status === "ready") return resolved;
+      const message = err instanceof Error ? err.message : String(err);
+      if (isSandboxHostGone(err) && lease.sandboxId) {
+        return hostGone(workspaceId, lease, managerInput, message, enteredAt);
+      }
+      const checkpointUnusable = isSandboxCheckpointUnusable(err) ? err.checkpointUnusable : void 0;
+      const bootFailed = checkpointUnusable !== void 0 || isSandboxRuntimeBootFailure(err);
+      const startLimit = !bootFailed && isSandboxProviderRateLimited(err) ? err.providerRateLimited : void 0;
+      const error = checkpointUnusable ? sandboxCheckpointUnusableError(checkpointUnusable, message) : bootFailed ? sandboxRuntimeBootFailedError(message) : startLimit ? sandboxProviderRateLimitedError(options.driver.id, startLimit) : isSandboxProviderKeyRefused(err) ? sandboxProviderKeyRefusedError(options.driver.id, message) : isSandboxStartRefusal(err) || sandboxLeaseEndedUnderStart(message) ? message : sandboxProviderFailedError(options.driver.id, message);
+      if (lease.status === "ready" && !bootFailed) {
+        const updated = await options.leaseStore.update(workspaceId, lease.epoch, { lastError: error }, "ready");
+        if (updated) {
+          const resolved = await leaseTarget(updated);
+          if (resolved.status === "ready") return { ...resolved, stale: true };
+        }
       }
       const nextRetryCount = lease.retryCount + 1;
-      const retryCapped = nextRetryCount >= maxRetryCount;
-      const failed = await options.leaseStore.recordFailure(
-        workspaceId,
-        lease.epoch,
-        error,
-        now() + (retryCapped ? retryCapCooldownMs : retryDelayMs(nextRetryCount))
-      );
+      const startLimitRetryMs = startLimit ? sandboxStartLimitRetryMs(startLimit.window) : void 0;
+      const dayLimited = startLimit !== void 0 && startLimitRetryMs === void 0;
+      const retryCapped = dayLimited || nextRetryCount >= maxRetryCount;
+      const hostLeftRunning = bootFailed || retryCapped ? !await stopHeldHost(workspaceId, lease.epoch) : false;
+      lifecycle.failed(lease, {
+        bootFailed,
+        retrying: !bootFailed && !retryCapped,
+        ...startLimit ? { startLimit: startLimit.window } : {},
+        ...hostLeftRunning ? { hostLeftRunning: true } : {},
+        ...checkpointUnusable ? { checkpointUnusable } : {}
+      });
+      const backoffMs = retryCapped ? retryCapCooldownMs : retryDelayMs(nextRetryCount);
+      const retryInMs = dayLimited ? void 0 : Math.max(backoffMs, startLimitRetryMs ?? 0);
+      const failed = await options.leaseStore.recordFailure(workspaceId, lease.epoch, error, retryInMs === void 0 ? void 0 : now() + retryInMs);
       return {
         status: "unavailable",
-        retryAfterMs: failed?.nextRetryAt ? Math.max(0, failed.nextRetryAt - now()) : retryAfterMs,
+        ...dayLimited ? {} : { retryAfterMs: failed?.nextRetryAt ? Math.max(0, failed.nextRetryAt - now()) : retryAfterMs },
         error,
         epoch: lease.epoch,
-        homeRegion
+        homeRegion,
+        ...retryCapped ? { exhausted: true } : {}
+      };
+    }
+  }
+  async function hostGone(workspaceId, lease, managerInput, message, enteredAt) {
+    if (!await endGoneHostLease(workspaceId, lease, message)) return { status: "unavailable", error: "runtime_lease_changed", epoch: lease.epoch, homeRegion: lease.homeRegion };
+    const admitted = await admit(workspaceId, managerInput);
+    if (!("lease" in admitted)) return admitted;
+    return provisionLease(workspaceId, admitted.lease, admitted.lease.homeRegion, managerInput, enteredAt);
+  }
+  async function endGoneHostLease(workspaceId, lease, message) {
+    const endedAt = hostLastProvenAliveAt(lease);
+    const ended = await options.leaseStore.update(workspaceId, lease.epoch, {
+      status: "destroyed",
+      lastError: sandboxHostGoneError(message),
+      ...endedAt === void 0 ? {} : { endedAt }
+    });
+    if (!ended) return false;
+    lifecycle.hostGone(lease, endedAt);
+    return true;
+  }
+  async function endStoppedHostLease(workspaceId, lease) {
+    const endedAt = hostLastProvenAliveAt(lease);
+    const ended = await options.leaseStore.update(workspaceId, lease.epoch, { status: "stopped", ...endedAt === void 0 ? {} : { endedAt } });
+    if (!ended) return false;
+    lifecycle.hostStopped(lease, endedAt);
+    return true;
+  }
+  function hostLastProvenAliveAt(lease) {
+    if (lease.status !== "ready" || !lease.start) return void 0;
+    return Math.max(lease.start.markedAt, lease.lastHeartbeatAt ?? 0, lease.lastActivityAt ?? 0);
+  }
+  async function hostStopped(stopHost, resource) {
+    try {
+      await stopHost?.(resource);
+      return "stopped";
+    } catch (err) {
+      if (!isSandboxHostGone(err)) throw err;
+      return "destroyed";
+    }
+  }
+  async function stopHeldHost(workspaceId, epoch) {
+    const current = await options.leaseStore.get(workspaceId);
+    const resource = current?.epoch === epoch ? leaseResource(current) : void 0;
+    const stopHost = options.driver.suspend ?? options.driver.stop;
+    if (!current || !resource || !stopHost) return true;
+    try {
+      await stopHost({ ...resource, ...current.checkpoint ? { checkpoint: current.checkpoint.providerReference } : {} });
+      return true;
+    } catch (stopError) {
+      console.warn("A sandbox host was not stopped after its start failed", {
+        workspaceId,
+        epoch,
+        sandboxId: resource.sandboxId,
+        error: stopError instanceof Error ? stopError.message : String(stopError)
+      });
+      return false;
+    }
+  }
+  function capture(manager, workspaceId, request, endsLease) {
+    return captureSandboxCheckpoint({
+      workspaceId,
+      request,
+      leaseStore: options.leaseStore,
+      target: (id) => manager.target(id),
+      snapshot: (id, committed) => manager.snapshot(id, committed),
+      ...options.driver.deleteSnapshot ? { deleteSnapshot: options.driver.deleteSnapshot } : {},
+      ...endsLease ? { endsLease } : {},
+      now
+    });
+  }
+  function wanted(lease, afterMs = retryAfterMs) {
+    return { status: "provisioning", retryAfterMs: afterMs, epoch: lease.epoch, homeRegion: lease.homeRegion, bootMode: leaseBootMode(lease, options.driver) };
+  }
+  function waiting(existing) {
+    if (!existing) return void 0;
+    if (existing.nextRetryAt && existing.nextRetryAt > now()) {
+      if (existing.status === "acquiring") return wanted(existing, existing.nextRetryAt - now());
+      return {
+        status: "unavailable",
+        retryAfterMs: existing.nextRetryAt - now(),
+        error: existing.lastError,
+        epoch: existing.epoch,
+        homeRegion: existing.homeRegion,
+        ...existing.retryCount >= maxRetryCount ? { exhausted: true } : {}
       };
     }
+    if (existing.status === "unavailable" && existing.retryCount >= maxRetryCount && existing.nextRetryAt === void 0 && sandboxProviderRateLimit(existing.lastError) !== "day") {
+      return {
+        status: "unavailable",
+        error: existing.lastError ?? SANDBOX_RETRY_CAP_EXCEEDED,
+        epoch: existing.epoch,
+        homeRegion: existing.homeRegion
+      };
+    }
+    return void 0;
+  }
+  function continues(lease) {
+    if (lease.status === "ready") return true;
+    if (lease.status !== "acquiring") return false;
+    const stale = now() - lease.updatedAt >= staleAfterMs;
+    return lease.sandboxId ? lease.nextRetryAt !== void 0 || stale : lease.nextRetryAt !== void 0 && !stale;
+  }
+  async function admit(workspaceId, input) {
+    const egress = sandboxEgressDisposition(options.driver.metadata.egressControl, input.net);
+    if (egress.action === "withhold" && input.net) {
+      egressWarnings.withheld({ workspaceId, ...input.labels ? { labels: input.labels } : {}, requested: input.net });
+    }
+    if (egress.action === "refuse") {
+      return { status: "unavailable", error: egress.reason, homeRegion: input.homeRegion };
+    }
+    const identityConflicts = workspaceRuntimeIdentityEnvConflicts(input.env);
+    if (identityConflicts.length) {
+      return {
+        status: "unavailable",
+        error: `sandbox env cannot set runtime identity: ${identityConflicts.join(", ")}`,
+        homeRegion: input.homeRegion
+      };
+    }
+    if (input.machineClass && !options.driver.metadata.machineClasses?.includes(input.machineClass)) {
+      return { status: "unavailable", error: `sandbox_machine_class_unsupported: ${options.driver.id} has no ${input.machineClass} machines`, homeRegion: input.homeRegion };
+    }
+    const existing = await options.leaseStore.get(workspaceId);
+    const wait = waiting(existing);
+    if (wait) return wait;
+    if (existing && continues(existing)) return { lease: existing };
+    const start = continuedStart(existing, { now: now(), maxRetryCount });
+    const acquired = await options.leaseStore.acquire(workspaceId, {
+      homeRegion: input.homeRegion,
+      driver: options.driver.id,
+      staleAfterMs,
+      now: now(),
+      ...input.labels ? { labels: input.labels } : {},
+      ...input.machineClass ? { machineClass: input.machineClass } : {},
+      ...start ? { start } : {}
+    });
+    if (!acquired.acquired) return wanted(acquired.lease, acquired.retryAfterMs);
+    if (!existing) input.onLeaseOpened?.();
+    return { lease: acquired.lease };
   }
   return {
     async ensure(workspaceId, input) {
-      const egress = sandboxEgressDisposition(options.driver.metadata.egressControl, input.net);
-      if (egress.action === "withhold" && input.net) {
-        reportEgressUnenforced({ workspaceId, requested: input.net });
-      }
-      if (egress.action === "refuse") {
-        return { status: "unavailable", error: egress.reason, homeRegion: input.homeRegion };
-      }
-      const existing = await options.leaseStore.get(workspaceId);
-      if (existing?.nextRetryAt && existing.nextRetryAt > now()) {
-        if (existing.status === "acquiring") {
-          return {
-            status: "provisioning",
-            retryAfterMs: existing.nextRetryAt - now(),
-            epoch: existing.epoch,
-            homeRegion: existing.homeRegion,
-            bootMode: leaseBootMode(existing)
-          };
-        }
-        return {
-          status: "unavailable",
-          retryAfterMs: existing.nextRetryAt - now(),
-          error: existing.lastError,
-          epoch: existing.epoch,
-          homeRegion: existing.homeRegion
-        };
-      }
-      if (existing?.status === "unavailable" && existing.retryCount >= maxRetryCount && existing.nextRetryAt === void 0) {
-        return {
-          status: "unavailable",
-          error: existing.lastError ?? "runtime_retry_cap_exceeded",
-          epoch: existing.epoch,
-          homeRegion: existing.homeRegion
-        };
-      }
-      if (existing?.status === "ready") {
-        return provision(workspaceId, existing, existing.homeRegion, input);
+      const enteredAt = now();
+      const admitted = await admit(workspaceId, input);
+      if (!("lease" in admitted)) return admitted;
+      return provisionLease(workspaceId, admitted.lease, admitted.lease.homeRegion, input, enteredAt);
+    },
+    async acquire(workspaceId, input) {
+      const admitted = await admit(workspaceId, input);
+      return "lease" in admitted ? wanted(admitted.lease) : admitted;
+    },
+    async provision(workspaceId, epoch, input) {
+      const enteredAt = now();
+      const lease = await options.leaseStore.get(workspaceId);
+      if (!lease || lease.epoch !== epoch) {
+        return { status: "unavailable", error: "runtime_lease_changed", epoch, homeRegion: input.homeRegion };
       }
-      if (existing?.status === "acquiring" && existing.nextRetryAt !== void 0 && now() - existing.updatedAt < staleAfterMs) {
-        return provision(workspaceId, existing, existing.homeRegion, input);
+      if (lease.status === "stopped" || lease.status === "destroyed") {
+        return { status: "unavailable", error: `runtime_lease_${lease.status}`, epoch, homeRegion: lease.homeRegion };
       }
-      const acquired = await options.leaseStore.acquire(workspaceId, {
-        homeRegion: input.homeRegion,
-        driver: options.driver.id,
-        staleAfterMs,
-        now: now()
-      });
-      if (!acquired.acquired) {
-        return {
-          status: "provisioning",
-          retryAfterMs: acquired.retryAfterMs,
-          epoch: acquired.lease.epoch,
-          homeRegion: acquired.lease.homeRegion,
-          bootMode: leaseBootMode(acquired.lease)
-        };
-      }
-      return provision(workspaceId, acquired.lease, input.homeRegion, input);
+      const admitted = lease.status === "unavailable" ? await admit(workspaceId, input) : waiting(lease) ?? { lease };
+      if (!("lease" in admitted)) return admitted;
+      return provisionLease(workspaceId, admitted.lease, admitted.lease.homeRegion, input, enteredAt);
     },
     async register(workspaceId, input) {
-      return await updateFromRuntimeSnapshot(workspaceId, input);
+      return await runtimeSnapshot(workspaceId, input);
     },
     async heartbeat(workspaceId, input) {
-      return await updateFromRuntimeSnapshot(workspaceId, input);
+      return await runtimeSnapshot(workspaceId, input);
     },
     async target(workspaceId) {
       const lease = await options.leaseStore.get(workspaceId);
@@ -529,21 +1559,14 @@ function createSandboxManager(options) {
       await options.driver.touch?.(target);
       return { touched: true, status: "ready" };
     },
-    async snapshot(workspaceId) {
+    async snapshot(workspaceId, committed) {
       const target = await this.target(workspaceId);
       if (target.status !== "ready") return { ok: false, reason: target.reason };
       if (!options.driver.snapshot) return { ok: false, reason: "snapshot_unsupported" };
-      return { ok: true, ...await options.driver.snapshot(target) };
+      return { ok: true, ...await options.driver.snapshot(target, committed) };
     },
     async checkpoint(workspaceId, input) {
-      return await checkpointLifecycle(workspaceId, "checkpoint", () => captureSandboxCheckpoint({
-        workspaceId,
-        request: input,
-        leaseStore: options.leaseStore,
-        target: (id) => this.target(id),
-        snapshot: (id) => this.snapshot(id),
-        now
-      }));
+      return await checkpointLifecycle(workspaceId, "checkpoint", () => capture(this, workspaceId, input));
     },
     async restore(workspaceId, input) {
       return await checkpointLifecycle(workspaceId, "restore", () => restoreSandboxCheckpoint({
@@ -554,142 +1577,178 @@ function createSandboxManager(options) {
         now
       }));
     },
-    async stop(workspaceId) {
+    async stop(workspaceId, input = {}) {
       return await mutationLifecycle(workspaceId, "stop", async () => {
         const lease = await options.leaseStore.get(workspaceId);
-        if (lease?.status === "stopped") return { ok: true, status: "stopped" };
+        if (input.expectedEpoch !== void 0 && lease?.epoch !== input.expectedEpoch) return { ok: false, reason: "runtime_lease_changed" };
+        const stopped = { ok: true, status: "stopped" };
+        if (lease?.status === "stopped") return stopped;
         const target = await this.target(workspaceId);
-        if (target.status !== "ready") return { ok: false, reason: target.reason };
-        if (options.driver.metadata.hostStopBehavior !== "not-supported") {
-          await (options.driver.suspend ?? options.driver.stop)?.(target);
-        } else {
-          await options.driver.stop?.(target);
+        const stopHost = input.hostStopsItself ? void 0 : options.driver.suspend ?? options.driver.stop;
+        const cause = input.idleBefore !== void 0 ? "idle" : input.unresponsiveForMs !== void 0 ? "unresponsive" : "explicit";
+        const stoppedError = input.unresponsiveForMs === void 0 ? void 0 : sandboxRuntimeUnresponsiveError(input.unresponsiveForMs);
+        const ended = async (resource2, status, unsaved2 = false) => {
+          if (!lease) return void 0;
+          const endedAt = status === "destroyed" ? hostLastProvenAliveAt(lease) : void 0;
+          const updated = await options.leaseStore.update(workspaceId, resource2.epoch, {
+            status,
+            ...status === "destroyed" ? { lastError: sandboxHostGoneError(`${resource2.sandboxId} is gone`) } : stoppedError ? { lastError: stoppedError } : {},
+            ...endedAt === void 0 ? {} : { endedAt }
+          });
+          if (!updated) return void 0;
+          if (status === "destroyed") lifecycle.hostGone(lease, endedAt);
+          else lifecycle.stopped(lease, cause, unsaved2 ? { unsaved: true } : {});
+          return { ok: true, status, ...unsaved2 ? { unsaved: true } : {} };
+        };
+        if (target.status !== "ready") {
+          const held = lease?.status === "acquiring" ? leaseResource(lease) : void 0;
+          if (!lease || !held) return { ok: false, reason: target.reason };
+          return await ended(held, await hostStopped(stopHost, held)) ?? { ok: false, reason: "runtime_lease_changed" };
+        }
+        const persistence2 = lease?.persistence;
+        let unsaved = false;
+        if (input.runtime && persistence2 && persistence2.capture !== "none") {
+          try {
+            const captured = await capture(this, workspaceId, { runtime: input.runtime, policy: "drain", idleBefore: input.idleBefore }, stoppedError ? { stoppedError } : {});
+            const checkpoint2 = captured.checkpoint.providerReference;
+            if (persistence2.captureSource === "preserved") await stopHost?.({ ...target, checkpoint: checkpoint2 });
+            if (lease) lifecycle.stopped(lease, cause, captured.checkpoint.metadata.unfrozen ? { unfrozen: true } : {});
+            return stopped;
+          } catch (error) {
+            if (input.idleBefore !== void 0) throw error;
+            console.warn("A stopping sandbox was not captured; it stops on its last checkpoint", {
+              workspaceId,
+              epoch: target.epoch,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            const current = await options.leaseStore.get(workspaceId);
+            if (current?.status === "stopped") return stopped;
+            if (current?.epoch !== target.epoch || current.status !== "ready") return { ok: false, reason: "runtime_lease_changed" };
+            unsaved = true;
+          }
         }
-        await options.leaseStore.update(workspaceId, target.epoch, { status: "stopped" });
-        return { ok: true, status: "stopped" };
+        const checkpoint = lease?.checkpoint?.providerReference;
+        const resource = { ...target, ...checkpoint ? { checkpoint } : {} };
+        return await ended(resource, await hostStopped(stopHost, resource), unsaved) ?? { ok: false, reason: "runtime_lease_changed" };
       });
     },
+    async endIfHostDown(workspaceId, epoch) {
+      const lease = await options.leaseStore.get(workspaceId);
+      if (!lease || lease.epoch !== epoch) return void 0;
+      const target = await leaseTarget(lease);
+      if (target.status !== "ready") return void 0;
+      const unansweredAt = now();
+      const state = options.driver.inspect ? await options.driver.inspect(target) : void 0;
+      if (state === void 0 || state === "serving") {
+        await options.leaseStore.update(workspaceId, epoch, { lastHealthFailureAt: unansweredAt, ...state ? { lastHeartbeatAt: unansweredAt } : {} }, "ready");
+        return void 0;
+      }
+      const ended = state === "gone" ? await endGoneHostLease(workspaceId, lease, `${target.sandboxId} is gone`) : await endStoppedHostLease(workspaceId, lease);
+      return ended ? state : void 0;
+    },
     async destroy(workspaceId) {
       return await mutationLifecycle(workspaceId, "destroy", async () => {
         const lease = await options.leaseStore.get(workspaceId);
         if (lease?.status === "destroyed") return { ok: true, status: "destroyed" };
-        const target = await this.target(workspaceId);
-        if (target.status !== "ready") return { ok: false, reason: target.reason };
+        if (!lease) return { ok: false, reason: "runtime_lease_missing" };
+        const target = leaseResource(lease);
+        if (!target) return { ok: false, reason: "runtime_lease_resource_missing" };
         await options.driver.destroy?.(target);
-        await options.leaseStore.update(workspaceId, target.epoch, { status: "destroyed" });
+        const updated = await options.leaseStore.update(workspaceId, target.epoch, { status: "destroyed" });
+        if (!updated) return { ok: false, reason: "runtime_lease_changed" };
+        lifecycle.destroyed(lease);
+        if (lease.checkpoint && lease.persistence?.capture !== "same-resource") {
+          await discardSnapshot(options.driver.deleteSnapshot, target, lease.checkpoint.providerReference);
+        }
         return { ok: true, status: "destroyed" };
       });
     },
+    startFresh(workspaceId) {
+      return mutationLifecycle(workspaceId, "startFresh", () => startSandboxFresh({
+        workspaceId,
+        driver: options.driver,
+        leaseStore: options.leaseStore,
+        lifecycle,
+        resource: leaseResource,
+        now: now(),
+        maxRetryCount
+      }));
+    },
     async release(workspaceId) {
       const lease = await options.leaseStore.get(workspaceId);
       if (!lease) return { released: false };
       await options.leaseStore.release(workspaceId);
       return { released: true };
     },
-    async garbageCollect() {
-      if (!options.driver.list) {
-        return {
-          destroyed: [],
-          kept: [],
-          skipped: [],
-          failed: [],
-          listingUnsupported: true,
-          driver: options.driver.id
-        };
-      }
-      let listed;
-      try {
-        listed = await options.driver.list();
-      } catch (err) {
-        if (!isSandboxListingUnsupported(err)) throw err;
-        return {
-          destroyed: [],
-          kept: [],
-          skipped: [],
-          failed: [],
-          listingUnsupported: true,
-          driver: options.driver.id
-        };
-      }
-      const leases = new Map((await options.leaseStore.list()).map((lease) => [lease.workspaceId, lease]));
-      const result = {
-        destroyed: [],
-        kept: [],
-        skipped: [],
-        failed: []
-      };
-      const appLabel = options.appLabel ?? DEFAULT_APP_LABEL;
-      for (const target of listed) {
-        if (target.labels?.app !== appLabel) {
-          result.skipped.push({ target, reason: "unmanaged_app_label" });
-          continue;
-        }
-        const workspaceId = target.labels.workspaceId;
-        const epoch = target.labels.epoch;
-        if (!workspaceId || !epoch) {
-          result.skipped.push({ target, reason: "missing_runtime_labels" });
-          continue;
-        }
-        const lease = leases.get(workspaceId);
-        if (lease?.status === "ready" && String(lease.epoch) === epoch && lease.hostId === target.hostId && lease.sandboxId === target.sandboxId) {
-          result.kept.push(target);
-          continue;
-        }
-        if (lease?.status === "acquiring" && String(lease.epoch) === epoch) {
-          result.kept.push(target);
-          continue;
-        }
-        if (!options.driver.destroy) {
-          result.skipped.push({ target, reason: "destroy_unsupported" });
-          continue;
-        }
-        try {
-          await options.driver.destroy(target);
-          result.destroyed.push(target);
-        } catch (err) {
-          result.failed.push({ target, error: err instanceof Error ? err.message : String(err) });
-        }
-      }
-      return result;
-    },
-    list: () => options.leaseStore.list()
+    garbageCollect: () => sweepSandboxes({ driver: options.driver, leaseStore: options.leaseStore, appLabel: options.appLabel ?? DEFAULT_APP_LABEL }),
+    list: () => options.leaseStore.list(),
+    recordStartPhases: (workspaceId, input) => starts.report(workspaceId, input),
+    markStartPhase: (workspaceId, input) => starts.markAfter(workspaceId, input)
   };
-  async function updateFromRuntimeSnapshot(workspaceId, input) {
-    const current = await options.leaseStore.get(workspaceId);
-    if (!current) return { ok: false, reason: "runtime_lease_missing" };
-    const expectedEpoch = input.epoch ?? current.epoch;
-    if (current.epoch !== expectedEpoch) return { ok: false, reason: "runtime_lease_epoch_mismatch" };
-    const timestamp = input.now ?? now();
-    const status = input.status === "unhealthy" || !input.ok ? "unavailable" : input.ok ? "ready" : current.status;
-    const updated = await options.leaseStore.update(workspaceId, expectedEpoch, {
-      status,
-      ...input.sandboxId ? { sandboxId: input.sandboxId } : {},
-      ...input.url ? { url: input.url } : {},
-      ...input.hostId ? { hostId: input.hostId } : input.sandboxId ? { hostId: input.sandboxId } : {},
-      ...input.driverResourceId ? { driverResourceId: input.driverResourceId } : input.sandboxId ? { driverResourceId: input.sandboxId } : {},
-      lastHeartbeatAt: timestamp,
-      ...input.active ? { lastActivityAt: timestamp } : {},
-      ...input.ok ? { lastError: null } : {}
-    });
-    if (!updated) return { ok: false, reason: "runtime_lease_epoch_mismatch" };
-    return { ok: true, status: updated.status };
+  function runtimeSnapshot(workspaceId, snapshot) {
+    return applySandboxRuntimeSnapshot({ leaseStore: options.leaseStore, workspaceId, snapshot, now });
   }
 }
 export {
   DEFAULT_WORKSPACE_RUNTIME_PORT,
   SANDBOX_BASELINE_EGRESS_HOSTS,
+  SANDBOX_IMAGE_LABEL,
   SANDBOX_MODEL_PROVIDER_HOSTS,
   SANDBOX_PACKAGE_REGISTRY_HOSTS,
+  SANDBOX_RETRY_CAP_EXCEEDED,
+  SANDBOX_RUNTIME_UNHEALTHY,
+  SANDBOX_START_WINDOWS,
+  SandboxCheckpointUnusableError,
+  SandboxHostGoneError,
+  SandboxProviderKeyRefusedError,
+  SandboxProviderRateLimitedError,
+  SandboxRuntimeBootError,
+  SandboxStartRefusedError,
+  applySandboxLeaseFailure,
   applySandboxLeasePatch,
+  applySandboxProvisionedTarget,
+  applySandboxRuntimeSnapshot,
+  boatBilling,
   brokeredPlaceholderEnv,
   brokeredSecretPlaceholder,
   captureSandboxCheckpoint,
+  cloudflareBilling,
   createSandboxManager,
+  discardSnapshot,
   hostedSandboxNetworkPolicy,
+  isSandboxCheckpointUnusable,
+  isSandboxCheckpointUnusableCause,
+  isSandboxHostGone,
   isSandboxListingUnsupported,
+  isSandboxProviderKeyRefused,
+  isSandboxProviderRateLimited,
+  isSandboxRuntimeBootFailure,
+  isSandboxStartRefusal,
+  liftSandboxRetryWait,
   restoreSandboxCheckpoint,
+  runtimeBootDiagnostic,
+  sandboxCheckpointUnusable,
+  sandboxCheckpointUnusableCauses,
+  sandboxCheckpointUnusableError,
   sandboxEgressDisposition,
+  sandboxHostGoneError,
+  sandboxLeaseEndedUnderStart,
+  sandboxLeaseFailure,
+  sandboxLeaseHeldHost,
+  sandboxMachineCostUsd,
+  sandboxMachineRate,
   sandboxNetworkPolicyWithBrokeredHosts,
+  sandboxProviderFailedError,
+  sandboxProviderKeyRefusedError,
+  sandboxProviderRateLimit,
+  sandboxProviderRateLimitedError,
+  sandboxRuntimeBootFailedError,
+  sandboxRuntimeBootFailure,
+  sandboxRuntimeUnresponsiveError,
   sandboxSourceHost,
-  validateSandboxPersistenceCapabilities
+  sandboxStartFailureReason,
+  sandboxStartLimitRetryMs,
+  sandboxStopReason,
+  validateSandboxPersistenceCapabilities,
+  workspaceRuntimeBootReason
 };