lua-cli 3.32.2 → 3.32.3

package/dist/workflow-builder.js

@@ -1709,6 +1709,79 @@ var WORKFLOW_RETRY_BACKOFFS = [
   "fixed",
   "exponential"
 ];
+var WORKFLOW_RETRY_MIN_ATTEMPTS = 1;
+var WORKFLOW_RETRY_POLICY_KEYS = [
+  "maxAttempts",
+  "backoffSeconds",
+  "backoff",
+  "maxBackoffSeconds"
+];
+var WORKFLOW_RETRY_MAX_ATTEMPTS = 20;
+function workflowRetryMaxAttemptsMessage(got) {
+  const tail = got === void 0 ? "" : ` (got ${JSON.stringify(got)})`;
+  return `\`retry.maxAttempts\` must be an integer ${WORKFLOW_RETRY_MIN_ATTEMPTS}..${WORKFLOW_RETRY_MAX_ATTEMPTS}${tail}`;
+}
+__name(workflowRetryMaxAttemptsMessage, "workflowRetryMaxAttemptsMessage");
+__name2(workflowRetryMaxAttemptsMessage, "workflowRetryMaxAttemptsMessage");
+function isWithinWorkflowRetryAttempts(value3) {
+  return typeof value3 === "number" && Number.isInteger(value3) && value3 >= WORKFLOW_RETRY_MIN_ATTEMPTS && value3 <= WORKFLOW_RETRY_MAX_ATTEMPTS;
+}
+__name(isWithinWorkflowRetryAttempts, "isWithinWorkflowRetryAttempts");
+__name2(isWithinWorkflowRetryAttempts, "isWithinWorkflowRetryAttempts");
+var WORKFLOW_RETRY_ENGINE_KEYS = [
+  "budgetBaseAttempt"
+];
+function workflowRetryUnknownMembersMessage(keys) {
+  const named = keys.map((k) => {
+    const engine = WORKFLOW_RETRY_ENGINE_KEYS.includes(k);
+    return `\`${k}\`${engine ? " (engine-owned \u2014 stamped by resetAttempts, never authored)" : ""}`;
+  });
+  return `\`retry\` has no member ${named.join(", ")}; members: ${WORKFLOW_RETRY_POLICY_KEYS.join(", ")}`;
+}
+__name(workflowRetryUnknownMembersMessage, "workflowRetryUnknownMembersMessage");
+__name2(workflowRetryUnknownMembersMessage, "workflowRetryUnknownMembersMessage");
+function unknownWorkflowRetryMembers(retry) {
+  if (!retry || typeof retry !== "object" || Array.isArray(retry)) return [];
+  return Object.keys(retry).filter((k) => !WORKFLOW_RETRY_POLICY_KEYS.includes(k));
+}
+__name(unknownWorkflowRetryMembers, "unknownWorkflowRetryMembers");
+__name2(unknownWorkflowRetryMembers, "unknownWorkflowRetryMembers");
+function authoredRetryPolicy(retry) {
+  if (!retry || typeof retry !== "object" || Array.isArray(retry)) return void 0;
+  const src = retry;
+  const out = {};
+  for (const k of WORKFLOW_RETRY_POLICY_KEYS) if (src[k] !== void 0) out[k] = src[k];
+  return Object.keys(out).length ? out : void 0;
+}
+__name(authoredRetryPolicy, "authoredRetryPolicy");
+__name2(authoredRetryPolicy, "authoredRetryPolicy");
+function retryBudgetBaseAttempt(row) {
+  const base = row.retry?.budgetBaseAttempt;
+  return typeof base === "number" && Number.isSafeInteger(base) && base > 0 ? base : 0;
+}
+__name(retryBudgetBaseAttempt, "retryBudgetBaseAttempt");
+__name2(retryBudgetBaseAttempt, "retryBudgetBaseAttempt");
+function retryBudgetAttempt(row) {
+  return Math.max(0, row.attempt - retryBudgetBaseAttempt(row));
+}
+__name(retryBudgetAttempt, "retryBudgetAttempt");
+__name2(retryBudgetAttempt, "retryBudgetAttempt");
+function retryBudgetMaxAttempts(row) {
+  const max = row.retry?.maxAttempts;
+  return typeof max === "number" && Number.isFinite(max) && max >= 1 ? max : 1;
+}
+__name(retryBudgetMaxAttempts, "retryBudgetMaxAttempts");
+__name2(retryBudgetMaxAttempts, "retryBudgetMaxAttempts");
+function retryBudgetRemaining(row) {
+  return retryBudgetAttempt(row) < retryBudgetMaxAttempts(row);
+}
+__name(retryBudgetRemaining, "retryBudgetRemaining");
+__name2(retryBudgetRemaining, "retryBudgetRemaining");
+function retriesRemaining(row) {
+  return Math.max(0, retryBudgetMaxAttempts(row) - retryBudgetAttempt(row));
+}
+__name(retriesRemaining, "retriesRemaining");
+__name2(retriesRemaining, "retriesRemaining");
 var WORKFLOW_JOB_RESOURCES = [
   "small",
   "medium",
@@ -2074,6 +2147,8 @@ var WORKFLOW_AUDIT_EVENTS = [
   "workflow.goal.resumed",
   "workflow.goal.done",
   "workflow.goal.closed",
+  // LUA-760: an ended goal's cadence Job retired (deleted) — inline on done / closed, by R21 / R28, or by sweep #30
+  "workflow.goal.job_retired",
   // --- org policy (02 §2.10 / 09 R23) ---
   "workflow.policy.retention_changed",
   "workflow.policy.pacing_changed",
@@ -2217,6 +2292,138 @@ ${items.join("\n\n")}`;
 }
 __name(renderTargetsBlock, "renderTargetsBlock");
 __name2(renderTargetsBlock, "renderTargetsBlock");
+var WORKFLOW_APPROVAL_OUTPUT_DECISIONS = [
+  "approved",
+  "denied",
+  "timed_out"
+];
+var WORKFLOW_APPROVAL_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    approved: {
+      type: "boolean"
+    },
+    decision: {
+      type: "string",
+      enum: [
+        ...WORKFLOW_APPROVAL_OUTPUT_DECISIONS
+      ]
+    },
+    /** the approver's note when given, else the decision word — what `${stepResults.<id>.text}` reads */
+    text: {
+      type: "string"
+    },
+    note: {
+      type: "string"
+    },
+    editedPayload: {},
+    editRevision: {
+      type: "integer"
+    },
+    decidedBy: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string"
+        },
+        kind: {
+          type: "string"
+        }
+      }
+    },
+    timedOut: {
+      type: "boolean"
+    },
+    escalations: {
+      type: "integer"
+    },
+    evidence: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    items: {
+      type: "array",
+      items: {
+        type: "object"
+      }
+    }
+  },
+  required: [
+    "approved",
+    "decision",
+    "text"
+  ]
+};
+function workflowApprovalDecisionOf(resumeData) {
+  if (resumeData.timedOut === true) return "timed_out";
+  return resumeData.approved === true ? "approved" : "denied";
+}
+__name(workflowApprovalDecisionOf, "workflowApprovalDecisionOf");
+__name2(workflowApprovalDecisionOf, "workflowApprovalDecisionOf");
+function workflowApprovalOutput(resumeData) {
+  const decision = typeof resumeData.decision === "string" ? resumeData.decision : workflowApprovalDecisionOf(resumeData);
+  const note = typeof resumeData.note === "string" && resumeData.note.trim() !== "" ? resumeData.note : void 0;
+  const text = typeof resumeData.text === "string" ? resumeData.text : note ?? decision;
+  return {
+    ...resumeData,
+    decision,
+    text
+  };
+}
+__name(workflowApprovalOutput, "workflowApprovalOutput");
+__name2(workflowApprovalOutput, "workflowApprovalOutput");
+function isWorkflowApprovalOutput(value3) {
+  if (typeof value3 !== "object" || value3 === null || Array.isArray(value3)) return false;
+  const v = value3;
+  return typeof v.approved === "boolean" && WORKFLOW_APPROVAL_OUTPUT_DECISIONS.includes(v.decision) && typeof v.text === "string";
+}
+__name(isWorkflowApprovalOutput, "isWorkflowApprovalOutput");
+__name2(isWorkflowApprovalOutput, "isWorkflowApprovalOutput");
+var JSON_FENCE_RE = /```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?```/g;
+function extractSingleJsonValue(text) {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return {
+    reason: "reply is empty"
+  };
+  const fenced = [
+    ...trimmed.matchAll(JSON_FENCE_RE)
+  ];
+  if (fenced.length > 1) return {
+    reason: "reply carries more than one fenced block"
+  };
+  const candidate = fenced.length === 1 ? fenced[0][1].trim() : trimmed;
+  try {
+    return {
+      value: JSON.parse(candidate)
+    };
+  } catch {
+    if (fenced.length === 1) return {
+      reason: "fenced block is not valid JSON"
+    };
+  }
+  const opens = [
+    trimmed.indexOf("{"),
+    trimmed.indexOf("[")
+  ].filter((i) => i !== -1);
+  const start = opens.length ? Math.min(...opens) : -1;
+  const end = Math.max(trimmed.lastIndexOf("}"), trimmed.lastIndexOf("]"));
+  if (start === -1 || end <= start) return {
+    reason: "reply is not JSON"
+  };
+  try {
+    return {
+      value: JSON.parse(trimmed.slice(start, end + 1))
+    };
+  } catch {
+    return {
+      reason: "reply does not contain a single JSON value"
+    };
+  }
+}
+__name(extractSingleJsonValue, "extractSingleJsonValue");
+__name2(extractSingleJsonValue, "extractSingleJsonValue");
 
 // ../workflow-graph/dist/index.mjs
 import { createHash } from "crypto";
@@ -2225,6 +2432,296 @@ import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
 var __defProp3 = Object.defineProperty;
 var __name3 = /* @__PURE__ */ __name((target, value22) => __defProp3(target, "name", { value: value22, configurable: true }), "__name");
+var WorkflowTemplateError = class extends Error {
+  static {
+    __name(this, "WorkflowTemplateError");
+  }
+  static {
+    __name3(this, "WorkflowTemplateError");
+  }
+  placeholder;
+  constructor(message, placeholder) {
+    super(message), this.placeholder = placeholder;
+    this.name = "WorkflowTemplateError";
+  }
+};
+function isMapConfigObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+__name(isMapConfigObject, "isMapConfigObject");
+__name3(isMapConfigObject, "isMapConfigObject");
+function parseMapConfig(raw, stepId) {
+  if (isMapConfigObject(raw)) return raw;
+  if (typeof raw !== "string") {
+    throw new Error(`Stored mapping step "${stepId}" has a mapConfig that is neither a JSON string nor an object.`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Stored mapping step "${stepId}" has invalid JSON mapConfig: ${e.message}`);
+  }
+}
+__name(parseMapConfig, "parseMapConfig");
+__name3(parseMapConfig, "parseMapConfig");
+function mapConfigWire(raw) {
+  if (typeof raw === "string") return raw;
+  if (isMapConfigObject(raw)) return canonicalJson(raw);
+  return void 0;
+}
+__name(mapConfigWire, "mapConfigWire");
+__name3(mapConfigWire, "mapConfigWire");
+var TEMPLATE_PLACEHOLDER = /\$\{([^}]*)\}/g;
+var TEMPLATE_NAMESPACES = [
+  "initData",
+  "state",
+  "requestContext",
+  "stepResults"
+];
+function describeBadPlaceholder(template22, idx, rawExpr) {
+  return `Template placeholder #${idx} (\${${rawExpr}}) in '${template22}'`;
+}
+__name(describeBadPlaceholder, "describeBadPlaceholder");
+__name3(describeBadPlaceholder, "describeBadPlaceholder");
+function parseTemplatePlaceholder(rawExpr) {
+  const dot = rawExpr.indexOf(".");
+  return {
+    scope: dot === -1 ? rawExpr : rawExpr.slice(0, dot),
+    rest: dot === -1 ? "" : rawExpr.slice(dot + 1)
+  };
+}
+__name(parseTemplatePlaceholder, "parseTemplatePlaceholder");
+__name3(parseTemplatePlaceholder, "parseTemplatePlaceholder");
+function traverseMappingPath(root, path, errorLabel) {
+  if (path === "" || path === ".") return root;
+  const parts = path.split(".");
+  let value22 = root;
+  for (const part of parts) {
+    if (typeof value22 === "object" && value22 !== null) value22 = value22[part];
+    else throw new WorkflowTemplateError(`Invalid path ${path} in ${errorLabel}`, path);
+  }
+  return value22;
+}
+__name(traverseMappingPath, "traverseMappingPath");
+__name3(traverseMappingPath, "traverseMappingPath");
+function stringifyTemplateValue(v, template22, idx, rawExpr) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "object") {
+    try {
+      return JSON.stringify(v);
+    } catch (err) {
+      throw new WorkflowTemplateError(`${describeBadPlaceholder(template22, idx, rawExpr)} resolved to a value that could not be JSON-stringified (${err.message}).`, rawExpr);
+    }
+  }
+  return String(v);
+}
+__name(stringifyTemplateValue, "stringifyTemplateValue");
+__name3(stringifyTemplateValue, "stringifyTemplateValue");
+function escapeFence(content) {
+  return content.replace(/<\/lua-data/g, "<\\/lua-data");
+}
+__name(escapeFence, "escapeFence");
+__name3(escapeFence, "escapeFence");
+function fenceBlock(name, source, content) {
+  return `<lua-data name="${name}" source="${source}" untrusted="true">${escapeFence(content)}</lua-data>`;
+}
+__name(fenceBlock, "fenceBlock");
+__name3(fenceBlock, "fenceBlock");
+function renderTemplate(template22, ctx, opts) {
+  let idx = 0;
+  return template22.replace(TEMPLATE_PLACEHOLDER, (_match, rawExpr) => {
+    idx += 1;
+    const { scope, rest } = parseTemplatePlaceholder(rawExpr);
+    const label = describeBadPlaceholder(template22, idx, rawExpr);
+    let rendered;
+    let source;
+    switch (scope) {
+      case "initData":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.initData, rest, label), template22, idx, rawExpr);
+        source = "initData";
+        break;
+      case "state":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.state, rest, label), template22, idx, rawExpr);
+        source = "state";
+        break;
+      case "requestContext":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.requestContext, rest, label), template22, idx, rawExpr);
+        source = "requestContext";
+        break;
+      case "stepResults": {
+        const innerDot = rest.indexOf(".");
+        const stepId = innerDot === -1 ? rest : rest.slice(0, innerDot);
+        const subPath = innerDot === -1 ? "" : rest.slice(innerDot + 1);
+        if (!stepId) throw new WorkflowTemplateError(`${label} must name a step: \${stepResults.<stepId>.<path>}.`, rawExpr);
+        if (!(stepId in ctx.stepResults) || ctx.stepResults[stepId] == null) {
+          throw new WorkflowTemplateError(`${label} references stepResults.${stepId} but step "${stepId}" has no resolvable output (not an ancestor, not run, failed, or produced no output).`, rawExpr);
+        }
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.stepResults[stepId], subPath, label), template22, idx, rawExpr);
+        source = `step:${stepId}`;
+        break;
+      }
+      default:
+        throw new WorkflowTemplateError(`${label} references unknown namespace "${scope}". Use one of: ${TEMPLATE_NAMESPACES.join(", ")}.`, rawExpr);
+    }
+    return opts.fenced ? fenceBlock(rawExpr, source, rendered) : rendered;
+  });
+}
+__name(renderTemplate, "renderTemplate");
+__name3(renderTemplate, "renderTemplate");
+function isMapDescriptor(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const d = v;
+  const keys = Object.keys(d);
+  const only = /* @__PURE__ */ __name3((...allowed) => keys.every((k) => allowed.includes(k)), "only");
+  if ("value" in d) return keys.length === 1;
+  if ("template" in d) return keys.length === 1 && typeof d.template === "string";
+  if ("requestContextPath" in d) return keys.length === 1 && typeof d.requestContextPath === "string";
+  if ("knowledge" in d) return keys.length === 1 && typeof d.knowledge === "object" && d.knowledge !== null;
+  if ("initData" in d) return d.initData === true && typeof d.path === "string" && only("initData", "path");
+  if ("step" in d) {
+    const stepOk = typeof d.step === "string" || Array.isArray(d.step) && d.step.every((x) => typeof x === "string");
+    return stepOk && typeof d.path === "string" && only("step", "path", "rows");
+  }
+  return false;
+}
+__name(isMapDescriptor, "isMapDescriptor");
+__name3(isMapDescriptor, "isMapDescriptor");
+var MAP_DESCRIPTOR_KEYS = [
+  "step",
+  "path",
+  "initData",
+  "value",
+  "template",
+  "requestContextPath",
+  "knowledge"
+];
+var MAP_MEMBER_MALFORMED_CODE = "map-member-malformed";
+function malformedMapMembers(cfg) {
+  if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) return [];
+  const out = [];
+  for (const [member, v] of Object.entries(cfg)) {
+    if (!v || typeof v !== "object" || Array.isArray(v) || isMapDescriptor(v)) continue;
+    const keys = Object.keys(v).filter((k) => MAP_DESCRIPTOR_KEYS.includes(k));
+    if (keys.length > 0) out.push({
+      member,
+      keys
+    });
+  }
+  return out;
+}
+__name(malformedMapMembers, "malformedMapMembers");
+__name3(malformedMapMembers, "malformedMapMembers");
+function mapMemberMalformedMessage(id, m) {
+  const keys = m.keys.map((k) => `\`${k}\``).join(", ");
+  return `"${id}".${m.member} carries descriptor key${m.keys.length === 1 ? "" : "s"} ${keys} but is not an exact binding form ({initData:true, path} | {step, path[, rows]} | {value} | {template} | {requestContextPath} | {knowledge}) \u2014 it is passed to the step verbatim as a literal; fix the descriptor, or wrap it in {value: \u2026} if the literal is intended`;
+}
+__name(mapMemberMalformedMessage, "mapMemberMalformedMessage");
+__name3(mapMemberMalformedMessage, "mapMemberMalformedMessage");
+function resolveDescriptor(key, m, ctx) {
+  if (!isMapDescriptor(m)) return {
+    value: m
+  };
+  try {
+    if ("value" in m) return {
+      value: m.value
+    };
+    if ("template" in m && typeof m.template === "string") {
+      return {
+        value: renderTemplate(m.template, ctx, {
+          fenced: false
+        })
+      };
+    }
+    if ("knowledge" in m || "rows" in m && m.rows !== void 0) {
+      return {
+        error: "binding_unresolved",
+        key
+      };
+    }
+    if ("requestContextPath" in m) {
+      const label = `requestContext path for key "${key}"`;
+      return {
+        value: traverseMappingPath(ctx.requestContext, m.requestContextPath, label)
+      };
+    }
+    if ("path" in m) {
+      const source = "initData" in m && m.initData ? "initData" : "step";
+      if (source === "initData") {
+        return {
+          value: traverseMappingPath(ctx.initData, m.path, `initData for key "${key}"`)
+        };
+      }
+      const stepRef = m.step;
+      const candidates = Array.isArray(stepRef) ? stepRef : [
+        stepRef
+      ];
+      const stepId = candidates.find((s) => ctx.stepResults[s] !== void 0 && ctx.stepResults[s] !== null);
+      if (stepId === void 0) return {
+        error: "binding_unresolved",
+        key
+      };
+      return {
+        value: traverseMappingPath(ctx.stepResults[stepId], m.path, `step ${candidates.join("|")} for key "${key}"`)
+      };
+    }
+    return {
+      error: "binding_unresolved",
+      key
+    };
+  } catch (err) {
+    if (err instanceof WorkflowTemplateError) return {
+      error: "binding_unresolved",
+      key
+    };
+    throw err;
+  }
+}
+__name(resolveDescriptor, "resolveDescriptor");
+__name3(resolveDescriptor, "resolveDescriptor");
+function resolveMapping(cfg, ctx) {
+  const keys = Object.keys(cfg);
+  if (keys.length === 1 && keys[0] === "") {
+    return resolveDescriptor("", cfg[""], ctx);
+  }
+  const result = {};
+  for (const key of keys) {
+    const resolved = resolveDescriptor(key, cfg[key], ctx);
+    if ("error" in resolved) return resolved;
+    result[key] = resolved.value;
+  }
+  return {
+    value: result
+  };
+}
+__name(resolveMapping, "resolveMapping");
+__name3(resolveMapping, "resolveMapping");
+var fromInit = /* @__PURE__ */ __name3((path) => ({
+  initData: true,
+  path
+}), "fromInit");
+var fromStep = /* @__PURE__ */ __name3((s, path = "") => {
+  const idOf = /* @__PURE__ */ __name3((x) => typeof x === "string" ? x : x.id, "idOf");
+  return {
+    step: Array.isArray(s) ? s.map(idOf) : idOf(s),
+    path
+  };
+}, "fromStep");
+var value = /* @__PURE__ */ __name3((v) => ({
+  value: v
+}), "value");
+var template = /* @__PURE__ */ __name3((s) => ({
+  template: s
+}), "template");
+var fromRequest = /* @__PURE__ */ __name3((path) => ({
+  requestContextPath: path
+}), "fromRequest");
+var rows = /* @__PURE__ */ __name3((s, path, page) => ({
+  step: typeof s === "string" ? s : s.id,
+  path,
+  rows: page
+}), "rows");
+var fromKnowledge = /* @__PURE__ */ __name3((k) => ({
+  knowledge: k
+}), "fromKnowledge");
 var SideEffectsSchema = z4.enum(WORKFLOW_SIDE_EFFECTS);
 var JobResourcesSchema = z4.enum(WORKFLOW_JOB_RESOURCES);
 var WORKFLOW_ARM_SUBRUN_ID = "$arm";
