@poe-platform/safe-js 0.1.802 → 0.1.804

package/dist/safe-js/portable/core.js

@@ -119,10 +119,10 @@ import {
   wrapCallerInjectedBindings,
   wrapCancelableBindings,
   wrapHostConstructor
-} from "./chunks/chunk-2FNMGWDK.js";
+} from "./chunks/chunk-SRMMDXD3.js";
 import {
   createRootedSourceResolver
-} from "./chunks/chunk-XCTU25SU.js";
+} from "./chunks/chunk-NLGXLZCK.js";
 import {
   AsyncLocalStorage,
   Budget,
@@ -131,12 +131,257 @@ import {
   createHostCallbackContext,
   describeThrownValue,
   dirname,
+  hostEnv,
   hostErrorData,
   hostFs,
   materializeWrappedErrorCause,
   replaceErrorStack,
   types
-} from "./chunks/chunk-H5X3T5VP.js";
+} from "./chunks/chunk-W6MZOTYR.js";
+
+// packages/safe-js/src/parse/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var IGNORED_KEYS = /* @__PURE__ */ new Set(["nodeId", "raw", "span"]);
+function hashSource(source, owner, includeFunctionSource = true) {
+  try {
+    return hashParsedAst(parse(source, "<input>", owner), includeFunctionSource);
+  } catch (error) {
+    if (error instanceof SandboxError) throw error;
+    return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
+  }
+}
+function hashParsedAst(ast, includeFunctionSource = true) {
+  let hash = FNV_OFFSET_BASIS;
+  visit(ast);
+  return hash.toString(16).padStart(8, "0");
+  function visit(value, includeTemplateRaw = false, enclosingSource, identifierName = false) {
+    if (value === null) {
+      write("null");
+      return;
+    }
+    if (value === void 0) {
+      write("undefined");
+      return;
+    }
+    if (Array.isArray(value)) {
+      write("[");
+      for (const entry of value) {
+        visit(entry, includeTemplateRaw, enclosingSource);
+        write(",");
+      }
+      write("]");
+      return;
+    }
+    switch (typeof value) {
+      case "boolean":
+        write(value ? "true" : "false");
+        return;
+      case "number":
+        write(Object.is(value, -0) ? "-0" : String(value));
+        return;
+      case "string":
+        write(JSON.stringify(value));
+        return;
+      case "object": {
+        const record = value;
+        if (record.type === "Identifier" && record.name === "undefined" && !identifierName) {
+          visit({ type: "UndefinedLiteral", value: void 0 });
+          return;
+        }
+        const source = includeFunctionSource ? functionSources.get(value) : void 0;
+        if (source !== void 0 && !(enclosingSource !== void 0 && source.text === enclosingSource.text && source.start >= enclosingSource.start && source.end <= enclosingSource.end)) {
+          write("function-source:");
+          write(String(source.end - source.start));
+          write(":");
+          write(source.text, source.start, source.end);
+        }
+        const keys = Object.keys(value).filter((key) => shouldHashKey(record, key, includeTemplateRaw)).sort();
+        write("{");
+        for (const key of keys) {
+          write(JSON.stringify(key));
+          write(":");
+          visit(
+            record[key],
+            shouldIncludeTemplateRaw(record, key, includeTemplateRaw),
+            source ?? enclosingSource,
+            key === "property" && record.type === "MemberExpression" && !record.computed || key === "key" && !record.computed || (key === "imported" || key === "local") && record.type === "ImportSpecifier" || key === "exported" && record.type === "ExportSpecifier"
+          );
+          write(",");
+        }
+        write("}");
+        return;
+      }
+      default:
+        throw new TypeError(`Unsupported AST value type: ${typeof value}`);
+    }
+  }
+  function write(chunk, start = 0, end = chunk.length) {
+    for (let index = start; index < end; index += 1) {
+      hash ^= chunk.charCodeAt(index);
+      hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+  }
+}
+function shouldHashKey(record, key, includeTemplateRaw) {
+  if (key !== "raw") {
+    return !IGNORED_KEYS.has(key);
+  }
+  return includeTemplateRaw || record.type === "RegexLiteral";
+}
+function shouldIncludeTemplateRaw(record, key, includeTemplateRaw) {
+  if (record.type === "TaggedTemplateExpression" && key === "quasi") {
+    return true;
+  }
+  if (includeTemplateRaw && record.type === "TemplateLiteral" && key === "quasis") {
+    return true;
+  }
+  if (includeTemplateRaw && record.type === "TemplateElement" && key === "value") {
+    return true;
+  }
+  return false;
+}
+
+// packages/safe-js/src/snapshot/migration.ts
+function validateMigrationSemantics(value) {
+  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7", "jobs-v8", "jobs-v9"].includes(
+    value
+  ))
+    throw new TypeError(
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v9)."
+    );
+}
+function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
+  if (replay === void 0)
+    throw new TypeError("Migration requires a complete host replay journal.");
+  if (!Array.isArray(hostCalls)) throw new TypeError("Invalid migration hostCalls.");
+  const journal = new HostCallJournal(
+    sourceHash,
+    hostCalls,
+    void 0,
+    replay,
+    owner?.budget,
+    owner
+  );
+  try {
+    const restored = journal.snapshotReplay();
+    for (const call of restored.calls) {
+      if (["created", "running"].includes(call.lifecycle) && call.outcome !== void 0)
+        throw new TypeError("Unresolved migration calls cannot contain a recorded outcome.");
+      for (const callback of call.callbacks ?? []) {
+        if (!call.functions?.includes(callback.id))
+          throw new TypeError("Migration callback has no registered source function.");
+      }
+    }
+    return restored;
+  } finally {
+    journal.dispose();
+  }
+}
+function validateMigrationReconciliation(value, checkpointDigest, calls) {
+  validateSnapshotData(value);
+  const receipt = value;
+  if (receipt === null || typeof receipt !== "object" || receipt.checkpointDigest !== checkpointDigest || !isCheckpointDigest(receipt.checkpointDigest))
+    throw new TypeError("Migration reconciliation must identify this exact checkpoint digest.");
+  if (receipt.quiescent !== true)
+    throw new TypeError(
+      "Migration requires explicit host confirmation that execution, operations, and callbacks are quiescent."
+    );
+  if (!Array.isArray(receipt.calls))
+    throw new TypeError("Migration reconciliation calls must be an array.");
+  const pending = new Map(
+    calls.filter((call) => !["settled", "consumed"].includes(call.lifecycle)).map((call) => [call.id, call])
+  );
+  for (const resolution of receipt.calls) {
+    if (resolution === null || typeof resolution !== "object" || !pending.has(resolution.callId))
+      throw new TypeError("Migration contains an unknown or duplicate call resolution.");
+    if (!["not-performed", "fulfilled", "rejected"].includes(resolution.disposition) || resolution.disposition === "fulfilled" && !Object.hasOwn(resolution, "value") || resolution.disposition === "rejected" && !Object.hasOwn(resolution, "reason"))
+      throw new TypeError(
+        "Migration call resolution requires a reconciled outcome or confirmed non-performance."
+      );
+    pending.delete(resolution.callId);
+  }
+  if (pending.size > 0)
+    throw new TypeError(
+      `Migration requires external reconciliation for: ${[...pending.keys()].join(", ")}`
+    );
+}
+function validateSnapshotMigration(value, sourceHash, owner) {
+  if (value === void 0) return void 0;
+  validateSnapshotData(value);
+  const migration = value;
+  if (migration === null || typeof migration !== "object" || migration.version !== 1 || !Array.isArray(migration.history) || migration.history.length === 0)
+    throw new TypeError("Invalid snapshot migration history.");
+  const compilation = new CompileScope(owner);
+  try {
+    decodeReplayData(migration.state, {}, compilation);
+  } finally {
+    compilation.dispose();
+  }
+  let previousTarget;
+  for (const entry of migration.history) {
+    if (entry === null || typeof entry !== "object" || typeof entry.sourceHash !== "string" || entry.sourceHash.length === 0 || typeof entry.targetSourceHash !== "string" || entry.targetSourceHash.length === 0 || previousTarget !== void 0 && previousTarget !== entry.sourceHash)
+      throw new TypeError("Invalid snapshot migration ancestry.");
+    validateMigrationSemantics(entry.executionSemantics);
+    const replay = validateMigrationJournal(entry.sourceHash, entry.replay, [], owner);
+    validateMigrationReconciliation(
+      entry.reconciliation,
+      entry.reconciliation?.checkpointDigest,
+      replay.calls
+    );
+    previousTarget = entry.targetSourceHash;
+  }
+  if (previousTarget !== sourceHash)
+    throw new TypeError("Migration ancestry does not match the target source.");
+  return migration;
+}
+function isCheckpointDigest(value) {
+  return typeof value === "string" && value.length === 64 && [...value].every((character) => "0123456789abcdef".includes(character));
+}
+
+// packages/safe-js/src/restore.ts
+var SnapshotMismatchError = class extends Error {
+  actualHash;
+  expectedHash;
+  constructor(expectedHash, actualHash) {
+    super(
+      `source changed since snapshot was taken (hash ${expectedHash} expected, got ${actualHash}); pass --reset to discard`
+    );
+    this.name = "SnapshotMismatchError";
+    this.actualHash = actualHash;
+    this.expectedHash = expectedHash;
+    replaceErrorStack(this);
+  }
+};
+function restore(snapshot, options, owner) {
+  assertSnapshotInactive(snapshot);
+  try {
+    validateDumpEnvelope(snapshot, { resume: true });
+  } catch (error) {
+    if (!(error instanceof SnapshotValidationError) || error.code !== "invalidState" || error.path === "$.replayError" || !inMemoryRunSnapshots.has(snapshot)) throw error;
+    validateRuntimeSnapshotDescriptors(snapshot);
+    snapshot = JSON.parse(serializeSafeJSSnapshot(snapshot));
+    validateDumpEnvelope(snapshot, { resume: true });
+  }
+  validateSnapshotMigration(snapshot.migration, snapshot.sourceHash, owner);
+  const includeFunctionSource = snapshot.executionSemantics !== "jobs-v6" && snapshot.executionSemantics !== "jobs-v7";
+  const currentSourceHash = options.importSpecifiers === void 0 ? hashSource(options.source, owner, includeFunctionSource) : hashParsedAst(parseExecutableModule(options.source, "<input>", owner, options.importSpecifiers), includeFunctionSource);
+  if (snapshot.sourceHash !== currentSourceHash) {
+    throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
+  }
+  if (snapshot.heap !== void 0 && typeof snapshot.heap === "object" && snapshot.heap !== null) {
+    try {
+      validateGuestHeapSource(snapshot.heap, options.importSpecifiers === void 0 ? parseModule(options.source, "<input>", owner) : parseExecutableModule(options.source, "<input>", owner, options.importSpecifiers), owner);
+    } catch (error) {
+      if (error instanceof SnapshotValidationError || error instanceof SandboxError) throw error;
+      throw new SnapshotValidationError("invalidValue", "$.heap", String(error));
+    }
+  }
+  return snapshot;
+}
+
+// packages/safe-js/src/parse.ts
+var parse2 = parse;
 
 // packages/safe-js/src/lint/rules/AS001.ts
 function AS001(source, options = {}) {
@@ -11302,109 +11547,6 @@ function hasOnlyRegexLiteralDiagnostics(diagnostics) {
   );
 }
 
