sbox-sdk 0.0.2

package/dist/modal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/modal/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,OAAO,IAAI,YAAY,EAAE,MAAM,OAAO,CAAC;AAkBlE,OAAO,KAAK,EASV,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BW,CAAC;AAEnC,MAAM,MAAM,SAAS,GAAG,OAAO,UAAU,CAAC;AAiD1C,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;gBA4MjB,CAAC"}

package/dist/modal/index.js

@@ -0,0 +1,223 @@
+/**
+ * `sbox-sdk/modal` — adapter for the Modal JS SDK (`modal`). Modal sandboxes
+ * require an App + Image up front; the adapter creates/looks them up lazily.
+ * exec is fully streaming (ContainerProcess stdout/stderr). Filesystem is done
+ * via exec + base64 (robust across images; needs coreutils `base64`). Modal has
+ * no keep-state stop or pause in JS — `destroy()` maps to terminate. GPU is a
+ * first-class create option. Requires the optional peer dependency `modal`.
+ */
+import { AsyncQueue, base64ToBytes, bytesToBase64, defineProvider, SandboxError, shellQuote as sq, } from "../adapter/index.js";
+export const MODAL_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "unsupported",
+    gpu: "native",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "unsupported",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "unsupported",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "native",
+    volumes: "unsupported",
+};
+const MODAL_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: false,
+    previewModel: "tunnel",
+};
+let cached = null;
+async function loadModal() {
+    if (!cached) {
+        cached = (await import("modal"));
+    }
+    return cached;
+}
+function mapModalError(e) {
+    const name = e instanceof Error ? e.name : "";
+    const msg = e instanceof Error ? e.message : String(e);
+    if (name === "NotFoundError" || /not ?found/i.test(msg)) {
+        return new SandboxError("NotFound", msg, { cause: e, provider: "modal" });
+    }
+    if (/unauthor|forbidden|token/i.test(msg)) {
+        return new SandboxError("Unauthorized", msg, {
+            cause: e,
+            provider: "modal",
+        });
+    }
+    if (name === "SandboxTimeoutError" || /timeout|timed out/i.test(msg)) {
+        return new SandboxError("Timeout", msg, { cause: e, provider: "modal" });
+    }
+    return undefined;
+}
+export const modal = defineProvider((opts) => {
+    let client = null;
+    const getClient = async () => {
+        if (!client) {
+            const mod = await loadModal();
+            client = new mod.ModalClient({
+                tokenId: opts.tokenId,
+                tokenSecret: opts.tokenSecret,
+                environment: opts.environment,
+            });
+        }
+        return client;
+    };
+    const makeHandle = (sb) => {
+        const s = sb;
+        const drainBoth = (proc, queue) => {
+            const out = (async () => {
+                for await (const c of proc.stdout) {
+                    queue.push({ type: "stdout", data: c });
+                }
+            })();
+            const err = (async () => {
+                for await (const c of proc.stderr) {
+                    queue.push({ type: "stderr", data: c });
+                }
+            })();
+            return Promise.all([out, err]).then(() => { });
+        };
+        const runBuffered = async (argv) => {
+            const proc = await s.exec(argv, {
+                stdout: "pipe",
+                stderr: "ignore",
+                mode: "text",
+            });
+            let out = "";
+            for await (const c of proc.stdout) {
+                out += c;
+            }
+            const exitCode = await proc.wait();
+            return { stdout: out, exitCode };
+        };
+        return {
+            id: s.sandboxId,
+            raw: sb,
+            getInfo() {
+                return {
+                    id: s.sandboxId,
+                    state: "running",
+                    provider: "modal",
+                    metadata: {},
+                    raw: sb,
+                };
+            },
+            async destroy() {
+                await s.terminate();
+            },
+            exec(cmd, options) {
+                const queue = new AsyncQueue();
+                void (async () => {
+                    const proc = await s.exec(["sh", "-c", cmd], {
+                        stdout: "pipe",
+                        stderr: "pipe",
+                        mode: "text",
+                        workdir: options.cwd,
+                        env: options.env,
+                        timeoutMs: options.timeoutMs,
+                    });
+                    await drainBoth(proc, queue);
+                    queue.push({ type: "exit", exitCode: await proc.wait() });
+                    queue.close();
+                })().catch((error) => queue.fail(mapModalError(error) ?? SandboxError.wrap(error, "modal")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* no per-process kill; terminate the sandbox to stop everything */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                const r = await runBuffered(["sh", "-c", `base64 ${sq(path)}`]);
+                if (r.exitCode !== 0) {
+                    throw new SandboxError("NotFound", `no such file: '${path}'`, {
+                        provider: "modal",
+                    });
+                }
+                return base64ToBytes(r.stdout);
+            },
+            async writeFile(path, data) {
+                const b64 = bytesToBase64(data);
+                const script = `mkdir -p "$(dirname ${sq(path)})" && printf %s ${sq(b64)} | base64 -d > ${sq(path)}`;
+                const r = await runBuffered(["sh", "-c", script]);
+                if (r.exitCode !== 0) {
+                    throw new SandboxError("Provider", `write failed: '${path}'`, {
+                        provider: "modal",
+                    });
+                }
+            },
+            async exposePort(port) {
+                const tunnels = await s.tunnels();
+                const t = tunnels[port];
+                if (!t) {
+                    throw new SandboxError("Validation", `port ${port} not exposed (declare it in spec.ports at create)`, { provider: "modal" });
+                }
+                return { url: t.url, port };
+            },
+        };
+    };
+    const provider = {
+        name: "modal",
+        capabilities: MODAL_CAPS,
+        flags: MODAL_FLAGS,
+        mapError: mapModalError,
+        async create(spec) {
+            const mod = await loadModal();
+            const c = await getClient();
+            const svc = c;
+            const app = await svc.apps.fromName(opts.appName ?? "sbox-sdk", {
+                createIfMissing: true,
+            });
+            const image = svc.images.fromRegistry(spec.template ?? opts.image ?? "python:3.13");
+            const sb = await svc.sandboxes.create(app, image, {
+                cpu: spec.resources?.vcpus,
+                memoryMiB: spec.resources?.memoryMB,
+                gpu: spec.resources?.gpu,
+                timeoutMs: spec.ttlMs,
+                workdir: undefined,
+                env: spec.env,
+                encryptedPorts: spec.ports,
+            });
+            void mod;
+            return makeHandle(sb);
+        },
+        async connect(id) {
+            const mod = await loadModal();
+            const c = await getClient();
+            const Ctor = mod.Sandbox;
+            return makeHandle(new Ctor(c, id));
+        },
+        async *list() {
+            const c = await getClient();
+            const svc = c;
+            for await (const sb of svc.sandboxes.list()) {
+                const s = sb;
+                yield {
+                    id: s.sandboxId,
+                    state: "running",
+                    provider: "modal",
+                    metadata: {},
+                    raw: sb,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/morph/index.d.ts

@@ -0,0 +1,91 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface MorphOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    /** Default image to snapshot from when `spec.template` is not a snapshot id. */
+    imageId?: string;
+    /** Defaults applied to a lazily-created snapshot. */
+    vcpus?: number;
+    memory?: number;
+    diskSize?: number;
+}
+export declare const MORPH_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type MorphCaps = typeof MORPH_CAPS;
+interface MorphExecResult {
+    exitCode?: number;
+    exit_code?: number;
+    stdout?: string;
+    stderr?: string;
+}
+interface MorphSnapshot {
+    id: string;
+}
+interface MorphHttpService {
+    url: string;
+}
+interface MorphInstance {
+    id: string;
+    status?: string;
+    exec(cmd: string): Promise<MorphExecResult>;
+    stop(): Promise<void>;
+    waitUntilReady(timeout?: number): Promise<void>;
+    snapshot(): Promise<MorphSnapshot>;
+    branch(count?: number): Promise<unknown>;
+    exposeHttpService(name: string, port: number): Promise<MorphHttpService>;
+    hideHttpService(name: string): Promise<void>;
+}
+export declare const morph: (opts: MorphOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, MorphInstance>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/morph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/morph/index.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAQV,eAAe,EAIhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BW,CAAC;AAEnC,MAAM,MAAM,SAAS,GAAG,OAAO,UAAU,CAAC;AAW1C,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AACD,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;CACZ;AACD,UAAU,gBAAgB;IACxB,GAAG,EAAE,MAAM,CAAC;CACb;AACD,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,QAAQ,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IACnC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACzE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAwDD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+JjB,CAAC"}

package/dist/morph/index.js

@@ -0,0 +1,221 @@
+/**
+ * `sbox-sdk/morph` — adapter for MorphCloud (`morphcloud` SDK). A "sandbox" is a
+ * Morph instance booted from a snapshot. Morph's model is snapshot-first: there
+ * is no boot-from-image, so `create()` either starts from a snapshot id
+ * (`spec.template` like `snapshot_…`) or lazily builds a snapshot from an image
+ * (`imageId`) and starts that.
+ *
+ * exec is the buffered `instance.exec(cmd)` (no per-call cwd/env — the core folds
+ * those into a `cd … && KEY=v …` wrapper via `perCommandEnvCwd: false`);
+ * filesystem is done via exec + base64. Morph's marquee features map cleanly:
+ * `snapshots.create()` -> `instance.snapshot()` and `snapshots.fork()` ->
+ * `instance.branch()` (in-place restore is unsupported — branching makes new
+ * instances). Ports are public HTTP services (`exposeHttpService`). `destroy()`
+ * stops the instance. Requires the optional peer dependency `morphcloud`.
+ */
+import { AsyncQueue, base64ToBytes, bytesToBase64, defineProvider, SandboxError, shellQuote as sq, } from "../adapter/index.js";
+export const MORPH_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "native",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "unsupported",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "native",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "emulated",
+    volumes: "unsupported",
+};
+const MORPH_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: false, // instance.exec(cmd) has no cwd/env — core wraps `cd && KEY=v`
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: false,
+    previewModel: "subdomain",
+};
+let cached = null;
+async function loadMorph() {
+    if (!cached) {
+        cached = (await import("morphcloud"));
+    }
+    return cached;
+}
+function mapState(state) {
+    switch ((state ?? "").toLowerCase()) {
+        case "ready":
+        case "running": {
+            return "running";
+        }
+        case "paused":
+        case "saving": {
+            return "paused";
+        }
+        case "pending":
+        case "starting": {
+            return "creating";
+        }
+        case "stopped":
+        case "terminated": {
+            return "destroyed";
+        }
+        default: {
+            return "unknown";
+        }
+    }
+}
+function portServiceName(port) {
+    return `sbox-${port}`;
+}
+export const morph = defineProvider((opts) => {
+    let clientP = null;
+    const getClient = () => {
+        if (!clientP) {
+            clientP = loadMorph().then((mod) => new mod.MorphCloudClient({ ...opts }));
+        }
+        return clientP;
+    };
+    const makeHandle = (inst) => {
+        const exec1 = (cmd) => inst.exec(cmd);
+        return {
+            id: inst.id,
+            raw: inst,
+            getInfo() {
+                return {
+                    id: inst.id,
+                    state: mapState(inst.status),
+                    provider: "morph",
+                    metadata: {},
+                    raw: inst,
+                };
+            },
+            async destroy() {
+                await inst.stop();
+            },
+            exec(cmd) {
+                const queue = new AsyncQueue();
+                void exec1(cmd)
+                    .then((r) => {
+                    if (r.stdout) {
+                        queue.push({ type: "stdout", data: r.stdout });
+                    }
+                    if (r.stderr) {
+                        queue.push({ type: "stderr", data: r.stderr });
+                    }
+                    queue.push({
+                        type: "exit",
+                        exitCode: r.exitCode ?? r.exit_code ?? 0,
+                    });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(error instanceof SandboxError
+                    ? error
+                    : SandboxError.wrap(error, "morph")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* instance.exec is buffered; no kill handle */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                const r = await exec1(`base64 ${sq(path)}`);
+                if ((r.exitCode ?? r.exit_code ?? 1) !== 0) {
+                    throw new SandboxError("NotFound", `no such file: '${path}'`, {
+                        provider: "morph",
+                    });
+                }
+                return base64ToBytes(r.stdout ?? "");
+            },
+            async writeFile(path, data) {
+                const b64 = bytesToBase64(data);
+                const r = await exec1(`mkdir -p "$(dirname ${sq(path)})" && printf %s ${sq(b64)} | base64 -d > ${sq(path)}`);
+                if ((r.exitCode ?? r.exit_code ?? 1) !== 0) {
+                    throw new SandboxError("Provider", `write failed: '${path}'`, {
+                        provider: "morph",
+                    });
+                }
+            },
+            async exposePort(port) {
+                const svc = await inst.exposeHttpService(portServiceName(port), port);
+                return { url: svc.url, port };
+            },
+            async unexposePort(port) {
+                await inst.hideHttpService(portServiceName(port));
+            },
+            async snapshot(snapOpts) {
+                const snap = await inst.snapshot();
+                return {
+                    id: snap.id,
+                    name: snapOpts.name,
+                    provider: "morph",
+                    raw: snap,
+                };
+            },
+            async fork(count) {
+                const res = (await inst.branch(count));
+                const instances = Array.isArray(res) ? res : (res.instances ?? []);
+                return instances.map((i) => makeHandle(i));
+            },
+        };
+    };
+    const provider = {
+        name: "morph",
+        capabilities: MORPH_CAPS,
+        flags: MORPH_FLAGS,
+        async create(spec) {
+            const client = await getClient();
+            const tpl = spec.template;
+            // A snapshot id boots directly; anything else is treated as an image to
+            // snapshot first (Morph has no boot-from-image path).
+            let snapshotId;
+            if (tpl && /^snapshot[_-]/i.test(tpl)) {
+                snapshotId = tpl;
+            }
+            else {
+                const snap = await client.snapshots.create({
+                    imageId: tpl ?? opts.imageId ?? "morphvm-minimal",
+                    vcpus: spec.resources?.vcpus ?? opts.vcpus,
+                    memory: spec.resources?.memoryMB ?? opts.memory,
+                    diskSize: spec.resources?.diskMB ?? opts.diskSize,
+                });
+                snapshotId = snap.id;
+            }
+            const inst = await client.instances.start({ snapshotId });
+            await inst.waitUntilReady().catch(() => { });
+            return makeHandle(inst);
+        },
+        async connect(id) {
+            const client = await getClient();
+            return makeHandle(await client.instances.get({ instanceId: id }));
+        },
+        async *list() {
+            const client = await getClient();
+            for (const inst of await client.instances.list()) {
+                yield {
+                    id: inst.id,
+                    state: mapState(inst.status),
+                    provider: "morph",
+                    metadata: {},
+                    raw: inst,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/northflank/index.d.ts

@@ -0,0 +1,74 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface NorthflankOptions {
+    /** Northflank API token. */
+    token: string;
+    /** Project the sandbox services live in (required). */
+    projectId: string;
+    /** Billing/compute plan for new sandboxes (default "nf-compute-200"). */
+    deploymentPlan?: string;
+    /** Default base image (default "ubuntu:22.04"). */
+    image?: string;
+    /** Ephemeral storage in MB for new sandboxes (default 2048). */
+    ephemeralStorageMB?: number;
+}
+interface NfRef {
+    projectId: string;
+    serviceId: string;
+}
+export declare const NORTHFLANK_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type NorthflankCaps = typeof NORTHFLANK_CAPS;
+export declare const northflank: (opts: NorthflankOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, NfRef>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/northflank/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/northflank/index.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAQV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,UAAU,KAAK;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEnC,MAAM,MAAM,cAAc,GAAG,OAAO,eAAe,CAAC;AA2FpD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;SAuNrB,CAAC"}