poe-code 10.0.3 → 11.0.0

package/packages/safejs/dist/chunks/{chunk-A2XBEN3H.js → chunk-DKXGPEOM.js}

@@ -16919,7 +16919,7 @@ function serializeArguments(value, serializeValue) {
 
 // packages/safejs/src/snapshot/dump-format.ts
 var DUMP_FORMAT_VERSION = 1;
-var EXECUTION_SEMANTICS = "jobs-v5";
+var EXECUTION_SEMANTICS = "jobs-v6";
 var SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
 function serializeSafeJSSnapshot(snapshot) {
   const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -17413,9 +17413,6 @@ function validateGenericValue(value, path, depth, state) {
   if (typeof value === "string") {
     requireString(value, path, state.limits);
     state.dataSize += value.length;
-  } else if (typeof value === "number") {
-    if (Number.isInteger(value) && !Number.isSafeInteger(value))
-      fail("invalidValue", path, "integer must be safe");
   } else if (Array.isArray(value)) {
     if (value.length > state.limits.maxEntries) fail("budgetExceeded", path, "array is too large");
     if (state.dataPropertiesOnly) {
@@ -21213,6 +21210,89 @@ function shouldIncludeTemplateRaw(record2, key, includeTemplateRaw) {
   return false;
 }
 
+// packages/safejs/src/snapshot/migration.ts
+function validateMigrationSemantics(value) {
+  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6"].includes(value))
+    throw new TypeError(
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v6)."
+    );
+}
+function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
+  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);
+  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) {
+  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.");
+  decodeReplayData(migration.state);
+  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);
+    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/safejs/src/restore.ts
 var SnapshotMismatchError = class extends Error {
   actualHash;
@@ -21230,6 +21310,7 @@ var SnapshotMismatchError = class extends Error {
 function restore(snapshot, options) {
   assertSnapshotInactive(snapshot);
   validateDumpEnvelope(snapshot);
+  validateSnapshotMigration(snapshot.migration, snapshot.sourceHash);
   if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
     throw new SnapshotValidationError(
       "unsupportedVersion",
@@ -25339,15 +25420,15 @@ var Scope = class _Scope {
       throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
     }
     const binding = scope.#bindings.get(name);
-    if (binding?.kind === "const") {
-      throw new TypeError(`Cannot assign to const binding '${name}'.`);
-    }
     if (binding === void 0) {
       throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
     }
     if (binding.value === uninitialized) {
       throw new ReferenceError(`Cannot access '${name}' before initialization.`);
     }
+    if (binding.kind === "const") {
+      throw new TypeError(`Cannot assign to const binding '${name}'.`);
+    }
     scope.#bindings.set(name, {
       kind: binding.kind,
       value
@@ -25867,39 +25948,37 @@ async function evaluateAssignmentExpression(node, context) {
       )
     };
   }
-  const binding = context.scope.lookup(node.left.name);
-  if (!binding.found) {
+  const binding = node.operator === "=" ? void 0 : context.scope.lookup(node.left.name);
+  if (binding?.found === false) {
     throw new ReferenceError(`Cannot assign to undeclared binding '${node.left.name}'.`);
   }
-  if (binding.kind === "const") {
-    throw new TypeError(`Cannot assign to const '${node.left.name}'`);
-  }
-  if (node.operator === "&&=" && !isTruthy(binding.value)) {
+  const current = binding?.value;
+  if (node.operator === "&&=" && !isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
-  if (node.operator === "||=" && isTruthy(binding.value)) {
+  if (node.operator === "||=" && isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
-  if (node.operator === "??=" && binding.value !== null && binding.value !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
   const right = await evaluateNode(node.right, context);
   if (right.kind !== "normal") {
     return right;
   }
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, binding.value, right.value, context);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   context.scope.assign(node.left.name, value);
   return {
     kind: "normal",
@@ -25921,45 +26000,33 @@ async function evaluateMemberAssignmentExpression(node, context) {
   if (member.kind === "nullish") {
     throw new TypeError("Cannot assign properties of null or undefined.");
   }
-  if (isSandboxRegex(member.object)) {
-    if (node.operator !== "=") {
-      throw new TypeError("RegExp properties only support direct assignment.");
-    }
-    const right2 = await evaluateNode(node.right, context);
-    if (right2.kind !== "normal") return right2;
-    setRegexMember(member.object, member.property, right2.value);
-    return { kind: "normal", hasValue: true, value: right2.value };
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  if (node.operator === "&&=" && !isTruthy(getMemberValue(member.object, member.property, context))) {
+  const current = node.operator === "=" ? void 0 : getPropertyValue(member.object, member.property, context);
+  if (node.operator === "&&=" && !isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
-  if (node.operator === "||=" && isTruthy(getMemberValue(member.object, member.property, context))) {
+  if (node.operator === "||=" && isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
-  if (node.operator === "??=" && getMemberValue(member.object, member.property, context) !== null && getMemberValue(member.object, member.property, context) !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
   const right = await evaluateNode(node.right, context);
   if (right.kind !== "normal") {
     return right;
   }
-  const current = getMemberValue(member.object, member.property, context);
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   setSandboxProperty(member.object, member.property, value);
   return {
     kind: "normal",
@@ -26926,10 +26993,7 @@ async function evaluateIdentifierUpdateExpression(node, context) {
       )
     };
   }
-  if (binding.kind === "const") {
-    throw new TypeError(`Cannot assign to const '${node.argument.name}'`);
-  }
-  const current = Number(binding.value);
+  const current = toNumber(await toNumericPrimitive(binding.value, context));
   const next = node.operator === "++" ? current + 1 : current - 1;
   context.scope.assign(node.argument.name, next);
   return {
@@ -26952,10 +27016,9 @@ async function evaluateMemberUpdateExpression(node, context) {
   if (member.kind === "nullish") {
     throw new TypeError("Cannot update properties of null or undefined.");
   }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Update expressions require a sandbox object property.");
-  }
-  const current = Number(getMemberValue(member.object, member.property, context));
+  const current = toNumber(
+    await toNumericPrimitive(getPropertyValue(member.object, member.property, context), context)
+  );
   const next = node.operator === "++" ? current + 1 : current - 1;
   setSandboxProperty(member.object, member.property, next);
   return {
@@ -26966,94 +27029,33 @@ async function evaluateMemberUpdateExpression(node, context) {
 }
 async function evaluateMemberExpression(node, context) {
   const member = await evaluateMemberAccess(node, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
+  if (member.kind === "error") return member;
+  if (member.kind === "completion") return member.result;
   if (member.kind === "nullish") {
-    if (node.optional) {
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: void 0
-      };
-    }
+    if (node.optional) return { kind: "normal", hasValue: true, value: void 0 };
     throw new TypeError("Cannot read properties of null or undefined.");
   }
-  if (typeof member.object === "string") {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getStringMember(member.object, member.property, context.budget)
-    };
-  }
-  if (typeof member.object === "number") {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getNumberMember(member.object, member.property, context.budget)
-    };
-  }
-  if (Array.isArray(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getArrayMemberValue(member.object, member.property, context)
-    };
-  }
-  if (isSandboxMap(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getMapMember(member.object, member.property, createMapMethodOptions(context))
-    };
-  }
-  if (isSandboxSet(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getSetMember(member.object, member.property, createSetMethodOptions(context))
-    };
-  }
-  if (isSandboxGenerator(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getGeneratorMember(member.object, member.property, context.budget)
-    };
-  }
-  if (isSandboxClosure(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getClosureMemberValue(member.object, member.property, context)
-    };
-  }
-  if (isSandboxPromise(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getPromiseMember(member.property, context.budget)
-    };
-  }
-  if (isSandboxRegex(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getRegexMember(member.object, member.property)
-    };
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Attempted to read a property from a non-object value.");
-  }
   return {
     kind: "normal",
     hasValue: true,
-    value: getMemberValue(member.object, member.property, context)
+    value: getPropertyValue(member.object, member.property, context)
   };
 }
+function getPropertyValue(target, property, context) {
+  if (typeof target === "string") return getStringMember(target, property, context.budget);
+  if (typeof target === "number") return getNumberMember(target, property, context.budget);
+  if (typeof target === "boolean") return void 0;
+  if (isSandboxMap(target)) return getMapMember(target, property, createMapMethodOptions(context));
+  if (isSandboxSet(target)) return getSetMember(target, property, createSetMethodOptions(context));
+  if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
+  if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
+  if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
+  if (isSandboxRegex(target)) return getRegexMember(target, property);
+  if (!isIndexableSandboxValue(target)) {
+    throw new TypeError("Attempted to read a property from a non-object value.");
+  }
+  return getMemberValue(target, property, context);
+}
 async function evaluateCallExpression(node, context) {
   if (node.callee.type === "MemberExpression") {
     context.budget.visitNode();
@@ -27529,7 +27531,9 @@ function applyBinaryOperator(node, left, right, context) {
       throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
   }
 }
-function applyCompoundAssignmentOperator(operator, left, right, context) {
+async function applyCompoundAssignmentOperator(operator, left, right, context) {
+  left = await toNumericPrimitive(left, context);
+  right = await toNumericPrimitive(right, context);
   switch (operator) {
     case "+=":
       return applyAdditionOperator(left, right, context);
@@ -27656,6 +27660,9 @@ async function toNumericPrimitive(value, context) {
   if (isIndexableSandboxValue(value)) {
     for (const methodName of ["valueOf", "toString"]) {
       const method = getMemberValue(value, methodName, context);
+      if (methodName === "toString" && method === void 0 && !Object.hasOwn(value, methodName)) {
+        return toString(value);
+      }
       if (!isSandboxClosure(method)) {
         continue;
       }
@@ -27671,6 +27678,7 @@ async function toNumericPrimitive(value, context) {
         return result;
       }
     }
+    throw new TypeError("Cannot convert object to primitive value.");
   }
   return toString(value);
 }
@@ -27725,17 +27733,30 @@ function getArrayMemberValue(target, property, context) {
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 function setSandboxProperty(target, property, value) {
+  if (isSandboxRegex(target)) {
+    setRegexMember(target, property, value);
+    return;
+  }
+  if (!isIndexableSandboxValue(target)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  const key = String(property);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
-    const key = String(property);
     if (key === "length" || isArrayIndexKey3(key)) {
       target[key] = value;
       return;
     }
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(target, key);
+  if (descriptor !== void 0) {
+    if (descriptor.writable !== true) {
+      throw new TypeError(`Cannot assign to read only property '${key}'.`);
+    }
+    Object.defineProperty(target, key, { value });
+  } else {
     defineSandboxProperty(target, key, value);
-    return;
   }
-  defineSandboxProperty(target, String(property), value);
 }
 function deleteSandboxProperty(target, property) {
   if (Array.isArray(target)) {
@@ -28386,6 +28407,17 @@ function run(source, options = {}) {
           }),
           ...createRegexGlobals()
         };
+        const importMeta = deepCopyToSandbox(options.importMeta ?? {});
+        if (restoredSnapshot?.migration !== void 0) {
+          if (Object.hasOwn(importMeta, "migration"))
+            throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
+          Object.defineProperty(importMeta, "migration", {
+            value: decodeReplayData(restoredSnapshot.migration.state),
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        }
         const initialInputs = prepareReplayInputs(
           {
             bindings: callerBindings,
@@ -28396,7 +28428,7 @@ function run(source, options = {}) {
               allowMissing: restoredSnapshot?.initialInputs !== void 0
             }),
             entryPointArgs: options.entryPointArgs === void 0 ? void 0 : deepCopyToSandbox([...options.entryPointArgs]),
-            importMeta: deepCopyToSandbox(options.importMeta ?? {})
+            importMeta
           },
           restoredSnapshot?.initialInputs,
           (promise, id) => {
@@ -28461,6 +28493,7 @@ function run(source, options = {}) {
         });
         snapshotScheduler = activeSnapshotScheduler;
         createFailureSnapshot = () => createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -28486,6 +28519,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -28527,6 +28561,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -28560,6 +28595,7 @@ function run(source, options = {}) {
           replayError = error.message;
         }
         const snapshot = createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -28729,6 +28765,7 @@ function createRunSnapshot(input) {
     version: DUMP_FORMAT_VERSION,
     executionSemantics: EXECUTION_SEMANTICS,
     sourceHash: input.sourceHash,
+    ...input.migration === void 0 ? {} : { migration: structuredClone(input.migration) },
     bindings: input.bindings,
     clock: input.clock?.snapshot(),
     ...input.hostCalls === void 0 || input.hostCalls.length === 0 ? {} : { hostCalls: input.hostCalls },
@@ -28798,6 +28835,7 @@ export {
   parse,
   parseModule,
   lint,
+  hashSource,
   runResources,
   noopOtelSink,
   bindOtelSpan,
@@ -28809,15 +28847,26 @@ export {
   safeEndSpan,
   SandboxError,
   Budget,
+  DUMP_FORMAT_VERSION,
+  EXECUTION_SEMANTICS,
+  serializeSafeJSSnapshot,
   SnapshotValidationError,
+  validateSnapshotData,
+  validateDumpEnvelope,
+  encodeReplayData,
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
   HostCallResumabilityError,
+  assertSnapshotInactive,
   isSandboxClosure,
   deepCopyToSandbox,
   deepCopyFromSandbox,
   createSeededRandom,
   createReplayableRandom,
+  validateMigrationSemantics,
+  validateMigrationJournal,
+  validateMigrationReconciliation,
+  validateSnapshotMigration,
   restore,
   declareHostOperation,
   dump,
@@ -28827,4 +28876,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-A2XBEN3H.js.map
+//# sourceMappingURL=chunk-DKXGPEOM.js.map