zeitlich 0.2.49 → 0.2.51

package/src/{adapters/sandbox/inmemory/proxy.ts → test-utils/in-memory-sandbox-proxy.ts}

@@ -1,26 +1,15 @@
 /**
- * Workflow-safe proxy for in-memory sandbox operations.
+ * Test-only workflow-safe proxy for the in-memory sandbox fixture.
  *
- * Import this from `zeitlich/adapters/sandbox/inmemory/workflow`
- * in your Temporal workflow files.
- *
- * By default the scope is derived from `workflowInfo().workflowType`,
- * so activities are automatically namespaced per workflow.
- *
- * @example
- * ```typescript
- * import { proxyInMemorySandboxOps } from 'zeitlich/adapters/sandbox/inmemory/workflow';
- *
- * // Auto-scoped to the current workflow name
- * const sandbox = proxyInMemorySandboxOps();
- * ```
+ * Not part of the shipped public surface — used by the capability-type
+ * fixtures to exercise the full-capability proxy shape.
  */
 import { proxyActivities, workflowInfo } from "@temporalio/workflow";
 import type {
   SandboxCreateOptions,
   SandboxOps,
-} from "../../../lib/sandbox/types";
-import type { InMemoryCaps } from "./index";
+} from "../lib/sandbox/types";
+import type { InMemoryCaps } from "./in-memory-sandbox";
 
 const ADAPTER_PREFIX = "inMemory";
 

package/src/{adapters/sandbox/inmemory/index.ts → test-utils/in-memory-sandbox.ts}

@@ -1,3 +1,11 @@
+/**
+ * Test-only in-memory {@link Sandbox} provider backed by `just-bash`.
+ *
+ * This is **not** part of the shipped public surface — it lives under
+ * `src/test-utils` purely so the sandbox manager, tool handlers, and
+ * capability-type fixtures have a lightweight, fully-featured backend to
+ * exercise against. `just-bash` is a dev dependency for the same reason.
+ */
 import {
   Bash,
   InMemoryFs,
@@ -18,9 +26,9 @@ import type {
   ExecResult,
   DirentEntry,
   FileStat,
-} from "../../../lib/sandbox/types";
-import { SandboxNotFoundError } from "../../../lib/sandbox/types";
-import { getShortId } from "../../../lib/thread/id";
+} from "../lib/sandbox/types";
+import { SandboxNotFoundError } from "../lib/sandbox/types";
+import { getShortId } from "../lib/thread/id";
 
 // ============================================================================
 // Adapter: IFileSystem → SandboxFileSystem

package/src/tools/bash/bash.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it, beforeEach } from "vitest";
 import { bashHandler } from "./handler";
 import { withSandbox } from "../../lib/tool-router/with-sandbox";
 import { SandboxManager } from "../../lib/sandbox/manager";
-import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
+import { InMemorySandboxProvider } from "../../test-utils/in-memory-sandbox";
 import type { RouterContext } from "../../lib/tool-router/types";
 import type { Sandbox, SandboxCreateOptions } from "../../lib/sandbox";
 

package/src/tools/edit/handler.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
+import { InMemorySandboxProvider } from "../../test-utils/in-memory-sandbox";
 import type { Sandbox, SandboxCreateOptions } from "../../lib/sandbox";
 import { SandboxManager } from "../../lib/sandbox/manager";
 import type { RouterContext } from "../../lib/tool-router/types";

package/tsup.config.ts

