zeitlich 0.2.28 → 0.2.30

package/dist/adapters/sandbox/virtual/index.d.cts

@@ -1,90 +0,0 @@
-import { a as FileEntryMetadata, V as VirtualSandboxCreateOptions, b as FileResolver, c as VirtualSandboxContext, T as TreeMutation, F as FileEntry, d as VirtualSandbox } from '../../../types-BgsAwN3L.cjs';
-export { e as VirtualFileTree, f as VirtualSandboxFileSystem, g as VirtualSandboxState } from '../../../types-BgsAwN3L.cjs';
-import { b as SandboxProvider, c as SandboxCapabilities, e as SandboxCreateResult } from '../../../types-ChAMwU3q.cjs';
-import { WorkflowClient } from '@temporalio/client';
-import { J as JsonValue, A as ActivityToolHandler, R as RouterContext } from '../../../types-BclYm5Ic.cjs';
-export { F as FileTreeAccessor, f as filesWithMimeType, h as hasDirectory, a as hasFileWithMimeType } from '../../../queries-DVnukByF.cjs';
-import '@temporalio/common';
-import '@temporalio/workflow';
-import '@temporalio/common/lib/interfaces';
-import 'zod';
-
-/**
- * Stateless {@link SandboxProvider} backed by a {@link FileResolver}.
- *
- * The provider holds **no internal state**. All sandbox state (sandboxId,
- * fileTree, resolverContext, workspaceBase) is returned as a `stateUpdate` from
- * {@link create} and merged into the workflow's `AgentState` by the session.
- * {@link withVirtualSandbox} reads this state back on every tool invocation.
- *
- * @example
- * ```typescript
- * const provider = new VirtualSandboxProvider(resolver);
- * const manager = new SandboxManager(provider);
- *
- * export const activities = {
- *   ...manager.createActivities("CodingAgent"),
- *   readFile: withVirtualSandbox(client, provider, readHandler),
- * };
- * ```
- */
-declare class VirtualSandboxProvider<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxProvider<VirtualSandboxCreateOptions<TCtx>> {
-    readonly id = "virtual";
-    readonly capabilities: SandboxCapabilities;
-    readonly resolver: FileResolver<TCtx, TMeta>;
-    constructor(resolver: FileResolver<TCtx, TMeta>);
-    create(options?: VirtualSandboxCreateOptions<TCtx>): Promise<SandboxCreateResult>;
-    get(): Promise<never>;
-    destroy(): Promise<void>;
-    pause(): Promise<void>;
-    fork(_sandboxId: string): Promise<never>;
-    snapshot(): Promise<never>;
-    restore(): Promise<never>;
-}
-
-/**
- * Wraps a tool handler that needs a virtual sandbox, automatically querying
- * the parent workflow for the current file tree and resolver context.
- *
- * On each invocation the wrapper:
- * 1. Queries the workflow's `AgentState` for `fileTree`, `resolverContext`, and `workspaceBase`
- * 2. Creates an ephemeral {@link VirtualSandbox} from tree + provider's resolver
- * 3. Runs the inner handler
- * 4. Returns the handler's result together with any {@link TreeMutation}s
- *
- * The consumer applies mutations back to workflow state via a post-tool hook.
- *
- * @param client    - Temporal `WorkflowClient` for querying the parent workflow
- * @param agentName - Agent name (used to derive the state query name)
- * @param provider  - {@link VirtualSandboxProvider} (wraps the resolver)
- * @param handler   - Inner handler expecting a {@link VirtualSandboxContext}
- *
- * @example
- * ```typescript
- * import { withVirtualSandbox, type VirtualSandboxContext } from 'zeitlich';
- *
- * const readHandler: ActivityToolHandler<FileReadArgs, ReadResult, VirtualSandboxContext> =
- *   async (args, { sandbox }) => {
- *     const content = await sandbox.fs.readFile(args.path);
- *     return { toolResponse: content, data: { path: args.path, content } };
- *   };
- *
- * // At activity registration:
- * const provider = new VirtualSandboxProvider(resolver);
- * const handler = withVirtualSandbox(client, "myAgent", provider, readHandler);
- * ```
- */
-declare function withVirtualSandbox<TArgs, TResult, TCtx, TMeta = FileEntryMetadata, TToolResponse = JsonValue>(client: WorkflowClient, provider: VirtualSandboxProvider<TCtx, TMeta>, handler: ActivityToolHandler<TArgs, TResult, VirtualSandboxContext<TCtx, TMeta>, TToolResponse>): ActivityToolHandler<TArgs, (TResult & {
-    treeMutations: TreeMutation<TMeta>[];
-}) | null, RouterContext, TToolResponse | string>;
-
-/**
- * Create an ephemeral {@link Sandbox} from a file tree and resolver.
- *
- * Used internally by {@link withVirtualSandbox} and
- * {@link VirtualSandboxProvider}; consumers can also call this directly
- * if they need a sandbox outside the wrapper pattern.
- */
-declare function createVirtualSandbox<TCtx, TMeta = FileEntryMetadata>(id: string, tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx, workspaceBase?: string): VirtualSandbox<TCtx, TMeta>;
-
-export { FileEntry, FileEntryMetadata, FileResolver, TreeMutation, VirtualSandbox, VirtualSandboxContext, VirtualSandboxCreateOptions, VirtualSandboxProvider, createVirtualSandbox, withVirtualSandbox };

