@sandboxxjs/state 0.0.1

package/dist/index.js

@@ -0,0 +1,1091 @@
+// src/errors.ts
+class StateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StateError";
+  }
+}
+
+class FileSystemError extends StateError {
+  constructor(message) {
+    super(message);
+    this.name = "FileSystemError";
+  }
+}
+
+// src/StateFS.ts
+class StateFS {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  async read(path) {
+    const result = await this.sandbox.shell(`cat "${path}"`);
+    if (!result.success) {
+      throw new FileSystemError(`Failed to read file: ${path}`);
+    }
+    return result.stdout;
+  }
+  async write(path, data) {
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    if (dir) {
+      await this.sandbox.shell(`mkdir -p "${dir}"`);
+    }
+    const result = await this.sandbox.shell(`cat > "${path}" << 'SANDBOX_EOF'
+${data}
+SANDBOX_EOF`);
+    if (!result.success) {
+      throw new FileSystemError(`Failed to write file: ${path}`);
+    }
+  }
+  async exists(path) {
+    const result = await this.sandbox.shell(`test -e "${path}" && echo "yes" || echo "no"`);
+    return result.stdout.trim() === "yes";
+  }
+  async delete(path) {
+    await this.sandbox.shell(`rm -rf "${path}"`);
+  }
+  async list(path) {
+    const result = await this.sandbox.shell(`ls -1 "${path}" 2>/dev/null`);
+    if (!result.success || !result.stdout.trim()) {
+      return [];
+    }
+    return result.stdout.trim().split(`
+`).filter(Boolean);
+  }
+}
+// src/StateEnv.ts
+class StateEnv {
+  vars;
+  constructor(initial) {
+    this.vars = new Map(Object.entries(initial ?? {}));
+  }
+  get(key) {
+    return this.vars.get(key);
+  }
+  set(key, value) {
+    this.vars.set(key, value);
+  }
+  has(key) {
+    return this.vars.has(key);
+  }
+  delete(key) {
+    this.vars.delete(key);
+  }
+  keys() {
+    return [...this.vars.keys()];
+  }
+  all() {
+    return Object.fromEntries(this.vars);
+  }
+}
+// src/StateStorage.ts
+class StateStorage {
+  data;
+  constructor(initial) {
+    this.data = new Map(Object.entries(initial ?? {}));
+  }
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.data.set(key, value);
+  }
+  removeItem(key) {
+    this.data.delete(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+  keys() {
+    return [...this.data.keys()];
+  }
+}
+// src/StateLog.ts
+class StateLog {
+  entries = [];
+  fs = {
+    write: (path, data) => {
+      this.entries.push({ op: "fs.write", args: { path, data } });
+      return this;
+    },
+    delete: (path) => {
+      this.entries.push({ op: "fs.delete", args: { path } });
+      return this;
+    }
+  };
+  env = {
+    set: (key, value) => {
+      this.entries.push({ op: "env.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "env.delete", args: { key } });
+      return this;
+    }
+  };
+  storage = {
+    set: (key, value) => {
+      this.entries.push({ op: "storage.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "storage.delete", args: { key } });
+      return this;
+    },
+    clear: () => {
+      this.entries.push({ op: "storage.clear", args: {} });
+      return this;
+    }
+  };
+  recordEntry(op, args) {
+    this.entries.push({ op, args });
+    return this;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  toJSON() {
+    return JSON.stringify(this.entries);
+  }
+  static fromJSON(json) {
+    const log = new StateLog;
+    log.entries = JSON.parse(json);
+    return log;
+  }
+  static fromEntries(entries) {
+    const log = new StateLog;
+    log.entries = [...entries];
+    return log;
+  }
+  compact() {
+    const fsState = new Map;
+    const envState = new Map;
+    const storageState = new Map;
+    let storageClear = null;
+    for (const entry of this.entries) {
+      const { op, args } = entry;
+      if (op === "fs.write") {
+        fsState.set(args.path, entry);
+      } else if (op === "fs.delete") {
+        fsState.set(args.path, entry);
+      } else if (op === "env.set") {
+        envState.set(args.key, entry);
+      } else if (op === "env.delete") {
+        envState.set(args.key, entry);
+      } else if (op === "storage.set") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.delete") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.clear") {
+        storageClear = entry;
+        storageState.clear();
+      }
+    }
+    const compactedEntries = [];
+    for (const entry of fsState.values()) {
+      compactedEntries.push(entry);
+    }
+    for (const entry of envState.values()) {
+      compactedEntries.push(entry);
+    }
+    if (storageClear) {
+      compactedEntries.push(storageClear);
+    }
+    for (const entry of storageState.values()) {
+      compactedEntries.push(entry);
+    }
+    return StateLog.fromEntries(compactedEntries);
+  }
+}
+function buildStateLog() {
+  return new StateLog;
+}
+function loadStateLog(json) {
+  return StateLog.fromJSON(json);
+}
+// src/opRegistry.ts
+var opRegistry = {
+  "fs.write": {
+    namespace: "fs",
+    method: "write",
+    args: ["path", "data"],
+    replay: async (target, args) => {
+      await target.fs.write(args.path, args.data);
+    }
+  },
+  "fs.delete": {
+    namespace: "fs",
+    method: "delete",
+    args: ["path"],
+    replay: async (target, args) => {
+      await target.fs.delete(args.path);
+    }
+  },
+  "env.set": {
+    namespace: "env",
+    method: "set",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.env.set(args.key, args.value);
+    }
+  },
+  "env.delete": {
+    namespace: "env",
+    method: "delete",
+    args: ["key"],
+    replay: (target, args) => {
+      target.env.delete(args.key);
+    }
+  },
+  "storage.set": {
+    namespace: "storage",
+    method: "setItem",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.storage.setItem(args.key, args.value);
+    }
+  },
+  "storage.delete": {
+    namespace: "storage",
+    method: "removeItem",
+    args: ["key"],
+    replay: (target, args) => {
+      target.storage.removeItem(args.key);
+    }
+  },
+  "storage.clear": {
+    namespace: "storage",
+    method: "clear",
+    args: [],
+    replay: (target) => {
+      target.storage.clear();
+    }
+  }
+};
+function findOp(namespace, method) {
+  for (const [op, config] of Object.entries(opRegistry)) {
+    if (config.namespace === namespace && config.method === method) {
+      return op;
+    }
+  }
+  return;
+}
+function argsToEntry(op, methodArgs) {
+  const config = opRegistry[op];
+  if (!config)
+    return {};
+  const entry = {};
+  config.args.forEach((name, index) => {
+    entry[name] = methodArgs[index];
+  });
+  return entry;
+}
+
+// src/replayStateLog.ts
+async function replayStateLog(log, target) {
+  for (const entry of log.getEntries()) {
+    const config = opRegistry[entry.op];
+    if (config) {
+      await config.replay(target, entry.args);
+    }
+  }
+}
+// src/createState.ts
+function createRecordingProxy(target, namespace, log) {
+  return new Proxy(target, {
+    get(obj, prop) {
+      const value = obj[prop];
+      if (typeof value !== "function") {
+        return value;
+      }
+      const method = prop;
+      const op = findOp(namespace, method);
+      if (!op) {
+        return value.bind(obj);
+      }
+      return (...args) => {
+        const result = value.apply(obj, args);
+        const record = () => {
+          const entryArgs = argsToEntry(op, args);
+          log.recordEntry(op, entryArgs);
+        };
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            record();
+            return res;
+          });
+        } else {
+          record();
+          return result;
+        }
+      };
+    }
+  });
+}
+function createState(options) {
+  const { sandbox, env, enableRecord } = options;
+  const baseFS = new StateFS(sandbox);
+  const baseEnv = new StateEnv(env);
+  const baseStorage = new StateStorage;
+  if (!enableRecord) {
+    return {
+      fs: baseFS,
+      env: baseEnv,
+      storage: baseStorage
+    };
+  }
+  const stateLog = buildStateLog();
+  return {
+    fs: createRecordingProxy(baseFS, "fs", stateLog),
+    env: createRecordingProxy(baseEnv, "env", stateLog),
+    storage: createRecordingProxy(baseStorage, "storage", stateLog),
+    stateLog
+  };
+}
+// ../../node_modules/.bun/resourcexjs@0.4.0/node_modules/resourcexjs/dist/index.js
+import { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile as readFile2, writeFile as writeFile2, readdir as readdir2, access as access2, unlink, mkdir as mkdir2, stat, rm as rm2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ParseError extends ResourceXError {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = "ParseError";
+  }
+}
+
+class TransportError extends ResourceXError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ResourceXError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+function parseARP(url) {
+  if (!url.startsWith("arp:")) {
+    throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
+  }
+  const content = url.substring(4);
+  const separatorIndex = content.indexOf("://");
+  if (separatorIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: missing "://"`, url);
+  }
+  const typePart = content.substring(0, separatorIndex);
+  const location = content.substring(separatorIndex + 3);
+  const colonIndex = typePart.indexOf(":");
+  if (colonIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
+  }
+  const semantic = typePart.substring(0, colonIndex);
+  const transport = typePart.substring(colonIndex + 1);
+  if (!semantic) {
+    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
+  }
+  if (!transport) {
+    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
+  }
+  if (!location) {
+    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
+  }
+  return { semantic, transport, location };
+}
+
+class HttpTransportHandler {
+  name;
+  protocol;
+  capabilities = {
+    canRead: true,
+    canWrite: false,
+    canList: false,
+    canDelete: false,
+    canStat: false
+  };
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.name = protocol;
+  }
+  async read(location) {
+    const url = `${this.protocol}://${location}`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.name);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.name, {
+        cause: error
+      });
+    }
+  }
+}
+var httpsHandler = new HttpTransportHandler("https");
+var httpHandler = new HttpTransportHandler("http");
+
+class FileTransportHandler {
+  name = "file";
+  capabilities = {
+    canRead: true,
+    canWrite: true,
+    canList: true,
+    canDelete: true,
+    canStat: true
+  };
+  resolvePath(location) {
+    return resolve(process.cwd(), location);
+  }
+  async read(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      return await readFile(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async write(location, content) {
+    const filePath = this.resolvePath(location);
+    try {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, content);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async list(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      return await readdir(dirPath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async mkdir(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      await mkdir(dirPath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async exists(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      const stats = await fsStat(filePath);
+      return {
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        isDirectory: stats.isDirectory()
+      };
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async delete(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await rm(filePath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+}
+var fileHandler = new FileTransportHandler;
+function deepracticeHandler(config = {}) {
+  const parentDir = config.parentDir || homedir();
+  const baseDir = join(parentDir, ".deepractice");
+  function resolvePath(location) {
+    return join(baseDir, location);
+  }
+  return {
+    name: "deepractice",
+    capabilities: {
+      canRead: true,
+      canWrite: true,
+      canList: true,
+      canDelete: true,
+      canStat: true
+    },
+    async read(location) {
+      const fullPath = resolvePath(location);
+      try {
+        return await readFile2(fullPath);
+      } catch (error) {
+        throw new TransportError(`Failed to read from deepractice: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async write(location, content) {
+      const fullPath = resolvePath(location);
+      try {
+        await mkdir2(join(fullPath, ".."), { recursive: true });
+        await writeFile2(fullPath, content);
+      } catch (error) {
+        throw new TransportError(`Failed to write to deepractice: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async list(location) {
+      const fullPath = resolvePath(location);
+      try {
+        return await readdir2(fullPath);
+      } catch (error) {
+        throw new TransportError(`Failed to list deepractice directory: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async exists(location) {
+      const fullPath = resolvePath(location);
+      try {
+        await access2(fullPath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async stat(location) {
+      const fullPath = resolvePath(location);
+      try {
+        const stats = await stat(fullPath);
+        return {
+          size: stats.size,
+          isDirectory: stats.isDirectory(),
+          modifiedAt: stats.mtime
+        };
+      } catch (error) {
+        throw new TransportError(`Failed to stat deepractice resource: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async delete(location) {
+      const fullPath = resolvePath(location);
+      try {
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+          await rm2(fullPath, { recursive: true, force: true });
+        } else {
+          await unlink(fullPath);
+        }
+      } catch (error) {
+        throw new TransportError(`Failed to delete from deepractice: ${error.message}`, "deepractice", { cause: error });
+      }
+    }
+  };
+}
+var handlers = new Map([
+  ["https", httpsHandler],
+  ["http", httpHandler],
+  ["file", fileHandler]
+]);
+function getTransportHandler(name) {
+  const handler = handlers.get(name);
+  if (!handler) {
+    throw new TransportError(`Unsupported transport type: ${name}`, name);
+  }
+  return handler;
+}
+function registerTransportHandler(handler) {
+  handlers.set(handler.name, handler);
+}
+
+class TextSemanticHandler {
+  name = "text";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const text = buffer.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = Buffer.from(data, "utf-8");
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var textHandler = new TextSemanticHandler;
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.from(data);
+  }
+  throw new SemanticError(`Unsupported binary input type`, "binary");
+}
+
+class BinarySemanticHandler {
+  name = "binary";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "binary",
+      content: buffer,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = toBuffer(data);
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var binaryHandler = new BinarySemanticHandler;
+var handlers2 = new Map([
+  ["text", textHandler],
+  ["binary", binaryHandler]
+]);
+function getSemanticHandler(name) {
+  const handler = handlers2.get(name);
+  if (!handler) {
+    throw new SemanticError(`Unsupported semantic type: ${name}`, name);
+  }
+  return handler;
+}
+function registerSemanticHandler(handler) {
+  handlers2.set(handler.name, handler);
+}
+function createContext(url, semantic, transport, location) {
+  return {
+    url,
+    semantic,
+    transport,
+    location,
+    timestamp: new Date
+  };
+}
+async function resolve2(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  return semantic.resolve(transport, parsed.location, context);
+}
+async function deposit(url, data) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  if (!semantic.deposit) {
+    throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, parsed.semantic);
+  }
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  await semantic.deposit(transport, parsed.location, data, context);
+}
+async function resourceExists(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  if (semantic.exists) {
+    return semantic.exists(transport, parsed.location, context);
+  }
+  if (transport.exists) {
+    return transport.exists(parsed.location);
+  }
+  try {
+    await transport.read(parsed.location);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resourceDelete(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  if (semantic.delete) {
+    return semantic.delete(transport, parsed.location, context);
+  }
+  if (!transport.delete) {
+    throw new SemanticError(`Neither semantic "${semantic.name}" nor transport "${transport.name}" supports delete operation`, parsed.semantic);
+  }
+  await transport.delete(parsed.location);
+}
+function createResourceRegistry() {
+  const registry = new Map;
+  return {
+    register(definition) {
+      if (!/^[a-z][a-z0-9-]*$/.test(definition.name)) {
+        throw new ParseError(`Invalid resource name: "${definition.name}". Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens.`, definition.name);
+      }
+      getSemanticHandler(definition.semantic);
+      getTransportHandler(definition.transport);
+      registry.set(definition.name, definition);
+    },
+    get(name) {
+      return registry.get(name);
+    },
+    has(name) {
+      return registry.has(name);
+    },
+    clear() {
+      registry.clear();
+    }
+  };
+}
+
+class ResourceX {
+  timeout;
+  alias;
+  resourceRegistry;
+  constructor(config = {}) {
+    this.timeout = config.timeout;
+    this.alias = config.alias || "@";
+    this.resourceRegistry = createResourceRegistry();
+    if (config.transports) {
+      for (const handler of config.transports) {
+        registerTransportHandler(handler);
+      }
+    }
+    if (config.semantics) {
+      for (const handler of config.semantics) {
+        registerSemanticHandler(handler);
+      }
+    }
+    if (config.resources) {
+      for (const resource of config.resources) {
+        this.resourceRegistry.register(resource);
+      }
+    }
+  }
+  parseURL(url) {
+    let content;
+    if (url.startsWith("arp:")) {
+      content = url.substring(4);
+    } else if (url.startsWith(this.alias)) {
+      content = url.substring(this.alias.length);
+    } else {
+      throw new ParseError(`Invalid URL prefix: must start with "arp:" or "${this.alias}"`, url);
+    }
+    const separatorIndex = content.indexOf("://");
+    if (separatorIndex === -1) {
+      throw new ParseError(`Invalid URL format: missing "://"`, url);
+    }
+    const beforeSeparator = content.substring(0, separatorIndex);
+    const location = content.substring(separatorIndex + 3);
+    const colonCount = (beforeSeparator.match(/:/g) || []).length;
+    if (colonCount === 1) {
+      const parts = beforeSeparator.split(":");
+      if (parts.length !== 2) {
+        throw new ParseError(`Invalid ARP URL format`, url);
+      }
+      const [semantic, transport] = parts;
+      if (!semantic || !transport || !location) {
+        throw new ParseError(`Invalid ARP URL: semantic, transport, and location are required`, url);
+      }
+      const arpUrl = `arp:${semantic}:${transport}://${location}`;
+      return {
+        arpUrl,
+        parsed: { semantic, transport, location }
+      };
+    }
+    if (colonCount === 0) {
+      const name = beforeSeparator;
+      if (!name || !location) {
+        throw new ParseError(`Invalid Resource URL: name and location are required`, url);
+      }
+      const definition = this.resourceRegistry.get(name);
+      if (!definition) {
+        throw new ParseError(`Unknown resource: "${name}"`, url);
+      }
+      const fullLocation = definition.basePath ? join2(definition.basePath, location) : location;
+      const arpUrl = `arp:${definition.semantic}:${definition.transport}://${fullLocation}`;
+      return {
+        arpUrl,
+        parsed: {
+          semantic: definition.semantic,
+          transport: definition.transport,
+          location: fullLocation
+        }
+      };
+    }
+    throw new ParseError(`Invalid URL format: unexpected colon count in "${beforeSeparator}"`, url);
+  }
+  parse(url) {
+    return this.parseURL(url).parsed;
+  }
+  async resolve(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resolve2(arpUrl);
+  }
+  async deposit(url, data) {
+    const { arpUrl } = this.parseURL(url);
+    return deposit(arpUrl, data);
+  }
+  async exists(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resourceExists(arpUrl);
+  }
+  async delete(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resourceDelete(arpUrl);
+  }
+}
+function createResourceX(config) {
+  return new ResourceX(config);
+}
+
+// src/StateStore.ts
+class MemoryStateStore {
+  logs = new Map;
+  blobs = new Map;
+  async saveLog(key, data) {
+    this.logs.set(key, data);
+  }
+  async loadLog(key) {
+    return this.logs.get(key) ?? null;
+  }
+  async deleteLog(key) {
+    this.logs.delete(key);
+  }
+  async listLogs() {
+    return [...this.logs.keys()];
+  }
+  async saveBlob(ref, data) {
+    this.blobs.set(ref, data);
+  }
+  async loadBlob(ref) {
+    return this.blobs.get(ref) ?? null;
+  }
+  async deleteBlob(ref) {
+    this.blobs.delete(ref);
+  }
+}
+
+class ResourceXStateStore {
+  rx;
+  constructor() {
+    this.rx = createResourceX({
+      transports: [deepracticeHandler()]
+    });
+  }
+  logUrl(key) {
+    return `@text:deepractice://sandbox/logs/${key}.json`;
+  }
+  blobUrl(ref) {
+    return `@binary:deepractice://sandbox/blobs/${ref}`;
+  }
+  async saveLog(key, data) {
+    await this.rx.deposit(this.logUrl(key), data);
+  }
+  async loadLog(key) {
+    try {
+      const exists = await this.rx.exists(this.logUrl(key));
+      if (!exists)
+        return null;
+      const resource = await this.rx.resolve(this.logUrl(key));
+      return resource.content;
+    } catch {
+      return null;
+    }
+  }
+  async deleteLog(key) {
+    try {
+      const exists = await this.rx.exists(this.logUrl(key));
+      if (exists) {
+        await this.rx.delete(this.logUrl(key));
+      }
+    } catch {}
+  }
+  async listLogs() {
+    return [];
+  }
+  async saveBlob(ref, data) {
+    await this.rx.deposit(this.blobUrl(ref), data);
+  }
+  async loadBlob(ref) {
+    try {
+      const exists = await this.rx.exists(this.blobUrl(ref));
+      if (!exists)
+        return null;
+      const resource = await this.rx.resolve(this.blobUrl(ref));
+      return resource.content;
+    } catch {
+      return null;
+    }
+  }
+  async deleteBlob(ref) {
+    try {
+      const exists = await this.rx.exists(this.blobUrl(ref));
+      if (exists) {
+        await this.rx.delete(this.blobUrl(ref));
+      }
+    } catch {}
+  }
+}
+function createStateStore(options) {
+  if (options.type === "memory") {
+    return new MemoryStateStore;
+  }
+  if (options.type === "resourcex") {
+    return new ResourceXStateStore;
+  }
+  throw new Error(`StateStore type "${options.type}" not implemented`);
+}
+// src/StateAssets.ts
+import { createHash } from "crypto";
+function generateRef(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256-${hash}`;
+}
+
+class StateAssetsImpl {
+  sandbox;
+  store;
+  uploadedPaths = new Set;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.store = options.store;
+  }
+  async uploadBuffer(data, remotePath) {
+    const ref = generateRef(data);
+    await this.sandbox.upload(data, remotePath);
+    await this.store.saveBlob(ref, data);
+    this.uploadedPaths.add(remotePath);
+    return ref;
+  }
+  async downloadBuffer(remotePath, options) {
+    const data = await this.sandbox.download(remotePath);
+    if (options?.persist) {
+      const ref = generateRef(data);
+      await this.store.saveBlob(ref, data);
+      return ref;
+    }
+    return data;
+  }
+  list() {
+    return [...this.uploadedPaths];
+  }
+}
+function createStateAssets(options) {
+  return new StateAssetsImpl(options);
+}
+export {
+  replayStateLog,
+  loadStateLog,
+  createStateStore,
+  createStateAssets,
+  createState,
+  buildStateLog,
+  StateStorage,
+  StateFS,
+  StateError,
+  StateEnv,
+  FileSystemError
+};
+
+//# debugId=0AA8C1D6A9548D7A64756E2164756E21