@alchemy.run/e2b 0.0.0 → 2.0.0-beta.86

package/lib/ReadVolume.d.ts

@@ -0,0 +1,25 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Volume } from "./Volume.ts";
+import type { ReadVolumeClient } from "./VolumeFiles.ts";
+/**
+ * Read a {@link Volume}'s files from outside any sandbox: a report a sandbox wrote, a dataset to inspect.
+ *
+ * The client talks to E2B's volume content API with the volume's own token,
+ * looked up once through the host's API key.
+ *
+ * ### Using the client
+ * **Example:** In a Worker
+ * ```typescript
+ * const reports = yield* E2B.ReadVolume(Reports);
+ * // in fetch:
+ * const report = yield* reports.readText("/report.json");
+ * ```
+ *
+ * @binding
+ * @product Volume
+ */
+export interface ReadVolume extends Binding.Service<ReadVolume, "E2B.ReadVolume", (volume: Volume) => Effect.Effect<ReadVolumeClient>> {
+}
+export declare const ReadVolume: ReadVolume;
+//# sourceMappingURL=ReadVolume.d.ts.map

package/lib/ReadVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadVolume.d.ts","sources":["../src/ReadVolume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,UAAW,SAAQ,OAAO,CAAC,OAAO,CACjD,UAAU,EACV,gBAAgB,EAChB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CACpD;CAAG;AAEJ,eAAO,MAAM,UAAU,YAAgD,CAAC"}

package/lib/ReadVolume.js

@@ -0,0 +1,3 @@
+import * as Binding from "alchemy/Binding";
+export const ReadVolume = Binding.Service("E2B.ReadVolume");
+//# sourceMappingURL=ReadVolume.js.map

package/lib/ReadVolume.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadVolume.js","sources":["../src/ReadVolume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AA4B3C,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAa,gBAAgB,CAAC,CAAC"}

package/lib/ReadVolumeHttp.d.ts

@@ -0,0 +1,20 @@
+import * as Layer from "effect/Layer";
+import { ReadVolume } from "./ReadVolume.ts";
+/**
+ * HTTP implementation of {@link ReadVolume}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const reports = yield* E2B.ReadVolume(Reports);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadVolumeHttp))
+ * ```
+ *
+ * @layer
+ * @product Volume
+ * @provides E2B.ReadVolume
+ */
+export declare const ReadVolumeHttp: Layer.Layer<ReadVolume, never, never>;
+//# sourceMappingURL=ReadVolumeHttp.d.ts.map

package/lib/ReadVolumeHttp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadVolumeHttp.d.ts","sources":["../src/ReadVolumeHttp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,uCAO1B,CAAC"}

package/lib/ReadVolumeHttp.js

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { bindE2B } from "./E2BBindings.js";
+import { makeVolumeFiles } from "./internal/VolumeHttp.js";
+import { ReadVolume } from "./ReadVolume.js";
+/**
+ * HTTP implementation of {@link ReadVolume}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const reports = yield* E2B.ReadVolume(Reports);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadVolumeHttp))
+ * ```
+ *
+ * @layer
+ * @product Volume
+ * @provides E2B.ReadVolume
+ */
+export const ReadVolumeHttp = Layer.succeed(ReadVolume, Effect.fn("E2B.ReadVolume")(function* (volume) {
+    const auth = yield* bindE2B;
+    const volumeId = yield* volume.volumeId.asEffect();
+    return makeVolumeFiles(auth, volumeId);
+}));
+//# sourceMappingURL=ReadVolumeHttp.js.map

package/lib/ReadVolumeHttp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadVolumeHttp.js","sources":["../src/ReadVolumeHttp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CACzC,UAAU,EACV,MAAM,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAc;IACnD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC;IAC5B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAE,MAAM,CAAC,QAAyC,CAAC,QAAQ,EAAE,CAAC;IACrF,OAAO,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACzC,CAAC,CAAC,CACH,CAAC"}

package/lib/ReadWebhook.d.ts

