experimental-agent 0.2.1 → 0.3.0

package/dist/sandbox.mjs

@@ -0,0 +1,19 @@
+import {
+  vercelSandbox
+} from "./chunk-RT72C52I.mjs";
+import {
+  dockerSandbox
+} from "./chunk-BFFNCESS.mjs";
+import {
+  localSandbox
+} from "./chunk-ZUFJJYC4.mjs";
+import "./chunk-GKASMIBR.mjs";
+import "./chunk-JO3JDCH5.mjs";
+import "./chunk-MSWINCCM.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  dockerSandbox,
+  localSandbox,
+  vercelSandbox
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/steps-BnkRQKlc.d.ts

@@ -0,0 +1,173 @@
+import * as _vercel_sandbox from '@vercel/sandbox';
+import { e as Storage, a as Sandbox } from './adapter-BigchkkI.js';
+
+type LogLevel = "info" | "warn" | "error" | "silent";
+type LogContext = {
+    sessionId?: string;
+    messageId?: string;
+    sandboxId?: string;
+    [key: string]: unknown;
+};
+type LoggingConfig = {
+    level?: LogLevel;
+    /**
+     * Top-level label for all log lines.
+     * @default "agent"
+     * @example "my-app" → [my-app:default:workflow]
+     */
+    prefix?: string;
+    name?: string;
+};
+declare class Logger {
+    readonly subsystem: string;
+    private readonly config;
+    private readonly context;
+    constructor({ subsystem, config, context, }: {
+        subsystem: string;
+        config: LoggingConfig;
+        context?: LogContext;
+    });
+    child({ subsystem, context, }: {
+        subsystem?: string;
+        context?: LogContext;
+    }): Logger;
+    withContext(context: LogContext): Logger;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Returns a function that, when called, logs the elapsed time at info level.
+     * Pass `logOnStart: true` to also log when the timer begins.
+     *
+     * @example
+     * const done = log.time("sandbox setup", { sandboxId }, { logOnStart: true });
+     * await setup();
+     * done(); // start: [agent:default:sandbox] sandbox setup { sandboxId: '...' }
+     *         // end:   [agent:default:sandbox] sandbox setup { sandboxId: '...', durationMs: 123 }
+     */
+    time(message: string, data?: Record<string, unknown>, opts?: {
+        logOnStart?: boolean;
+    }): (endData?: Record<string, unknown>) => void;
+}
+
+type ExecResult = {
+    commandId: string;
+    logs: () => AsyncIterable<{
+        stream: "stdout" | "stderr";
+        data: string;
+    }>;
+    result: Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+};
+type UploadableFile = {
+    path: string;
+    content: string | Buffer;
+};
+interface SandboxInstance {
+    readonly cwd: string;
+    exec(opts: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        sudo?: boolean;
+        signal?: AbortSignal;
+    }): Promise<ExecResult>;
+    readFile(opts: {
+        path: string;
+        signal?: AbortSignal;
+    }): Promise<Buffer | null>;
+    writeFiles(opts: {
+        files: UploadableFile[];
+        destPath: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    getDomain(opts: {
+        port: number;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    updateNetworkPolicy(opts: {
+        policy: _vercel_sandbox.NetworkPolicy;
+        signal?: AbortSignal;
+    }): Promise<_vercel_sandbox.NetworkPolicy>;
+    start(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    stop(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    snapshot(opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        snapshotId: string;
+    }>;
+    kill(opts: {
+        commandId: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    getStatus(opts?: {
+        signal?: AbortSignal;
+    }): Promise<"pending" | "running" | "stopping" | "stopped" | "failed">;
+}
+type SandboxAgentRef = {
+    name: string;
+    storage: Storage;
+    options: {
+        logging?: Omit<LoggingConfig, "name">;
+    };
+};
+type WithConfig<TConfig> = unknown extends TConfig ? {
+    config?: Record<string, unknown>;
+} : Partial<TConfig> extends TConfig ? {
+    config?: TConfig;
+} : {
+    config: TConfig;
+};
+type SandboxSetupFields = Omit<Sandbox["setup"], "binding" | "completedAt">;
+type SandboxBinding<TType extends string = string, TConfig = any, TMetadata = any> = {
+    type: TType;
+    create(opts: {
+        cwd: string;
+        agent: SandboxAgentRef;
+        setup: SandboxSetupFields & {
+            run?: (sandbox: SandboxInstance) => Promise<void>;
+        } & WithConfig<TConfig>;
+        record?: Sandbox;
+        signal?: AbortSignal;
+        log: Logger;
+    }): Promise<{
+        instance: SandboxInstance;
+        metadata: TMetadata;
+    }>;
+    connect(opts: {
+        agent: SandboxAgentRef;
+        metadata: TMetadata;
+        signal?: AbortSignal;
+        log: Logger;
+    }): Promise<SandboxInstance>;
+};
+
+type LifecycleStepResult = {
+    action: "continue";
+    nextPollMs: number;
+} | {
+    action: "exit";
+    reason: "sandboxId_changed" | "idle" | "timeout" | "not_found";
+};
+type LifecycleConfig = {
+    pollIntervalMs?: number;
+    stopAfterInactiveMs?: number;
+    snapshotBeforeTimeoutMs?: number;
+};
+type LifecycleInput = {
+    agent: SandboxAgentRef;
+    sandboxId: string;
+    vercelSandboxId: string;
+    config?: LifecycleConfig;
+};
+declare function checkAndSnapshotStep(input: LifecycleInput): Promise<Error | LifecycleStepResult>;
+
+export { type ExecResult as E, type LifecycleInput as L, type SandboxBinding as S, type UploadableFile as U, type WithConfig as W, type SandboxSetupFields as a, type SandboxInstance as b, type LoggingConfig as c, type SandboxAgentRef as d, type LifecycleConfig as e, type LifecycleStepResult as f, checkAndSnapshotStep as g };

package/dist/steps-u-mGDbP_.d.mts

@@ -0,0 +1,173 @@
+import * as _vercel_sandbox from '@vercel/sandbox';
+import { e as Storage, a as Sandbox } from './adapter-BigchkkI.mjs';
+
+type LogLevel = "info" | "warn" | "error" | "silent";
+type LogContext = {
+    sessionId?: string;
+    messageId?: string;
+    sandboxId?: string;
+    [key: string]: unknown;
+};
+type LoggingConfig = {
+    level?: LogLevel;
+    /**
+     * Top-level label for all log lines.
+     * @default "agent"
+     * @example "my-app" → [my-app:default:workflow]
+     */
+    prefix?: string;
+    name?: string;
+};
+declare class Logger {
+    readonly subsystem: string;
+    private readonly config;
+    private readonly context;
+    constructor({ subsystem, config, context, }: {
+        subsystem: string;
+        config: LoggingConfig;
+        context?: LogContext;
+    });
+    child({ subsystem, context, }: {
+        subsystem?: string;
+        context?: LogContext;
+    }): Logger;
+    withContext(context: LogContext): Logger;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Returns a function that, when called, logs the elapsed time at info level.
+     * Pass `logOnStart: true` to also log when the timer begins.
+     *
+     * @example
+     * const done = log.time("sandbox setup", { sandboxId }, { logOnStart: true });
+     * await setup();
+     * done(); // start: [agent:default:sandbox] sandbox setup { sandboxId: '...' }
+     *         // end:   [agent:default:sandbox] sandbox setup { sandboxId: '...', durationMs: 123 }
+     */
+    time(message: string, data?: Record<string, unknown>, opts?: {
+        logOnStart?: boolean;
+    }): (endData?: Record<string, unknown>) => void;
+}
+
+type ExecResult = {
+    commandId: string;
+    logs: () => AsyncIterable<{
+        stream: "stdout" | "stderr";
+        data: string;
+    }>;
+    result: Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+};
+type UploadableFile = {
+    path: string;
+    content: string | Buffer;
+};
+interface SandboxInstance {
+    readonly cwd: string;
+    exec(opts: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        sudo?: boolean;
+        signal?: AbortSignal;
+    }): Promise<ExecResult>;
+    readFile(opts: {
+        path: string;
+        signal?: AbortSignal;
+    }): Promise<Buffer | null>;
+    writeFiles(opts: {
+        files: UploadableFile[];
+        destPath: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    getDomain(opts: {
+        port: number;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    updateNetworkPolicy(opts: {
+        policy: _vercel_sandbox.NetworkPolicy;
+        signal?: AbortSignal;
+    }): Promise<_vercel_sandbox.NetworkPolicy>;
+    start(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    stop(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    snapshot(opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        snapshotId: string;
+    }>;
+    kill(opts: {
+        commandId: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    getStatus(opts?: {
+        signal?: AbortSignal;
+    }): Promise<"pending" | "running" | "stopping" | "stopped" | "failed">;
+}
+type SandboxAgentRef = {
+    name: string;
+    storage: Storage;
+    options: {
+        logging?: Omit<LoggingConfig, "name">;
+    };
+};
+type WithConfig<TConfig> = unknown extends TConfig ? {
+    config?: Record<string, unknown>;
+} : Partial<TConfig> extends TConfig ? {
+    config?: TConfig;
+} : {
+    config: TConfig;
+};
+type SandboxSetupFields = Omit<Sandbox["setup"], "binding" | "completedAt">;
+type SandboxBinding<TType extends string = string, TConfig = any, TMetadata = any> = {
+    type: TType;
+    create(opts: {
+        cwd: string;
+        agent: SandboxAgentRef;
+        setup: SandboxSetupFields & {
+            run?: (sandbox: SandboxInstance) => Promise<void>;
+        } & WithConfig<TConfig>;
+        record?: Sandbox;
+        signal?: AbortSignal;
+        log: Logger;
+    }): Promise<{
+        instance: SandboxInstance;
+        metadata: TMetadata;
+    }>;
+    connect(opts: {
+        agent: SandboxAgentRef;
+        metadata: TMetadata;
+        signal?: AbortSignal;
+        log: Logger;
+    }): Promise<SandboxInstance>;
+};
+
+type LifecycleStepResult = {
+    action: "continue";
+    nextPollMs: number;
+} | {
+    action: "exit";
+    reason: "sandboxId_changed" | "idle" | "timeout" | "not_found";
+};
+type LifecycleConfig = {
+    pollIntervalMs?: number;
+    stopAfterInactiveMs?: number;
+    snapshotBeforeTimeoutMs?: number;
+};
+type LifecycleInput = {
+    agent: SandboxAgentRef;
+    sandboxId: string;
+    vercelSandboxId: string;
+    config?: LifecycleConfig;
+};
+declare function checkAndSnapshotStep(input: LifecycleInput): Promise<Error | LifecycleStepResult>;
+
+export { type ExecResult as E, type LifecycleInput as L, type SandboxBinding as S, type UploadableFile as U, type WithConfig as W, type SandboxSetupFields as a, type SandboxInstance as b, type LoggingConfig as c, type SandboxAgentRef as d, type LifecycleConfig as e, type LifecycleStepResult as f, checkAndSnapshotStep as g };

package/dist/storage.d.mts

@@ -0,0 +1,11 @@
+import { S as StorageHandlers } from './adapter-BigchkkI.mjs';
+export { M as Message, P as Part, a as Sandbox, b as Session, c as Setup, d as SetupSnapshot, e as Storage, f as StorageCall, g as StorageStep, h as StorageStepFunction, t as toStorage } from './adapter-BigchkkI.mjs';
+import '@workflow/serde';
+import '@vercel/sandbox';
+import 'ai';
+
+declare function localStorage(opts?: {
+    dir?: string;
+}): StorageHandlers;
+
+export { StorageHandlers, localStorage };

package/dist/storage.d.ts

@@ -0,0 +1,11 @@
+import { S as StorageHandlers } from './adapter-BigchkkI.js';
+export { M as Message, P as Part, a as Sandbox, b as Session, c as Setup, d as SetupSnapshot, e as Storage, f as StorageCall, g as StorageStep, h as StorageStepFunction, t as toStorage } from './adapter-BigchkkI.js';
+import '@workflow/serde';
+import '@vercel/sandbox';
+import 'ai';
+
+declare function localStorage(opts?: {
+    dir?: string;
+}): StorageHandlers;
+
+export { StorageHandlers, localStorage };

package/dist/storage.js

@@ -0,0 +1,234 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/entry.ts
+var entry_exports = {};
+__export(entry_exports, {
+  StorageStep: () => StorageStep,
+  localStorage: () => localStorage,
+  toStorage: () => toStorage
+});
+module.exports = __toCommonJS(entry_exports);
+
+// src/storage/adapter.ts
+var import_serde = require("@workflow/serde");
+var StorageStep = class _StorageStep {
+  event;
+  constructor(event) {
+    this.event = event;
+  }
+  static [import_serde.WORKFLOW_SERIALIZE](instance) {
+    return { event: instance.event };
+  }
+  static [import_serde.WORKFLOW_DESERIALIZE](data) {
+    return new _StorageStep(data.event);
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: safe dispatch — event.method selects the matching handler
+  on(handlers) {
+    return handlers[this.event.method](this.event);
+  }
+};
+function isStepFunction(h) {
+  return typeof h === "function";
+}
+function fromStepFunction(fn) {
+  return {
+    session: {
+      get: (id) => fn(new StorageStep({ method: "session.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "session.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "session.update", id, updates }))
+    },
+    message: {
+      get: (id) => fn(new StorageStep({ method: "message.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "message.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "message.update", id, updates })),
+      listBySession: (sessionId) => fn(new StorageStep({ method: "message.listBySession", sessionId }))
+    },
+    part: {
+      get: (id) => fn(new StorageStep({ method: "part.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "part.set", id, value })),
+      listBySession: (sessionId) => fn(new StorageStep({ method: "part.listBySession", sessionId }))
+    },
+    sandbox: {
+      get: (id) => fn(new StorageStep({ method: "sandbox.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "sandbox.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "sandbox.update", id, updates }))
+    },
+    setup: {
+      get: (id) => fn(new StorageStep({ method: "setup.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "setup.set", id, value }))
+    }
+  };
+}
+function fromHandlers(h) {
+  return {
+    session: {
+      get: (id) => h["session.get"]({ id }),
+      set: (id, value) => h["session.set"]({ id, value }),
+      update: (id, updates) => h["session.update"]({ id, updates })
+    },
+    message: {
+      get: (id) => h["message.get"]({ id }),
+      set: (id, value) => h["message.set"]({ id, value }),
+      update: (id, updates) => h["message.update"]({ id, updates }),
+      listBySession: (sessionId) => h["message.listBySession"]({ sessionId })
+    },
+    part: {
+      get: (id) => h["part.get"]({ id }),
+      set: (id, value) => h["part.set"]({ id, value }),
+      listBySession: (sessionId) => h["part.listBySession"]({ sessionId })
+    },
+    sandbox: {
+      get: (id) => h["sandbox.get"]({ id }),
+      set: (id, value) => h["sandbox.set"]({ id, value }),
+      update: (id, updates) => h["sandbox.update"]({ id, updates })
+    },
+    setup: {
+      get: (id) => h["setup.get"]({ id }),
+      set: (id, value) => h["setup.set"]({ id, value })
+    }
+  };
+}
+function toStorage(h) {
+  return isStepFunction(h) ? fromStepFunction(h) : fromHandlers(h);
+}
+
+// src/storage/bindings/local.ts
+var _fs;
+var _path;
+async function fs() {
+  if (!_fs) {
+    _fs = await import("fs/promises");
+  }
+  return _fs;
+}
+async function path() {
+  if (!_path) {
+    _path = await import("path");
+  }
+  return _path;
+}
+function createStore(dir) {
+  const filePath = async (key) => (await path()).join(dir, `${key}.json`);
+  return {
+    async get(key) {
+      try {
+        const data = await (await fs()).readFile(await filePath(key), "utf-8");
+        return JSON.parse(data);
+      } catch {
+        return null;
+      }
+    },
+    async set(key, value) {
+      const p = await filePath(key);
+      const { mkdir, writeFile } = await fs();
+      const { dirname } = await path();
+      await mkdir(dirname(p), { recursive: true });
+      await writeFile(p, JSON.stringify(value, null, 2));
+    },
+    async update(key, updates) {
+      const p = await filePath(key);
+      const { readFile, mkdir, writeFile } = await fs();
+      const { dirname } = await path();
+      let existing;
+      try {
+        const data = await readFile(p, "utf-8");
+        existing = JSON.parse(data);
+      } catch {
+        throw new Error(`Not found: ${key}`);
+      }
+      const updated = { ...existing, ...updates };
+      await mkdir(dirname(p), { recursive: true });
+      await writeFile(p, JSON.stringify(updated, null, 2));
+      return updated;
+    }
+  };
+}
+async function readAllFromDir(dir) {
+  const { readdir, readFile } = await fs();
+  const { join } = await path();
+  let files;
+  try {
+    files = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const data = await readFile(join(dir, file), "utf-8");
+      result.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  return result;
+}
+function localStorage(opts) {
+  const dir = opts?.dir ?? ".agent";
+  const sessionStore = createStore(`${dir}/session`);
+  const messageStore = createStore(`${dir}/message`);
+  const partStore = createStore(`${dir}/part`);
+  const sandboxStore = createStore(`${dir}/sandbox`);
+  const setupStore = createStore(`${dir}/setup`);
+  const messageDir = `${dir}/message`;
+  const partDir = `${dir}/part`;
+  return {
+    "session.get": ({ id }) => sessionStore.get(id),
+    "session.set": ({ id, value }) => sessionStore.set(id, value),
+    "session.update": ({ id, updates }) => sessionStore.update(id, updates),
+    "message.get": ({ id }) => messageStore.get(id),
+    "message.set": ({ id, value }) => messageStore.set(id, value),
+    "message.update": ({ id, updates }) => messageStore.update(id, updates),
+    "message.listBySession": async ({ sessionId }) => {
+      const all = await readAllFromDir(messageDir);
+      return all.filter((m) => m.sessionId === sessionId);
+    },
+    "part.get": ({ id }) => partStore.get(id),
+    "part.set": ({ id, value }) => partStore.set(id, value),
+    "part.listBySession": async ({ sessionId }) => {
+      const all = await readAllFromDir(partDir);
+      return all.filter((p) => p.sessionId === sessionId);
+    },
+    "sandbox.get": ({ id }) => sandboxStore.get(id),
+    "sandbox.set": ({ id, value }) => sandboxStore.set(id, value),
+    "sandbox.update": ({ id, updates }) => sandboxStore.update(id, updates),
+    "setup.get": ({ id }) => setupStore.get(id),
+    "setup.set": ({ id, value }) => setupStore.set(id, value)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageStep,
+  localStorage,
+  toStorage
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/entry.ts", "../src/storage/adapter.ts", "../src/storage/bindings/local.ts"],
  "sourcesContent": ["export type { Storage, StorageCall, StorageHandlers, StorageStepFunction } from \"./adapter\";\nexport { StorageStep, toStorage } from \"./adapter\";\nexport { localStorage } from \"./bindings/local\";\nexport type { Message, Part, Sandbox, Session, Setup, SetupSnapshot } from \"./types\";\n", "import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from \"@workflow/serde\";\nimport type { Message, Part, Sandbox, Session, Setup } from \"./types\";\n\n// \u2500\u2500\u2500 StorageHandlers (public, flat) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type StorageHandlers = {\n  \"session.get\"(p: { id: string }): Promise<Session | null>;\n  \"session.set\"(p: { id: string; value: Session }): Promise<void>;\n  \"session.update\"(p: {\n    id: string;\n    updates: Partial<Session>;\n  }): Promise<Session>;\n\n  \"message.get\"(p: { id: string }): Promise<Message | null>;\n  \"message.set\"(p: { id: string; value: Message }): Promise<void>;\n  \"message.update\"(p: {\n    id: string;\n    updates: Partial<Message>;\n  }): Promise<Message>;\n  \"message.listBySession\"(p: { sessionId: string }): Promise<Message[]>;\n\n  \"part.get\"(p: { id: string }): Promise<Part | null>;\n  \"part.set\"(p: { id: string; value: Part }): Promise<void>;\n  \"part.listBySession\"(p: { sessionId: string }): Promise<Part[]>;\n\n  \"sandbox.get\"(p: { id: string }): Promise<Sandbox | null>;\n  \"sandbox.set\"(p: { id: string; value: Sandbox }): Promise<void>;\n  \"sandbox.update\"(p: {\n    id: string;\n    updates: Partial<Sandbox>;\n  }): Promise<Sandbox>;\n\n  \"setup.get\"(p: { id: string }): Promise<Setup | null>;\n  \"setup.set\"(p: {\n    id: string;\n    value: Setup;\n  }): Promise<void>;\n};\n\n// \u2500\u2500\u2500 StorageCall (derived from StorageHandlers) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type StorageCall = {\n  [K in keyof StorageHandlers]: { method: K } & Parameters<\n    StorageHandlers[K]\n  >[0];\n}[keyof StorageHandlers];\n\n// \u2500\u2500\u2500 StorageStep (serializable across workflow boundary) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport class StorageStep {\n  event: StorageCall;\n\n  constructor(event: StorageCall) {\n    this.event = event;\n  }\n\n  static [WORKFLOW_SERIALIZE](instance: StorageStep) {\n    return { event: instance.event };\n  }\n\n  static [WORKFLOW_DESERIALIZE](data: { event: StorageCall }) {\n    return new StorageStep(data.event);\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: safe dispatch \u2014 event.method selects the matching handler\n  on(handlers: StorageHandlers): Promise<any> {\n    // biome-ignore lint/suspicious/noExplicitAny: see above\n    return (handlers[this.event.method] as any)(this.event);\n  }\n}\n\n/**\n * A single function that handles all storage operations. Intended to be\n * marked with `\"use step\"` so that its body (and Node.js-dependent\n * imports like database clients) is extracted by the workflow bundler\n * and runs server-side.\n *\n * The step receives a `StorageStep` instance (serializable via\n * `@workflow/serde`) and should call `step.handle({ ... })` with a\n * `StorageHandlers` map.\n */\n// biome-ignore lint/suspicious/noExplicitAny: step function is a dispatcher; type safety is at the handlers level\nexport type StorageStepFunction = (store: StorageStep) => Promise<any>;\n\n// \u2500\u2500\u2500 Storage (internal, nested) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface Storage {\n  session: {\n    get(key: string): Promise<Session | null>;\n    set(key: string, value: Session): Promise<void>;\n    update(key: string, updates: Partial<Session>): Promise<Session>;\n  };\n  message: {\n    get(key: string): Promise<Message | null>;\n    set(key: string, value: Message): Promise<void>;\n    update(key: string, updates: Partial<Message>): Promise<Message>;\n    listBySession(sessionId: string): Promise<Message[]>;\n  };\n  part: {\n    get(key: string): Promise<Part | null>;\n    set(key: string, value: Part): Promise<void>;\n    listBySession(sessionId: string): Promise<Part[]>;\n  };\n  sandbox: {\n    get(key: string): Promise<Sandbox | null>;\n    set(key: string, value: Sandbox): Promise<void>;\n    update(key: string, updates: Partial<Sandbox>): Promise<Sandbox>;\n  };\n  setup: {\n    get(key: string): Promise<Setup | null>;\n    set(key: string, value: Setup): Promise<void>;\n  };\n}\n\nexport type StorageInput = StorageHandlers | StorageStepFunction;\n\nfunction isStepFunction(h: StorageInput): h is StorageStepFunction {\n  return typeof h === \"function\";\n}\n\nfunction fromStepFunction(fn: StorageStepFunction): Storage {\n  return {\n    session: {\n      get: (id) => fn(new StorageStep({ method: \"session.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"session.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"session.update\", id, updates })),\n    },\n    message: {\n      get: (id) => fn(new StorageStep({ method: \"message.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"message.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"message.update\", id, updates })),\n      listBySession: (sessionId) =>\n        fn(new StorageStep({ method: \"message.listBySession\", sessionId })),\n    },\n    part: {\n      get: (id) => fn(new StorageStep({ method: \"part.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"part.set\", id, value })),\n      listBySession: (sessionId) =>\n        fn(new StorageStep({ method: \"part.listBySession\", sessionId })),\n    },\n    sandbox: {\n      get: (id) => fn(new StorageStep({ method: \"sandbox.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"sandbox.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"sandbox.update\", id, updates })),\n    },\n    setup: {\n      get: (id) => fn(new StorageStep({ method: \"setup.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"setup.set\", id, value })),\n    },\n  };\n}\n\nfunction fromHandlers(h: StorageHandlers): Storage {\n  return {\n    session: {\n      get: (id) => h[\"session.get\"]({ id }),\n      set: (id, value) => h[\"session.set\"]({ id, value }),\n      update: (id, updates) => h[\"session.update\"]({ id, updates }),\n    },\n    message: {\n      get: (id) => h[\"message.get\"]({ id }),\n      set: (id, value) => h[\"message.set\"]({ id, value }),\n      update: (id, updates) => h[\"message.update\"]({ id, updates }),\n      listBySession: (sessionId) => h[\"message.listBySession\"]({ sessionId }),\n    },\n    part: {\n      get: (id) => h[\"part.get\"]({ id }),\n      set: (id, value) => h[\"part.set\"]({ id, value }),\n      listBySession: (sessionId) => h[\"part.listBySession\"]({ sessionId }),\n    },\n    sandbox: {\n      get: (id) => h[\"sandbox.get\"]({ id }),\n      set: (id, value) => h[\"sandbox.set\"]({ id, value }),\n      update: (id, updates) => h[\"sandbox.update\"]({ id, updates }),\n    },\n    setup: {\n      get: (id) => h[\"setup.get\"]({ id }),\n      set: (id, value) => h[\"setup.set\"]({ id, value }),\n    },\n  };\n}\n\nexport function toStorage(h: StorageInput): Storage {\n  return isStepFunction(h) ? fromStepFunction(h) : fromHandlers(h);\n}\n", "import type {\n  Message,\n  Part,\n  Sandbox,\n  Session,\n  Setup,\n} from \"../types\";\nimport type { StorageHandlers } from \"../adapter\";\n\nlet _fs: typeof import(\"node:fs/promises\") | undefined;\nlet _path: typeof import(\"node:path\") | undefined;\n\nasync function fs() {\n  if (!_fs) {\n    _fs = await import(\"node:fs/promises\");\n  }\n  return _fs;\n}\nasync function path() {\n  if (!_path) {\n    _path = await import(\"node:path\");\n  }\n  return _path;\n}\n\nfunction createStore<T>(dir: string) {\n  const filePath = async (key: string) =>\n    (await path()).join(dir, `${key}.json`);\n\n  return {\n    async get(key: string): Promise<T | null> {\n      try {\n        const data = await (await fs()).readFile(await filePath(key), \"utf-8\");\n        return JSON.parse(data) as T;\n      } catch {\n        return null;\n      }\n    },\n    async set(key: string, value: T): Promise<void> {\n      const p = await filePath(key);\n      const { mkdir, writeFile } = await fs();\n      const { dirname } = await path();\n      await mkdir(dirname(p), { recursive: true });\n      await writeFile(p, JSON.stringify(value, null, 2));\n    },\n    async update(key: string, updates: Partial<T>): Promise<T> {\n      const p = await filePath(key);\n      const { readFile, mkdir, writeFile } = await fs();\n      const { dirname } = await path();\n      let existing: T;\n      try {\n        const data = await readFile(p, \"utf-8\");\n        existing = JSON.parse(data) as T;\n      } catch {\n        throw new Error(`Not found: ${key}`);\n      }\n      const updated = { ...existing, ...updates };\n      await mkdir(dirname(p), { recursive: true });\n      await writeFile(p, JSON.stringify(updated, null, 2));\n      return updated;\n    },\n  };\n}\n\nasync function readAllFromDir<T>(dir: string): Promise<T[]> {\n  const { readdir, readFile } = await fs();\n  const { join } = await path();\n  let files: string[];\n  try {\n    files = await readdir(dir);\n  } catch {\n    return [];\n  }\n  const result: T[] = [];\n  for (const file of files) {\n    if (!file.endsWith(\".json\")) {\n      continue;\n    }\n    try {\n      const data = await readFile(join(dir, file), \"utf-8\");\n      result.push(JSON.parse(data) as T);\n    } catch {\n      // skip corrupt files\n    }\n  }\n  return result;\n}\n\nexport function localStorage(opts?: { dir?: string }): StorageHandlers {\n  const dir = opts?.dir ?? \".agent\";\n\n  const sessionStore = createStore<Session>(`${dir}/session`);\n  const messageStore = createStore<Message>(`${dir}/message`);\n  const partStore = createStore<Part>(`${dir}/part`);\n  const sandboxStore = createStore<Sandbox>(`${dir}/sandbox`);\n  const setupStore = createStore<Setup>(`${dir}/setup`);\n  const messageDir = `${dir}/message`;\n  const partDir = `${dir}/part`;\n\n  return {\n    \"session.get\": ({ id }) => sessionStore.get(id),\n    \"session.set\": ({ id, value }) => sessionStore.set(id, value),\n    \"session.update\": ({ id, updates }) => sessionStore.update(id, updates),\n\n    \"message.get\": ({ id }) => messageStore.get(id),\n    \"message.set\": ({ id, value }) => messageStore.set(id, value),\n    \"message.update\": ({ id, updates }) => messageStore.update(id, updates),\n    \"message.listBySession\": async ({ sessionId }) => {\n      const all = await readAllFromDir<Message>(messageDir);\n      return all.filter((m) => m.sessionId === sessionId);\n    },\n\n    \"part.get\": ({ id }) => partStore.get(id),\n    \"part.set\": ({ id, value }) => partStore.set(id, value),\n    \"part.listBySession\": async ({ sessionId }) => {\n      const all = await readAllFromDir<Part>(partDir);\n      return all.filter((p) => p.sessionId === sessionId);\n    },\n\n    \"sandbox.get\": ({ id }) => sandboxStore.get(id),\n    \"sandbox.set\": ({ id, value }) => sandboxStore.set(id, value),\n    \"sandbox.update\": ({ id, updates }) => sandboxStore.update(id, updates),\n\n    \"setup.get\": ({ id }) => setupStore.get(id),\n    \"setup.set\": ({ id, value }) => setupStore.set(id, value),\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAAyD;AAiDlD,IAAM,cAAN,MAAM,aAAY;AAAA,EACvB;AAAA,EAEA,YAAY,OAAoB;AAC9B,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,QAAQ,+BAAkB,EAAE,UAAuB;AACjD,WAAO,EAAE,OAAO,SAAS,MAAM;AAAA,EACjC;AAAA,EAEA,QAAQ,iCAAoB,EAAE,MAA8B;AAC1D,WAAO,IAAI,aAAY,KAAK,KAAK;AAAA,EACnC;AAAA;AAAA,EAGA,GAAG,UAAyC;AAE1C,WAAQ,SAAS,KAAK,MAAM,MAAM,EAAU,KAAK,KAAK;AAAA,EACxD;AACF;AA+CA,SAAS,eAAe,GAA2C;AACjE,SAAO,OAAO,MAAM;AACtB;AAEA,SAAS,iBAAiB,IAAkC;AAC1D,SAAO;AAAA,IACL,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,GAAG,CAAC,CAAC;AAAA,MAC9D,KAAK,CAAC,IAAI,UACR,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,IAAI,MAAM,CAAC,CAAC;AAAA,MAC1D,QAAQ,CAAC,IAAI,YACX,GAAG,IAAI,YAAY,EAAE,QAAQ,kBAAkB,IAAI,QAAQ,CAAC,CAAC;AAAA,IACjE;AAAA,IACA,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,GAAG,CAAC,CAAC;AAAA,MAC9D,KAAK,CAAC,IAAI,UACR,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,IAAI,MAAM,CAAC,CAAC;AAAA,MAC1D,QAAQ,CAAC,IAAI,YACX,GAAG,IAAI,YAAY,EAAE,QAAQ,kBAAkB,IAAI,QAAQ,CAAC,CAAC;AAAA,MAC/D,eAAe,CAAC,cACd,GAAG,IAAI,YAAY,EAAE,QAAQ,yBAAyB,UAAU,CAAC,CAAC;AAAA,IACtE;AAAA,IACA,MAAM;AAAA,MACJ,KAAK,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,QAAQ,YAAY,GAAG,CAAC,CAAC;AAAA,MAC3D,KAAK,CAAC,IAAI,UACR,GAAG,IAAI,YAAY,EAAE,QAAQ,YAAY,IAAI,MAAM,CAAC,CAAC;AAAA,MACvD,eAAe,CAAC,cACd,GAAG,IAAI,YAAY,EAAE,QAAQ,sBAAsB,UAAU,CAAC,CAAC;AAAA,IACnE;AAAA,IACA,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,GAAG,CAAC,CAAC;AAAA,MAC9D,KAAK,CAAC,IAAI,UACR,GAAG,IAAI,YAAY,EAAE,QAAQ,eAAe,IAAI,MAAM,CAAC,CAAC;AAAA,MAC1D,QAAQ,CAAC,IAAI,YACX,GAAG,IAAI,YAAY,EAAE,QAAQ,kBAAkB,IAAI,QAAQ,CAAC,CAAC;AAAA,IACjE;AAAA,IACA,OAAO;AAAA,MACL,KAAK,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,QAAQ,aAAa,GAAG,CAAC,CAAC;AAAA,MAC5D,KAAK,CAAC,IAAI,UACR,GAAG,IAAI,YAAY,EAAE,QAAQ,aAAa,IAAI,MAAM,CAAC,CAAC;AAAA,IAC1D;AAAA,EACF;AACF;AAEA,SAAS,aAAa,GAA6B;AACjD,SAAO;AAAA,IACL,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,GAAG,CAAC;AAAA,MACpC,KAAK,CAAC,IAAI,UAAU,EAAE,aAAa,EAAE,EAAE,IAAI,MAAM,CAAC;AAAA,MAClD,QAAQ,CAAC,IAAI,YAAY,EAAE,gBAAgB,EAAE,EAAE,IAAI,QAAQ,CAAC;AAAA,IAC9D;AAAA,IACA,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,GAAG,CAAC;AAAA,MACpC,KAAK,CAAC,IAAI,UAAU,EAAE,aAAa,EAAE,EAAE,IAAI,MAAM,CAAC;AAAA,MAClD,QAAQ,CAAC,IAAI,YAAY,EAAE,gBAAgB,EAAE,EAAE,IAAI,QAAQ,CAAC;AAAA,MAC5D,eAAe,CAAC,cAAc,EAAE,uBAAuB,EAAE,EAAE,UAAU,CAAC;AAAA,IACxE;AAAA,IACA,MAAM;AAAA,MACJ,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,CAAC;AAAA,MACjC,KAAK,CAAC,IAAI,UAAU,EAAE,UAAU,EAAE,EAAE,IAAI,MAAM,CAAC;AAAA,MAC/C,eAAe,CAAC,cAAc,EAAE,oBAAoB,EAAE,EAAE,UAAU,CAAC;AAAA,IACrE;AAAA,IACA,SAAS;AAAA,MACP,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,GAAG,CAAC;AAAA,MACpC,KAAK,CAAC,IAAI,UAAU,EAAE,aAAa,EAAE,EAAE,IAAI,MAAM,CAAC;AAAA,MAClD,QAAQ,CAAC,IAAI,YAAY,EAAE,gBAAgB,EAAE,EAAE,IAAI,QAAQ,CAAC;AAAA,IAC9D;AAAA,IACA,OAAO;AAAA,MACL,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,GAAG,CAAC;AAAA,MAClC,KAAK,CAAC,IAAI,UAAU,EAAE,WAAW,EAAE,EAAE,IAAI,MAAM,CAAC;AAAA,IAClD;AAAA,EACF;AACF;AAEO,SAAS,UAAU,GAA0B;AAClD,SAAO,eAAe,CAAC,IAAI,iBAAiB,CAAC,IAAI,aAAa,CAAC;AACjE;;;ACvLA,IAAI;AACJ,IAAI;AAEJ,eAAe,KAAK;AAClB,MAAI,CAAC,KAAK;AACR,UAAM,MAAM,OAAO,aAAkB;AAAA,EACvC;AACA,SAAO;AACT;AACA,eAAe,OAAO;AACpB,MAAI,CAAC,OAAO;AACV,YAAQ,MAAM,OAAO,MAAW;AAAA,EAClC;AACA,SAAO;AACT;AAEA,SAAS,YAAe,KAAa;AACnC,QAAM,WAAW,OAAO,SACrB,MAAM,KAAK,GAAG,KAAK,KAAK,GAAG,GAAG,OAAO;AAExC,SAAO;AAAA,IACL,MAAM,IAAI,KAAgC;AACxC,UAAI;AACF,cAAM,OAAO,OAAO,MAAM,GAAG,GAAG,SAAS,MAAM,SAAS,GAAG,GAAG,OAAO;AACrE,eAAO,KAAK,MAAM,IAAI;AAAA,MACxB,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,MAAM,IAAI,KAAa,OAAyB;AAC9C,YAAM,IAAI,MAAM,SAAS,GAAG;AAC5B,YAAM,EAAE,OAAO,UAAU,IAAI,MAAM,GAAG;AACtC,YAAM,EAAE,QAAQ,IAAI,MAAM,KAAK;AAC/B,YAAM,MAAM,QAAQ,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC;AAC3C,YAAM,UAAU,GAAG,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AAAA,IACnD;AAAA,IACA,MAAM,OAAO,KAAa,SAAiC;AACzD,YAAM,IAAI,MAAM,SAAS,GAAG;AAC5B,YAAM,EAAE,UAAU,OAAO,UAAU,IAAI,MAAM,GAAG;AAChD,YAAM,EAAE,QAAQ,IAAI,MAAM,KAAK;AAC/B,UAAI;AACJ,UAAI;AACF,cAAM,OAAO,MAAM,SAAS,GAAG,OAAO;AACtC,mBAAW,KAAK,MAAM,IAAI;AAAA,MAC5B,QAAQ;AACN,cAAM,IAAI,MAAM,cAAc,GAAG,EAAE;AAAA,MACrC;AACA,YAAM,UAAU,EAAE,GAAG,UAAU,GAAG,QAAQ;AAC1C,YAAM,MAAM,QAAQ,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC;AAC3C,YAAM,UAAU,GAAG,KAAK,UAAU,SAAS,MAAM,CAAC,CAAC;AACnD,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,eAAe,eAAkB,KAA2B;AAC1D,QAAM,EAAE,SAAS,SAAS,IAAI,MAAM,GAAG;AACvC,QAAM,EAAE,KAAK,IAAI,MAAM,KAAK;AAC5B,MAAI;AACJ,MAAI;AACF,YAAQ,MAAM,QAAQ,GAAG;AAAA,EAC3B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,QAAM,SAAc,CAAC;AACrB,aAAW,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAK,SAAS,OAAO,GAAG;AAC3B;AAAA,IACF;AACA,QAAI;AACF,YAAM,OAAO,MAAM,SAAS,KAAK,KAAK,IAAI,GAAG,OAAO;AACpD,aAAO,KAAK,KAAK,MAAM,IAAI,CAAM;AAAA,IACnC,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,aAAa,MAA0C;AACrE,QAAM,MAAM,MAAM,OAAO;AAEzB,QAAM,eAAe,YAAqB,GAAG,GAAG,UAAU;AAC1D,QAAM,eAAe,YAAqB,GAAG,GAAG,UAAU;AAC1D,QAAM,YAAY,YAAkB,GAAG,GAAG,OAAO;AACjD,QAAM,eAAe,YAAqB,GAAG,GAAG,UAAU;AAC1D,QAAM,aAAa,YAAmB,GAAG,GAAG,QAAQ;AACpD,QAAM,aAAa,GAAG,GAAG;AACzB,QAAM,UAAU,GAAG,GAAG;AAEtB,SAAO;AAAA,IACL,eAAe,CAAC,EAAE,GAAG,MAAM,aAAa,IAAI,EAAE;AAAA,IAC9C,eAAe,CAAC,EAAE,IAAI,MAAM,MAAM,aAAa,IAAI,IAAI,KAAK;AAAA,IAC5D,kBAAkB,CAAC,EAAE,IAAI,QAAQ,MAAM,aAAa,OAAO,IAAI,OAAO;AAAA,IAEtE,eAAe,CAAC,EAAE,GAAG,MAAM,aAAa,IAAI,EAAE;AAAA,IAC9C,eAAe,CAAC,EAAE,IAAI,MAAM,MAAM,aAAa,IAAI,IAAI,KAAK;AAAA,IAC5D,kBAAkB,CAAC,EAAE,IAAI,QAAQ,MAAM,aAAa,OAAO,IAAI,OAAO;AAAA,IACtE,yBAAyB,OAAO,EAAE,UAAU,MAAM;AAChD,YAAM,MAAM,MAAM,eAAwB,UAAU;AACpD,aAAO,IAAI,OAAO,CAAC,MAAM,EAAE,cAAc,SAAS;AAAA,IACpD;AAAA,IAEA,YAAY,CAAC,EAAE,GAAG,MAAM,UAAU,IAAI,EAAE;AAAA,IACxC,YAAY,CAAC,EAAE,IAAI,MAAM,MAAM,UAAU,IAAI,IAAI,KAAK;AAAA,IACtD,sBAAsB,OAAO,EAAE,UAAU,MAAM;AAC7C,YAAM,MAAM,MAAM,eAAqB,OAAO;AAC9C,aAAO,IAAI,OAAO,CAAC,MAAM,EAAE,cAAc,SAAS;AAAA,IACpD;AAAA,IAEA,eAAe,CAAC,EAAE,GAAG,MAAM,aAAa,IAAI,EAAE;AAAA,IAC9C,eAAe,CAAC,EAAE,IAAI,MAAM,MAAM,aAAa,IAAI,IAAI,KAAK;AAAA,IAC5D,kBAAkB,CAAC,EAAE,IAAI,QAAQ,MAAM,aAAa,OAAO,IAAI,OAAO;AAAA,IAEtE,aAAa,CAAC,EAAE,GAAG,MAAM,WAAW,IAAI,EAAE;AAAA,IAC1C,aAAa,CAAC,EAAE,IAAI,MAAM,MAAM,WAAW,IAAI,IAAI,KAAK;AAAA,EAC1D;AACF;",
  "names": []
}


package/dist/storage.mjs

@@ -0,0 +1,12 @@
+import {
+  StorageStep,
+  localStorage,
+  toStorage
+} from "./chunk-DOD4MC5D.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  StorageStep,
+  localStorage,
+  toStorage
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K