zeitlich 0.2.28 → 0.2.30

package/src/lib/session/types.ts

@@ -1,8 +1,5 @@
 import type { Duration } from "@temporalio/common";
-import type {
-  ToolResultConfig,
-  SessionExitReason,
-} from "../types";
+import type { ToolResultConfig, SessionExitReason } from "../types";
 import type {
   ToolMap,
   ToolCallResultUnion,
@@ -12,10 +9,15 @@ import type { Hooks } from "../hooks/types";
 import type { SubagentConfig } from "../subagent/types";
 import type { Skill } from "../skills/types";
 import type { SandboxOps } from "../sandbox/types";
+import type { VirtualFsOps } from "../virtual-fs/types";
 import type { RunAgentActivity } from "../model/types";
 import type { AgentStateManager, JsonSerializable } from "../state/types";
 import type { ActivityInterfaceFor } from "@temporalio/workflow";
-import type { ThreadInit, SandboxInit, SubagentSandboxShutdown } from "../lifecycle";
+import type {
+  ThreadInit,
+  SandboxInit,
+  SubagentSandboxShutdown,
+} from "../lifecycle";
 
 /**
  * Thread operations required by a session.
@@ -33,7 +35,7 @@ export interface ThreadOps<TContent = string> {
     threadId: string,
     id: string,
     content: TContent,
-    threadKey?: string,
+    threadKey?: string
   ): Promise<void>;
   /** Append a tool result to the thread */
   appendToolResult(id: string, config: ToolResultConfig): Promise<void>;
@@ -42,10 +44,14 @@ export interface ThreadOps<TContent = string> {
     threadId: string,
     id: string,
     content: string,
-    threadKey?: string,
+    threadKey?: string
   ): Promise<void>;
   /** Copy all messages from sourceThreadId into a new thread at targetThreadId */
-  forkThread(sourceThreadId: string, targetThreadId: string, threadKey?: string): Promise<void>;
+  forkThread(
+    sourceThreadId: string,
+    targetThreadId: string,
+    threadKey?: string
+  ): Promise<void>;
 }
 
 /**
@@ -86,7 +92,11 @@ export type PrefixedThreadOps<TPrefix extends string, TContent = string> = {
  * @typeParam M - SDK-native message type returned by the model invoker
  * @typeParam TContent - SDK-native content type for human messages (defaults to `string`)
  */
-export interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
+export interface SessionConfig<
+  T extends ToolMap,
+  M = unknown,
+  TContent = string,
+> {
   /** The name of the agent, should be unique within the workflows */
   agentName: string;
   /** Metadata for the session */
@@ -163,6 +173,26 @@ export interface SessionConfig<T extends ToolMap, M = unknown, TContent = string
    * Has no effect when the sandbox is inherited (`sandbox.mode === "inherit"`).
    */
   sandboxShutdown?: SubagentSandboxShutdown;
+
+  // ---------------------------------------------------------------------------
+  // Virtual filesystem
+  // ---------------------------------------------------------------------------
+
+  virtualFsOps?: VirtualFsOps;
+
+  /**
+   * Virtual filesystem configuration (optional — independent of sandbox).
+   *
+   * When provided, the session resolves the file tree on start and merges
+   * `fileTree`, `ctx`, and `workspaceBase` into `AgentState`.
+   * Tool handlers wrapped with `withVirtualFs` can then read this state.
+   *
+   * Can be used alongside `sandboxOps` for agents that need both a real
+   * sandbox (e.g. for execution) and a virtual filesystem.
+   */
+  virtualFs?: {
+    ctx: unknown;
+  };
 }
 
 export type SessionResult<

package/src/lib/state/manager.integration.test.ts