@@ -0,0 +1,32 @@
+import type * as webhooks from "@distilled.cloud/e2b/webhooks";
+import * as Binding from "alchemy/Binding";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type { E2BError } from "./SandboxClient.ts";
+import type { Webhook } from "./Webhook.ts";
+/** A webhook's delivery history and stats. */
+export interface WebhookClient {
+    /** Deliveries grouped by event, newest first, with each attempt's request and response. */
+    deliveries(options?: Omit<webhooks.ListWebhookDeliveriesRequest, "webhookID">): Effect.Effect<webhooks.WebhookDeliveriesListPayload, E2BError, RuntimeContext>;
+    /** Delivery counts, failures and latency over time. */
+    stats(options?: Omit<webhooks.GetWebhookStatsRequest, "webhookID">): Effect.Effect<webhooks.WebhookDeliveryStats, E2BError, RuntimeContext>;
+}
+/**
+ * Read an E2B {@link Webhook}'s delivery history and stats: debug a failing
+ * endpoint, or alert on failed deliveries.
+ *
+ * ### Reading deliveries
+ * **Example:** Failed deliveries in the last hour
+ * ```typescript
+ * const hook = yield* E2B.ReadWebhook(Lifecycle);
+ * // in fetch:
+ * const failed = yield* hook.deliveries({ deliveryStatus: ["failed"] });
+ * ```
+ *
+ * @binding
+ * @product Webhook
+ */
+export interface ReadWebhook extends Binding.Service<ReadWebhook, "E2B.ReadWebhook", (webhook: Webhook) => Effect.Effect<WebhookClient>> {
+}
+export declare const ReadWebhook: ReadWebhook;
+//# sourceMappingURL=ReadWebhook.d.ts.map

package/lib/ReadWebhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWebhook.d.ts","sources":["../src/ReadWebhook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,8CAA8C;AAC9C,MAAM,WAAW,aAAa;IAC5B,2FAA2F;IAC3F,UAAU,CACR,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,4BAA4B,EAAE,WAAW,CAAC,GACjE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAA4B,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;IAClF,uDAAuD;IACvD,KAAK,CACH,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE,WAAW,CAAC,GAC3D,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;CAC3E;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,OAAO,CAClD,WAAW,EACX,iBAAiB,EACjB,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CACnD;CAAG;AAEJ,eAAO,MAAM,WAAW,aAAkD,CAAC"}

package/lib/ReadWebhook.js

@@ -0,0 +1,3 @@
+import * as Binding from "alchemy/Binding";
+export const ReadWebhook = Binding.Service("E2B.ReadWebhook");
+//# sourceMappingURL=ReadWebhook.js.map

package/lib/ReadWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWebhook.js","sources":["../src/ReadWebhook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAuC3C,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAc,iBAAiB,CAAC,CAAC"}

package/lib/ReadWebhookHttp.d.ts

@@ -0,0 +1,20 @@
+import * as Layer from "effect/Layer";
+import { ReadWebhook } from "./ReadWebhook.ts";
+/**
+ * HTTP implementation of {@link ReadWebhook}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const hook = yield* E2B.ReadWebhook(Lifecycle);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadWebhookHttp))
+ * ```
+ *
+ * @layer
+ * @product Webhook
+ * @provides E2B.ReadWebhook
+ */
+export declare const ReadWebhookHttp: Layer.Layer<ReadWebhook, never, never>;
+//# sourceMappingURL=ReadWebhookHttp.d.ts.map

package/lib/ReadWebhookHttp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWebhookHttp.d.ts","sources":["../src/ReadWebhookHttp.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAGnE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,wCAiB3B,CAAC"}

package/lib/ReadWebhookHttp.js

@@ -0,0 +1,31 @@
+import * as webhooks from "@distilled.cloud/e2b/webhooks";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { bindE2B } from "./E2BBindings.js";
+import { ReadWebhook } from "./ReadWebhook.js";
+/**
+ * HTTP implementation of {@link ReadWebhook}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const hook = yield* E2B.ReadWebhook(Lifecycle);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadWebhookHttp))
+ * ```
+ *
+ * @layer
+ * @product Webhook
+ * @provides E2B.ReadWebhook
+ */
+export const ReadWebhookHttp = Layer.succeed(ReadWebhook, Effect.fn("E2B.ReadWebhook")(function* (webhook) {
+    const auth = yield* bindE2B;
+    const webhookId = yield* webhook.webhookId.asEffect();
+    const client = {
+        deliveries: (options) => Effect.flatMap(webhookId, (id) => auth.authorize(webhooks.listWebhookDeliveries({ ...options, webhookID: id }))),
+        stats: (options) => Effect.flatMap(webhookId, (id) => auth.authorize(webhooks.getWebhookStats({ ...options, webhookID: id }))),
+    };
+    return client;
+}));
+//# sourceMappingURL=ReadWebhookHttp.js.map

