@ai-sdk/sandbox-vercel 0.0.0 → 1.0.0-canary.3

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# @ai-sdk/sandbox-vercel
+
+## 1.0.0-canary.3
+
+### Patch Changes
+
+- Updated dependencies [21d3d60]
+  - @ai-sdk/harness@1.0.0-canary.3
+
+## 1.0.0-canary.2
+
+### Patch Changes
+
+- 6c7a3e5: Start the `1.0.0` canary release line for the experimental harness and sandbox packages. They were unintentionally published as `0.0.0-canary.*` because they were scaffolded with a `0.0.0-canary.0` premajor version, which semver could not advance past on a major bump.
+- Updated dependencies [6c7a3e5]
+  - @ai-sdk/harness@1.0.0-canary.2
+
+## 0.0.0-canary.1
+
+### Major Changes
+
+- 9d6dbe0: feat(harness): add sandbox specific expansion for harness abstraction, add `sandbox-just-bash` and `sandbox-vercel`
+
+### Patch Changes
+
+- Updated dependencies [9d6dbe0]
+  - @ai-sdk/harness@0.0.0-canary.1

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Vercel, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,76 @@
+# AI SDK - Vercel Sandbox
+
+_This package is **experimental**._
+
+`HarnessV1SandboxProvider` implementation for [Vercel Sandbox](https://vercel.com/docs/vercel-sandbox).
+
+## Setup
+
+```bash
+npm i @ai-sdk/sandbox-vercel @vercel/sandbox
+```
+
+## Usage
+
+The factory is synchronous. The returned provider is stable; the actual `@vercel/sandbox` `Sandbox` is created on demand inside `provider.createSession()`.
+
+```ts
+import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+
+const vercelSandbox = createVercelSandbox({
+  runtime: 'node24',
+  ports: [3000],
+});
+
+const networkSandboxSession = await vercelSandbox.createSession();
+const sandboxSession = networkSandboxSession.restricted();
+
+await sandboxSession.writeTextFile({ path: 'hello.txt', content: 'hi' });
+
+const { stdout } = await sandboxSession.run({
+  command: 'cat hello.txt',
+});
+console.log(stdout); // "hi"
+await networkSandboxSession.stop();
+```
+
+`networkSandboxSession.restricted()` is typed as `Experimental_SandboxSession`, so it's safe to pass to AI SDK tools that accept `experimental_sandbox`. The network sandbox session itself carries the infra surface (`ports`, `getPortUrl`, `setNetworkPolicy`, `stop`) that only the harness should reach for.
+
+The flat-field settings are aliased directly from `@vercel/sandbox`'s `Sandbox.create` parameters, so every option Vercel supports — including its native `NetworkPolicy` — is available without re-declaration:
+
+```ts
+const sandbox = createVercelSandbox({
+  runtime: 'node24',
+  ports: [3000],
+  timeout: 10 * 60 * 1000,
+  networkPolicy: {
+    allow: ['api.example.com'],
+    subnets: { deny: ['169.254.169.254/32'] },
+  },
+});
+```
+
+To wrap an already-created `@vercel/sandbox` `Sandbox` instead — e.g. when you need credentials or options outside the factory's settings, or you want to share one sandbox across multiple harness sessions — pass it via `sandbox`. The network sandbox session's `stop()` is a no-op in this case; the caller owns the lifecycle.
+
+```ts
+import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { Sandbox } from '@vercel/sandbox';
+
+const sandbox = createVercelSandbox({
+  sandbox: await Sandbox.create({ runtime: 'node24', ports: [3000] }),
+});
+```
+
+### Mid-session network policy
+
+Once the network sandbox session is alive, the host can update outbound network policy on the running sandbox:
+
+```ts
+await networkSandboxSession.setNetworkPolicy?.({
+  mode: 'custom',
+  allowedHosts: ['api.example.com'],
+  deniedCIDRs: ['169.254.169.254/32'],
+});
+```
+
+`HarnessV1NetworkPolicy` is the harness-level abstraction used here. The provider translates it to `@vercel/sandbox`'s native `NetworkPolicy` for enforcement.

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { HarnessV1SandboxProvider, HarnessV1NetworkSandboxSession } from '@ai-sdk/harness';
+import { Experimental_SandboxSession } from '@ai-sdk/provider-utils';
+import { Sandbox } from '@vercel/sandbox';
+
+/**
+ * Flattens an intersection of object types into a single object type so the
+ * resolved shape displays as its named properties rather than a chain of
+ * `A & B & C`.
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Distributes `Omit` across each member of a union instead of collapsing the
+ * union to its common keys. `Sandbox.create`'s parameter is a union (a
+ * git/tarball/no-source create variant and a snapshot-source create variant),
+ * so a plain `Omit` would discard keys absent from any one member (e.g.
+ * `runtime`, which the snapshot variant lacks) and merge the `source` shapes.
+ * Applying `Omit` per-member preserves every variant intact; the `Prettify`
+ * wrapper collapses each member's intersections into a readable object shape.
+ */
+type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Prettify<Omit<T, K>> : never;
+/**
+ * Parameters forwarded to `@vercel/sandbox`'s `Sandbox.create` when creating
+ * a sandbox from scratch. Aliased directly from the underlying SDK so the
+ * full surface — every option Vercel supports, including its native
+ * `NetworkPolicy` — is available without us re-declaring it.
+ */
+type VercelSandboxCreateParams = DistributiveOmit<NonNullable<Parameters<typeof Sandbox.create>[0]>, 'onResume'>;
+/**
+ * Settings for {@link createVercelSandbox}. Two mutually-exclusive shapes:
+ *
+ * - `{ sandbox }` — wrap an already-created `@vercel/sandbox` `Sandbox`. The
+ *   caller owns its lifecycle; the provider's `stop()` and `destroy()` are
+ *   no-ops. Optionally declare `bridgePorts` to give the harness a port pool to
+ *   lease from for concurrent sessions on the same provided sandbox.
+ * - {@link VercelSandboxCreateParams} fields — provider creates the underlying
+ *   sandbox. When the adapter declares a bootstrap recipe the provider uses
+ *   `Sandbox.getOrCreate` to maintain a persistent named template snapshot
+ *   keyed by the recipe identity, and forks an ephemeral sandbox per session
+ *   from the snapshot. Use `name` to override the auto-derived template name.
+ */
+type VercelSandboxSettings = {
+    sandbox: Sandbox;
+    bridgePorts?: ReadonlyArray<number>;
+} | (VercelSandboxCreateParams & {
+    sandbox?: never;
+    name?: string;
+});
+declare function createVercelSandbox(settings?: VercelSandboxSettings): HarnessV1SandboxProvider;
+/**
+ * `HarnessV1SandboxProvider` implementation backed by `@vercel/sandbox`.
+ * Construct one via {@link createVercelSandbox} at module scope and pass it
+ * to a `HarnessAgent` (or call `createSession()` directly if you want raw
+ * access to a network sandbox session).
+ */
+declare class VercelSandboxProvider implements HarnessV1SandboxProvider {
+    private readonly settings;
+    readonly specificationVersion: "harness-sandbox-v1";
+    readonly providerId = "vercel-sandbox";
+    readonly bridgePorts?: ReadonlyArray<number>;
+    constructor(settings: VercelSandboxSettings);
+    createSession: (options?: {
+        sessionId?: string;
+        abortSignal?: AbortSignal;
+        identity?: string;
+        onFirstCreate?: (session: Experimental_SandboxSession, opts: {
+            abortSignal?: AbortSignal;
+        }) => Promise<void>;
+    }) => Promise<HarnessV1NetworkSandboxSession>;
+    resumeSession: (options: {
+        sessionId: string;
+        abortSignal?: AbortSignal;
+    }) => Promise<HarnessV1NetworkSandboxSession>;
+}
+
+export { VercelSandboxProvider, type VercelSandboxSettings, createVercelSandbox };

package/dist/index.js

@@ -0,0 +1,474 @@
+// src/vercel-sandbox.ts
+import { Sandbox } from "@vercel/sandbox";
+
+// src/vercel-network-sandbox-session.ts
+import {
+  HarnessCapabilityUnsupportedError
+} from "@ai-sdk/harness";
+
+// src/vercel-sandbox-session.ts
+import { posix } from "path";
+import {
+  extractLines
+} from "@ai-sdk/provider-utils";
+var VercelSandboxSession = class {
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  get description() {
+    return [
+      `Vercel Sandbox (name: ${this.sandbox.name}).`,
+      "Filesystem changes persist for the lifetime of the sandbox."
+    ].join("\n");
+  }
+  async run({
+    command,
+    workingDirectory,
+    env,
+    abortSignal
+  }) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    const finished = await this.sandbox.runCommand({
+      cmd: "bash",
+      args: ["-c", command],
+      ...workingDirectory !== void 0 ? { cwd: workingDirectory } : {},
+      ...env !== void 0 ? { env } : {},
+      ...abortSignal !== void 0 ? { signal: abortSignal } : {}
+    });
+    const [stdout, stderr] = await Promise.all([
+      finished.stdout(),
+      finished.stderr()
+    ]);
+    return {
+      exitCode: finished.exitCode,
+      stdout,
+      stderr
+    };
+  }
+  async spawn({
+    command,
+    workingDirectory,
+    env,
+    abortSignal
+  }) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    const live = await this.sandbox.runCommand({
+      cmd: "bash",
+      args: ["-c", command],
+      detached: true,
+      ...workingDirectory !== void 0 ? { cwd: workingDirectory } : {},
+      ...env !== void 0 ? { env } : {},
+      ...abortSignal !== void 0 ? { signal: abortSignal } : {}
+    });
+    return createSandboxProcess(live, abortSignal);
+  }
+  async readFile({
+    path,
+    abortSignal
+  }) {
+    const bytes = await this.readBinaryFile({ path, abortSignal });
+    if (bytes == null) return null;
+    return bytesToStream(bytes);
+  }
+  async readBinaryFile({
+    path,
+    abortSignal
+  }) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    try {
+      const buffer = await this.sandbox.readFileToBuffer(
+        { path },
+        abortSignal ? { signal: abortSignal } : void 0
+      );
+      if (buffer == null) return null;
+      return new Uint8Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      );
+    } catch (error) {
+      if (isFileNotFoundError(error)) return null;
+      throw error;
+    }
+  }
+  async readTextFile({
+    path,
+    encoding = "utf-8",
+    startLine,
+    endLine,
+    abortSignal
+  }) {
+    const bytes = await this.readBinaryFile({ path, abortSignal });
+    if (bytes == null) return null;
+    const text = Buffer.from(bytes).toString(encoding);
+    return extractLines({ text, startLine, endLine });
+  }
+  async writeFile({
+    path,
+    content,
+    abortSignal
+  }) {
+    const bytes = await collectStream(content);
+    await this.writeBinaryFile({ path, content: bytes, abortSignal });
+  }
+  async writeBinaryFile({
+    path,
+    content,
+    abortSignal
+  }) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    const parent = posix.dirname(path);
+    if (parent && parent !== "." && parent !== "/") {
+      await this.sandbox.runCommand({
+        cmd: "mkdir",
+        args: ["-p", parent],
+        ...abortSignal !== void 0 ? { signal: abortSignal } : {}
+      });
+    }
+    await this.sandbox.writeFiles(
+      [{ path, content }],
+      abortSignal ? { signal: abortSignal } : void 0
+    );
+  }
+  async writeTextFile({
+    path,
+    content,
+    encoding = "utf-8",
+    abortSignal
+  }) {
+    const buffer = Buffer.from(content, encoding);
+    await this.writeBinaryFile({
+      path,
+      content: new Uint8Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      ),
+      abortSignal
+    });
+  }
+};
+function createSandboxProcess(command, abortSignal) {
+  const encoder = new TextEncoder();
+  const controllers = {};
+  const stdout = new ReadableStream({
+    start(controller) {
+      controllers.stdout = controller;
+    }
+  });
+  const stderr = new ReadableStream({
+    start(controller) {
+      controllers.stderr = controller;
+    }
+  });
+  const drained = (async () => {
+    var _a, _b, _c, _d;
+    try {
+      const iterator = abortSignal ? command.logs({ signal: abortSignal }) : command.logs();
+      for await (const message of iterator) {
+        const target = message.stream === "stdout" ? controllers.stdout : controllers.stderr;
+        target == null ? void 0 : target.enqueue(encoder.encode(message.data));
+      }
+      (_a = controllers.stdout) == null ? void 0 : _a.close();
+      (_b = controllers.stderr) == null ? void 0 : _b.close();
+    } catch (error) {
+      (_c = controllers.stdout) == null ? void 0 : _c.error(error);
+      (_d = controllers.stderr) == null ? void 0 : _d.error(error);
+    }
+  })();
+  return {
+    stdout,
+    stderr,
+    async wait() {
+      var _a;
+      const finished = await command.wait();
+      await drained;
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        throw (_a = abortSignal.reason) != null ? _a : new DOMException("Aborted", "AbortError");
+      }
+      return { exitCode: finished.exitCode };
+    },
+    async kill() {
+      await command.kill();
+    }
+  };
+}
+function bytesToStream(bytes) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+async function collectStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+function isFileNotFoundError(error) {
+  if (error == null || typeof error !== "object") return false;
+  const code = error.code;
+  if (code === "ENOENT") return true;
+  const message = error.message;
+  return typeof message === "string" && /no such file|not found|does not exist|ENOENT/i.test(message);
+}
+
+// src/vercel-network-sandbox-session.ts
+var VERCEL_PROVIDER_ID = "vercel-sandbox";
+var VercelNetworkSandboxSession = class extends VercelSandboxSession {
+  constructor(input) {
+    super(input.sandbox);
+    this.getPortUrl = async (options) => {
+      var _a;
+      const exposedPorts = this.ports;
+      if (!exposedPorts.includes(options.port)) {
+        throw new HarnessCapabilityUnsupportedError({
+          harnessId: VERCEL_PROVIDER_ID,
+          message: `Port ${options.port} is not exposed on this sandbox. Exposed ports: [${exposedPorts.join(", ")}].`
+        });
+      }
+      const protocol = (_a = options.protocol) != null ? _a : "https";
+      const url = new URL(this.sandbox.domain(options.port));
+      const isSecure = url.protocol === "https:";
+      switch (protocol) {
+        case "http":
+          url.protocol = isSecure ? "https:" : "http:";
+          break;
+        case "https":
+          url.protocol = "https:";
+          break;
+        case "ws":
+          url.protocol = isSecure ? "wss:" : "ws:";
+          break;
+      }
+      return url.toString();
+    };
+    this.setNetworkPolicy = async (policy) => {
+      await this.sandbox.update({ networkPolicy: toVercelPolicy(policy) });
+    };
+    this.setPorts = async (ports, options) => {
+      await this.sandbox.update(
+        { ports: [...ports] },
+        (options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : void 0
+      );
+    };
+    this.stop = async () => {
+      if (!this.ownsLifecycle) return;
+      await this.sandbox.stop();
+    };
+    this.destroy = async () => {
+      if (!this.ownsLifecycle) return;
+      await this.sandbox.stop().catch(() => {
+      });
+      await this.sandbox.delete();
+    };
+    this.ownsLifecycle = input.ownsLifecycle;
+    this.id = input.sandbox.name;
+    this.defaultWorkingDirectory = input.sandbox.currentSession().cwd;
+  }
+  get ports() {
+    return this.sandbox.routes.map((route) => route.port);
+  }
+  restricted() {
+    return new VercelSandboxSession(this.sandbox);
+  }
+};
+function toVercelPolicy(policy) {
+  switch (policy.mode) {
+    case "allow-all":
+      return "allow-all";
+    case "deny-all":
+      return "deny-all";
+    case "custom": {
+      const result = {};
+      const { allowedHosts, allowedCIDRs, deniedCIDRs } = policy;
+      if (allowedHosts != null && allowedHosts.length > 0) {
+        result.allow = [...allowedHosts];
+      }
+      if (allowedCIDRs != null && allowedCIDRs.length > 0 || deniedCIDRs != null && deniedCIDRs.length > 0) {
+        result.subnets = {
+          ...allowedCIDRs != null && allowedCIDRs.length > 0 ? { allow: [...allowedCIDRs] } : {},
+          ...deniedCIDRs != null && deniedCIDRs.length > 0 ? { deny: [...deniedCIDRs] } : {}
+        };
+      }
+      if (result.allow == null && result.subnets == null) {
+        throw new HarnessCapabilityUnsupportedError({
+          harnessId: VERCEL_PROVIDER_ID,
+          message: "Custom network policy requires at least one of allowedHosts or allowedCIDRs to be non-empty."
+        });
+      }
+      return result;
+    }
+  }
+}
+
+// src/vercel-sandbox.ts
+var DEFAULT_SANDBOX_TIMEOUT_MS = 30 * 60 * 1e3;
+var VERCEL_PROVIDER_ID2 = "vercel-sandbox";
+var TEMPLATE_NAME_PREFIX = "ai-sdk-harness";
+var SESSION_NAME_PREFIX = "ai-sdk-harness-session";
+var SNAPSHOT_POLL_INTERVAL_MS = 500;
+var SNAPSHOT_POLL_TIMEOUT_MS = 3e4;
+function sessionSandboxName(sessionId) {
+  return `${SESSION_NAME_PREFIX}-${sessionId}`;
+}
+function createVercelSandbox(settings = {}) {
+  return new VercelSandboxProvider(settings);
+}
+var VercelSandboxProvider = class {
+  constructor(settings) {
+    this.settings = settings;
+    this.specificationVersion = "harness-sandbox-v1";
+    this.providerId = VERCEL_PROVIDER_ID2;
+    this.createSession = async (options) => {
+      var _a, _b, _c, _d;
+      (_a = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a.throwIfAborted();
+      if ("sandbox" in this.settings && this.settings.sandbox != null) {
+        return new VercelNetworkSandboxSession({
+          sandbox: this.settings.sandbox,
+          ownsLifecycle: false
+        });
+      }
+      const settings = this.settings;
+      const {
+        sandbox: _ignoredSandbox,
+        name: explicitName,
+        ...createParams
+      } = settings;
+      const baseParams = {
+        ...createParams,
+        timeout: (_b = createParams.timeout) != null ? _b : DEFAULT_SANDBOX_TIMEOUT_MS
+      };
+      const identity = options == null ? void 0 : options.identity;
+      const onFirstCreate = options == null ? void 0 : options.onFirstCreate;
+      const sessionNameOverride = (options == null ? void 0 : options.sessionId) ? { name: sessionSandboxName(options.sessionId) } : {};
+      if (identity == null || onFirstCreate == null) {
+        const sandbox = await Sandbox.create({
+          ...baseParams,
+          ...sessionNameOverride,
+          ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
+        });
+        return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+      }
+      const templateName = explicitName != null ? explicitName : `${TEMPLATE_NAME_PREFIX}-${identity}`;
+      const cache = getSnapshotCache();
+      let snapshotId = cache.get(templateName);
+      if (snapshotId == null) {
+        const template = await Sandbox.getOrCreate({
+          ...baseParams,
+          name: templateName,
+          persistent: true,
+          snapshotExpiration: (_c = baseParams.snapshotExpiration) != null ? _c : 0,
+          onCreate: async (sbx) => {
+            await onFirstCreate(new VercelSandboxSession(sbx), {
+              abortSignal: options == null ? void 0 : options.abortSignal
+            });
+          },
+          ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
+        });
+        let resolvedId = template.currentSnapshotId;
+        if (resolvedId == null) {
+          const stopResult = await template.stop(
+            (options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : void 0
+          );
+          resolvedId = (_d = stopResult.snapshot) == null ? void 0 : _d.id;
+          if (resolvedId == null) {
+            resolvedId = await pollForTemplateSnapshot(
+              templateName,
+              options == null ? void 0 : options.abortSignal
+            );
+          }
+        }
+        cache.set(templateName, resolvedId);
+        snapshotId = resolvedId;
+      }
+      const {
+        runtime: _ignoredRuntime,
+        source: _ignoredSource,
+        persistent: _ignoredPersistent,
+        ...forkParams
+      } = baseParams;
+      const fork = await Sandbox.create({
+        ...forkParams,
+        source: { type: "snapshot", snapshotId },
+        ...sessionNameOverride,
+        ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
+      });
+      return new VercelNetworkSandboxSession({
+        sandbox: fork,
+        ownsLifecycle: true
+      });
+    };
+    this.resumeSession = async (options) => {
+      var _a;
+      (_a = options.abortSignal) == null ? void 0 : _a.throwIfAborted();
+      if ("sandbox" in this.settings && this.settings.sandbox != null) {
+        return new VercelNetworkSandboxSession({
+          sandbox: this.settings.sandbox,
+          ownsLifecycle: false
+        });
+      }
+      const sandbox = await Sandbox.get({
+        name: sessionSandboxName(options.sessionId),
+        ...options.abortSignal ? { signal: options.abortSignal } : {}
+      });
+      return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+    };
+    if ("sandbox" in settings && settings.sandbox != null && settings.bridgePorts != null && settings.bridgePorts.length > 0) {
+      this.bridgePorts = [...settings.bridgePorts];
+    }
+  }
+};
+var SNAPSHOT_CACHE_KEY = /* @__PURE__ */ Symbol.for(
+  "ai-sdk.harness.vercel-template-snapshots"
+);
+function getSnapshotCache() {
+  const globals = globalThis;
+  let cache = globals[SNAPSHOT_CACHE_KEY];
+  if (cache == null) {
+    cache = /* @__PURE__ */ new Map();
+    globals[SNAPSHOT_CACHE_KEY] = cache;
+  }
+  return cache;
+}
+async function pollForTemplateSnapshot(name, abortSignal) {
+  const deadline = Date.now() + SNAPSHOT_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    const refreshed = await Sandbox.get({
+      name,
+      resume: false,
+      ...abortSignal ? { signal: abortSignal } : {}
+    });
+    if (refreshed.currentSnapshotId) {
+      return refreshed.currentSnapshotId;
+    }
+    await new Promise(
+      (resolve) => setTimeout(resolve, SNAPSHOT_POLL_INTERVAL_MS)
+    );
+  }
+  throw new Error(
+    `Timed out waiting for snapshot of template "${name}" to publish.`
+  );
+}
+export {
+  VercelSandboxProvider,
+  createVercelSandbox
+};
+//# sourceMappingURL=index.js.map