package/dist/adapters/sandbox/virtual/index.d.ts

@@ -1,90 +0,0 @@
-import { a as FileEntryMetadata, V as VirtualSandboxCreateOptions, b as FileResolver, c as VirtualSandboxContext, T as TreeMutation, F as FileEntry, d as VirtualSandbox } from '../../../types-yU5AINiP.js';
-export { e as VirtualFileTree, f as VirtualSandboxFileSystem, g as VirtualSandboxState } from '../../../types-yU5AINiP.js';
-import { b as SandboxProvider, c as SandboxCapabilities, e as SandboxCreateResult } from '../../../types-ChAMwU3q.js';
-import { WorkflowClient } from '@temporalio/client';
-import { J as JsonValue, A as ActivityToolHandler, R as RouterContext } from '../../../types-BclYm5Ic.js';
-export { F as FileTreeAccessor, f as filesWithMimeType, h as hasDirectory, a as hasFileWithMimeType } from '../../../queries-kjlvsUfz.js';
-import '@temporalio/common';
-import '@temporalio/workflow';
-import '@temporalio/common/lib/interfaces';
-import 'zod';
-
-/**
- * Stateless {@link SandboxProvider} backed by a {@link FileResolver}.
- *
- * The provider holds **no internal state**. All sandbox state (sandboxId,
- * fileTree, resolverContext, workspaceBase) is returned as a `stateUpdate` from
- * {@link create} and merged into the workflow's `AgentState` by the session.
- * {@link withVirtualSandbox} reads this state back on every tool invocation.
- *
- * @example
- * ```typescript
- * const provider = new VirtualSandboxProvider(resolver);
- * const manager = new SandboxManager(provider);
- *
- * export const activities = {
- *   ...manager.createActivities("CodingAgent"),
- *   readFile: withVirtualSandbox(client, provider, readHandler),
- * };
- * ```
- */
-declare class VirtualSandboxProvider<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxProvider<VirtualSandboxCreateOptions<TCtx>> {
-    readonly id = "virtual";
-    readonly capabilities: SandboxCapabilities;
-    readonly resolver: FileResolver<TCtx, TMeta>;
-    constructor(resolver: FileResolver<TCtx, TMeta>);
-    create(options?: VirtualSandboxCreateOptions<TCtx>): Promise<SandboxCreateResult>;
-    get(): Promise<never>;
-    destroy(): Promise<void>;
-    pause(): Promise<void>;
-    fork(_sandboxId: string): Promise<never>;
-    snapshot(): Promise<never>;
-    restore(): Promise<never>;
-}
-
-/**
- * Wraps a tool handler that needs a virtual sandbox, automatically querying
- * the parent workflow for the current file tree and resolver context.
- *
- * On each invocation the wrapper:
- * 1. Queries the workflow's `AgentState` for `fileTree`, `resolverContext`, and `workspaceBase`
- * 2. Creates an ephemeral {@link VirtualSandbox} from tree + provider's resolver
- * 3. Runs the inner handler
- * 4. Returns the handler's result together with any {@link TreeMutation}s
- *
- * The consumer applies mutations back to workflow state via a post-tool hook.
- *
- * @param client    - Temporal `WorkflowClient` for querying the parent workflow
- * @param agentName - Agent name (used to derive the state query name)
- * @param provider  - {@link VirtualSandboxProvider} (wraps the resolver)
- * @param handler   - Inner handler expecting a {@link VirtualSandboxContext}
- *
- * @example
- * ```typescript
- * import { withVirtualSandbox, type VirtualSandboxContext } from 'zeitlich';
- *
- * const readHandler: ActivityToolHandler<FileReadArgs, ReadResult, VirtualSandboxContext> =
- *   async (args, { sandbox }) => {
- *     const content = await sandbox.fs.readFile(args.path);
- *     return { toolResponse: content, data: { path: args.path, content } };
- *   };
- *
- * // At activity registration:
- * const provider = new VirtualSandboxProvider(resolver);
- * const handler = withVirtualSandbox(client, "myAgent", provider, readHandler);
- * ```
- */
-declare function withVirtualSandbox<TArgs, TResult, TCtx, TMeta = FileEntryMetadata, TToolResponse = JsonValue>(client: WorkflowClient, provider: VirtualSandboxProvider<TCtx, TMeta>, handler: ActivityToolHandler<TArgs, TResult, VirtualSandboxContext<TCtx, TMeta>, TToolResponse>): ActivityToolHandler<TArgs, (TResult & {
-    treeMutations: TreeMutation<TMeta>[];
-}) | null, RouterContext, TToolResponse | string>;
-
-/**
- * Create an ephemeral {@link Sandbox} from a file tree and resolver.
- *
- * Used internally by {@link withVirtualSandbox} and
- * {@link VirtualSandboxProvider}; consumers can also call this directly
- * if they need a sandbox outside the wrapper pattern.
- */
-declare function createVirtualSandbox<TCtx, TMeta = FileEntryMetadata>(id: string, tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx, workspaceBase?: string): VirtualSandbox<TCtx, TMeta>;
-
-export { FileEntry, FileEntryMetadata, FileResolver, TreeMutation, VirtualSandbox, VirtualSandboxContext, VirtualSandboxCreateOptions, VirtualSandboxProvider, createVirtualSandbox, withVirtualSandbox };

