@poe-platform/safe-js 0.1.730 → 0.1.731

package/dist/safe-js/chunks/{chunk-EG3QWREA.js → chunk-RULU2F5J.js}

@@ -8,7 +8,7 @@ import {
   numericTypedArrayConstructors,
   parseModule,
   tokenize
-} from "./chunk-Y5EZYHU6.js";
+} from "./chunk-QKO4FATZ.js";
 
 // packages/safe-js/src/lint/rules/AS001.ts
 function AS001(source, options = {}) {
@@ -11177,4 +11177,4 @@ function hasOnlyRegexLiteralDiagnostics(diagnostics) {
 export {
   lint
 };
-//# sourceMappingURL=chunk-EG3QWREA.js.map
+//# sourceMappingURL=chunk-RULU2F5J.js.map

package/dist/safe-js/chunks/chunk-UQPYTZOZ.js

@@ -0,0 +1,72 @@
+// packages/safe-js/src/platform/node.ts
+import * as nodeUtil from "node:util";
+import * as nativeFsPromises from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { MessageChannel, MessagePort, receiveMessageOnPort } from "node:worker_threads";
+import { setImmediate } from "node:timers/promises";
+import { inspect } from "node:util";
+import { formatWithOptions } from "node:util";
+import { constants } from "node:fs";
+var nativeClone = structuredClone;
+var sharedByteLength = Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
+var postMessage = MessagePort.prototype.postMessage;
+var closePort = MessagePort.prototype.close;
+var probe = new SharedArrayBuffer(1);
+var nativeSharesStorage = false;
+try {
+  const copy = nativeClone(probe);
+  Reflect.apply(sharedByteLength, copy, []);
+  new Uint8Array(copy)[0] = 1;
+  nativeSharesStorage = copy !== probe && new Uint8Array(probe)[0] === 1;
+} catch {
+}
+var cloneSharedBufferWrapper = nativeSharesStorage ? nativeClone : (value) => {
+  Reflect.apply(sharedByteLength, value, []);
+  const { port1, port2 } = new MessageChannel();
+  try {
+    Reflect.apply(postMessage, port1, [value]);
+    const copy = receiveMessageOnPort(port2)?.message;
+    Reflect.apply(sharedByteLength, copy, []);
+    if (copy === value) throw new TypeError("Shared storage requires a distinct wrapper.");
+    return copy;
+  } finally {
+    Reflect.apply(closePort, port1, []);
+    Reflect.apply(closePort, port2, []);
+  }
+};
+function createHostCallbackContext() {
+  return new AsyncLocalStorage();
+}
+var accessDeniedSystemError = readSystemError("EACCES");
+function readSystemError(code) {
+  const fallback = /* @__PURE__ */ new Map([
+    [process.platform === "win32" ? -4092 : -13, ["EACCES", "permission denied"]]
+  ]);
+  const systemErrors = nodeUtil.getSystemErrorMap?.() ?? fallback;
+  for (const [errno, [name, message]] of systemErrors) {
+    if (name === code) {
+      return [errno, message];
+    }
+  }
+  throw new Error(`node does not define the ${code} system error.`);
+}
+var types2 = nodeUtil.types;
+var hostFs = nativeFsPromises;
+var hostCwd = process.cwd.bind(process);
+var hostPlatform = process.platform;
+
+export {
+  AsyncLocalStorage,
+  cloneSharedBufferWrapper,
+  createHostCallbackContext,
+  accessDeniedSystemError,
+  types2 as types,
+  hostFs,
+  hostCwd,
+  hostPlatform,
+  setImmediate,
+  inspect,
+  formatWithOptions,
+  constants
+};
+//# sourceMappingURL=chunk-UQPYTZOZ.js.map

package/dist/safe-js/chunks/chunk-UQPYTZOZ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/platform/node.ts"],
+  "sourcesContent": ["import * as nodeUtil from \"node:util\";\nimport * as nativeFsPromises from \"node:fs/promises\";\nimport { AsyncLocalStorage } from \"node:async_hooks\";\nimport { MessageChannel, MessagePort, receiveMessageOnPort } from \"node:worker_threads\";\nimport type { HostCallbackContext } from \"../interp/host-callback-context.js\";\n\nconst nativeClone = structuredClone;\nconst sharedByteLength = Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, \"byteLength\")!.get!;\nconst postMessage = MessagePort.prototype.postMessage;\nconst closePort = MessagePort.prototype.close;\n\n// Probe private storage once: a broken native clone must never copy a guest's\n// potentially large allocation before selecting the shared-wrapper fallback.\nconst probe = new SharedArrayBuffer(1);\nlet nativeSharesStorage = false;\ntry {\n  const copy = nativeClone(probe);\n  Reflect.apply(sharedByteLength, copy, []);\n  new Uint8Array(copy)[0] = 1;\n  nativeSharesStorage = copy !== probe && new Uint8Array(probe)[0] === 1;\n} catch {\n  // Some supported hosts do not implement shared-buffer structured cloning.\n}\n\nexport const cloneSharedBufferWrapper: (value: SharedArrayBuffer) => SharedArrayBuffer = nativeSharesStorage\n  ? nativeClone\n  : (value) => {\n    Reflect.apply(sharedByteLength, value, []);\n    const { port1, port2 } = new MessageChannel();\n    try {\n      Reflect.apply(postMessage, port1, [value]);\n      const copy: unknown = receiveMessageOnPort(port2)?.message;\n      Reflect.apply(sharedByteLength, copy, []);\n      if (copy === value) throw new TypeError(\"Shared storage requires a distinct wrapper.\");\n      return copy as SharedArrayBuffer;\n    } finally {\n      Reflect.apply(closePort, port1, []);\n      Reflect.apply(closePort, port2, []);\n    }\n  };\n\nexport function createHostCallbackContext(): HostCallbackContext {\n  return new AsyncLocalStorage<boolean>();\n}\n\nexport const accessDeniedSystemError: readonly [number, string] = readSystemError(\"EACCES\");\n\nfunction readSystemError(code: string): [number, string] {\n  const fallback = new Map<number, [string, string]>([\n    [process.platform === \"win32\" ? -4092 : -13, [\"EACCES\", \"permission denied\"]]\n  ]);\n  const systemErrors = nodeUtil.getSystemErrorMap?.() ?? fallback;\n  for (const [errno, [name, message]] of systemErrors) {\n    if (name === code) {\n      return [errno, message];\n    }\n  }\n\n  throw new Error(`node does not define the ${code} system error.`);\n}\n\nexport { AsyncLocalStorage };\nexport const types = nodeUtil.types;\nexport { setImmediate as yieldToHost } from \"node:timers/promises\";\nexport { inspect } from \"node:util\";\nexport { formatWithOptions } from \"node:util\";\nexport { constants as fsConstants } from \"node:fs\";\nexport const hostFs = nativeFsPromises;\nexport const hostCwd = process.cwd.bind(process);\nexport const hostPlatform = process.platform;\n"],
+  "mappings": ";AAAA,YAAY,cAAc;AAC1B,YAAY,sBAAsB;AAClC,SAAS,yBAAyB;AAClC,SAAS,gBAAgB,aAAa,4BAA4B;AA4DlE,SAAyB,oBAAmB;AAC5C,SAAS,eAAe;AACxB,SAAS,yBAAyB;AAClC,SAAsB,iBAAmB;AA5DzC,IAAM,cAAc;AACpB,IAAM,mBAAmB,OAAO,yBAAyB,kBAAkB,WAAW,YAAY,EAAG;AACrG,IAAM,cAAc,YAAY,UAAU;AAC1C,IAAM,YAAY,YAAY,UAAU;AAIxC,IAAM,QAAQ,IAAI,kBAAkB,CAAC;AACrC,IAAI,sBAAsB;AAC1B,IAAI;AACF,QAAM,OAAO,YAAY,KAAK;AAC9B,UAAQ,MAAM,kBAAkB,MAAM,CAAC,CAAC;AACxC,MAAI,WAAW,IAAI,EAAE,CAAC,IAAI;AAC1B,wBAAsB,SAAS,SAAS,IAAI,WAAW,KAAK,EAAE,CAAC,MAAM;AACvE,QAAQ;AAER;AAEO,IAAM,2BAA4E,sBACrF,cACA,CAAC,UAAU;AACX,UAAQ,MAAM,kBAAkB,OAAO,CAAC,CAAC;AACzC,QAAM,EAAE,OAAO,MAAM,IAAI,IAAI,eAAe;AAC5C,MAAI;AACF,YAAQ,MAAM,aAAa,OAAO,CAAC,KAAK,CAAC;AACzC,UAAM,OAAgB,qBAAqB,KAAK,GAAG;AACnD,YAAQ,MAAM,kBAAkB,MAAM,CAAC,CAAC;AACxC,QAAI,SAAS,MAAO,OAAM,IAAI,UAAU,6CAA6C;AACrF,WAAO;AAAA,EACT,UAAE;AACA,YAAQ,MAAM,WAAW,OAAO,CAAC,CAAC;AAClC,YAAQ,MAAM,WAAW,OAAO,CAAC,CAAC;AAAA,EACpC;AACF;AAEK,SAAS,4BAAiD;AAC/D,SAAO,IAAI,kBAA2B;AACxC;AAEO,IAAM,0BAAqD,gBAAgB,QAAQ;AAE1F,SAAS,gBAAgB,MAAgC;AACvD,QAAM,WAAW,oBAAI,IAA8B;AAAA,IACjD,CAAC,QAAQ,aAAa,UAAU,QAAQ,KAAK,CAAC,UAAU,mBAAmB,CAAC;AAAA,EAC9E,CAAC;AACD,QAAM,eAAwB,6BAAoB,KAAK;AACvD,aAAW,CAAC,OAAO,CAAC,MAAM,OAAO,CAAC,KAAK,cAAc;AACnD,QAAI,SAAS,MAAM;AACjB,aAAO,CAAC,OAAO,OAAO;AAAA,IACxB;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,4BAA4B,IAAI,gBAAgB;AAClE;AAGO,IAAMA,SAAiB;AAKvB,IAAM,SAAS;AACf,IAAM,UAAU,QAAQ,IAAI,KAAK,OAAO;AACxC,IAAM,eAAe,QAAQ;",
+  "names": ["types"]
+}

package/dist/safe-js/chunks/{chunk-LRSWTDIV.js → chunk-W4SWUHCQ.js}

@@ -1,13 +1,16 @@
+import {
+  fsCodec
+} from "./chunk-GVKXZW53.js";
 import {
   hasOwnErrorCode
-} from "./chunk-SJZWSPWD.js";
+} from "./chunk-2GVBG23M.js";
 import {
   hashSource,
   validateMigrationJournal,
   validateMigrationReconciliation,
   validateMigrationSemantics,
   validateSnapshotMigration
-} from "./chunk-EA7AHM2X.js";
+} from "./chunk-PSVV3IG2.js";
 import {
   DUMP_FORMAT_VERSION,
   EXECUTION_SEMANTICS,
@@ -17,15 +20,20 @@ import {
   serializeSafeJSSnapshot,
   validateDumpEnvelope,
   validateSnapshotData
-} from "./chunk-S5YDMMM3.js";
+} from "./chunk-MDIWQFYU.js";
 import {
   parseModule
-} from "./chunk-Y5EZYHU6.js";
+} from "./chunk-QKO4FATZ.js";
+import {
+  paths_default
+} from "./chunk-YUQFFRUF.js";
+import {
+  hostCwd,
+  hostFs
+} from "./chunk-UQPYTZOZ.js";
 
 // packages/safe-js/src/migration-file.ts