@@ -11,6 +11,7 @@ vi.mock("@temporalio/workflow", () => {
     setHandler: (_def: unknown, _handler: unknown) => {},
     uuid4: () =>
       `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
+    log: { trace: () => {}, debug: () => {}, info: () => {}, warn: () => {}, error: () => {} },
   };
 });
 

package/src/lib/state/types.ts

@@ -1,8 +1,11 @@
-import type {
-  QueryDefinition,
-} from "@temporalio/workflow";
+import type { QueryDefinition } from "@temporalio/workflow";
 import type { UpdateDefinition } from "@temporalio/common/lib/interfaces";
-import type { AgentStatus, BaseAgentState, TokenUsage, WorkflowTask } from "../types";
+import type {
+  AgentStatus,
+  BaseAgentState,
+  TokenUsage,
+  WorkflowTask,
+} from "../types";
 import type { ToolDefinition } from "../tool-router/types";
 
 /**
@@ -98,8 +101,8 @@ export interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
   /** Set a custom state value by key */
   set<K extends keyof TCustom>(key: K, value: TCustom[K]): void;
 
-  /** Bulk-merge a partial update into custom state (e.g. from sandbox stateUpdate) */
-  mergeUpdate(update: Partial<TCustom>): void;
+  /** Bulk-merge a partial update into custom state */
+  mergeUpdate(update: Partial<AgentState<TCustom>>): void;
 
   /** Get full state for query handler */
   getCurrentState(): AgentState<TCustom>;

package/src/lib/subagent/handler.ts

@@ -17,7 +17,11 @@ import type {
 } from "./types";
 import type { SubagentArgs } from "./tool";
 import type { z } from "zod";
-import type { ThreadInit, SandboxInit, SubagentSandboxShutdown } from "../lifecycle";
+import type {
+  ThreadInit,
+  SandboxInit,
+  SubagentSandboxShutdown,
+} from "../lifecycle";
 import { childResultSignal, destroySandboxSignal } from "./signals";
 
 /**
@@ -45,9 +49,9 @@ function resolveSandboxConfig(config?: SubagentSandboxConfig): {
  */
 export function createSubagentHandler<
   const T extends readonly SubagentConfig[],
->(subagents: [...T], options?: {
-  getSandboxStateForInheritance?: () => Record<string, unknown> | undefined;
-}): {
+>(
+  subagents: [...T]
+): {
   handler: (
     args: SubagentArgs,
     context: RouterContext
@@ -99,18 +103,18 @@ export function createSubagentHandler<
     // --- Build thread init ---
     let thread: ThreadInit | undefined;
     if (continuationThreadId) {
-      thread = { mode: threadMode as "fork" | "continue", threadId: continuationThreadId };
-
+      thread = {
+        mode: threadMode as "fork" | "continue",
+        threadId: continuationThreadId,
+      };
     }
 
     // --- Build sandbox init ---
     let sandbox: SandboxInit | undefined;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
-      const stateUpdate = options?.getSandboxStateForInheritance?.();
       sandbox = {
         mode: "inherit",
         sandboxId: parentSandboxId,
-        ...(stateUpdate && { stateUpdate }),
       };
     } else if (sandboxCfg.source === "own") {
       const prevSbId = continuationThreadId
@@ -144,12 +148,20 @@ export function createSubagentHandler<
       taskQueue: config.taskQueue ?? parentTaskQueue,
     };
 
+    log.info("subagent spawned", {
+      subagent: config.agentName,
+      childWorkflowId,
+      threadMode,
+      sandboxSource: sandboxCfg.source,
+    });
+
     const childHandle = await startChild(config.workflow, childOpts);
 
     const effectiveShutdown = sandboxCfg.shutdown ?? "destroy";
     const shouldDeferDestroy =
       effectiveShutdown === "pause-until-parent-close" &&
-      (sandboxCfg.source === "own" || (allowsContinuation && sandboxCfg.source !== "inherit"));
+      (sandboxCfg.source === "own" ||
+        (allowsContinuation && sandboxCfg.source !== "inherit"));
 
     if (shouldDeferDestroy) {
       pendingDestroys.set(childWorkflowId, childHandle);
@@ -168,12 +180,22 @@ export function createSubagentHandler<
     childResults.delete(childWorkflowId);
 
     if (!childResult) {
+      log.warn("subagent returned no result", {
+        subagent: config.agentName,
+        childWorkflowId,
+      });
       return {
         toolResponse: "Subagent workflow did not signal a result",
         data: null,
       };
     }
 
+    log.info("subagent completed", {
+      subagent: config.agentName,
+      childWorkflowId,
+      ...(childResult.usage && { usage: childResult.usage }),
+    });
+
     const {
       toolResponse,
       data,
@@ -214,9 +236,10 @@ export function createSubagentHandler<
     let finalToolResponse: JsonValue = toolResponse;
 
     if (allowsContinuation && childThreadId) {
-      const responseStr = typeof toolResponse === "string"
-        ? toolResponse
-        : JSON.stringify(toolResponse);
+      const responseStr =
+        typeof toolResponse === "string"
+          ? toolResponse
+          : JSON.stringify(toolResponse);
       finalToolResponse = `${responseStr}\n\n[${config.agentName} Thread ID: ${childThreadId}]`;
     }
 

package/src/lib/subagent/register.ts

@@ -6,7 +6,11 @@ import type {
 } from "../tool-router/types";
 import type { SubagentConfig, SubagentHooks } from "./types";
 import type { z } from "zod";
-import { createSubagentTool, SUBAGENT_TOOL_NAME, type SubagentArgs } from "./tool";
+import {
+  createSubagentTool,
+  SUBAGENT_TOOL_NAME,
+  type SubagentArgs,
+} from "./tool";
 import { createSubagentHandler } from "./handler";
 
 /**
@@ -19,12 +23,7 @@ import { createSubagentHandler } from "./handler";
  *
  * Returns null if no subagents are configured.
  */
-export function buildSubagentRegistration(
-  subagents: SubagentConfig[],
-  options?: {
-    getSandboxStateForInheritance?: () => Record<string, unknown> | undefined;
-  },
-): {
+export function buildSubagentRegistration(subagents: SubagentConfig[]): {
   registration: ToolMap[string];
   destroySubagentSandboxes: () => Promise<void>;
 } | null {
@@ -32,7 +31,7 @@ export function buildSubagentRegistration(
 
   const getEnabled = (): SubagentConfig[] =>
     subagents.filter((s) =>
-      typeof s.enabled === "function" ? s.enabled() : (s.enabled ?? true),
+      typeof s.enabled === "function" ? s.enabled() : (s.enabled ?? true)
     );
 
   const subagentHooksMap = new Map<string, SubagentHooks>();
@@ -43,15 +42,15 @@ export function buildSubagentRegistration(
   const resolveSubagentName = (args: unknown): string =>
     (args as SubagentArgs).subagent;
 
-  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents, {
-    getSandboxStateForInheritance: options?.getSandboxStateForInheritance,
-  });
+  const { handler, destroySubagentSandboxes } =
+    createSubagentHandler(subagents);
 
   const registration: ToolMap[string] = {
     name: SUBAGENT_TOOL_NAME,
     enabled: (): boolean => getEnabled().length > 0,
     description: (): string => createSubagentTool(getEnabled()).description,
-    schema: (): z.ZodObject<z.ZodRawShape> => createSubagentTool(getEnabled()).schema,
+    schema: (): z.ZodObject<z.ZodRawShape> =>
+      createSubagentTool(getEnabled()).schema,
     handler,
     ...(subagentHooksMap.size > 0 && {
       hooks: {

package/src/lib/subagent/subagent.integration.test.ts

@@ -81,6 +81,7 @@ vi.mock("@temporalio/workflow", () => {
       ).join("");
       return `${bytes.slice(0, 8)}-${bytes.slice(8, 12)}-${bytes.slice(12, 16)}-${bytes.slice(16, 20)}-${bytes.slice(20, 32)}`;
     },
+    log: { trace: () => {}, debug: () => {}, info: () => {}, warn: () => {}, error: () => {} },
   };
 });
 

package/src/lib/tool-router/router-edge-cases.integration.test.ts

@@ -22,9 +22,11 @@ vi.mock("@temporalio/workflow", () => {
       return err;
     }
   }
+  const noop = () => {};
   return {
     ApplicationFailure: MockApplicationFailure,
     uuid4: () => "00000000-0000-0000-0000-000000000000",
+    log: { trace: noop, debug: noop, info: noop, warn: noop, error: noop },
   };
 });
 

package/src/lib/tool-router/router.integration.test.ts

@@ -22,9 +22,11 @@ vi.mock("@temporalio/workflow", () => {
       return err;
     }
   }
+  const noop = () => {};
   return {
     ApplicationFailure: MockApplicationFailure,
     uuid4: () => "00000000-0000-0000-0000-000000000000",
+    log: { trace: noop, debug: noop, info: noop, warn: noop, error: noop },
   };
 });
 

package/src/lib/tool-router/router.ts

@@ -20,7 +20,7 @@ import type {
 
 import type { JsonValue } from "../state/types";
 import type { z } from "zod";
-import { uuid4 } from "@temporalio/workflow";
+import { uuid4, log } from "@temporalio/workflow";
 
 /**
  * Creates a tool router for declarative tool call processing.
@@ -223,6 +223,12 @@ export function createToolRouter<T extends ToolMap>(
     }
     const effectiveArgs = preResult.args;
 
+    log.debug("tool call dispatched", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn,
+    });
+
     // --- Execute handler ---
     let result: unknown;
     let content!: JsonValue;
@@ -251,6 +257,13 @@ export function createToolRouter<T extends ToolMap>(
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      log.warn("tool call failed", {
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        turn,
+        durationMs: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error),
+      });
       const recovery = await runFailureHooks(
         toolCall,
         tool,
@@ -279,6 +292,8 @@ export function createToolRouter<T extends ToolMap>(
       );
     }
 
+    const durationMs = Date.now() - startTime;
+
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
@@ -286,6 +301,13 @@ export function createToolRouter<T extends ToolMap>(
       ...(metadata && { metadata }),
     } as ToolCallResultUnion<TResults>;
 
+    log.debug("tool call completed", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn,
+      durationMs,
+    });
+
     // --- Post-hooks ---
     await runPostHooks(
       toolCall,
@@ -293,7 +315,7 @@ export function createToolRouter<T extends ToolMap>(
       toolResult,
       effectiveArgs,
       turn,
-      Date.now() - startTime
+      durationMs
     );
 
     return toolResult;

package/src/lib/types.ts

@@ -1,4 +1,5 @@
 import type { JsonValue } from "./state/types";
+import type { FileEntry } from "./virtual-fs/types";
 
 // ============================================================================
 // Agent core types
@@ -23,6 +24,7 @@ export interface BaseAgentState {
   version: number;
   turns: number;
   tasks: Map<string, WorkflowTask>;
+  fileTree: FileEntry[];
   systemPrompt?: string;
   totalInputTokens: number;
   totalOutputTokens: number;

package/src/{adapters/sandbox/virtual → lib/virtual-fs}/filesystem.ts

@@ -2,8 +2,8 @@ import type {
   SandboxFileSystem,
   DirentEntry,
   FileStat,
-} from "../../../lib/sandbox/types";
-import { SandboxNotSupportedError } from "../../../lib/sandbox/types";
+} from "../sandbox/types";
+import { SandboxNotSupportedError } from "../sandbox/types";
 import { posix } from "node:path";
 import type {
   FileEntry,
@@ -45,13 +45,13 @@ function inferDirectories(
 }
 
 /**
- * Ephemeral {@link SandboxFileSystem} backed by a {@link FileResolver}.
+ * Ephemeral virtual filesystem backed by a {@link FileResolver}.
  *
  * Created fresh for each tool invocation from the current workflow file tree.
  * Directory structure is inferred from file paths. All mutations are tracked
  * and can be retrieved via {@link getMutations} after the handler completes.
  */
-export class VirtualSandboxFileSystem<
+export class VirtualFileSystem<
   TCtx = unknown,
   TMeta = FileEntryMetadata,
 > implements SandboxFileSystem {

package/src/lib/virtual-fs/index.ts

@@ -0,0 +1,18 @@
+export { VirtualFileSystem } from "./filesystem";
+export { withVirtualFs } from "./with-virtual-fs";
+export { createVirtualFsActivities } from "./manager";
+export { hasFileWithMimeType, filesWithMimeType, hasDirectory } from "./queries";
+export { applyVirtualTreeMutations } from "./mutations";
+export { formatVirtualFileTree } from "./tree";
+export type { FileTreeAccessor } from "./queries";
+export type {
+  FileEntry,
+  FileEntryMetadata,
+  FileResolver,
+  VirtualFileTree,
+  VirtualFsOps,
+  PrefixedVirtualFsOps,
+  VirtualFsState,
+  VirtualFsContext,
+  TreeMutation,
+} from "./types";

package/src/lib/virtual-fs/manager.ts

@@ -0,0 +1,48 @@
+import type {
+  FileEntryMetadata,
+  FileResolver,
+  PrefixedVirtualFsOps,
+  VirtualFsOps,
+} from "./types";
+
+/**
+ * Creates prefixed Temporal activity functions for a {@link FileResolver}.
+ *
+ * Pair with {@link proxyVirtualFsOps} on the workflow side using the same
+ * scope string.
+ *
+ * @param resolver - Consumer-provided bridge to DB / S3 / CRUD layer
+ * @param scope    - Workflow name used to namespace the activities
+ *
+ * @example
+ * ```typescript
+ * import { createVirtualFsActivities } from 'zeitlich';
+ *
+ * const activities = {
+ *   ...createVirtualFsActivities(resolver, "CodingAgent"),
+ * };
+ * // registers: codingAgentResolveFileTree
+ * ```
+ */
+export function createVirtualFsActivities<
+  S extends string,
+  TCtx = unknown,
+  TMeta = FileEntryMetadata,
+>(
+  resolver: FileResolver<TCtx, TMeta>,
+  scope: S,
+): PrefixedVirtualFsOps<S, TCtx, TMeta> {
+  const ops: VirtualFsOps<TCtx, TMeta> = {
+    resolveFileTree: async (ctx: TCtx) => {
+      const fileTree = await resolver.resolveEntries(ctx);
+      return { fileTree };
+    },
+  };
+
+  const prefix = scope;
+  const cap = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
+
+  return Object.fromEntries(
+    Object.entries(ops).map(([k, v]) => [`${prefix}${cap(k)}`, v]),
+  ) as PrefixedVirtualFsOps<S, TCtx, TMeta>;
+}

package/src/lib/virtual-fs/proxy.ts

@@ -0,0 +1,45 @@
+/**
+ * Workflow-safe proxy for virtual filesystem operations.
+ *
+ * Import this from `zeitlich/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 { proxyVirtualFsOps } from 'zeitlich/workflow';
+ *
+ * const virtualFsOps = proxyVirtualFsOps();
+ * ```
+ */
+import { proxyActivities, workflowInfo } from "@temporalio/workflow";
+import type { VirtualFsOps } from "./types";
+
+export function proxyVirtualFsOps<TCtx = unknown>(
+  scope?: string,
+  options?: Parameters<typeof proxyActivities>[0],
+): VirtualFsOps<TCtx> {
+  const resolvedScope = scope ?? workflowInfo().workflowType;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const acts = proxyActivities<Record<string, (...args: any[]) => any>>(
+    options ?? {
+      startToCloseTimeout: "30s",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "2s",
+        maximumInterval: "30s",
+        backoffCoefficient: 2,
+      },
+    },
+  );
+
+  const prefix = resolvedScope;
+  const p = (key: string): string =>
+    `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+
+  return {
+    resolveFileTree: acts[p("resolveFileTree")],
+  } as VirtualFsOps<TCtx>;
+}

package/src/{adapters/sandbox/virtual → lib/virtual-fs}/types.ts

@@ -1,6 +1,5 @@
-import type { Sandbox, SandboxCreateOptions } from "../../../lib/sandbox/types";
-import type { RouterContext } from "../../../lib/tool-router/types";
-import type { VirtualSandboxFileSystem } from "./filesystem";
+import type { RouterContext } from "../tool-router/types";
+import type { VirtualFileSystem } from "./filesystem";
 
 // ============================================================================
 // File Entry
@@ -15,7 +14,7 @@ export type FileEntryMetadata = Record<
 /** JSON-serializable metadata for a single file in the virtual tree. */
 export interface FileEntry<TMeta = FileEntryMetadata> {
   id: string;
-  /** Virtual path inside the sandbox, e.g. "/src/index.ts" */
+  /** Virtual path, e.g. "/src/index.ts" */
   path: string;
   size: number;
   /** ISO-8601 date string (JSON-safe) */
@@ -73,63 +72,68 @@ export interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
 }
 
 // ============================================================================
-// Create Options
+// VirtualFsOps — workflow-side activity interface
 // ============================================================================
 
 /**
- * Options for {@link VirtualSandboxProvider.create}.
- * Extends base options with resolver context.
+ * Workflow-side operations for the virtual filesystem.
+ *
+ * Unlike {@link SandboxOps}, this only exposes what is actually needed:
+ * resolving the initial file tree from the consumer's data layer.
  */
-export interface VirtualSandboxCreateOptions<
-  TCtx,
-> extends SandboxCreateOptions {
-  resolverContext: TCtx;
-  /** Base path for resolving relative filesystem paths (default "/"). */
-  workspaceBase?: string;
+export interface VirtualFsOps<TCtx = unknown, TMeta = FileEntryMetadata> {
+  resolveFileTree(ctx: TCtx): Promise<{
+    fileTree: FileEntry<TMeta>[];
+  }>;
 }
 
-// ============================================================================
-// Workflow State Shape
-// ============================================================================
-
 /**
- * The portion of workflow `AgentState` that the virtual sandbox reads via
- * {@link queryParentWorkflowState}. Populated automatically by the session
- * from the provider's `stateUpdate` after `createSandbox`.
+ * Maps generic {@link VirtualFsOps} method names to scope-prefixed names.
+ *
+ * @example
+ * ```typescript
+ * type Ops = PrefixedVirtualFsOps<"codingAgent">;
+ * // → { codingAgentResolveFileTree: ... }
+ * ```
  */
-export interface VirtualSandboxState<
+export type PrefixedVirtualFsOps<
+  TPrefix extends string,
   TCtx = unknown,
   TMeta = FileEntryMetadata,
-> {
-  sandboxId: string;
-  fileTree: FileEntry<TMeta>[];
-  resolverContext: TCtx;
-  workspaceBase?: string;
-}
+> = {
+  [K in keyof VirtualFsOps<
+    TCtx,
+    TMeta
+  > as `${TPrefix}${Capitalize<K & string>}`]: VirtualFsOps<TCtx, TMeta>[K];
+};
 
 // ============================================================================
-// VirtualSandbox instance type
+// Workflow State Shape
 // ============================================================================
 
 /**
- * A {@link Sandbox} whose filesystem is backed by a {@link VirtualSandboxFileSystem}.
+ * The portion of workflow `AgentState` that the virtual filesystem reads via
+ * {@link queryParentWorkflowState}. Populated automatically by the session
+ * when `virtualFs` config is provided.
  */
-export type VirtualSandbox<
-  TCtx = unknown,
-  TMeta = FileEntryMetadata,
-> = Sandbox & { fs: VirtualSandboxFileSystem<TCtx, TMeta> };
+export interface VirtualFsState<TCtx = unknown, TMeta = FileEntryMetadata> {
+  fileTree: FileEntry<TMeta>[];
+  ctx: TCtx;
+  workspaceBase?: string;
+}
 
 // ============================================================================
 // Handler Context
 // ============================================================================
 
 /**
- * Extended router context injected by {@link withVirtualSandbox}.
- * Guarantees a live (ephemeral) sandbox built from the workflow file tree.
+ * Extended router context injected by {@link withVirtualFs}.
+ * Guarantees a live (ephemeral) virtual filesystem built from the workflow
+ * file tree.
  */
-export interface VirtualSandboxContext<
+export interface VirtualFsContext<
   TCtx = unknown,
   TMeta = FileEntryMetadata,
 > extends RouterContext {
-  sandbox: VirtualSandbox<TCtx, TMeta>;
+  virtualFs: VirtualFileSystem<TCtx, TMeta>;
 }