poe-code 8.0.1 → 9.0.0

package/dist/index.js

@@ -16370,17 +16370,17 @@ function validate(schema, value) {
   }
   return { ok: true, value: result.present ? result.value : void 0 };
 }
-function walkSchema(schema, value, path189, state) {
+function walkSchema(schema, value, path190, state) {
   if (schema.kind === "optional") {
-    return walkOptional(schema, value, path189, state);
+    return walkOptional(schema, value, path190, state);
   }
   if (value === missingValue) {
     addIssue(
       state,
-      path189,
+      path190,
       expectedFor(schema),
       "missing",
-      `Expected ${expectedFor(schema)} at ${formatPath(path189)}`
+      `Expected ${expectedFor(schema)} at ${formatPath(path190)}`
     );
     return { present: false };
   }
@@ -16389,149 +16389,149 @@ function walkSchema(schema, value, path189, state) {
   }
   switch (schema.kind) {
     case "string":
-      return walkString(schema, value, path189, state);
+      return walkString(schema, value, path190, state);
     case "number":
-      return walkNumber(schema, value, path189, state);
+      return walkNumber(schema, value, path190, state);
     case "boolean":
-      return walkBoolean(value, path189, state);
+      return walkBoolean(value, path190, state);
     case "enum":
-      return walkEnum(schema, value, path189, state);
+      return walkEnum(schema, value, path190, state);
     case "array":
-      return walkArray(schema, value, path189, state);
+      return walkArray(schema, value, path190, state);
     case "object":
-      return walkObject(schema, value, path189, state);
+      return walkObject(schema, value, path190, state);
     case "oneOf":
-      return walkOneOf(schema, value, path189, state);
+      return walkOneOf(schema, value, path190, state);
     case "union":
-      return walkUnion(schema, value, path189, state);
+      return walkUnion(schema, value, path190, state);
     case "record":
-      return walkRecord(schema, value, path189, state);
+      return walkRecord(schema, value, path190, state);
     case "json":
-      return walkJson(value, path189, state);
+      return walkJson(value, path190, state);
   }
 }
-function walkOptional(schema, value, path189, state) {
+function walkOptional(schema, value, path190, state) {
   if (value === missingValue || value === void 0) {
     const defaultValue = getDefault(schema.inner);
     if (defaultValue.present) {
-      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path189, state);
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path190, state);
     }
     return { present: false };
   }
-  return walkSchema(schema.inner, value, path189, state);
+  return walkSchema(schema.inner, value, path190, state);
 }
-function walkString(schema, value, path189, state) {
+function walkString(schema, value, path190, state) {
   if (typeof value !== "string") {
-    addExpectedIssue(state, path189, "string", value);
+    addExpectedIssue(state, path190, "string", value);
     return { present: true, value };
   }
   if (schema.minLength !== void 0 && value.length < schema.minLength) {
     const expected = `string with length at least ${schema.minLength}`;
     addIssue(
       state,
-      path189,
+      path190,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path189)}`
+      `Expected ${expected} at ${formatPath(path190)}`
     );
   }
   if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
     const expected = `string with length at most ${schema.maxLength}`;
     addIssue(
       state,
-      path189,
+      path190,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path189)}`
+      `Expected ${expected} at ${formatPath(path190)}`
     );
   }
   if (schema.pattern !== void 0) {
     const pattern = compilePattern(schema.pattern);
     if (pattern === void 0 || !pattern.test(value)) {
       const expected = `string matching pattern ${schema.pattern}`;
-      addIssue(state, path189, expected, value, `Expected ${expected} at ${formatPath(path189)}`);
+      addIssue(state, path190, expected, value, `Expected ${expected} at ${formatPath(path190)}`);
     }
   }
   return { present: true, value };
 }
-function walkNumber(schema, value, path189, state) {
+function walkNumber(schema, value, path190, state) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    addExpectedIssue(state, path189, schema.jsonType === "integer" ? "integer" : "number", value);
+    addExpectedIssue(state, path190, schema.jsonType === "integer" ? "integer" : "number", value);
     return { present: true, value };
   }
   if (schema.jsonType === "integer" && !Number.isInteger(value)) {
-    addExpectedIssue(state, path189, "integer", value);
+    addExpectedIssue(state, path190, "integer", value);
   }
   if (schema.minimum !== void 0 && value < schema.minimum) {
     const expected = `number greater than or equal to ${schema.minimum}`;
-    addIssue(state, path189, expected, String(value), `Expected ${expected} at ${formatPath(path189)}`);
+    addIssue(state, path190, expected, String(value), `Expected ${expected} at ${formatPath(path190)}`);
   }
   if (schema.maximum !== void 0 && value > schema.maximum) {
     const expected = `number less than or equal to ${schema.maximum}`;
-    addIssue(state, path189, expected, String(value), `Expected ${expected} at ${formatPath(path189)}`);
+    addIssue(state, path190, expected, String(value), `Expected ${expected} at ${formatPath(path190)}`);
   }
   return { present: true, value };
 }