package/lib/ReadWebhookHttp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWebhookHttp.js","sources":["../src/ReadWebhookHttp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAC;AAE1D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAGnE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAC1C,WAAW,EACX,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAgB;IACtD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC;IAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAE,OAAO,CAAC,SAA0C,CAAC,QAAQ,EAAE,CAAC;IACxF,MAAM,MAAM,GAAkB;QAC5B,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,CACtB,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,CAC/B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,CAC9E;QACH,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CACjB,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,CAC/B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,CACxE;KACJ,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,CACH,CAAC"}

package/lib/ReadWriteVolume.d.ts

@@ -0,0 +1,26 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Volume } from "./Volume.ts";
+import type { ReadWriteVolumeClient } from "./VolumeFiles.ts";
+/**
+ * Read and write a {@link Volume}'s files from outside any sandbox.
+ *
+ * The client talks to E2B's volume content API with the volume's own token,
+ * looked up once through the host's API key.
+ *
+ * ### Using the client
+ * **Example:** In a Worker
+ * ```typescript
+ * const cache = yield* E2B.ReadWriteVolume(Cache);
+ * // in fetch:
+ * yield* cache.write("/notes.md", "hello");
+ * const notes = yield* cache.readText("/notes.md");
+ * ```
+ *
+ * @binding
+ * @product Volume
+ */
+export interface ReadWriteVolume extends Binding.Service<ReadWriteVolume, "E2B.ReadWriteVolume", (volume: Volume) => Effect.Effect<ReadWriteVolumeClient>> {
+}
+export declare const ReadWriteVolume: ReadWriteVolume;
+//# sourceMappingURL=ReadWriteVolume.d.ts.map

package/lib/ReadWriteVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWriteVolume.d.ts","sources":["../src/ReadWriteVolume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAgB,SAAQ,OAAO,CAAC,OAAO,CACtD,eAAe,EACf,qBAAqB,EACrB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,CACzD;CAAG;AAEJ,eAAO,MAAM,eAAe,iBAA0D,CAAC"}

package/lib/ReadWriteVolume.js

@@ -0,0 +1,3 @@
+import * as Binding from "alchemy/Binding";
+export const ReadWriteVolume = Binding.Service("E2B.ReadWriteVolume");
+//# sourceMappingURL=ReadWriteVolume.js.map

package/lib/ReadWriteVolume.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWriteVolume.js","sources":["../src/ReadWriteVolume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AA6B3C,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAkB,qBAAqB,CAAC,CAAC"}

package/lib/ReadWriteVolumeHttp.d.ts

@@ -0,0 +1,20 @@
+import * as Layer from "effect/Layer";
+import { ReadWriteVolume } from "./ReadWriteVolume.ts";
+/**
+ * HTTP implementation of {@link ReadWriteVolume}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const cache = yield* E2B.ReadWriteVolume(Cache);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadWriteVolumeHttp))
+ * ```
+ *
+ * @layer
+ * @product Volume
+ * @provides E2B.ReadWriteVolume
+ */
+export declare const ReadWriteVolumeHttp: Layer.Layer<ReadWriteVolume, never, never>;
+//# sourceMappingURL=ReadWriteVolumeHttp.d.ts.map

package/lib/ReadWriteVolumeHttp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWriteVolumeHttp.d.ts","sources":["../src/ReadWriteVolumeHttp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,4CAO/B,CAAC"}

package/lib/ReadWriteVolumeHttp.js

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { bindE2B } from "./E2BBindings.js";
+import { makeVolumeFiles } from "./internal/VolumeHttp.js";
+import { ReadWriteVolume } from "./ReadWriteVolume.js";
+/**
+ * HTTP implementation of {@link ReadWriteVolume}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const cache = yield* E2B.ReadWriteVolume(Cache);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.ReadWriteVolumeHttp))
+ * ```
+ *
+ * @layer
+ * @product Volume
+ * @provides E2B.ReadWriteVolume
+ */
+export const ReadWriteVolumeHttp = Layer.succeed(ReadWriteVolume, Effect.fn("E2B.ReadWriteVolume")(function* (volume) {
+    const auth = yield* bindE2B;
+    const volumeId = yield* volume.volumeId.asEffect();
+    return makeVolumeFiles(auth, volumeId);
+}));
+//# sourceMappingURL=ReadWriteVolumeHttp.js.map