package/dist/adapters/sandbox/virtual/index.js

@@ -1,479 +0,0 @@
-import { ApplicationFailure } from '@temporalio/common';
-import { posix } from 'path';
-import { uuid4 } from '@temporalio/workflow';
-import { Context } from '@temporalio/activity';
-
-// src/lib/sandbox/types.ts
-var SandboxNotSupportedError = class extends ApplicationFailure {
-  constructor(operation) {
-    super(
-      `Sandbox does not support: ${operation}`,
-      "SandboxNotSupportedError",
-      true
-    );
-  }
-};
-function normalisePath(p, workspaceBase = "/") {
-  return posix.resolve(workspaceBase, p);
-}
-function parentDir(p) {
-  const idx = p.lastIndexOf("/");
-  return idx <= 0 ? "/" : p.slice(0, idx);
-}
-function inferDirectories(entries, workspaceBase) {
-  const dirs = /* @__PURE__ */ new Set();
-  dirs.add("/");
-  for (const entry of entries) {
-    let dir = parentDir(normalisePath(entry.path, workspaceBase));
-    while (dir !== "/" && !dirs.has(dir)) {
-      dirs.add(dir);
-      dir = parentDir(dir);
-    }
-    dirs.add("/");
-  }
-  return dirs;
-}
-var VirtualSandboxFileSystem = class {
-  constructor(tree, resolver, ctx, workspaceBase = "/") {
-    this.resolver = resolver;
-    this.ctx = ctx;
-    this.workspaceBase = normalisePath(workspaceBase);
-    this.entries = new Map(
-      tree.map((e) => [normalisePath(e.path, this.workspaceBase), e])
-    );
-    this.directories = inferDirectories(tree, this.workspaceBase);
-  }
-  workspaceBase;
-  entries;
-  directories;
-  mutations = [];
-  /** Return all mutations accumulated during this invocation. */
-  getMutations() {
-    return this.mutations;
-  }
-  /** Look up a file entry by virtual path. */
-  getEntry(path) {
-    return this.entries.get(normalisePath(path, this.workspaceBase));
-  }
-  // --------------------------------------------------------------------------
-  // Read operations — delegate to resolver lazily
-  // --------------------------------------------------------------------------
-  async readFile(path) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const entry = this.entries.get(norm);
-    if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
-    return this.resolver.readFile(entry.id, this.ctx, entry.metadata);
-  }
-  async readFileBuffer(path) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const entry = this.entries.get(norm);
-    if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
-    return this.resolver.readFileBuffer(entry.id, this.ctx, entry.metadata);
-  }
-  // --------------------------------------------------------------------------
-  // Metadata operations — pure, resolved from the tree
-  // --------------------------------------------------------------------------
-  async exists(path) {
-    const norm = normalisePath(path, this.workspaceBase);
-    return this.entries.has(norm) || this.directories.has(norm);
-  }
-  async stat(path) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const entry = this.entries.get(norm);
-    if (entry) {
-      return {
-        isFile: true,
-        isDirectory: false,
-        isSymbolicLink: false,
-        size: entry.size,
-        mtime: new Date(entry.mtime)
-      };
-    }
-    if (this.directories.has(norm)) {
-      return {
-        isFile: false,
-        isDirectory: true,
-        isSymbolicLink: false,
-        size: 0,
-        mtime: /* @__PURE__ */ new Date()
-      };
-    }
-    throw new Error(`ENOENT: no such file or directory: ${path}`);
-  }
-  async readdir(path) {
-    const norm = normalisePath(path, this.workspaceBase);
-    if (!this.directories.has(norm)) {
-      throw new Error(`ENOENT: no such directory: ${path}`);
-    }
-    const prefix = norm === "/" ? "/" : norm + "/";
-    const names = /* @__PURE__ */ new Set();
-    for (const p of this.entries.keys()) {
-      if (p.startsWith(prefix)) {
-        const rest = p.slice(prefix.length);
-        const seg = rest.split("/")[0];
-        if (seg) names.add(seg);
-      }
-    }
-    for (const d of this.directories) {
-      if (d.startsWith(prefix) && d !== norm) {
-        const rest = d.slice(prefix.length);
-        const seg = rest.split("/")[0];
-        if (seg) names.add(seg);
-      }
-    }
-    return [...names].sort();
-  }
-  async readdirWithFileTypes(path) {
-    const names = await this.readdir(path);
-    const norm = normalisePath(path, this.workspaceBase);
-    const prefix = norm === "/" ? "/" : norm + "/";
-    return names.map((name) => {
-      const full = prefix + name;
-      const isFile = this.entries.has(full);
-      const isDirectory = this.directories.has(full);
-      return { name, isFile, isDirectory, isSymbolicLink: false };
-    });
-  }
-  // --------------------------------------------------------------------------
-  // Write operations — delegate to resolver, record mutations
-  // --------------------------------------------------------------------------
-  async writeFile(path, content) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const existing = this.entries.get(norm);
-    if (existing) {
-      await this.resolver.writeFile(
-        existing.id,
-        content,
-        this.ctx,
-        existing.metadata
-      );
-      const size = typeof content === "string" ? new TextEncoder().encode(content).byteLength : content.byteLength;
-      const updated = {
-        ...existing,
-        size,
-        mtime: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      this.entries.set(norm, updated);
-      this.mutations.push({ type: "update", path: norm, entry: updated });
-    } else {
-      const entry = await this.resolver.createFile(norm, content, this.ctx);
-      const normalised = { ...entry, path: norm };
-      this.entries.set(norm, normalised);
-      this.addParentDirectories(norm);
-      this.mutations.push({ type: "add", entry: normalised });
-    }
-  }
-  async appendFile(path, content) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const existing = this.entries.get(norm);
-    if (!existing) {
-      return this.writeFile(path, content);
-    }
-    const current = await this.resolver.readFile(
-      existing.id,
-      this.ctx,
-      existing.metadata
-    );
-    const appended = typeof content === "string" ? current + content : current + new TextDecoder().decode(content);
-    await this.resolver.writeFile(
-      existing.id,
-      appended,
-      this.ctx,
-      existing.metadata
-    );
-    const size = new TextEncoder().encode(appended).byteLength;
-    const updated = {
-      ...existing,
-      size,
-      mtime: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.entries.set(norm, updated);
-    this.mutations.push({ type: "update", path: norm, entry: updated });
-  }
-  async mkdir(_path, _options) {
-    const norm = normalisePath(_path, this.workspaceBase);
-    if (this.directories.has(norm)) return;
-    if (_options?.recursive) {
-      this.addParentDirectories(norm + "/placeholder");
-      this.directories.add(norm);
-    } else {
-      const parent = parentDir(norm);
-      if (!this.directories.has(parent)) {
-        throw new Error(`ENOENT: no such directory: ${parent}`);
-      }
-      this.directories.add(norm);
-    }
-  }
-  async rm(path, options) {
-    const norm = normalisePath(path, this.workspaceBase);
-    const entry = this.entries.get(norm);
-    if (entry) {
-      await this.resolver.deleteFile(entry.id, this.ctx, entry.metadata);
-      this.entries.delete(norm);
-      this.mutations.push({ type: "remove", path: norm });
-      return;
-    }
-    if (this.directories.has(norm)) {
-      if (!options?.recursive) {
-        throw new Error(`EISDIR: is a directory (use recursive): ${path}`);
-      }
-      const prefix = norm === "/" ? "/" : norm + "/";
-      for (const [p, e] of this.entries) {
-        if (p.startsWith(prefix)) {
-          await this.resolver.deleteFile(e.id, this.ctx, e.metadata);
-          this.entries.delete(p);
-          this.mutations.push({ type: "remove", path: p });
-        }
-      }
-      for (const d of this.directories) {
-        if (d.startsWith(prefix)) this.directories.delete(d);
-      }
-      this.directories.delete(norm);
-      return;
-    }
-    if (!options?.force) {
-      throw new Error(`ENOENT: no such file or directory: ${path}`);
-    }
-  }
-  async cp(src, dest, _options) {
-    const normSrc = normalisePath(src, this.workspaceBase);
-    const normDest = normalisePath(dest, this.workspaceBase);
-    const entry = this.entries.get(normSrc);
-    if (entry) {
-      const content = await this.resolver.readFile(
-        entry.id,
-        this.ctx,
-        entry.metadata
-      );
-      await this.writeFile(normDest, content);
-      return;
-    }
-    if (!this.directories.has(normSrc)) {
-      throw new Error(`ENOENT: no such file or directory: ${src}`);
-    }
-    if (!_options?.recursive) {
-      throw new Error(`EISDIR: is a directory (use recursive): ${src}`);
-    }
-    const prefix = normSrc === "/" ? "/" : normSrc + "/";
-    for (const [p, e] of this.entries) {
-      if (p.startsWith(prefix)) {
-        const relative = p.slice(normSrc.length);
-        const content = await this.resolver.readFile(
-          e.id,
-          this.ctx,
-          e.metadata
-        );
-        await this.writeFile(normDest + relative, content);
-      }
-    }
-  }
-  async mv(src, dest) {
-    await this.cp(src, dest, { recursive: true });
-    await this.rm(src, { recursive: true });
-  }
-  // --------------------------------------------------------------------------
-  // Unsupported
-  // --------------------------------------------------------------------------
-  async readlink(_path) {
-    throw new SandboxNotSupportedError("readlink");
-  }
-  resolvePath(base, path) {
-    return posix.resolve(normalisePath(base, this.workspaceBase), path);
-  }
-  // --------------------------------------------------------------------------
-  // Helpers
-  // --------------------------------------------------------------------------
-  addParentDirectories(filePath) {
-    let dir = parentDir(normalisePath(filePath, this.workspaceBase));
-    while (!this.directories.has(dir)) {
-      this.directories.add(dir);
-      dir = parentDir(dir);
-    }
-  }
-};
-var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function getShortId(length = 12) {
-  const hex = 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/virtual/provider.ts
-var VirtualSandboxProvider = class {
-  id = "virtual";
-  capabilities = {
-    filesystem: true,
-    execution: false,
-    persistence: true
-  };
-  resolver;
-  constructor(resolver) {
-    this.resolver = resolver;
-  }
-  async create(options) {
-    if (!options || !("resolverContext" in options)) {
-      throw new Error("VirtualSandboxProvider.create requires resolverContext");
-    }
-    const sandboxId = options.id ?? getShortId();
-    const fileTree = await this.resolver.resolveEntries(
-      options.resolverContext
-    );
-    const workspaceBase = options.workspaceBase ?? "/";
-    const sandbox = createVirtualSandbox(
-      sandboxId,
-      fileTree,
-      this.resolver,
-      options.resolverContext,
-      workspaceBase
-    );
-    if (options.initialFiles) {
-      for (const [path, content] of Object.entries(options.initialFiles)) {
-        await sandbox.fs.writeFile(path, content);
-      }
-      for (const m of sandbox.fs.getMutations()) {
-        if (m.type === "add") fileTree.push(m.entry);
-      }
-    }
-    return {
-      sandbox,
-      stateUpdate: {
-        sandboxId,
-        fileTree,
-        resolverContext: options.resolverContext,
-        workspaceBase
-      }
-    };
-  }
-  async get() {
-    throw new SandboxNotSupportedError(
-      "get (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-  async destroy() {
-  }
-  async pause() {
-  }
-  async fork(_sandboxId) {
-    throw new Error("Not implemented");
-  }
-  async snapshot() {
-    throw new SandboxNotSupportedError(
-      "snapshot (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-  async restore() {
-    throw new SandboxNotSupportedError(
-      "restore (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-};
-async function queryParentWorkflowState(client) {
-  const { workflowExecution } = Context.current().info;
-  const handle = client.getHandle(
-    workflowExecution.workflowId,
-    workflowExecution.runId
-  );
-  return handle.query("getAgentState");
-}
-
-// src/adapters/sandbox/virtual/with-virtual-sandbox.ts
-function withVirtualSandbox(client, provider, handler) {
-  return async (args, context) => {
-    const state = await queryParentWorkflowState(client);
-    const { sandboxId, fileTree, resolverContext, workspaceBase } = state;
-    if (!fileTree || !sandboxId) {
-      return {
-        toolResponse: `Error: No fileTree/sandboxId in agent state. The ${context.toolName} tool requires a virtual sandbox.`,
-        data: null
-      };
-    }
-    const sandbox = createVirtualSandbox(
-      sandboxId,
-      fileTree,
-      provider.resolver,
-      resolverContext,
-      workspaceBase ?? "/"
-    );
-    const response = await handler(args, { ...context, sandbox });
-    const mutations = sandbox.fs.getMutations();
-    return {
-      toolResponse: response.toolResponse,
-      data: {
-        ...response.data ?? {},
-        treeMutations: mutations
-      }
-    };
-  };
-}
-
-// src/adapters/sandbox/virtual/queries.ts
-function hasFileWithMimeType(stateManager, pattern) {
-  const tree = stateManager.get("fileTree");
-  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
-  return tree.some((entry) => {
-    const meta = entry.metadata;
-    const mime = meta?.mimeType;
-    return typeof mime === "string" && matchers.some((m) => m(mime));
-  });
-}
-function filesWithMimeType(stateManager, pattern) {
-  const tree = stateManager.get("fileTree");
-  const match = buildMatcher(pattern);
-  return tree.filter((entry) => {
-    const meta = entry.metadata;
-    const mime = meta?.mimeType;
-    return typeof mime === "string" && match(mime);
-  });
-}
-function hasDirectory(stateManager, pattern) {
-  const tree = stateManager.get("fileTree");
-  const match = buildGlobMatcher(pattern);
-  return tree.some((entry) => {
-    const segments = entry.path.split("/").filter(Boolean);
-    return segments.slice(0, -1).some(match);
-  });
-}
-function buildMatcher(pattern) {
-  if (pattern.endsWith("/*")) {
-    const prefix = pattern.slice(0, -1);
-    return (v) => v.startsWith(prefix);
-  }
-  return (v) => v === pattern;
-}
-function buildGlobMatcher(pattern) {
-  if (!pattern.includes("*")) return (v) => v === pattern;
-  const re = new RegExp(
-    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$"
-  );
-  return (v) => re.test(v);
-}
-
-// src/adapters/sandbox/virtual/index.ts
-var VirtualSandboxImpl = class {
-  constructor(id, tree, resolver, ctx, workspaceBase = "/") {
-    this.id = id;
-    this.fs = new VirtualSandboxFileSystem(tree, resolver, ctx, workspaceBase);
-  }
-  capabilities = {
-    filesystem: true,
-    execution: false,
-    persistence: true
-  };
-  fs;
-  async exec(_command, _options) {
-    throw new SandboxNotSupportedError("exec");
-  }
-  async destroy() {
-  }
-};
-function createVirtualSandbox(id, tree, resolver, ctx, workspaceBase = "/") {
-  return new VirtualSandboxImpl(id, tree, resolver, ctx, workspaceBase);
-}
-
-export { VirtualSandboxFileSystem, VirtualSandboxProvider, createVirtualSandbox, filesWithMimeType, hasDirectory, hasFileWithMimeType, withVirtualSandbox };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map