-function walkBoolean(value, path189, state) {
+function walkBoolean(value, path190, state) {
   if (typeof value !== "boolean") {
-    addExpectedIssue(state, path189, "boolean", value);
+    addExpectedIssue(state, path190, "boolean", value);
   }
   return { present: true, value };
 }
-function walkEnum(schema, value, path189, state) {
+function walkEnum(schema, value, path190, state) {
   if (!schema.values.includes(value)) {
     const expected = `one of ${schema.values.join(", ")}`;
     addIssue(
       state,
-      path189,
+      path190,
       expected,
       receivedValue(value),
-      `Expected ${expected} at ${formatPath(path189)}`
+      `Expected ${expected} at ${formatPath(path190)}`
     );
   }
   return { present: true, value };
 }
-function walkArray(schema, value, path189, state) {
+function walkArray(schema, value, path190, state) {
   if (!Array.isArray(value)) {
-    addExpectedIssue(state, path189, "array", value);
+    addExpectedIssue(state, path190, "array", value);
     return { present: true, value };
   }
   if (schema.minItems !== void 0 && value.length < schema.minItems) {
     const expected = `array with at least ${schema.minItems} items`;
     addIssue(
       state,
-      path189,
+      path190,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path189)}`
+      `Expected ${expected} at ${formatPath(path190)}`
     );
   }
   if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
     const expected = `array with at most ${schema.maxItems} items`;
     addIssue(
       state,
-      path189,
+      path190,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path189)}`
+      `Expected ${expected} at ${formatPath(path190)}`
     );
   }
   const nextValue = value.map((item, index) => {
-    const result = walkSchema(schema.item, item, [...path189, String(index)], state);
+    const result = walkSchema(schema.item, item, [...path190, String(index)], state);
     return result.present ? result.value : item;
   });
   return { present: true, value: nextValue };
 }
-function walkObject(schema, value, path189, state, injectedProperties = {}) {
+function walkObject(schema, value, path190, state, injectedProperties = {}) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path189, "object", value);
+    addExpectedIssue(state, path190, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
   for (const [key3, propertySchema] of Object.entries(schema.shape)) {
     const propertyValue = Object.hasOwn(value, key3) ? value[key3] : missingValue;
-    const result = walkSchema(propertySchema, propertyValue, [...path189, key3], state);
+    const result = walkSchema(propertySchema, propertyValue, [...path190, key3], state);
     if (result.present) {
       setOwnValue(nextValue, key3, result.value);
     }
@@ -16550,18 +16550,18 @@ function walkObject(schema, value, path189, state, injectedProperties = {}) {
     if (schema.additionalProperties === true) {
       setOwnValue(nextValue, key3, propertyValue);
     } else {
-      addUnexpectedPropertyIssue(state, [...path189, key3]);
+      addUnexpectedPropertyIssue(state, [...path190, key3]);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkOneOf(schema, value, path189, state) {
+function walkOneOf(schema, value, path190, state) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path189, "object", value);
+    addExpectedIssue(state, path190, "object", value);
     return { present: true, value };
   }
   const discriminatorValue = value[schema.discriminator];
-  const discriminatorPath = [...path189, schema.discriminator];
+  const discriminatorPath = [...path190, schema.discriminator];
   const branchValues = Object.keys(schema.branches);
   const expected = `one of ${branchValues.join(", ")}`;
   if (!Object.hasOwn(value, schema.discriminator)) {
@@ -16570,7 +16570,7 @@ function walkOneOf(schema, value, path189, state) {
       discriminatorPath,
       expected,
       "missing",
-      `Missing discriminator "${schema.discriminator}" at ${formatPath(path189)}. Expected one of: ${branchValues.join(", ")}.`
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path190)}. Expected one of: ${branchValues.join(", ")}.`
     );
     return { present: true, value };
   }
@@ -16584,21 +16584,21 @@ function walkOneOf(schema, value, path189, state) {
     );
     return { present: true, value };
   }
-  return walkObject(schema.branches[discriminatorValue], value, path189, state, {
+  return walkObject(schema.branches[discriminatorValue], value, path190, state, {
     [schema.discriminator]: discriminatorValue
   });
 }
-function walkUnion(schema, value, path189, state) {
+function walkUnion(schema, value, path190, state) {
   if (isPlainRecord3(value)) {
     const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
     if (candidateBranches.length === 1) {
-      return walkObject(candidateBranches[0], value, path189, state);
+      return walkObject(candidateBranches[0], value, path190, state);
     }
   }
   const matches = [];
   for (const branch of schema.branches) {
     const branchState = { issues: [] };
-    const result = walkObject(branch, value, path189, branchState);
+    const result = walkObject(branch, value, path190, branchState);
     if (branchState.issues.length === 0 && result.present) {
       matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
     }
@@ -16610,19 +16610,19 @@ function walkUnion(schema, value, path189, state) {
     const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
     addIssueWithMessage(
       state,
-      path189,
+      path190,
       "exactly one union branch",
       "0 matching branches",
-      `No union branch matched at ${formatPath(path189)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+      `No union branch matched at ${formatPath(path190)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
     );
     return { present: true, value };
   }
   addIssueWithMessage(
     state,
-    path189,
+    path190,
     "exactly one union branch",
     `${matches.length} matching branches`,
-    `Expected exactly one union branch at ${formatPath(path189)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+    `Expected exactly one union branch at ${formatPath(path190)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
   );
   return { present: true, value };
 }
@@ -16634,25 +16634,25 @@ function hasRequiredKeys(schema, value) {
   }
   return true;
 }
-function walkRecord(schema, value, path189, state) {
+function walkRecord(schema, value, path190, state) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path189, "object", value);
+    addExpectedIssue(state, path190, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   for (const [key3, propertyValue] of Object.entries(value)) {
-    const result = walkSchema(schema.value, propertyValue, [...path189, key3], state);
+    const result = walkSchema(schema.value, propertyValue, [...path190, key3], state);
     if (result.present) {
       setOwnValue(nextValue, key3, result.value);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkJson(value, path189, state) {
+function walkJson(value, path190, state) {
   if (isJsonValue(value)) {
     return { present: true, value };
   }
-  addExpectedIssue(state, path189, "JSON value", value);
+  addExpectedIssue(state, path190, "JSON value", value);
   return { present: true, value };
 }
 function getDefault(schema) {
@@ -16730,45 +16730,45 @@ function expectedFor(schema) {
       return expectedFor(schema.inner);
   }
 }
-function addExpectedIssue(state, path189, expected, value) {
+function addExpectedIssue(state, path190, expected, value) {
   addIssue(
     state,
-    path189,
+    path190,
     expected,
     receivedType(value),
-    `Expected ${expected} at ${formatPath(path189)}`
+    `Expected ${expected} at ${formatPath(path190)}`
   );
 }
-function addUnexpectedPropertyIssue(state, path189) {
+function addUnexpectedPropertyIssue(state, path190) {
   addIssue(
     state,
-    path189,
+    path190,
     "no additional properties",
     "unknown property",
-    `Unexpected property ${formatPath(path189)}`
+    `Unexpected property ${formatPath(path190)}`
   );
 }
-function addIssue(state, path189, expected, received, _message) {
+function addIssue(state, path190, expected, received, _message) {
   state.issues.push({
-    path: path189,
+    path: path190,
     expected,
     received,
-    message: formatIssueMessage(expected, path189, received)
+    message: formatIssueMessage(expected, path190, received)
   });
 }
-function addIssueWithMessage(state, path189, expected, received, message2) {
+function addIssueWithMessage(state, path190, expected, received, message2) {
   state.issues.push({
-    path: path189,
+    path: path190,
     expected,
     received,
     message: message2
   });
 }
-function formatIssueMessage(expected, path189, received) {
-  return `Expected ${expected} at ${formatPath(path189)}, got ${received}`;
+function formatIssueMessage(expected, path190, received) {
+  return `Expected ${expected} at ${formatPath(path190)}, got ${received}`;
 }
-function formatPath(path189) {
-  return path189.length === 0 ? "value" : path189.join(".");
+function formatPath(path190) {
+  return path190.length === 0 ? "value" : path190.join(".");
 }
 function compilePattern(pattern) {
   try {
@@ -16882,8 +16882,8 @@ function receivedType2(value) {
   }
   return typeof value;
 }
-function issue(path189, expected, value, message2, keyword = keywordFor(expected)) {
-  return { path: path189, expected, received: receivedType2(value), message: message2, keyword };
+function issue(path190, expected, value, message2, keyword = keywordFor(expected)) {
+  return { path: path190, expected, received: receivedType2(value), message: message2, keyword };
 }
 function keywordFor(expected) {
   if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
@@ -17715,44 +17715,44 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
   }
   return results;
 }
-function evaluateValidationKeywords(node, schema, value, path189) {
+function evaluateValidationKeywords(node, schema, value, path190) {
   const results = [];
   if (schema.nullable === true && value === null) {
     return results;
   }
   const types2 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
   if (types2.length > 0 && !types2.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path189, types2.join(","), value, `must be ${types2.join(",")}`)));
+    results.push(invalidResult(issue(path190, types2.join(","), value, `must be ${types2.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
-    results.push(invalidResult(issue(path189, "const", value, "must be equal to constant")));
+    results.push(invalidResult(issue(path190, "const", value, "must be equal to constant")));
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
     results.push(
-      invalidResult(issue(path189, "enum", value, "must be equal to one of the allowed values"))
+      invalidResult(issue(path190, "enum", value, "must be equal to one of the allowed values"))
     );
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    evaluateNumberKeywords(schema, value, path189, results);
+    evaluateNumberKeywords(schema, value, path190, results);
   }
   if (typeof value === "string") {
-    evaluateStringKeywords(schema, value, path189, results);
+    evaluateStringKeywords(schema, value, path190, results);
   }
   if (Array.isArray(value)) {
-    evaluateArrayKeywords(schema, value, path189, results);
+    evaluateArrayKeywords(schema, value, path190, results);
   }
   if (isObject(value)) {
-    evaluateObjectKeywords(node, schema, value, path189, results);
+    evaluateObjectKeywords(node, schema, value, path190, results);
   }
   return results;
 }
-function evaluateNumberKeywords(schema, value, path189, results) {
+function evaluateNumberKeywords(schema, value, path190, results) {
   if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `multiple of ${schema.multipleOf}`,
           value,
           `must be multiple of ${schema.multipleOf}`
@@ -17762,36 +17762,36 @@ function evaluateNumberKeywords(schema, value, path189, results) {
   }
   if (typeof schema.maximum === "number" && value > schema.maximum) {
     results.push(
-      invalidResult(issue(path189, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
+      invalidResult(issue(path190, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
     );
   }
   if (typeof schema.minimum === "number" && value < schema.minimum) {
     results.push(
-      invalidResult(issue(path189, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
+      invalidResult(issue(path190, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
     );
   }
   if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
     results.push(
       invalidResult(
-        issue(path189, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
+        issue(path190, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
       )
     );
   }
   if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
     results.push(
       invalidResult(
-        issue(path189, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
+        issue(path190, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
       )
     );
   }
 }
-function evaluateStringKeywords(schema, value, path189, results) {
+function evaluateStringKeywords(schema, value, path190, results) {
   const length = unicodeLength(value);
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `length <= ${schema.maxLength}`,
           value,
           `must NOT have more than ${schema.maxLength} characters`
@@ -17803,7 +17803,7 @@ function evaluateStringKeywords(schema, value, path189, results) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `length >= ${schema.minLength}`,
           value,
           `must NOT have fewer than ${schema.minLength} characters`
@@ -17814,17 +17814,17 @@ function evaluateStringKeywords(schema, value, path189, results) {
   if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
     results.push(
       invalidResult(
-        issue(path189, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
+        issue(path190, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
       )
     );
   }
 }
-function evaluateArrayKeywords(schema, value, path189, results) {
+function evaluateArrayKeywords(schema, value, path190, results) {
   if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `items <= ${schema.maxItems}`,
           value,
           `must NOT have more than ${schema.maxItems} items`
@@ -17836,7 +17836,7 @@ function evaluateArrayKeywords(schema, value, path189, results) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `items >= ${schema.minItems}`,
           value,
           `must NOT have fewer than ${schema.minItems} items`
@@ -17849,7 +17849,7 @@ function evaluateArrayKeywords(schema, value, path189, results) {
       for (let right = left + 1; right < value.length; right += 1) {
         if (deepEqual(value[left], value[right])) {
           results.push(
-            invalidResult(issue(path189, "unique items", value, "must NOT have duplicate items"))
+            invalidResult(issue(path190, "unique items", value, "must NOT have duplicate items"))
           );
           return;
         }
@@ -17857,13 +17857,13 @@ function evaluateArrayKeywords(schema, value, path189, results) {
     }
   }
 }
-function evaluateObjectKeywords(node, schema, value, path189, results) {
+function evaluateObjectKeywords(node, schema, value, path190, results) {
   const keys = Object.keys(value);
   if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `properties <= ${schema.maxProperties}`,
           value,
           `must NOT have more than ${schema.maxProperties} properties`
@@ -17875,7 +17875,7 @@ function evaluateObjectKeywords(node, schema, value, path189, results) {
     results.push(
       invalidResult(
         issue(
-          path189,
+          path190,
           `properties >= ${schema.minProperties}`,
           value,
           `must NOT have fewer than ${schema.minProperties} properties`
@@ -17888,7 +17888,7 @@ function evaluateObjectKeywords(node, schema, value, path189, results) {
       if (typeof key3 === "string" && !Object.prototype.hasOwnProperty.call(value, key3)) {
         results.push(
           invalidResult(
-            issue([...path189, key3], "required", void 0, `must have required property '${key3}'`)
+            issue([...path190, key3], "required", void 0, `must have required property '${key3}'`)
           )
         );
       }
@@ -17897,24 +17897,24 @@ function evaluateObjectKeywords(node, schema, value, path189, results) {
   const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
   for (const [key3, dependencies] of Object.entries(dependentRequired)) {
     if (Object.prototype.hasOwnProperty.call(value, key3) && Array.isArray(dependencies)) {
-      addMissingDependencies(value, dependencies, path189, results);
+      addMissingDependencies(value, dependencies, path190, results);
     }
   }
   if (node.dialect === "draft7" && isObject(schema.dependencies)) {
     for (const [key3, dependencies] of Object.entries(schema.dependencies)) {
       if (Object.prototype.hasOwnProperty.call(value, key3) && Array.isArray(dependencies)) {
-        addMissingDependencies(value, dependencies, path189, results);
+        addMissingDependencies(value, dependencies, path190, results);
       }
     }
   }
 }
-function addMissingDependencies(value, dependencies, path189, results) {
+function addMissingDependencies(value, dependencies, path190, results) {
   for (const dependency of dependencies) {
     if (typeof dependency === "string" && !Object.prototype.hasOwnProperty.call(value, dependency)) {
       results.push(
         invalidResult(
           issue(
-            [...path189, dependency],
+            [...path190, dependency],
             "dependency",
             void 0,
             `must have property '${dependency}'`
@@ -18036,8 +18036,8 @@ function compileJsonSchema(schema, options = {}) {
 }
 function formatIssues(issues) {
   return issues.map((current) => {
-    const path189 = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
-    return `${path189} ${current.message}`;
+    const path190 = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
+    return `${path190} ${current.message}`;
   }).join(", ");
 }
 var init_json_schema = __esm({
@@ -18547,11 +18547,11 @@ function mergeLayers(layers) {
   }
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path189) {
+function mergeObjectLayers(layers, path190) {
   const data = {};
   const sources = {};
   for (const key3 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key3, path189);
+    const resolved = resolveKey(layers, key3, path190);
     if (resolved === void 0) {
       continue;
     }
@@ -18571,7 +18571,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key3, path189) {
+function resolveKey(layers, key3, path190) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -18604,9 +18604,9 @@ function resolveKey(layers, key3, path189) {
   if (winningValue === null) {
     return void 0;
   }
-  const fullPath = buildPath(path189, key3);
+  const fullPath = buildPath(path190, key3);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path189, key3]);
+    const merged = mergeObjectLayers(objectLayers, [...path190, key3]);
     return {
       value: merged.data,
       sources: {
@@ -18634,8 +18634,8 @@ function isWinningCandidate(key3, value) {
 function getOwnEntry2(record2, key3) {
   return Object.prototype.hasOwnProperty.call(record2, key3) ? record2[key3] : void 0;
 }
-function buildPath(path189, key3) {
-  return [...path189, key3].map(escapePathSegment).join(".");
+function buildPath(path190, key3) {
+  return [...path190, key3].map(escapePathSegment).join(".");
 }
 function escapePathSegment(segment) {
   return segment.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
@@ -19499,22 +19499,22 @@ function prune2(obj, shape) {
   }
   return { changed, result };
 }
-function modifyAtPath(content, path189, value) {
+function modifyAtPath(content, path190, value) {
   const indent = detectIndent(content);
   const formattingOptions = {
     tabSize: indent === "	" ? 1 : indent.length,
     insertSpaces: indent !== "	",
     eol: "\n"
   };
-  const edits = jsonc.modify(content, path189, value, { formattingOptions });
+  const edits = jsonc.modify(content, path190, value, { formattingOptions });
   let result = jsonc.applyEdits(content, edits);
   if (!result.endsWith("\n")) {
     result += "\n";
   }
   return result;
 }
-function removeAtPath(content, path189) {
-  return modifyAtPath(content, path189, void 0);
+function removeAtPath(content, path190) {
+  return modifyAtPath(content, path190, void 0);
 }
 function serializeUpdate(content, current, next) {
   let result = content || "{}";
@@ -19524,15 +19524,15 @@ function serializeUpdate(content, current, next) {
   }
   return result;
 }
-function applyObjectUpdate(content, path189, current, next) {
+function applyObjectUpdate(content, path190, current, next) {
   let result = content;
   for (const key3 of Object.keys(current)) {
     if (!hasConfigEntry(next, key3)) {
-      result = removeAtPath(result, [...path189, key3]);
+      result = removeAtPath(result, [...path190, key3]);
     }
   }
   for (const [key3, nextValue] of Object.entries(next)) {
-    const nextPath = [...path189, key3];
+    const nextPath = [...path190, key3];
     const hasCurrent = hasConfigEntry(current, key3);
     const currentValue = hasCurrent ? current[key3] : void 0;
     if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
@@ -19739,16 +19739,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path189) {
-  const ext = getExtension(path189);
+function detectFormat2(path190) {
+  const ext = getExtension(path190);
   return extensionMap[ext];
 }
-function getExtension(path189) {
-  const lastDot = path189.lastIndexOf(".");
+function getExtension(path190) {
+  const lastDot = path190.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path189.slice(lastDot).toLowerCase();
+  return path190.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -21138,7 +21138,7 @@ function mergeScope(scope, baseScope, overrideScope) {
   }
   return merged;
 }
-function mergeRuntimeScope(baseScope, overrideScope, path189 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path190 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key3 of keys) {
@@ -21151,7 +21151,7 @@ function mergeRuntimeScope(baseScope, overrideScope, path189 = []) {
       continue;
     }
     if (isRecord4(baseValue) && isRecord4(overrideValue)) {
-      setOwnEntry(merged, key3, mergeRuntimeScope(baseValue, overrideValue, [...path189, key3]));
+      setOwnEntry(merged, key3, mergeRuntimeScope(baseValue, overrideValue, [...path190, key3]));
       continue;
     }
     setOwnEntry(merged, key3, overrideValue);
@@ -22742,45 +22742,45 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path189, encoding) {
+    async readFile(path190, encoding) {
       if (encoding) {
-        return base.readFile(path189, encoding);
+        return base.readFile(path190, encoding);
       }
-      return base.readFile(path189);
+      return base.readFile(path190);
     },
-    async writeFile(path189, data, options) {
-      const previousContent = await tryReadText(base, path189);
+    async writeFile(path190, data, options) {
+      const previousContent = await tryReadText(base, path190);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path189,
+        path: path190,
         nextContent,
         previousContent
       });
     },
-    async symlink(target, path189) {
-      recorder.record({ type: "symlink", target, path: path189 });
+    async symlink(target, path190) {
+      recorder.record({ type: "symlink", target, path: path190 });
     },
-    async readlink(path189) {
-      return base.readlink(path189);
+    async readlink(path190) {
+      return base.readlink(path190);
     },
-    async realpath(path189) {
-      return base.realpath(path189);
+    async realpath(path190) {
+      return base.realpath(path190);
     },
-    async mkdir(path189, options) {
+    async mkdir(path190, options) {
       recorder.record({
         type: "mkdir",
-        path: path189,
+        path: path190,
         options,
         // Matches how the mutation layer itself decides the mkdir is a no-op.
-        existing: await pathExists(base, path189)
+        existing: await pathExists(base, path190)
       });
     },
-    async stat(path189) {
-      return base.stat(path189);
+    async stat(path190) {
+      return base.stat(path190);
     },
-    async lstat(path189) {
-      return base.lstat(path189);
+    async lstat(path190) {
+      return base.lstat(path190);
     },
     async rename(from, to) {
       const staged = recorder.takeStagedWrite(from);
@@ -22795,16 +22795,16 @@ function createDryRunFileSystem(base, recorder) {
       }
       recorder.record({ type: "rename", from, to });
     },
-    async unlink(path189) {
-      recorder.record({ type: "unlink", path: path189 });
+    async unlink(path190) {
+      recorder.record({ type: "unlink", path: path190 });
     },
-    async readdir(path189) {
-      return base.readdir(path189);
+    async readdir(path190) {
+      return base.readdir(path190);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path189, options) => {
-      recorder.record({ type: "rm", path: path189, options });
+    proxy.rm = async (path190, options) => {
+      recorder.record({ type: "rm", path: path190, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -22949,8 +22949,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path189, change) {
-  const command = `cat > ${quoteShellArgument(path189)}`;
+function renderWriteCommand(path190, change) {
+  const command = `cat > ${quoteShellArgument(path190)}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -23157,9 +23157,9 @@ function describesChange(operation) {
   }
   return true;
 }
-async function tryReadText(base, path189) {
+async function tryReadText(base, path190) {
   try {
-    return await base.readFile(path189, "utf8");
+    return await base.readFile(path190, "utf8");
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -23213,10 +23213,10 @@ var init_dry_run = __esm({
       // Atomic writers stage content in a temp file and rename it over the target.
       // Pulling the staged write back out lets the rename re-record it against the
       // real target, so the preview diffs the delta instead of the whole file.
-      takeStagedWrite(path189) {
+      takeStagedWrite(path190) {
         for (let index = this.operations.length - 1; index >= 0; index -= 1) {
           const operation = this.operations[index];
-          if (operation.type === "writeFile" && operation.path === path189) {
+          if (operation.type === "writeFile" && operation.path === path190) {
             this.operations.splice(index, 1);
             return operation;
           }
@@ -34906,21 +34906,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path189;
+        let path190;
         if (typeof item.content === "string") {
-          path189 = item.content;
+          path190 = item.content;
         } else {
           try {
-            path189 = JSON.stringify(item.content);
+            path190 = JSON.stringify(item.content);
           } catch {
-            path189 = String(item.content);
+            path190 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path189
+          path: path190
         };
       }
     }
@@ -35043,10 +35043,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path189 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path190 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path189 };
+        yield { event: "tool_complete", id: item.id, kind, path: path190 };
       }
     }
   }
@@ -35425,14 +35425,14 @@ function toolInfo(event) {
   const [toolName = "tool", rawTool = {}] = Object.entries(toolCall)[0] ?? [];
   const tool = asObject2(rawTool) ?? {};
   const args = asObject2(tool.args) ?? asObject2(tool.arguments) ?? tool;
-  const path189 = typeof args.path === "string" ? args.path : "";
+  const path190 = typeof args.path === "string" ? args.path : "";
   const kinds = {
     editToolCall: "edit",
     readToolCall: "read",
     shellToolCall: "exec",
     bashToolCall: "exec"
   };
-  return { kind: kinds[toolName] ?? "other", title: path189 || toolName, path: path189 };
+  return { kind: kinds[toolName] ?? "other", title: path190 || toolName, path: path190 };
 }
 async function* adaptCursor(lines) {
   for await (const rawLine of lines) {
@@ -37316,13 +37316,13 @@ var init_acp_transport = __esm({
           cwd,
           env,
           firstRequestId,
-          spawn: spawn11 = spawnChildProcess3
+          spawn: spawn12 = spawnChildProcess3
         } = options;
         this.command = command;
         this.closed = new Promise((resolve17) => {
           this.resolveClosed = resolve17;
         });
-        this.child = spawn11(command, [...args], {
+        this.child = spawn12(command, [...args], {
           cwd,
           env,
           stdio: ["pipe", "pipe", "pipe"]
@@ -37783,8 +37783,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path189) {
-  if (!isAbsolute(path189)) {
+function assertAbsolutePath(path190) {
+  if (!isAbsolute(path190)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -39196,7 +39196,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path189 = readString(event.path);
+  const path190 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -39211,8 +39211,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path189) {
-    toolCall.path = path189;
+  if (path190) {
+    toolCall.path = path190;
   }
 }
 var sessionCapture;
@@ -55184,7 +55184,7 @@ function isWorktree(value) {
     return false;
   }
   const name = getOwnEntry18(value, "name");
-  const path189 = getOwnEntry18(value, "path");
+  const path190 = getOwnEntry18(value, "path");
   const branch = getOwnEntry18(value, "branch");
   const baseBranch = getOwnEntry18(value, "baseBranch");
   const createdAt2 = getOwnEntry18(value, "createdAt");
@@ -55198,7 +55198,7 @@ function isWorktree(value) {
   const baseHead = getOwnEntry18(value, "baseHead");
   const reconciledAt = getOwnEntry18(value, "reconciledAt");
   const reconciliation = getOwnEntry18(value, "reconciliation");
-  return typeof name === "string" && typeof path189 === "string" && typeof branch === "string" && typeof baseBranch === "string" && typeof createdAt2 === "string" && typeof source === "string" && typeof agent3 === "string" && (status === "active" || status === "reconciling" || status === "conflicted" || status === "cleanup_failed" || status === "done" || status === "failed" || status === "removing") && (storyId === void 0 || typeof storyId === "string") && (planPath === void 0 || typeof planPath === "string") && (prompt === void 0 || typeof prompt === "string") && (sourceCwd === void 0 || typeof sourceCwd === "string") && (baseHead === void 0 || typeof baseHead === "string") && (reconciledAt === void 0 || typeof reconciledAt === "string") && (reconciliation === void 0 || isReconciliationSummary(reconciliation));
+  return typeof name === "string" && typeof path190 === "string" && typeof branch === "string" && typeof baseBranch === "string" && typeof createdAt2 === "string" && typeof source === "string" && typeof agent3 === "string" && (status === "active" || status === "reconciling" || status === "conflicted" || status === "cleanup_failed" || status === "done" || status === "failed" || status === "removing") && (storyId === void 0 || typeof storyId === "string") && (planPath === void 0 || typeof planPath === "string") && (prompt === void 0 || typeof prompt === "string") && (sourceCwd === void 0 || typeof sourceCwd === "string") && (baseHead === void 0 || typeof baseHead === "string") && (reconciledAt === void 0 || typeof reconciledAt === "string") && (reconciliation === void 0 || isReconciliationSummary(reconciliation));
 }
 function isReconciliationSummary(value) {
   if (typeof value !== "object" || value === null) {
@@ -55639,9 +55639,9 @@ function parsePorcelainPaths(output) {
   const entries = output.split("\0").filter((entry) => entry.length > 0);
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
-    const path189 = entry.length > 3 ? entry.slice(3) : entry;
-    if (path189.length > 0) {
-      paths.push(path189);
+    const path190 = entry.length > 3 ? entry.slice(3) : entry;
+    if (path190.length > 0) {
+      paths.push(path190);
     }
     if ((entry.startsWith("R ") || entry.startsWith("C ")) && index + 1 < entries.length) {
       const sourcePath = entries[index + 1];
@@ -59063,10 +59063,10 @@ function parseReviewDiff(diffText) {
       finalizeFile();
       const paths = parseDiffGitPaths(line);
       const previousPath = paths?.previousPath ?? "";
-      const path189 = paths?.path ?? previousPath;
+      const path190 = paths?.path ?? previousPath;
       currentFile = {
-        path: path189,
-        previousPath: previousPath && previousPath !== path189 ? previousPath : null,
+        path: path190,
+        previousPath: previousPath && previousPath !== path190 ? previousPath : null,
         status: "modified",
         hunks: [],
         reviewableLines: [],
@@ -59096,9 +59096,9 @@ function parseReviewDiff(diffText) {
       continue;
     }
     if (line.startsWith("+++ ")) {
-      const path189 = normalizeDiffPath(line.slice(4).trim());
-      if (path189) {
-        currentFile.path = path189;
+      const path190 = normalizeDiffPath(line.slice(4).trim());
+      if (path190) {
+        currentFile.path = path190;
       }
       continue;
     }
@@ -59157,31 +59157,31 @@ function validateInlineComments(comments, context) {
   const accepted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const comment of comments) {
-    const path189 = comment.path;
+    const path190 = comment.path;
     const body = comment.body.trim();
-    if (path189.length === 0 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
+    if (path190.length === 0 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
       throw new Error("Inline review comments require path, positive line, and body.");
     }
     if (comment.side === "LEFT") {
       throw new Error(
-        `Inline comment target ${path189}:${comment.line} is a left-side diff target; only right-side comments are supported.`
+        `Inline comment target ${path190}:${comment.line} is a left-side diff target; only right-side comments are supported.`
       );
     }
-    if (!context.reviewableLinesByPath.get(path189)?.has(comment.line)) {
+    if (!context.reviewableLinesByPath.get(path190)?.has(comment.line)) {
       throw new Error(
-        `Inline comment target ${path189}:${comment.line} is not a valid right-side diff target.`
+        `Inline comment target ${path190}:${comment.line} is not a valid right-side diff target.`
       );
     }
-    if (!comment.side && context.leftLinesByPath.get(path189)?.has(comment.line) && context.rightContextLinesByPath.get(path189)?.has(comment.line)) {
+    if (!comment.side && context.leftLinesByPath.get(path190)?.has(comment.line) && context.rightContextLinesByPath.get(path190)?.has(comment.line)) {
       throw new Error(
-        `Inline comment target ${path189}:${comment.line} is ambiguous; specify side RIGHT to target the right-side diff line.`
+        `Inline comment target ${path190}:${comment.line} is ambiguous; specify side RIGHT to target the right-side diff line.`
       );
     }
-    const key3 = `${path189}\0${comment.line}\0${body}`;
+    const key3 = `${path190}\0${comment.line}\0${body}`;
     if (!seen.has(key3)) {
       seen.add(key3);
       accepted.push({
-        path: path189,
+        path: path190,
         line: comment.line,
         ...comment.side ? { side: comment.side } : {},
         body
@@ -59682,9 +59682,9 @@ function reviewEndpoint(prUrl) {
 }
 function normalizeReviewComments(comments) {
   return comments.map((comment) => {
-    const path189 = comment.path.trim();
+    const path190 = comment.path.trim();
     const body = comment.body.trim();
-    if (!path189) {
+    if (!path190) {
       throw new Error("Review comment path must be non-empty.");
     }
     if (!Number.isSafeInteger(comment.line) || comment.line <= 0) {
@@ -59693,7 +59693,7 @@ function normalizeReviewComments(comments) {
     if (!body) {
       throw new Error("Review comment body must be non-empty.");
     }
-    return { path: path189, line: comment.line, body };
+    return { path: path190, line: comment.line, body };
   });
 }
 function submissionFromResponse(response) {
@@ -59988,10 +59988,10 @@ var init_review_history = __esm({
           kind,
           body
         };
-        const path189 = text4(record2, "path");
+        const path190 = text4(record2, "path");
         const line = integer(record2, "line") ?? integer(record2, "original_line");
         const diffHunk = text4(record2, "diff_hunk");
-        if (path189) normalized.path = path189;
+        if (path190) normalized.path = path190;
         if (line !== null) normalized.line = line;
         if (diffHunk) normalized.diffHunk = diffHunk;
         return normalized;
@@ -60701,9 +60701,9 @@ function containedPath(directory, name) {
   }
   return target;
 }
-async function pathExists7(path189) {
+async function pathExists7(path190) {
   try {
-    await access(path189);
+    await access(path190);
     return true;
   } catch (error3) {
     if (isMissingFileError4(error3)) {
@@ -64100,9 +64100,9 @@ function normalizeToolResult2(handlerResult, outputSchema) {
     structuredContent
   };
 }
-function assertObjectRootSchema(schema, path189) {
+function assertObjectRootSchema(schema, path190) {
   if (schema.type !== "object") {
-    throw new Error(`${path189} root type must be "object"`);
+    throw new Error(`${path190} root type must be "object"`);
   }
 }
 function isJsonObject(value) {
@@ -64441,23 +64441,23 @@ function extractFieldErrors(body) {
   const flattened = candidates.flatMap((candidate) => flattenFieldErrors(candidate, []));
   return flattened.length === 0 ? void 0 : flattened;
 }
-function flattenFieldErrors(value, path189) {
+function flattenFieldErrors(value, path190) {
   if (typeof value === "string") {
-    return [{ path: formatPath2(path189), message: value }];
+    return [{ path: formatPath2(path190), message: value }];
   }
   if (Array.isArray(value)) {
     if (value.every((entry) => typeof entry === "string")) {
-      return value.map((message2) => ({ path: formatPath2(path189), message: message2 }));
+      return value.map((message2) => ({ path: formatPath2(path190), message: message2 }));
     }
-    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path189, String(index)]));
+    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path190, String(index)]));
   }
   if (!isPlainObject4(value)) {
     return [];
   }
-  return Object.entries(value).flatMap(([key3, nested]) => flattenFieldErrors(nested, [...path189, key3]));
+  return Object.entries(value).flatMap(([key3, nested]) => flattenFieldErrors(nested, [...path190, key3]));
 }
-function formatPath2(path189) {
-  return path189.length === 0 ? "error" : path189.join(".");
+function formatPath2(path190) {
+  return path190.length === 0 ? "error" : path190.join(".");
 }
 function extractFirstString(body, fields) {
   if (!isPlainObject4(body)) {
@@ -64999,12 +64999,12 @@ function mergeApprovalsRoot(root, options) {
   }
   return options.humanInLoop.mergeApprovalsGroup(root);
 }
-function findHumanInLoopCommandPath(node, path189) {
+function findHumanInLoopCommandPath(node, path190) {
   if (node.kind === "command") {
-    return node.humanInLoop ? path189.join(".") || node.name : void 0;
+    return node.humanInLoop ? path190.join(".") || node.name : void 0;
   }
   for (const child of node.children) {
-    const found = findHumanInLoopCommandPath(child, [...path189, child.name]);
+    const found = findHumanInLoopCommandPath(child, [...path190, child.name]);
     if (found !== void 0) {
       return found;
     }
@@ -65039,13 +65039,13 @@ function convertJsonSchema(schema) {
   }
   return convertSchema(schema, schema, []);
 }
-function convertSchema(schema, root, path189) {
-  const resolvedSchema = resolveReferencedSchema(schema, root, path189);
+function convertSchema(schema, root, path190) {
+  const resolvedSchema = resolveReferencedSchema(schema, root, path190);
   const normalizedSchema = normalizeNullability(resolvedSchema);
   const composition = getComposition(normalizedSchema.schema);
   if (Array.isArray(normalizedSchema.schema.type)) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path189)}" has an unsupported type "${formatJsonSchemaType(
+      `JSON Schema "${formatJsonSchemaPath(path190)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -65057,13 +65057,13 @@ function convertSchema(schema, root, path189) {
     return convertEnumSchema(resolvedSchema, normalizedSchema.nullable);
   }
   if (composition !== void 0) {
-    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path189);
+    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path190);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path189,
+          ...path190,
           "additionalProperties"
         ])
       ),
@@ -65112,12 +65112,12 @@ function convertSchema(schema, root, path189) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path189
+            path190
           )}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`
         );
       }
       return S.Array(
-        convertSchema(normalizedSchema.schema.items, root, [...path189, "items"]),
+        convertSchema(normalizedSchema.schema.items, root, [...path190, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -65127,7 +65127,7 @@ function convertSchema(schema, root, path189) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path189
+        path: path190
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -65142,12 +65142,12 @@ function convertSchema(schema, root, path189) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path189
+          path190
         )}" must declare one of: "type", "enum", "const", "oneOf", "anyOf", or "allOf".`
       );
   }
   throw new Error(
-    `JSON Schema "${formatJsonSchemaPath(path189)}" has an unsupported type "${formatJsonSchemaType(
+    `JSON Schema "${formatJsonSchemaPath(path190)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -65191,21 +65191,21 @@ function convertEnumSchema(schema, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema, root, nullable, path189) {
+function convertCompositionSchema(schema, root, nullable, path190) {
   const composition = getComposition(schema);
   const branchSchemas = composition?.branches ?? [];
   const keyword = composition?.keyword ?? "oneOf";
   const branches = branchSchemas.map(
-    (branch, index) => resolveReferencedSchema(branch, root, [...path189, keyword, String(index)])
+    (branch, index) => resolveReferencedSchema(branch, root, [...path190, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path189);
+  const discriminator = findDiscriminator(branches, root, path190);
   if (discriminator !== void 0) {
     const convertedBranches = Object.fromEntries(
       branches.map((branch, index) => [
         getDiscriminatorLiteral(branch, discriminator, root),
         convertObjectSchema(branch, root, {
           omitProperty: discriminator,
-          path: [...path189, keyword, String(index)]
+          path: [...path190, keyword, String(index)]
         })
       ])
     );
@@ -65224,7 +65224,7 @@ function convertCompositionSchema(schema, root, nullable, path189) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path189, keyword, String(index)]
+          path: [...path190, keyword, String(index)]
         })
       )
     ),
@@ -65338,11 +65338,11 @@ function getComposition(schema) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path189) {
-  if (path189.length === 0) {
+function formatJsonSchemaPath(path190) {
+  if (path190.length === 0) {
     return "#";
   }
-  return `#/${path189.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path190.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type) {
   return Array.isArray(type) ? JSON.stringify(type) : String(type);
@@ -65358,11 +65358,11 @@ function isRecordSchema(schema) {
   const propertyKeys = Object.keys(schema.properties ?? {});
   return schema.type === "object" && propertyKeys.length === 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null;
 }
-function findDiscriminator(branches, root, path189) {
+function findDiscriminator(branches, root, path190) {
   const [firstBranch] = branches;
   if (firstBranch === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path189)}" uses oneOf/anyOf/allOf but has no branches.`
+      `JSON Schema "${formatJsonSchemaPath(path190)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -65402,19 +65402,19 @@ function getDiscriminatorLiteral(branch, key3, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema, root, path189) {
+function resolveReferencedSchema(schema, root, path190) {
   if (schema.$ref === void 0) {
     return schema;
   }
   const resolvedTarget = resolveLocalRef(root, schema.$ref);
   if (resolvedTarget === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path189)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
+      `JSON Schema "${formatJsonSchemaPath(path190)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
     );
   }
   const { $ref: ignoredRef, ...siblingKeywords } = schema;
   void ignoredRef;
-  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path189);
+  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path190);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -65438,9 +65438,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path189 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path190 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path189);
+  nextActivePaths.add(path190);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -65451,13 +65451,13 @@ function hasSelfReferencingRef(schema, root, path189 = "#", activePaths = /* @__
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path189}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path190}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path189}/additionalProperties`,
+    `${path190}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -65466,7 +65466,7 @@ function hasSelfReferencingRef(schema, root, path189 = "#", activePaths = /* @__
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path189}/properties/${escapeJsonPointerSegment(key3)}`,
+      `${path190}/properties/${escapeJsonPointerSegment(key3)}`,
       nextActivePaths
     )) {
       return true;
@@ -65476,24 +65476,24 @@ function hasSelfReferencingRef(schema, root, path189 = "#", activePaths = /* @__
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path189}/$defs/${escapeJsonPointerSegment(key3)}`,
+      `${path190}/$defs/${escapeJsonPointerSegment(key3)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path189}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path190}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path189}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path190}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.allOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path189}/allOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path190}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -65509,14 +65509,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path189 = getLocalRefPath(ref);
-  if (path189 === void 0) {
+  const path190 = getLocalRefPath(ref);
+  if (path190 === void 0) {
     return void 0;
   }
-  if (path189 === "#") {
+  if (path190 === "#") {
     return root;
   }
-  const segments = path189.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path190.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -66269,21 +66269,21 @@ function createFs(fs31) {
     return fs31;
   }
   return {
-    readFile: async (path189, encoding = "utf8") => readFile13(path189, { encoding }),
-    writeFile: async (path189, contents, options) => {
-      await writeFile9(path189, contents, options);
+    readFile: async (path190, encoding = "utf8") => readFile13(path190, { encoding }),
+    writeFile: async (path190, contents, options) => {
+      await writeFile9(path190, contents, options);
     },
-    exists: async (path189) => {
+    exists: async (path190) => {
       try {
-        await access2(path189);
+        await access2(path190);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path189) => lstat12(path189),
+    lstat: async (path190) => lstat12(path190),
     rename: async (fromPath, toPath) => rename10(fromPath, toPath),
-    unlink: async (path189) => unlink9(path189)
+    unlink: async (path190) => unlink9(path190)
   };
 }
 function createEnv(values = process.env) {
@@ -66421,11 +66421,11 @@ function applySchemaCasing(schema, casing) {
     ...oneOf === void 0 ? {} : { oneOf }
   };
 }
-function collectParamSummaries(schema, casing, path189 = [], inheritedOptional = false) {
+function collectParamSummaries(schema, casing, path190 = [], inheritedOptional = false) {
   const summaries = [];
   for (const [key3, rawChildSchema] of Object.entries(schema.shape)) {
     const childSchema = unwrapOptional3(rawChildSchema);
-    const nextPath = [...path189, formatSegment(key3, casing)];
+    const nextPath = [...path190, formatSegment(key3, casing)];
     const optional = inheritedOptional || isOptional(rawChildSchema);
     if (childSchema.kind === "object") {
       summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
@@ -66469,8 +66469,8 @@ function matchesAllowlist(toolName, allowlist) {
   const candidates = segments.map((_segment, index) => segments.slice(0, index + 1).join("__"));
   return candidates.some((candidate) => allowlist.includes(candidate));
 }
-function formatToolName(path189) {
-  return path189.map((segment) => formatSegment(segment, "snake")).join("__");
+function formatToolName(path190) {
+  return path190.map((segment) => formatSegment(segment, "snake")).join("__");
 }
 function validateUniqueMCPParameterFields(schema, casing) {
   const sourceKeysByField = /* @__PURE__ */ new Map();
@@ -69066,14 +69066,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path189 = input.slice(slashIndex);
-  if (container.length === 0 || path189.length === 0) {
+  const path190 = input.slice(slashIndex);
+  if (container.length === 0 || path190.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path189
+    path: path190
   };
 }
 function splitOnce(input, separator) {
@@ -69937,8 +69937,8 @@ async function checkAuth(options) {
 }
 function createCurrentBalanceUrl(baseUrl) {
   const url = new URL(baseUrl);
-  const path189 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-  url.pathname = `${path189}/usage/current_balance`;
+  const path190 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+  url.pathname = `${path190}/usage/current_balance`;
   return url.toString();
 }
 function isCurrentBalanceResponse(value) {
@@ -71404,26 +71404,26 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path189, encoding) => {
+    readFile: ((path190, encoding) => {
       if (encoding) {
-        return fs9.readFile(path189, encoding);
+        return fs9.readFile(path190, encoding);
       }
-      return fs9.readFile(path189);
+      return fs9.readFile(path190);
     }),
-    symlink: (target, path189) => fs9.symlink(target, path189),
-    readlink: (path189) => fs9.readlink(path189, { encoding: "utf8" }),
-    realpath: (path189) => fs9.realpath(path189),
-    writeFile: (path189, data, opts) => fs9.writeFile(path189, data, opts),
-    mkdir: (path189, opts) => fs9.mkdir(path189, opts).then(() => {
+    symlink: (target, path190) => fs9.symlink(target, path190),
+    readlink: (path190) => fs9.readlink(path190, { encoding: "utf8" }),
+    realpath: (path190) => fs9.realpath(path190),
+    writeFile: (path190, data, opts) => fs9.writeFile(path190, data, opts),
+    mkdir: (path190, opts) => fs9.mkdir(path190, opts).then(() => {
     }),
-    stat: (path189) => fs9.stat(path189),
-    lstat: (path189) => fs9.lstat(path189),
+    stat: (path190) => fs9.stat(path190),
+    lstat: (path190) => fs9.lstat(path190),
     rename: (oldPath, newPath) => fs9.rename(oldPath, newPath),
-    rm: (path189, opts) => fs9.rm(path189, opts),
-    unlink: (path189) => fs9.unlink(path189),
-    readdir: (path189) => fs9.readdir(path189),
+    rm: (path190, opts) => fs9.rm(path190, opts),
+    unlink: (path190) => fs9.unlink(path190),
+    readdir: (path190) => fs9.readdir(path190),
     copyFile: (src, dest) => fs9.copyFile(src, dest),
-    chmod: (path189, mode) => fs9.chmod(path189, mode)
+    chmod: (path190, mode) => fs9.chmod(path190, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authProviders = allAuthProviders;
@@ -71878,8 +71878,8 @@ function createNodeWorktreeDeps2() {
   };
 }
 async function defaultSpawnAgent(service, options) {
-  const { spawn: spawn11 } = await init_spawn4().then(() => spawn_exports);
-  return await spawn11(service, options).result;
+  const { spawn: spawn12 } = await init_spawn4().then(() => spawn_exports);
+  return await spawn12(service, options).result;
 }
 var execShell2;
 var init_worktree = __esm({
@@ -86847,7 +86847,7 @@ async function ingestGaslight(options) {
   const cwd = options.cwd ?? process.cwd();
   const homeDir = options.homeDir ?? os17.homedir();
   const fs31 = options.fs ?? nodeFs14;
-  const spawn11 = options.spawn ?? spawn4;
+  const spawn12 = options.spawn ?? spawn4;
   const collectHumanPrompts2 = options.collectHumanPrompts ?? collectHumanPromptsWithStats;
   const analysisAgent = requireNonEmptyString3(options.analysisAgent, "analysisAgent");
   const model = resolveOptionalNonEmptyString(options.model, "model");
@@ -86890,7 +86890,7 @@ async function ingestGaslight(options) {
       agent: analysisAgent,
       dataPath: dataPath.absolutePath
     });
-    const result = await spawn11(analysisAgent, {
+    const result = await spawn12(analysisAgent, {
       prompt: buildAnalysisPrompt(dataPath.absolutePath),
       cwd,
       mode: "read",
@@ -87092,7 +87092,7 @@ async function runGaslight(options) {
   const cwd = options.cwd ?? process.cwd();
   const homeDir = options.homeDir ?? os18.homedir();
   const fs31 = options.fs ?? nodeFs15;
-  const spawn11 = options.spawn ?? spawn4;
+  const spawn12 = options.spawn ?? spawn4;
   const model = resolveModel(options.model);
   const mode = options.mode ?? "auto";
   const inlineSetup = resolveOptionalPrompt(options.setup, "setup");
@@ -87137,7 +87137,7 @@ async function runGaslight(options) {
         planIndex: planIndex + 1,
         totalPlans: planPaths.length
       });
-      const result = await spawn11(agent3, {
+      const result = await spawn12(agent3, {
         prompt,
         cwd,
         mode,
@@ -88043,15 +88043,15 @@ async function publishFiles(fs31, files) {
 function isAlreadyExistsError12(error3) {
   return hasOwnErrorCode24(error3, "EEXIST");
 }
-async function assertNotSymbolicLinkIfSet(fs31, path189) {
-  if (path189 !== void 0 && path189 !== "") {
-    await assertNotSymbolicLink2(fs31, path189);
+async function assertNotSymbolicLinkIfSet(fs31, path190) {
+  if (path190 !== void 0 && path190 !== "") {
+    await assertNotSymbolicLink2(fs31, path190);
   }
 }
-async function assertNotSymbolicLink2(fs31, path189) {
+async function assertNotSymbolicLink2(fs31, path190) {
   try {
-    if ((await fs31.lstat(path189)).isSymbolicLink()) {
-      throw new UserError2(`Refusing to use symbolic link path: ${path189}`);
+    if ((await fs31.lstat(path190)).isSymbolicLink()) {
+      throw new UserError2(`Refusing to use symbolic link path: ${path190}`);
     }
   } catch (error3) {
     if (isMissingFileError8(error3)) {
@@ -89459,12 +89459,12 @@ function validateNonBlankStrings(value) {
   }
   return issues;
 }
-function blankStringIssue(path189, value) {
+function blankStringIssue(path190, value) {
   return {
-    path: path189,
+    path: path190,
     expected: "non-blank string",
     received: JSON.stringify(value),
-    message: `${path189.join(".")} must not be blank.`
+    message: `${path190.join(".")} must not be blank.`
   };
 }
 function validateTarget(target) {
@@ -89515,8 +89515,8 @@ function validateMetrics(metrics) {
 function formatIssues2(filePath, issues) {
   return issues.map((issue2) => `${filePath} (${formatPath3(issue2.path)}): ${issue2.message}`).join("\n");
 }
-function formatPath3(path189) {
-  return path189.join(".") || "value";
+function formatPath3(path190) {
+  return path190.join(".") || "value";
 }
 var nonEmptyString2, positiveInteger, nonNegativeInteger, scoringWeight, metricEvaluatorSchema, metricSchema, evalYamlSchema, EvalYamlValidationError;
 var init_schema5 = __esm({
@@ -89920,9 +89920,9 @@ async function loadEval(source, id, fs31 = nodeFs17) {
     plan
   };
 }
-async function isFile2(path189, fs31) {
+async function isFile2(path190, fs31) {
   try {
-    const stat36 = await fs31.stat(path189);
+    const stat36 = await fs31.stat(path190);
     return typeof stat36.isFile === "function" ? stat36.isFile() : !stat36.isDirectory();
   } catch (error3) {
     if (isMissingPath4(error3)) {
@@ -91805,19 +91805,19 @@ function validateRunResult(value, filePath) {
   requireRecord2(result.cheatReport, filePath, "result.json", ["cheatReport"]);
   return result;
 }
-function validateScoringComponent(value, filePath, path189) {
-  const component = requireRecord2(value, filePath, "result.json", path189);
-  requireBoolean(component.configured, filePath, "result.json", [...path189, "configured"]);
-  requireBoolean(component.required, filePath, "result.json", [...path189, "required"]);
+function validateScoringComponent(value, filePath, path190) {
+  const component = requireRecord2(value, filePath, "result.json", path190);
+  requireBoolean(component.configured, filePath, "result.json", [...path190, "configured"]);
+  requireBoolean(component.required, filePath, "result.json", [...path190, "required"]);
   requireRange(component.configuredWeight, 0, 1, filePath, "result.json", [
-    ...path189,
+    ...path190,
     "configuredWeight"
   ]);
   requireRange(component.effectiveWeight, 0, 1, filePath, "result.json", [
-    ...path189,
+    ...path190,
     "effectiveWeight"
   ]);
-  requireString(component.status, filePath, "result.json", [...path189, "status"]);
+  requireString(component.status, filePath, "result.json", [...path190, "status"]);
 }
 function validateTrace(value, filePath) {
   const trace = requireRecord2(value, filePath, "trace.json", []);
@@ -91826,48 +91826,48 @@ function validateTrace(value, filePath) {
   }
   return trace;
 }
-function requireRecord2(value, filePath, artifact, path189) {
+function requireRecord2(value, filePath, artifact, path190) {
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path189, "object", value);
+  throw invalidArtifactField(filePath, artifact, path190, "object", value);
 }
-function requireString(value, filePath, artifact, path189) {
+function requireString(value, filePath, artifact, path190) {
   if (typeof value === "string" && value.length > 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path189, "non-empty string", value);
+  throw invalidArtifactField(filePath, artifact, path190, "non-empty string", value);
 }
-function requireBoolean(value, filePath, artifact, path189) {
+function requireBoolean(value, filePath, artifact, path190) {
   if (typeof value !== "boolean") {
-    throw invalidArtifactField(filePath, artifact, path189, "boolean", value);
+    throw invalidArtifactField(filePath, artifact, path190, "boolean", value);
   }
 }
-function requireNonNegativeInteger2(value, filePath, artifact, path189) {
+function requireNonNegativeInteger2(value, filePath, artifact, path190) {
   if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path189, "non-negative integer", value);
+  throw invalidArtifactField(filePath, artifact, path190, "non-negative integer", value);
 }
-function requireNonNegativeNumber(value, filePath, artifact, path189) {
+function requireNonNegativeNumber(value, filePath, artifact, path190) {
   if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path189, "non-negative number", value);
+  throw invalidArtifactField(filePath, artifact, path190, "non-negative number", value);
 }
-function requireRange(value, min, max, filePath, artifact, path189) {
+function requireRange(value, min, max, filePath, artifact, path190) {
   if (typeof value === "number" && Number.isFinite(value) && value >= min && value <= max) {
     return;
   }
-  throw invalidArtifactField(filePath, artifact, path189, `number from ${min} through ${max}`, value);
+  throw invalidArtifactField(filePath, artifact, path190, `number from ${min} through ${max}`, value);
 }
-function invalidArtifactField(filePath, artifact, path189, expected, received) {
+function invalidArtifactField(filePath, artifact, path190, expected, received) {
   return new Error(
-    `Invalid ${artifact} in ${filePath} (${formatIssuePath(path189)}): expected ${expected}, received ${formatReceived2(received)}.`
+    `Invalid ${artifact} in ${filePath} (${formatIssuePath(path190)}): expected ${expected}, received ${formatReceived2(received)}.`
   );
 }
-function formatIssuePath(path189) {
-  return path189.join(".") || "value";
+function formatIssuePath(path190) {
+  return path190.join(".") || "value";
 }
 function formatReceived2(value) {
   if (typeof value === "string") {
@@ -96660,11 +96660,11 @@ function formatSegment2(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords4(segment).join(separator);
 }
-function toOptionFlag(path189, casing) {
-  return `--${path189.map((segment) => formatSegment2(segment, casing)).join(".")}`;
+function toOptionFlag(path190, casing) {
+  return `--${path190.map((segment) => formatSegment2(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path189, casing) {
-  return path189.map((segment) => {
+function toOptionAttribute(path190, casing) {
+  return path190.map((segment) => {
     const formatted = formatSegment2(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -96675,23 +96675,23 @@ function toOptionAttribute(path189, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path189) {
-  return path189.join(".");
+function toDisplayPath(path190) {
+  return path190.join(".");
 }
-function toUnionKindControlPath(path189) {
-  if (path189.length === 0) {
+function toUnionKindControlPath(path190) {
+  if (path190.length === 0) {
     return ["kind"];
   }
-  const head = path189.slice(0, -1);
-  const tail = path189[path189.length - 1] ?? "";
+  const head = path190.slice(0, -1);
+  const tail = path190[path190.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path189) {
-  if (path189.length === 0) {
+function toUnionKindDisplayPath(path190) {
+  if (path190.length === 0) {
     return "kind";
   }
-  const head = path189.slice(0, -1);
-  const tail = path189[path189.length - 1] ?? "";
+  const head = path190.slice(0, -1);
+  const tail = path190[path190.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -96707,14 +96707,14 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema]) => schema.kind !== "optional").map(([key3]) => formatSegment2(key3, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema, casing, globalLongOptionFlags, path189 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path190 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key3, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path189, key3];
+    const nextPath = [...path190, key3];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional4(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -96900,9 +96900,9 @@ function collectFields(schema, casing, globalLongOptionFlags, path189 = [], inhe
   }
   return collected;
 }
-function toCommanderOptionAttribute(path189, casing, globalLongOptionFlags) {
-  const optionAttribute = toOptionAttribute(path189, casing);
-  const optionFlag = toOptionFlag(path189, casing);
+function toCommanderOptionAttribute(path190, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path190, casing);
+  const optionFlag = toOptionFlag(path190, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -98496,10 +98496,10 @@ function writeCLIDiagnosticEvent(event) {
   process.stderr.write(`${event.message}
 `);
 }
-function setNestedValue(target, path189, value) {
+function setNestedValue(target, path190, value) {
   let cursor2 = target;
-  for (let index = 0; index < path189.length - 1; index += 1) {
-    const segment = path189[index] ?? "";
+  for (let index = 0; index < path190.length - 1; index += 1) {
+    const segment = path190[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor2, segment) ? cursor2[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor2 = existing;
@@ -98514,7 +98514,7 @@ function setNestedValue(target, path189, value) {
     });
     cursor2 = next;
   }
-  const leaf = path189[path189.length - 1];
+  const leaf = path190[path190.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor2, leaf, {
       value,
@@ -98696,9 +98696,9 @@ function isPlainObject8(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path189) {
+function hasNestedField(fields, path190) {
   return fields.some(
-    (field) => path189.length < field.path.length && path189.every((segment, index) => field.path[index] === segment)
+    (field) => path190.length < field.path.length && path190.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -98827,9 +98827,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path189) {
+  function visitObject(current, path190) {
     for (const [key3, value] of Object.entries(current)) {
-      const nextPath = [...path189, key3];
+      const nextPath = [...path190, key3];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -99212,8 +99212,8 @@ This is a bug in toolcraft or in the command definition; it cannot be worked aro
   }
   process.exitCode = 1;
 }
-function getNestedValue(target, path189) {
-  return path189.reduce(
+function getNestedValue(target, path190) {
+  return path190.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -101277,13 +101277,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path189) => {
+  const visit = (node, path190) => {
     if (node.kind === "command") {
-      paths.push(path189.join("."));
+      paths.push(path190.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path189, child.name]);
+      visit(child, [...path190, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -105158,9 +105158,9 @@ var init_config8 = __esm({
 
 // src/cli/commands/utils-symlink-ops.ts
 import { dirname as dirname10 } from "node:path";
-async function tryLstat(fs31, path189) {
+async function tryLstat(fs31, path190) {
   try {
-    return await fs31.lstat(path189);
+    return await fs31.lstat(path190);
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -105244,13 +105244,13 @@ function formatUnknownError6(error3) {
   }
   return String(error3);
 }
-async function isSymlinkPointingTo(fs31, path189, expectedTarget) {
+async function isSymlinkPointingTo(fs31, path190, expectedTarget) {
   try {
-    const stats2 = await fs31.lstat(path189);
+    const stats2 = await fs31.lstat(path190);
     if (!stats2.isSymbolicLink()) {
       return false;
     }
-    return await fs31.readlink(path189) === expectedTarget;
+    return await fs31.readlink(path190) === expectedTarget;
   } catch (error3) {
     if (isNotFound(error3)) {
       return false;
@@ -109721,28 +109721,28 @@ function detectTraceFile(firstLine) {
   }
   return void 0;
 }
-async function loadTraceFromFile(path189, options) {
-  const stat36 = await options.fs.stat(path189).catch(() => void 0);
+async function loadTraceFromFile(path190, options) {
+  const stat36 = await options.fs.stat(path190).catch(() => void 0);
   if (stat36 === void 0) {
     throw new UserError(
-      `Trace file not found: ${path189}
+      `Trace file not found: ${path190}
 Pass a path to an existing trace file, or run "poe-code traces" to list the traces found.`
     );
   }
   if (stat36.isDirectory()) {
     throw new UserError(
-      `Trace path is a directory: ${path189}
+      `Trace path is a directory: ${path190}
 Pass a path to a trace file, or run "poe-code traces" to list the traces found.`
     );
   }
-  const contents = await options.fs.readFile(path189, "utf8");
+  const contents = await options.fs.readFile(path190, "utf8");
   const firstLineEnd = contents.indexOf("\n");
   const firstLine = firstLineEnd === -1 ? contents : contents.slice(0, firstLineEnd);
   const source = detectTraceFile(firstLine);
   if (source === void 0) {
-    throw new Error(`Unable to detect trace source for file: ${path189}`);
+    throw new Error(`Unable to detect trace source for file: ${path190}`);
   }
-  return loadTrace({ source, id: path189, path: path189 }, options);
+  return loadTrace({ source, id: path190, path: path190 }, options);
 }
 function dateValue(date) {
   return date?.getTime() ?? 0;
@@ -114351,7 +114351,7 @@ function parseSources(value) {
         'Invalid "sources" frontmatter. Expected each source to be a string or object.'
       );
     }
-    const path189 = readRequiredString(getOwnEntry35(item, "path"), "sources[].path");
+    const path190 = readRequiredString(getOwnEntry35(item, "path"), "sources[].path");
     const startLine = readOptionalPositiveInteger(
       getOwnEntry35(item, "startLine"),
       "sources[].startLine"
@@ -114359,7 +114359,7 @@ function parseSources(value) {
     const endLine = readOptionalPositiveInteger(getOwnEntry35(item, "endLine"), "sources[].endLine");
     return parseSourceRef(
       serializeSourceRef({
-        path: path189,
+        path: path190,
         ...startLine === void 0 ? {} : { startLine },
         ...endLine === void 0 ? {} : { endLine }
       })
@@ -130879,9 +130879,9 @@ function findPathToModule(currentModuleName, targetModuleName, dependencyGraph,
   }
   visited.add(currentModuleName);
   for (const dependencyModuleName of dependencyGraph.get(currentModuleName) ?? []) {
-    const path189 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
-    if (path189 !== void 0) {
-      return [currentModuleName, ...path189];
+    const path190 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
+    if (path190 !== void 0) {
+      return [currentModuleName, ...path190];
     }
   }
   visited.delete(currentModuleName);
@@ -135699,6 +135699,47 @@ var init_hash = __esm({
   }
 });
 
+// packages/safejs/src/interp/resources.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+async function withRunResources(signal, execute2) {
+  const controller = new AbortController();
+  const cancel2 = () => controller.abort(signal?.reason);
+  const cleanups = /* @__PURE__ */ new Set();
+  const resources = {
+    signal: controller.signal,
+    add(close) {
+      cleanups.add(close);
+    }
+  };
+  signal?.addEventListener("abort", cancel2, { once: true });
+  if (signal?.aborted) cancel2();
+  let result;
+  let failure;
+  let errors2 = [];
+  try {
+    result = await runResources.run(resources, execute2);
+  } catch (error3) {
+    failure = { reason: error3 };
+  } finally {
+    signal?.removeEventListener("abort", cancel2);
+    controller.abort(new Error("SafeJS run finished."));
+    const outcomes = await Promise.allSettled(
+      [...cleanups].map((close) => Promise.resolve().then(close))
+    );
+    errors2 = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  }
+  if (failure !== void 0) throw failure.reason;
+  if (errors2.length > 0) throw new AggregateError(errors2, "SafeJS resource cleanup failed.");
+  return result;
+}
+var runResources;
+var init_resources = __esm({
+  "packages/safejs/src/interp/resources.ts"() {
+    "use strict";
+    runResources = new AsyncLocalStorage3();
+  }
+});
+
 // packages/safejs/src/observability/otel.ts
 function bindOtelSpan(value, span) {
   spanByAsyncValue.set(value, span);
@@ -136047,7 +136088,7 @@ var init_budget2 = __esm({
 });
 
 // packages/safejs/src/interp/promise-tracker.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 function assertPromiseExecutionAllowed() {
   const failure = activePromiseTracker.getStore()?.failure;
   if (failure !== void 0 && fatalRejectionCleanup.getStore() !== true) throw failure;
@@ -136161,8 +136202,8 @@ var init_promise_tracker = __esm({
         return void 0;
       }
     };
-    activePromiseTracker = new AsyncLocalStorage3();
-    fatalRejectionCleanup = new AsyncLocalStorage3();
+    activePromiseTracker = new AsyncLocalStorage4();
+    fatalRejectionCleanup = new AsyncLocalStorage4();
   }
 });
 
@@ -136223,11 +136264,11 @@ function assertSandboxDataDepth(depth) {
     throw new SandboxError({ budget: "dataDepth", current: depth, limit: MAX_DATA_DEPTH });
   }
 }
-function assertSnapshotDataDepth(depth, path189) {
-  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path189, depth);
+function assertSnapshotDataDepth(depth, path190) {
+  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path190, depth);
 }
 function assertSnapshotGraphDepth(value, rootPath = "$") {
-  walkGraphDepth(value, rootPath, (depth, path189) => assertSnapshotDataDepth(depth, path189));
+  walkGraphDepth(value, rootPath, (depth, path190) => assertSnapshotDataDepth(depth, path190));
 }
 function assertSandboxGraphDepth(value) {
   walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth));
@@ -136294,12 +136335,12 @@ var init_graph_depth = __esm({
       current;
       limit;
       path;
-      constructor(path189, current, limit = MAX_DATA_DEPTH) {
-        super(`Snapshot budget exceeded for dataDepth at ${path189}: ${current} > ${limit}.`);
+      constructor(path190, current, limit = MAX_DATA_DEPTH) {
+        super(`Snapshot budget exceeded for dataDepth at ${path190}: ${current} > ${limit}.`);
         this.name = "SnapshotBudgetError";
         this.current = current;
         this.limit = limit;
-        this.path = path189;
+        this.path = path190;
         replaceErrorStack(this);
       }
     };
@@ -136382,7 +136423,7 @@ function createDumpFile(snapshot2) {
   }
   return dumped;
 }
-function serializeDumpValue(value, path189, state) {
+function serializeDumpValue(value, path190, state) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
@@ -136399,22 +136440,22 @@ function serializeDumpValue(value, path189, state) {
     return SKIP_VALUE;
   }
   if (Array.isArray(value)) {
-    const reference2 = serializeHeapReference(value, path189, state);
+    const reference2 = serializeHeapReference(value, path190, state);
     if (reference2 !== void 0) {
       return reference2;
     }
-    return serializeArrayItems(value, path189, state);
+    return serializeArrayItems(value, path190, state);
   }
   if (!isPlainObject9(value)) {
     return SKIP_VALUE;
   }
-  const reference = serializeHeapReference(value, path189, state);
+  const reference = serializeHeapReference(value, path190, state);
   if (reference !== void 0) {
     return reference;
   }
-  return serializeObjectEntries(value, path189, state);
+  return serializeObjectEntries(value, path190, state);
 }
-function serializeHeapReference(value, path189, state) {
+function serializeHeapReference(value, path190, state) {
   const id = state.heapIds.get(value);
   if (id === void 0) {
     return void 0;
@@ -136423,19 +136464,19 @@ function serializeHeapReference(value, path189, state) {
     state.serializedHeapIds.add(id);
     if (isSandboxArguments(value)) {
       state.heap[String(id)] = serializeArguments(value, (entry, key3) => {
-        const serialized = serializeDumpValue(entry, `${path189}.${key3}`, state);
+        const serialized = serializeDumpValue(entry, `${path190}.${key3}`, state);
         return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
       });
     } else if (Array.isArray(value)) {
       state.heap[String(id)] = {
         kind: "array",
-        items: serializeArrayItems(value, path189, state)
+        items: serializeArrayItems(value, path190, state)
       };
     } else {
       const errorType = sandboxErrorTypes.get(value);
       state.heap[String(id)] = {
         kind: "object",
-        entries: serializeObjectEntries(value, path189, state),
+        entries: serializeObjectEntries(value, path190, state),
         ...errorType === void 0 ? {} : { errorType }
       };
     }
@@ -136445,10 +136486,10 @@ function serializeHeapReference(value, path189, state) {
     id
   };
 }
-function serializeObjectEntries(value, path189, state) {
+function serializeObjectEntries(value, path190, state) {
   const serialized = {};
   for (const [key3, entry] of getEnumerableDataEntries(value)) {
-    const dumped = serializeDumpValue(entry, `${path189}.${key3}`, state);
+    const dumped = serializeDumpValue(entry, `${path190}.${key3}`, state);
     if (dumped !== SKIP_VALUE) {
       serialized[key3] = dumped;
     }
@@ -136510,9 +136551,9 @@ function isPlainObject9(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function serializeArrayItems(value, path189, state) {
+function serializeArrayItems(value, path190, state) {
   return getArrayDataItems(value).map((entry, index) => {
-    const serialized = serializeDumpValue(entry, `${path189}[${index}]`, state);
+    const serialized = serializeDumpValue(entry, `${path190}[${index}]`, state);
     return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
   });
 }
@@ -136546,7 +136587,7 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     DUMP_FORMAT_VERSION = 1;
-    EXECUTION_SEMANTICS = "jobs-v4";
+    EXECUTION_SEMANTICS = "jobs-v5";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
@@ -136593,44 +136634,44 @@ function validateDumpHeap(root, state) {
   const heap = root.heap === void 0 ? /* @__PURE__ */ Object.create(null) : requireRecord3(root.heap, "$.heap");
   const heapIds = /* @__PURE__ */ new Set();
   for (const [key3, value] of Object.entries(heap)) {
-    const path189 = `$.heap${formatKey(key3)}`;
-    const id = parseHeapId(key3, path189);
-    addUnique2(heapIds, id, path189);
-    const entry = requireRecord3(value, path189);
-    validateErrorType(entry, path189);
+    const path190 = `$.heap${formatKey(key3)}`;
+    const id = parseHeapId(key3, path190);
+    addUnique2(heapIds, id, path190);
+    const entry = requireRecord3(value, path190);
+    validateErrorType(entry, path190);
     if (entry.kind === "arguments") {
-      validateArgumentsProperties(entry, path189);
+      validateArgumentsProperties(entry, path190);
       continue;
     }
     if (entry.kind === "array") {
-      requireArray(entry.items, `${path189}.items`, state);
+      requireArray(entry.items, `${path190}.items`, state);
       continue;
     }
     if (entry.kind === "object") {
-      requireRecord3(entry.entries, `${path189}.entries`);
+      requireRecord3(entry.entries, `${path190}.entries`);
       continue;
     }
-    fail2("unknownTag", `${path189}.kind`, "unknown dump heap tag");
+    fail2("unknownTag", `${path190}.kind`, "unknown dump heap tag");
   }
   validateDumpReferences(root, "$", 0, state, heapIds);
 }
-function validateDumpReferences(value, path189, depth, state, heapIds) {
+function validateDumpReferences(value, path190, depth, state, heapIds) {
   if (value === null || typeof value !== "object") return;
   if (depth > state.limits.maxDepth)
-    fail2("budgetExceeded", path189, `exceeds nesting limit ${state.limits.maxDepth}`);
+    fail2("budgetExceeded", path190, `exceeds nesting limit ${state.limits.maxDepth}`);
   if (Array.isArray(value)) {
     value.forEach(
-      (entry, index) => validateDumpReferences(entry, `${path189}[${index}]`, depth + 1, state, heapIds)
+      (entry, index) => validateDumpReferences(entry, `${path190}[${index}]`, depth + 1, state, heapIds)
     );
     return;
   }
   const record2 = value;
   if (record2.kind === "ref") {
-    const id = requireSafeInteger(record2.id, `${path189}.id`, 1);
-    if (!heapIds.has(id)) fail2("danglingReference", `${path189}.id`, `unknown heap value ${id}`);
+    const id = requireSafeInteger(record2.id, `${path190}.id`, 1);
+    if (!heapIds.has(id)) fail2("danglingReference", `${path190}.id`, `unknown heap value ${id}`);
   }
   for (const [key3, entry] of Object.entries(record2)) {
-    validateDumpReferences(entry, `${path189}${formatKey(key3)}`, depth + 1, state, heapIds);
+    validateDumpReferences(entry, `${path190}${formatKey(key3)}`, depth + 1, state, heapIds);
   }
 }
 function validateRunSnapshotState(root, state) {
@@ -136649,64 +136690,64 @@ function validateRunSnapshotState(root, state) {
   if (root.loopIterations !== void 0) {
     const iterations = requireRecord3(root.loopIterations, "$.loopIterations");
     for (const [nodeId, value] of Object.entries(iterations)) {
-      const path189 = `$.loopIterations${formatKey(nodeId)}`;
-      requireSafeInteger(Number(nodeId), `${path189}#key`, 0);
+      const path190 = `$.loopIterations${formatKey(nodeId)}`;
+      requireSafeInteger(Number(nodeId), `${path190}#key`, 0);
       if (typeof value === "number") {
-        requireSafeInteger(value, path189, 0);
+        requireSafeInteger(value, path190, 0);
         continue;
       }
-      const iteration = requireRecord3(value, path189);
-      requireSafeInteger(iteration.index, `${path189}.index`, 0);
-      requireArray(iteration.values, `${path189}.values`, state);
+      const iteration = requireRecord3(value, path190);
+      requireSafeInteger(iteration.index, `${path190}.index`, 0);
+      requireArray(iteration.values, `${path190}.values`, state);
     }
   }
   if (root.pendingAwaits !== void 0) {
     const pendingAwaits = requireArray(root.pendingAwaits, "$.pendingAwaits", state);
     pendingAwaits.forEach((value, index) => {
-      const path189 = `$.pendingAwaits[${index}]`;
-      const pending = requireRecord3(value, path189);
-      if (pending.nodeId !== void 0) requireSafeInteger(pending.nodeId, `${path189}.nodeId`, 0);
-      const span = requireRecord3(pending.span, `${path189}.span`);
-      const start = validatePosition(span.start, `${path189}.span.start`);
-      const end = validatePosition(span.end, `${path189}.span.end`);
+      const path190 = `$.pendingAwaits[${index}]`;
+      const pending = requireRecord3(value, path190);
+      if (pending.nodeId !== void 0) requireSafeInteger(pending.nodeId, `${path190}.nodeId`, 0);
+      const span = requireRecord3(pending.span, `${path190}.span`);
+      const start = validatePosition(span.start, `${path190}.span.start`);
+      const end = validatePosition(span.end, `${path190}.span.end`);
       if (start > end) {
-        fail2("invalidValue", `${path189}.span`, "start must not exceed end");
+        fail2("invalidValue", `${path190}.span`, "start must not exceed end");
       }
     });
   }
 }
-function validatePosition(value, path189) {
-  const position = requireRecord3(value, path189);
-  requireSafeInteger(position.line, `${path189}.line`, 1);
-  requireSafeInteger(position.column, `${path189}.column`, 0);
-  return requireSafeInteger(position.offset, `${path189}.offset`, 0);
+function validatePosition(value, path190) {
+  const position = requireRecord3(value, path190);
+  requireSafeInteger(position.line, `${path190}.line`, 1);
+  requireSafeInteger(position.column, `${path190}.column`, 0);
+  return requireSafeInteger(position.offset, `${path190}.offset`, 0);
 }
-function validateTaggedValue(record2, path189, state) {
+function validateTaggedValue(record2, path190, state) {
   switch (record2.kind) {
     case "undefined":
       return;
     case "number":
       if (!["-Infinity", "Infinity", "NaN"].includes(String(record2.value))) {
-        fail2("invalidValue", `${path189}.value`, "unknown non-finite number value");
+        fail2("invalidValue", `${path190}.value`, "unknown non-finite number value");
       }
       return;
     case "fn":
-      requireSafeInteger(record2.astNodeId, `${path189}.astNodeId`, 0);
-      requireSnapshotId(record2.capturedScopeId, `${path189}.capturedScopeId`);
+      requireSafeInteger(record2.astNodeId, `${path190}.astNodeId`, 0);
+      requireSnapshotId(record2.capturedScopeId, `${path190}.capturedScopeId`);
       return;
     case "generator":
-      validateGeneratorShape(record2, path189, state);
+      validateGeneratorShape(record2, path190, state);
       return;
     case "promise":
-      requireSnapshotId(record2.id, `${path189}.id`);
+      requireSnapshotId(record2.id, `${path190}.id`);
       return;
     case "ref":
-      requireSafeInteger(record2.id, `${path189}.id`, 1);
+      requireSafeInteger(record2.id, `${path190}.id`, 1);
       return;
     case "regex":
-      requireString2(record2.source, `${path189}.source`, state.limits);
-      requireString2(record2.flags, `${path189}.flags`, state.limits);
-      requireSafeInteger(record2.lastIndex, `${path189}.lastIndex`, 0);
+      requireString2(record2.source, `${path190}.source`, state.limits);
+      requireString2(record2.flags, `${path190}.flags`, state.limits);
+      requireSafeInteger(record2.lastIndex, `${path190}.lastIndex`, 0);
       return;
     case "array":
     case "arguments":
@@ -136716,28 +136757,28 @@ function validateTaggedValue(record2, path189, state) {
       return;
   }
 }
-function validateGeneratorShape(record2, path189, state) {
+function validateGeneratorShape(record2, path190, state) {
   if (!["start", "suspended", "done"].includes(String(record2.state))) {
-    fail2("invalidState", `${path189}.state`, "unknown generator state");
+    fail2("invalidState", `${path190}.state`, "unknown generator state");
   }
   if (record2.state === "done") {
     if (record2.astNodeId !== void 0 || record2.capturedScopeId !== void 0 || record2.sent !== void 0 || record2.yieldNodeId !== void 0) {
-      fail2("invalidState", path189, "done generator cannot contain resume state");
+      fail2("invalidState", path190, "done generator cannot contain resume state");
     }
     return;
   }
-  requireSafeInteger(record2.astNodeId, `${path189}.astNodeId`, 0);
-  requireSnapshotId(record2.capturedScopeId, `${path189}.capturedScopeId`);
+  requireSafeInteger(record2.astNodeId, `${path190}.astNodeId`, 0);
+  requireSnapshotId(record2.capturedScopeId, `${path190}.capturedScopeId`);
   if (record2.state === "start") {
     if (record2.sent !== void 0 || record2.yieldNodeId !== void 0) {
-      fail2("invalidState", path189, "unstarted generator cannot contain a resume cursor");
+      fail2("invalidState", path190, "unstarted generator cannot contain a resume cursor");
     }
     return;
   }
-  requireSafeInteger(record2.yieldNodeId, `${path189}.yieldNodeId`, 0);
-  const sent = requireArray(record2.sent, `${path189}.sent`, state);
+  requireSafeInteger(record2.yieldNodeId, `${path190}.yieldNodeId`, 0);
+  const sent = requireArray(record2.sent, `${path190}.sent`, state);
   sent.forEach((completion, index) => {
-    const completionPath = `${path189}.sent[${index}]`;
+    const completionPath = `${path190}.sent[${index}]`;
     const candidate = requireRecord3(completion, completionPath);
     if (!Object.hasOwn(candidate, "type")) {
       fail2("invalidValue", `${completionPath}.type`, "completion type is required");
@@ -136750,41 +136791,41 @@ function validateGeneratorShape(record2, path189, state) {
     }
   });
 }
-function validateErrorType(record2, path189) {
+function validateErrorType(record2, path190) {
   if (!Object.hasOwn(record2, "errorType")) return;
   if (record2.kind !== "object" || !sandboxErrorNames.includes(record2.errorType)) {
-    fail2("invalidValue", `${path189}.errorType`, "invalid error metadata");
+    fail2("invalidValue", `${path190}.errorType`, "invalid error metadata");
   }
 }
-function validateArgumentsProperties(record2, path189) {
+function validateArgumentsProperties(record2, path190) {
   if (typeof record2.extensible !== "boolean") {
-    fail2("invalidType", `${path189}.extensible`, "expected boolean");
+    fail2("invalidType", `${path190}.extensible`, "expected boolean");
   }
   if (typeof record2.lengthBeforeCallee !== "boolean") {
-    fail2("invalidType", `${path189}.lengthBeforeCallee`, "expected boolean");
+    fail2("invalidType", `${path190}.lengthBeforeCallee`, "expected boolean");
   }
-  const properties = requireRecord3(record2.properties, `${path189}.properties`);
+  const properties = requireRecord3(record2.properties, `${path190}.properties`);
   if (record2.iterator !== null) {
-    const iterator = requireRecord3(record2.iterator, `${path189}.iterator`);
+    const iterator = requireRecord3(record2.iterator, `${path190}.iterator`);
     for (const key3 of Object.keys(iterator)) {
       if (!["configurable", "enumerable", "writable"].includes(key3)) {
         fail2(
           "invalidValue",
-          `${path189}.iterator${formatKey(key3)}`,
+          `${path190}.iterator${formatKey(key3)}`,
           "unknown iterator descriptor field"
         );
       }
     }
     for (const flag of ["configurable", "enumerable", "writable"]) {
       if (typeof iterator[flag] !== "boolean")
-        fail2("invalidType", `${path189}.iterator.${flag}`, "expected boolean");
+        fail2("invalidType", `${path190}.iterator.${flag}`, "expected boolean");
     }
   }
   if (record2.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
-    fail2("invalidValue", `${path189}.properties`, "initial length property is required");
+    fail2("invalidValue", `${path190}.properties`, "initial length property is required");
   }
   for (const [key3, value] of Object.entries(properties)) {
-    const propertyPath = `${path189}.properties${formatKey(key3)}`;
+    const propertyPath = `${path190}.properties${formatKey(key3)}`;
     if (key3 === "callee")
       fail2("invalidValue", propertyPath, "strict callee accessor cannot be replaced");
     const descriptor = requireRecord3(value, propertyPath);
@@ -136805,71 +136846,71 @@ function validateArgumentsProperties(record2, path189) {
     }
   }
 }
-function validateGenericValue(value, path189, depth, state) {
+function validateGenericValue(value, path190, depth, state) {
   if (state.dataPropertiesOnly && types.isProxy(value)) {
-    fail2("invalidType", path189, "proxy objects are not snapshot data");
+    fail2("invalidType", path190, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
-    fail2("budgetExceeded", path189, `exceeds nesting limit ${state.limits.maxDepth}`);
+    fail2("budgetExceeded", path190, `exceeds nesting limit ${state.limits.maxDepth}`);
   state.entries += 1;
   if (state.entries > state.limits.maxAggregateEntries)
     fail2(
       "budgetExceeded",
-      path189,
+      path190,
       `exceeds aggregate entry limit ${state.limits.maxAggregateEntries}`
     );
   if (typeof value === "string") {
-    requireString2(value, path189, state.limits);
+    requireString2(value, path190, state.limits);
     state.dataSize += value.length;
   } else if (typeof value === "number") {
     if (Number.isInteger(value) && !Number.isSafeInteger(value))
-      fail2("invalidValue", path189, "integer must be safe");
+      fail2("invalidValue", path190, "integer must be safe");
   } else if (Array.isArray(value)) {
-    if (value.length > state.limits.maxEntries) fail2("budgetExceeded", path189, "array is too large");
+    if (value.length > state.limits.maxEntries) fail2("budgetExceeded", path190, "array is too large");
     if (state.dataPropertiesOnly) {
-      const entries = snapshotDataEntries(value, path189).filter(([key3]) => key3 !== "length");
+      const entries = snapshotDataEntries(value, path190).filter(([key3]) => key3 !== "length");
       if (entries.length !== value.length)
-        fail2("invalidType", path189, "snapshot arrays must be dense");
+        fail2("invalidType", path190, "snapshot arrays must be dense");
       for (const [key3, entry] of entries) {
         const index = Number(key3);
         if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key3) {
-          fail2("invalidType", path189, "snapshot arrays cannot have named properties");
+          fail2("invalidType", path190, "snapshot arrays cannot have named properties");
         }
-        validateGenericValue(entry, `${path189}[${key3}]`, depth + 1, state);
+        validateGenericValue(entry, `${path190}[${key3}]`, depth + 1, state);
       }
     } else {
       value.forEach(
-        (entry, index) => validateGenericValue(entry, `${path189}[${index}]`, depth + 1, state)
+        (entry, index) => validateGenericValue(entry, `${path190}[${index}]`, depth + 1, state)
       );
     }
   } else if (value !== null && typeof value === "object") {
     const record2 = value;
     if (state.validateTaggedPayloads && isTaggedValueShape(record2)) {
-      validateTaggedValue(record2, path189, state);
+      validateTaggedValue(record2, path190, state);
     }
-    const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path189) : Object.entries(value);
+    const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path190) : Object.entries(value);
     for (const [key3, entry] of entries) {
-      requireString2(key3, `${path189}${formatKey(key3)}`, state.limits);
+      requireString2(key3, `${path190}${formatKey(key3)}`, state.limits);
       state.dataSize += key3.length;
-      validateGenericValue(entry, `${path189}${formatKey(key3)}`, depth + 1, state);
+      validateGenericValue(entry, `${path190}${formatKey(key3)}`, depth + 1, state);
     }
   } else if (!["boolean", "number"].includes(typeof value) && !(state.allowFunctions && typeof value === "function") && !(state.allowUndefined && value === void 0) && value !== null) {
-    fail2("invalidType", path189, "contains an unsupported value");
+    fail2("invalidType", path190, "contains an unsupported value");
   }
   if (state.dataSize > state.limits.maxDataSize)
-    fail2("budgetExceeded", path189, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
+    fail2("budgetExceeded", path190, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
 }
-function snapshotDataEntries(value, path189) {
+function snapshotDataEntries(value, path190) {
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== null && prototype !== (Array.isArray(value) ? Array.prototype : Object.prototype)) {
-    fail2("invalidType", path189, "snapshot data must not have a custom prototype");
+    fail2("invalidType", path190, "snapshot data must not have a custom prototype");
   }
   if (Object.getOwnPropertySymbols(value).length > 0) {
-    fail2("invalidType", path189, "snapshot data must not have symbol properties");
+    fail2("invalidType", path190, "snapshot data must not have symbol properties");
   }
   return Object.entries(Object.getOwnPropertyDescriptors(value)).map(([key3, descriptor]) => {
     if (!("value" in descriptor))
-      fail2("invalidType", `${path189}${formatKey(key3)}`, "snapshot data must not have accessors");
+      fail2("invalidType", `${path190}${formatKey(key3)}`, "snapshot data must not have accessors");
     return [key3, descriptor.value];
   });
 }
@@ -136883,48 +136924,48 @@ function defaultLimits() {
     maxDataSize: DEFAULT_MAX_DATA_SIZE
   };
 }
-function requireArray(value, path189, state) {
-  if (!Array.isArray(value)) fail2("invalidType", path189, "must be an array");
+function requireArray(value, path190, state) {
+  if (!Array.isArray(value)) fail2("invalidType", path190, "must be an array");
   if (value.length > state.limits.maxEntries)
-    fail2("budgetExceeded", path189, `exceeds collection entry limit ${state.limits.maxEntries}`);
+    fail2("budgetExceeded", path190, `exceeds collection entry limit ${state.limits.maxEntries}`);
   return value;
 }
-function requireRecord3(value, path189) {
+function requireRecord3(value, path190) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
-    fail2("invalidType", path189, "must be an object");
+    fail2("invalidType", path190, "must be an object");
   return value;
 }
-function requireSnapshotId(value, path189) {
+function requireSnapshotId(value, path190) {
   if (typeof value === "string") {
-    if (value.length === 0) fail2("invalidValue", path189, "id must not be empty");
+    if (value.length === 0) fail2("invalidValue", path190, "id must not be empty");
     return value;
   }
-  return requireSafeInteger(value, path189, 0);
+  return requireSafeInteger(value, path190, 0);
 }
-function requireSafeInteger(value, path189, minimum) {
+function requireSafeInteger(value, path190, minimum) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)
-    fail2("invalidValue", path189, `must be a safe integer >= ${minimum}`);
+    fail2("invalidValue", path190, `must be a safe integer >= ${minimum}`);
   return value;
 }
-function requireNonEmptyString5(value, path189, limits) {
-  const text5 = requireString2(value, path189, limits);
-  if (text5.length === 0) fail2("invalidValue", path189, "must not be empty");
+function requireNonEmptyString5(value, path190, limits) {
+  const text5 = requireString2(value, path190, limits);
+  if (text5.length === 0) fail2("invalidValue", path190, "must not be empty");
   return text5;
 }
-function requireString2(value, path189, limits) {
-  if (typeof value !== "string") fail2("invalidType", path189, "must be a string");
+function requireString2(value, path190, limits) {
+  if (typeof value !== "string") fail2("invalidType", path190, "must be a string");
   if (value.length > limits.maxStringLength)
-    fail2("budgetExceeded", path189, `exceeds string limit ${limits.maxStringLength}`);
+    fail2("budgetExceeded", path190, `exceeds string limit ${limits.maxStringLength}`);
   return value;
 }
-function addUnique2(values, value, path189) {
-  if (values.has(value)) fail2("duplicateId", path189, `duplicate id ${String(value)}`);
+function addUnique2(values, value, path190) {
+  if (values.has(value)) fail2("duplicateId", path190, `duplicate id ${String(value)}`);
   values.add(value);
 }
-function parseHeapId(value, path189) {
+function parseHeapId(value, path190) {
   if (String(Number(value)) !== value)
-    fail2("invalidValue", path189, "heap key must be a canonical positive integer");
-  return requireSafeInteger(Number(value), path189, 1);
+    fail2("invalidValue", path190, "heap key must be a canonical positive integer");
+  return requireSafeInteger(Number(value), path190, 1);
 }
 function formatKey(key3) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key3) ? `.${key3}` : `[${JSON.stringify(key3)}]`;
@@ -136932,8 +136973,8 @@ function formatKey(key3) {
 function isTaggedValueShape(value) {
   return typeof value.kind === "string" && TAGGED_VALUE_KINDS.has(value.kind);
 }
-function fail2(code, path189, detail) {
-  throw new SnapshotValidationError(code, path189, detail);
+function fail2(code, path190, detail) {
+  throw new SnapshotValidationError(code, path190, detail);
 }
 var DEFAULT_MAX_DEPTH, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_STRING_LENGTH, DEFAULT_MAX_DATA_SIZE, TAGGED_VALUE_KINDS, SnapshotValidationError;
 var init_validation = __esm({
@@ -136964,11 +137005,11 @@ var init_validation = __esm({
     SnapshotValidationError = class extends Error {
       code;
       path;
-      constructor(code, path189, detail) {
-        super(`Invalid snapshot at ${path189}: ${detail}`);
+      constructor(code, path190, detail) {
+        super(`Invalid snapshot at ${path190}: ${detail}`);
         this.name = "SnapshotValidationError";
         this.code = code;
-        this.path = path189;
+        this.path = path190;
         replaceErrorStack(this);
       }
     };
@@ -136976,7 +137017,7 @@ var init_validation = __esm({
 });
 
 // packages/safejs/src/interp/promise-replay.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 function validateReplay(value) {
   validateSnapshotData(value);
   if (value === null || typeof value !== "object" || !("version" in value) || value.version !== 1 || !("steps" in value) || !isCounter(value.steps) || !("promises" in value) || !isCounter(value.promises) || !("settlements" in value) || !Array.isArray(value.settlements)) {
@@ -137314,7 +137355,7 @@ var init_promise_replay = __esm({
         this.liveWaiters.clear();
       }
     };
-    promiseReplayContext = new AsyncLocalStorage4();
+    promiseReplayContext = new AsyncLocalStorage5();
   }
 });
 
@@ -137322,7 +137363,7 @@ var init_promise_replay = __esm({
 function encodeReplayData(value, options = {}) {
   const nodes = [];
   const seen = /* @__PURE__ */ new WeakMap();
-  const encode = (entry, depth, path189) => {
+  const encode = (entry, depth, path190) => {
     if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
     if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
     if (entry === void 0) return { tag: "undefined" };
@@ -137335,12 +137376,12 @@ function encodeReplayData(value, options = {}) {
       };
     }
     if (isSandboxPromise(entry)) {
-      const id2 = options.identifyPromise?.(entry, path189);
+      const id2 = options.identifyPromise?.(entry, path190);
       if (typeof id2 === "string" && id2.length > 0) return { tag: "promise-capability", id: id2 };
     }
     let capabilityId;
     if (isSandboxClosure(entry)) {
-      capabilityId = options.identifyCapability?.(entry, path189);
+      capabilityId = options.identifyCapability?.(entry, path190);
       if (typeof capabilityId !== "string" || capabilityId.length === 0)
         throw new MissingReplayCapabilityError("A callable needs an explicit resume capability.");
       if (!options.captureCapabilityProperties) return { tag: "capability", id: capabilityId };
@@ -137355,7 +137396,7 @@ function encodeReplayData(value, options = {}) {
     const id = nodes.length;
     seen.set(entry, id);
     nodes.push(void 0);
-    const child = (value2, key3) => encode(value2, depth + 1, [...path189, key3]);
+    const child = (value2, key3) => encode(value2, depth + 1, [...path190, key3]);
     if (isSandboxClosure(entry)) {
       nodes[id] = {
         kind: "capability",
@@ -137477,7 +137518,7 @@ function decodeReplayData(input, options = {}) {
         restored.set(id, capability);
         return capability;
       }
-      return createSandboxClosure({
+      const copy = createSandboxClosure({
         ...capability,
         boundTarget: capability.boundTarget,
         cancellationSignal: capability.cancellationSignal,
@@ -137491,6 +137532,8 @@ function decodeReplayData(input, options = {}) {
           return properties;
         }
       });
+      options.onCapabilityRestored?.(capability, copy);
+      return copy;
     }
     if (kind === "map") {
       const result2 = createSandboxMap();
@@ -137648,7 +137691,7 @@ import { createHash as createHash13, randomUUID as randomUUID49 } from "node:cry
 function copyOutcome(outcome) {
   return outcome.status === "fulfilled" ? { status: "fulfilled", value: deepCopyToSandbox(outcome.value) } : { status: "rejected", reason: deepCopyToSandbox(outcome.reason) };
 }
-function restoreReplayCalls(input, encodedOutcomes, callbackSizes) {
+function restoreReplayCalls(input, encodedOutcomes, callbackSizes, requiredHostCapabilities = /* @__PURE__ */ new Set()) {
   validateSnapshotData(input);
   if (input === null || typeof input !== "object" || !("version" in input) || input.version !== 1 || !("calls" in input) || !Array.isArray(input.calls)) {
     throw new TypeError("Invalid host call replay header.");
@@ -137669,7 +137712,23 @@ function restoreReplayCalls(input, encodedOutcomes, callbackSizes) {
       );
     }
   }
-  const resolveCapability = (id) => capabilities.get(id);
+  const resolveCapability = (id) => {
+    if (!capabilities.has(id) && id.startsWith("host:")) {
+      const path190 = JSON.parse(id.slice(5));
+      if (!Array.isArray(path190) || path190.length < 2 || path190.some((value) => typeof value !== "string"))
+        throw new TypeError("Invalid host capability identity.");
+      requiredHostCapabilities.add(id);
+      capabilities.set(
+        id,
+        createSandboxClosure({
+          call: () => {
+            throw new TypeError("Host capability has not been reconstructed.");
+          }
+        })
+      );
+    }
+    return capabilities.get(id);
+  };
   return input.calls.map((entry, index) => {
     if (entry === null || typeof entry !== "object" || Array.isArray(entry))
       throw new TypeError("Invalid replay call.");
@@ -137842,7 +137901,12 @@ var init_host_call = __esm({
         this.budget = budget;
         this.recordedReplay = replay !== void 0;
         if (replay !== void 0) {
-          const replayRecords = restoreReplayCalls(replay, this.encodedOutcomes, this.callbackSizes);
+          const replayRecords = restoreReplayCalls(
+            replay,
+            this.encodedOutcomes,
+            this.callbackSizes,
+            this.requiredHostCapabilities
+          );
           const restoredRunId = replayRecords[0]?.runId ?? records[0]?.runId ?? randomUUID49();
           validateRestoredRecords(records, restoredRunId, sourceHash);
           for (const record2 of records) {
@@ -137894,8 +137958,10 @@ var init_host_call = __esm({
       retainedSize = 0;
       outcomeSizes = /* @__PURE__ */ new Map();
       capabilities = /* @__PURE__ */ new Map();
+      requiredHostCapabilities = /* @__PURE__ */ new Set();
       capabilityIds = /* @__PURE__ */ new WeakMap();
       nativeClosures = /* @__PURE__ */ new WeakMap();
+      hostSources = /* @__PURE__ */ new WeakMap();
       encodedOutcomes = /* @__PURE__ */ new Map();
       callbackSizes = /* @__PURE__ */ new Map();
       completedCallbackOwners = /* @__PURE__ */ new Set();
@@ -138048,6 +138114,30 @@ var init_host_call = __esm({
         if (!this.capabilityIds.has(closure)) this.capabilityIds.set(closure, identity);
         this.nativeClosures.set(native, closure);
       }
+      registerHostCapability(path190, closure, native) {
+        const identity = `host:${path190}`;
+        const existing = this.capabilities.get(identity);
+        if (existing !== void 0 && existing !== closure)
+          throw new TypeError(`Conflicting replay capability '${identity}'.`);
+        this.capabilities.set(identity, closure);
+        if (!this.capabilityIds.has(closure)) this.capabilityIds.set(closure, identity);
+        if (!this.nativeClosures.has(native)) this.nativeClosures.set(native, closure);
+        this.hostSources.set(closure, native);
+      }
+      rebindHostCapability(original, restored) {
+        const identity = this.capabilityIds.get(original);
+        const source = this.hostSources.get(original);
+        if (identity === void 0 || source === void 0) return;
+        this.capabilities.set(identity, restored);
+        this.capabilityIds.set(restored, identity);
+        this.nativeClosures.set(source, restored);
+        this.hostSources.set(restored, source);
+      }
+      validateHostCapabilities() {
+        for (const identity of this.requiredHostCapabilities) {
+          if (!this.capabilities.has(identity)) throw new UnresolvedReplayCapabilityError(identity);
+        }
+      }
       waitForCapability(id) {
         if (this.capabilities.has(id)) return Promise.resolve();
         const owner = id.slice(0, id.lastIndexOf("/function/"));
@@ -138716,7 +138806,7 @@ var init_iteration = __esm({
 });
 
 // packages/safejs/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
 function runPromiseJob(task) {
   const job = activeJob.getStore();
   return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
@@ -138750,7 +138840,7 @@ var activeJob, SandboxJobQueue;
 var init_jobs4 = __esm({
   "packages/safejs/src/interp/jobs.ts"() {
     "use strict";
-    activeJob = new AsyncLocalStorage5();
+    activeJob = new AsyncLocalStorage6();
     SandboxJobQueue = class {
       running = false;
       pending = [];
@@ -139558,7 +139648,7 @@ var init_promise = __esm({
 });
 
 // packages/safejs/src/interp/cancel.ts
-import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
 function withCancellationSignal(signal, task) {
   return activeCancellation.run({ signal, host: false }, task);
 }
@@ -139738,7 +139828,7 @@ var init_cancel2 = __esm({
     init_promise_tracker();
     init_shape();
     init_promise();
-    activeCancellation = new AsyncLocalStorage6();
+    activeCancellation = new AsyncLocalStorage7();
     sandboxPromises = /* @__PURE__ */ new WeakSet();
     cancelableOutcomes = /* @__PURE__ */ new WeakMap();
   }
@@ -139981,7 +140071,7 @@ function deepCopyFromSandbox(value, options = {}) {
     options
   );
 }
-function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections = false, depth = 0) {
+function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections = false, depth = 0) {
   assertSandboxDataDepth(depth);
   if (isSandboxPrimitive(value)) {
     return value;
@@ -139997,8 +140087,8 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const [key3, entry] of value.entries) {
       copy.entries.set(
-        copyToSandbox(key3, state, `${path189}.<key>`, true, depth + 1),
-        copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1)
+        copyToSandbox(key3, state, `${path190}.<key>`, true, depth + 1),
+        copyToSandbox(entry, state, `${path190}.<value>`, true, depth + 1)
       );
     }
     return copy;
@@ -140010,7 +140100,7 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     const copy = createSandboxSet();
     state.seen.set(value, copy);
     for (const entry of value.values) {
-      copy.values.add(copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1));
+      copy.values.add(copyToSandbox(entry, state, `${path190}.<value>`, true, depth + 1));
     }
     return copy;
   }
@@ -140036,8 +140126,8 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const [key3, entry] of value) {
       copy.entries.set(
-        copyToSandbox(key3, state, `${path189}.<key>`, cloneSandboxCollections, depth + 1),
-        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
+        copyToSandbox(key3, state, `${path190}.<key>`, cloneSandboxCollections, depth + 1),
+        copyToSandbox(entry, state, `${path190}.<value>`, cloneSandboxCollections, depth + 1)
       );
     }
     return copy;
@@ -140051,7 +140141,7 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const entry of value) {
       copy.values.add(
-        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
+        copyToSandbox(entry, state, `${path190}.<value>`, cloneSandboxCollections, depth + 1)
       );
     }
     return copy;
@@ -140063,14 +140153,14 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path189)) {
+    for (const entry of getEnumerableArrayEntries(value, path190)) {
       defineOwnDataProperty(
         copy,
         entry.key,
         copyToSandbox(
           entry.value,
           state,
-          joinArrayPath(path189, entry.key),
+          joinArrayPath(path190, entry.key),
           cloneSandboxCollections,
           depth + 1
         )
@@ -140086,7 +140176,7 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     copySandboxArgumentProperties(
       value,
       copy,
-      (entry, key3) => copyToSandbox(entry, state, joinPath(path189, key3), cloneSandboxCollections, depth + 1)
+      (entry, key3) => copyToSandbox(entry, state, joinPath(path190, key3), cloneSandboxCollections, depth + 1)
     );
     return copy;
   }
@@ -140099,14 +140189,14 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     const errorType = sandboxErrorTypes.get(value);
     if (errorType !== void 0) sandboxErrorTypes.set(copy, errorType);
-    for (const entry of getEnumerableObjectEntries(value, path189)) {
+    for (const entry of getEnumerableObjectEntries(value, path190)) {
       defineOwnDataProperty(
         copy,
         entry.key,
         copyToSandbox(
           entry.value,
           state,
-          joinPath(path189, entry.key),
+          joinPath(path190, entry.key),
           cloneSandboxCollections,
           depth + 1
         )
@@ -140114,9 +140204,9 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue(value)}`);
 }
-function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
+function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
   assertSandboxDataDepth(depth);
   if (isSandboxPrimitive(value)) {
     return value;
@@ -140161,8 +140251,8 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     state.seen.set(value, copy);
     for (const [key3, entry] of value.entries) {
       copy.set(
-        copyFromSandbox(key3, state, `${path189}.<key>`, options, depth + 1),
-        copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1)
+        copyFromSandbox(key3, state, `${path190}.<key>`, options, depth + 1),
+        copyFromSandbox(entry, state, `${path190}.<value>`, options, depth + 1)
       );
     }
     return copy;
@@ -140175,7 +140265,7 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     const copy = /* @__PURE__ */ new Set();
     state.seen.set(value, copy);
     for (const entry of value.values) {
-      copy.add(copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1));
+      copy.add(copyFromSandbox(entry, state, `${path190}.<value>`, options, depth + 1));
     }
     return copy;
   }
@@ -140186,11 +140276,11 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path189)) {
+    for (const entry of getEnumerableArrayEntries(value, path190)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinArrayPath(path189, entry.key), options, depth + 1)
+        copyFromSandbox(entry.value, state, joinArrayPath(path190, entry.key), options, depth + 1)
       );
     }
     return copy;
@@ -140203,7 +140293,7 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     copySandboxArgumentProperties(
       value,
       copy,
-      (entry, key3) => copyFromSandbox(entry, state, joinPath(path189, key3), options, depth + 1)
+      (entry, key3) => copyFromSandbox(entry, state, joinPath(path190, key3), options, depth + 1)
     );
     return copy;
   }
@@ -140214,16 +140304,16 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     }
     const copy = createPlainObject(Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path189)) {
+    for (const entry of getEnumerableObjectEntries(value, path190)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinPath(path189, entry.key), options, depth + 1)
+        copyFromSandbox(entry.value, state, joinPath(path190, entry.key), options, depth + 1)
       );
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue(value)}`);
 }
 function isSandboxPrimitive(value) {
   return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -140303,7 +140393,7 @@ function defineOwnDataProperty(target, key3, value) {
     value
   });
 }
-function getEnumerableObjectEntries(value, path189) {
+function getEnumerableObjectEntries(value, path190) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key3, descriptor] of Object.entries(descriptors)) {
@@ -140311,7 +140401,7 @@ function getEnumerableObjectEntries(value, path189) {
       continue;
     }
     if ("get" in descriptor || "set" in descriptor) {
-      throw new TypeError(`Unsupported sandbox value at ${joinPath(path189, key3)}: accessor property`);
+      throw new TypeError(`Unsupported sandbox value at ${joinPath(path190, key3)}: accessor property`);
     }
     entries.push({
       key: key3,
@@ -140320,7 +140410,7 @@ function getEnumerableObjectEntries(value, path189) {
   }
   return entries;
 }
-function getEnumerableArrayEntries(value, path189) {
+function getEnumerableArrayEntries(value, path190) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key3, descriptor] of Object.entries(descriptors)) {
@@ -140329,7 +140419,7 @@ function getEnumerableArrayEntries(value, path189) {
     }
     if ("get" in descriptor || "set" in descriptor) {
       throw new TypeError(
-        `Unsupported sandbox value at ${joinArrayPath(path189, key3)}: accessor property`
+        `Unsupported sandbox value at ${joinArrayPath(path190, key3)}: accessor property`
       );
     }
     entries.push({
@@ -140358,11 +140448,11 @@ function describeValue(value) {
   }
   return typeof value;
 }
-function joinPath(path189, key3) {
-  return path189 === "<root>" ? `<root>.${key3}` : `${path189}.${key3}`;
+function joinPath(path190, key3) {
+  return path190 === "<root>" ? `<root>.${key3}` : `${path190}.${key3}`;
 }
-function joinArrayPath(path189, key3) {
-  return isArrayIndexKey(key3) ? `${path189}[${key3}]` : joinPath(path189, key3);
+function joinArrayPath(path190, key3) {
+  return isArrayIndexKey(key3) ? `${path190}[${key3}]` : joinPath(path190, key3);
 }
 var sandboxClosureBrand, sandboxGeneratorBrand, sandboxMapBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxSetBrand, sandboxRetainedValues;
 var init_values = __esm({
@@ -141164,18 +141254,25 @@ function readHostOperationPolicy(operation) {
   return hostOperationPolicies.get(operation);
 }
 function wrapCallerInjectedBindings(bindings, options) {
+  options = { ...options, registerCapabilities: true };
   const state = { seen: /* @__PURE__ */ new WeakMap() };
   const copied = Object.fromEntries(
     Object.entries(bindings).map(([name, value]) => [
       name,
-      typeof value === "function" ? wrapCallerInjectedFunction(name, value, options, state) : copyHostValueToSandbox(value, [], { ...options, operation: name }, state, "<root>")
+      typeof value === "function" ? wrapCallerInjectedFunction(name, value, { ...options, capabilityPath: [name] }, state) : copyHostValueToSandbox(
+        value,
+        [],
+        { ...options, operation: name, capabilityPath: [name] },
+        state,
+        "<root>"
+      )
     ])
   );
   options.budget.provisionDataUsage(measureSandboxData(Object.values(copied)));
   return copied;
 }
 function wrapCallerInjectedFunction(name, value, options, state) {
-  const existing = state.seen.get(value);
+  const existing = state.seen.get(value) ?? options.hostCalls?.nativeClosures.get(value);
   if (existing !== void 0) return existing;
   const bindingName = name === "default" && value.name.length > 0 ? value.name : name;
   const callable = value;
@@ -141290,6 +141387,16 @@ function wrapCallerInjectedFunction(name, value, options, state) {
     name: bindingName,
     properties: (closure) => {
       state.seen.set(value, closure);
+      if (options.registerCapabilities) {
+        options.hostCalls?.registerHostCapability(
+          JSON.stringify([
+            options.moduleId ?? "<bindings>",
+            ...options.capabilityPath ?? [bindingName]
+          ]),
+          closure,
+          value
+        );
+      }
       return copyFunctionProperties(callable, [], options, state, options.operation ?? bindingName) ?? {};
     }
   });
@@ -141460,7 +141567,7 @@ function copyHostResultToSandbox(result, stackFrames, options) {
   const value = copyHostValueToSandbox(
     result,
     stackFrames,
-    options,
+    { ...options, registerCapabilities: false },
     {
       seen: /* @__PURE__ */ new WeakMap()
     },
@@ -141673,7 +141780,7 @@ function wrapHostPromiseWithSignal(promise, signal) {
     );
   });
 }
-function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
+function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
   const { budget } = options;
   if (value === null || value === void 0 || typeof value === "number" || typeof value === "boolean") {
     return value;
@@ -141699,11 +141806,11 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
       return existing;
     }
     return wrapCallerInjectedFunction(
-      callable.name.length > 0 ? callable.name : readPathName(path189),
+      callable.name.length > 0 ? callable.name : readPathName(path190),
       callable,
       {
         ...options,
-        operation: path189.startsWith("<root>") ? `${options.operation ?? "<root>"}${path189.slice(6)}` : path189
+        operation: path190.startsWith("<root>") ? `${options.operation ?? "<root>"}${path190.slice(6)}` : path190
       },
       state
     );
@@ -141755,14 +141862,14 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
       const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
       if (descriptor === void 0) continue;
       if (!("value" in descriptor)) {
-        throw new TypeError(`Unsupported sandbox value at ${path189}[${index}]: accessor property`);
+        throw new TypeError(`Unsupported sandbox value at ${path190}[${index}]: accessor property`);
       }
       copy[index] = copyHostValueToSandbox(
         descriptor.value,
         stackFrames,
-        options,
+        { ...options, capabilityPath: [...options.capabilityPath ?? [], String(index)] },
         state,
-        `${path189}[${index}]`
+        `${path190}[${index}]`
       );
     }
     return copy;
@@ -141776,9 +141883,22 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
     state.seen.set(value, copy);
     budget.allocateCollectionEntries(value.size);
     for (const [key3, entry] of value) {
+      const ordinal = copy.entries.size;
       copy.entries.set(
-        copyHostValueToSandbox(key3, stackFrames, options, state, `${path189}.<key>`),
-        copyHostValueToSandbox(entry, stackFrames, options, state, `${path189}.<value>`)
+        copyHostValueToSandbox(
+          key3,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], `key:${ordinal}`] },
+          state,
+          `${path190}.<key>`
+        ),
+        copyHostValueToSandbox(
+          entry,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], `value:${ordinal}`] },
+          state,
+          `${path190}.<value>`
+        )
       );
     }
     return copy;
@@ -141793,7 +141913,16 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
     budget.allocateCollectionEntries(value.size);
     for (const entry of value) {
       copy.values.add(
-        copyHostValueToSandbox(entry, stackFrames, options, state, `${path189}.<value>`)
+        copyHostValueToSandbox(
+          entry,
+          stackFrames,
+          {
+            ...options,
+            capabilityPath: [...options.capabilityPath ?? [], String(copy.values.size)]
+          },
+          state,
+          `${path190}.<value>`
+        )
       );
     }
     return copy;
@@ -141811,7 +141940,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
       }
       if ("get" in descriptor || "set" in descriptor) {
         throw new TypeError(
-          `Unsupported sandbox value at ${joinPath2(path189, key3)}: accessor property`
+          `Unsupported sandbox value at ${joinPath2(path190, key3)}: accessor property`
         );
       }
       Object.defineProperty(copy, budget.allocateString(key3), {
@@ -141821,15 +141950,15 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path189) {
         value: copyHostValueToSandbox(
           descriptor.value,
           stackFrames,
-          options,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
           state,
-          joinPath2(path189, key3)
+          joinPath2(path190, key3)
         )
       });
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue2(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue2(value)}`);
 }
 function readAbortReason2(signal) {
   return signal.reason ?? createAbortError11();
@@ -141878,7 +142007,7 @@ function readStringProperty(value, key3) {
   const entry = value[key3];
   return typeof entry === "string" ? entry : void 0;
 }
-function copyFunctionProperties(callable, stackFrames, options, state, path189) {
+function copyFunctionProperties(callable, stackFrames, options, state, path190) {
   const properties = {};
   for (const key3 of Object.getOwnPropertyNames(callable)) {
     const descriptor = Object.getOwnPropertyDescriptor(callable, key3);
@@ -141894,9 +142023,9 @@ function copyFunctionProperties(callable, stackFrames, options, state, path189)
     properties[key3] = copyHostValueToSandbox(
       descriptor.value,
       stackFrames,
-      options,
+      { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
       state,
-      joinPath2(path189, key3)
+      joinPath2(path190, key3)
     );
   }
   return Object.keys(properties).length > 0 ? properties : void 0;
@@ -141908,11 +142037,11 @@ function isPlainObject11(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function joinPath2(path189, key3) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key3) ? `${path189}.${key3}` : `${path189}[${JSON.stringify(key3)}]`;
+function joinPath2(path190, key3) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key3) ? `${path190}.${key3}` : `${path190}[${JSON.stringify(key3)}]`;
 }
-function readPathName(path189) {
-  const segment = path189.replace(/^.*\./u, "");
+function readPathName(path190) {
+  const segment = path190.replace(/^.*\./u, "");
   return segment === "<root>" ? "host" : segment;
 }
 function describeValue2(value) {
@@ -147430,16 +147559,16 @@ async function writeSnapshotOnce(temporaryPath, snapshotPath, contents) {
     }
   }
 }
-async function enqueueOperation(path189, operation) {
-  const previous = pendingOperations.get(path189) ?? Promise.resolve();
+async function enqueueOperation(path190, operation) {
+  const previous = pendingOperations.get(path190) ?? Promise.resolve();
   const pending = previous.catch(() => void 0).then(operation);
   const queued = pending.catch(() => void 0);
-  pendingOperations.set(path189, queued);
+  pendingOperations.set(path190, queued);
   try {
     await pending;
   } finally {
-    if (pendingOperations.get(path189) === queued) {
-      pendingOperations.delete(path189);
+    if (pendingOperations.get(path190) === queued) {
+      pendingOperations.delete(path190);
     }
   }
 }
@@ -147476,8 +147605,8 @@ var init_backend = __esm({
     LOCKED_FILE_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
     pendingOperations = /* @__PURE__ */ new Map();
     FileSnapshotBackend = class {
-      constructor(path189, options = {}) {
-        this.path = path189;
+      constructor(path190, options = {}) {
+        this.path = path190;
         this.#writeMaxAttempts = options.writeMaxAttempts ?? DEFAULT_WRITE_MAX_ATTEMPTS;
         this.#writeRetryDelayMs = options.writeRetryDelayMs ?? DEFAULT_WRITE_RETRY_DELAY_MS;
       }
@@ -147625,34 +147754,34 @@ var init_serialize = __esm({
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
-      constructor(path189) {
+      constructor(path190) {
         super(
           "Cannot snapshot a generator suspended mid-iteration; drain or discard it before the await boundary."
         );
         this.name = "UnsnapshotableValueError";
-        this.path = path189;
+        this.path = path190;
       }
     };
   }
 });
 
 // packages/safejs/src/snapshot/replay-inputs.ts
-function prepareReplayInputs(current, saved, preparePromise) {
+function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestored) {
   const identities = /* @__PURE__ */ new WeakMap();
   const capabilities = /* @__PURE__ */ new Map();
   const promises = /* @__PURE__ */ new Map();
   if (saved === void 0) {
     const snapshot2 = encodeReplayData(current, {
       captureCapabilityProperties: true,
-      identifyCapability: (closure, path189) => {
-        const id = identities.get(closure) ?? JSON.stringify(path189);
+      identifyCapability: (closure, path190) => {
+        const id = identities.get(closure) ?? JSON.stringify(path190);
         identities.set(closure, id);
         capabilities.set(id, closure);
         return id;
       },
-      identifyPromise: (promise, path189) => {
+      identifyPromise: (promise, path190) => {
         if (preparePromise === void 0) return void 0;
-        const id = identities.get(promise) ?? JSON.stringify(path189);
+        const id = identities.get(promise) ?? JSON.stringify(path190);
         identities.set(promise, id);
         if (!promises.has(id)) promises.set(id, preparePromise(promise, id));
         return id;
@@ -147667,11 +147796,11 @@ function prepareReplayInputs(current, saved, preparePromise) {
     };
   }
   const readCapability = (id) => {
-    const path189 = JSON.parse(id);
-    if (!Array.isArray(path189) || path189.length === 0 || path189.some((key3) => typeof key3 !== "string"))
+    const path190 = JSON.parse(id);
+    if (!Array.isArray(path190) || path190.length === 0 || path190.some((key3) => typeof key3 !== "string"))
       throw new TypeError("Invalid replay input capability path.");
     let value = current;
-    for (const key3 of path189) {
+    for (const key3 of path190) {
       if (isSandboxMap(value)) {
         const [kind, ordinal] = key3.split(":");
         const index = Number(ordinal);
@@ -147708,6 +147837,7 @@ function prepareReplayInputs(current, saved, preparePromise) {
   assertReplayInputShape(validated);
   const restored = decodeReplayData(saved, {
     resolveCapability,
+    onCapabilityRestored,
     resolvePromise: (id) => {
       const value = readCapability(id);
       if (!promises.has(id) && preparePromise !== void 0)
@@ -147743,7 +147873,7 @@ function run(source, options = {}) {
   const lifecycle = { hostCallbackDepth: 0 };
   const dumpController = createDumpController(lifecycle);
   const promiseTracker = createSandboxPromiseRejectionTracker();
-  const result = withSandboxPromiseRejectionTracker(promiseTracker, async () => {
+  const execute2 = async () => {
     const promiseReplay = new PromiseReplay(options.snapshot?.promiseReplay);
     return promiseReplayContext.run(promiseReplay, async () => {
       const deactivateOtelSink = activateOtelSink(options.otelSink);
@@ -147843,8 +147973,10 @@ function run(source, options = {}) {
             if (!isSandboxClosure(binding))
               throw new TypeError("Invalid initial promise operation.");
             return binding.call([]);
-          }
+          },
+          hostCalls.rebindHostCapability.bind(hostCalls)
         );
+        hostCalls.validateHostCapabilities();
         budget.setRetainedDataUsage(
           initialInputs,
           measureSandboxData(
@@ -148023,7 +148155,11 @@ function run(source, options = {}) {
         deactivateOtelSink();
       }
     });
-  });
+  };
+  const result = withRunResources(
+    options.signal,
+    () => withSandboxPromiseRejectionTracker(promiseTracker, execute2)
+  );
   return attachDumpController(result, dumpController);
 }
 async function throwIfReturnedPromiseRejected(result) {
@@ -148201,6 +148337,7 @@ var init_run7 = __esm({
   "packages/safejs/src/run.ts"() {
     "use strict";
     init_hash();
+    init_resources();
     init_random();
     init_shape();
     init_parser3();
@@ -148399,7 +148536,7 @@ var init_find_exported = __esm({
 });
 
 // packages/safejs/src/modules/agent.ts
-import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
 function createSpawnUsageAccumulator() {
   let inputTokens = 0;
   let outputTokens = 0;
@@ -149302,7 +149439,7 @@ var init_agent3 = __esm({
         hostErrorData.set(this, { result });
       }
     };
-    activeUsageAccumulator = new AsyncLocalStorage7();
+    activeUsageAccumulator = new AsyncLocalStorage8();
     oneAttemptRetryOptions = {
       maxAttempts: 1,
       backoffMs: 0,
@@ -149352,9 +149489,9 @@ var init_fail = __esm({
 
 // packages/safejs/src/modules/canonical-path.ts
 import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute9, relative as relative7, resolve as resolve13, sep as sep6 } from "node:path";
-async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5 }, path189) {
+async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5 }, path190) {
   const missingSegments = [];
-  let current = path189;
+  let current = path190;
   let follows = 0;
   while (true) {
     try {
@@ -149367,23 +149504,23 @@ async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5
       const target = await readSymlinkTarget2(readlink5, current);
       if (target !== void 0) {
         if (++follows > MAX_SYMLINK_FOLLOWS) {
-          throw createLoopError(path189);
+          throw createLoopError(path190);
         }
         current = isAbsolute9(target) ? resolve13(target) : resolve13(dirname13(current), target);
         continue;
       }
       const parent = dirname13(current);
       if (parent === current) {
-        return resolve13(path189);
+        return resolve13(path190);
       }
       missingSegments.push(basename8(current));
       current = parent;
     }
   }
 }
-async function readSymlinkTarget2(readlink5, path189) {
+async function readSymlinkTarget2(readlink5, path190) {
   try {
-    return await readlink5(path189);
+    return await readlink5(path190);
   } catch (error3) {
     if (NOT_A_SYMLINK_CODES.includes(getOwnErrorCode2(error3) ?? "")) {
       return void 0;
@@ -149391,9 +149528,9 @@ async function readSymlinkTarget2(readlink5, path189) {
     throw error3;
   }
 }
-function createLoopError(path189) {
+function createLoopError(path190) {
   const error3 = new Error(
-    `ELOOP: too many symbolic links encountered, realpath '${path189}'`
+    `ELOOP: too many symbolic links encountered, realpath '${path190}'`
   );
   error3.code = "ELOOP";
   return error3;
@@ -149436,9 +149573,9 @@ async function descendsFromRoot(stat36, canonicalRoot, canonicalPath) {
     current = parent;
   }
 }
-async function readIdentity(stat36, path189) {
+async function readIdentity(stat36, path190) {
   try {
-    const { dev, ino } = await stat36(path189);
+    const { dev, ino } = await stat36(path190);
     return { dev, ino };
   } catch (error3) {
     if (MISSING_PATH_CODES.includes(getOwnErrorCode2(error3) ?? "")) {
@@ -149586,32 +149723,32 @@ async function resolvePathArguments(fs31, root, name, args) {
     return resolved;
   }
   const paths = FS_PATH_ARGUMENTS[name].map((_, index) => {
-    const path189 = readPath(canonicalRoot, args[index]);
-    resolved[index] = path189;
-    return path189;
+    const path190 = readPath(canonicalRoot, args[index]);
+    resolved[index] = path190;
+    return path190;
   });
   await assertInsideRoot2(fs31, canonicalRoot, name, paths);
   return resolved;
 }
 async function assertInsideRoot2(fs31, canonicalRoot, name, paths) {
-  for (const path189 of paths) {
-    if (await escapesRoot(fs31, canonicalRoot, path189)) {
+  for (const path190 of paths) {
+    if (await escapesRoot(fs31, canonicalRoot, path190)) {
       throw createAccessDeniedError(name, paths[0], paths[1]);
     }
   }
 }
-async function escapesRoot(fs31, canonicalRoot, path189) {
-  const canonicalPath = await resolveCanonicalPath(readCanonicalPathFs(fs31), path189);
+async function escapesRoot(fs31, canonicalRoot, path190) {
+  const canonicalPath = await resolveCanonicalPath(readCanonicalPathFs(fs31), path190);
   return !await containsPath(readStat(fs31), canonicalRoot, canonicalPath);
 }
 function readCanonicalPathFs(fs31) {
   return {
-    realpath: async (path189) => await invoke(fs31, "realpath", [path189]),
-    readlink: async (path189) => await invoke(fs31, "readlink", [path189])
+    realpath: async (path190) => await invoke(fs31, "realpath", [path190]),
+    readlink: async (path190) => await invoke(fs31, "readlink", [path190])
   };
 }
 function readStat(fs31) {
-  return async (path189) => await invoke(fs31, "stat", [path189]);
+  return async (path190) => await invoke(fs31, "stat", [path190]);
 }
 function assertSupportedPath(name, argument, value) {
   if (typeof value === "string") {
@@ -149662,19 +149799,19 @@ function describeReceivedValue(value) {
   return `type ${typeof value} (${inspect(value)})`;
 }
 function readPath(base, value) {
-  const path189 = value;
-  return isAbsolute10(path189) ? resolve14(path189) : resolve14(base, path189);
+  const path190 = value;
+  return isAbsolute10(path190) ? resolve14(path190) : resolve14(base, path190);
 }
-function createAccessDeniedError(name, path189, dest) {
+function createAccessDeniedError(name, path190, dest) {
   const syscall = FS_SYSCALLS[name];
-  const target = dest === void 0 ? `'${path189}'` : `'${path189}' -> '${dest}'`;
+  const target = dest === void 0 ? `'${path190}'` : `'${path190}' -> '${dest}'`;
   const error3 = new Error(
     `${ACCESS_DENIED_CODE}: ${ACCESS_DENIED_MESSAGE}, ${syscall} ${target}`
   );
   error3.code = ACCESS_DENIED_CODE;
   error3.errno = ACCESS_DENIED_ERRNO;
   error3.syscall = syscall;
-  error3.path = path189;
+  error3.path = path190;
   if (dest !== void 0) {
     error3.dest = dest;
   }
@@ -150032,9 +150169,9 @@ function makeGitModule(cwd) {
         branch: normalizedBranch
       };
     },
-    async worktreeRemove(path189) {
+    async worktreeRemove(path190) {
       const repoRoot = await getRepoRoot(normalizedCwd);
-      const worktreePath = await resolveWorktreePath(repoRoot, path189, "Git worktree path");
+      const worktreePath = await resolveWorktreePath(repoRoot, path190, "Git worktree path");
       const worktrees = await listWorktrees2(normalizedCwd);
       if (!worktrees.some((worktree) => resolve15(worktree.path) === worktreePath)) {
         return;
@@ -150081,10 +150218,10 @@ function normalizeWorktreeCreateOptions(options) {
     throw new Error("Git worktree create options must be an object.");
   }
   const base = getOwnProperty8(options, "base");
-  const path189 = getOwnProperty8(options, "path");
+  const path190 = getOwnProperty8(options, "path");
   return {
     base: base === void 0 ? "HEAD" : readNonEmptyString6(base, "Git worktree create options base"),
-    path: path189 === void 0 ? void 0 : readNonEmptyString6(path189, "Git worktree create options path")
+    path: path190 === void 0 ? void 0 : readNonEmptyString6(path190, "Git worktree create options path")
   };
 }
 function createSavepointRef() {
@@ -150144,9 +150281,9 @@ function parseBranchRef(ref) {
   const branchPrefix = "refs/heads/";
   return ref.startsWith(branchPrefix) ? ref.slice(branchPrefix.length) : ref;
 }
-async function resolveWorktreePath(repoRoot, path189, label) {
+async function resolveWorktreePath(repoRoot, path190, label) {
   const resolvedRoot = resolve15(repoRoot);
-  const resolvedPath = isAbsolute11(path189) ? resolve15(path189) : resolve15(resolvedRoot, path189);
+  const resolvedPath = isAbsolute11(path190) ? resolve15(path190) : resolve15(resolvedRoot, path190);
   const canonicalRoot = await realpath19(resolvedRoot);
   const canonicalPath = await resolveCanonicalPath({ realpath: realpath19, readlink: readlink4 }, resolvedPath);
   const [inside, isRootItself] = await Promise.all([
@@ -150512,10 +150649,650 @@ var init_metric = __esm({
   }
 });
 
+// packages/safejs/src/modules/mcp-transport.ts
+import { spawn as spawn11 } from "node:child_process";
+import path184 from "node:path";
+function parseMcpConfig3(source, directory) {
+  const parsed = JSON.parse(source);
+  const options = normalizeMcpOptions(parsed, [
+    "servers",
+    "requestTimeoutMs",
+    "closeTimeoutMs",
+    "maxToolPages"
+  ]);
+  for (const server of Object.values(options.servers)) {
+    if ("command" in server) {
+      server.cwd = path184.resolve(directory, server.cwd ?? ".");
+      if (server.command.includes("/") || server.command.includes("\\")) {
+        server.command = path184.resolve(directory, server.command);
+      }
+    }
+  }
+  return options;
+}
+function normalizeMcpOptions(value, keys = [
+  "servers",
+  "requestTimeoutMs",
+  "closeTimeoutMs",
+  "maxToolPages",
+  "signal",
+  "fetch",
+  "spawn"
+]) {
+  const options = readRecord2(value, "MCP options", keys);
+  const servers = readRecord2(options.servers, "MCP servers");
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [name, input] of Object.entries(servers)) {
+    if (name.length === 0 || name.trim() !== name)
+      throw new TypeError("MCP server names must be non-empty without surrounding whitespace.");
+    const server = readRecord2(input, `MCP server ${name}`);
+    if (Object.hasOwn(server, "command")) {
+      readRecord2(server, `MCP server ${name}`, ["command", "args", "cwd", "env"]);
+      const command = readText(server.command, "MCP command");
+      if (server.args !== void 0 && (!Array.isArray(server.args) || server.args.some((argument) => typeof argument !== "string")))
+        throw new TypeError("MCP args must be an array of strings.");
+      normalized[name] = {
+        command,
+        ...server.args === void 0 ? {} : { args: [...server.args] },
+        ...server.cwd === void 0 ? {} : { cwd: readText(server.cwd, "MCP cwd") },
+        env: readStrings(server.env ?? {}, "MCP environment")
+      };
+    } else {
+      readRecord2(server, `MCP server ${name}`, ["url", "headers"]);
+      const url = new URL(readText(server.url, "MCP URL"));
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
+        throw new TypeError("MCP URL must use HTTP or HTTPS without credentials or a fragment.");
+      const headers = readStrings(server.headers ?? {}, "MCP headers");
+      new Headers(headers);
+      normalized[name] = { url: url.href, headers };
+    }
+  }
+  for (const name of ["fetch", "spawn"])
+    if (options[name] !== void 0 && typeof options[name] !== "function")
+      throw new TypeError(`MCP ${name} must be a function.`);
+  if (options.signal !== void 0 && !(options.signal instanceof AbortSignal))
+    throw new TypeError("MCP signal must be an AbortSignal.");
+  return {
+    servers: normalized,
+    requestTimeoutMs: readTimeout(options.requestTimeoutMs, 3e4),
+    closeTimeoutMs: readTimeout(options.closeTimeoutMs, 1e3),
+    maxToolPages: readTimeout(options.maxToolPages, 100),
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+    ...options.spawn === void 0 ? {} : { spawn: options.spawn }
+  };
+}
+function readRecord2(value, label, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new TypeError(`${label} must be a plain object.`);
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!("value" in descriptor) || keys !== void 0 && !keys.includes(key3))
+      throw new TypeError(`${label} contains unsupported field ${key3}.`);
+    result[key3] = descriptor.value;
+  }
+  return result;
+}
+function readText(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0"))
+    throw new TypeError(`${label} must be a non-empty string without NUL characters.`);
+  return value;
+}
+function readStrings(value, label) {
+  const entries = readRecord2(value, label);
+  for (const [name, entry] of Object.entries(entries))
+    if (typeof entry !== "string" || name.includes("\0") || entry.includes("\0"))
+      throw new TypeError(`${label} must contain strings without NUL characters.`);
+  return entries;
+}
+function readTimeout(value, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > 2147483647)
+    throw new TypeError("MCP timeouts must be positive 32-bit integers.");
+  return value;
+}
+function connectMcpTransport(server, options, signal) {
+  signal?.throwIfAborted();
+  options.signal?.throwIfAborted();
+  const client = new McpClient({
+    clientInfo: { name: "safejs", version: "1" },
+    requestTimeoutMs: options.requestTimeoutMs
+  });
+  let child;
+  const activeRequests = /* @__PURE__ */ new Set();
+  const transport = "command" in server ? new StdioTransport({
+    ...server,
+    spawn(command, args, spawnOptions) {
+      child = options.spawn === void 0 ? spawn11(command, args, spawnOptions) : options.spawn(command, args, spawnOptions);
+      return child;
+    }
+  }) : new HttpTransport({
+    ...server,
+    async fetch(input, init) {
+      const controller = new AbortController();
+      activeRequests.add(controller);
+      const cancel3 = () => controller.abort(init?.signal?.reason);
+      init?.signal?.addEventListener("abort", cancel3, { once: true });
+      if (init?.signal?.aborted) cancel3();
+      const timeout = setTimeout(
+        () => controller.abort(new Error("MCP HTTP request timed out.")),
+        init?.method === "DELETE" ? options.closeTimeoutMs : options.requestTimeoutMs
+      );
+      const finish = () => {
+        clearTimeout(timeout);
+        activeRequests.delete(controller);
+        init?.signal?.removeEventListener("abort", cancel3);
+      };
+      try {
+        const response = await (options.fetch ?? fetch)(input, {
+          ...init,
+          signal: controller.signal,
+          redirect: "error"
+        });
+        if (response.body === null) {
+          finish();
+          return response;
+        }
+        const reader = response.body.getReader();
+        let stopReading;
+        const release2 = () => {
+          finish();
+          if (stopReading !== void 0)
+            controller.signal.removeEventListener("abort", stopReading);
+        };
+        const body = new ReadableStream({
+          start(stream) {
+            stopReading = () => {
+              void reader.cancel(controller.signal.reason).catch(() => void 0);
+              stream.error(controller.signal.reason);
+              release2();
+            };
+            controller.signal.addEventListener("abort", stopReading, { once: true });
+            if (controller.signal.aborted) stopReading();
+          },
+          async pull(stream) {
+            try {
+              const result = await reader.read();
+              if (controller.signal.aborted) return;
+              if (result.done) {
+                release2();
+                stream.close();
+              } else stream.enqueue(result.value);
+            } catch (error3) {
+              release2();
+              stream.error(error3);
+            }
+          },
+          async cancel(reason) {
+            release2();
+            await reader.cancel(reason);
+          }
+        });
+        return new Response(body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      } catch (error3) {
+        finish();
+        throw error3;
+      }
+    }
+  });
+  let closing;
+  const cancel2 = () => {
+    void close().catch(() => void 0);
+  };
+  function close() {
+    closing ??= (async () => {
+      signal?.removeEventListener("abort", cancel2);
+      options.signal?.removeEventListener("abort", cancel2);
+      for (const request of activeRequests) request.abort(new Error("MCP connection closed."));
+      await client.close();
+      transport.dispose();
+      await new Promise((resolve17, reject) => {
+        let forced;
+        const timeout = setTimeout(() => {
+          if (child !== void 0 && child.exitCode === null && child.signalCode === null)
+            child.kill("SIGKILL");
+          forced = setTimeout(
+            () => reject(new Error("MCP transport did not close.")),
+            options.closeTimeoutMs
+          );
+        }, options.closeTimeoutMs);
+        void transport.closed.then(
+          () => {
+            clearTimeout(timeout);
+            clearTimeout(forced);
+            resolve17();
+          },
+          (error3) => {
+            clearTimeout(timeout);
+            clearTimeout(forced);
+            reject(error3);
+          }
+        );
+      });
+    })();
+    return closing;
+  }
+  signal?.addEventListener("abort", cancel2, { once: true });
+  options.signal?.addEventListener("abort", cancel2, { once: true });
+  const aborted = signal?.aborted || options.signal?.aborted;
+  if (aborted) cancel2();
+  const connecting = aborted ? Promise.reject(signal?.aborted ? signal.reason : options.signal?.reason) : client.connect(transport);
+  const ready = connecting.then(
+    () => client,
+    async (error3) => {
+      await close().catch(() => void 0);
+      throw signal?.aborted ? signal.reason : options.signal?.aborted ? options.signal.reason : error3;
+    }
+  );
+  return { ready, close };
+}
+var init_mcp_transport = __esm({
+  "packages/safejs/src/modules/mcp-transport.ts"() {
+    "use strict";
+    init_src19();
+  }
+});
+
 // packages/safejs/src/modules/mcp.ts
+function makeMcpModule(connectMcp) {
+  if (typeof connectMcp !== "function") {
+    const options = normalizeMcpOptions(connectMcp);
+    const servers = /* @__PURE__ */ Object.create(null);
+    for (const [name, config2] of Object.entries(options.servers)) {
+      const connections = /* @__PURE__ */ new WeakMap();
+      const directScope = {};
+      const connection = () => {
+        const scope = runResources.getStore();
+        scope?.signal.throwIfAborted();
+        options.signal?.throwIfAborted();
+        const owner = scope ?? directScope;
+        let current = connections.get(owner);
+        if (current === void 0) {
+          current = connectMcpTransport(config2, options, scope?.signal);
+          connections.set(owner, current);
+          scope?.add(current.close);
+        }
+        return current.ready;
+      };
+      const invoke2 = async (operation) => {
+        try {
+          const result = await operation(await connection());
+          runResources.getStore()?.signal.throwIfAborted();
+          options.signal?.throwIfAborted();
+          return result;
+        } catch (error3) {
+          runResources.getStore()?.signal.throwIfAborted();
+          options.signal?.throwIfAborted();
+          if (error3 instanceof McpError) {
+            hostErrorData.set(error3, {
+              code: error3.code,
+              ...error3.data === void 0 ? {} : { data: error3.data }
+            });
+          }
+          throw error3;
+        }
+      };
+      servers[name] = {
+        tools: declareHostOperation(
+          async () => invoke2(async (client) => {
+            const tools = [];
+            const cursors = /* @__PURE__ */ new Set();
+            let pages = 0;
+            let cursor2;
+            do {
+              const result = await client.listTools(
+                cursor2 === void 0 ? void 0 : { cursor: cursor2 }
+              );
+              pages += 1;
+              tools.push(...normalizeToolsResult(result));
+              cursor2 = result.nextCursor;
+              if (cursor2 !== void 0) {
+                if (typeof cursor2 !== "string" || cursors.has(cursor2))
+                  throw new Error("MCP tools pagination did not advance.");
+                cursors.add(cursor2);
+                if (pages >= options.maxToolPages)
+                  throw new Error("MCP tools page limit exceeded.");
+              }
+            } while (cursor2 !== void 0);
+            return tools;
+          }),
+          "re-issue"
+        ),
+        tool: declareHostOperation(async (toolName, args) => {
+          const request = createNullRecord7({
+            name: readNonEmptyTrimmedString(toolName, "MCP tool name"),
+            ...args === void 0 ? {} : { arguments: readToolArguments(args) }
+          });
+          return invoke2((client) => client.callTool(request));
+        }, "read-side-effect"),
+        toolBatch: declareHostOperation(async (calls) => {
+          const normalized = readToolBatchCalls(calls);
+          if (normalized.length === 0) return [];
+          return invoke2((client) => executeToolBatch(client, normalized));
+        }, "read-side-effect"),
+        close: declareHostOperation(async () => {
+          const owner = runResources.getStore() ?? directScope;
+          const current = connections.get(owner);
+          if (current !== void 0) {
+            await current.close();
+            connections.delete(owner);
+          }
+        }, "re-issue")
+      };
+    }
+    const readName = (value) => {
+      const name = readNonEmptyString9(value, "MCP server name");
+      if (!Object.hasOwn(servers, name)) throw new Error(`MCP server '${name}' is not configured.`);
+      return name;
+    };
+    return {
+      servers,
+      server(name) {
+        return createNullRecord7({ name: readName(name) });
+      },
+      async client(handle) {
+        if (typeof handle === "string") return servers[readName(handle)];
+        if (!isRecord44(handle) || Object.keys(handle).length !== 1 || !Object.hasOwn(handle, "name"))
+          throw new TypeError("MCP client requires a named server handle.");
+        return servers[readName(getOwnProperty9(handle, "name"))];
+      }
+    };
+  }
+  return {
+    server(server) {
+      return normalizeServerHandle(server);
+    },
+    async client(handle) {
+      const connection = validateConnection(await connectMcp(normalizeServerHandle(handle)));
+      return {
+        async tools() {
+          return normalizeToolsResult(await connection.listTools());
+        },
+        async tool(name, args) {
+          return connection.callTool(
+            createNullRecord7({
+              name: readNonEmptyTrimmedString(name, "MCP tool name"),
+              ...args === void 0 ? {} : { arguments: readToolArguments(args) }
+            })
+          );
+        },
+        async toolBatch(calls) {
+          return executeToolBatch(connection, readToolBatchCalls(calls));
+        }
+      };
+    }
+  };
+}
+async function executeToolBatch(connection, calls) {
+  if (calls.length === 0) {
+    return [];
+  }
+  if (connection.callToolBatch !== void 0 && calls.every((call) => call.ok)) {
+    try {
+      return normalizeProtocolBatchResults(
+        await connection.callToolBatch(calls.map((call) => call.request)),
+        calls.length
+      );
+    } catch (error3) {
+      const batchError = normalizeToolBatchError(error3);
+      return calls.map(
+        () => createNullRecord7({
+          ok: false,
+          error: batchError
+        })
+      );
+    }
+  }
+  return executeToolBatchWithConcurrency(connection, calls, DEFAULT_TOOL_BATCH_CONCURRENCY);
+}
+async function executeToolBatchWithConcurrency(connection, calls, concurrency) {
+  const results = new Array(calls.length);
+  let nextIndex = 0;
+  let disconnectError;
+  const workerCount = Math.min(concurrency, calls.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < calls.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const call = calls[index];
+      if (call === void 0) {
+        continue;
+      }
+      if (!call.ok) {
+        results[index] = createNullRecord7({
+          ok: false,
+          error: call.error
+        });
+        continue;
+      }
+      if (disconnectError !== void 0) {
+        results[index] = createNullRecord7({
+          ok: false,
+          error: disconnectError
+        });
+        continue;
+      }
+      try {
+        results[index] = createNullRecord7({
+          ok: true,
+          value: await connection.callTool(call.request)
+        });
+      } catch (error3) {
+        const toolError = normalizeToolBatchError(error3);
+        results[index] = createNullRecord7({
+          ok: false,
+          error: toolError
+        });
+        if (isMcpDisconnectError(toolError)) {
+          disconnectError = toolError;
+        }
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function normalizeProtocolBatchResults(value, expectedLength) {
+  if (!Array.isArray(value) || value.length !== expectedLength) {
+    throw new Error(
+      "MCP callToolBatch() must resolve to a result array matching the input length."
+    );
+  }
+  return value.map((entry, index) => normalizeProtocolBatchResult(entry, index));
+}
+function normalizeProtocolBatchResult(value, index) {
+  if (!isRecord44(value)) {
+    throw new Error(`MCP callToolBatch()[${index}] must be a result envelope.`);
+  }
+  const ok = getOwnProperty9(value, "ok");
+  if (typeof ok !== "boolean") {
+    throw new Error(`MCP callToolBatch()[${index}] must be a result envelope.`);
+  }
+  if (ok === true) {
+    return createNullRecord7({
+      ok: true,
+      value: getOwnProperty9(value, "value")
+    });
+  }
+  return createNullRecord7({
+    ok: false,
+    error: normalizeToolBatchError(getOwnProperty9(value, "error"))
+  });
+}
+function normalizeServerHandle(value) {
+  if (!isRecord44(value)) {
+    throw new Error("MCP server must be an object.");
+  }
+  const command = getOwnProperty9(value, "command");
+  const args = getOwnProperty9(value, "args");
+  const env = getOwnProperty9(value, "env");
+  return createNullRecord7({
+    command: readNonEmptyTrimmedString(command, "MCP server command"),
+    ...args === void 0 ? {} : { args: readStringArray2(args, "MCP server args") },
+    ...env === void 0 ? {} : { env: readStringRecord2(env, "MCP server env") }
+  });
+}
+function validateConnection(value) {
+  if (!isRecord44(value) || typeof value.listTools !== "function" || typeof value.callTool !== "function") {
+    throw new Error("connectMcp must resolve to an object with listTools() and callTool().");
+  }
+  const callToolBatch = getOwnProperty9(value, "callToolBatch");
+  return createNullRecord7({
+    listTools: () => value.listTools(),
+    callTool: (params) => value.callTool(params),
+    ...typeof callToolBatch === "function" ? {
+      callToolBatch: (params) => callToolBatch(params)
+    } : {}
+  });
+}
+function normalizeToolsResult(value) {
+  const tools = isRecord44(value) ? getOwnProperty9(value, "tools") : void 0;
+  if (!Array.isArray(tools)) {
+    throw new Error("MCP listTools() must resolve to an object with a tools array.");
+  }
+  return tools.map((tool, index) => normalizeTool3(tool, index));
+}
+function normalizeTool3(value, index) {
+  if (!isRecord44(value)) {
+    throw new Error(`MCP tool[${index}] must be an object.`);
+  }
+  const description = getOwnProperty9(value, "description");
+  const inputSchema = getOwnProperty9(value, "inputSchema");
+  return createNullRecord7({
+    name: readNonEmptyString9(getOwnProperty9(value, "name"), `MCP tool[${index}] name`),
+    ...description === void 0 ? {} : { description: readOptionalString8(description, `MCP tool[${index}] description`) },
+    ...inputSchema === void 0 ? {} : { schema: inputSchema }
+  });
+}
+function readStringArray2(value, label) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  return [...value];
+}
+function readStringRecord2(value, label) {
+  if (!isRecord44(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const entries = Object.entries(value);
+  if (entries.some(([, entry]) => typeof entry !== "string")) {
+    throw new Error(`${label} must be a string record.`);
+  }
+  return createNullRecord7(Object.fromEntries(entries));
+}
+function readOptionalString8(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string.`);
+  }
+  return value;
+}
+function readNonEmptyString9(value, label) {
+  const text5 = readOptionalString8(value, label);
+  if (text5 === void 0 || text5.trim().length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return text5;
+}
+function readNonEmptyTrimmedString(value, label) {
+  return readNonEmptyString9(value, label).trim();
+}
+function readToolArguments(value) {
+  if (!isPlainObjectRecord(value)) {
+    throw new Error("MCP tool arguments must be an object.");
+  }
+  return createNullRecord7(Object.fromEntries(Object.entries(value)));
+}
+function readToolBatchCalls(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("MCP toolBatch calls must be an array.");
+  }
+  return value.map((entry, index) => normalizeToolBatchCall(entry, index));
+}
+function normalizeToolBatchCall(value, index) {
+  try {
+    if (!isRecord44(value)) {
+      throw new Error(`MCP toolBatch call[${index}] must be an object.`);
+    }
+    const args = getOwnProperty9(value, "args");
+    return createNullRecord7({
+      ok: true,
+      request: createNullRecord7({
+        name: readNonEmptyTrimmedString(
+          getOwnProperty9(value, "name"),
+          `MCP toolBatch call[${index}] name`
+        ),
+        ...args === void 0 ? {} : { arguments: readToolArguments(args) }
+      })
+    });
+  } catch (error3) {
+    return createNullRecord7({
+      ok: false,
+      error: normalizeToolBatchError(error3)
+    });
+  }
+}
+function normalizeToolBatchError(error3) {
+  if (error3 instanceof Error) {
+    return createNullRecord7({
+      name: error3.name.length === 0 ? "Error" : error3.name,
+      message: error3.message
+    });
+  }
+  if (isRecord44(error3)) {
+    const nameValue = getOwnProperty9(error3, "name");
+    const messageValue2 = getOwnProperty9(error3, "message");
+    const name = typeof nameValue === "string" && nameValue.trim().length > 0 ? nameValue : "Error";
+    const message2 = typeof messageValue2 === "string" ? messageValue2 : String(error3);
+    return createNullRecord7({
+      name,
+      message: message2
+    });
+  }
+  return createNullRecord7({
+    name: "Error",
+    message: error3 === void 0 ? "" : String(error3)
+  });
+}
+function isMcpDisconnectError(error3) {
+  const message2 = error3.message.toLowerCase();
+  return message2.includes("disconnected") || message2.includes("connection closed") || message2.includes("transport closed") || message2.includes("disposed") || message2.includes("eof");
+}
+function isRecord44(value) {
+  return typeof value === "object" && value !== null;
+}
+function getOwnProperty9(value, name) {
+  return hasOwnProperty18(value, name) ? value[name] : void 0;
+}
+function hasOwnProperty18(value, name) {
+  return Object.prototype.hasOwnProperty.call(value, name);
+}
+function createNullRecord7(value) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), value);
+}
+function isPlainObjectRecord(value) {
+  if (!isRecord44(value) || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var DEFAULT_TOOL_BATCH_CONCURRENCY;
 var init_mcp5 = __esm({
   "packages/safejs/src/modules/mcp.ts"() {
     "use strict";
+    init_src19();
+    init_shape();
+    init_host_bridge();
+    init_resources();
+    init_mcp_transport();
+    DEFAULT_TOOL_BATCH_CONCURRENCY = 4;
   }
 });
 
@@ -150629,6 +151406,7 @@ var init_src49 = __esm({
     init_log2();
     init_metric();
     init_mcp5();
+    init_mcp_transport();
     init_time();
   }
 });
@@ -150712,7 +151490,7 @@ function readVariableDeclaration(statement) {
   return void 0;
 }
 function readUnboundIdentifierName(error3) {
-  if (typeof error3 !== "object" || error3 === null || !hasOwnProperty18(error3, "code") || error3.code !== "UNBOUND_IDENTIFIER") {
+  if (typeof error3 !== "object" || error3 === null || !hasOwnProperty19(error3, "code") || error3.code !== "UNBOUND_IDENTIFIER") {
     return void 0;
   }
   const message2 = readErrorMessage4(error3);
@@ -150727,12 +151505,12 @@ function readErrorMessage4(error3) {
   if (error3 instanceof Error) {
     return error3.message;
   }
-  if (typeof error3 === "object" && error3 !== null && hasOwnProperty18(error3, "message") && typeof error3.message === "string") {
+  if (typeof error3 === "object" && error3 !== null && hasOwnProperty19(error3, "message") && typeof error3.message === "string") {
     return error3.message;
   }
   return String(error3);
 }
-function hasOwnProperty18(value, name) {
+function hasOwnProperty19(value, name) {
   return Object.prototype.hasOwnProperty.call(value, name);
 }
 var SCHEMA_EXTRACTION_BUDGET;
@@ -150754,7 +151532,7 @@ var init_extract_schema = __esm({
 // packages/agent-harness/src/codegen/emit-schemas.ts
 import { randomUUID as randomUUID51 } from "node:crypto";
 import * as nodeFs21 from "node:fs/promises";
-import path184 from "node:path";
+import path185 from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 var init_emit_schemas = __esm({
   "packages/agent-harness/src/codegen/emit-schemas.ts"() {
@@ -150812,23 +151590,23 @@ var init_pair = __esm({
     MissingPairError = class extends UserError {
       side;
       path;
-      constructor(side, path189) {
+      constructor(side, path190) {
         super(
-          `Missing harness ${side} file: ${path189}
+          `Missing harness ${side} file: ${path190}
 Run \`poe-code harness list\` to see available harnesses, or \`poe-code harness new <name>\` to scaffold this pair.`
         );
         this.side = side;
-        this.path = path189;
+        this.path = path190;
       }
     };
     InvalidPairExtensionError = class extends Error {
       extension;
       path;
-      constructor(path189, extension) {
-        super(`Harness pair input must be a .md or .ajs file: ${path189}`);
+      constructor(path190, extension) {
+        super(`Harness pair input must be a .md or .ajs file: ${path190}`);
         this.name = "InvalidPairExtensionError";
         this.extension = extension;
-        this.path = path189;
+        this.path = path190;
       }
     };
   }
@@ -150895,8 +151673,8 @@ function validateFrontmatter(schema, frontmatter, mdPath) {
 function formatIssues3(mdPath, issues) {
   return issues.map((issue2) => `${mdPath} (${formatPath4(issue2.path)}): ${issue2.message}`).join("\n");
 }
-function formatPath4(path189) {
-  return path189.join(".") || "frontmatter";
+function formatPath4(path190) {
+  return path190.join(".") || "frontmatter";
 }
 var FrontmatterValidationError;
 var init_validate4 = __esm({
@@ -151120,10 +151898,10 @@ function restoreRandomState(random) {
   };
 }
 function isClockState(value) {
-  if (!hasOwnProperty19(value, "next")) return false;
+  if (!hasOwnProperty20(value, "next")) return false;
   return typeof value.next === "number" && Number.isFinite(value.next);
 }
-function hasOwnProperty19(value, name) {
+function hasOwnProperty20(value, name) {
   return typeof value === "object" && value !== null && Object.hasOwn(value, name);
 }
 async function createHostCallReplay(snapshotPath, statefulBindings = {}, opts = {}) {
@@ -151281,9 +152059,9 @@ async function writeTextFileAtomically2(filePath, content) {
 async function cleanupCompletedSnapshot(snapshotBackend, snapshotPath) {
   await Promise.all([snapshotBackend.remove(), unlinkIfExists(hostCallStorePath(snapshotPath))]);
 }
-async function unlinkIfExists(path189) {
+async function unlinkIfExists(path190) {
   try {
-    await unlink25(path189);
+    await unlink25(path190);
   } catch (error3) {
     if (!hasErrorCode6(error3, "ENOENT")) {
       throw error3;
@@ -151347,8 +152125,8 @@ async function assertDefaultSnapshotPathIsRegular(snapshotPath) {
     }
   }
 }
-async function readTextFile(path189) {
-  const source = await readFile55(path189, "utf8");
+async function readTextFile(path190) {
+  const source = await readFile55(path190, "utf8");
   return source.startsWith("\uFEFF") ? source.slice(1) : source;
 }
 function formatLintErrorMessage(diagnostics) {
@@ -151503,7 +152281,7 @@ var init_harness_spawn_retry = __esm({
 });
 
 // src/cli/commands/harness.ts
-import path185 from "node:path";
+import path186 from "node:path";
 import { readFile as readFile57 } from "node:fs/promises";
 import { Argument } from "commander";
 function registerHarnessCommand(program, container) {
@@ -151512,7 +152290,7 @@ function registerHarnessCommand(program, container) {
     harness.command("run").description("Run a harness pair.").argument("[md-paths...]", "Paths to harness .md files to run sequentially").option("--dir <path>", "Directory to search for harness pairs when no md-path is given.").option("--fix", "Apply supported lint fixes to the harness .ajs file before running.").option("--fs", "Give the harness a real filesystem module, confined to --fs-root.").option(
       "--fs-root <path>",
       "Directory --fs confines the harness to (default: the harness directory)."
-    ).option("--snapshot-path <path>", "File to write/read harness snapshots.").option("--resume", "Resume from the snapshot file when it exists.").option("--agent <name>", "Override the agent id from the harness frontmatter agent block.").option("--model <name>", "Override the model from the harness frontmatter agent block.").option(
+    ).option("--snapshot-path <path>", "File to write/read harness snapshots.").option("--mcp-config <path>", "Give the harness named MCP servers from a JSON config.").option("--resume", "Resume from the snapshot file when it exists.").option("--agent <name>", "Override the agent id from the harness frontmatter agent block.").option("--model <name>", "Override the model from the harness frontmatter agent block.").option(
       "--mode <mode>",
       "Override the mode from the harness frontmatter agent block (read|edit|auto|yolo)."
     ).option("-y, --yes", "Accept defaults without prompting.")
@@ -151533,7 +152311,17 @@ async function executeHarnessRun(program, container, mdPath, options) {
   const flags = resolveHarnessFlags(program, options.yes);
   const resources = createExecutionResources(container, flags, "harness:run");
   const fsOptions = resolveHarnessFsOptions(container, options);
-  const selectedPath = mdPath ? path185.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, options.dir, flags.assumeYes)).mdPath;
+  let mcpOptions;
+  if (options.mcpConfig !== void 0) {
+    if (options.mcpConfig.trim().length === 0)
+      throw new ValidationError("--mcp-config needs a JSON file path.");
+    const configPath = path186.resolve(container.env.cwd, options.mcpConfig);
+    mcpOptions = parseMcpConfig3(
+      await container.fs.readFile(configPath, "utf8"),
+      path186.dirname(configPath)
+    );
+  }
+  const selectedPath = mdPath ? path186.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, options.dir, flags.assumeYes)).mdPath;
   if (flags.dryRun) {
     await resolvePair(selectedPath, container.fs);
     resources.logger.dryRun(
@@ -151541,7 +152329,7 @@ async function executeHarnessRun(program, container, mdPath, options) {
     );
     if (fsOptions !== void 0) {
       resources.logger.dryRun(
-        `Dry run: would enable the fs module rooted at ${formatDisplayPath3(container, resolveFsRoot(fsOptions, path185.dirname(selectedPath)))}.`
+        `Dry run: would enable the fs module rooted at ${formatDisplayPath3(container, resolveFsRoot(fsOptions, path186.dirname(selectedPath)))}.`
       );
     }
     return;
@@ -151588,7 +152376,8 @@ async function executeHarnessRun(program, container, mdPath, options) {
               (error3) => {
                 reportedSpawnFailures.add(error3);
               },
-              runFsOptions
+              runFsOptions,
+              mcpOptions
             ),
             onDiagnostics: (diagnostics) => {
               lintDiagnostics.push(...diagnostics);
@@ -151639,9 +152428,9 @@ async function resolveHarnessWorktreeAgent(container, selectedPath, options) {
   );
 }
 function mapSourcePathIntoWorktree3(sourceCwd, sourcePath, worktreeCwd) {
-  const relativePath = path185.relative(sourceCwd, sourcePath);
-  if (relativePath === "" || !relativePath.startsWith("..") && !path185.isAbsolute(relativePath)) {
-    return path185.join(worktreeCwd, relativePath);
+  const relativePath = path186.relative(sourceCwd, sourcePath);
+  if (relativePath === "" || !relativePath.startsWith("..") && !path186.isAbsolute(relativePath)) {
+    return path186.join(worktreeCwd, relativePath);
   }
   return sourcePath;
 }
@@ -151785,10 +152574,10 @@ function buildAgentFrontmatterOverrides(options) {
 }
 function resolveRunSnapshotPath(container, mdPath, snapshotPath) {
   if (snapshotPath !== void 0) {
-    return path185.resolve(container.env.cwd, snapshotPath);
+    return path186.resolve(container.env.cwd, snapshotPath);
   }
-  const basename10 = path185.basename(mdPath, path185.extname(mdPath));
-  return path185.join(container.env.cwd, ".poe-code", "harnesses", basename10, "snapshot.json");
+  const basename10 = path186.basename(mdPath, path186.extname(mdPath));
+  return path186.join(container.env.cwd, ".poe-code", "harnesses", basename10, "snapshot.json");
 }
 async function prepareHarnessSnapshot(container, mdPath, snapshotPath, resumeRequested) {
   const snapshotExists = await pathExists17(container, snapshotPath);
@@ -151857,8 +152646,8 @@ function formatRunMessage(baseMessage, progress) {
   return progress === void 0 ? baseMessage : `${baseMessage} (${progress})`;
 }
 function resolveAjsPath(mdPath) {
-  const parsed = path185.parse(mdPath);
-  return path185.join(parsed.dir, `${parsed.name}.ajs`);
+  const parsed = path186.parse(mdPath);
+  return path186.join(parsed.dir, `${parsed.name}.ajs`);
 }
 async function pathExists17(container, targetPath) {
   try {
@@ -151884,16 +152673,16 @@ async function executeHarnessNew(program, container, kind, basename10, options)
       `Unknown harness template "${kind}". Available kinds: ${builtinKinds().join(", ")}.`
     );
   }
-  if (basename10.length === 0 || basename10 === "." || basename10 === ".." || path185.basename(basename10) !== basename10) {
+  if (basename10.length === 0 || basename10 === "." || basename10 === ".." || path186.basename(basename10) !== basename10) {
     throw new ValidationError(
       `Invalid harness basename "${basename10}". Use a single directory name.`
     );
   }
-  const defaultDir = path185.join(".poe-code", "harnesses", basename10);
+  const defaultDir = path186.join(".poe-code", "harnesses", basename10);
   const outputDir = options.dir ?? await resolveOutputDir(defaultDir, flags.assumeYes);
-  const resolvedDir = path185.resolve(container.env.cwd, outputDir);
-  const mdPath = path185.join(resolvedDir, `${basename10}.md`);
-  const ajsPath = path185.join(resolvedDir, `${basename10}.ajs`);
+  const resolvedDir = path186.resolve(container.env.cwd, outputDir);
+  const mdPath = path186.join(resolvedDir, `${basename10}.md`);
+  const ajsPath = path186.join(resolvedDir, `${basename10}.ajs`);
   await assertFilesDoNotExist(container, [mdPath, ajsPath]);
   if (flags.dryRun) {
     resources.logger.dryRun(`Would create ${formatDisplayPath3(container, mdPath)}`);
@@ -152011,10 +152800,10 @@ async function resolveDiscoveredHarness(container, dir, assumeYes) {
 }
 function harnessDiscoveryRoots(container, dir) {
   const roots = [
-    path185.join(container.env.cwd, ".poe-code", "harnesses"),
-    path185.join(container.env.homeDir, ".poe-code", "harnesses")
+    path186.join(container.env.cwd, ".poe-code", "harnesses"),
+    path186.join(container.env.homeDir, ".poe-code", "harnesses")
   ];
-  return dir === void 0 ? roots : [path185.resolve(container.env.cwd, dir), ...roots];
+  return dir === void 0 ? roots : [path186.resolve(container.env.cwd, dir), ...roots];
 }
 function formatSearchedRoots(container, dir) {
   return harnessDiscoveryRoots(container, dir).map((root) => formatDisplayPath3(container, root)).join(", ");
@@ -152036,7 +152825,7 @@ async function discoverPairsDirectlyIn(container, root) {
   for (const entry of entries.filter((name) => name.endsWith(".md")).sort()) {
     try {
       pairs.push(
-        await resolvePair(path185.join(root, entry), container.fs)
+        await resolvePair(path186.join(root, entry), container.fs)
       );
     } catch (error3) {
       if (error3 instanceof MissingPairError) {
@@ -152058,7 +152847,7 @@ async function discoverProjectThenUserHarnesses(container, dir) {
       const stat36 = await container.fs.stat(pair.mdPath);
       discovered.push({
         ...pair,
-        dir: path185.dirname(pair.mdPath),
+        dir: path186.dirname(pair.mdPath),
         mdMtimeMs: stat36.mtimeMs
       });
     }
@@ -152114,12 +152903,12 @@ function resolveHarnessFsOptions(container, options) {
       "--fs-root needs a directory path. Pass --fs-root <path> to confine the harness to that directory, or drop --fs-root to confine it to the harness directory."
     );
   }
-  return { root: path185.resolve(container.env.cwd, options.fsRoot) };
+  return { root: path186.resolve(container.env.cwd, options.fsRoot) };
 }
 function resolveFsRoot(fsOptions, harnessDir) {
   return fsOptions.root ?? harnessDir;
 }
-function createHarnessModules(container, logger2, frontmatter, meta, onSpawnFailure, fsOptions) {
+function createHarnessModules(container, logger2, frontmatter, meta, onSpawnFailure, fsOptions, mcpOptions) {
   const harnessMeta = {
     kind: meta.kind,
     version: meta.version,
@@ -152172,6 +152961,7 @@ function createHarnessModules(container, logger2, frontmatter, meta, onSpawnFail
   });
   return {
     agent: toModuleExports(agent3),
+    ...mcpOptions === void 0 ? {} : { mcp: toModuleExports(makeMcpModule(mcpOptions)) },
     fail: toModuleExports(/* @__PURE__ */ new Map([["default", fail3]])),
     ...fsOptions === void 0 ? {} : { fs: toModuleExports(makeFsModule({ root: resolveFsRoot(fsOptions, meta.dirname) })) },
     git: toModuleExports(git2),
@@ -152268,8 +153058,8 @@ function toModuleExports(moduleExports) {
   return new Map(Object.entries(moduleExports));
 }
 function formatDisplayPath3(container, filePath) {
-  const relative8 = path185.relative(container.env.cwd, filePath);
-  return relative8.length > 0 && !relative8.startsWith("..") && !path185.isAbsolute(relative8) ? relative8 : filePath.replace(container.env.homeDir, "~");
+  const relative8 = path186.relative(container.env.cwd, filePath);
+  return relative8.length > 0 && !relative8.startsWith("..") && !path186.isAbsolute(relative8) ? relative8 : filePath.replace(container.env.homeDir, "~");
 }
 var init_harness3 = __esm({
   async "src/cli/commands/harness.ts"() {
@@ -152576,7 +153366,7 @@ import { Argument as Argument2 } from "commander";
 function isVisible(command) {
   return Reflect.get(command, "_hidden") !== true;
 }
-function collectNodes(command, path189 = []) {
+function collectNodes(command, path190 = []) {
   const children2 = command.commands.filter(isVisible).map((child) => ({
     name: child.name(),
     aliases: [...child.aliases()],
@@ -152607,10 +153397,10 @@ function collectNodes(command, path189 = []) {
     return [];
   }
   return [
-    { path: path189, children: children2, options, requiredValueFlags, isPositionalLeaf, positionalChildren },
+    { path: path190, children: children2, options, requiredValueFlags, isPositionalLeaf, positionalChildren },
     ...command.commands.filter(isVisible).flatMap(
       (child) => [child.name(), ...child.aliases()].flatMap(
-        (name) => collectNodes(child, [...path189, name])
+        (name) => collectNodes(child, [...path190, name])
       )
     )
   ];
@@ -152742,8 +153532,8 @@ function renderZsh(nodes) {
 function quoteFish(value) {
   return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
-function fishCondition(path189) {
-  return path189.length === 0 ? '"__fish_use_subcommand"' : `"__fish_seen_subcommand_from ${path189.at(-1)}"`;
+function fishCondition(path190) {
+  return path190.length === 0 ? '"__fish_use_subcommand"' : `"__fish_seen_subcommand_from ${path190.at(-1)}"`;
 }
 function renderFish(nodes) {
   const lines = nodes.flatMap((node) => {
@@ -152800,7 +153590,7 @@ var init_completion = __esm({
 
 // src/cli/commands/tasks-options.ts
 import * as fsPromises27 from "node:fs/promises";
-import path186 from "node:path";
+import path187 from "node:path";
 async function resolveWorkflowTaskListOptions(workflowPath) {
   const frontmatter = await readWorkflowFrontmatter(workflowPath);
   return readTaskListOptions(frontmatter, workflowPath);
@@ -152951,14 +153741,14 @@ function readMaestroStates(frontmatter) {
     return [];
   }
   return unique3([
-    ...readStringArray2(getOwnEntry37(maestro, "active_states")),
-    ...readStringArray2(getOwnEntry37(maestro, "terminal_states"))
+    ...readStringArray3(getOwnEntry37(maestro, "active_states")),
+    ...readStringArray3(getOwnEntry37(maestro, "terminal_states"))
   ]);
 }
 function readLegacyTopLevelStates(frontmatter) {
   return unique3([
-    ...readStringArray2(getOwnEntry37(frontmatter, "active_states")),
-    ...readStringArray2(getOwnEntry37(frontmatter, "terminal_states"))
+    ...readStringArray3(getOwnEntry37(frontmatter, "active_states")),
+    ...readStringArray3(getOwnEntry37(frontmatter, "terminal_states"))
   ]);
 }
 function readDeclaredStates(value) {
@@ -152994,7 +153784,7 @@ function referencesMaestroTaskStateMachine(value) {
   const record2 = asRecord6(value);
   return record2 === void 0 ? false : Object.values(record2).some((item) => referencesMaestroTaskStateMachine(item));
 }
-function readStringArray2(value) {
+function readStringArray3(value) {
   if (!Array.isArray(value)) {
     return [];
   }
@@ -153038,7 +153828,7 @@ function resolveStringValue2(value) {
   return process.env[value.slice(envPrefix.length)] ?? value;
 }
 function resolveWorkflowRelativePath(value, workflowPath) {
-  return path186.isAbsolute(value) ? value : path186.resolve(path186.dirname(workflowPath), value);
+  return path187.isAbsolute(value) ? value : path187.resolve(path187.dirname(workflowPath), value);
 }
 function asRecord6(value) {
   return isPlainRecord6(value) ? value : void 0;
@@ -153083,7 +153873,7 @@ var init_tasks_options = __esm({
 });
 
 // src/cli/commands/tasks.ts
-import path187 from "node:path";
+import path188 from "node:path";
 function registerTasksCommand(program, container) {
   const tasks = program.command("tasks").description("Read and mutate configured workflow tasks.");
   tasks.command("verify").description("Verify a task GitHub Project.").argument("<list>", "Project list in <owner>/<number> format.").option("--workflow <path>", "Workflow file path.", "./WORKFLOW.md").option("--repo <owner/name>", "GitHub repository owner/name.").option("--project <owner/number>", "GitHub project owner/number.").option("--states <csv>", "Required task state names.").option("--json", jsonOptionDescription).action(async (list2, options, command) => {
@@ -153233,7 +154023,7 @@ async function runImport(options, container) {
     const limit = options.limit === void 0 ? void 0 : parseNonNegativeInteger3(options.limit, "--limit");
     const source = {
       type: "markdown-dir",
-      path: path187.resolve(options.from),
+      path: path188.resolve(options.from),
       singleList: "import",
       frontmatterMode: "passthrough"
     };
@@ -153449,7 +154239,7 @@ async function openConfiguredTaskList2(options, container) {
 }
 function addRuntimeTaskOptions(resolved, container) {
   const options = resolved.taskListOptions;
-  if (!hasOwnProperty20(options, "path")) {
+  if (!hasOwnProperty21(options, "path")) {
     return options;
   }
   return {
@@ -153536,7 +154326,7 @@ function logTask(logger2, task) {
   logger2.info(`metadata: ${JSON.stringify(task.metadata)}`);
 }
 function writeField(task, field) {
-  if (!hasOwnProperty20(task, field)) {
+  if (!hasOwnProperty21(task, field)) {
     throw new TasksCommandUsageError(`Task field "${field}" does not exist.`);
   }
   const value = task[field];
@@ -153644,7 +154434,7 @@ function readCommentMethod(tasks) {
   const candidate = tasks.comment;
   return typeof candidate === "function" ? candidate : void 0;
 }
-function hasOwnProperty20(value, key3) {
+function hasOwnProperty21(value, key3) {
   return Object.prototype.hasOwnProperty.call(value, key3);
 }
 var TasksCommandUsageError;
@@ -153667,7 +154457,7 @@ var init_tasks2 = __esm({
 });
 
 // src/cli/commands/gaslight.ts
-import path188 from "node:path";
+import path189 from "node:path";
 import { Option as Option10 } from "commander";
 async function resolveGaslightCommandConfig(container) {
   const configDoc = await readMergedDocumentReadonly(
@@ -153686,9 +154476,9 @@ async function resolveGaslightCommandConfig(container) {
 }
 function resolveConfiguredPath(cwd, homeDir, value) {
   if (value.startsWith("~/")) {
-    return path188.join(homeDir, value.slice(2));
+    return path189.join(homeDir, value.slice(2));
   }
-  return path188.isAbsolute(value) ? value : path188.resolve(cwd, value);
+  return path189.isAbsolute(value) ? value : path189.resolve(cwd, value);
 }
 function formatPlanDirectoryDetails(container, planDirectory, absoluteDirectory) {
   return [
@@ -153803,7 +154593,7 @@ function formatCompletedPlans(result) {
   return [
     "Completed plans:",
     ...result.plans.map(
-      (plan) => `- ${path188.basename(plan.planPath)}${plan.durationMs === void 0 ? "" : ` \xB7 ${formatDuration3(plan.durationMs)}`}`
+      (plan) => `- ${path189.basename(plan.planPath)}${plan.durationMs === void 0 ? "" : ` \xB7 ${formatDuration3(plan.durationMs)}`}`
     )
   ].join("\n");
 }
@@ -153869,8 +154659,8 @@ async function resolveInstallScope(options, assumeYes) {
 }
 async function scaffoldConfig(container, scope, force, dryRun) {
   const root = scope === "global" ? container.env.homeDir : container.env.cwd;
-  const configPath = path188.join(root, ".poe-code", "gaslight.yaml");
-  const configDirectory = path188.dirname(configPath);
+  const configPath = path189.join(root, ".poe-code", "gaslight.yaml");
+  const configDirectory = path189.dirname(configPath);
   try {
     const stats2 = await container.fs.lstat(configDirectory);
     if (stats2.isSymbolicLink()) {
@@ -154265,7 +155055,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "8.0.1",
+      version: "9.0.0",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",
@@ -154899,11 +155689,11 @@ function readCommandTreeOption(command, optionName) {
   }
   return void 0;
 }
-function assertPathIsNotOptionName(path189, command) {
-  const named = command.options.find((option) => option.long === `--${path189}`);
+function assertPathIsNotOptionName(path190, command) {
+  const named = command.options.find((option) => option.long === `--${path190}`);
   if (named !== void 0) {
     throw new ValidationError(
-      `\`${path189}\` is not a workflow path. Did you mean \`${named.long}\`?`
+      `\`${path190}\` is not a workflow path. Did you mean \`${named.long}\`?`
     );
   }
 }
@@ -154964,14 +155754,14 @@ function registerMaestroCommand(program, container) {
       "--log-level <level>",
       maestroCommandSchema.shape.logLevel.description ?? "Log level"
     ).choices(maestroCommandSchema.shape.logLevel.values.map(String)).default(maestroCommandSchema.shape.logLevel.default)
-  ).action(async (path189, options, command) => {
-    assertPathIsNotOptionName(path189, command);
+  ).action(async (path190, options, command) => {
+    assertPathIsNotOptionName(path190, command);
     const mergedOptions = {
       ...options,
       ...command.optsWithGlobals()
     };
     await runMaestro({
-      workflowPath: mergedOptions.config ?? path189,
+      workflowPath: mergedOptions.config ?? path190,
       maxConcurrent: mergedOptions.maxConcurrent,
       pollIntervalMs: mergedOptions.pollIntervalMs,
       list: mergedOptions.list,
@@ -155132,7 +155922,7 @@ function createProgram(dependencies) {
 }
 function assertKnownHelpPath(program, container, argv) {
   let target = program;
-  const path189 = [];
+  const path190 = [];
   for (const token of argv.filter((arg) => !arg.startsWith("-"))) {
     if (target.commands.length === 0) {
       return;
@@ -155140,7 +155930,7 @@ function assertKnownHelpPath(program, container, argv) {
     const child = findCommand2(target, token);
     if (child !== void 0) {
       target = child;
-      path189.push(token);
+      path190.push(token);
       continue;
     }
     if (target !== program && target.registeredArguments.length > 0) {
@@ -155150,7 +155940,7 @@ function assertKnownHelpPath(program, container, argv) {
       container,
       scope: target === program ? "cli" : target.name(),
       unknownCommand: token,
-      helpArgs: [...path189, "--help"],
+      helpArgs: [...path190, "--help"],
       candidates: commandCandidates(target),
       moduleUrl: import.meta.url
     });
@@ -155181,16 +155971,16 @@ function commandCandidates(parent) {
   return parent.commands.flatMap((command) => [command.name(), ...command.aliases()]);
 }
 function registerHelpCommand(program, container) {
-  program.command("help").description("Display help for a command.").argument("[command...]", "Command path to describe, for example `maestro tui`.").action((path189) => {
+  program.command("help").description("Display help for a command.").argument("[command...]", "Command path to describe, for example `maestro tui`.").action((path190) => {
     let target = program;
-    for (const name of path189) {
+    for (const name of path190) {
       const child = findCommand2(target, name);
       if (child === void 0) {
         throwCommandNotFound({
           container,
           scope: "cli",
           unknownCommand: name,
-          helpArgs: [...path189.slice(0, path189.indexOf(name)), "--help"],
+          helpArgs: [...path190.slice(0, path190.indexOf(name)), "--help"],
           candidates: commandCandidates(target),
           moduleUrl: import.meta.url
         });