pi-fabric 0.66.0 → 0.67.0

package/dist/chunks/{fabric-runtime-state-FDTVRRCU.js → fabric-runtime-state-LG265P3R.js}

@@ -11707,4 +11707,4 @@ var deepAssign = (target, source) => {
 export {
   FabricRuntimeState
 };
-//# sourceMappingURL=fabric-runtime-state-FDTVRRCU.js.map
+//# sourceMappingURL=fabric-runtime-state-LG265P3R.js.map

package/dist/index.js

@@ -76,6 +76,10 @@ import {
 import {
   resolveAgentDir
 } from "./chunks/chunk-SOBEXOWK.js";
+import {
+  GUEST_TYPE_DECLARATIONS,
+  PI_CORE_COMPATIBILITY_ARGUMENT_TYPE_NAMES
+} from "./chunks/chunk-HGVFNZEQ.js";
 import {
   awaitPeerSettle,
   buildPeerCards
@@ -2396,10 +2400,146 @@ var prepareFabricExecArguments = (input) => {
   return prepared;
 };
 
+// src/runtime/core-tool-properties.ts
+var CORE_TOOL_NAMES = Object.keys(
+  PI_CORE_COMPATIBILITY_ARGUMENT_TYPE_NAMES
+);
+var extractTypeDeclarations = (declarations) => {
+  const parsed = /* @__PURE__ */ new Map();
+  for (const match of declarations.matchAll(/\btype\s+(\w+)\s*=/g)) {
+    const name = match[1];
+    if (name === void 0) continue;
+    const rhsStart = match.index + match[0].length;
+    let depth = 0;
+    let end = rhsStart;
+    while (end < declarations.length) {
+      const character = declarations[end];
+      if (character === "(" || character === "{" || character === "[") depth += 1;
+      else if (character === ")" || character === "}" || character === "]") depth -= 1;
+      else if (character === ";" && depth === 0) break;
+      end += 1;
+    }
+    parsed.set(name, declarations.slice(rhsStart, end));
+  }
+  return parsed;
+};
+var matchCaptures = (text, pattern) => [...text.matchAll(pattern)].flatMap(
+  (match) => match[1] === void 0 ? [] : [match[1]]
+);
+var objectLiteralKeys = (rhs) => {
+  const withoutMappedKeys = rhs.replace(/\[\s*\w+\s+in\s+keyof\s+\w+\s*\]\s*:/g, " ");
+  return matchCaptures(withoutMappedKeys, /([A-Za-z_]\w*)\s*\??:/g);
+};
+var referencedTypeNames = (rhs) => matchCaptures(rhs, /\b(Pi[A-Z]\w*)/g);
+var capitalise = (tool) => tool.charAt(0).toUpperCase() + tool.slice(1);
+var collectCoreToolProperties = (declarations) => {
+  const typeDeclarations = extractTypeDeclarations(declarations);
+  const owners = /* @__PURE__ */ new Map();
+  for (const tool of CORE_TOOL_NAMES) {
+    const roots = [
+      `Pi${capitalise(tool)}Argument`,
+      PI_CORE_COMPATIBILITY_ARGUMENT_TYPE_NAMES[tool],
+      `Pi${capitalise(tool)}Options`
+    ];
+    const visited = /* @__PURE__ */ new Set();
+    const walk = (name) => {
+      if (visited.has(name)) return;
+      visited.add(name);
+      const rhs = typeDeclarations.get(name);
+      if (rhs === void 0) return;
+      for (const property of objectLiteralKeys(rhs)) {
+        const toolSet = owners.get(property) ?? /* @__PURE__ */ new Set();
+        toolSet.add(tool);
+        owners.set(property, toolSet);
+      }
+      for (const reference of referencedTypeNames(rhs)) walk(reference);
+    };
+    for (const root of roots) walk(root);
+  }
+  return new Map([...owners].map(([property, toolSet]) => [property, [...toolSet]]));
+};
+var CORE_TOOL_PROPERTIES = collectCoreToolProperties(GUEST_TYPE_DECLARATIONS);
+
 // src/type-error-guidance.ts
 var SYNTAX_ERROR_PATTERN = /expected|unterminated|unexpected|invalid character/i;
 var PAYLOAD_CALL_PATTERN = /\bpi\.(?:edit|write)\s*\(/;
+var PROMISE_ALL_PATTERN = /\bPromise\.all\s*\(/;
+var TUPLE_ARITY_PATTERN = /Tuple type .* of length '[0-9]+' has no element at index '[0-9]+'/;
+var MISSING_NAME_PATTERN = /^Cannot find name '([^']+)'/;
+var UNKNOWN_PROPERTY_PATTERN = /'([^']+)' does not exist in type '([^']+)'/;
+var PI_CALL_PATTERN = /\bpi\.(\w+)\s*\(/g;
+var FABRIC_EXEC_ARGUMENT_NOTES = {
+  strings: "named `strings` belong in the outer `fabric_exec` arguments, then become available inside `code` as `\u03C0.key`.",
+  tokenBudget: "budget arguments (`tokenBudget`, `agentBudget`) belong to the outer `fabric_exec` call, not inside `code`.",
+  agentBudget: "budget arguments (`tokenBudget`, `agentBudget`) belong to the outer `fabric_exec` call, not inside `code`.",
+  display: "the `display` objective belongs to the outer `fabric_exec` call, not inside `code`.",
+  resultFormat: "`resultFormat` belongs to the outer `fabric_exec` call, not inside `code`."
+};
+var PROPERTY_NOTES = {
+  settle: "`settle:true` settles nonzero `pi.bash` exits into an `ok:false` envelope instead of rejecting; other `pi.*` calls reject failures normally.",
+  timeout: "`timeout` is measured in seconds; `timeoutMs` is converted from milliseconds."
+};
+var isCoreToolName = (name) => CORE_TOOL_NAMES.includes(name);
+var toolFromTypeText = (typeText) => {
+  for (const match of typeText.matchAll(/\bPi([A-Z]\w*)/g)) {
+    const captured = match[1];
+    if (captured === void 0) continue;
+    const candidate = captured.replace(/(?:Compatibility)?(?:Argument|Options)$/, "").toLowerCase();
+    if (isCoreToolName(candidate)) return candidate;
+  }
+  return void 0;
+};
+var enclosingCoreTool = (code, error) => {
+  const lines = code.split("\n");
+  for (const lineIndex of [error.line - 2, error.line - 1]) {
+    if (lineIndex < 0 || lineIndex >= lines.length) continue;
+    const offset = lines.slice(0, lineIndex).join("\n").length + (lineIndex > 0 ? 1 : 0) + Math.max(0, error.column - 1);
+    PI_CALL_PATTERN.lastIndex = 0;
+    let match;
+    let tool;
+    while ((match = PI_CALL_PATTERN.exec(code)) !== null && match.index < offset) {
+      const called = match[1];
+      if (called !== void 0 && isCoreToolName(called)) tool = called;
+    }
+    if (tool !== void 0) return tool;
+  }
+  return void 0;
+};
+var unknownPropertyHint = (property, tool) => {
+  if (tool === void 0) return void 0;
+  const envelopeNote = FABRIC_EXEC_ARGUMENT_NOTES[property];
+  if (envelopeNote !== void 0) {
+    return `Recovery hint: \`${property}\` is a \`fabric_exec\` argument, not a \`pi.${tool}\` property. ${envelopeNote}`;
+  }
+  const ownerTools = CORE_TOOL_PROPERTIES.get(property);
+  if (ownerTools === void 0 || ownerTools.includes(tool)) return void 0;
+  const owners = ownerTools.map((owner) => `\`pi.${owner}\``).join(", ");
+  const note = PROPERTY_NOTES[property];
+  return `Recovery hint: \`${property}\` is not a \`pi.${tool}\` property \u2014 it belongs to ${owners}.${note ? ` ${note}` : ""}`;
+};
+var hasLiteralPayloadInterpolation = (code, errors) => {
+  if (!PAYLOAD_CALL_PATTERN.test(code)) return false;
+  return errors.some((error) => {
+    const name = MISSING_NAME_PATTERN.exec(error.message)?.[1];
+    return name !== void 0 && code.includes(`\${${name}}`);
+  });
+};
 var typeErrorRecoveryHint = (code, errors) => {
+  for (const error of errors) {
+    const property = UNKNOWN_PROPERTY_PATTERN.exec(error.message)?.[1];
+    const typeText = UNKNOWN_PROPERTY_PATTERN.exec(error.message)?.[2];
+    if (property !== void 0 && typeText !== void 0) {
+      const tool = toolFromTypeText(typeText) ?? enclosingCoreTool(code, error);
+      const hint = unknownPropertyHint(property, tool);
+      if (hint) return hint;
+    }
+  }
+  if (PROMISE_ALL_PATTERN.test(code) && errors.some((error) => TUPLE_ARITY_PATTERN.test(error.message))) {
+    return "Recovery hint: match `Promise.all` destructuring one binding per promise; remove the extra binding or add the missing call.";
+  }
+  if (hasLiteralPayloadInterpolation(code, errors)) {
+    return "Recovery hint: a `${...}` expression in an edit/write payload is being evaluated by the Fabric TypeScript program. Declare it if intentional; for literal file content, move the payload to top-level `strings` and reference `\u03C0.key`.";
+  }
   if (!PAYLOAD_CALL_PATTERN.test(code)) return void 0;
   if (!errors.some((error) => SYNTAX_ERROR_PATTERN.test(error.message))) {
     return void 0;
@@ -3551,7 +3691,7 @@ var FabricState = class {
     return activation;
   }
   async #createRuntime() {
-    const module = await (this.#options.runtimeLoader?.() ?? import("./chunks/fabric-runtime-state-FDTVRRCU.js"));
+    const module = await (this.#options.runtimeLoader?.() ?? import("./chunks/fabric-runtime-state-LG265P3R.js"));
     return new module.FabricRuntimeState(
       this.pi,
       this.capturedTools,