-// packages/safe-js/src/parse/hash.ts
-var FNV_OFFSET_BASIS = 2166136261;
-var FNV_PRIME = 16777619;
-var IGNORED_KEYS = /* @__PURE__ */ new Set(["nodeId", "raw", "span"]);
-function hashSource(source, owner, includeFunctionSource = true) {
-  try {
-    return hashParsedAst(parse(source, "<input>", owner), includeFunctionSource);
-  } catch (error) {
-    if (error instanceof SandboxError) throw error;
-    return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
-  }
-}
-function hashParsedAst(ast, includeFunctionSource = true) {
-  let hash = FNV_OFFSET_BASIS;
-  visit(ast);
-  return hash.toString(16).padStart(8, "0");
-  function visit(value, includeTemplateRaw = false, enclosingSource, identifierName = false) {
-    if (value === null) {
-      write("null");
-      return;
-    }
-    if (value === void 0) {
-      write("undefined");
-      return;
-    }
-    if (Array.isArray(value)) {
-      write("[");
-      for (const entry of value) {
-        visit(entry, includeTemplateRaw, enclosingSource);
-        write(",");
-      }
-      write("]");
-      return;
-    }
-    switch (typeof value) {
-      case "boolean":
-        write(value ? "true" : "false");
-        return;
-      case "number":
-        write(Object.is(value, -0) ? "-0" : String(value));
-        return;
-      case "string":
-        write(JSON.stringify(value));
-        return;
-      case "object": {
-        const record = value;
-        if (record.type === "Identifier" && record.name === "undefined" && !identifierName) {
-          visit({ type: "UndefinedLiteral", value: void 0 });
-          return;
-        }
-        const source = includeFunctionSource ? functionSources.get(value) : void 0;
-        if (source !== void 0 && !(enclosingSource !== void 0 && source.text === enclosingSource.text && source.start >= enclosingSource.start && source.end <= enclosingSource.end)) {
-          write("function-source:");
-          write(String(source.end - source.start));
-          write(":");
-          write(source.text, source.start, source.end);
-        }
-        const keys = Object.keys(value).filter((key) => shouldHashKey(record, key, includeTemplateRaw)).sort();
-        write("{");
-        for (const key of keys) {
-          write(JSON.stringify(key));
-          write(":");
-          visit(
-            record[key],
-            shouldIncludeTemplateRaw(record, key, includeTemplateRaw),
-            source ?? enclosingSource,
-            key === "property" && record.type === "MemberExpression" && !record.computed || key === "key" && !record.computed || (key === "imported" || key === "local") && record.type === "ImportSpecifier" || key === "exported" && record.type === "ExportSpecifier"
-          );
-          write(",");
-        }
-        write("}");
-        return;
-      }
-      default:
-        throw new TypeError(`Unsupported AST value type: ${typeof value}`);
-    }
-  }
-  function write(chunk, start = 0, end = chunk.length) {
-    for (let index = start; index < end; index += 1) {
-      hash ^= chunk.charCodeAt(index);
-      hash = Math.imul(hash, FNV_PRIME) >>> 0;
-    }
-  }
-}
-function shouldHashKey(record, key, includeTemplateRaw) {
-  if (key !== "raw") {
-    return !IGNORED_KEYS.has(key);
-  }
-  return includeTemplateRaw || record.type === "RegexLiteral";
-}
-function shouldIncludeTemplateRaw(record, key, includeTemplateRaw) {
-  if (record.type === "TaggedTemplateExpression" && key === "quasi") {
-    return true;
-  }
-  if (includeTemplateRaw && record.type === "TemplateLiteral" && key === "quasis") {
-    return true;
-  }
-  if (includeTemplateRaw && record.type === "TemplateElement" && key === "value") {
-    return true;
-  }
-  return false;
-}
-
 // packages/safe-js/src/modules/source-graph.ts
 var ambiguous = /* @__PURE__ */ Symbol("ambiguous module export");
 var sourceRecords = /* @__PURE__ */ new WeakSet();