-import { randomUUID } from "node:crypto";
-import { link, open, readFile, unlink } from "node:fs/promises";
-import path from "node:path";
+import { createFsBridge } from "@poe-platform/safe-fs/core";
 
 // packages/safe-js/src/migrate.ts
 import { sha256 } from "@noble/hashes/sha2.js";
@@ -104,11 +112,14 @@ function canonicalData(value) {
 
 // packages/safe-js/src/migration-file.ts
 async function migrateSnapshotFile(options) {
-  const cwd = options.cwd ?? process.cwd();
+  const adapter = options.adapter;
+  const io = adapter ? createFsBridge(adapter, { codec: fsCodec }) : hostFs;
+  const readFile = io.readFile.bind(io);
+  const cwd = options.cwd ?? hostCwd();
   const resolvePath = (value, label) => {
     if (typeof value !== "string" || value.trim().length === 0)
       throw new TypeError(`Migration requires ${label}.`);
-    return path.resolve(cwd, value);
+    return paths_default.resolve(cwd, value);
   };
   const snapshotPath = resolvePath(options.snapshotPath, "a snapshot path");
   const sourcePath = resolvePath(options.sourcePath, "--from <original.ajs>");
@@ -120,7 +131,7 @@ async function migrateSnapshotFile(options) {
   const targetSourcePath = options.inspect ? void 0 : resolvePath(options.targetSourcePath, "--to <continuation.ajs>");
   const planPath = options.inspect ? void 0 : resolvePath(options.planPath, "--plan <migration.json>");
   for (const filepath of [sourcePath, targetSourcePath]) {
-    if (filepath !== void 0 && ![".ajs", ".safejs"].includes(path.extname(filepath)))
+    if (filepath !== void 0 && ![".ajs", ".safejs"].includes(paths_default.extname(filepath)))
       throw new TypeError(
         "Migration source paths must name executable .ajs or .safejs files, not harness Markdown."
       );
@@ -141,22 +152,43 @@ async function migrateSnapshotFile(options) {
   });
   const contents = serializeSafeJSSnapshot(migrated);
   if (!options.dryRun) {
-    const temporaryPath = path.join(
-      path.dirname(outputPath),
-      `.safejs-migration-${randomUUID()}.tmp`
+    const temporaryPath = paths_default.join(
+      paths_default.dirname(outputPath),
+      `.safejs-migration-${globalThis.crypto.randomUUID()}.tmp`
     );
     let created = false;
     try {
-      const handle = await open(temporaryPath, "wx", 384);
-      created = true;
-      try {
-        await handle.writeFile(contents, "utf8");
-        await handle.sync();
-      } finally {
-        await handle.close();
+      if (adapter) {
+        if (!adapter.open || !adapter.link || !adapter.unlink)
+          throw new TypeError("Migration filesystem must support retained writes, hard links and unlink.");
+        const handle = await adapter.open(temporaryPath, { access: "write", creation: "exclusive", mode: 384 });
+        created = true;
+        try {
+          const bytes = new TextEncoder().encode(contents);
+          let position = 0;
+          while (position < bytes.byteLength) {
+            const written = await handle.write(bytes.subarray(position), position);
+            if (!Number.isSafeInteger(written) || written <= 0 || written > bytes.byteLength - position)
+              throw new Error("Migration filesystem returned an invalid write count.");
+            position += written;
+          }
+          await handle.sync(false);
+        } finally {
+          await handle.close();
+        }
+      } else {
+        const handle = await hostFs.open(temporaryPath, "wx", 384);
+        created = true;
+        try {
+          await handle.writeFile(contents, "utf8");
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
       }
       try {
-        await link(temporaryPath, outputPath);
+        if (adapter) await adapter.link(temporaryPath, outputPath);
+        else await hostFs.link(temporaryPath, outputPath);
       } catch (error) {
         if (hasOwnErrorCode(error, "EEXIST"))
           throw Object.assign(
@@ -169,7 +201,10 @@ async function migrateSnapshotFile(options) {
         throw error;
       }
     } finally {
-      if (created) await unlink(temporaryPath);
+      if (created) {
+        if (adapter) await adapter.unlink(temporaryPath);
+        else await hostFs.unlink(temporaryPath);
+      }
     }
   }
   return { inspection, outputPath, dryRun: options.dryRun === true };
@@ -180,4 +215,4 @@ export {
   migrateSnapshot,
   migrateSnapshotFile
 };
-//# sourceMappingURL=chunk-LRSWTDIV.js.map
+//# sourceMappingURL=chunk-W4SWUHCQ.js.map

package/dist/safe-js/chunks/chunk-W4SWUHCQ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/migration-file.ts", "../../src/migrate.ts"],
+  "sourcesContent": ["import { hostFs, hostCwd } from \"#safe-js-platform\";\nimport {createFsBridge, type FileSystem} from \"@poe-code/safe-fs/core\";\nimport {fsCodec} from \"./modules/fs-codec.js\";\nimport path from \"./modules/paths.js\";\nimport { hasOwnErrorCode } from \"./error-codes.js\";\n\nimport {\n  inspectSnapshotMigration,\n  migrateSnapshot,\n  type SnapshotMigrationOptions\n} from \"./migrate.js\";\nimport type { SafeJSSnapshot } from \"./restore.js\";\nimport { serializeSafeJSSnapshot } from \"./snapshot/dump-format.js\";\n\nexport type SnapshotMigrationFileOptions = {\n  adapter?: FileSystem;\n  snapshotPath: string;\n  sourcePath: string;\n  targetSourcePath?: string;\n  planPath?: string;\n  outputPath?: string;\n  inspect?: boolean;\n  dryRun?: boolean;\n  cwd?: string;\n};\n\nexport async function migrateSnapshotFile(options: SnapshotMigrationFileOptions) {\n  const adapter = options.adapter;\n  const io = adapter ? createFsBridge(adapter, {codec: fsCodec}) : hostFs;\n  const readFile = io.readFile.bind(io);\n  const cwd = options.cwd ?? hostCwd();\n  const resolvePath = (value: string | undefined, label: string) => {\n    if (typeof value !== \"string\" || value.trim().length === 0)\n      throw new TypeError(`Migration requires ${label}.`);\n    return path.resolve(cwd, value);\n  };\n  const snapshotPath = resolvePath(options.snapshotPath, \"a snapshot path\");\n  const sourcePath = resolvePath(options.sourcePath, \"--from <original.ajs>\");\n  if (\n    options.inspect &&\n    [options.targetSourcePath, options.planPath, options.outputPath].some(\n      (value) => value !== undefined\n    )\n  )\n    throw new TypeError(\"Migration --inspect cannot be combined with --to, --plan, or --output.\");\n  const outputPath = options.inspect\n    ? undefined\n    : resolvePath(options.outputPath, \"--output <new-checkpoint.json>\");\n  const targetSourcePath = options.inspect\n    ? undefined\n    : resolvePath(options.targetSourcePath, \"--to <continuation.ajs>\");\n  const planPath = options.inspect\n    ? undefined\n    : resolvePath(options.planPath, \"--plan <migration.json>\");\n  for (const filepath of [sourcePath, targetSourcePath]) {\n    if (filepath !== undefined && ![\".ajs\", \".safejs\"].includes(path.extname(filepath)))\n      throw new TypeError(\n        \"Migration source paths must name executable .ajs or .safejs files, not harness Markdown.\"\n      );\n  }\n  const snapshot: SafeJSSnapshot = JSON.parse(await readFile(snapshotPath, \"utf8\"));\n  const source = await readFile(sourcePath, \"utf8\");\n  const inspection = inspectSnapshotMigration(snapshot, { source });\n  if (options.inspect) return { inspection };\n  const plan: unknown = JSON.parse(await readFile(planPath!, \"utf8\"));\n  if (\n    plan === null ||\n    typeof plan !== \"object\" ||\n    !Object.hasOwn(plan, \"state\") ||\n    !Object.hasOwn(plan, \"reconciliation\")\n  )\n    throw new TypeError(\"Migration plan requires explicit state and reconciliation fields.\");\n  const targetSource = await readFile(targetSourcePath!, \"utf8\");\n  const migrated = migrateSnapshot(snapshot, {\n    source,\n    targetSource,\n    state: (plan as SnapshotMigrationOptions).state,\n    reconciliation: (plan as SnapshotMigrationOptions).reconciliation\n  });\n  const contents = serializeSafeJSSnapshot(migrated);\n  if (!options.dryRun) {\n    const temporaryPath = path.join(\n      path.dirname(outputPath!),\n      `.safejs-migration-${globalThis.crypto.randomUUID()}.tmp`\n    );\n    let created = false;\n    try {\n      if (adapter) {\n        if (!adapter.open || !adapter.link || !adapter.unlink)\n          throw new TypeError(\"Migration filesystem must support retained writes, hard links and unlink.\");\n        const handle = await adapter.open(temporaryPath, {access: \"write\", creation: \"exclusive\", mode: 0o600});\n        created = true;\n        try {\n          const bytes = new TextEncoder().encode(contents);\n          let position = 0;\n          while (position < bytes.byteLength) {\n            const written = await handle.write(bytes.subarray(position), position);\n            if (!Number.isSafeInteger(written) || written <= 0 || written > bytes.byteLength - position)\n              throw new Error(\"Migration filesystem returned an invalid write count.\");\n            position += written;\n          }\n          await handle.sync(false);\n        } finally {await handle.close();}\n      } else {\n        const handle = await hostFs.open(temporaryPath, \"wx\", 0o600);\n        created = true;\n        try {\n          await handle.writeFile(contents, \"utf8\");\n          await handle.sync();\n        } finally {\n          await handle.close();\n        }\n      }\n      try {\n        if (adapter) await adapter.link!(temporaryPath, outputPath!);\n        else await hostFs.link(temporaryPath, outputPath!);\n      } catch (error) {\n        if (hasOwnErrorCode(error, \"EEXIST\"))\n          throw Object.assign(\n            new Error(\n              `Migration output already exists: ${JSON.stringify(outputPath)}. Choose a new output path; existing files are never overwritten.`,\n              { cause: error }\n            ),\n            { code: \"EEXIST\" }\n          );\n        throw error;\n      }\n    } finally {\n      if (created) {\n        if (adapter) await adapter.unlink!(temporaryPath);\n        else await hostFs.unlink(temporaryPath);\n      }\n    }\n  }\n  return { inspection, outputPath, dryRun: options.dryRun === true };\n}\n", "import { sha256 } from \"@noble/hashes/sha2.js\";\nimport { bytesToHex } from \"@noble/hashes/utils.js\";\n\nimport { assertSnapshotInactive } from \"./interp/running-state.js\";\nimport { deepCopyToSandbox } from \"./interp/values.js\";\nimport { hashSource } from \"./parse/hash.js\";\nimport { parseModule } from \"./parse/parser.js\";\nimport type { SafeJSSnapshot } from \"./restore.js\";\nimport { DUMP_FORMAT_VERSION, EXECUTION_SEMANTICS } from \"./snapshot/dump-format.js\";\nimport {\n  validateMigrationJournal,\n  validateMigrationReconciliation,\n  validateMigrationSemantics,\n  validateSnapshotMigration,\n  type SnapshotMigration,\n  type SnapshotMigrationReconciliation\n} from \"./snapshot/migration.js\";\nimport { encodeReplayData } from \"./snapshot/replay-data.js\";\nimport { validateDumpEnvelope, validateSnapshotData } from \"./snapshot/validation.js\";\n\nexport type {\n  SnapshotMigration,\n  SnapshotMigrationReconciliation,\n  SnapshotMigrationResolution\n} from \"./snapshot/migration.js\";\n\nexport type SnapshotMigrationOptions = {\n  source: string;\n  targetSource: string;\n  state: unknown;\n  reconciliation: SnapshotMigrationReconciliation;\n};\n\nexport function inspectSnapshotMigration(snapshot: SafeJSSnapshot, options: { source: string }) {\n  assertSnapshotInactive(snapshot);\n  validateSnapshotData(snapshot);\n  validateDumpEnvelope(snapshot);\n  validateMigrationSemantics(snapshot.executionSemantics);\n  const sourceHash = hashSource(\n    options.source,\n    undefined,\n    snapshot.executionSemantics === \"jobs-v8\" || snapshot.executionSemantics === EXECUTION_SEMANTICS\n  );\n  if (snapshot.sourceHash !== sourceHash)\n    throw new TypeError(\n      `Migration requires the original executable source (checkpoint hash ${snapshot.sourceHash}, supplied ${sourceHash}). Preserve the checkpoint; do not replace its hash.`\n    );\n  validateSnapshotMigration(snapshot.migration, sourceHash);\n  const replay = validateMigrationJournal(sourceHash, snapshot.replay, snapshot.hostCalls);\n  return {\n    checkpointDigest: bytesToHex(sha256(new TextEncoder().encode(canonicalData(snapshot)))),\n    sourceHash,\n    executionSemantics: snapshot.executionSemantics,\n    calls: replay.calls,\n    unresolvedCalls: replay.calls.filter(\n      (call) => ![\"settled\", \"consumed\"].includes(call.lifecycle)\n    )\n  };\n}\n\nexport function migrateSnapshot(\n  snapshot: SafeJSSnapshot,\n  options: SnapshotMigrationOptions\n): SafeJSSnapshot & { migration: SnapshotMigration } {\n  if (!Object.hasOwn(options, \"state\"))\n    throw new TypeError(\"Migration requires explicit application state.\");\n  const inspection = inspectSnapshotMigration(snapshot, { source: options.source });\n  parseModule(options.targetSource);\n  const targetSourceHash = hashSource(options.targetSource);\n  validateMigrationReconciliation(\n    options.reconciliation,\n    inspection.checkpointDigest,\n    inspection.calls\n  );\n  const state = encodeReplayData(deepCopyToSandbox(options.state));\n  const previous = snapshot.migration as SnapshotMigration | undefined;\n  const migration: SnapshotMigration = {\n    version: 1,\n    state,\n    history: [\n      ...structuredClone(previous?.history ?? []),\n      {\n        sourceHash: inspection.sourceHash,\n        targetSourceHash,\n        executionSemantics: inspection.executionSemantics,\n        replay: { version: 1, calls: inspection.calls },\n        reconciliation: structuredClone(options.reconciliation)\n      }\n    ]\n  };\n  validateSnapshotMigration(migration, targetSourceHash);\n  return {\n    version: DUMP_FORMAT_VERSION,\n    executionSemantics: EXECUTION_SEMANTICS,\n    sourceHash: targetSourceHash,\n    bindings: {},\n    replay: { version: 1, calls: [] },\n    migration\n  };\n}\n\nfunction canonicalData(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(canonicalData).join(\",\")}]`;\n  if (value !== null && typeof value === \"object\")\n    return `{${Object.keys(value)\n      .sort()\n      .map(\n        (key) => `${JSON.stringify(key)}:${canonicalData((value as Record<string, unknown>)[key])}`\n      )\n      .join(\",\")}}`;\n  return JSON.stringify(value);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/safe-js/chunks/{chunk-W3IY6FKO.js → chunk-WS2FJBH6.js}

@@ -1,6 +1,6 @@
 import {
   deepCopyToSandbox
-} from "./chunk-S5YDMMM3.js";
+} from "./chunk-MDIWQFYU.js";
 
 // packages/safe-js/src/modules/harness.ts
 function makeHarnessModule(frontmatter, meta) {
@@ -52,4 +52,4 @@ ${prompt}`;
 export {
   makeHarnessModule
 };
-//# sourceMappingURL=chunk-W3IY6FKO.js.map
+//# sourceMappingURL=chunk-WS2FJBH6.js.map

package/dist/safe-js/chunks/{chunk-MVLDRXWS.js → chunk-X3CKAZQ4.js}

@@ -1,10 +1,10 @@
 import {
   SnapshotNotReadyError,
   serializeSafeJSSnapshot
-} from "./chunk-S5YDMMM3.js";
+} from "./chunk-MDIWQFYU.js";
 import {
   SandboxError
-} from "./chunk-Y5EZYHU6.js";
+} from "./chunk-QKO4FATZ.js";
 
 // packages/safe-js/src/snapshot/dump.ts
 var RUN_DUMP_CONTROLLER = /* @__PURE__ */ Symbol("SafeJS.run-dump-controller");
@@ -195,4 +195,4 @@ export {
   dumpCurrent,
   serializeRunSnapshot
 };
-//# sourceMappingURL=chunk-MVLDRXWS.js.map
+//# sourceMappingURL=chunk-X3CKAZQ4.js.map

package/dist/safe-js/chunks/chunk-YUQFFRUF.js

@@ -0,0 +1,26 @@
+import {
+  hostCwd
+} from "./chunk-UQPYTZOZ.js";
+
+// packages/safe-js/src/modules/paths.ts
+import { basename, dirname, extname, isAbsolutePath, joinPath, relativePath, resolvePath } from "@poe-platform/safe-fs/core";
+var sep = "/";
+function resolve(...paths) {
+  return resolvePath(hostCwd(), ...paths);
+}
+function relative(from, to) {
+  return relativePath(resolve(from), resolve(to));
+}
+var paths_default = { basename, dirname, extname, isAbsolute: isAbsolutePath, join: joinPath, relative, resolve, sep };
+
+export {
+  basename,
+  dirname,
+  extname,
+  isAbsolutePath,
+  sep,
+  resolve,
+  relative,
+  paths_default
+};
+//# sourceMappingURL=chunk-YUQFFRUF.js.map

package/dist/safe-js/chunks/chunk-YUQFFRUF.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/paths.ts"],
+  "sourcesContent": ["import { basename, dirname, extname, isAbsolutePath, joinPath, relativePath, resolvePath } from \"@poe-code/safe-fs/core\";\nimport { hostCwd } from \"#safe-js-platform\";\nexport { basename, dirname, extname, isAbsolutePath as isAbsolute, joinPath as join };\nexport const sep = \"/\";\nexport function resolve(...paths: string[]): string { return resolvePath(hostCwd(), ...paths); }\nexport function relative(from: string, to: string): string { return relativePath(resolve(from), resolve(to)); }\nexport default { basename, dirname, extname, isAbsolute: isAbsolutePath, join: joinPath, relative, resolve, sep };\n\nexport function pathToFileURL(path: string): URL {\n  return new URL(\"file://\" + resolve(path).split(\"/\").map(segment => encodeURIComponent(segment)).join(\"/\"));\n}\n"],
+  "mappings": ";;;;;AAAA,SAAS,UAAU,SAAS,SAAS,gBAAgB,UAAU,cAAc,mBAAmB;AAGzF,IAAM,MAAM;AACZ,SAAS,WAAW,OAAyB;AAAE,SAAO,YAAY,QAAQ,GAAG,GAAG,KAAK;AAAG;AACxF,SAAS,SAAS,MAAc,IAAoB;AAAE,SAAO,aAAa,QAAQ,IAAI,GAAG,QAAQ,EAAE,CAAC;AAAG;AAC9G,IAAO,gBAAQ,EAAE,UAAU,SAAS,SAAS,YAAY,gBAAgB,MAAM,UAAU,UAAU,SAAS,IAAI;",
+  "names": []
+}

package/dist/safe-js/chunks/{cli-runtime-WSVW5DNT.js → cli-runtime-NUEFUM64.js}

@@ -12,40 +12,57 @@ import {
   parseFsConfig,
   resolveFsConfig,
   splitFrontmatter
-} from "./chunk-MFCEBCGV.js";
+} from "./chunk-KETIFEA7.js";
 import {
   parseMcpConfig
-} from "./chunk-MW2QLYVN.js";
+} from "./chunk-MGHE7ZFI.js";
 import {
   lint
-} from "./chunk-EG3QWREA.js";
+} from "./chunk-RULU2F5J.js";
 import {
   createBrokenPipeState,
   createSafeOutputStream,
   withBrokenPipeGuard
-} from "./chunk-OZLTLIHX.js";
+} from "./chunk-G6WTEIJJ.js";
+import {
+  createRootedSourceResolver
+} from "./chunk-F6CV74HU.js";
 import "./chunk-U7ZNMTSQ.js";
+import {
+  fsCodec
+} from "./chunk-GVKXZW53.js";
 import {
   hasOwnErrorCode
-} from "./chunk-SJZWSPWD.js";
+} from "./chunk-2GVBG23M.js";
 import {
   Budget,
   SandboxError,
   parseModule,
   parseSourceModule,
   replaceErrorStack
-} from "./chunk-Y5EZYHU6.js";
+} from "./chunk-QKO4FATZ.js";
+import {
+  dirname,
+  extname,
+  paths_default
+} from "./chunk-YUQFFRUF.js";
+import {
+  formatWithOptions,
+  hostFs
+} from "./chunk-UQPYTZOZ.js";
 import "./chunk-4YIDX44G.js";
 
 // packages/safe-js/src/cli-runtime.ts
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import path, { dirname, extname } from "node:path";
-import { formatWithOptions } from "node:util";
+import { createFsBridge } from "@poe-platform/safe-fs/core";
 var EXIT_RUNTIME = 1;
 var EXIT_PARSE = 2;
 var EXIT_BUDGET = 3;
 var EXIT_SIGINT = 130;
 async function runCli(argv, options, usage) {
+  const io = options.adapter ? createFsBridge(options.adapter, { codec: fsCodec }) : hostFs;
+  const readFile = io.readFile.bind(io);
+  const writeFile = io.writeFile.bind(io);
+  const stat = io.stat.bind(io);
   const brokenPipe = createBrokenPipeState();
   const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
   const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
@@ -55,10 +72,11 @@ async function runCli(argv, options, usage) {
     async () => {
       try {
         if (argv[0] === "migrate") {
-          const { migrateSnapshotFile } = await import("./migration-file-3SWGNDS2.js");
+          const { migrateSnapshotFile } = await import("./migration-file-KRXQYI3Q.js");
           const result = await migrateSnapshotFile({
             ...parseMigrationArgs(argv.slice(1)),
-            cwd: options.cwd ?? readCurrentWorkingDirectory()
+            cwd: options.cwd ?? readCurrentWorkingDirectory(),
+            adapter: options.adapter
           });
           stdout.write(`${JSON.stringify(result, null, 2)}
 `);
@@ -71,10 +89,10 @@ async function runCli(argv, options, usage) {
           return brokenPipe.closed ? 0 : EXIT_RUNTIME;
         }
         const cwd = options.cwd ?? readCurrentWorkingDirectory();
-        const filepath = path.resolve(cwd, parsed.filepath);
+        const filepath = paths_default.resolve(cwd, parsed.filepath);
         const configuredFs = parsed.fsConfig === void 0 ? void 0 : await resolveFsConfig(
           parseFsConfig(
-            await (options.readFile ?? readFile)(path.resolve(cwd, parsed.fsConfig), "utf8")
+            await (options.readFile ?? readFile)(paths_default.resolve(cwd, parsed.fsConfig), "utf8")
           )
         );
         await assertHarnessFile({
@@ -85,6 +103,7 @@ async function runCli(argv, options, usage) {
         return await runScriptFile(filepath, parsed, {
           cwd,
           configuredFs,
+          adapter: options.adapter,
           env: options.env,
           mcp: options.mcp,
           modulesFor: options.modulesFor,
@@ -272,12 +291,12 @@ async function assertHarnessFile(input) {
 }
 async function runScriptFile(filepath, parsed, options) {
   const [{ run }, { restore }, { dump, dumpCurrent }, { createLintModulesFromRuntimeRegistry }, { makeFsModule }, { makeMcpModule }] = await Promise.all([
-    import("./run-ESJHEXCE.js"),
-    import("./restore-FCTWPLU3.js"),
-    import("./dump-UNYK24YS.js"),
-    import("./runtime-modules-7V6BWCRK.js"),
-    import("./fs-AOV77RQC.js"),
-    import("./mcp-E2AJXEQM.js")
+    import("./run-ZSFX66RN.js"),
+    import("./restore-GEO7VN2R.js"),
+    import("./dump-RGRC3CG3.js"),
+    import("./runtime-modules-A3U2DKFL.js"),
+    import("../modules/fs.js"),
+    import("./mcp-S672263Q.js")
   ]);
   const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
   const meta = {
@@ -286,7 +305,7 @@ async function runScriptFile(filepath, parsed, options) {
     version: loaded.frontmatter.version
   };
   const runtime = await createRuntime(loaded.frontmatter, meta, {
-    fs: parsed.fs ? { root: path.resolve(options.cwd, parsed.fsRoot ?? dirname(filepath)) } : void 0,
+    fs: parsed.fs ? { root: paths_default.resolve(options.cwd, parsed.fsRoot ?? dirname(filepath)), ...options.adapter ? { adapter: options.adapter } : {} } : void 0,
     modulesFor: options.modulesFor,
     stderr: options.stderr,
     stdout: options.stdout
@@ -303,7 +322,7 @@ async function runScriptFile(filepath, parsed, options) {
   if (parsed.envConfig !== void 0) {
     if (env !== void 0)
       throw new TypeError("Pass environment options or --env-config, not both.");
-    const configPath = path.resolve(options.cwd, parsed.envConfig);
+    const configPath = paths_default.resolve(options.cwd, parsed.envConfig);
     env = parseEnvConfig(await options.readFile(configPath, "utf8"));
   }
   if (env !== void 0) {
@@ -318,7 +337,7 @@ async function runScriptFile(filepath, parsed, options) {
   let mcp = options.mcp;
   if (parsed.mcpConfig !== void 0) {
     if (mcp !== void 0) throw new TypeError("Pass MCP options or --mcp-config, not both.");
-    const configPath = path.resolve(options.cwd, parsed.mcpConfig);
+    const configPath = paths_default.resolve(options.cwd, parsed.mcpConfig);
     mcp = parseMcpConfig(await options.readFile(configPath, "utf8"), dirname(configPath));
   }
   if (mcp !== void 0) {
@@ -399,14 +418,16 @@ ${formatDiagnostics(lintWarnings)}
       signalSnapshotWrite = writeCurrentSnapshot(runPromise, parsed.snapshotPath, options, dumpCurrent);
     }
   };
+  const sourceResolver = parsed.sourceRoot !== void 0 && options.adapter !== void 0 ? await createRootedSourceResolver(paths_default.resolve(options.cwd, parsed.sourceRoot), options.adapter) : void 0;
   options.process.on("SIGINT", onSigint);
   try {
     runPromise = run(executableSource, {
       budget: parsed.maxSteps === void 0 && parsed.dataSize === void 0 ? void 0 : new Budget({ dataSize: parsed.dataSize, maxSteps: parsed.maxSteps }),
       entryPointArgs: parsed.sourceType === "module" ? void 0 : hasDefaultExport(executableSource, diagnosticFilename) ? [] : void 0,
       sourceType: parsed.sourceType,
-      sourceRoot: parsed.sourceRoot === void 0 ? void 0 : path.resolve(options.cwd, parsed.sourceRoot),
-      filename: diagnosticFilename,
+      sourceResolver,
+      sourceRoot: sourceResolver !== void 0 || parsed.sourceRoot === void 0 ? void 0 : paths_default.resolve(options.cwd, parsed.sourceRoot),
+      filename: sourceResolver === void 0 ? diagnosticFilename : await sourceResolver.entryId(filepath),
       modules,
       signal: abortController.signal,
       sink: createConsoleSink(options.stdout, options.stderr),
@@ -513,8 +534,8 @@ async function createRuntime(frontmatter, meta, options) {
     };
   }
   const [{ makeHarnessModule }, { makeFsModule }] = await Promise.all([
-    import("./harness-ZIEO7NAV.js"),
-    import("./fs-AOV77RQC.js")
+    import("./harness-UMOMFXDT.js"),
+    import("../modules/fs.js")
   ]);
   const state = {
     metricCalls: /* @__PURE__ */ new Map(),
@@ -555,7 +576,7 @@ async function readRestoreSnapshot(restorePath, options) {
   if (restorePath === void 0) {
     return void 0;
   }
-  const snapshotPath = path.resolve(options.cwd, restorePath);
+  const snapshotPath = paths_default.resolve(options.cwd, restorePath);
   let rawSnapshot;
   try {
     rawSnapshot = await options.readFile(snapshotPath, "utf8");
@@ -582,8 +603,8 @@ async function writeCurrentSnapshot(result, snapshotPath, options, capture) {
   }
 }
 async function writeSnapshot(snapshotPath, content, options) {
-  const resolvedPath = path.resolve(options.cwd, snapshotPath);
-  await mkdir(dirname(resolvedPath), { recursive: true });
+  const resolvedPath = paths_default.resolve(options.cwd, snapshotPath);
+  await (options.adapter ? createFsBridge(options.adapter, { codec: fsCodec }) : hostFs).mkdir(dirname(resolvedPath), { recursive: true });
   await options.writeFile(resolvedPath, content, { encoding: "utf8" });
 }
 function createConsoleSink(stdout, stderr) {
@@ -704,4 +725,4 @@ export {
   exitCodeForError,
   runCli
 };
-//# sourceMappingURL=cli-runtime-WSVW5DNT.js.map
+//# sourceMappingURL=cli-runtime-NUEFUM64.js.map