@@ -15,9 +15,6 @@ export default defineConfig({
     "adapters/thread/anthropic/index": "src/adapters/thread/anthropic/index.ts",
     "adapters/thread/anthropic/workflow":
       "src/adapters/thread/anthropic/proxy.ts",
-    "adapters/sandbox/inmemory/index": "src/adapters/sandbox/inmemory/index.ts",
-    "adapters/sandbox/inmemory/workflow":
-      "src/adapters/sandbox/inmemory/proxy.ts",
     "adapters/sandbox/daytona/index": "src/adapters/sandbox/daytona/index.ts",
     "adapters/sandbox/daytona/workflow":
       "src/adapters/sandbox/daytona/proxy.ts",
@@ -38,7 +35,8 @@ export default defineConfig({
     /^@anthropic-ai\//,
     /^@daytonaio\//,
     /^@e2b\//,
-    "ioredis",
+    "redis",
+    /^@redis\//,
     "@mongodb-js/zstd",
     "node-liblzma",
   ],

package/dist/activities-7OcT_vdR.d.cts

@@ -1,162 +0,0 @@
-import Redis from 'ioredis';
-import { Part, Content, GoogleGenAI } from '@google/genai';
-import { a as ModelInvoker, b as PrefixedThreadOps, S as ScopedPrefix, R as RouterContext, c as ToolHandlerResponse, d as ActivityToolHandler } from './types-XUUFvrJ9.cjs';
-import { C as ColdThreadStore } from './cold-store-CkWoNtMh.cjs';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-BR-k7h0e.cjs';
-import { A as ADAPTER_ID } from './adapter-id-BB-mmrts.cjs';
-
-/** SDK-native content type for Google GenAI human messages */
-type GoogleGenAIContent = string | Part[];
-/** SDK-native content type for Google GenAI system instructions */
-type GoogleGenAISystemContent = string | Part[];
-/** A Content with a unique ID for idempotent Redis storage */
-interface StoredContent {
-    id: string;
-    content: Content;
-}
-type GoogleGenAIThreadManagerHooks = ThreadManagerHooks<StoredContent, Content>;
-interface GoogleGenAIThreadManagerConfig {
-    redis: Redis;
-    threadId: string;
-    /** Thread key, defaults to 'messages' */
-    key?: string;
-    hooks?: GoogleGenAIThreadManagerHooks;
-    /**
-     * Override the default thread TTL (90 days). When pairing the
-     * adapter with a durable cold tier, a shorter TTL (hours) is
-     * typically more appropriate.
-     */
-    ttlSeconds?: number;
-}
-/** Prepared payload ready to send to the Google GenAI API */
-interface GoogleGenAIInvocationPayload {
-    contents: Content[];
-    systemInstruction?: Part[];
-}
-/** Thread manager with Google GenAI Content convenience helpers */
-interface GoogleGenAIThreadManager extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
-    appendModelContent(id: string, parts: Part[]): Promise<void>;
-    prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
-}
-/**
- * Creates a Google GenAI-specific thread manager that stores StoredContent
- * instances in Redis and provides convenience helpers for creating and
- * appending typed Content messages.
- */
-declare function createGoogleGenAIThreadManager(config: GoogleGenAIThreadManagerConfig): GoogleGenAIThreadManager;
-
-type GoogleGenAIThreadOps<TScope extends string = ""> = PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_ID>, GoogleGenAIContent>;
-interface GoogleGenAIAdapterConfig {
-    redis: Redis;
-    client?: GoogleGenAI;
-    /** Default model name (e.g. 'gemini-2.5-flash'). If omitted, use `createModelInvoker()` */
-    model?: string;
-    hooks?: GoogleGenAIThreadManagerHooks;
-    /**
-     * Optional durable cold tier (e.g. S3, R2, GCS). When provided,
-     * the session hydrates the thread on entry (`continue`/`fork`) and
-     * flushes it on every exit path. When omitted, the adapter is
-     * Redis-only and `hydrateThread`/`flushThread` activities are no-ops.
-     */
-    coldStore?: ColdThreadStore;
-    /**
-     * Override the default Redis TTL (90 days). When pairing the
-     * adapter with a `coldStore`, a shorter TTL (hours) is typically
-     * more appropriate.
-     */
-    ttlSeconds?: number;
-}
-/**
- * Tool response type accepted by the Google GenAI adapter.
- *
- * Handlers can return:
- * - **`string`** — plain text, wrapped in a `functionResponse` part.
- * - **`Record<string, unknown>`** — structured object used as `functionResponse.response`.
- * - **`Part[]`** — pre-built parts used directly as `Content.parts`.
- *   The handler is responsible for building correct Part objects (e.g. `functionResponse`,
- *   `inlineData`, `text`). Use `context.toolCallId` and `context.toolName` to construct
- *   `functionResponse` parts.
- *
- * @example
- * ```typescript
- * adapter.wrapHandler(async (args, ctx) => ({
- *   toolResponse: [
- *     { functionResponse: { id: ctx.toolCallId, name: ctx.toolName, response: { result: "done" } } },
- *     { inlineData: { data: base64, mimeType: "image/png" } },
- *   ],
- *   data: null,
- * }));
- * ```
- */
-type GoogleGenAIToolResponse = string | Record<string, unknown> | Part[];
-interface GoogleGenAIAdapter {
-    /** Model invoker using the default model (only available when `model` was provided) */
-    invoker: ModelInvoker<Content>;
-    /** Create an invoker for a specific model name (for multi-model setups) */
-    createModelInvoker(model: string, client: GoogleGenAI): ModelInvoker<Content>;
-    /**
-     * Create prefixed thread activities for registration on the worker.
-     *
-     * @param scope - Workflow name appended to the adapter prefix.
-     *   Use different scopes for the main agent vs subagents to avoid collisions.
-     *
-     * @example
-     * ```typescript
-     * adapter.createActivities("codingAgent")
-     * // → { googleGenAICodingAgentInitializeThread, googleGenAICodingAgentAppendHumanMessage, … }
-     *
-     * adapter.createActivities("researchAgent")
-     * // → { googleGenAIResearchAgentInitializeThread, … }
-     * ```
-     */
-    createActivities<S extends string = "">(scope?: S): GoogleGenAIThreadOps<S>;
-    /**
-     * Identity wrapper that types a tool handler for this adapter.
-     * Constrains `toolResponse` to {@link GoogleGenAIToolResponse}.
-     */
-    wrapHandler<TArgs, TResult, TContext extends RouterContext = RouterContext>(handler: (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult, GoogleGenAIToolResponse>>): ActivityToolHandler<TArgs, TResult, TContext, GoogleGenAIToolResponse>;
-}
-/**
- * Creates a Google GenAI adapter that bundles thread operations and model
- * invocation using the `@google/genai` SDK.
- *
- * Use `createActivities(scope)` to register scoped thread operations as
- * Temporal activities on the worker. The `invoker` (or invokers created via
- * `createModelInvoker`) should be wrapped with `createRunAgentActivity`.
- *
- * @example
- * ```typescript
- * import { createGoogleGenAIAdapter } from 'zeitlich/adapters/thread/google-genai';
- * import { createRunAgentActivity } from 'zeitlich';
- * import { GoogleGenAI } from '@google/genai';
- *
- * const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
- * const adapter = createGoogleGenAIAdapter({ redis, client, model: 'gemini-2.5-flash' });
- *
- * export function createActivities(temporalClient: WorkflowClient) {
- *   return {
- *     ...adapter.createActivities("codingAgent"),
- *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
- *   };
- * }
- * ```
- *
- * @example Multi-agent worker (main + subagent share the adapter)
- * ```typescript
- * export function createActivities(temporalClient: WorkflowClient) {
- *   return {
- *     ...adapter.createActivities("codingAgent"),
- *     ...adapter.createActivities("researchAgent"),
- *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
- *     ...createRunAgentActivity(
- *       temporalClient,
- *       adapter.createModelInvoker('gemini-2.5-pro'),
- *       "researchAgent",
- *     ),
- *   };
- * }
- * ```
- */
-declare function createGoogleGenAIAdapter(config: GoogleGenAIAdapterConfig): GoogleGenAIAdapter;
-
-export { type GoogleGenAIThreadManagerHooks as G, type StoredContent as S, type GoogleGenAIAdapter as a, type GoogleGenAIAdapterConfig as b, type GoogleGenAIContent as c, type GoogleGenAIInvocationPayload as d, type GoogleGenAIThreadManager as e, type GoogleGenAIThreadManagerConfig as f, type GoogleGenAIThreadOps as g, type GoogleGenAIToolResponse as h, createGoogleGenAIAdapter as i, createGoogleGenAIThreadManager as j };

package/dist/activities-zG_FBoY2.d.ts

@@ -1,162 +0,0 @@
-import Redis from 'ioredis';
-import { Part, Content, GoogleGenAI } from '@google/genai';
-import { a as ModelInvoker, b as PrefixedThreadOps, S as ScopedPrefix, R as RouterContext, c as ToolHandlerResponse, d as ActivityToolHandler } from './types-DeVNWqlb.js';
-import { C as ColdThreadStore } from './cold-store-DKMAO1Dd.js';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DO4Tkwxo.js';
-import { A as ADAPTER_ID } from './adapter-id-BB-mmrts.js';
-
-/** SDK-native content type for Google GenAI human messages */
-type GoogleGenAIContent = string | Part[];
-/** SDK-native content type for Google GenAI system instructions */
-type GoogleGenAISystemContent = string | Part[];
-/** A Content with a unique ID for idempotent Redis storage */
-interface StoredContent {
-    id: string;
-    content: Content;
-}
-type GoogleGenAIThreadManagerHooks = ThreadManagerHooks<StoredContent, Content>;
-interface GoogleGenAIThreadManagerConfig {
-    redis: Redis;
-    threadId: string;
-    /** Thread key, defaults to 'messages' */
-    key?: string;
-    hooks?: GoogleGenAIThreadManagerHooks;
-    /**
-     * Override the default thread TTL (90 days). When pairing the
-     * adapter with a durable cold tier, a shorter TTL (hours) is
-     * typically more appropriate.
-     */
-    ttlSeconds?: number;
-}
-/** Prepared payload ready to send to the Google GenAI API */
-interface GoogleGenAIInvocationPayload {
-    contents: Content[];
-    systemInstruction?: Part[];
-}
-/** Thread manager with Google GenAI Content convenience helpers */
-interface GoogleGenAIThreadManager extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
-    appendModelContent(id: string, parts: Part[]): Promise<void>;
-    prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
-}
-/**
- * Creates a Google GenAI-specific thread manager that stores StoredContent
- * instances in Redis and provides convenience helpers for creating and
- * appending typed Content messages.
- */
-declare function createGoogleGenAIThreadManager(config: GoogleGenAIThreadManagerConfig): GoogleGenAIThreadManager;
-
-type GoogleGenAIThreadOps<TScope extends string = ""> = PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_ID>, GoogleGenAIContent>;
-interface GoogleGenAIAdapterConfig {
-    redis: Redis;
-    client?: GoogleGenAI;
-    /** Default model name (e.g. 'gemini-2.5-flash'). If omitted, use `createModelInvoker()` */
-    model?: string;
-    hooks?: GoogleGenAIThreadManagerHooks;
-    /**
-     * Optional durable cold tier (e.g. S3, R2, GCS). When provided,
-     * the session hydrates the thread on entry (`continue`/`fork`) and
-     * flushes it on every exit path. When omitted, the adapter is
-     * Redis-only and `hydrateThread`/`flushThread` activities are no-ops.
-     */
-    coldStore?: ColdThreadStore;
-    /**
-     * Override the default Redis TTL (90 days). When pairing the
-     * adapter with a `coldStore`, a shorter TTL (hours) is typically
-     * more appropriate.
-     */
-    ttlSeconds?: number;
-}
-/**
- * Tool response type accepted by the Google GenAI adapter.
- *
- * Handlers can return:
- * - **`string`** — plain text, wrapped in a `functionResponse` part.
- * - **`Record<string, unknown>`** — structured object used as `functionResponse.response`.
- * - **`Part[]`** — pre-built parts used directly as `Content.parts`.
- *   The handler is responsible for building correct Part objects (e.g. `functionResponse`,
- *   `inlineData`, `text`). Use `context.toolCallId` and `context.toolName` to construct
- *   `functionResponse` parts.
- *
- * @example
- * ```typescript
- * adapter.wrapHandler(async (args, ctx) => ({
- *   toolResponse: [
- *     { functionResponse: { id: ctx.toolCallId, name: ctx.toolName, response: { result: "done" } } },
- *     { inlineData: { data: base64, mimeType: "image/png" } },
- *   ],
- *   data: null,
- * }));
- * ```
- */
-type GoogleGenAIToolResponse = string | Record<string, unknown> | Part[];
-interface GoogleGenAIAdapter {
-    /** Model invoker using the default model (only available when `model` was provided) */
-    invoker: ModelInvoker<Content>;
-    /** Create an invoker for a specific model name (for multi-model setups) */
-    createModelInvoker(model: string, client: GoogleGenAI): ModelInvoker<Content>;
-    /**
-     * Create prefixed thread activities for registration on the worker.
-     *
-     * @param scope - Workflow name appended to the adapter prefix.
-     *   Use different scopes for the main agent vs subagents to avoid collisions.
-     *
-     * @example
-     * ```typescript
-     * adapter.createActivities("codingAgent")
-     * // → { googleGenAICodingAgentInitializeThread, googleGenAICodingAgentAppendHumanMessage, … }
-     *
-     * adapter.createActivities("researchAgent")
-     * // → { googleGenAIResearchAgentInitializeThread, … }
-     * ```
-     */
-    createActivities<S extends string = "">(scope?: S): GoogleGenAIThreadOps<S>;
-    /**
-     * Identity wrapper that types a tool handler for this adapter.
-     * Constrains `toolResponse` to {@link GoogleGenAIToolResponse}.
-     */
-    wrapHandler<TArgs, TResult, TContext extends RouterContext = RouterContext>(handler: (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult, GoogleGenAIToolResponse>>): ActivityToolHandler<TArgs, TResult, TContext, GoogleGenAIToolResponse>;
-}
-/**
- * Creates a Google GenAI adapter that bundles thread operations and model
- * invocation using the `@google/genai` SDK.
- *
- * Use `createActivities(scope)` to register scoped thread operations as
- * Temporal activities on the worker. The `invoker` (or invokers created via
- * `createModelInvoker`) should be wrapped with `createRunAgentActivity`.
- *
- * @example
- * ```typescript
- * import { createGoogleGenAIAdapter } from 'zeitlich/adapters/thread/google-genai';
- * import { createRunAgentActivity } from 'zeitlich';
- * import { GoogleGenAI } from '@google/genai';
- *
- * const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
- * const adapter = createGoogleGenAIAdapter({ redis, client, model: 'gemini-2.5-flash' });
- *
- * export function createActivities(temporalClient: WorkflowClient) {
- *   return {
- *     ...adapter.createActivities("codingAgent"),
- *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
- *   };
- * }
- * ```
- *
- * @example Multi-agent worker (main + subagent share the adapter)
- * ```typescript
- * export function createActivities(temporalClient: WorkflowClient) {
- *   return {
- *     ...adapter.createActivities("codingAgent"),
- *     ...adapter.createActivities("researchAgent"),
- *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
- *     ...createRunAgentActivity(
- *       temporalClient,
- *       adapter.createModelInvoker('gemini-2.5-pro'),
- *       "researchAgent",
- *     ),
- *   };
- * }
- * ```
- */
-declare function createGoogleGenAIAdapter(config: GoogleGenAIAdapterConfig): GoogleGenAIAdapter;
-
-export { type GoogleGenAIThreadManagerHooks as G, type StoredContent as S, type GoogleGenAIAdapter as a, type GoogleGenAIAdapterConfig as b, type GoogleGenAIContent as c, type GoogleGenAIInvocationPayload as d, type GoogleGenAIThreadManager as e, type GoogleGenAIThreadManagerConfig as f, type GoogleGenAIThreadOps as g, type GoogleGenAIToolResponse as h, createGoogleGenAIAdapter as i, createGoogleGenAIThreadManager as j };

package/dist/adapters/sandbox/inmemory/index.cjs

@@ -1,214 +0,0 @@
-'use strict';
-
-var justBash = require('just-bash');
-var common = require('@temporalio/common');
-var workflow = require('@temporalio/workflow');
-
-// src/adapters/sandbox/inmemory/index.ts
-var SandboxNotFoundError = class extends common.ApplicationFailure {
-  constructor(sandboxId) {
-    super(`Sandbox not found: ${sandboxId}`, "SandboxNotFoundError", true);
-  }
-};
-var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function getShortId(length = 12) {
-  const hex = workflow.uuid4().replace(/-/g, "");
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    result += BASE62[byte % BASE62.length];
-  }
-  return result;
-}
-
-// src/adapters/sandbox/inmemory/index.ts
-function toSandboxFs(fs) {
-  const workspaceBase = "/";
-  const normalisePath = (path) => fs.resolvePath(workspaceBase, path);
-  return {
-    workspaceBase,
-    readFile: (path) => fs.readFile(normalisePath(path)),
-    readFileBuffer: (path) => fs.readFileBuffer(normalisePath(path)),
-    writeFile: (path, content) => fs.writeFile(normalisePath(path), content),
-    appendFile: (path, content) => fs.appendFile(normalisePath(path), content),
-    exists: (path) => fs.exists(normalisePath(path)),
-    stat: async (path) => {
-      const s = await fs.stat(normalisePath(path));
-      return {
-        isFile: s.isFile,
-        isDirectory: s.isDirectory,
-        isSymbolicLink: s.isSymbolicLink,
-        size: s.size,
-        mtime: s.mtime
-      };
-    },
-    mkdir: (path, opts) => fs.mkdir(normalisePath(path), opts),
-    readdir: (path) => fs.readdir(normalisePath(path)),
-    readdirWithFileTypes: async (path) => {
-      const dirPath = normalisePath(path);
-      if (!fs.readdirWithFileTypes) {
-        const names = await fs.readdir(dirPath);
-        return Promise.all(
-          names.map(async (name) => {
-            const childPath = fs.resolvePath(dirPath, name);
-            const s = await fs.stat(childPath);
-            return {
-              name,
-              isFile: s.isFile,
-              isDirectory: s.isDirectory,
-              isSymbolicLink: s.isSymbolicLink
-            };
-          })
-        );
-      }
-      return fs.readdirWithFileTypes(dirPath);
-    },
-    rm: (path, opts) => fs.rm(normalisePath(path), opts),
-    cp: (src, dest, opts) => fs.cp(normalisePath(src), normalisePath(dest), opts),
-    mv: (src, dest) => fs.mv(normalisePath(src), normalisePath(dest)),
-    readlink: (path) => fs.readlink(normalisePath(path)),
-    resolvePath: (base, p) => fs.resolvePath(normalisePath(base), p)
-  };
-}
-var InMemorySandboxImpl = class {
-  constructor(id, justBashFs, options) {
-    this.id = id;
-    this.justBashFs = justBashFs;
-    this.fs = toSandboxFs(justBashFs);
-    this.bashOptions = {
-      executionLimits: { maxStringLength: 52428800 },
-      ...options?.bashOptions
-    };
-  }
-  id;
-  justBashFs;
-  capabilities = {
-    filesystem: true,
-    execution: true,
-    persistence: true
-  };
-  fs;
-  bashOptions;
-  async exec(command, _options) {
-    const bash = new justBash.Bash({ ...this.bashOptions, fs: this.justBashFs });
-    const { exitCode, stderr, stdout } = await bash.exec(command);
-    return { exitCode, stdout, stderr };
-  }
-  async destroy() {
-  }
-  /** Expose the underlying IFileSystem for snapshot serialisation */
-  _getJustBashFs() {
-    return this.justBashFs;
-  }
-};
-var IN_MEMORY_CAPS = [
-  "pause",
-  "resume",
-  "snapshot",
-  "restore",
-  "fork"
-];
-var InMemorySandboxProvider = class {
-  constructor(defaultOptions) {
-    this.defaultOptions = defaultOptions;
-  }
-  defaultOptions;
-  id = "inMemory";
-  capabilities = {
-    filesystem: true,
-    execution: true,
-    persistence: true
-  };
-  supportedCapabilities = new Set(
-    IN_MEMORY_CAPS
-  );
-  sandboxes = /* @__PURE__ */ new Map();
-  async get(id) {
-    const sandbox = this.sandboxes.get(id);
-    if (!sandbox) throw new SandboxNotFoundError(id);
-    return sandbox;
-  }
-  async destroy(id) {
-    const sandbox = this.sandboxes.get(id);
-    if (sandbox) {
-      await sandbox.destroy();
-      this.sandboxes.delete(id);
-    }
-  }
-  async pause(_sandboxId, _ttlSeconds) {
-  }
-  async resume(_sandboxId) {
-  }
-  async create(options) {
-    const id = options?.id ?? getShortId();
-    const initialFiles = {};
-    if (options?.initialFiles) {
-      for (const [path, content] of Object.entries(options.initialFiles)) {
-        initialFiles[path] = content;
-      }
-    }
-    const fs = new justBash.InMemoryFs(initialFiles);
-    const sandbox = new InMemorySandboxImpl(id, fs, this.defaultOptions);
-    this.sandboxes.set(id, sandbox);
-    return { sandbox };
-  }
-  async snapshot(sandboxId, _options) {
-    const sandbox = this.sandboxes.get(sandboxId);
-    if (!sandbox) throw new SandboxNotFoundError(sandboxId);
-    const fs = sandbox._getJustBashFs();
-    const paths = fs.getAllPaths();
-    const files = {};
-    for (const p of paths) {
-      try {
-        const stat = await fs.stat(p);
-        if (stat.isFile) {
-          files[p] = await fs.readFile(p);
-        }
-      } catch {
-      }
-    }
-    return {
-      sandboxId,
-      providerId: this.id,
-      data: { files },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async fork(sandboxId, _options) {
-    const sandbox = await this.get(sandboxId);
-    const entries = await sandbox.fs.readdirWithFileTypes("/");
-    const initialFiles = {};
-    for (const entry of entries) {
-      if (entry.isFile) {
-        initialFiles[entry.name] = await sandbox.fs.readFileBuffer(entry.name);
-      }
-    }
-    const newSandbox = await this.create({
-      id: getShortId(),
-      initialFiles
-    });
-    return newSandbox.sandbox;
-  }
-  async restore(snapshot, _options) {
-    const { files } = snapshot.data;
-    const initialFiles = {};
-    for (const [path, content] of Object.entries(files)) {
-      initialFiles[path] = content;
-    }
-    const fs = new justBash.InMemoryFs(initialFiles);
-    const sandbox = new InMemorySandboxImpl(
-      snapshot.sandboxId,
-      fs,
-      this.defaultOptions
-    );
-    this.sandboxes.set(sandbox.id, sandbox);
-    return sandbox;
-  }
-  async deleteSnapshot(_snapshot) {
-  }
-};
-
-exports.IN_MEMORY_CAPS = IN_MEMORY_CAPS;
-exports.InMemorySandboxProvider = InMemorySandboxProvider;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map