@@ -13103,144 +13245,6 @@ function readRealmOptions(value, oneShot = false) {
   return options;
 }
 
-// packages/safe-js/src/snapshot/migration.ts
-function validateMigrationSemantics(value) {
-  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7", "jobs-v8", "jobs-v9"].includes(
-    value
-  ))
-    throw new TypeError(
-      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v9)."
-    );
-}
-function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
-  if (replay === void 0)
-    throw new TypeError("Migration requires a complete host replay journal.");
-  if (!Array.isArray(hostCalls)) throw new TypeError("Invalid migration hostCalls.");
-  const journal = new HostCallJournal(
-    sourceHash,
-    hostCalls,
-    void 0,
-    replay,
-    owner?.budget,
-    owner
-  );
-  try {
-    const restored = journal.snapshotReplay();
-    for (const call of restored.calls) {
-      if (["created", "running"].includes(call.lifecycle) && call.outcome !== void 0)
-        throw new TypeError("Unresolved migration calls cannot contain a recorded outcome.");
-      for (const callback of call.callbacks ?? []) {
-        if (!call.functions?.includes(callback.id))
-          throw new TypeError("Migration callback has no registered source function.");
-      }
-    }
-    return restored;
-  } finally {
-    journal.dispose();
-  }
-}
-function validateMigrationReconciliation(value, checkpointDigest, calls) {
-  validateSnapshotData(value);
-  const receipt = value;
-  if (receipt === null || typeof receipt !== "object" || receipt.checkpointDigest !== checkpointDigest || !isCheckpointDigest(receipt.checkpointDigest))
-    throw new TypeError("Migration reconciliation must identify this exact checkpoint digest.");
-  if (receipt.quiescent !== true)
-    throw new TypeError(
-      "Migration requires explicit host confirmation that execution, operations, and callbacks are quiescent."
-    );
-  if (!Array.isArray(receipt.calls))
-    throw new TypeError("Migration reconciliation calls must be an array.");
-  const pending = new Map(
-    calls.filter((call) => !["settled", "consumed"].includes(call.lifecycle)).map((call) => [call.id, call])
-  );
-  for (const resolution of receipt.calls) {
-    if (resolution === null || typeof resolution !== "object" || !pending.has(resolution.callId))
-      throw new TypeError("Migration contains an unknown or duplicate call resolution.");
-    if (!["not-performed", "fulfilled", "rejected"].includes(resolution.disposition) || resolution.disposition === "fulfilled" && !Object.hasOwn(resolution, "value") || resolution.disposition === "rejected" && !Object.hasOwn(resolution, "reason"))
-      throw new TypeError(
-        "Migration call resolution requires a reconciled outcome or confirmed non-performance."
-      );
-    pending.delete(resolution.callId);
-  }
-  if (pending.size > 0)
-    throw new TypeError(
-      `Migration requires external reconciliation for: ${[...pending.keys()].join(", ")}`
-    );
-}
-function validateSnapshotMigration(value, sourceHash, owner) {
-  if (value === void 0) return void 0;
-  validateSnapshotData(value);
-  const migration = value;
-  if (migration === null || typeof migration !== "object" || migration.version !== 1 || !Array.isArray(migration.history) || migration.history.length === 0)
-    throw new TypeError("Invalid snapshot migration history.");
-  const compilation = new CompileScope(owner);
-  try {
-    decodeReplayData(migration.state, {}, compilation);
-  } finally {
-    compilation.dispose();
-  }
-  let previousTarget;
-  for (const entry of migration.history) {
-    if (entry === null || typeof entry !== "object" || typeof entry.sourceHash !== "string" || entry.sourceHash.length === 0 || typeof entry.targetSourceHash !== "string" || entry.targetSourceHash.length === 0 || previousTarget !== void 0 && previousTarget !== entry.sourceHash)
-      throw new TypeError("Invalid snapshot migration ancestry.");
-    validateMigrationSemantics(entry.executionSemantics);
-    const replay = validateMigrationJournal(entry.sourceHash, entry.replay, [], owner);
-    validateMigrationReconciliation(
-      entry.reconciliation,
-      entry.reconciliation?.checkpointDigest,
-      replay.calls
-    );
-    previousTarget = entry.targetSourceHash;
-  }
-  if (previousTarget !== sourceHash)
-    throw new TypeError("Migration ancestry does not match the target source.");
-  return migration;
-}
-function isCheckpointDigest(value) {
-  return typeof value === "string" && value.length === 64 && [...value].every((character) => "0123456789abcdef".includes(character));
-}
-
-// packages/safe-js/src/restore.ts
-var SnapshotMismatchError = class extends Error {
-  actualHash;
-  expectedHash;
-  constructor(expectedHash, actualHash) {
-    super(
-      `source changed since snapshot was taken (hash ${expectedHash} expected, got ${actualHash}); pass --reset to discard`
-    );
-    this.name = "SnapshotMismatchError";
-    this.actualHash = actualHash;
-    this.expectedHash = expectedHash;
-    replaceErrorStack(this);
-  }
-};
-function restore(snapshot, options, owner) {
-  assertSnapshotInactive(snapshot);
-  try {
-    validateDumpEnvelope(snapshot, { resume: true });
-  } catch (error) {
-    if (!(error instanceof SnapshotValidationError) || error.code !== "invalidState" || error.path === "$.replayError" || !inMemoryRunSnapshots.has(snapshot)) throw error;
-    validateRuntimeSnapshotDescriptors(snapshot);
-    snapshot = JSON.parse(serializeSafeJSSnapshot(snapshot));
-    validateDumpEnvelope(snapshot, { resume: true });
-  }
-  validateSnapshotMigration(snapshot.migration, snapshot.sourceHash, owner);
-  const includeFunctionSource = snapshot.executionSemantics !== "jobs-v6" && snapshot.executionSemantics !== "jobs-v7";
-  const currentSourceHash = options.importSpecifiers === void 0 ? hashSource(options.source, owner, includeFunctionSource) : hashParsedAst(parseExecutableModule(options.source, "<input>", owner, options.importSpecifiers), includeFunctionSource);
-  if (snapshot.sourceHash !== currentSourceHash) {
-    throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
-  }
-  if (snapshot.heap !== void 0 && typeof snapshot.heap === "object" && snapshot.heap !== null) {
-    try {
-      validateGuestHeapSource(snapshot.heap, options.importSpecifiers === void 0 ? parseModule(options.source, "<input>", owner) : parseExecutableModule(options.source, "<input>", owner, options.importSpecifiers), owner);
-    } catch (error) {
-      if (error instanceof SnapshotValidationError || error instanceof SandboxError) throw error;
-      throw new SnapshotValidationError("invalidValue", "$.heap", String(error));
-    }
-  }
-  return snapshot;
-}
-
 // packages/safe-js/src/snapshot/dump.ts
 var RUN_DUMP_CONTROLLER = /* @__PURE__ */ Symbol("SafeJS.run-dump-controller");
 function attachDumpController(result, controller) {
@@ -13384,9 +13388,37 @@ function createDumpController(lifecycle, pause) {
 function isDataBudgetError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "budgetExceeded" && "budget" in error && error.budget === "dataSize";
 }
+function dump(result, options = {}) {
+  const controller = readDumpController(result);
+  if (controller !== void 0) {
+    return controller.requestSnapshot(options);
+  }
+  if (hasSnapshot(result)) {
+    try {
+      return Promise.resolve(serializeRunSnapshot(result.snapshot));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  return Promise.resolve(result).then((resolved) => {
+    if (!hasSnapshot(resolved)) {
+      throw new Error("Run completed without producing a snapshot.");
+    }
+    return serializeRunSnapshot(resolved.snapshot);
+  });
+}
 function serializeRunSnapshot(snapshot) {
   return serializeSafeJSSnapshot(snapshot);
 }
+function hasSnapshot(value) {
+  return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, "snapshot");
+}
+function readDumpController(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return value[RUN_DUMP_CONTROLLER];
+}
 
 // packages/safe-js/src/snapshot/backend.ts
 import { createFsBridge } from "@poe-platform/safe-fs/core";
@@ -13659,7 +13691,7 @@ var UnsnapshotableValueError = class extends Error {
 };
 
 // packages/safe-js/src/snapshot/replay-inputs.ts
-function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestored, compilation, onInputSymbols) {
+function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestored, compilation, onInputSymbols, restoredPromiseOrder = []) {
   const identities = /* @__PURE__ */ new WeakMap();
   const capabilities = /* @__PURE__ */ new Map();
   const promises = /* @__PURE__ */ new Map();
@@ -13754,6 +13786,8 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
     return isSandboxClosure(value) ? value : void 0;
   };
   const memo = { nodes: context.nodes, values: /* @__PURE__ */ new Map() };
+  const restoredRootPromises = /* @__PURE__ */ new Set();
+  const restoredNamespacePromises = /* @__PURE__ */ new Map();
   if (saved !== void 0) validateSnapshotData(saved);
   const snapshot = saved === void 0 ? encodeReplayData(current, {
     context,
@@ -13771,6 +13805,7 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
         resolveCapability,
         resolvePromise: (id) => {
           readCapability(id);
+          restoredRootPromises.add(id);
           return createSandboxPromise(Promise.resolve(void 0), { trackReplay: false });
         }
       }, validationScope);
@@ -13779,7 +13814,8 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
         if (snapshot.namespaceRoots === null || typeof snapshot.namespaceRoots !== "object" || Array.isArray(snapshot.namespaceRoots))
           throw new TypeError("Invalid replay namespace roots.");
         const validationCapability = createSandboxClosure({ call: () => void 0 });
-        for (const root of Object.values(snapshot.namespaceRoots)) {
+        for (const [name, root] of Object.entries(snapshot.namespaceRoots)) {
+          const ids = /* @__PURE__ */ new Set();
           const namespace = decodeReplayData({ root, nodes: snapshot.nodes }, {
             resolveCapability: (id) => {
               readCapability(id);
@@ -13787,10 +13823,12 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
             },
             resolvePromise: (id) => {
               readCapability(id);
+              ids.add(id);
               return createSandboxPromise(Promise.resolve(void 0), { trackReplay: false });
             }
           }, validationScope);
           if (!isSandboxModuleNamespace(namespace)) throw new TypeError("Invalid replay module namespace.");
+          restoredNamespacePromises.set(name, ids);
         }
       }
     } finally {
@@ -13813,6 +13851,7 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
       promises.set(id, preparePromise(isSandboxPromise(value) ? value : void 0, id));
     return promises.get(id);
   };
