poe-code 14.0.59 → 14.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "14.0.59",
+  "version": "14.0.61",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safe-js/dist/chunks/{chunk-YZGYOQK3.js → chunk-VAYQP2VZ.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-D4YY44EF.js";
+} from "./chunk-ZTGKRKQH.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-YZGYOQK3.js.map
+//# sourceMappingURL=chunk-VAYQP2VZ.js.map

package/packages/safe-js/dist/chunks/{chunk-D4YY44EF.js → chunk-ZTGKRKQH.js}

@@ -2525,23 +2525,21 @@ function parseTokens(tokens, compilation) {
 function parseModuleTokens(tokens, compilation) {
   return new Parser(tokens, compilation).parseModule();
 }
-function parseExpressionTokens(tokens, compilation) {
-  return new Parser(tokens, compilation).parseExpressionOnly();
-}
 var Parser = class {
-  constructor(tokens, compilation) {
+  constructor(tokens, compilation, functionContext = "normal") {
     this.tokens = tokens;
     this.compilation = compilation;
+    this.functionContext = functionContext;
     this.functionScopes.add(this.scopes[0]);
   }
   tokens;
   compilation;
+  functionContext;
   index = 0;
   breakableDepth = 0;
   conditionalExpressionDepth = 0;
   ifStatementDepth = 0;
   loopDepth = 0;
-  generatorBody = false;
   scopes = [/* @__PURE__ */ new Map()];
   functionScopes = /* @__PURE__ */ new WeakSet();
   varNames = /* @__PURE__ */ new WeakMap();
@@ -2727,9 +2725,9 @@ var Parser = class {
   }
   parseArrowFunctionBody(params) {
     if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-      return this.withFunctionContext(false, () => this.parseBlockStatement(params));
+      return this.withFunctionContext("normal", () => this.parseBlockStatement(params));
     }
-    return this.withFunctionContext(false, () => this.parseExpression().node);
+    return this.withFunctionContext("normal", () => this.parseExpression().node);
   }
   parseBlockStatement(params, catchParam) {
     const start = this.expectPunctuator("{");
@@ -3333,7 +3331,7 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionDeclaration",
       async: asyncToken !== void 0,
@@ -3368,32 +3366,34 @@ var Parser = class {
     };
   }
   parseArrowParameters() {
-    this.expectPunctuator("(");
-    const params = [];
-    if (this.consumePunctuator(")") !== void 0) {
-      return params;
-    }
-    while (true) {
-      const param = this.parseBindingElement();
-      params.push(param);
-      const comma = this.consumePunctuator(",");
-      if (comma === void 0) {
-        break;
+    return this.withFunctionContext("parameters", () => {
+      this.expectPunctuator("(");
+      const params = [];
+      if (this.consumePunctuator(")") !== void 0) {
+        return params;
       }
-      if (param.type === "RestElement") {
+      while (true) {
+        const param = this.parseBindingElement();
+        params.push(param);
+        const comma = this.consumePunctuator(",");
+        if (comma === void 0) {
+          break;
+        }
+        if (param.type === "RestElement") {
+          if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
+            throw unexpectedTokenError(comma);
+          }
+          throw new Error(
+            `Rest element must be the last parameter at line ${comma.start.line}, column ${comma.start.column}.`
+          );
+        }
         if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
-          throw unexpectedTokenError(comma);
+          break;
         }
-        throw new Error(
-          `Rest element must be the last parameter at line ${comma.start.line}, column ${comma.start.column}.`
-        );
-      }
-      if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
-        break;
       }
-    }
-    this.expectPunctuator(")");
-    return params;
+      this.expectPunctuator(")");
+      return params;
+    });
   }
   parseBindingElement() {
     if (this.consumePunctuator("...") !== void 0) {
@@ -3947,7 +3947,7 @@ var Parser = class {
       };
     }
     if (token.type === "keyword" && token.value === "yield") {
-      if (!this.generatorBody) {
+      if (this.functionContext !== "generator") {
         throw new Error(
           `yield is only valid inside a generator body at line ${token.start.line}, column ${token.start.column}.`
         );
@@ -3974,11 +3974,16 @@ var Parser = class {
       };
     }
     if (token.type === "keyword" && token.value === "await") {
-      if (this.generatorBody) {
+      if (this.functionContext === "generator") {
         throw new Error(
           `generators cannot await; use a regular async function at line ${token.start.line}, column ${token.start.column}.`
         );
       }
+      if (this.functionContext === "parameters") {
+        throw new Error(
+          `await is not valid in function parameters at line ${token.start.line}, column ${token.start.column}.`
+        );
+      }
       this.index += 1;
       const argument = this.parseUnaryExpression();
       return {
@@ -4103,7 +4108,7 @@ var Parser = class {
       if (this.currentToken().type === "template") {
         const quasi = createTemplateLiteral(
           this.currentToken(),
-          { allowMalformedEscapes: true },
+          { allowMalformedEscapes: true, functionContext: this.functionContext },
           this.compilation
         );
         this.index += 1;
@@ -4190,7 +4195,11 @@ var Parser = class {
     if (token.type === "template") {
       this.index += 1;
       return {
-        node: createTemplateLiteral(token, { allowMalformedEscapes: false }, this.compilation),
+        node: createTemplateLiteral(
+          token,
+          { allowMalformedEscapes: false, functionContext: this.functionContext },
+          this.compilation
+        ),
         parenthesized: false
       };
     }
@@ -4306,7 +4315,7 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionExpression",
       async: asyncToken !== void 0,
@@ -4550,7 +4559,7 @@ var Parser = class {
       }
       return parsedParams;
     });
-    const body = this.withFunctionContext(false, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionExpression",
       async: asyncToken !== void 0,
@@ -4955,19 +4964,19 @@ var Parser = class {
   hasReturnArgument(returnToken, nextToken) {
     return !(hasLineBreakBetween(returnToken, nextToken) || nextToken.type === "punctuator" && (nextToken.value === ";" || nextToken.value === "}") || nextToken.type === "eof");
   }
-  withFunctionContext(generatorBody, callback) {
+  withFunctionContext(functionContext, callback) {
     const previousBreakableDepth = this.breakableDepth;
     const previousLoopDepth = this.loopDepth;
-    const previousGeneratorBody = this.generatorBody;
+    const previousFunctionContext = this.functionContext;
     this.breakableDepth = 0;
     this.loopDepth = 0;
-    this.generatorBody = generatorBody;
+    this.functionContext = functionContext;
     try {
       return callback();
     } finally {
       this.breakableDepth = previousBreakableDepth;
       this.loopDepth = previousLoopDepth;
-      this.generatorBody = previousGeneratorBody;
+      this.functionContext = previousFunctionContext;
     }
   }
   withLoopContext(callback) {
@@ -5402,7 +5411,7 @@ function createLiteralFromToken(token) {
   }
   return createKeywordLiteral(token);
 }
-function createTemplateLiteral(token, options = { allowMalformedEscapes: false }, compilation) {
+function createTemplateLiteral(token, options, compilation) {
   const raw = token.value;
   const expressions = [];
   const quasis = [];
@@ -5422,6 +5431,7 @@ function createTemplateLiteral(token, options = { allowMalformedEscapes: false }
         parseEmbeddedExpression(
           raw.slice(expressionStart, expressionEnd),
           positionWithinRaw(token.start, raw, expressionStart),
+          options.functionContext,
           compilation
         )
       );
@@ -5784,13 +5794,13 @@ function decodeHexEscape(value, start) {
     end: index + 2
   };
 }
-function parseEmbeddedExpression(source, base, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, compilation) {
   const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
     ...token,
     start: rebasePosition(token.start, base),
     end: rebasePosition(token.end, base)
   }));
-  return parseExpressionTokens(tokens, compilation);
+  return new Parser(tokens, compilation, functionContext).parseExpressionOnly();
 }
 function findRegexLiteral(node) {
   if (node === null || node === void 0) {
@@ -8257,7 +8267,7 @@ function isCounter(value) {
 }
 
 // packages/safe-js/src/interp/cancel.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 
 // packages/safe-js/src/interp/builtin-call.ts
 async function invokeBuiltinClosure(closure, args, budget, context, thisValue, construct = false) {
@@ -8617,6 +8627,55 @@ function toMatchArray(match, input) {
   return result;
 }
 
+// packages/safe-js/src/interp/resources.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+var runResources = new AsyncLocalStorage3();
+function retainValues(budget, values) {
+  const retained = {};
+  budget.setRetainedValues(retained, values);
+  const pending = runResources.getStore()?.referenceReleases;
+  const release = () => {
+    budget.setRetainedValues(retained, void 0);
+    pending?.delete(release);
+  };
+  pending?.add(release);
+  return release;
+}
+async function withRunResources(signal, execute) {
+  const controller = new AbortController();
+  const cancel = () => controller.abort(signal?.reason);
+  const cleanups = /* @__PURE__ */ new Set();
+  const resources = {
+    signal: controller.signal,
+    referenceReleases: /* @__PURE__ */ new Set(),
+    add(close) {
+      cleanups.add(close);
+    }
+  };
+  signal?.addEventListener("abort", cancel, { once: true });
+  if (signal?.aborted) cancel();
+  let result;
+  let failure;
+  let errors = [];
+  try {
+    result = await runResources.run(resources, execute);
+  } catch (error) {
+    failure = { reason: error };
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    controller.abort(new Error("SafeJS run finished."));
+    for (const release of resources.referenceReleases) release();
+    resources.referenceReleases.clear();
+    const outcomes = await Promise.allSettled(
+      [...cleanups].map((close) => Promise.resolve().then(close))
+    );
+    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  }
+  if (failure !== void 0) throw failure.reason;
+  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
+  return result;
+}
+
 // packages/safe-js/src/interp/string-coercion.ts
 var defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
 var defaultValueHook = /* @__PURE__ */ Symbol("defaultValueHook");
@@ -8703,9 +8762,10 @@ async function defaultToString(value, budget, context, joining) {
     }
     if (joining.has(value)) return "";
     joining.add(value);
+    let text = "";
+    const release = retainValues(budget, () => [text]);
     try {
       const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
-      let text = "";
       for (let index = 0; index < length; index++) {
         budget.visitNode();
         const element = ownDataValue(value, String(index));
@@ -8714,15 +8774,21 @@ async function defaultToString(value, budget, context, joining) {
       }
       return text;
     } finally {
+      release();
       joining.delete(value);
     }
   }
   if (sandboxErrorTypes.has(value)) {
     const nameValue = ownDataValue(value, "name");
     const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
-    const messageValue = ownDataValue(value, "message");
-    const message = messageValue === void 0 ? "" : await sandboxString(messageValue, budget, context, joining);
-    return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+    const release = retainValues(budget, () => [name]);
+    try {
+      const messageValue = ownDataValue(value, "message");
+      const message = messageValue === void 0 ? "" : await sandboxString(messageValue, budget, context, joining);
+      return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+    } finally {
+      release();
+    }
   }
   return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
 }
@@ -9332,8 +9398,8 @@ function syncIterator(iterator) {
 }
 
 // packages/safe-js/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
-var activeJob = new AsyncLocalStorage3();
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var activeJob = new AsyncLocalStorage4();
 var SandboxJobQueue = class {
   running = false;
   pending = [];
@@ -10162,7 +10228,7 @@ function isPromiseLike(value) {
 }
 
 // packages/safe-js/src/interp/cancel.ts
-var activeCancellation = new AsyncLocalStorage4();
+var activeCancellation = new AsyncLocalStorage5();
 var sandboxPromises = /* @__PURE__ */ new WeakSet();
 var cancelableOutcomes = /* @__PURE__ */ new WeakMap();
 function withCancellationSignal(signal, task) {
@@ -23880,44 +23946,6 @@ function hoistVarDeclarations(node, scope) {
   }
 }
 
-// packages/safe-js/src/interp/resources.ts
-import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
-var runResources = new AsyncLocalStorage5();
-async function withRunResources(signal, execute) {
-  const controller = new AbortController();
-  const cancel = () => controller.abort(signal?.reason);
-  const cleanups = /* @__PURE__ */ new Set();
-  const resources = {
-    signal: controller.signal,
-    referenceReleases: /* @__PURE__ */ new Set(),
-    add(close) {
-      cleanups.add(close);
-    }
-  };
-  signal?.addEventListener("abort", cancel, { once: true });
-  if (signal?.aborted) cancel();
-  let result;
-  let failure;
-  let errors = [];
-  try {
-    result = await runResources.run(resources, execute);
-  } catch (error) {
-    failure = { reason: error };
-  } finally {
-    signal?.removeEventListener("abort", cancel);
-    controller.abort(new Error("SafeJS run finished."));
-    for (const release of resources.referenceReleases) release();
-    resources.referenceReleases.clear();
-    const outcomes = await Promise.allSettled(
-      [...cleanups].map((close) => Promise.resolve().then(close))
-    );
-    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-  }
-  if (failure !== void 0) throw failure.reason;
-  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
-  return result;
-}
-
 // packages/safe-js/src/interp/methods/array.ts
 var arrayLikeSources = /* @__PURE__ */ new WeakMap();
 var activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
@@ -25064,6 +25092,9 @@ function isStringMethodName(property) {
 function validateStringMethodArguments(_methodName, _args) {
 }
 function callStringMethod(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
+  if (methodName === "concat" && args.some((argument) => argument !== null && typeof argument === "object")) {
+    return callConcat(value, args, budget, context);
+  }
   if (methodName === "isWellFormed") {
     for (let index = 0; index < value.length; index++) {
       const codeUnit = value.charCodeAt(index);
@@ -25219,6 +25250,19 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
     operation.release();
   }
 }
+async function callConcat(value, args, budget, context) {
+  let result = budget.allocateString(value);
+  const release = retainValues(budget, () => [result]);
+  try {
+    for (const argument of args) {
+      const text = sandboxString(argument, budget, context);
+      result = budget.allocateString(result + (typeof text === "string" ? text : await text));
+    }
+    return result;
+  } finally {
+    release();
+  }
+}
 function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
   const search = args[0];
   const replacement = args[1];
@@ -26679,14 +26723,18 @@ function isObjectPrototypeSetterProperty(property, key) {
 }
 async function evaluateTemplateLiteral(node, context) {
   let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
-  const release = retainValues(context.budget, () => [value]);
+  let input = void 0;
+  const release = retainValues(context.budget, () => [value, input]);
   try {
     for (let index = 0; index < node.expressions.length; index += 1) {
       const expression = await evaluateNode(node.expressions[index], context);
       if (expression.kind !== "normal") {
         return expression;
       }
-      const expressionText = context.budget.allocateString(String(expression.value));
+      input = expression.value;
+      const text = sandboxString(input, context.budget, createCoercionContext(context));
+      const expressionText = typeof text === "string" ? text : await text;
+      input = void 0;
       value = context.budget.allocateString(value + expressionText);
       const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
       value = context.budget.allocateString(value + quasiText);
@@ -28133,17 +28181,6 @@ async function evaluateMemberAccess(node, context, consume) {
     release();
   }
 }
-function retainValues(budget, values) {
-  const retained = {};
-  budget.setRetainedValues(retained, values);
-  const pending = runResources.getStore()?.referenceReleases;
-  const release = () => {
-    budget.setRetainedValues(retained, void 0);
-    pending?.delete(release);
-  };
-  pending?.add(release);
-  return release;
-}
 async function evaluateMemberProperty(node, context) {
   const property = await evaluateNode(node, context);
   if (property.kind !== "normal") {
@@ -33435,6 +33472,7 @@ export {
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
   HostCallResumabilityError,
+  runResources,
   assertSnapshotInactive,
   isSandboxClosure,
   deepCopyToSandbox,
@@ -33451,7 +33489,6 @@ export {
   validateSnapshotMigration,
   restore,
   lint,
-  runResources,
   declareHostOperation,
   createSeededRandom,
   createReplayableRandom,
@@ -33463,4 +33500,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-D4YY44EF.js.map
+//# sourceMappingURL=chunk-ZTGKRKQH.js.map