poe-code 14.0.16 → 14.0.18

package/dist/index.js

@@ -125635,11 +125635,15 @@ function createLiveHostObject(definition, controller) {
   if (input.named !== void 0) {
     const data = readDataRecord(input.named, "Named host capability");
     if (Object.keys(data).some(
-      (key3) => !["keys", "get", "maxKeys", "maxKeyCodeUnits", "enumerable"].includes(key3)
+      (key3) => !["keys", "get", "set", "delete", "maxKeys", "maxKeyCodeUnits", "enumerable"].includes(key3)
     ))
       throw new TypeError("Unknown named host capability field.");
-    if (typeof data.keys !== "function" || typeof data.get !== "function")
-      throw new TypeError("Named keys and get must be synchronous functions.");
+    for (const name of ["keys", "get", "set", "delete"]) {
+      const operation = data[name];
+      if (operation === void 0 && (name === "set" || name === "delete")) continue;
+      if (typeof operation !== "function" || types2.isProxy(operation) || types2.isAsyncFunction(operation) || types2.isGeneratorFunction(operation))
+        throw new TypeError(`Named ${name} must be a synchronous non-generator function, not a proxy.`);
+    }
     if (typeof data.maxKeys !== "number" || !Number.isInteger(data.maxKeys) || data.maxKeys < 1 || data.maxKeys > MAX_NAMED_KEYS)
       throw new RangeError(`Named maxKeys must be an integer from 1 to ${MAX_NAMED_KEYS}.`);
     if (typeof data.maxKeyCodeUnits !== "number" || !Number.isInteger(data.maxKeyCodeUnits) || data.maxKeyCodeUnits < 1 || data.maxKeyCodeUnits > MAX_NAMED_KEY_CODE_UNITS)
@@ -125651,6 +125655,8 @@ function createLiveHostObject(definition, controller) {
     named = {
       keys: data.keys,
       get: data.get,
+      set: data.set,
+      delete: data.delete,
       maxKeys: data.maxKeys,
       maxKeyCodeUnits: data.maxKeyCodeUnits,
       enumerable: data.enumerable
@@ -125774,8 +125780,28 @@ function setHostObjectMember(value, key3, entry) {
   state.controller.assertActive();
   state.controller.chargeWork();
   const property = state.properties.get(key3);
-  if (property?.set === void 0) throw new TypeError(`Host property '${key3}' is not writable.`);
-  state.controller.write(property.set, entry);
+  if (property !== void 0) {
+    if (property.set === void 0) throw new TypeError(`Host property '${key3}' is not writable.`);
+    state.controller.write(property.set, entry);
+    return;
+  }
+  if (state.named?.set === void 0) throw new TypeError(`Host property '${key3}' is not writable.`);
+  namedMutationKeys(state, key3, true);
+  state.controller.write((value2) => state.named.set(key3, value2), entry);
+  namedKeys2(state);
+}
+function deleteHostObjectMember(value, key3) {
+  const state = guestObjects.get(value);
+  state.controller.assertActive();
+  state.controller.chargeWork();
+  if (state.named?.delete === void 0) throw new TypeError("Live host properties cannot be deleted.");
+  if (!namedMutationKeys(state, key3, false).includes(key3)) return true;
+  const deleted = state.controller.read(() => state.named.delete(key3), (result) => {
+    if (typeof result !== "boolean") throw new TypeError("Named delete must return a boolean.");
+    return result;
+  });
+  namedKeys2(state);
+  return deleted;
 }
 function getHostObjectKeys(value) {
   const state = guestObjects.get(value);
@@ -125846,6 +125872,27 @@ function canonicalIndex(key3) {
   const index = Number(key3);
   return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key3 ? index : void 0;
 }
+function namedMutationKeys(state, key3, create) {
+  state.controller.chargeWork(key3.length);
+  state.controller.checkString(key3);
+  if (["constructor", "prototype", "__proto__"].includes(key3) || state.properties.has(key3) || state.methods.has(key3) || state.indexed !== void 0 && (key3 === "length" || canonicalIndex(key3) !== void 0))
+    throw new TypeError(`Host member '${key3}' is protected from named mutation.`);
+  const named = state.named;
+  if (key3.length > named.maxKeyCodeUnits)
+    throw new RangeError("Named key exceeds maximum UTF-16 code units.");
+  const keys = namedKeys2(state);
+  if (create && !keys.includes(key3)) {
+    const length = keys.length + 1;
+    if (length > named.maxKeys) throw new RangeError("Named keys exceed maxKeys.");
+    state.controller.checkLength(length);
+    let units = key3.length;
+    for (const existing of keys) units += existing.length;
+    if (units > named.maxKeyCodeUnits)
+      throw new RangeError("Named keys exceed maximum UTF-16 code units.");
+    state.controller.checkTemporaryDataSize(1 + length + units);
+  }
+  return keys;
+}
 function namedKeys2(state) {
   const named = state.named;
   return state.controller.read(named.keys, (value) => {
@@ -147054,11 +147101,11 @@ async function evaluateDeleteExpression(node, context) {
   if (!isIndexableSandboxValue(member.object)) {
     throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
   }
-  deleteSandboxProperty(member.object, member.property);
+  const deleted = deleteSandboxProperty(member.object, member.property);
   return {
     kind: "normal",
     hasValue: true,
-    value: true
+    value: deleted
   };
 }
 async function evaluateUpdateExpression(node, context) {
@@ -147920,12 +147967,12 @@ function setSandboxProperty(target, property, value, budget) {
   }
 }
 function deleteSandboxProperty(target, property) {
-  if (isGuestHostObject(target)) throw new TypeError("Live host properties cannot be deleted.");
+  if (isGuestHostObject(target)) return deleteHostObjectMember(target, String(property));
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
   }
-  delete target[String(property)];
+  return delete target[String(property)];
 }
 function getClosureMemberValue(target, property, context) {
   return getFunctionMember(target, property, createFunctionMethodOptions(context));
@@ -151284,6 +151331,9 @@ var init_realm = __esm({
           assertActive: this.assertOpen,
           chargeWork: this.chargeWork,
           checkLength: (length) => this.budget.allocateArrayLength(length),
+          checkString: (value) => {
+            this.budget.allocateString(value);
+          },
           checkTemporaryDataSize: (size) => {
             const temporary = {};
             try {
@@ -151296,7 +151346,7 @@ var init_realm = __esm({
             const value = this.invokeHost(operation, operation);
             if (types5.isPromise(value)) {
               void Promise.resolve(value).catch(() => void 0);
-              throw new TypeError("Live property getters must be synchronous.");
+              throw new TypeError("Live property operations must be synchronous.");
             }
             return this.importValue(validate2 === void 0 ? value : validate2(value));
           },
@@ -159695,7 +159745,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "14.0.16",
+      version: "14.0.18",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",
@@ -159997,7 +160047,9 @@ var init_package2 = __esm({
         postinstall: "node scripts/postinstall-sync-skills.mjs",
         "test:workspaces": "node scripts/build-workspaces.mjs --test-unit",
         "test:stress:lint": "vitest run --config vitest.lint-stress.config.ts",
-        posttest: "npm run test:stress:lint"
+        posttest: "npm run test:stress:lint",
+        "test:ci:fresh": "node scripts/build-workspaces.mjs --test-unit --ci-group=fresh",
+        "test:ci:cached": "node scripts/build-workspaces.mjs --test-unit --ci-group=cached"
       },
       bin: {
         poe: "dist/bin.cjs",