+  for (const id of restoredPromiseOrder) if (restoredRootPromises.has(id)) resolvePromise(id);
   if (inputPromises.size > 0) {
     memo.values.clear();
     for (const [id, symbol] of inputSymbols) memo.values.set(id, symbol);
@@ -13843,6 +13882,10 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
     captureNamespace,
     prepareNamespace: (namespace, name) => {
       captureNamespace(namespace, name);
+      const ids = restoredNamespacePromises.get(name);
+      if (ids !== void 0) {
+        for (const id of restoredPromiseOrder) if (ids.has(id)) resolvePromise(id);
+      }
       return decodeReplayData(
         { root: snapshot.namespaceRoots[name], nodes: snapshot.nodes },
         { memo, resolveCapability, resolvePromise, onCapabilityRestored },
@@ -13885,7 +13928,7 @@ function run(source, options = {}) {
         throw new TypeError("Source resolution requires sourceType: 'module'.");
       if (options.sourceRoot !== void 0) {
         if (options.sourceResolver !== void 0) throw new TypeError("Specify sourceRoot or sourceResolver, not both.");
-        const { createRootedSourceResolver: createRootedSourceResolver2 } = await import("./chunks/source-files-CVU252FB.js");
+        const { createRootedSourceResolver: createRootedSourceResolver2 } = await import("./chunks/source-files-AEDWESAJ.js");
         const { sourceRoot, ...resolved } = options;
         const sourceResolver = await createRootedSourceResolver2(sourceRoot);
         return runWithExtensions(source, { ...resolved, filename: await sourceResolver.entryId(options.filename), sourceResolver }, jobs);
@@ -14049,7 +14092,8 @@ function run(source, options = {}) {
             prepareInputPromise,
             hostCalls.rebindHostCapability.bind(hostCalls),
             compilation,
-            hostCalls.registerInputSymbols.bind(hostCalls)
+            hostCalls.registerInputSymbols.bind(hostCalls),
+            hostCalls.inputPromiseOrder()
           );
           leaveInputReplay = () => {
             budget.setRetainedDataUsage(initialInputs, 0);
@@ -14497,7 +14541,7 @@ function makeEnvModule(input) {
     get(name) {
       const variable = readEnvName(name, "Environment variable name");
       if (!allowedNames.has(variable)) throw new EnvAccessError(variable);
-      return readEnvValue(values ?? (typeof process !== "undefined" ? process.env ?? {} : {}), variable);
+      return readEnvValue(values ?? hostEnv(), variable);
     }
   };
 }
@@ -14741,23 +14785,197 @@ function assertSleepDelay(ms) {
 function createSleepAbortError() {
   return new Error("time.sleep aborted.");
 }
+
+// packages/safe-js/src/output-stream.ts
+function createBrokenPipeState() {
+  return { closed: false };
+}
+function createSafeOutputStream(stream, brokenPipe) {
+  return {
+    write(chunk) {
+      if (brokenPipe.closed) {
+        return;
+      }
+      try {
+        stream.write(chunk);
+      } catch (error) {
+        if (isBrokenPipeError(error)) {
+          brokenPipe.closed = true;
+          return;
+        }
+        throw error;
+      }
+    }
+  };
+}
+function addBrokenPipeListener(stream, brokenPipe) {
+  const onError = (error) => {
+    if (isBrokenPipeError(error)) {
+      brokenPipe.closed = true;
+      return;
+    }
+    throw error;
+  };
+  stream.on?.("error", onError);
+  return () => {
+    stream.off?.("error", onError);
+  };
+}
+function isBrokenPipeError(error) {
+  return hasOwnErrorCode(error, "EPIPE");
+}
+
+// packages/safe-js/src/modules/log.ts
+var stdoutSinks = /* @__PURE__ */ new WeakMap();
+function makeLogModule(sink = createJsonlStdoutSink()) {
+  const normalizedSink = readSink(sink);
+  return {
+    info(...args) {
+      normalizedSink({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "info",
+        args
+      });
+    },
+    error(...args) {
+      normalizedSink({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "error",
+        args
+      });
+    },
+    event(name, payload) {
+      normalizedSink({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "event",
+        name: readNonEmptyString3(name, "Event name"),
+        payload
+      });
+    }
+  };
+}
+function createJsonlStdoutSink() {
+  const stream = typeof process !== "undefined" ? process.stdout : void 0;
+  if (stream == null || typeof stream.write !== "function") {
+    return (entry) => console.log(JSON.stringify(toJsonValue(entry, /* @__PURE__ */ new WeakSet())));
+  }
+  const existing = stdoutSinks.get(stream);
+  if (existing) return existing;
+  const brokenPipe = createBrokenPipeState();
+  const stdout = createSafeOutputStream(stream, brokenPipe);
+  addBrokenPipeListener(stream, brokenPipe);
+  const sink = (entry) => {
+    stdout.write(`${JSON.stringify(toJsonValue(entry, /* @__PURE__ */ new WeakSet()))}
+`);
+  };
+  stdoutSinks.set(stream, sink);
+  return sink;
+}
+function readNonEmptyString3(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  const normalizedValue = value.trim();
+  if (normalizedValue.length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return normalizedValue;
+}
+function readSink(value) {
+  if (typeof value !== "function") {
+    throw new Error("Log sink must be a function.");
+  }
+  return value;
+}
+function toJsonValue(value, seen) {
+  if (value === void 0) {
+    return null;
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : String(value);
+  }
+  if (typeof value === "bigint" || typeof value === "symbol") {
+    return String(value);
+  }
+  if (typeof value === "function") {
+    return `[Function ${value.name || "anonymous"}]`;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+  }
+  if (value instanceof Error) {
+    const serializedError = {
+      name: value.name,
+      message: value.message
+    };
+    if (typeof value.stack === "string" && value.stack.length > 0) {
+      serializedError.stack = value.stack;
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "cause")) {
+      serializedError.cause = toJsonValue(value.cause, seen);
+    }
+    return serializedError;
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const normalized = value.map((entry) => toJsonValue(entry, seen));
+    seen.delete(value);
+    return normalized;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const normalized = /* @__PURE__ */ Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+      normalized[key] = toJsonValue(entry, seen);
+    }
+    seen.delete(value);
+    return normalized;
+  }
+  return String(value);
+}
+
+// packages/safe-js/src/core.ts
+var parseModule2 = parseModule;
+var parseSourceModule2 = parseSourceModule;
+var restore2 = restore;
+var deepCopyFromSandbox2 = deepCopyFromSandbox;
 export {
   Budget,
   EnvAccessError,
   FS_OPTION_SURFACE,
   HarnessFailure,
+  SandboxError,
+  SnapshotValidationError,
   admitNativePromiseProperties,
   createRealm,
   createReplayableRandom,
   createRootedSourceResolver,
+  declareHostOperation,
+  deepCopyFromSandbox2 as deepCopyFromSandbox,
+  deepCopyToSandbox,
   defineExtension,
+  dump,
   lint,
   makeEnvModule,
   makeFailModule,
   makeFsModule,
   makeHarnessModule,
+  makeLogModule,
   makeMetricModule,
   makeTimeModule,
+  parse2 as parse,
   parseEnvConfig,
+  parseModule2 as parseModule,
+  parseSourceModule2 as parseSourceModule,
+  restore2 as restore,
   run
 };