@@ -2482,12 +2979,11 @@ function mapConfigStepRefs(raw) {
   if (!cfg) return [];
   const ids = [];
   for (const d of Object.values(cfg)) {
-    if (!d || typeof d !== "object") continue;
-    const desc = d;
-    if (desc.step !== void 0) ids.push(...Array.isArray(desc.step) ? desc.step : [
-      desc.step
+    if (!isMapDescriptor(d)) continue;
+    if ("step" in d) ids.push(...Array.isArray(d.step) ? d.step : [
+      d.step
     ]);
-    if (typeof desc.template === "string") ids.push(...templateStepRefs(desc.template));
+    if ("template" in d) ids.push(...templateStepRefs(d.template));
   }
   return ids;
 }
@@ -2616,6 +3112,12 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     const r = node.retry;
     if (!r) return;
     const id = singleId(node);
+    const unknown = unknownWorkflowRetryMembers(r);
+    if (unknown.length) err("invalid-envelope", workflowRetryUnknownMembersMessage(unknown), `${path}.retry`, id);
+    if (r.maxAttempts !== void 0 && !isWithinWorkflowRetryAttempts(r.maxAttempts)) {
+      const over = typeof r.maxAttempts === "number" && r.maxAttempts > WORKFLOW_RETRY_MAX_ATTEMPTS;
+      err(over ? "cap-exceeded" : "invalid-envelope", workflowRetryMaxAttemptsMessage(r.maxAttempts), `${path}.retry.maxAttempts`, id);
+    }
     const backoffs = retryBackoffs();
     if (r.backoff !== void 0 && !backoffs.includes(r.backoff)) {
       const list = backoffs.map((b) => `'${b}'`).join(" | ");
@@ -2758,6 +3260,21 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     const schema = node.type === "step" ? node.step.outputSchema : node.type === "agent" ? node.outputSchema : void 0;
     if (schema !== void 0) outputSchemas.set(singleId(node), schema);
   }, "recordOutputSchema");
+  const checkMapMembers = /* @__PURE__ */ __name3((cfg, basePath, id) => {
+    for (const m of malformedMapMembers(cfg)) {
+      warn(MAP_MEMBER_MALFORMED_CODE, mapMemberMalformedMessage(id, m), `${basePath}.${m.member}`, id);
+    }
+  }, "checkMapMembers");
+  const checkInputShape = /* @__PURE__ */ __name3((node, path) => {
+    if (node.type !== "tool" && node.type !== "workflow") return;
+    const input = node.input;
+    if (input === void 0) return;
+    if (input !== null && typeof input === "object" && !Array.isArray(input)) {
+      checkMapMembers(input, `${path}.input`, node.id);
+      return;
+    }
+    err("invalid-envelope", `\`input\` must be an object map \u2014 each member a binding descriptor ({initData:true, path} | {step, path} | {value} | {template} | {requestContextPath}) or a JSON literal (got ${JSON.stringify(input)})`, `${path}.input`, node.id);
+  }, "checkInputShape");
   const checkSingle = /* @__PURE__ */ __name3((node, path, depth) => {
     recordOutputSchema(node);
     if (node.type === "workflow" && node.workflowId === WORKFLOW_ARM_SUBRUN_ID) {
@@ -2785,6 +3302,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     }
     checkId(singleId(node), path);
     checkPolicyEnums(node, path);
+    checkInputShape(node, path);
     checkTimeout(node, path);
     checkTier(node, path);
     checkRetry(node, path);
@@ -2865,6 +3383,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
   const checkArm = /* @__PURE__ */ __name3((arm, path, depth, container) => {
     if (arm.type === "mapping") {
       checkId(arm.id, path);
+      checkMapMembers(readMapConfig(arm.mapConfig), `${path}.mapConfig`, arm.id);
       for (const ref of nodeStepRefs(arm)) {
         if (!upstream.has(ref)) err("template-reference-unresolved", `"${arm.id}" references stepResults.${ref}, which is not upstream`, path, arm.id);
       }
@@ -2889,6 +3408,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         break;
       case "mapping":
         checkId(entry.id, path);
+        checkMapMembers(readMapConfig(entry.mapConfig), `${path}.mapConfig`, entry.id);
         for (const ref of nodeStepRefs(entry)) {
           if (!upstream.has(ref)) err("template-reference-unresolved", `"${entry.id}" references stepResults.${ref}, which is not upstream`, path, entry.id);
         }
@@ -3629,244 +4149,6 @@ var not = /* @__PURE__ */ __name3((arg) => ({
   op: "not",
   arg
 }), "not");
-var WorkflowTemplateError = class extends Error {
-  static {
-    __name(this, "WorkflowTemplateError");
-  }
-  static {
-    __name3(this, "WorkflowTemplateError");
-  }
-  placeholder;
-  constructor(message, placeholder) {
-    super(message), this.placeholder = placeholder;
-    this.name = "WorkflowTemplateError";
-  }
-};
-function isMapConfigObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-__name(isMapConfigObject, "isMapConfigObject");
-__name3(isMapConfigObject, "isMapConfigObject");
-function parseMapConfig(raw, stepId) {
-  if (isMapConfigObject(raw)) return raw;
-  if (typeof raw !== "string") {
-    throw new Error(`Stored mapping step "${stepId}" has a mapConfig that is neither a JSON string nor an object.`);
-  }
-  try {
-    return JSON.parse(raw);
-  } catch (e) {
-    throw new Error(`Stored mapping step "${stepId}" has invalid JSON mapConfig: ${e.message}`);
-  }
-}
-__name(parseMapConfig, "parseMapConfig");
-__name3(parseMapConfig, "parseMapConfig");
-function mapConfigWire(raw) {
-  if (typeof raw === "string") return raw;
-  if (isMapConfigObject(raw)) return canonicalJson(raw);
-  return void 0;
-}
-__name(mapConfigWire, "mapConfigWire");
-__name3(mapConfigWire, "mapConfigWire");
-var TEMPLATE_PLACEHOLDER = /\$\{([^}]*)\}/g;
-var TEMPLATE_NAMESPACES = [
-  "initData",
-  "state",
-  "requestContext",
-  "stepResults"
-];
-function describeBadPlaceholder(template22, idx, rawExpr) {
-  return `Template placeholder #${idx} (\${${rawExpr}}) in '${template22}'`;
-}
-__name(describeBadPlaceholder, "describeBadPlaceholder");
-__name3(describeBadPlaceholder, "describeBadPlaceholder");
-function parseTemplatePlaceholder(rawExpr) {
-  const dot = rawExpr.indexOf(".");
-  return {
-    scope: dot === -1 ? rawExpr : rawExpr.slice(0, dot),
-    rest: dot === -1 ? "" : rawExpr.slice(dot + 1)
-  };
-}
-__name(parseTemplatePlaceholder, "parseTemplatePlaceholder");
-__name3(parseTemplatePlaceholder, "parseTemplatePlaceholder");
-function traverseMappingPath(root, path, errorLabel) {
-  if (path === "" || path === ".") return root;
-  const parts = path.split(".");
-  let value22 = root;
-  for (const part of parts) {
-    if (typeof value22 === "object" && value22 !== null) value22 = value22[part];
-    else throw new WorkflowTemplateError(`Invalid path ${path} in ${errorLabel}`, path);
-  }
-  return value22;
-}
-__name(traverseMappingPath, "traverseMappingPath");
-__name3(traverseMappingPath, "traverseMappingPath");
-function stringifyTemplateValue(v, template22, idx, rawExpr) {
-  if (v === null || v === void 0) return "";
-  if (typeof v === "object") {
-    try {
-      return JSON.stringify(v);
-    } catch (err) {
-      throw new WorkflowTemplateError(`${describeBadPlaceholder(template22, idx, rawExpr)} resolved to a value that could not be JSON-stringified (${err.message}).`, rawExpr);
-    }
-  }
-  return String(v);
-}
-__name(stringifyTemplateValue, "stringifyTemplateValue");
-__name3(stringifyTemplateValue, "stringifyTemplateValue");
-function escapeFence(content) {
-  return content.replace(/<\/lua-data/g, "<\\/lua-data");
-}
-__name(escapeFence, "escapeFence");
-__name3(escapeFence, "escapeFence");
-function fenceBlock(name, source, content) {
-  return `<lua-data name="${name}" source="${source}" untrusted="true">${escapeFence(content)}</lua-data>`;
-}
-__name(fenceBlock, "fenceBlock");
-__name3(fenceBlock, "fenceBlock");
-function renderTemplate(template22, ctx, opts) {
-  let idx = 0;
-  return template22.replace(TEMPLATE_PLACEHOLDER, (_match, rawExpr) => {
-    idx += 1;
-    const { scope, rest } = parseTemplatePlaceholder(rawExpr);
-    const label = describeBadPlaceholder(template22, idx, rawExpr);
-    let rendered;
-    let source;
-    switch (scope) {
-      case "initData":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.initData, rest, label), template22, idx, rawExpr);
-        source = "initData";
-        break;
-      case "state":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.state, rest, label), template22, idx, rawExpr);
-        source = "state";
-        break;
-      case "requestContext":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.requestContext, rest, label), template22, idx, rawExpr);
-        source = "requestContext";
-        break;
-      case "stepResults": {
-        const innerDot = rest.indexOf(".");
-        const stepId = innerDot === -1 ? rest : rest.slice(0, innerDot);
-        const subPath = innerDot === -1 ? "" : rest.slice(innerDot + 1);
-        if (!stepId) throw new WorkflowTemplateError(`${label} must name a step: \${stepResults.<stepId>.<path>}.`, rawExpr);
-        if (!(stepId in ctx.stepResults) || ctx.stepResults[stepId] == null) {
-          throw new WorkflowTemplateError(`${label} references stepResults.${stepId} but step "${stepId}" has no resolvable output (not an ancestor, not run, failed, or produced no output).`, rawExpr);
-        }
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.stepResults[stepId], subPath, label), template22, idx, rawExpr);
-        source = `step:${stepId}`;
-        break;
-      }
-      default:
-        throw new WorkflowTemplateError(`${label} references unknown namespace "${scope}". Use one of: ${TEMPLATE_NAMESPACES.join(", ")}.`, rawExpr);
-    }
-    return opts.fenced ? fenceBlock(rawExpr, source, rendered) : rendered;
-  });
-}
-__name(renderTemplate, "renderTemplate");
-__name3(renderTemplate, "renderTemplate");
-function resolveDescriptor(key, m, ctx) {
-  try {
-    if ("value" in m) return {
-      value: m.value
-    };
-    if ("template" in m && typeof m.template === "string") {
-      return {
-        value: renderTemplate(m.template, ctx, {
-          fenced: false
-        })
-      };
-    }
-    if ("knowledge" in m || "rows" in m && m.rows !== void 0) {
-      return {
-        error: "binding_unresolved",
-        key
-      };
-    }
-    if ("requestContextPath" in m) {
-      const label = `requestContext path for key "${key}"`;
-      return {
-        value: traverseMappingPath(ctx.requestContext, m.requestContextPath, label)
-      };
-    }
-    if ("path" in m) {
-      const source = "initData" in m && m.initData ? "initData" : "step";
-      if (source === "initData") {
-        return {
-          value: traverseMappingPath(ctx.initData, m.path, `initData for key "${key}"`)
-        };
-      }
-      const stepRef = m.step;
-      const candidates = Array.isArray(stepRef) ? stepRef : [
-        stepRef
-      ];
-      const stepId = candidates.find((s) => ctx.stepResults[s] !== void 0 && ctx.stepResults[s] !== null);
-      if (stepId === void 0) return {
-        error: "binding_unresolved",
-        key
-      };
-      return {
-        value: traverseMappingPath(ctx.stepResults[stepId], m.path, `step ${candidates.join("|")} for key "${key}"`)
-      };
-    }
-    return {
-      error: "binding_unresolved",
-      key
-    };
-  } catch (err) {
-    if (err instanceof WorkflowTemplateError) return {
-      error: "binding_unresolved",
-      key
-    };
-    throw err;
-  }
-}
-__name(resolveDescriptor, "resolveDescriptor");
-__name3(resolveDescriptor, "resolveDescriptor");
-function resolveMapping(cfg, ctx) {
-  const keys = Object.keys(cfg);
-  if (keys.length === 1 && keys[0] === "") {
-    return resolveDescriptor("", cfg[""], ctx);
-  }
-  const result = {};
-  for (const key of keys) {
-    const resolved = resolveDescriptor(key, cfg[key], ctx);
-    if ("error" in resolved) return resolved;
-    result[key] = resolved.value;
-  }
-  return {
-    value: result
-  };
-}
-__name(resolveMapping, "resolveMapping");
-__name3(resolveMapping, "resolveMapping");
-var fromInit = /* @__PURE__ */ __name3((path) => ({
-  initData: true,
-  path
-}), "fromInit");
-var fromStep = /* @__PURE__ */ __name3((s, path = "") => {
-  const idOf = /* @__PURE__ */ __name3((x) => typeof x === "string" ? x : x.id, "idOf");
-  return {
-    step: Array.isArray(s) ? s.map(idOf) : idOf(s),
-    path
-  };
-}, "fromStep");
-var value = /* @__PURE__ */ __name3((v) => ({
-  value: v
-}), "value");
-var template = /* @__PURE__ */ __name3((s) => ({
-  template: s
-}), "template");
-var fromRequest = /* @__PURE__ */ __name3((path) => ({
-  requestContextPath: path
-}), "fromRequest");
-var rows = /* @__PURE__ */ __name3((s, path, page) => ({
-  step: typeof s === "string" ? s : s.id,
-  path,
-  rows: page
-}), "rows");
-var fromKnowledge = /* @__PURE__ */ __name3((k) => ({
-  knowledge: k
-}), "fromKnowledge");
 var CONTINUED_FAILURE_TAG = "continued_failure";
 var CONTINUED_FAILURE_DEFAULT_CODE = "step_failed";
 var CONTINUED_FAILURE_OUTPUT_SCHEMA = Object.freeze({
@@ -4626,10 +4908,57 @@ function runCounts(counts) {
 }
 __name(runCounts, "runCounts");
 __name3(runCounts, "runCounts");
-function runUsage(run) {
+function isPricedStepReceipt(receipt) {
+  return typeof receipt?.multiplier === "number" && Number.isFinite(receipt.multiplier);
+}
+__name(isPricedStepReceipt, "isPricedStepReceipt");
+__name3(isPricedStepReceipt, "isPricedStepReceipt");
+function receiptEngine(engine) {
+  if (engine === "actions") return "seat";
+  if (engine === "credits") return "legacy";
+  return void 0;
+}
+__name(receiptEngine, "receiptEngine");
+__name3(receiptEngine, "receiptEngine");
+function receiptTier(tier) {
+  return tier === "light" || tier === "standard" || tier === "heavy" ? tier : void 0;
+}
+__name(receiptTier, "receiptTier");
+__name3(receiptTier, "receiptTier");
+function stepBillingView(receipt) {
+  const engine = receiptEngine(receipt?.engine);
+  if (!receipt || engine === void 0) return void 0;
+  return pruneUndefined({
+    engine,
+    attempt: typeof receipt.attempt === "number" ? receipt.attempt : void 0,
+    credits: typeof receipt.credits === "number" ? receipt.credits : void 0,
+    actions: typeof receipt.actionsEstimate === "number" ? receipt.actionsEstimate : void 0,
+    model: typeof receipt.model === "string" ? receipt.model : void 0,
+    tier: receiptTier(receipt.tier),
+    multiplier: typeof receipt.multiplier === "number" ? receipt.multiplier : void 0,
+    byok: typeof receipt.byok === "boolean" ? receipt.byok : void 0,
+    calibrated: typeof receipt.calibrated === "boolean" ? receipt.calibrated : void 0
+  });
+}
+__name(stepBillingView, "stepBillingView");
+__name3(stepBillingView, "stepBillingView");
+function runUsage(run, receipts) {
+  const actions = n(run.budget?.spent?.actionsEstimate);
+  const stamped = run.budget?.engine;
+  const priced = (receipts ?? []).filter(isPricedStepReceipt);
+  const engine = stamped === "seat" || stamped === "legacy" ? stamped : actions > 0 || priced.some((r) => r.engine === "actions") ? "seat" : priced.some((r) => r.engine === "credits") ? "legacy" : void 0;
+  const seat = engine === "seat";
+  const metering = engine ? "priced" : "flat";
   return {
     creditsUsed: run.budget?.spent?.credits ?? 0,
     actionsEstimate: run.budget?.spent?.actionsEstimate ?? 0,
+    ...seat ? {
+      actionsUsed: actions
+    } : {},
+    metering,
+    ...engine ? {
+      engine
+    } : {},
     steps: run.budget?.spent?.steps ?? 0,
     inputTokens: run.usage?.inputTokens ?? 0,
     outputTokens: run.usage?.outputTokens ?? 0
@@ -4637,6 +4966,20 @@ function runUsage(run) {
 }
 __name(runUsage, "runUsage");
 __name3(runUsage, "runUsage");
+function runBudgetCap(budget) {
+  const cap = budget?.maxCredits;
+  return typeof cap === "number" && Number.isFinite(cap) && cap > 0 ? cap : void 0;
+}
+__name(runBudgetCap, "runBudgetCap");
+__name3(runBudgetCap, "runBudgetCap");
+function runBudgetRemaining(budget) {
+  const cap = runBudgetCap(budget);
+  if (cap === void 0) return void 0;
+  const spent = budget?.spent;
+  return Math.max(0, cap - n(spent?.credits) - n(spent?.actionsEstimate) - n(budget?.reserved));
+}
+__name(runBudgetRemaining, "runBudgetRemaining");
+__name3(runBudgetRemaining, "runBudgetRemaining");
 function runCancelView(cancel) {
   if (!cancel) return void 0;
   return {
@@ -6021,6 +6364,7 @@ var assertPredicate = /* @__PURE__ */ __name((p, where) => {
 }, "assertPredicate");
 var assertRetry = /* @__PURE__ */ __name((r, id) => {
   if (!r) return;
+  if (typeof r.maxAttempts === "number" && r.maxAttempts > WORKFLOW_RETRY_MAX_ATTEMPTS) throw new LuaWorkflowBuildError("cap-exceeded", `"${id}": ${workflowRetryMaxAttemptsMessage(r.maxAttempts)}`);
   if (r.backoff !== void 0 && !WORKFLOW_RETRY_BACKOFFS.includes(r.backoff)) throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.backoff must be ${WORKFLOW_RETRY_BACKOFFS.map((b) => `'${b}'`).join(" | ")}`);
   if (r.maxBackoffSeconds !== void 0) {
     if (r.backoff !== "exponential") throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.maxBackoffSeconds is only meaningful with backoff:'exponential'`);