@poe-platform/safe-js 0.1.162 → 0.1.164

package/dist/safe-js/chunks/{chunk-MLVHXQVK.js → chunk-JPANSO6U.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-56XYHJCY.js";
+} from "./chunk-VHZYRV5Q.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-MLVHXQVK.js.map
+//# sourceMappingURL=chunk-JPANSO6U.js.map

package/dist/safe-js/chunks/{chunk-56XYHJCY.js → chunk-VHZYRV5Q.js}

@@ -2567,6 +2567,7 @@ var Parser = class {
   loopDepth = 0;
   scopes = [/* @__PURE__ */ new Map()];
   functionScopes = /* @__PURE__ */ new WeakSet();
+  parenthesizedNodes = /* @__PURE__ */ new WeakSet();
   varNames = /* @__PURE__ */ new WeakMap();
   withFunctionSource(node) {
     functionSources.set(node, {
@@ -3941,13 +3942,12 @@ var Parser = class {
   parseAssignmentObjectPatternProperty() {
     if (this.consumePunctuator("...") !== void 0) {
       const start = this.previousToken().start;
-      const token2 = this.currentToken();
-      if (token2.type !== "identifier") {
+      const argument = this.parseAssignmentTarget();
+      if (argument.type !== "Identifier" && (argument.type !== "MemberExpression" || this.hasOptionalAssignmentChain(argument))) {
         throw new Error(
-          `Object rest element must bind to an identifier at line ${token2.start.line}, column ${token2.start.column}.`
+          `Object rest assignment requires an identifier or member target at line ${argument.span.start.line}, column ${argument.span.start.column}.`
         );
       }
-      const argument = this.parseBindingIdentifier();
       return {
         type: "RestElement",
         argument,
@@ -4427,6 +4427,7 @@ var Parser = class {
       const expression = this.parseExpression({ allowSequence: true });
       const end = this.expectPunctuator(")");
       expression.node.span = createSpan2(start.start, end.end);
+      this.parenthesizedNodes.add(expression.node);
       return {
         node: expression.node,
         parenthesized: true
@@ -4963,9 +4964,9 @@ var Parser = class {
   }
   toObjectPatternProperty(property) {
     if (property.type === "SpreadElement") {
-      if (property.argument.type !== "Identifier") {
+      if (property.argument.type !== "Identifier" && (property.argument.type !== "MemberExpression" || this.hasOptionalAssignmentChain(property.argument))) {
         throw new Error(
-          `Object rest element must bind to an identifier at line ${property.argument.span.start.line}, column ${property.argument.span.start.column}.`
+          `Object rest assignment requires an identifier or member target at line ${property.argument.span.start.line}, column ${property.argument.span.start.column}.`
         );
       }
       return {
@@ -4984,6 +4985,15 @@ var Parser = class {
       span: property.span
     };
   }
+  hasOptionalAssignmentChain(node) {
+    while (node.type === "MemberExpression" || node.type === "CallExpression") {
+      if (node.optional) return true;
+      const base = node.type === "MemberExpression" ? node.object : node.callee;
+      if (this.parenthesizedNodes.has(base)) return false;
+      node = base;
+    }
+    return false;
+  }
   toObjectPropertyValue(value) {
     if (value.type === "AssignmentExpression" && value.operator === "=") {
       return {
@@ -9070,221 +9080,6 @@ async function withRunResources(signal, execute) {
   return result;
 }
 
-// packages/safe-js/src/interp/patterns.ts
-async function bindPattern(pattern, value, target, scope, context) {
-  switch (pattern.type) {
-    case "Identifier":
-      bindIdentifier(pattern, value, target, scope);
-      return { ok: true };
-    case "MemberExpression":
-      if ("kind" in target) {
-        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
-      }
-      return bindMemberExpression(pattern, value, scope, context);
-    case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, target, scope, context);
-    case "ArrayPattern":
-      return bindArrayPattern(pattern, value, target, scope, context);
-    case "ObjectPattern":
-      return bindObjectPattern(pattern, value, target, scope, context);
-    case "RestElement":
-      return bindPattern(pattern.argument, value, target, scope, context);
-  }
-}
-function bindIdentifier(pattern, value, target, scope) {
-  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
-    if ("assign" in target) {
-      const binding = scope.lookup(pattern.name);
-      if (!binding.found) {
-        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
-      }
-      if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
-      }
-    }
-    scope.assign(pattern.name, value);
-    return;
-  }
-  scope.declare(pattern.name, target.kind, value);
-}
-async function bindAssignmentPattern(pattern, value, target, scope, context) {
-  if (value !== void 0) {
-    return bindPattern(pattern.left, value, target, scope, context);
-  }
-  const defaultValue = await context.evaluate(
-    pattern.right,
-    pattern.left.type === "Identifier" ? pattern.left.name : void 0
-  );
-  if (defaultValue.kind !== "normal") {
-    return { ok: false, result: defaultValue };
-  }
-  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
-}
-async function bindArrayPattern(pattern, value, target, scope, context) {
-  const iterator = isSandboxCollectionIterator(value) ? value : void 0;
-  const values = iterator === void 0 ? getArrayPatternValues(value) : void 0;
-  let cursor = 0;
-  let done = false;
-  const next = async () => {
-    if (iterator !== void 0) return nextCollectionIterator(iterator, context.budget);
-    if (done || cursor >= values.length) {
-      done = true;
-      return { done: true, value: void 0 };
-    }
-    return { done: false, value: await context.getProperty(values, cursor++) };
-  };
-  for (let index = 0; index < pattern.elements.length; index += 1) {
-    const element = pattern.elements[index];
-    if (element === null) {
-      await next();
-      continue;
-    }
-    let elementValue;
-    if (element.type === "RestElement") {
-      const rest = [];
-      for (let entry = await next(); !entry.done; entry = await next()) {
-        context.budget?.allocateArrayLength(rest.length + 1);
-        rest.push(entry.value);
-      }
-      elementValue = rest;
-    } else {
-      elementValue = (await next()).value;
-    }
-    const binding = await bindPattern(element, elementValue, target, scope, context);
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindObjectPattern(pattern, value, target, scope, context) {
-  if (typeof value !== "object" || value === null) {
-    throw new TypeError("Object destructuring declarations require a non-null object value.");
-  }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const binding2 = await bindPattern(
-        property,
-        await copyObjectRestValue(value, excludedKeys, context),
-        target,
-        scope,
-        context
-      );
-      if (!binding2.ok) {
-        return binding2;
-      }
-      continue;
-    }
-    const key = await evaluatePatternKey(property, context);
-    if (!key.ok) {
-      return key;
-    }
-    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
-    const binding = await bindPattern(
-      property.value,
-      await context.getProperty(value, key.value),
-      target,
-      scope,
-      context
-    );
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindMemberExpression(pattern, value, scope, context) {
-  const object = await context.evaluate(pattern.object);
-  if (object.kind !== "normal") {
-    return { ok: false, result: object };
-  }
-  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
-  if (property.kind !== "normal") {
-    return { ok: false, result: property };
-  }
-  if (object.value === null || object.value === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  if (!isIndexableValue(object.value)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  await context.setProperty(object.value, await context.toPropertyKey(property.value), value);
-  return { ok: true };
-}
-async function evaluatePatternKey(property, context) {
-  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
-}
-async function evaluateProperty(property, context) {
-  const result = await context.evaluate(property);
-  if (result.kind !== "normal") {
-    return { ok: false, result };
-  }
-  return { ok: true, value: await context.toPropertyKey(result.value) };
-}
-function getStaticPropertyName(property) {
-  if (property.type === "Identifier") {
-    return property.name;
-  }
-  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
-    return property.value;
-  }
-  throw new TypeError(`Unsupported static property node '${property.type}'.`);
-}
-function getArrayPatternValues(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return Array.from(value);
-  }
-  if (isSandboxMap(value)) {
-    return Array.from(value.entries, ([key, entry]) => [key, entry]);
-  }
-  if (isSandboxSet(value)) {
-    return [...value.values];
-  }
-  if (isIterableValue(value)) {
-    throw new TypeError(
-      `Array destructuring declarations support only arrays and strings; received ${describeRuntimeValue(value)}.`
-    );
-  }
-  throw new TypeError("Array destructuring declarations require an array or string iterable.");
-}
-function isIterableValue(value) {
-  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
-}
-function describeRuntimeValue(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (typeof value === "object") return value.constructor?.name ?? "Object";
-  return typeof value;
-}
-async function copyObjectRestValue(value, excludedKeys, context) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
-  try {
-    for (const key of ownEnumerableSandboxKeys(value, true)) {
-      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
-      defineProperty(rest, key, await context.getProperty(value, key));
-    }
-    return rest;
-  } finally {
-    release();
-  }
-}
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
-}
-function defineProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-
 // packages/safe-js/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 var activeJob = new AsyncLocalStorage4();
@@ -9377,31 +9172,6 @@ async function suspendJob(pending) {
   }
 }
 
-// packages/safe-js/src/interp/var-hoist.ts
-function hoistVarDeclarations(node, scope) {
-  for (const declaration of hoistedVarDeclarations([node])) {
-    for (const declarator of declaration.declarations) {
-      for (const identifier of boundIdentifiers(declarator.id)) {
-        scope.declareVar(identifier.name);
-      }
-    }
-  }
-}
-
-// packages/safe-js/src/interp/data-checkpoint.ts
-function createDataCheckpoint(budget, context) {
-  let estimatedDataSize = 0;
-  return (value, growth = 0, force = false) => {
-    const limit = budget.limits.dataSize;
-    if (limit === void 0) return;
-    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
-    if (!force && estimatedDataSize <= limit) return;
-    if (context?.reconcileData !== void 0) context.reconcileData(value);
-    else reconcileCompiledValues(budget, [value], context?.compilation);
-    estimatedDataSize = budget.currentDataSize;
-  };
-}
-
 // packages/safe-js/src/interp/iteration.ts
 async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
   const key = asyncProtocol ? Symbol.asyncIterator : Symbol.iterator;
@@ -9715,6 +9485,249 @@ function syncIterator(iterator) {
   };
 }
 
+// packages/safe-js/src/interp/patterns.ts
+async function bindPattern(pattern, value, target, scope, context) {
+  switch (pattern.type) {
+    case "Identifier":
+      bindIdentifier(pattern, value, target, scope);
+      return { ok: true };
+    case "MemberExpression":
+      if ("kind" in target) {
+        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
+      }
+      return bindMemberExpression(pattern, value, scope, context);
+    case "AssignmentPattern":
+      return bindAssignmentPattern(pattern, value, target, scope, context);
+    case "ArrayPattern":
+      return bindArrayPattern(pattern, value, target, scope, context);
+    case "ObjectPattern":
+      return bindObjectPattern(pattern, value, target, scope, context);
+    case "RestElement":
+      return bindPattern(pattern.argument, value, target, scope, context);
+  }
+}
+function bindIdentifier(pattern, value, target, scope) {
+  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
+    if ("assign" in target) {
+      const binding = scope.lookup(pattern.name);
+      if (!binding.found) {
+        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
+      }
+      if (binding.kind === "const") {
+        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
+      }
+    }
+    scope.assign(pattern.name, value);
+    return;
+  }
+  scope.declare(pattern.name, target.kind, value);
+}
+async function bindAssignmentPattern(pattern, value, target, scope, context) {
+  if (value !== void 0) {
+    return bindPattern(pattern.left, value, target, scope, context);
+  }
+  const defaultValue = await context.evaluate(
+    pattern.right,
+    pattern.left.type === "Identifier" ? pattern.left.name : void 0
+  );
+  if (defaultValue.kind !== "normal") {
+    return { ok: false, result: defaultValue };
+  }
+  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
+}
+async function bindArrayPattern(pattern, value, target, scope, context) {
+  const budget = context.budget ?? new Budget();
+  const iterator = await acquireSandboxIterator(
+    value,
+    budget,
+    context.callContext ?? {
+      stack: [],
+      thisValue: void 0,
+      getProperty: context.getProperty
+    }
+  );
+  if (iterator === void 0) throw new TypeError("Array destructuring requires an iterable.");
+  let done = false;
+  const next = async (readValue = true) => {
+    if (done) return { value: void 0 };
+    try {
+      const result = await iterator.next();
+      if (typeof result !== "object" && typeof result !== "function" || result === null)
+        throw new TypeError("Iterator result must be an object.");
+      done = Boolean((await readIteratorResult(iterator, result, "done")).value);
+      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator, result, "value");
+    } catch (error) {
+      done = true;
+      throw error;
+    }
+  };
+  let retained;
+  const release = retainValues(budget, () => [value, iterator.retainedValue, retained]);
+  try {
+    for (let index = 0; index < pattern.elements.length; index += 1) {
+      const element = pattern.elements[index];
+      if (element === null) {
+        await next(false);
+        continue;
+      }
+      let elementValue;
+      if (element.type === "RestElement") {
+        const rest = [];
+        retained = rest;
+        for (let entry = await next(); !done; entry = await next()) {
+          budget.allocateArrayLength(rest.length + 1);
+          rest.push(entry.value);
+        }
+        elementValue = rest;
+      } else {
+        elementValue = (await next()).value;
+      }
+      retained = elementValue;
+      const binding = await bindPattern(element, elementValue, target, scope, context);
+      if (!binding.ok) {
+        if (!done) {
+          done = true;
+          await closeIterator(iterator, binding.result.kind === "throw");
+        }
+        return binding;
+      }
+    }
+    if (!done) {
+      done = true;
+      await closeIterator(iterator);
+    }
+    return { ok: true };
+  } catch (error) {
+    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator, true);
+    throw error;
+  } finally {
+    release();
+  }
+}
+async function bindObjectPattern(pattern, value, target, scope, context) {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const binding2 = await bindPattern(
+        property,
+        await copyObjectRestValue(value, excludedKeys, context),
+        target,
+        scope,
+        context
+      );
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key = await evaluatePatternKey(property, context);
+    if (!key.ok) {
+      return key;
+    }
+    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
+    const binding = await bindPattern(
+      property.value,
+      await context.getProperty(value, key.value),
+      target,
+      scope,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function bindMemberExpression(pattern, value, scope, context) {
+  const object = await context.evaluate(pattern.object);
+  if (object.kind !== "normal") {
+    return { ok: false, result: object };
+  }
+  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
+  if (property.kind !== "normal") {
+    return { ok: false, result: property };
+  }
+  if (object.value === null || object.value === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
+  }
+  if (!isIndexableValue(object.value)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  await context.setProperty(object.value, await context.toPropertyKey(property.value), value);
+  return { ok: true };
+}
+async function evaluatePatternKey(property, context) {
+  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
+}
+async function evaluateProperty(property, context) {
+  const result = await context.evaluate(property);
+  if (result.kind !== "normal") {
+    return { ok: false, result };
+  }
+  return { ok: true, value: await context.toPropertyKey(result.value) };
+}
+function getStaticPropertyName(property) {
+  if (property.type === "Identifier") {
+    return property.name;
+  }
+  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
+    return property.value;
+  }
+  throw new TypeError(`Unsupported static property node '${property.type}'.`);
+}
+async function copyObjectRestValue(value, excludedKeys, context) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
+  try {
+    for (const key of ownEnumerableSandboxKeys(value, true)) {
+      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
+      defineProperty(rest, key, await context.getProperty(value, key));
+    }
+    return rest;
+  } finally {
+    release();
+  }
+}
+function isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function defineProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+
+// packages/safe-js/src/interp/var-hoist.ts
+function hoistVarDeclarations(node, scope) {
+  for (const declaration of hoistedVarDeclarations([node])) {
+    for (const declarator of declaration.declarations) {
+      for (const identifier of boundIdentifiers(declarator.id)) {
+        scope.declareVar(identifier.name);
+      }
+    }
+  }
+}
+
+// packages/safe-js/src/interp/data-checkpoint.ts
+function createDataCheckpoint(budget, context) {
+  let estimatedDataSize = 0;
+  return (value, growth = 0, force = false) => {
+    const limit = budget.limits.dataSize;
+    if (limit === void 0) return;
+    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+    if (!force && estimatedDataSize <= limit) return;
+    if (context?.reconcileData !== void 0) context.reconcileData(value);
+    else reconcileCompiledValues(budget, [value], context?.compilation);
+    estimatedDataSize = budget.currentDataSize;
+  };
+}
+
 // packages/safe-js/src/interp/globals/numeric-parsers.ts
 function createNumericParsers(budget) {
   return {
@@ -15492,6 +15505,7 @@ function createPatternContext(context, scope = context.scope, evaluate = evaluat
   const evaluationContext = { ...context, scope };
   return {
     budget: context.budget,
+    callContext: createCoercionContext(evaluationContext),
     evaluate: (node, inferredName) => evaluate(node, { ...evaluationContext, inferredName }),
     toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
     getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
@@ -35882,4 +35896,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-56XYHJCY.js.map
+//# sourceMappingURL=chunk-VHZYRV5Q.js.map