@poe-platform/safe-js 0.1.404 → 0.1.406

package/dist/safe-js/chunks/{chunk-2RUHJIRX.js → chunk-WHJV4CR7.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-LQCVRFUS.js";
+} from "./chunk-XY5ZPK3G.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-2RUHJIRX.js.map
+//# sourceMappingURL=chunk-WHJV4CR7.js.map

package/dist/safe-js/chunks/{chunk-LQCVRFUS.js → chunk-XY5ZPK3G.js}

@@ -10766,6 +10766,9 @@ function getGeneratorOrigin(value) {
   return generatorOrigins.get(value);
 }
 
+// packages/safe-js/src/interp/construction-state.ts
+var constructionStates = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/async.ts
 function emitResumeBreakpoint(context, breakpoint) {
   context.onYield?.({
@@ -10809,6 +10812,8 @@ function createInterpretedClosure(node, context, evaluateNode2, homeObject, init
   if (node.type !== "ArrowFunctionExpression" && node.generator) {
     return createGeneratorClosure(node, context, evaluateNode2, initializeGeneratorPrototype);
   }
+  const construction = context.functionEnvironment?.construction;
+  const constructionState = construction === void 0 ? void 0 : constructionStates.get(construction);
   const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
     const thisValue = {};
     const newTarget = callContext?.newTarget ?? closure;
@@ -10838,7 +10843,19 @@ function createInterpretedClosure(node, context, evaluateNode2, homeObject, init
     ...node.async ? { async: true } : {},
     ...node.type === "FunctionDeclaration" || node.type === "FunctionExpression" ? node.id === void 0 ? { name: context.inferredName } : { name: node.id.name } : { name: context.inferredName },
     ...construct === void 0 ? {} : { construct },
-    retainedValues: () => [...context.scope.retainedValues(), context.functionEnvironment?.homeObject, context.functionEnvironment?.newTarget],
+    retainedValues: () => {
+      const values = [...context.scope.retainedValues(), context.functionEnvironment?.homeObject, context.functionEnvironment?.newTarget];
+      if (constructionState !== void 0) {
+        values.push(
+          constructionState.constructor,
+          constructionState.newTarget,
+          constructionState.prototype,
+          constructionState.thisValue
+        );
+        if (constructionState.thisScope !== void 0) values.push(...constructionState.thisScope.retainedValues());
+      }
+      return values;
+    },
     call: (args, callContext) => {
       const invocationContext = {
         ...context,
@@ -15903,64 +15920,81 @@ function createClassConstructor(node, context, evaluateNode2, fields2) {
     construct: async (args, invocation) => {
       const prototype = materializeFunctionProperties(constructor).prototype;
       const newTarget = invocation?.newTarget ?? constructor;
-      let thisValue;
-      let thisScope;
-      let initialized = !derived;
-      const initializeFields = async (receiver) => {
-        for (const [name, element] of classOrigins.get(constructor).privateMethods) addPrivateElement(receiver, name, element);
-        for (const field of fields2) {
-          await initializeElement(field, receiver, prototype, classContext, evaluateNode2);
-        }
-      };
-      const superCall = async (argumentsList) => {
-        const superConstructor = getSandboxPrototype(constructor, context.budget);
-        if (!isSandboxClosure(superConstructor) || superConstructor.construct === void 0)
-          throw new TypeError("Super constructor is not a constructor.");
-        const receiver = await invocation.invokeClosure(superConstructor, argumentsList, void 0, true, newTarget);
-        if (initialized) throw new ReferenceError("Super constructor may only initialize this once.");
-        initialized = true;
-        thisValue = receiver;
-        thisScope?.declare("this", "const", receiver);
-        await initializeFields(receiver);
-        return receiver;
+      const state = {
+        constructor,
+        newTarget,
+        prototype,
+        thisValue: void 0,
+        thisScope: void 0,
+        initialized: !derived,
+        activeCalls: 1
       };
-      if (!derived) {
-        thisValue = {};
-        const targetPrototype = await invocation.getProperty(newTarget, "prototype");
-        if (typeof targetPrototype === "object" && targetPrototype !== null)
-          setSandboxPrototype(thisValue, targetPrototype, context.budget);
-      }
-      if (constructorElement === void 0) {
-        if (derived) return superCall(args);
-        await initializeFields(thisValue);
-        return thisValue;
-      }
-      const result = await executeClosure(constructorElement.value, args, thisValue, {
-        ...classContext,
-        compilation: invocation?.compilation ?? context.compilation,
-        callStack: [...invocation?.stack ?? context.callStack],
-        functionEnvironment: {
-          newTarget,
-          homeObject: prototype,
-          construction: {
-            derived,
-            superCall,
-            initialize: async (functionScope) => {
-              thisScope = functionScope;
-              if (!derived) await initializeFields(thisValue);
-            }
-          }
-        }
-      }, evaluateNode2);
-      if (typeof result === "object" && result !== null) return result;
-      if (derived && result !== void 0) throw new TypeError("Derived constructors may only return an object or undefined.");
-      if (!initialized) throw new ReferenceError("Must call super constructor before returning from derived constructor.");
-      return thisValue;
+      try {
+        const construction = createConstructionEnvironment(state, classContext, evaluateNode2, invocation);
+        if (!derived) {
+          state.thisValue = {};
+          const targetPrototype = await invocation.getProperty(newTarget, "prototype");
+          if (typeof targetPrototype === "object" && targetPrototype !== null)
+            setSandboxPrototype(state.thisValue, targetPrototype, context.budget);
+        }
+        if (constructorElement === void 0) {
+          if (derived) return construction.superCall(args);
+          await initializeConstructionFields(state, classContext, evaluateNode2);
+          return state.thisValue;
+        }
+        const result = await executeClosure(constructorElement.value, args, state.thisValue, {
+          ...classContext,
+          compilation: invocation?.compilation ?? context.compilation,
+          callStack: [...invocation?.stack ?? context.callStack],
+          functionEnvironment: { newTarget, homeObject: prototype, construction }
+        }, evaluateNode2);
+        if (typeof result === "object" && result !== null) return result;
+        if (derived && result !== void 0) throw new TypeError("Derived constructors may only return an object or undefined.");
+        if (!state.initialized) throw new ReferenceError("Must call super constructor before returning from derived constructor.");
+        return state.thisValue;
+      } finally {
+        state.activeCalls--;
+      }
     }
   });
   classOrigins.set(constructor, { node, scope, fields: fields2, initialized: false, privateMethods: /* @__PURE__ */ new Map() });
   return constructor;
 }
+function createConstructionEnvironment(state, context, evaluateNode2, invocation = createCoercionContext(context)) {
+  const derived = classOrigins.get(state.constructor).node.superClass !== void 0;
+  const construction = {
+    derived,
+    initialize: async (scope) => {
+      state.thisScope = scope;
+      if (!derived) await initializeConstructionFields(state, context, evaluateNode2);
+    },
+    superCall: async (args) => {
+      state.activeCalls++;
+      try {
+        const parent = getSandboxPrototype(state.constructor, context.budget);
+        if (!isSandboxClosure(parent) || parent.construct === void 0)
+          throw new TypeError("Super constructor is not a constructor.");
+        const receiver = await invocation.invokeClosure(parent, args, void 0, true, state.newTarget);
+        if (state.initialized) throw new ReferenceError("Super constructor may only initialize this once.");
+        state.initialized = true;
+        state.thisValue = receiver;
+        state.thisScope?.declare("this", "const", receiver);
+        await initializeConstructionFields(state, context, evaluateNode2);
+        return receiver;
+      } finally {
+        state.activeCalls--;
+      }
+    }
+  };
+  constructionStates.set(construction, state);
+  return construction;
+}
+async function initializeConstructionFields(state, context, evaluateNode2) {
+  const origin = classOrigins.get(state.constructor);
+  for (const [name, element] of origin.privateMethods) addPrivateElement(state.thisValue, name, element);
+  for (const field of origin.fields)
+    await initializeElement(field, state.thisValue, state.prototype, context, evaluateNode2);
+}
 async function initializeElement(definition, receiver, homeObject, context, evaluateNode2) {
   const scope = context.scope.child({}, { functionBoundary: true });
   scope.declare("this", "const", receiver);
@@ -22368,6 +22402,20 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const construction = constructionStates.get(value);
+  if (construction !== void 0) {
+    if (construction.activeCalls !== 0 || construction.thisScope === void 0)
+      throw new TypeError("Active class construction environments cannot yet be serialized.");
+    return {
+      kind: "construction-environment",
+      constructor: encode(construction.constructor),
+      newTarget: encode(construction.newTarget),
+      prototype: encode(construction.prototype),
+      thisValue: encode(construction.thisValue),
+      thisScope: encode(construction.thisScope),
+      initialized: construction.initialized
+    };
+  }
   const executor = isSandboxClosure(value) ? promiseCapabilityExecutors.get(value) : void 0;
   if (executor !== void 0)
     return { kind: "capability-executor", resolve: encode(executor.resolve), reject: encode(executor.reject), state: captureObjectState(value, encode) };
@@ -22593,7 +22641,6 @@ function captureGuestHeapNode(value, encode) {
   if (isSandboxGenerator(value)) {
     const origin2 = getGeneratorOrigin(value);
     if (origin2?.node.nodeId === void 0) throw new TypeError("Generators require a captured origin for public dumps.");
-    if (origin2.environment?.construction !== void 0) throw new TypeError("Active class construction environments cannot yet be serialized.");
     const channel = value.channel.snapshot();
     return {
       kind: "guest-generator",
@@ -22674,7 +22721,8 @@ function captureGuestHeapNode(value, encode) {
       sent: channel.sent.map((completion) => ({ type: completion.type, value: encode(completion.value) })),
       ...origin2.environment === void 0 ? {} : { environment: {
         ...origin2.environment.homeObject === void 0 ? {} : { homeObject: encode(origin2.environment.homeObject) },
-        ...origin2.environment.newTarget === void 0 ? {} : { newTarget: encode(origin2.environment.newTarget) }
+        ...origin2.environment.newTarget === void 0 ? {} : { newTarget: encode(origin2.environment.newTarget) },
+        ...origin2.environment.construction === void 0 ? {} : { construction: encode(origin2.environment.construction) }
       } }
     };
   }
@@ -22707,8 +22755,6 @@ function captureGuestHeapNode(value, encode) {
     return void 0;
   }
   if (origin.node.nodeId === void 0) throw new TypeError("Guest closures require an AST node identity.");
-  if (origin.environment?.construction !== void 0)
-    throw new TypeError("Active class construction environments cannot yet be serialized.");
   const state = captureObjectState(value, encode);
   if (state === void 0) throw new TypeError("Guest closures require a property state.");
   return {
@@ -22719,7 +22765,8 @@ function captureGuestHeapNode(value, encode) {
     ...isSandboxClosure(value) && value.name !== void 0 ? { name: value.name } : {},
     ...origin.environment === void 0 ? {} : { environment: {
       ...origin.environment.homeObject === void 0 ? {} : { homeObject: encode(origin.environment.homeObject) },
-      ...origin.environment.newTarget === void 0 ? {} : { newTarget: encode(origin.environment.newTarget) }
+      ...origin.environment.newTarget === void 0 ? {} : { newTarget: encode(origin.environment.newTarget) },
+      ...origin.environment.construction === void 0 ? {} : { construction: encode(origin.environment.construction) }
     } }
   };
 }
@@ -27913,7 +27960,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -28005,7 +28052,25 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "capability-executor") {
+  if (node.kind === "construction-environment") {
+    fields(node, ["kind", "constructor", "newTarget", "prototype", "thisValue", "thisScope", "initialized"]);
+    const owner = reference(node.constructor, ["guest-class"]);
+    callable(node.newTarget);
+    const prototype = reference(node.prototype);
+    const scope = reference(node.thisScope, ["scope-frame"]);
+    if (typeof node.initialized !== "boolean") throw new TypeError("Invalid construction initialization flag.");
+    if (!node.initialized && !absent(node.thisValue)) throw new TypeError("Uninitialized construction cannot have this value.");
+    const property = array(record3(record3(owner.state).properties).properties).map(array).find((entry) => entry[0] === "prototype");
+    if (property === void 0 || record3(property[1]).kind !== "data" || reference(record3(property[1]).value) !== prototype)
+      throw new TypeError("Invalid construction prototype ownership.");
+    if (absent(scope.parent) || reference(scope.parent, ["scope-frame"]) !== reference(owner.scope, ["scope-frame"]))
+      throw new TypeError("Invalid construction scope ownership.");
+    const binding = array(scope.bindings).map(array).find((entry) => entry[0] === "this");
+    if (binding === void 0) throw new TypeError("Invalid construction this binding.");
+    const cell = record3(array(scope.cells)[integer(binding[1])]);
+    if (cell.kind !== "const" || cell.initialized !== node.initialized || node.initialized && reference(cell.value) !== reference(node.thisValue))
+      throw new TypeError("Invalid construction this binding.");
+  } else if (node.kind === "capability-executor") {
     fields(node, ["kind", "resolve", "reject", "state"]);
     state(node.state);
   } else if (node.kind === "promise-aggregate") {
@@ -28294,9 +28359,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (Object.hasOwn(node, "name") && typeof node.name !== "string") throw new TypeError("Invalid guest function name.");
     if (Object.hasOwn(node, "environment")) {
       const environment = record3(node.environment);
-      fields(environment, [], ["homeObject", "newTarget"]);
+      fields(environment, [], ["homeObject", "newTarget", "construction"]);
       if (Object.hasOwn(environment, "homeObject")) reference(environment.homeObject);
       if (Object.hasOwn(environment, "newTarget")) callable(environment.newTarget);
+      if (Object.hasOwn(environment, "construction")) reference(environment.construction, ["construction-environment"]);
     }
     state(node.state);
   } else if (node.kind === "guest-generator") {
@@ -28463,9 +28529,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     if (Object.hasOwn(node, "environment")) {
       const environment = record3(node.environment);
-      fields(environment, [], ["homeObject", "newTarget"]);
+      fields(environment, [], ["homeObject", "newTarget", "construction"]);
       if (Object.hasOwn(environment, "homeObject")) reference(environment.homeObject);
       if (Object.hasOwn(environment, "newTarget")) callable(environment.newTarget);
+      if (Object.hasOwn(environment, "construction")) reference(environment.construction, ["construction-environment"]);
     }
   } else {
     fields(node, ["kind", "parent", "importMeta", "functionBoundary", "chargeData", "bindings", "cells"], ["restoredBindings", "privateNames"]);
@@ -28917,7 +28984,7 @@ function validateDumpHeap(root, state) {
     fail("invalidCycle", "$.heap", error instanceof Error ? error.message : "invalid guest scope parent graph");
   }
 }
-function validateDumpReferences(value, path, depth, state, heapIds, heap, role = "data", allowScopeReference = false) {
+function validateDumpReferences(value, path, depth, state, heapIds, heap, role = "data", allowScopeReference = false, allowConstructionReference = false) {
   if (value === null || typeof value !== "object") return;
   if (depth > state.limits.maxDepth)
     fail("budgetExceeded", path, `exceeds nesting limit ${state.limits.maxDepth}`);
@@ -28933,11 +29000,23 @@ function validateDumpReferences(value, path, depth, state, heapIds, heap, role =
     if (!heapIds.has(id)) fail("danglingReference", `${path}.id`, `unknown heap value ${id}`);
     if (heap[String(id)].kind === "scope-frame" && !allowScopeReference)
       fail("invalidValue", path, "Internal scopes cannot be guest data");
+    if (heap[String(id)].kind === "construction-environment" && !allowConstructionReference)
+      fail("invalidValue", path, "Internal construction environments cannot be guest data");
   }
   for (const [key, entry] of Object.entries(record4)) {
-    const childRole = role === "root" && key === "heap" ? "heap" : role === "heap" ? "heap-node" : role === "heap-node" && record4.kind === "guest-generator" && key === "blockScopes" ? "scope-map" : role === "heap-node" && record4.kind === "guest-generator" && key === "expressionStates" ? "expressions" : role === "expressions" ? "expression" : "data";
-    const scopeField = role === "scope-map" || role === "expression" && (record4.kind === "for" && ["loopScope", "activeScope"].includes(key) || ["switch", "for-in", "for-of-array", "for-of-iterator"].includes(String(record4.kind)) && key === "scope") || role === "heap-node" && (record4.kind === "scope-frame" && key === "parent" || (record4.kind === "guest-function" || record4.kind === "guest-class") && key === "scope" || record4.kind === "guest-generator" && ["scope", "closureScope", "suspendedScope"].includes(key));
-    validateDumpReferences(entry, `${path}${formatKey(key)}`, depth + 1, state, heapIds, heap, childRole, scopeField);
+    const childRole = role === "root" && key === "heap" ? "heap" : role === "heap" ? "heap-node" : role === "heap-node" && (record4.kind === "guest-function" || record4.kind === "guest-generator") && key === "environment" ? "function-environment" : role === "heap-node" && record4.kind === "guest-generator" && key === "blockScopes" ? "scope-map" : role === "heap-node" && record4.kind === "guest-generator" && key === "expressionStates" ? "expressions" : role === "expressions" ? "expression" : "data";
+    const scopeField = role === "scope-map" || role === "expression" && (record4.kind === "for" && ["loopScope", "activeScope"].includes(key) || ["switch", "for-in", "for-of-array", "for-of-iterator"].includes(String(record4.kind)) && key === "scope") || role === "heap-node" && (record4.kind === "scope-frame" && key === "parent" || record4.kind === "construction-environment" && key === "thisScope" || (record4.kind === "guest-function" || record4.kind === "guest-class") && key === "scope" || record4.kind === "guest-generator" && ["scope", "closureScope", "suspendedScope"].includes(key));
+    validateDumpReferences(
+      entry,
+      `${path}${formatKey(key)}`,
+      depth + 1,
+      state,
+      heapIds,
+      heap,
+      childRole,
+      scopeField,
+      role === "function-environment" && key === "construction"
+    );
   }
 }
 function validateRunSnapshotState(root, state) {
@@ -30236,9 +30315,8 @@ function measureSandboxData(values, options = {}) {
       const storage = typedArrayStorage(value);
       visit(storage.buffer, depth + 1);
       for (const [key, descriptor] of typedArrayProperties(value)) {
-        usage += 1;
-        if (typeof key === "string") usage += key.length;
-        else visit(key, depth + 1);
+        if (typeof key !== "string") continue;
+        usage += 1 + key.length;
         if ("value" in descriptor) visit(descriptor.value, depth + 1);
         else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
       }
@@ -45374,4 +45452,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-LQCVRFUS.js.map
+//# sourceMappingURL=chunk-XY5ZPK3G.js.map