@poe-platform/safe-js 0.1.418 → 0.1.420

package/dist/safe-js/chunks/{chunk-VL4HQ4WF.js → chunk-Q5EFE5BH.js}

@@ -7768,6 +7768,8 @@ function writePropertyDescriptor(descriptor, receiver, value, context) {
 var wellKnownSymbols = Object.freeze({
   iterator: Symbol.iterator,
   asyncIterator: Symbol.asyncIterator,
+  dispose: Symbol.dispose ?? /* @__PURE__ */ Symbol.for("nodejs.dispose"),
+  asyncDispose: Symbol.asyncDispose ?? /* @__PURE__ */ Symbol.for("nodejs.asyncDispose"),
   hasInstance: Symbol.hasInstance,
   isConcatSpreadable: Symbol.isConcatSpreadable,
   match: Symbol.match,
@@ -8688,6 +8690,9 @@ function nextStringIterator(value, budget) {
 // packages/safe-js/src/interp/iterator-wrapper.ts
 var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
 
+// packages/safe-js/src/interp/disposable-stack.ts
+var disposableStackStates = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/iterator-helper.ts
 var iteratorHelperStates = /* @__PURE__ */ new WeakMap();
 
@@ -22512,6 +22517,16 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const disposable = disposableStackStates.get(value);
+  if (disposable !== void 0) {
+    if (disposable.active) throw new SnapshotNotReadyError("Cannot snapshot active synchronous resource cleanup.");
+    return {
+      kind: "disposable-stack",
+      disposed: disposable.disposed,
+      resources: disposable.resources.map((resource) => ({ method: encode(resource.method), receiver: encode(resource.receiver), args: resource.args.map(encode) })),
+      state: captureObjectState(value, encode)
+    };
+  }
   const construction = constructionStates.get(value);
   if (construction !== void 0) {
     if (construction.activeCalls !== 0 || construction.thisScope === void 0)
@@ -27402,6 +27417,128 @@ function createIteratorGlobal(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/disposable-stack.ts
+function createDisposableStackGlobal(budget) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  setSandboxPrototype(prototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "DisposableStack",
+    length: 0,
+    call: () => {
+      throw new TypeError("DisposableStack requires new.");
+    },
+    construct: async (_args, context) => {
+      const parent = await read(context?.newTarget ?? constructor, "prototype", context);
+      const instance = /* @__PURE__ */ Object.create(null);
+      disposableStackStates.set(instance, { disposed: false, active: false, resources: [] });
+      setSandboxPrototype(instance, parent !== null && typeof parent === "object" ? parent : prototype, budget);
+      createDataCheckpoint(budget, context)(instance, 0, true);
+      return instance;
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "DisposableStack", configurable: true },
+    disposed: { get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get disposed",
+      length: 0,
+      call: (_args, context) => requireState(context?.thisValue).disposed
+    }), "get"), configurable: true }
+  });
+  for (const name of ["use", "adopt", "defer", "move", "dispose"]) {
+    const method = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name,
+      length: name === "adopt" ? 2 : name === "move" || name === "dispose" ? 0 : 1,
+      call: async (args, context) => {
+        const receiver = context?.thisValue;
+        const state = requireState(receiver);
+        if (name === "dispose") {
+          if (state.disposed) return void 0;
+          state.disposed = true;
+          state.active = true;
+          let failed = false;
+          let failure;
+          let current;
+          const release = retainValues(budget, () => [
+            receiver,
+            failure,
+            ...current === void 0 ? [] : [current.method, current.receiver, ...current.args]
+          ]);
+          try {
+            while ((current = state.resources.pop()) !== void 0) {
+              budget.visitNode();
+              try {
+                await invokeBuiltinClosure(current.method, current.args, budget, context, current.receiver);
+              } catch (error) {
+                if (isFatalSandboxError(error)) throw error;
+                const thrown = createThrowCompletion(error, budget, context?.stack ?? []).value;
+                if (failed) {
+                  const combined = createSubsetErrorValue("SuppressedError", void 0, context?.stack ?? [], budget);
+                  Object.defineProperties(combined, {
+                    error: { value: thrown, writable: true, configurable: true },
+                    suppressed: { value: failure, writable: true, configurable: true }
+                  });
+                  failure = combined;
+                } else {
+                  failed = true;
+                  failure = thrown;
+                }
+              }
+            }
+            if (failed) throw failure;
+            return void 0;
+          } finally {
+            state.active = false;
+            release();
+          }
+        }
+        if (state.disposed) throw new ReferenceError("DisposableStack is already disposed.");
+        if (name === "move") {
+          const moved = /* @__PURE__ */ Object.create(null);
+          disposableStackStates.set(moved, { disposed: false, active: false, resources: state.resources });
+          setSandboxPrototype(moved, prototype, budget);
+          state.resources = [];
+          state.disposed = true;
+          createDataCheckpoint(budget, context)(moved, 0, true);
+          return moved;
+        }
+        const value = args[0];
+        if (name === "use" && (value === null || value === void 0)) return value;
+        if (name === "use" && typeof value !== "object") throw new TypeError("Disposable resource must be an object.");
+        const resources = state.resources;
+        const method2 = name === "use" ? await read(value, wellKnownSymbols.dispose, context) : args[name === "adopt" ? 1 : 0];
+        if (!isSandboxClosure(method2)) throw new TypeError("Disposer must be callable.");
+        resources.push({ method: method2, receiver: name === "use" ? value : void 0, args: name === "adopt" ? [value] : [] });
+        createDataCheckpoint(budget, context)(receiver, 0, true);
+        return name === "defer" ? void 0 : value;
+      }
+    });
+    Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
+    if (name === "dispose") Object.defineProperty(prototype, wellKnownSymbols.dispose, { value: method, writable: true, configurable: true });
+  }
+  registerBuiltinIdentities(budget, { DisposableStack: constructor });
+  registerIntrinsicFunction(budget, constructor);
+  registerIntrinsicObject(budget, prototype);
+  return constructor;
+  async function read(value, key, context) {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  }
+}
+function requireState(receiver) {
+  const state = receiver !== null && typeof receiver === "object" ? disposableStackStates.get(receiver) : void 0;
+  if (state === void 0) throw new TypeError("DisposableStack method requires a branded receiver.");
+  return state;
+}
+
 // packages/safe-js/src/interp/globals/symbol.ts
 var registries = /* @__PURE__ */ new WeakMap();
 function createSymbolGlobal(budget) {
@@ -28029,6 +28166,7 @@ function createBuiltinBindings(options) {
     ...createMathGlobals({ random: options.random, budget: options.budget }),
     ...createObjectArrayGlobals(options),
     Iterator: createIteratorGlobal(options.budget),
+    DisposableStack: createDisposableStackGlobal(options.budget),
     Reflect: createReflectGlobal(options.budget),
     ArrayBuffer: createArrayBufferGlobal(options.budget),
     DataView: createDataViewGlobal(options.budget),
@@ -28106,7 +28244,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["thenable-state", "thenable-resolver", "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;
+  if (!["thenable-state", "thenable-resolver", "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", "disposable-stack", "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"]);
@@ -28401,6 +28539,19 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     const iterator = reference(node.iterator);
     if (iterator.kind === "symbol" || iterator.kind === "scope-frame") throw new TypeError("Invalid wrapped iterator.");
     state(node.state);
+  } else if (node.kind === "disposable-stack") {
+    fields(node, ["kind", "disposed", "resources", "state"]);
+    const resources = array(node.resources);
+    if (typeof node.disposed !== "boolean" || resources.length > maxArrayLength)
+      throw new TypeError("Invalid disposable stack state.");
+    for (const rawResource of resources) {
+      const resource = record3(rawResource);
+      fields(resource, ["method", "receiver", "args"]);
+      if (absent(resource.method)) throw new TypeError("Missing disposer.");
+      callable(resource.method);
+      if (array(resource.args).length > 1) throw new TypeError("Invalid disposer arguments.");
+    }
+    state(node.state);
   } else if (node.kind === "intrinsic") {
     fields(node, ["kind", "id"], ["state", "symbolRegistry"]);
     if (typeof node.id !== "string" || !intrinsicCatalogue().has(node.id)) throw new TypeError("Unknown intrinsic identity.");
@@ -30328,6 +30479,8 @@ function* cloneStructuredGraph(value, state, budget, depth = 0) {
   if (typeof value !== "object" || value === null) return allocateProducedSandboxValue(value, budget);
   if (iteratorHelperStates.has(value) || iteratorWrapperStates.has(value))
     throw new DOMException("Iterator objects cannot be structured cloned.", "DataCloneError");
+  if (disposableStackStates.has(value))
+    throw new DOMException("Disposable stacks cannot be structured cloned.", "DataCloneError");
   if (isLiveCapability(value)) throw new DOMException("Capabilities cannot be structured cloned.", "DataCloneError");
   const existing = state.seen.get(value);
   if (existing !== void 0) return existing;
@@ -30427,6 +30580,7 @@ function measureSandboxData(values, options = {}) {
     assertSandboxDataDepth(depth);
     seen.add(value);
     usage += 1;
+    const disposableResources = disposableStackStates.get(value)?.resources.map((resource) => [resource.method, resource.receiver, ...resource.args]);
     const arrayLength = Array.isArray(value) ? value.length : void 0;
     const managedArray = arrayLength !== void 0 && hasManagedDescriptors(value);
     let arrayDescriptors;
@@ -30492,6 +30646,10 @@ function measureSandboxData(values, options = {}) {
       return;
     }
     const wrapperState = iteratorWrapperStates.get(value);
+    if (disposableResources !== void 0) {
+      usage += disposableResources.length;
+      for (const resource of disposableResources) for (const retained2 of resource) visit(retained2, depth + 1);
+    }
     if (wrapperState !== void 0) {
       visit(wrapperState.iterator, depth + 1);
       visit(wrapperState.next, depth + 1);
@@ -33132,6 +33290,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Boolean",
   "BigInt",
   "Date",
+  "DisposableStack",
   "decodeURI",
   "decodeURIComponent",
   "encodeURI",
@@ -45650,4 +45809,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-VL4HQ4WF.js.map
+//# sourceMappingURL=chunk-Q5EFE5BH.js.map