@pipelex/mthds-ui 0.27.0 → 0.29.0

package/dist/static-graph/index.js

@@ -3,9 +3,11 @@ import {
   parsePipeRef
 } from "../chunk-2N65P32H.js";
 import {
+  BINDING_STEP_TYPE,
   KNOWN_PIPE_TYPES,
+  isBindingStepSpec,
   isPluralMultiplicity
-} from "../chunk-VCO4GZDZ.js";
+} from "../chunk-3I3ZPYMW.js";
 import {
   __spreadProps,
   __spreadValues
@@ -33,28 +35,117 @@ function boolOrNull(value) {
 
 // src/static-graph/conceptRefs.ts
 var NATIVE_DOMAIN = "native";
-var NATIVE_CONCEPT_DESCRIPTIONS = {
-  Dynamic: "A dynamic concept",
-  Text: "A text",
-  Image: "An image",
-  Document: "A document",
-  Html: "HTML content",
-  TextAndImages: "A text and an image",
-  Number: "A number",
-  YesNo: "The answer to a yes/no question",
-  Date: "A calendar date, optionally with a time of day \u2014 as precise as its source states.",
-  Time: "A time of day, optionally with a UTC offset \u2014 as precise as its source states.",
-  Page: "The content of a page of a document, comprising text and linked images and an optional page view image",
-  JSON: "A JSON object",
-  SearchResult: "A search result with answer and sources",
-  Anything: "Anything",
-  Composite: "A named composition of contents"
+var field = (type) => ({
+  type,
+  conceptRef: null,
+  itemType: null,
+  itemConceptRef: null
+});
+var conceptField = (conceptRef) => ({
+  type: "concept",
+  conceptRef,
+  itemType: null,
+  itemConceptRef: null
+});
+var conceptListField = (itemConceptRef) => ({
+  type: "list",
+  conceptRef: null,
+  itemType: "concept",
+  itemConceptRef
+});
+var NATIVE_CONCEPTS = {
+  Dynamic: { description: "A dynamic concept", fields: null },
+  Text: { description: "A text", fields: { text: field("text") } },
+  Markdown: {
+    description: "A text written in Markdown",
+    refines: "native.Text",
+    fields: { text: field("text") }
+  },
+  Image: {
+    description: "An image",
+    fields: {
+      url: field("text"),
+      public_url: field("text"),
+      source_prompt: field("text"),
+      source_negative_prompt: field("text"),
+      caption: field("text"),
+      mime_type: field("text"),
+      width: field("integer"),
+      height: field("integer"),
+      filename: field("text")
+    }
+  },
+  Document: {
+    description: "A document",
+    fields: {
+      url: field("text"),
+      public_url: field("text"),
+      mime_type: field("text"),
+      filename: field("text"),
+      title: field("text"),
+      snippet: field("text")
+    }
+  },
+  Html: {
+    description: "HTML content",
+    fields: { inner_html: field("text"), css_class: field("text") }
+  },
+  TextAndImages: {
+    description: "A text and an image",
+    fields: {
+      text: conceptField("native.Text"),
+      images: conceptListField("native.Image"),
+      raw_html: field("text")
+    }
+  },
+  Number: { description: "A number", fields: { number: field("number") } },
+  YesNo: {
+    description: "The answer to a yes/no question",
+    fields: { yes_no: field("boolean"), probability: field("number") }
+  },
+  Choice: {
+    description: "One option picked out of a declared set",
+    fields: { choice: field("text"), confidence: field("number"), probabilities: field("dict") }
+  },
+  Rating: {
+    description: "A position on an ordered scale of described levels",
+    fields: {
+      level: field("integer"),
+      confidence: field("number"),
+      probabilities: field("dict"),
+      position: field("number")
+    }
+  },
+  Date: {
+    description: "A calendar date, optionally with a time of day \u2014 as precise as its source states.",
+    fields: { date: field("date"), time: field("time") }
+  },
+  Time: {
+    description: "A time of day, optionally with a UTC offset \u2014 as precise as its source states.",
+    fields: { time: field("time") }
+  },
+  Page: {
+    description: "The content of a page of a document, comprising text and linked images and an optional page view image",
+    fields: {
+      text_and_images: conceptField("native.TextAndImages"),
+      page_view: conceptField("native.Image")
+    }
+  },
+  JSON: { description: "A JSON object", fields: { json_obj: field("dict") } },
+  SearchResult: {
+    description: "A search result with answer and sources",
+    fields: { answer: field("text"), sources: conceptListField("native.Document") }
+  },
+  Anything: { description: "Anything", fields: null },
+  Composite: { description: "A named composition of contents", fields: null }
 };
-var NATIVE_CONCEPT_CODES = new Set(
-  Object.keys(NATIVE_CONCEPT_DESCRIPTIONS)
-);
+var NATIVE_CONCEPT_CODES = new Set(Object.keys(NATIVE_CONCEPTS));
 function isNativeConceptCode(code) {
-  return Object.hasOwn(NATIVE_CONCEPT_DESCRIPTIONS, code);
+  return Object.hasOwn(NATIVE_CONCEPTS, code);
+}
+function nativeConceptFields(code) {
+  const definition = NATIVE_CONCEPTS[code];
+  return definition.fields;
 }
 var CONCEPT_REF_RE = /^(?:([A-Za-z0-9_][A-Za-z0-9_.]*)\.)?([A-Za-z0-9_]+)(?:\[(\d*)\])?([?!])?$/;
 function presenceFromSymbol(symbol) {
@@ -76,40 +167,50 @@ function parseConceptRef(raw) {
 }
 var INPUT_SLOT_KEYS = /* @__PURE__ */ new Set(["concept", "hints"]);
 var CONCEPT_CODE_RE = /^[A-Z][A-Za-z0-9]*$/;
-function looksLikeUnquotedDottedName(raw, unknownKeys) {
-  if (raw.concept !== void 0 || unknownKeys.length === 0) return false;
-  return unknownKeys.every((key) => {
-    const parts = parseConceptRef(raw[key]);
-    return parts !== null && CONCEPT_CODE_RE.test(parts.code);
-  });
+function isConceptCodeRef(raw) {
+  const parts = parseConceptRef(raw);
+  return parts !== null && CONCEPT_CODE_RE.test(parts.code);
+}
+function unquotedDottedInputNames(name, raw) {
+  if (!isPlainObject(raw) || raw.concept !== void 0) return null;
+  const keys = Object.keys(raw);
+  if (keys.length === 0) return null;
+  const dottedNames = [];
+  for (const key of keys) {
+    const value = raw[key];
+    const dottedName = `${name}.${key}`;
+    if (isConceptCodeRef(value) || isPlainObject(value) && isConceptCodeRef(value.concept)) {
+      dottedNames.push(dottedName);
+      continue;
+    }
+    const nested = unquotedDottedInputNames(dottedName, value);
+    if (nested === null) return null;
+    dottedNames.push(...nested);
+  }
+  return dottedNames;
 }
 function parseInputSlot(raw) {
   if (!isPlainObject(raw)) {
-    return {
-      ref: parseConceptRef(raw),
-      missingConcept: false,
-      unknownKeys: [],
-      dottedName: false
-    };
+    return { ref: parseConceptRef(raw), missingConcept: false, unknownKeys: [] };
   }
-  const unknownKeys = Object.keys(raw).filter((key) => !INPUT_SLOT_KEYS.has(key));
   return {
     ref: parseConceptRef(raw.concept),
     missingConcept: raw.concept === void 0,
-    unknownKeys,
-    dottedName: looksLikeUnquotedDottedName(raw, unknownKeys)
+    unknownKeys: Object.keys(raw).filter((key) => !INPUT_SLOT_KEYS.has(key))
   };
 }
 function qualifiedStructureClassName(domain, code) {
   return `${domain.replaceAll(".", "\xB7")}__${code}`;
 }
 function nativeConceptInfo(code) {
+  var _a;
+  const definition = NATIVE_CONCEPTS[code];
   return {
     code,
     domain_code: NATIVE_DOMAIN,
-    description: NATIVE_CONCEPT_DESCRIPTIONS[code],
+    description: definition.description,
     structure_class_name: `${code}Content`,
-    refines: null
+    refines: (_a = definition.refines) != null ? _a : null
   };
 }
 function stubConceptInfo(code, domain) {
@@ -146,12 +247,11 @@ function resolveStuffSpec(raw, currentDomain, localConcepts) {
   return parts === null ? null : stuffSpecFromParts(parts, currentDomain, localConcepts);
 }
 function resolveInputSlot(raw, currentDomain, localConcepts) {
-  const { ref, missingConcept, unknownKeys, dottedName } = parseInputSlot(raw);
+  const { ref, missingConcept, unknownKeys } = parseInputSlot(raw);
   return {
     spec: ref === null ? null : stuffSpecFromParts(ref, currentDomain, localConcepts),
     missingConcept,
-    unknownKeys,
-    dottedName
+    unknownKeys
   };
 }
 
@@ -174,6 +274,25 @@ function stringArrayOrNull(value) {
   if (!Array.isArray(value)) return null;
   return value.filter((item) => typeof item === "string");
 }
+var PLAIN_NAME_RE = /^[a-z][a-z0-9_]*$/;
+function bindingStepFor(dottedPath) {
+  const plainName = dottedPath.slice(dottedPath.lastIndexOf(".") + 1);
+  return `{ from = "${dottedPath}", result = "${plainName}" }`;
+}
+function dottedInputNameRemedy(dottedName) {
+  const root = dottedName.slice(0, dottedName.indexOf("."));
+  return `an input names one whole value, so its name cannot reach into a field with a dot; declare "${root}" with its whole concept and read the field through it, or have the calling sequence bind the field to a plain name with a binding step (${bindingStepFor(dottedName)}) and declare that name`;
+}
+function invalidInputNameReason(name) {
+  const segments = name.split(".");
+  if (segments.length > 1 && segments.every((segment) => PLAIN_NAME_RE.test(segment))) {
+    return `is not a plain input name: ${dottedInputNameRemedy(name)}`;
+  }
+  return "is not a plain input name, which is a lowercase letter followed by lowercase letters, digits and underscores";
+}
+function tomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
 function normalizeInputs(raw, pipeCode, ctx) {
   const inputs = authoredRecord();
   if (raw === void 0 || raw === null) return inputs;
@@ -187,26 +306,33 @@ function normalizeInputs(raw, pipeCode, ctx) {
     return inputs;
   }
   for (const [name, slot] of Object.entries(raw)) {
-    const { spec, missingConcept, unknownKeys, dottedName } = resolveInputSlot(
-      slot,
-      ctx.domain,
-      ctx.concepts
-    );
-    if (dottedName) {
+    const path = `pipe.${pipeCode}.inputs.${tomlKey(name)}`;
+    if (!PLAIN_NAME_RE.test(name)) {
       ctx.diagnostics.push({
         severity: "warning",
-        code: "invalid-concept-ref",
-        message: `pipe "${pipeCode}": input "${name}" reads as a slot table but looks like an unquoted dotted input name \u2014 write it as one quoted key ("${name}.${unknownKeys.join(".")}" = \u2026) \u2014 skipped`,
-        path: `pipe.${pipeCode}.inputs.${name}`
+        code: "invalid-input-name",
+        message: `pipe "${pipeCode}": input "${name}" ${invalidInputNameReason(name)} \u2014 skipped`,
+        path
       });
       continue;
     }
+    const dottedNames = unquotedDottedInputNames(name, slot);
+    if (dottedNames !== null) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-input-name",
+        message: `pipe "${pipeCode}": input "${name}" is a table with no "concept", which is how TOML reads the unquoted dotted input ${dottedNames.length === 1 ? "name" : "names"} ${dottedNames.map((dotted) => `"${dotted}"`).join(", ")}; ${dottedInputNameRemedy(dottedNames[0])} \u2014 skipped`,
+        path
+      });
+      continue;
+    }
+    const { spec, missingConcept, unknownKeys } = resolveInputSlot(slot, ctx.domain, ctx.concepts);
     if (unknownKeys.length > 0) {
       ctx.diagnostics.push({
         severity: "warning",
         code: "unknown-input-slot-key",
         message: `pipe "${pipeCode}": input "${name}" declares ${unknownKeys.map((key) => `"${key}"`).join(", ")}, which the input slot form does not define \u2014 ignored here, and the runtime refuses the bundle`,
-        path: `pipe.${pipeCode}.inputs.${name}`
+        path
       });
     }
     if (spec === null) {
@@ -214,7 +340,7 @@ function normalizeInputs(raw, pipeCode, ctx) {
         severity: "warning",
         code: "invalid-concept-ref",
         message: missingConcept ? `pipe "${pipeCode}": input "${name}" is a slot table with no "concept" \u2014 the key is required \u2014 skipped` : `pipe "${pipeCode}": input "${name}" has an uninterpretable concept ref \u2014 skipped`,
-        path: `pipe.${pipeCode}.inputs.${name}`
+        path
       });
       continue;
     }
@@ -235,7 +361,7 @@ function normalizeOutput(raw, pipeCode, ctx) {
 }
 function normalizeSubPipe(raw, pipeCode, path, ctx) {
   var _a;
-  if (!isPlainObject(raw) || strOrNull(raw.pipe) === null) {
+  if (strOrNull(raw.pipe) === null) {
     ctx.diagnostics.push({
       severity: "warning",
       code: "invalid-sub-pipe",
@@ -266,21 +392,168 @@ function normalizeSubPipe(raw, pipeCode, path, ctx) {
     batch_params: batchParams
   };
 }
-function normalizeSubPipeList(raw, pipeCode, key, ctx) {
+var BINDING_PATH_RE = /^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)*$/;
+var BINDING_STEP_KEYS = /* @__PURE__ */ new Set(["from", "result"]);
+var PRIVATE_BINDING_NAME_PREFIX = "_bound_";
+function normalizeBindingStep(raw, pipeCode, path, ctx) {
+  const skip = (why) => {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "invalid-binding-step",
+      message: `pipe "${pipeCode}": binding step ${why} \u2014 skipped`,
+      path
+    });
+    return null;
+  };
+  if (raw.pipe !== void 0) return skip(`carries both "from" and "pipe"`);
+  const fromPath = strOrNull(raw.from);
+  if (fromPath === null || !BINDING_PATH_RE.test(fromPath)) {
+    return skip(`has a "from" that is not a path of identifiers separated by dots`);
+  }
+  const result = strOrNull(raw.result);
+  if (result === null) return skip(`binds "${fromPath}" under no "result"`);
+  if (!PLAIN_NAME_RE.test(result)) {
+    return skip(
+      result.startsWith(PRIVATE_BINDING_NAME_PREFIX) ? `binds "${fromPath}" under "${result}", which takes the prefix "${PRIVATE_BINDING_NAME_PREFIX}" the runtime reserves for its own names` : `binds "${fromPath}" under "${result}", which is not a plain name (lowercase letters, digits and underscores, starting with a letter)`
+    );
+  }
+  const extraKeys = Object.keys(raw).filter((key) => !BINDING_STEP_KEYS.has(key));
+  if (extraKeys.length > 0) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "invalid-binding-step",
+      message: `pipe "${pipeCode}": binding step of "${fromPath}" carries ${extraKeys.map((key) => `"${key}"`).join(", ")}, which a binding step does not take \u2014 ignored`,
+      path
+    });
+  }
+  return { from_path: fromPath, output_name: result, is_dotted_batch_over: false };
+}
+function namesInSequence(inputNames, rawSteps) {
+  const names = new Set(inputNames);
+  for (const step of rawSteps) {
+    if (!isPlainObject(step)) continue;
+    if (step.from !== void 0) {
+      const fromPath = strOrNull(step.from);
+      if (fromPath !== null) names.add(fromPath.split(".")[0]);
+      const result = strOrNull(step.result);
+      if (result !== null) names.add(result);
+      continue;
+    }
+    for (const name of [strOrNull(step.result), strOrNull(step.batch_as)]) {
+      if (name !== null) names.add(name);
+    }
+    const batchOver = strOrNull(step.batch_over);
+    if (batchOver !== null) names.add(batchOver.split(".")[0]);
+  }
+  return names;
+}
+function makePrivateBindingName(path, takenNames) {
+  const baseName = `${PRIVATE_BINDING_NAME_PREFIX}${path.replaceAll(".", "_")}`;
+  let name = baseName;
+  for (let suffix = 2; takenNames.has(name); suffix++) name = `${baseName}_${suffix}`;
+  return name;
+}
+function normalizeSequenceSteps(raw, pipeCode, inputNames, ctx) {
+  if (!Array.isArray(raw)) {
+    if (raw !== void 0) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-pipe-entry",
+        message: `pipe "${pipeCode}": steps is not an array \u2014 treated as empty`,
+        path: `pipe.${pipeCode}.steps`
+      });
+    }
+    return [];
+  }
+  const takenNames = namesInSequence(inputNames, raw);
+  const steps = [];
+  raw.forEach((entry, index) => {
+    var _a;
+    const path = `pipe.${pipeCode}.steps[${index}]`;
+    if (isPlainObject(entry) && entry.from !== void 0) {
+      const binding = normalizeBindingStep(entry, pipeCode, path, ctx);
+      if (binding !== null) steps.push(binding);
+      return;
+    }
+    if (!isPlainObject(entry)) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-sub-pipe",
+        message: `pipe "${pipeCode}": sub-pipe entry without a "pipe" ref \u2014 skipped`,
+        path
+      });
+      return;
+    }
+    const step = normalizeSubPipe(entry, pipeCode, path, ctx);
+    if (step === null) return;
+    const listName = (_a = step.batch_params) == null ? void 0 : _a.input_list_stuff_name;
+    if (step.batch_params != null && listName !== void 0 && listName.includes(".")) {
+      if (!BINDING_PATH_RE.test(listName)) {
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "invalid-binding-step",
+          message: `pipe "${pipeCode}": dotted batch_over "${listName}" is not a path of identifiers separated by dots \u2014 batching over it as a name`,
+          path
+        });
+      } else {
+        const privateName = makePrivateBindingName(listName, takenNames);
+        takenNames.add(privateName);
+        steps.push({ from_path: listName, output_name: privateName, is_dotted_batch_over: true });
+        step.batch_params = __spreadProps(__spreadValues({}, step.batch_params), { input_list_stuff_name: privateName });
+      }
+    }
+    steps.push(step);
+  });
+  return steps;
+}
+function normalizeBranchList(raw, pipeCode, ctx) {
   if (!Array.isArray(raw)) {
     if (raw !== void 0) {
       ctx.diagnostics.push({
         severity: "warning",
         code: "invalid-pipe-entry",
-        message: `pipe "${pipeCode}": ${key} is not an array \u2014 treated as empty`,
-        path: `pipe.${pipeCode}.${key}`
+        message: `pipe "${pipeCode}": branches is not an array \u2014 treated as empty`,
+        path: `pipe.${pipeCode}.branches`
       });
     }
     return [];
   }
-  return raw.map(
-    (entry, index) => normalizeSubPipe(entry, pipeCode, `pipe.${pipeCode}.${key}[${index}]`, ctx)
-  ).filter((entry) => entry !== null);
+  const branches = [];
+  raw.forEach((entry, index) => {
+    var _a;
+    const path = `pipe.${pipeCode}.branches[${index}]`;
+    if (!isPlainObject(entry)) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-sub-pipe",
+        message: `pipe "${pipeCode}": sub-pipe entry without a "pipe" ref \u2014 skipped`,
+        path
+      });
+      return;
+    }
+    if (entry.from !== void 0) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-binding-step",
+        message: `pipe "${pipeCode}": a parallel branch cannot be a binding step \u2014 bind in a sequence step before the parallel \u2014 skipped`,
+        path
+      });
+      return;
+    }
+    const branch = normalizeSubPipe(entry, pipeCode, path, ctx);
+    if (branch === null) return;
+    if ((_a = branch.batch_params) == null ? void 0 : _a.input_list_stuff_name.includes(".")) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-binding-step",
+        message: `pipe "${pipeCode}": a parallel branch cannot batch over the dotted path "${branch.batch_params.input_list_stuff_name}" \u2014 bind it in a sequence step before the parallel \u2014 skipped`,
+        path
+      });
+      return;
+    }
+    branches.push(branch);
+  });
+  return branches;
 }
 function normalizeConstructField(value) {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value)) {
@@ -306,11 +579,36 @@ function normalizeConstruct(raw) {
   if (!isPlainObject(raw)) return null;
   const fields = {};
   for (const [name, value] of Object.entries(raw)) {
-    const field = normalizeConstructField(value);
-    if (field !== null) fields[name] = field;
+    const field2 = normalizeConstructField(value);
+    if (field2 !== null) fields[name] = field2;
   }
   return Object.keys(fields).length > 0 ? { fields } : null;
 }
+function normalizeJudgmentQuestion(raw) {
+  var _a, _b;
+  const instructions = (_b = (_a = strOrNull(raw.question)) != null ? _a : strOrNull(raw.prompt)) != null ? _b : "";
+  if (isPlainObject(raw.options)) {
+    const options = {};
+    for (const [key, description] of Object.entries(raw.options)) {
+      options[key] = typeof description === "string" ? description : null;
+    }
+    return { kind: "choice", instructions, options };
+  }
+  if (Array.isArray(raw.levels)) {
+    return {
+      kind: "rating",
+      instructions,
+      levels: raw.levels.filter((level) => typeof level === "string")
+    };
+  }
+  const criteria = isPlainObject(raw.criteria) ? raw.criteria : {};
+  return {
+    kind: "yes_no",
+    instructions,
+    yes_criterion: strOrNull(criteria.yes),
+    no_criterion: strOrNull(criteria.no)
+  };
+}
 var SIGNATURE_ONLY_KEYS = /* @__PURE__ */ new Set([
   "description",
   "inputs",
@@ -343,7 +641,7 @@ function resolvePipeTypeTag(code, raw, ctx) {
   return null;
 }
 function normalizePipe(code, raw, ctx) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   const typeValue = resolvePipeTypeTag(code, raw, ctx);
   if (typeValue === null) return null;
   const type = typeValue;
@@ -359,13 +657,18 @@ function normalizePipe(code, raw, ctx) {
       return __spreadProps(__spreadValues({}, base), {
         type,
         pipe_category: "PipeController",
-        sequential_sub_pipes: normalizeSubPipeList(raw.steps, code, "steps", ctx)
+        sequential_sub_pipes: normalizeSequenceSteps(
+          raw.steps,
+          code,
+          Object.keys(base.inputs),
+          ctx
+        )
       });
     case "PipeParallel":
       return __spreadProps(__spreadValues({}, base), {
         type,
         pipe_category: "PipeController",
-        parallel_sub_pipes: normalizeSubPipeList(raw.branches, code, "branches", ctx),
+        parallel_sub_pipes: normalizeBranchList(raw.branches, code, ctx),
         add_each_output: raw.add_each_output === true,
         combined_output: strOrNull(raw.combined_output)
       });
@@ -527,6 +830,24 @@ function normalizePipe(code, raw, ctx) {
     }
     case "PipeFunc":
       return __spreadProps(__spreadValues({}, base), { type, pipe_category: "PipeOperator" });
+    case "PipeJudge":
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        judgment_choice: isPlainObject(raw.model) ? raw.model : strOrNull(raw.model),
+        judgment_question: normalizeJudgmentQuestion(raw),
+        threshold: typeof raw.threshold === "number" ? raw.threshold : null
+      });
+    case "PipeDocGen":
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        doc_gen_format: (_m = strOrNull(raw.format)) != null ? _m : "",
+        doc_gen_choice: isPlainObject(raw.model) ? raw.model : strOrNull(raw.model),
+        template: strOrNull(raw.template),
+        template_file: strOrNull(raw.template_file),
+        filename: strOrNull(raw.filename)
+      });
     case "PipeSignature": {
       const signatureFor = strOrNull(raw.signature_for);
       return __spreadProps(__spreadValues({}, base), {
@@ -580,6 +901,7 @@ function deriveJsonSchema(structure, title, description) {
   for (const [name, spec] of Object.entries(structure)) {
     if (typeof spec === "string") {
       properties[name] = { type: "string", description: spec };
+      required.push(name);
       continue;
     }
     if (!isPlainObject(spec)) continue;
@@ -611,10 +933,28 @@ function qualifyRefines(raw, domain, declaredCodes, conceptCode, diagnostics) {
   }
   return `${domain}.${parts.code}`;
 }
+function parseStructureFields(structure) {
+  const fields = authoredRecord();
+  for (const [name, spec] of Object.entries(structure)) {
+    if (typeof spec === "string") {
+      fields[name] = { type: "text", conceptRef: null, itemType: null, itemConceptRef: null };
+      continue;
+    }
+    if (!isPlainObject(spec)) continue;
+    fields[name] = {
+      type: strOrNull(spec.type),
+      conceptRef: strOrNull(spec.concept_ref),
+      itemType: strOrNull(spec.item_type),
+      itemConceptRef: strOrNull(spec.item_concept_ref)
+    };
+  }
+  return fields;
+}
 function parseConcepts(raw, domain, diagnostics) {
   var _a, _b;
   const concepts = authoredRecord();
-  if (raw === void 0) return concepts;
+  const structures = authoredRecord();
+  if (raw === void 0) return { concepts, structures };
   if (!isPlainObject(raw)) {
     diagnostics.push({
       severity: "warning",
@@ -622,7 +962,7 @@ function parseConcepts(raw, domain, diagnostics) {
       message: "concept section is not a table \u2014 ignored",
       path: "concept"
     });
-    return concepts;
+    return { concepts, structures };
   }
   const declaredCodes = new Set(Object.keys(raw));
   for (const [code, entry] of Object.entries(raw)) {
@@ -655,8 +995,13 @@ function parseConcepts(raw, domain, diagnostics) {
       refines: qualifyRefines(entry.refines, domain, declaredCodes, code, diagnostics),
       json_schema: deriveJsonSchema(entry.structure, structureClassName, description)
     };
+    if (isPlainObject(entry.structure)) {
+      structures[code] = parseStructureFields(entry.structure);
+    } else if (typeof entry.structure === "string") {
+      structures[code] = entry.structure;
+    }
   }
-  return concepts;
+  return { concepts, structures };
 }
 function emptyBundle() {
   return {
@@ -665,6 +1010,7 @@ function emptyBundle() {
     main_pipe: null,
     system_prompt: null,
     concepts: authoredRecord(),
+    structures: authoredRecord(),
     pipes: authoredRecord()
   };
 }
@@ -696,7 +1042,9 @@ function parseMthdsBundle(tomlText) {
     });
   }
   const domain = (_a = bundle.domain) != null ? _a : UNKNOWN_DOMAIN;
-  bundle.concepts = parseConcepts(root.concept, domain, diagnostics);
+  const { concepts, structures } = parseConcepts(root.concept, domain, diagnostics);
+  bundle.concepts = concepts;
+  bundle.structures = structures;
   const pipeTable = root.pipe;
   if (pipeTable !== void 0) {
     if (!isPlainObject(pipeTable)) {
@@ -754,6 +1102,7 @@ function mergeBundles(bundles) {
     const namespace = (_b = domains[domain]) != null ? _b : domains[domain] = {
       domain,
       concepts: authoredRecord(),
+      structures: authoredRecord(),
       pipes: authoredRecord()
     };
     if (mainDomain === null && bundle.domain !== null) mainDomain = bundle.domain;
@@ -774,6 +1123,9 @@ function mergeBundles(bundles) {
         continue;
       }
       namespace.concepts[code] = concept;
+      if (Object.hasOwn(bundle.structures, code)) {
+        namespace.structures[code] = bundle.structures[code];
+      }
     }
     for (const [code, pipe] of Object.entries(bundle.pipes)) {
       const existing = namespace.pipes[code];
@@ -816,6 +1168,197 @@ function mergeBundles(bundles) {
   return { domains, mainDomain, mainPipe, description, diagnostics };
 }
 
+// src/static-graph/bindingWalk.ts
+var SINGLE_FIELD_NATIVE_REASON = "holds its value in a single field";
+var DESCRIBED_ONLY_REASON = "is declared with neither a structure nor refines";
+function splitRef(ref) {
+  const dot = ref.lastIndexOf(".");
+  return { domain: ref.slice(0, dot), code: ref.slice(dot + 1) };
+}
+function qualifyFieldRef(ref, domain) {
+  if (ref.includes("->")) return ref;
+  if (ref.startsWith(`${NATIVE_DOMAIN}.`)) return ref;
+  if (!ref.includes("."))
+    return isNativeConceptCode(ref) ? `${NATIVE_DOMAIN}.${ref}` : `${domain}.${ref}`;
+  return ref;
+}
+function resolveWalkable(set, ref, visited = /* @__PURE__ */ new Set()) {
+  if (ref.includes("->")) {
+    return {
+      shape: "no-structure",
+      ref,
+      reason: "belongs to a dependency, which a method's own bundles do not show"
+    };
+  }
+  const { domain, code } = splitRef(ref);
+  if (domain === NATIVE_DOMAIN) {
+    if (!isNativeConceptCode(code)) {
+      return { shape: "no-structure", ref, reason: "is not a native concept" };
+    }
+    const fields = nativeConceptFields(code);
+    if (fields === null) {
+      return { shape: "no-structure", ref, reason: "is structureless by definition" };
+    }
+    if (Object.keys(fields).length === 1) {
+      return { shape: "value", ref, reason: SINGLE_FIELD_NATIVE_REASON };
+    }
+    return { shape: "structure", ref, fields };
+  }
+  if (visited.has(ref))
+    return { shape: "no-structure", ref, reason: "refines itself through a cycle" };
+  const namespace = set.domains[domain];
+  const concept = namespace !== void 0 && Object.hasOwn(namespace.concepts, code) ? namespace.concepts[code] : void 0;
+  if (namespace === void 0 || concept === void 0) {
+    return { shape: "no-structure", ref, reason: "is not declared in this method" };
+  }
+  const structure = Object.hasOwn(namespace.structures, code) ? namespace.structures[code] : void 0;
+  if (typeof structure === "string") {
+    return {
+      shape: "no-structure",
+      ref,
+      reason: "has a Python class for a structure, which a bundle does not show"
+    };
+  }
+  if (structure !== void 0) {
+    const fields = /* @__PURE__ */ Object.create(null);
+    for (const [name, declared] of Object.entries(structure)) {
+      fields[name] = __spreadProps(__spreadValues({}, declared), {
+        conceptRef: declared.conceptRef === null ? null : qualifyFieldRef(declared.conceptRef, domain),
+        itemConceptRef: declared.itemConceptRef === null ? null : qualifyFieldRef(declared.itemConceptRef, domain)
+      });
+    }
+    return { shape: "structure", ref, fields };
+  }
+  if (concept.refines != null) {
+    const refined = resolveWalkable(set, concept.refines, /* @__PURE__ */ new Set([...visited, ref]));
+    if (refined.shape === "structure") return { shape: "structure", ref, fields: refined.fields };
+    const reason = `refines '${refined.ref}', which ${refined.reason}`;
+    return refined.shape === "value" ? { shape: "value", ref, reason } : { shape: "no-structure", ref, reason };
+  }
+  return { shape: "no-structure", ref, reason: DESCRIBED_ONLY_REASON };
+}
+var SCALAR_NATIVE = {
+  text: "Text",
+  number: "Number",
+  integer: "Number",
+  boolean: "YesNo",
+  date: "Date",
+  datetime: "Date",
+  time: "Time",
+  dict: "JSON"
+};
+function fieldStep(declared) {
+  var _a;
+  const type = (_a = declared.type) != null ? _a : "text";
+  if (type === "concept") return { kind: "concept", ref: declared.conceptRef, crossesList: false };
+  if (type === "list") {
+    const itemType = declared.itemType;
+    if (itemType === null) {
+      return { kind: "underivable", crossesList: true, reason: "the list declares no item_type" };
+    }
+    if (itemType === "concept") {
+      return { kind: "concept", ref: declared.itemConceptRef, crossesList: true };
+    }
+    const nativeCode2 = Object.hasOwn(SCALAR_NATIVE, itemType) ? SCALAR_NATIVE[itemType] : null;
+    if (nativeCode2 === null) {
+      return {
+        kind: "underivable",
+        crossesList: true,
+        reason: `the list's item_type '${itemType}' derives no concept`
+      };
+    }
+    return { kind: "leaf", nativeCode: nativeCode2, crossesList: true, description: `a list of ${itemType}` };
+  }
+  const nativeCode = Object.hasOwn(SCALAR_NATIVE, type) ? SCALAR_NATIVE[type] : null;
+  if (nativeCode === null) {
+    return {
+      kind: "underivable",
+      crossesList: false,
+      reason: `its type '${type}' derives no concept`
+    };
+  }
+  return { kind: "leaf", nativeCode, crossesList: false, description: `a ${type} field` };
+}
+function conceptInfoForRef(set, ref) {
+  var _a, _b;
+  const { domain, code } = splitRef(ref);
+  return resolveConceptInfo(
+    { domain, code, multiplicity: null, presence: "plain" },
+    domain,
+    (_b = (_a = set.domains[domain]) == null ? void 0 : _a.concepts) != null ? _b : {}
+  );
+}
+function conceptRefOf(concept) {
+  return `${concept.domain_code}.${concept.code}`;
+}
+function deriveBinding(set, path, root) {
+  const segments = path.split(".").slice(1);
+  if (segments.length === 0) {
+    return { kind: "derived", concept: root.concept, multiplicity: root.multiplicity };
+  }
+  let crossesAnyList = isPluralMultiplicity(root.multiplicity);
+  let reachedPath = path.split(".")[0];
+  let current = resolveWalkable(set, conceptRefOf(root.concept));
+  let leafDescription = null;
+  let derivedRef = conceptRefOf(root.concept);
+  const fail = (reason) => ({
+    kind: "unresolved",
+    reason: `cannot bind '${path}': ${reason}`
+  });
+  for (const [index, segment] of segments.entries()) {
+    if (leafDescription !== null) {
+      return fail(
+        `'${reachedPath}' is ${leafDescription}, a leaf holding a plain value, so the segment '${segment}' cannot follow it`
+      );
+    }
+    if (current === null) {
+      return fail(
+        `nothing is known of '${reachedPath}', so the segment '${segment}' cannot be walked`
+      );
+    }
+    if (current.shape === "value") {
+      return fail(
+        `'${reachedPath}' holds a '${current.ref}', which ${current.reason}, so it is a leaf and the segment '${segment}' cannot follow it`
+      );
+    }
+    if (current.shape === "no-structure") {
+      return fail(
+        `'${reachedPath}' holds a '${current.ref}', which ${current.reason}, so the segment '${segment}' has no structure to walk`
+      );
+    }
+    const declared = Object.hasOwn(current.fields, segment) ? current.fields[segment] : void 0;
+    if (declared === void 0) {
+      const names = Object.keys(current.fields);
+      return fail(
+        `'${reachedPath}' holds a '${current.ref}', which has no field '${segment}'` + (names.length > 0 ? ` (its fields are ${names.map((name) => `'${name}'`).join(", ")})` : "")
+      );
+    }
+    reachedPath = `${reachedPath}.${segment}`;
+    const isLast = index === segments.length - 1;
+    const step = fieldStep(declared);
+    if (step.crossesList) crossesAnyList = true;
+    switch (step.kind) {
+      case "underivable":
+        return fail(`'${reachedPath}' derives no concept, since ${step.reason}`);
+      case "concept":
+        if (step.ref === null) return fail(`the concept field '${reachedPath}' names no concept`);
+        derivedRef = step.ref;
+        current = isLast ? null : resolveWalkable(set, step.ref);
+        break;
+      case "leaf":
+        derivedRef = `${NATIVE_DOMAIN}.${step.nativeCode}`;
+        leafDescription = step.description;
+        current = null;
+        break;
+    }
+  }
+  return {
+    kind: "derived",
+    concept: conceptInfoForRef(set, derivedRef),
+    multiplicity: crossesAnyList ? true : null
+  };
+}
+
 // src/static-graph/buildStaticGraphSpec.ts
 function buildStaticGraphSpec(set, options = {}) {
   var _a;
@@ -893,7 +1436,9 @@ function referencedPipeCodes(namespace) {
   for (const pipe of Object.values(namespace.pipes)) {
     switch (pipe.type) {
       case "PipeSequence":
-        for (const sub of pipe.sequential_sub_pipes) add(sub.pipe_code);
+        for (const step of pipe.sequential_sub_pipes) {
+          if (!isBindingStepSpec(step)) add(step.pipe_code);
+        }
         break;
       case "PipeParallel":
         for (const sub of pipe.parallel_sub_pipes) add(sub.pipe_code);
@@ -1017,23 +1562,13 @@ function formatBatchMultiplicity(multiplicity) {
   if (multiplicity === true) return "xmany";
   return "x?";
 }
-function lookupScope(scope, name) {
-  let candidate = name;
-  for (; ; ) {
-    const found = scope.get(candidate);
-    if (found !== void 0) return found;
-    const dot = candidate.lastIndexOf(".");
-    if (dot <= 0) return void 0;
-    candidate = candidate.slice(0, dot);
-  }
-}
 function conceptKey(concept) {
   return `${concept.domain_code}.${concept.code}`;
 }
 function bindInputs(ctx, blueprint, scope) {
   const ioInputs = [];
   for (const [name, spec] of Object.entries(blueprint.inputs)) {
-    let bound = lookupScope(scope, name);
+    let bound = scope.get(name);
     if (bound === void 0) {
       bound = mintStuff(ctx, `input:${name}`, name, spec.concept, spec.multiplicity);
       scope.set(name, bound);
@@ -1179,11 +1714,18 @@ function emitOpaqueLeaf(ctx, ref, currentDomain, nodeId, parentId, inv) {
 function finishSequence(ctx, node, blueprint, nodeId, scope, inv) {
   let lastOutput = null;
   blueprint.sequential_sub_pipes.forEach((sub, index) => {
+    const stepId = `${nodeId}/step_${index + 1}`;
+    if (isBindingStepSpec(sub)) {
+      const bound = walkBindingStep(ctx, sub, blueprint, stepId, nodeId, scope);
+      scope.set(sub.output_name, bound);
+      lastOutput = bound;
+      return;
+    }
     const result = walkSubPipe(
       ctx,
       sub,
       blueprint.domain_code,
-      `${nodeId}/step_${index + 1}`,
+      stepId,
       nodeId,
       scope,
       inv.outputMultiplicity
@@ -1198,6 +1740,54 @@ function finishSequence(ctx, node, blueprint, nodeId, scope, inv) {
   node.io.outputs = lastOutput === null ? [] : [ioItem(lastOutput, inv.resultName)];
   return { nodeId, output: lastOutput, eachOutputs: [] };
 }
+function walkBindingStep(ctx, step, sequence, nodeId, parentId, scope) {
+  const rootName = step.from_path.split(".")[0];
+  let root = scope.get(rootName);
+  if (root === void 0) {
+    root = mintStuff(ctx, `input:${rootName}`, rootName, nativeConceptInfo("Anything"), null);
+    scope.set(rootName, root);
+  }
+  const node = emitNode(ctx, {
+    id: nodeId,
+    kind: "binding",
+    pipeCode: step.from_path,
+    pipeType: BINDING_STEP_TYPE,
+    description: `Binds '${step.from_path}' to '${step.output_name}'`,
+    domainCode: sequence.domain_code,
+    ioInputs: [ioItem(root, rootName)],
+    parentId,
+    inv: { resultName: step.output_name, outputMultiplicity: null }
+  });
+  node.execution_data = { from: step.from_path, result: step.output_name };
+  const derivation = deriveBinding(ctx.set, step.from_path, {
+    concept: root.concept,
+    multiplicity: root.multiplicity
+  });
+  let concept;
+  let multiplicity;
+  if (derivation.kind === "derived") {
+    ({ concept, multiplicity } = derivation);
+  } else {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "binding-path-unresolved",
+      message: `pipe "${sequence.code}": ${derivation.reason} \u2014 bound as native.Anything`,
+      path: nodeId,
+      domain_code: sequence.domain_code
+    });
+    concept = nativeConceptInfo("Anything");
+    multiplicity = isPluralMultiplicity(root.multiplicity) ? true : null;
+  }
+  const output = mintStuff(
+    ctx,
+    `${nodeId}:${step.output_name}`,
+    step.output_name,
+    concept,
+    multiplicity
+  );
+  node.io.outputs = [ioItem(output)];
+  return output;
+}
 function finishParallel(ctx, node, blueprint, nodeId, scope, inv) {
   var _a, _b;
   const branchResults = [];
@@ -1240,13 +1830,13 @@ function finishParallel(ctx, node, blueprint, nodeId, scope, inv) {
   return { nodeId, output: combined, eachOutputs };
 }
 function finishCondition(ctx, node, blueprint, nodeId, scope, inv) {
-  var _a, _b, _c, _d;
+  var _a, _b;
   const conditionScope = new Map(scope);
   if (blueprint.add_alias_from_expression_to != null) {
     const alias = blueprint.add_alias_from_expression_to;
     conditionScope.set(
       alias,
-      mintStuff(ctx, `${nodeId}:${alias}`, alias, nativeConceptInfo("Dynamic"), null)
+      mintStuff(ctx, `${nodeId}:alias:${alias}`, alias, nativeConceptInfo("Dynamic"), null)
     );
   }
   const targets = [];
@@ -1289,16 +1879,47 @@ function finishCondition(ctx, node, blueprint, nodeId, scope, inv) {
     );
     if (result !== null) results.push({ entry, result });
   }
-  const primary = (_d = (_c = (_a = results.find(({ entry, result }) => entry.viaDefault && result.output !== null)) == null ? void 0 : _a.result.output) != null ? _c : (_b = results.find(({ result }) => result.output !== null)) == null ? void 0 : _b.result.output) != null ? _d : null;
-  node.io.outputs = primary === null ? [] : [ioItem(primary, inv.resultName)];
-  return { nodeId, output: primary, eachOutputs: [] };
+  const outputs = results.flatMap(({ result }) => result.output === null ? [] : [result.output]);
+  const representative = (_b = (_a = results.find(({ entry, result }) => entry.viaDefault && result.output !== null)) == null ? void 0 : _a.result.output) != null ? _b : outputs[0];
+  if (representative === void 0) {
+    node.io.outputs = [];
+    return { nodeId, output: null, eachOutputs: [] };
+  }
+  const outcomesAgree = outputs.every(
+    (output) => conceptKey(output.concept) === conceptKey(representative.concept) && output.multiplicity === representative.multiplicity
+  );
+  const declaredMultiplicity = typeof inv.outputMultiplicity === "number" || inv.outputMultiplicity === true ? inv.outputMultiplicity : blueprint.output.multiplicity;
+  const shared = mintStuff(
+    ctx,
+    `${nodeId}:${representative.name}`,
+    representative.name,
+    outcomesAgree ? representative.concept : blueprint.output.concept,
+    outcomesAgree ? representative.multiplicity : declaredMultiplicity
+  );
+  for (const output of outputs) {
+    if (output.digest.startsWith(`${nodeId}/`)) renameStuff(ctx, output.digest, shared);
+  }
+  node.io.outputs = [ioItem(shared, inv.resultName)];
+  return { nodeId, output: shared, eachOutputs: [] };
+}
+function renameStuff(ctx, from, to) {
+  for (const node of ctx.nodes) {
+    for (const item of [...node.io.inputs, ...node.io.outputs]) {
+      if (item.digest === from) item.digest = to.digest;
+    }
+  }
+  for (const edge of ctx.edges) {
+    if (edge.source_stuff_digest === from) edge.source_stuff_digest = to.digest;
+    if (edge.target_stuff_digest === from) edge.target_stuff_digest = to.digest;
+  }
+  ctx.stuffByDigest.delete(from);
 }
 function finishBatch(ctx, node, blueprint, nodeId, scope, inv) {
   var _a, _b, _c;
   const params = blueprint.batch_params;
   let listStuff = null;
   if (params.input_list_stuff_name !== "") {
-    const bound = lookupScope(scope, params.input_list_stuff_name);
+    const bound = scope.get(params.input_list_stuff_name);
     if (bound !== void 0) {
       listStuff = bound;
     } else {
@@ -1368,7 +1989,7 @@ function walkInlineBatch(ctx, sub, domain, nodeId, parentId, scope) {
   const branchTail = refTail.slice(refTail.lastIndexOf(".") + 1);
   const branchResolution = resolvePipeRef(ctx.set, sub.pipe_code, domain);
   const branchBlueprint = branchResolution.kind === "resolved" ? branchResolution.blueprint : null;
-  const listBinding = lookupScope(scope, params.input_list_stuff_name);
+  const listBinding = scope.get(params.input_list_stuff_name);
   const listConcept = (_c = (_b = listBinding == null ? void 0 : listBinding.concept) != null ? _b : (_a = branchBlueprint == null ? void 0 : branchBlueprint.inputs[params.input_item_stuff_name]) == null ? void 0 : _a.concept) != null ? _c : nativeConceptInfo("Anything");
   const outputSpec = (_d = branchBlueprint == null ? void 0 : branchBlueprint.output) != null ? _d : {
     concept: nativeConceptInfo("Anything"),