package/lib/ReadWriteVolumeHttp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWriteVolumeHttp.js","sources":["../src/ReadWriteVolumeHttp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAC,OAAO,CAC9C,eAAe,EACf,MAAM,CAAC,EAAE,CAAC,qBAAqB,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAc;IACxD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC;IAC5B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAE,MAAM,CAAC,QAAyC,CAAC,QAAQ,EAAE,CAAC;IACrF,OAAO,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACzC,CAAC,CAAC,CACH,CAAC"}

package/lib/Sandbox.d.ts

@@ -0,0 +1,295 @@
+import * as sandboxes from "@distilled.cloud/e2b/sandboxes";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type { VolumeMount } from "./MountVolume.ts";
+import type { Providers } from "./Providers.ts";
+/**
+ * A SOCKS5 proxy that carries a sandbox's outbound TCP. E2B applies the
+ * allow and deny rules first, then tunnels what's left through the proxy;
+ * code in the sandbox can't tell, and can't go around it. The proxy must
+ * accept TCP connections, so a Cloudflare Worker can't be one.
+ */
+export interface SandboxEgressProxy {
+    /** The proxy's address, as `host:port`. */
+    address: string;
+    /** SOCKS5 username. */
+    username?: string;
+    /** SOCKS5 password. E2B never returns it. */
+    password?: string | Redacted.Redacted<string>;
+    /**
+     * Connect to the proxy over TLS, so the username and password aren't
+     * sent in the clear.
+     */
+    tls?: {
+        /** Whether to use TLS. */
+        enabled: boolean;
+        /** Name to check the proxy's certificate against. @default the host in `address` */
+        serverName?: string;
+        /** PEM certificates to trust instead of the system's, for a private CA. */
+        caCert?: string;
+    };
+}
+/** Egress rules for a declared sandbox, in E2B's shape. */
+export interface SandboxNetwork {
+    /**
+     * Whether the sandbox's URLs accept requests without its traffic token.
+     * Changing it replaces the sandbox.
+     * @default true
+     */
+    allowPublicTraffic?: boolean;
+    /**
+     * The only destinations the sandbox may reach: CIDR blocks, IPs or
+     * domains (`*.example.com`). Everything else is denied unless `denyOut`
+     * says otherwise.
+     */
+    allowOut?: string[];
+    /** Denied CIDR blocks or IPs. Domains are not supported. */
+    denyOut?: string[];
+    /** DNS servers the sandbox may reach when `allowOut` lists a domain. @default ["8.8.8.8"] */
+    dnsServers?: string[];
+    /**
+     * Header rules for outbound HTTPS requests, by domain. Reference an
+     * `E2B.Secret`'s `ref` here to inject it at egress.
+     */
+    rules?: sandboxes.SandboxNetworkConfigRulesMap;
+    /**
+     * Send the sandbox's outbound TCP through a SOCKS5 proxy you run: a
+     * gateway that adds credentials, a static IP, or an audit log.
+     */
+    egressProxy?: SandboxEgressProxy;
+    /**
+     * The `Host` header requests to the sandbox's URLs arrive with, such as
+     * `localhost:${PORT}`. Changing it replaces the sandbox.
+     */
+    maskRequestHost?: string;
+    /**
+     * Ports where the sandbox serves HTTPS itself. E2B connects to them over
+     * TLS without checking the certificate. Changing them replaces the
+     * sandbox.
+     */
+    httpsPorts?: number[];
+}
+/**
+ * What a sandbox boots from: an `E2B.Template` or an `E2B.Snapshot`, declared
+ * or yielded.
+ */
+export interface SandboxTemplate {
+    templateId: string;
+    /** A template's current build. A new build replaces the sandbox. */
+    buildId?: string;
+    /** A snapshot's setup hash. A new snapshot replaces the sandbox. */
+    setupHash?: string;
+    /** The volumes a template program mounts (`E2B.MountVolume`). */
+    mounts?: VolumeMount[];
+}
+export interface SandboxProps {
+    /**
+     * The `E2B.Template` or `E2B.Snapshot` the sandbox boots from. Changing
+     * it, or rebuilding it, replaces the sandbox so it boots the new build.
+     */
+    template: SandboxTemplate;
+    /**
+     * How long the sandbox runs after it starts or resumes before E2B pauses
+     * it. Changing it applies to the current run (and resumes a paused
+     * sandbox once to apply it).
+     * @default "5 minutes"
+     */
+    timeout?: Duration.Input;
+    /**
+     * Resume the paused sandbox on the next request: to one of its URLs, or
+     * a call into it from `E2B.ConnectSandbox`. Without it, calls into the
+     * paused sandbox fail with `SandboxNotRunning` until `resume()`. Needs
+     * `memory`. Changing it replaces the sandbox.
+     * @default true
+     */
+    autoResume?: boolean;
+    /**
+     * Keep memory as well as the filesystem when the sandbox pauses, so it
+     * resumes where it left off. `false` keeps only the filesystem and the
+     * sandbox reboots on resume. Changing it replaces the sandbox.
+     * @default true
+     */
+    memory?: boolean;
+    /** Environment variables for the sandbox. Changing them replaces the sandbox. */
+    env?: Record<string, string>;
+    /** Your own metadata. Changing it replaces the sandbox. */
+    metadata?: Record<string, string>;
+    /**
+     * Egress rules. `allowOut`, `denyOut`, `dnsServers`, `rules` and
+     * `egressProxy` update in place; `allowPublicTraffic`, `maskRequestHost`
+     * and `httpsPorts` replace the sandbox.
+     */
+    network?: SandboxNetwork;
+    /**
+     * Volumes to mount: `{ volume, path }`, where `volume` is an `E2B.Volume`.
+     * A template program's own mounts are added. E2B attaches volumes only
+     * when a sandbox is created, so changing them replaces the sandbox.
+     */
+    mounts?: VolumeMount[];
+}
+export interface SandboxAttributes {
+    /** E2B's sandbox id. */
+    sandboxId: string;
+    /** The template id the sandbox booted from. */
+    templateId: string;
+    /** The template build (or snapshot) the sandbox booted. */
+    templateBuild: string | undefined;
+    /** The volumes mounted into the sandbox: its own and its template program's. */
+    mounts: VolumeMount[];
+    /**
+     * The domain its ports are served under: port `p` answers at
+     * `https://<p>-<sandboxId>.<domain>`.
+     */
+    domain: string;
+    /**
+     * The token requests to the sandbox's URLs send in the
+     * `e2b-traffic-access-token` header when `allowPublicTraffic` is `false`.
+     */
+    trafficAccessToken: Redacted.Redacted<string> | undefined;
+    /** Your metadata, without Alchemy's ownership stamp. */
+    metadata: Record<string, string>;
+    /** CPU cores. */
+    cpuCount: number;
+    /** Memory in MiB. */
+    memoryMB: number;
+}
+export interface Sandbox extends Resource<"E2B.Sandbox", SandboxProps, SandboxAttributes, never, Providers, {
+    sandboxId: string;
+}> {
+}
+/**
+ * An E2B sandbox the stack owns: one long-lived sandbox that pauses when it
+ * is idle and resumes when it is used, instead of one per request.
+ *
+ * Use it for a workspace that outlives requests (an agent's home, a dev
+ * box) or to serve a template program at a stable URL. The sandbox runs for
+ * `timeout` after it starts or resumes, then E2B pauses it with its memory
+ * and files. A request to one of its URLs resumes it (`autoResume`), and so
+ * does `resume()` on `E2B.ConnectSandbox`.
+ *
+ * Alchemy stamps its stack, stage and logical ID into the sandbox's
+ * metadata to recognise the sandboxes it owns.
+ *
+ * :::caution
+ * Replacing the sandbox (a new or rebuilt `template`, or new `env`,
+ * `metadata`, `mounts`, `memory`, `autoResume`, `allowPublicTraffic`,
+ * `maskRequestHost` or `httpsPorts`) starts a
+ * fresh sandbox and kills the old one with its files. If E2B no longer has
+ * the sandbox, the next deploy that updates it (or `alchemy drift`) creates
+ * a new one.
+ * :::
+ *
+ * ### Creating a Sandbox
+ * **Example:** A dev box from a template
+ * ```typescript
+ * import * as E2B from "@alchemy.run/e2b";
+ * import * as Effect from "effect/Effect";
+ *
+ * export const Node = E2B.Template("Node", { image: "node:22" });
+ *
+ * export const DevBox = E2B.Sandbox("DevBox", {
+ *   template: Node,
+ *   timeout: "10 minutes",
+ * });
+ * ```
+ *
+ * ### Serving a template program
+ * A template program starts when its sandbox boots. Declare one sandbox for
+ * it: each new build of the program replaces the sandbox, so it always runs
+ * the current one.
+ *
+ * **Example:** The program at a stable URL
+ * ```typescript
+ * import * as E2B from "@alchemy.run/e2b";
+ * import * as Output from "alchemy/Output";
+ * import * as Effect from "effect/Effect";
+ * import Api from "./src/api.ts";
+ *
+ * export const ApiSandbox = Effect.gen(function* () {
+ *   const sandbox = yield* E2B.Sandbox("Api", { template: Api });
+ *   return { url: Output.interpolate`https://3000-${sandbox.sandboxId}.${sandbox.domain}` };
+ * });
+ * ```
+ *
+ * ### Private URLs
+ * **Example:** Require the traffic token
+ * ```typescript
+ * const sandbox = yield* E2B.Sandbox("Private", {
+ *   template: Node,
+ *   network: { allowPublicTraffic: false },
+ * });
+ * // send sandbox.trafficAccessToken in the `e2b-traffic-access-token` header
+ * ```
+ *
+ * ### Egress through your own proxy
+ * E2B sends the sandbox's outbound TCP through a SOCKS5 proxy you run,
+ * after its allow and deny rules. Code in the sandbox can't tell, and
+ * can't go around it.
+ *
+ * **Example:** A proxy over TLS, with a password
+ * ```typescript
+ * import * as E2B from "@alchemy.run/e2b";
+ * import * as Config from "effect/Config";
+ * import { Node } from "./Node.ts";
+ *
+ * export const Proxied = E2B.Sandbox("Proxied", {
+ *   template: Node,
+ *   network: {
+ *     egressProxy: {
+ *       address: "proxy.example.com:1080",
+ *       username: "sandbox",
+ *       password: Config.Redacted("PROXY_PASSWORD"),
+ *       tls: { enabled: true },
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * ### Using it at runtime
+ * **Example:** Run a command in it from a Worker
+ * ```typescript
+ * const devBox = yield* E2B.ConnectSandbox(DevBox);
+ * // in fetch:
+ * yield* devBox.resume();
+ * const result = yield* devBox.exec("git pull && npm test", { cwd: "/home/user/repo" });
+ * ```
+ *
+ * ### Mounting volumes
+ * **Example:** A shared cache volume
+ * ```typescript
+ * export const Cache = E2B.Volume("Cache", {});
+ *
+ * export const Builder = E2B.Sandbox("Builder", {
+ *   template: Node,
+ *   mounts: [{ volume: Cache, path: "/cache" }],
+ * });
+ * ```
+ *
+ * ### Referencing a sandbox the stack doesn't manage
+ * **Example:** Look one up by id
+ * ```typescript
+ * const shared = E2B.Sandbox.lookup({ sandboxId: "i1a2b3c4d5e6f7g8h9" });
+ * const box = yield* E2B.ConnectSandbox(shared);
+ * ```
+ *
+ * @resource
+ * @product Sandbox
+ */
+export declare const Sandbox: import("alchemy/Resource").ResourceConstructor<Sandbox, Providers> & Effect.Effect<import("alchemy/Resource").ResourceConstructor<Sandbox, never>, never, never> & {
+    Self: import("alchemy/Self").Self<Sandbox>;
+    Provider: Provider.Provider<Sandbox>;
+    Aliases: readonly string[] | undefined;
+    ref(id: string, options?: {
+        stage?: string;
+        stack?: string;
+    }): Effect.Effect<Sandbox, never, never>;
+} & {
+    lookup(props: {
+        sandboxId: import("alchemy/Input").Input<string>;
+    }): Sandbox;
+} & ((id: string, props: import("./internal/Declared.ts").DeclaredProps<SandboxProps>) => Effect.Effect<Sandbox, never, Providers>);
+export declare const SandboxProvider: () => import("effect/Layer").Layer<Provider.Provider<Sandbox>, never, import("alchemy/Stack").Stack | import("alchemy/Stage").Stage | sandboxes.E2BOpContext>;
+//# sourceMappingURL=Sandbox.d.ts.map

package/lib/Sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.d.ts","sources":["../src/Sandbox.ts"],"names":[],"mappings":"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"}