@pipelex/mthds-ui 0.11.0 → 0.13.0

package/dist/static-graph/index.js

@@ -0,0 +1,1278 @@
+import {
+  KNOWN_PIPE_TYPES
+} from "../chunk-IMQ7MVYL.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-2NMEKWO5.js";
+
+// src/static-graph/types.ts
+var UNKNOWN_DOMAIN = "unknown";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function strOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function intOrNull(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+function boolOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
+
+// src/static-graph/conceptRefs.ts
+var NATIVE_DOMAIN = "native";
+var NATIVE_CONCEPT_DESCRIPTIONS = {
+  Dynamic: "Dynamically typed content",
+  Text: "A text",
+  Image: "An image",
+  Document: "A document",
+  Html: "HTML content",
+  TextAndImages: "A text with images",
+  Number: "A number",
+  Page: "The content of a page of a document",
+  JSON: "JSON content",
+  SearchResult: "A search result",
+  Anything: "Anything",
+  Composite: "A named composition of multiple contents"
+};
+var NATIVE_CONCEPT_CODES = new Set(
+  Object.keys(NATIVE_CONCEPT_DESCRIPTIONS)
+);
+var CONCEPT_REF_RE = /^(?:([A-Za-z0-9_][A-Za-z0-9_.]*)\.)?([A-Za-z0-9_]+)(?:\[(\d*)\])?$/;
+function parseConceptRef(raw) {
+  if (typeof raw !== "string") return null;
+  const match = CONCEPT_REF_RE.exec(raw.trim());
+  if (!match) return null;
+  const [, domain, code, multiplicity] = match;
+  return {
+    domain: domain != null ? domain : null,
+    code,
+    multiplicity: multiplicity === void 0 ? null : multiplicity === "" ? true : Number.parseInt(multiplicity, 10)
+  };
+}
+function qualifiedStructureClassName(domain, code) {
+  return `${domain.replaceAll(".", "\xB7")}__${code}`;
+}
+function nativeConceptInfo(code) {
+  var _a;
+  return {
+    code,
+    domain_code: NATIVE_DOMAIN,
+    description: (_a = NATIVE_CONCEPT_DESCRIPTIONS[code]) != null ? _a : code,
+    structure_class_name: `${code}Content`,
+    refines: null
+  };
+}
+function stubConceptInfo(code, domain) {
+  return {
+    code,
+    domain_code: domain,
+    description: "",
+    structure_class_name: qualifiedStructureClassName(domain, code),
+    refines: null
+  };
+}
+function resolveConceptInfo(parts, currentDomain, localConcepts) {
+  if (parts.domain === NATIVE_DOMAIN) {
+    return NATIVE_CONCEPT_CODES.has(parts.code) ? nativeConceptInfo(parts.code) : stubConceptInfo(parts.code, NATIVE_DOMAIN);
+  }
+  if (parts.domain !== null && parts.domain !== currentDomain) {
+    return stubConceptInfo(parts.code, parts.domain);
+  }
+  const local = localConcepts[parts.code];
+  if (local) return local;
+  if (parts.domain === null && NATIVE_CONCEPT_CODES.has(parts.code)) {
+    return nativeConceptInfo(parts.code);
+  }
+  return stubConceptInfo(parts.code, currentDomain);
+}
+function resolveStuffSpec(raw, currentDomain, localConcepts) {
+  const parts = parseConceptRef(raw);
+  if (parts === null) return null;
+  return {
+    concept: resolveConceptInfo(parts, currentDomain, localConcepts),
+    multiplicity: parts.multiplicity
+  };
+}
+
+// src/static-graph/parseMthdsBundle.ts
+import { parse as parseToml } from "smol-toml";
+
+// src/static-graph/normalizePipe.ts
+function makeTemplate(template, category) {
+  return { template, templating_style: null, category, extra_context: null };
+}
+function modelToString(value) {
+  var _a, _b;
+  if (typeof value === "string") return strOrNull(value);
+  if (isPlainObject(value)) {
+    return (_b = (_a = strOrNull(value.model)) != null ? _a : strOrNull(value.raw)) != null ? _b : strOrNull(value.name);
+  }
+  return null;
+}
+function stringArrayOrNull(value) {
+  if (!Array.isArray(value)) return null;
+  return value.filter((item) => typeof item === "string");
+}
+function normalizeInputs(raw, pipeCode, ctx) {
+  const inputs = {};
+  if (raw === void 0 || raw === null) return inputs;
+  if (!isPlainObject(raw)) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "invalid-pipe-entry",
+      message: `pipe "${pipeCode}": inputs is not a table \u2014 ignored`,
+      path: `pipe.${pipeCode}.inputs`
+    });
+    return inputs;
+  }
+  for (const [name, ref] of Object.entries(raw)) {
+    const spec = resolveStuffSpec(ref, ctx.domain, ctx.concepts);
+    if (spec === null) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "invalid-concept-ref",
+        message: `pipe "${pipeCode}": input "${name}" has an uninterpretable concept ref \u2014 skipped`,
+        path: `pipe.${pipeCode}.inputs.${name}`
+      });
+      continue;
+    }
+    inputs[name] = spec;
+  }
+  return inputs;
+}
+function normalizeOutput(raw, pipeCode, ctx) {
+  const spec = resolveStuffSpec(raw, ctx.domain, ctx.concepts);
+  if (spec !== null) return spec;
+  ctx.diagnostics.push({
+    severity: "warning",
+    code: "missing-pipe-output",
+    message: `pipe "${pipeCode}": missing or uninterpretable output \u2014 assuming native.Anything`,
+    path: `pipe.${pipeCode}.output`
+  });
+  return { concept: nativeConceptInfo("Anything"), multiplicity: null };
+}
+function normalizeSubPipe(raw, pipeCode, path, ctx) {
+  var _a;
+  if (!isPlainObject(raw) || strOrNull(raw.pipe) === null) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "invalid-sub-pipe",
+      message: `pipe "${pipeCode}": sub-pipe entry without a "pipe" ref \u2014 skipped`,
+      path
+    });
+    return null;
+  }
+  const batchOver = strOrNull(raw.batch_over);
+  const batchAs = strOrNull(raw.batch_as);
+  let batchParams = null;
+  if (batchOver !== null && batchAs !== null) {
+    batchParams = { input_list_stuff_name: batchOver, input_item_stuff_name: batchAs };
+  } else if (batchOver !== null || batchAs !== null) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "incomplete-batch-spec",
+      message: `pipe "${pipeCode}": sub-pipe "${raw.pipe}" sets only one of batch_over/batch_as \u2014 batching ignored`,
+      path
+    });
+  }
+  let outputMultiplicity = (_a = intOrNull(raw.nb_output)) != null ? _a : raw.multiple_output === true ? true : null;
+  if (batchParams !== null && outputMultiplicity === null) outputMultiplicity = true;
+  return {
+    pipe_code: raw.pipe,
+    output_name: strOrNull(raw.result),
+    output_multiplicity: outputMultiplicity,
+    batch_params: batchParams
+  };
+}
+function normalizeSubPipeList(raw, pipeCode, key, 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}`
+      });
+    }
+    return [];
+  }
+  return raw.map(
+    (entry, index) => normalizeSubPipe(entry, pipeCode, `pipe.${pipeCode}.${key}[${index}]`, ctx)
+  ).filter((entry) => entry !== null);
+}
+function normalizeConstructField(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value)) {
+    return { method: "fixed", fixed_value: value };
+  }
+  if (isPlainObject(value)) {
+    if (typeof value.from === "string") {
+      return {
+        method: "from_var",
+        from_path: value.from,
+        list_to_dict_keyed_by: strOrNull(value.list_to_dict_keyed_by)
+      };
+    }
+    if (typeof value.template === "string") {
+      return { method: "template", template: value.template };
+    }
+    const nested = normalizeConstruct(value);
+    if (nested !== null) return { method: "nested", nested };
+  }
+  return null;
+}
+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;
+  }
+  return Object.keys(fields).length > 0 ? { fields } : null;
+}
+function normalizePipe(code, raw, ctx) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const typeValue = raw.type;
+  if (typeof typeValue !== "string" || !KNOWN_PIPE_TYPES.has(typeValue)) {
+    ctx.diagnostics.push({
+      severity: "error",
+      code: "unknown-pipe-type",
+      message: `pipe "${code}": unknown pipe type ${JSON.stringify(typeValue)} \u2014 pipe skipped`,
+      path: `pipe.${code}.type`
+    });
+    return null;
+  }
+  const type = typeValue;
+  const base = {
+    code,
+    domain_code: ctx.domain,
+    description: (_a = strOrNull(raw.description)) != null ? _a : "",
+    inputs: normalizeInputs(raw.inputs, code, ctx),
+    output: normalizeOutput(raw.output, code, ctx)
+  };
+  switch (type) {
+    case "PipeSequence":
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeController",
+        sequential_sub_pipes: normalizeSubPipeList(raw.steps, code, "steps", ctx)
+      });
+    case "PipeParallel":
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeController",
+        parallel_sub_pipes: normalizeSubPipeList(raw.branches, code, "branches", ctx),
+        add_each_output: raw.add_each_output === true,
+        combined_output: strOrNull(raw.combined_output)
+      });
+    case "PipeCondition": {
+      const outcomeMap = {};
+      if (isPlainObject(raw.outcomes)) {
+        for (const [outcome, pipeRef] of Object.entries(raw.outcomes)) {
+          if (typeof pipeRef === "string" && pipeRef.length > 0) {
+            outcomeMap[outcome] = pipeRef;
+          } else {
+            ctx.diagnostics.push({
+              severity: "warning",
+              code: "invalid-pipe-entry",
+              message: `pipe "${code}": outcome "${outcome}" is not a pipe ref \u2014 skipped`,
+              path: `pipe.${code}.outcomes.${outcome}`
+            });
+          }
+        }
+      }
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeController",
+        expression: (_c = (_b = strOrNull(raw.expression)) != null ? _b : strOrNull(raw.expression_template)) != null ? _c : "",
+        outcome_map: outcomeMap,
+        default_outcome: (_d = strOrNull(raw.default_outcome)) != null ? _d : "",
+        add_alias_from_expression_to: strOrNull(raw.add_alias_from_expression_to)
+      });
+    }
+    case "PipeBatch": {
+      const branchPipeCode = strOrNull(raw.branch_pipe_code);
+      if (branchPipeCode === null) {
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "invalid-pipe-entry",
+          message: `pipe "${code}": PipeBatch without branch_pipe_code`,
+          path: `pipe.${code}.branch_pipe_code`
+        });
+      }
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeController",
+        branch_pipe_code: branchPipeCode != null ? branchPipeCode : "",
+        batch_params: {
+          input_list_stuff_name: (_e = strOrNull(raw.input_list_name)) != null ? _e : "",
+          input_item_stuff_name: (_f = strOrNull(raw.input_item_name)) != null ? _f : ""
+        }
+      });
+    }
+    case "PipeLLM": {
+      const systemPrompt = strOrNull(raw.system_prompt);
+      const prompt = strOrNull(raw.prompt);
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        llm_prompt_spec: {
+          templating_style: null,
+          system_prompt_blueprint: systemPrompt === null ? null : makeTemplate(systemPrompt, "llm_prompt"),
+          prompt_blueprint: prompt === null ? null : makeTemplate(prompt, "llm_prompt"),
+          user_image_references: null,
+          user_document_references: null,
+          system_image_references: null,
+          system_document_references: null
+        },
+        llm_choices: {
+          for_text: modelToString(raw.model),
+          for_object: modelToString(raw.model_to_structure)
+        },
+        structuring_method: strOrNull(raw.structuring_method),
+        output_multiplicity: null
+      });
+    }
+    case "PipeStructure": {
+      const inputNames = Object.keys(base.inputs);
+      const llmChoice = isPlainObject(raw.model) ? raw.model : strOrNull(raw.model);
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        llm_choice: llmChoice,
+        text_input_name: (_g = inputNames[0]) != null ? _g : "text",
+        output_multiplicity: null
+      });
+    }
+    case "PipeExtract": {
+      const isImageLike = (spec) => spec.concept.domain_code === NATIVE_DOMAIN && spec.concept.code === "Image" || spec.concept.refines === `${NATIVE_DOMAIN}.Image`;
+      const inputEntries = Object.entries(base.inputs);
+      const imageInput = inputEntries.find(([, spec]) => isImageLike(spec));
+      const documentInput = imageInput === void 0 ? inputEntries[0] : void 0;
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        extract_choice: modelToString(raw.model),
+        should_caption_images: raw.page_image_captions === true,
+        max_page_images: intOrNull(raw.max_page_images),
+        should_include_page_views: raw.page_views === true,
+        page_views_dpi: intOrNull(raw.page_views_dpi),
+        render_js: boolOrNull(raw.render_js),
+        include_raw_html: boolOrNull(raw.include_raw_html),
+        image_stuff_name: (_h = imageInput == null ? void 0 : imageInput[0]) != null ? _h : null,
+        document_stuff_name: (_i = documentInput == null ? void 0 : documentInput[0]) != null ? _i : null
+      });
+    }
+    case "PipeSearch":
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        search_choice: modelToString(raw.model),
+        prompt_blueprint: makeTemplate((_j = strOrNull(raw.prompt)) != null ? _j : "", "basic"),
+        include_images_override: boolOrNull(raw.include_images),
+        max_results_override: intOrNull(raw.max_results),
+        from_date: strOrNull(raw.from_date),
+        to_date: strOrNull(raw.to_date),
+        include_domains: stringArrayOrNull(raw.include_domains),
+        exclude_domains: stringArrayOrNull(raw.exclude_domains),
+        is_structured_output: false
+      });
+    case "PipeImgGen": {
+      const prompt = strOrNull(raw.prompt);
+      const negativePrompt = strOrNull(raw.negative_prompt);
+      const seed = (_k = intOrNull(raw.seed)) != null ? _k : raw.seed === "auto" ? "auto" : null;
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        img_gen_prompt_blueprint: {
+          prompt_blueprint: prompt === null ? null : makeTemplate(prompt, "img_gen_prompt"),
+          negative_prompt_blueprint: negativePrompt === null ? null : makeTemplate(negativePrompt, "img_gen_prompt"),
+          image_references: null
+        },
+        img_gen_choice: modelToString(raw.model),
+        aspect_ratio: strOrNull(raw.aspect_ratio),
+        is_raw: boolOrNull(raw.is_raw),
+        seed,
+        background: strOrNull(raw.background),
+        output_format: strOrNull(raw.output_format),
+        output_multiplicity: typeof base.output.multiplicity === "number" ? base.output.multiplicity : 1
+      });
+    }
+    case "PipeCompose": {
+      const rawTemplate = raw.template;
+      let template = null;
+      let templatingStyle = null;
+      let category = "basic";
+      let extraContext = null;
+      if (typeof rawTemplate === "string") {
+        template = rawTemplate;
+      } else if (isPlainObject(rawTemplate)) {
+        template = strOrNull(rawTemplate.template);
+        templatingStyle = strOrNull(rawTemplate.templating_style);
+        category = (_l = strOrNull(rawTemplate.category)) != null ? _l : category;
+        extraContext = isPlainObject(rawTemplate.extra_context) ? rawTemplate.extra_context : null;
+      }
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: "PipeOperator",
+        template,
+        templating_style: templatingStyle,
+        category,
+        extra_context: extraContext,
+        construct_blueprint: normalizeConstruct(raw.construct)
+      });
+    }
+    case "PipeFunc":
+      return __spreadProps(__spreadValues({}, base), { type, pipe_category: "PipeOperator" });
+    case "PipeSignature": {
+      const signatureFor = strOrNull(raw.signature_for);
+      return __spreadProps(__spreadValues({}, base), {
+        type,
+        pipe_category: null,
+        signature_for: signatureFor !== null && KNOWN_PIPE_TYPES.has(signatureFor) ? signatureFor : null
+      });
+    }
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/static-graph/parseMthdsBundle.ts
+var FIELD_TYPE_TO_JSON = {
+  text: { type: "string" },
+  integer: { type: "integer" },
+  number: { type: "number" },
+  boolean: { type: "boolean" },
+  date: { type: "string", format: "date-time" },
+  list: { type: "array" },
+  dict: { type: "object" },
+  concept: { type: "object" }
+};
+function fieldSchema(spec) {
+  var _a, _b, _c;
+  const typeName = (_a = strOrNull(spec.type)) != null ? _a : "text";
+  const schema = __spreadValues({}, (_b = FIELD_TYPE_TO_JSON[typeName]) != null ? _b : { type: "string" });
+  const description = strOrNull(spec.description);
+  if (description !== null) schema.description = description;
+  if (typeName === "list") {
+    const itemType = strOrNull(spec.item_type);
+    schema.items = itemType !== null ? __spreadValues({}, (_c = FIELD_TYPE_TO_JSON[itemType]) != null ? _c : {}) : {};
+  }
+  if (Array.isArray(spec.choices)) {
+    schema.enum = spec.choices.filter((choice) => typeof choice === "string");
+  }
+  if (spec.default_value !== void 0 && spec.default_value !== null) {
+    schema.default = spec.default_value;
+  }
+  return schema;
+}
+function deriveJsonSchema(structure, title, description) {
+  if (!isPlainObject(structure)) return void 0;
+  const properties = {};
+  const required = [];
+  for (const [name, spec] of Object.entries(structure)) {
+    if (typeof spec === "string") {
+      properties[name] = { type: "string", description: spec };
+      continue;
+    }
+    if (!isPlainObject(spec)) continue;
+    properties[name] = fieldSchema(spec);
+    if (spec.required === true) required.push(name);
+  }
+  return __spreadValues({
+    title,
+    type: "object",
+    description,
+    properties
+  }, required.length > 0 ? { required } : {});
+}
+function qualifyRefines(raw, domain, declaredCodes) {
+  const parts = parseConceptRef(raw);
+  if (parts === null) return null;
+  if (parts.domain !== null) return `${parts.domain}.${parts.code}`;
+  if (!declaredCodes.has(parts.code) && NATIVE_CONCEPT_CODES.has(parts.code)) {
+    return `${NATIVE_DOMAIN}.${parts.code}`;
+  }
+  return `${domain}.${parts.code}`;
+}
+function parseConcepts(raw, domain, diagnostics) {
+  var _a, _b;
+  const concepts = {};
+  if (raw === void 0) return concepts;
+  if (!isPlainObject(raw)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "invalid-bundle-shape",
+      message: "concept section is not a table \u2014 ignored",
+      path: "concept"
+    });
+    return concepts;
+  }
+  const declaredCodes = new Set(Object.keys(raw));
+  for (const [code, entry] of Object.entries(raw)) {
+    if (typeof entry === "string") {
+      concepts[code] = {
+        code,
+        domain_code: domain,
+        description: entry,
+        structure_class_name: qualifiedStructureClassName(domain, code),
+        refines: null
+      };
+      continue;
+    }
+    if (!isPlainObject(entry)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "invalid-concept-entry",
+        message: `concept "${code}" is neither a table nor a description string \u2014 skipped`,
+        path: `concept.${code}`
+      });
+      continue;
+    }
+    const description = (_a = strOrNull(entry.description)) != null ? _a : "";
+    const structureClassName = (_b = strOrNull(entry.structure)) != null ? _b : qualifiedStructureClassName(domain, code);
+    concepts[code] = {
+      code,
+      domain_code: domain,
+      description,
+      structure_class_name: structureClassName,
+      refines: qualifyRefines(entry.refines, domain, declaredCodes),
+      json_schema: deriveJsonSchema(entry.structure, structureClassName, description)
+    };
+  }
+  return concepts;
+}
+function emptyBundle() {
+  return {
+    domain: null,
+    description: null,
+    main_pipe: null,
+    system_prompt: null,
+    concepts: {},
+    pipes: {}
+  };
+}
+function parseMthdsBundle(tomlText) {
+  var _a;
+  const diagnostics = [];
+  let root;
+  try {
+    root = parseToml(tomlText);
+  } catch (error) {
+    diagnostics.push({
+      severity: "error",
+      code: "toml-parse-error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return { bundle: emptyBundle(), diagnostics };
+  }
+  const bundle = emptyBundle();
+  bundle.domain = strOrNull(root.domain);
+  bundle.description = strOrNull(root.description);
+  bundle.main_pipe = strOrNull(root.main_pipe);
+  bundle.system_prompt = strOrNull(root.system_prompt);
+  if (bundle.domain === null) {
+    diagnostics.push({
+      severity: "warning",
+      code: "missing-domain",
+      message: `bundle declares no domain \u2014 using "${UNKNOWN_DOMAIN}"`,
+      path: "domain"
+    });
+  }
+  const domain = (_a = bundle.domain) != null ? _a : UNKNOWN_DOMAIN;
+  bundle.concepts = parseConcepts(root.concept, domain, diagnostics);
+  const pipeTable = root.pipe;
+  if (pipeTable !== void 0) {
+    if (!isPlainObject(pipeTable)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "invalid-bundle-shape",
+        message: "pipe section is not a table \u2014 ignored",
+        path: "pipe"
+      });
+    } else {
+      const ctx = { domain, concepts: bundle.concepts, diagnostics };
+      for (const [code, entry] of Object.entries(pipeTable)) {
+        if (!isPlainObject(entry)) {
+          diagnostics.push({
+            severity: "error",
+            code: "invalid-pipe-entry",
+            message: `pipe "${code}" is not a table \u2014 skipped`,
+            path: `pipe.${code}`
+          });
+          continue;
+        }
+        const pipe = normalizePipe(code, entry, ctx);
+        if (pipe !== null) bundle.pipes[code] = pipe;
+      }
+    }
+  }
+  return { bundle, diagnostics };
+}
+
+// src/static-graph/mergeBundles.ts
+function enrichPipeConcepts(pipe, domains) {
+  const enrichSpec = (spec) => {
+    var _a;
+    const declared = (_a = domains[spec.concept.domain_code]) == null ? void 0 : _a.concepts[spec.concept.code];
+    return declared !== void 0 && declared !== spec.concept ? __spreadProps(__spreadValues({}, spec), { concept: declared }) : spec;
+  };
+  const inputs = {};
+  for (const [name, spec] of Object.entries(pipe.inputs)) {
+    inputs[name] = enrichSpec(spec);
+  }
+  return __spreadProps(__spreadValues({}, pipe), { inputs, output: enrichSpec(pipe.output) });
+}
+function mergeBundles(bundles) {
+  var _a, _b;
+  const diagnostics = [];
+  const domains = {};
+  let mainDomain = null;
+  let mainPipe = null;
+  let description = null;
+  for (const bundle of bundles) {
+    const domain = (_a = bundle.domain) != null ? _a : UNKNOWN_DOMAIN;
+    const namespace = (_b = domains[domain]) != null ? _b : domains[domain] = { domain, concepts: {}, pipes: {} };
+    if (mainDomain === null && bundle.domain !== null) mainDomain = bundle.domain;
+    if (mainPipe === null && bundle.main_pipe !== null) {
+      mainPipe = bundle.main_pipe;
+      mainDomain = domain;
+    }
+    if (description === null && bundle.description !== null) description = bundle.description;
+    for (const [code, concept] of Object.entries(bundle.concepts)) {
+      if (code in namespace.concepts) {
+        diagnostics.push({
+          severity: "warning",
+          code: "duplicate-concept",
+          message: `concept "${domain}.${code}" declared more than once \u2014 keeping the first declaration`,
+          path: `concept.${code}`
+        });
+        continue;
+      }
+      namespace.concepts[code] = concept;
+    }
+    for (const [code, pipe] of Object.entries(bundle.pipes)) {
+      if (code in namespace.pipes) {
+        diagnostics.push({
+          severity: "warning",
+          code: "duplicate-pipe",
+          message: `pipe "${domain}.${code}" declared more than once \u2014 keeping the first declaration`,
+          path: `pipe.${code}`
+        });
+        continue;
+      }
+      namespace.pipes[code] = pipe;
+    }
+  }
+  for (const namespace of Object.values(domains)) {
+    for (const [code, pipe] of Object.entries(namespace.pipes)) {
+      namespace.pipes[code] = enrichPipeConcepts(pipe, domains);
+    }
+  }
+  return { domains, mainDomain, mainPipe, description, diagnostics };
+}
+
+// src/static-graph/buildStaticGraphSpec.ts
+function buildStaticGraphSpec(set, options = {}) {
+  var _a;
+  const diagnostics = [];
+  const ctx = {
+    set,
+    nodes: [],
+    edges: [],
+    pipeRegistry: {},
+    conceptRegistry: {},
+    stuffByDigest: /* @__PURE__ */ new Map(),
+    diagnostics,
+    stack: [],
+    edgeSeq: 0
+  };
+  for (const namespace of Object.values(set.domains)) {
+    for (const concept of Object.values(namespace.concepts)) registerConcept(ctx, concept);
+    for (const pipe of Object.values(namespace.pipes)) {
+      ctx.pipeRegistry[`${pipe.domain_code}.${pipe.code}`] = pipe;
+      for (const spec2 of Object.values(pipe.inputs)) registerConcept(ctx, spec2.concept);
+      registerConcept(ctx, pipe.output.concept);
+    }
+  }
+  const entry = pickEntryPipe(set, (_a = options.entryPipe) != null ? _a : null, diagnostics);
+  if (entry !== null) {
+    walkPipe(ctx, entry.code, entry.domain, `${entry.domain}.${entry.code}`, null, /* @__PURE__ */ new Map(), {
+      resultName: null,
+      outputMultiplicity: null
+    });
+  }
+  const spec = {
+    nodes: ctx.nodes,
+    edges: ctx.edges,
+    meta: { format: "mthds", mode: "static" },
+    pipe_registry: ctx.pipeRegistry,
+    concept_registry: ctx.conceptRegistry
+  };
+  if (entry !== null) {
+    spec.pipeline_ref = { domain: entry.domain, main_pipe: entry.code };
+  }
+  return { spec, diagnostics };
+}
+function buildStaticGraphSpecFromToml(tomlTexts, options = {}) {
+  const texts = Array.isArray(tomlTexts) ? tomlTexts : [tomlTexts];
+  const parsed = texts.map((text) => parseMthdsBundle(text));
+  const merged = mergeBundles(parsed.map((result) => result.bundle));
+  const built = buildStaticGraphSpec(merged, options);
+  return {
+    spec: built.spec,
+    diagnostics: [
+      ...parsed.flatMap((result) => result.diagnostics),
+      ...merged.diagnostics,
+      ...built.diagnostics
+    ]
+  };
+}
+function resolvePipeRef(set, ref, currentDomain) {
+  var _a;
+  if (ref.includes("->")) return { kind: "opaque" };
+  const dot = ref.lastIndexOf(".");
+  const domain = dot === -1 ? currentDomain : ref.slice(0, dot);
+  const code = dot === -1 ? ref : ref.slice(dot + 1);
+  const blueprint = (_a = set.domains[domain]) == null ? void 0 : _a.pipes[code];
+  if (blueprint === void 0) return { kind: "unresolved" };
+  return { kind: "resolved", blueprint, domain, code };
+}
+function referencedPipeCodes(namespace) {
+  const refs = /* @__PURE__ */ new Set();
+  const add = (ref) => {
+    if (ref === "" || ref.includes("->")) return;
+    const dot = ref.lastIndexOf(".");
+    if (dot === -1) refs.add(ref);
+    else if (ref.slice(0, dot) === namespace.domain) refs.add(ref.slice(dot + 1));
+  };
+  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);
+        break;
+      case "PipeParallel":
+        for (const sub of pipe.parallel_sub_pipes) add(sub.pipe_code);
+        break;
+      case "PipeCondition":
+        for (const target of Object.values(pipe.outcome_map)) add(target);
+        add(pipe.default_outcome);
+        break;
+      case "PipeBatch":
+        add(pipe.branch_pipe_code);
+        break;
+      default:
+        break;
+    }
+  }
+  return refs;
+}
+function pickEntryPipe(set, explicitRef, diagnostics) {
+  var _a, _b;
+  const domainsInOrder = Object.keys(set.domains);
+  const fallbackDomain = (_a = set.mainDomain) != null ? _a : domainsInOrder[0];
+  if (fallbackDomain === void 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "no-entry-pipe",
+      message: "no bundles to build a graph from"
+    });
+    return null;
+  }
+  const resolveEntry = (ref) => {
+    const resolution = resolvePipeRef(set, ref, fallbackDomain);
+    return resolution.kind === "resolved" ? { domain: resolution.domain, code: resolution.code } : null;
+  };
+  if (explicitRef !== null) {
+    const entry = resolveEntry(explicitRef);
+    if (entry === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "unresolved-pipe-ref",
+        message: `entry pipe "${explicitRef}" not found in the method set`
+      });
+    }
+    return entry;
+  }
+  if (set.mainPipe !== null) {
+    const entry = resolveEntry(set.mainPipe);
+    if (entry !== null) return entry;
+    diagnostics.push({
+      severity: "warning",
+      code: "unresolved-pipe-ref",
+      message: `main_pipe "${set.mainPipe}" not found \u2014 falling back to a root heuristic`
+    });
+  } else {
+    diagnostics.push({
+      severity: "warning",
+      code: "missing-main-pipe",
+      message: "no main_pipe declared \u2014 falling back to a root heuristic"
+    });
+  }
+  const domainWithPipes = [fallbackDomain, ...domainsInOrder].find(
+    (domain) => {
+      var _a2, _b2;
+      return Object.keys((_b2 = (_a2 = set.domains[domain]) == null ? void 0 : _a2.pipes) != null ? _b2 : {}).length > 0;
+    }
+  );
+  if (domainWithPipes === void 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "no-entry-pipe",
+      message: "no pipes found in any bundle"
+    });
+    return null;
+  }
+  const namespace = set.domains[domainWithPipes];
+  const referenced = referencedPipeCodes(namespace);
+  const codes = Object.keys(namespace.pipes);
+  const root = (_b = codes.find((code) => !referenced.has(code))) != null ? _b : codes[0];
+  return { domain: domainWithPipes, code: root };
+}
+function snakeCase(code) {
+  return code.replace(/([A-Z]+)([A-Z][a-z0-9])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function registerConcept(ctx, concept) {
+  var _a, _b, _c;
+  (_c = (_a = ctx.conceptRegistry)[_b = `${concept.domain_code}.${concept.code}`]) != null ? _c : _a[_b] = concept;
+}
+function mintStuff(ctx, digest, name, concept, multiplicity) {
+  const existing = ctx.stuffByDigest.get(digest);
+  if (existing !== void 0) return existing;
+  const record = { digest, name, concept, multiplicity };
+  ctx.stuffByDigest.set(digest, record);
+  registerConcept(ctx, concept);
+  return record;
+}
+function ioItem(stuff, slotName) {
+  return { name: slotName != null ? slotName : stuff.name, digest: stuff.digest, concept: stuff.concept.code };
+}
+function addEdge(ctx, kind, source, target, extras) {
+  const edge = { id: `static:edge_${ctx.edgeSeq++}`, source, target, kind };
+  if ((extras == null ? void 0 : extras.label) !== void 0) edge.label = extras.label;
+  if ((extras == null ? void 0 : extras.sourceStuff) !== void 0) edge.source_stuff_digest = extras.sourceStuff;
+  if ((extras == null ? void 0 : extras.targetStuff) !== void 0) edge.target_stuff_digest = extras.targetStuff;
+  ctx.edges.push(edge);
+}
+function addNodeTag(node, key, value) {
+  var _a;
+  node.tags = __spreadProps(__spreadValues({}, (_a = node.tags) != null ? _a : {}), { [key]: value });
+}
+function formatBatchMultiplicity(multiplicity) {
+  if (typeof multiplicity === "number") return `x${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);
+    if (bound === void 0) {
+      bound = mintStuff(ctx, `input:${name}`, name, spec.concept, spec.multiplicity);
+      scope.set(name, bound);
+      if (conceptKey(bound.concept) !== conceptKey(spec.concept)) {
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "conflicting-input-concept",
+          message: `pipe "${blueprint.code}": dangling input "${name}" is declared as ${conceptKey(spec.concept)} here but was first seen as ${conceptKey(bound.concept)} \u2014 keeping the first`,
+          path: `pipe.${blueprint.code}.inputs.${name}`
+        });
+      }
+    }
+    ioInputs.push(ioItem(bound));
+  }
+  return ioInputs;
+}
+function emitNode(ctx, args) {
+  const node = {
+    id: args.id,
+    kind: args.kind,
+    pipe_code: args.pipeCode,
+    pipe_type: args.pipeType,
+    // validateGraphSpec requires a non-empty description; WIP pipes may lack one.
+    description: args.description.length > 0 ? args.description : args.pipeCode,
+    domain_code: args.domainCode,
+    status: "scheduled",
+    io: { inputs: args.ioInputs, outputs: [] }
+  };
+  if (args.inv.outcomeValue !== void 0) node.tags = { outcome: args.inv.outcomeValue };
+  ctx.nodes.push(node);
+  if (args.parentId !== null) {
+    addEdge(
+      ctx,
+      "contains",
+      args.parentId,
+      args.id,
+      args.inv.outcomeValue !== void 0 ? { label: args.inv.outcomeValue } : void 0
+    );
+  }
+  return node;
+}
+function walkPipe(ctx, ref, currentDomain, nodeId, parentId, scope, inv) {
+  const resolution = resolvePipeRef(ctx.set, ref, currentDomain);
+  if (resolution.kind === "unresolved") {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unresolved-pipe-ref",
+      message: `pipe ref "${ref}" cannot be resolved \u2014 node skipped`,
+      path: nodeId
+    });
+    return null;
+  }
+  if (resolution.kind === "opaque") {
+    return emitOpaqueLeaf(ctx, ref, currentDomain, nodeId, parentId, inv);
+  }
+  const { blueprint, domain, code } = resolution;
+  const qualified = `${domain}.${code}`;
+  const ioInputs = bindInputs(ctx, blueprint, scope);
+  const node = emitNode(ctx, {
+    id: nodeId,
+    kind: blueprint.pipe_category === "PipeController" ? "controller" : "operator",
+    pipeCode: code,
+    pipeType: blueprint.type,
+    description: blueprint.description,
+    domainCode: blueprint.domain_code,
+    ioInputs,
+    parentId,
+    inv
+  });
+  if (ctx.stack.includes(qualified)) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "cyclic-pipe-ref",
+      message: `pipe "${qualified}" is invoked recursively \u2014 rendered as a leaf`,
+      path: nodeId
+    });
+    return finishLeaf(ctx, node, blueprint, nodeId, inv);
+  }
+  ctx.stack.push(qualified);
+  try {
+    switch (blueprint.type) {
+      case "PipeSequence":
+        return finishSequence(ctx, node, blueprint, nodeId, scope, inv);
+      case "PipeParallel":
+        return finishParallel(ctx, node, blueprint, nodeId, scope, inv);
+      case "PipeCondition":
+        return finishCondition(ctx, node, blueprint, nodeId, scope, inv);
+      case "PipeBatch":
+        return finishBatch(ctx, node, blueprint, nodeId, scope, inv);
+      default:
+        return finishLeaf(ctx, node, blueprint, nodeId, inv);
+    }
+  } finally {
+    ctx.stack.pop();
+  }
+}
+function walkSubPipe(ctx, sub, domain, nodeId, parentId, scope) {
+  if (sub.batch_params !== null) {
+    return walkInlineBatch(ctx, sub, domain, nodeId, parentId, scope);
+  }
+  return walkPipe(ctx, sub.pipe_code, domain, nodeId, parentId, scope, {
+    resultName: sub.output_name,
+    outputMultiplicity: sub.output_multiplicity
+  });
+}
+function finishLeaf(ctx, node, blueprint, nodeId, inv) {
+  var _a;
+  const name = (_a = inv.resultName) != null ? _a : snakeCase(blueprint.output.concept.code);
+  const multiplicity = typeof inv.outputMultiplicity === "number" || inv.outputMultiplicity === true ? inv.outputMultiplicity : blueprint.output.multiplicity;
+  const output = mintStuff(ctx, `${nodeId}:${name}`, name, blueprint.output.concept, multiplicity);
+  node.io.outputs = [ioItem(output)];
+  return { nodeId, output, eachOutputs: [] };
+}
+function emitOpaqueLeaf(ctx, ref, currentDomain, nodeId, parentId, inv) {
+  var _a;
+  const alias = ref.slice(0, ref.indexOf("->"));
+  const tail = ref.slice(ref.lastIndexOf("->") + 2);
+  const codeTail = tail.slice(tail.lastIndexOf(".") + 1);
+  const node = emitNode(ctx, {
+    id: nodeId,
+    kind: "operator",
+    pipeCode: codeTail.length > 0 ? codeTail : ref,
+    pipeType: "PipeSignature",
+    description: `External pipe from dependency "${alias}"`,
+    domainCode: alias.length > 0 ? alias : currentDomain,
+    ioInputs: [],
+    parentId,
+    inv
+  });
+  const name = (_a = inv.resultName) != null ? _a : "output";
+  const output = mintStuff(ctx, `${nodeId}:${name}`, name, nativeConceptInfo("Anything"), null);
+  node.io.outputs = [ioItem(output)];
+  return { nodeId, output, eachOutputs: [] };
+}
+function finishSequence(ctx, node, blueprint, nodeId, scope, inv) {
+  let lastOutput = null;
+  blueprint.sequential_sub_pipes.forEach((sub, index) => {
+    const result = walkSubPipe(
+      ctx,
+      sub,
+      blueprint.domain_code,
+      `${nodeId}/step_${index + 1}`,
+      nodeId,
+      scope
+    );
+    if (result === null) return;
+    if (result.output !== null) {
+      if (sub.output_name !== null) scope.set(sub.output_name, result.output);
+      lastOutput = result.output;
+    }
+    for (const [name, stuff] of result.eachOutputs) scope.set(name, stuff);
+  });
+  node.io.outputs = lastOutput === null ? [] : [ioItem(lastOutput, inv.resultName)];
+  return { nodeId, output: lastOutput, eachOutputs: [] };
+}
+function finishParallel(ctx, node, blueprint, nodeId, scope, inv) {
+  var _a, _b;
+  const branchResults = [];
+  blueprint.parallel_sub_pipes.forEach((sub, index) => {
+    const result = walkSubPipe(
+      ctx,
+      sub,
+      blueprint.domain_code,
+      `${nodeId}/branch_${index + 1}`,
+      nodeId,
+      new Map(scope)
+    );
+    if (result !== null) branchResults.push({ sub, result });
+  });
+  const eachOutputs = [];
+  if (blueprint.add_each_output) {
+    for (const { sub, result } of branchResults) {
+      if (sub.output_name !== null && result.output !== null) {
+        eachOutputs.push([sub.output_name, result.output]);
+      }
+    }
+  }
+  const combinedName = (_b = (_a = blueprint.combined_output) != null ? _a : inv.resultName) != null ? _b : snakeCase(blueprint.output.concept.code);
+  const combined = mintStuff(
+    ctx,
+    `${nodeId}:${combinedName}`,
+    combinedName,
+    blueprint.output.concept,
+    blueprint.output.multiplicity
+  );
+  for (const { result } of branchResults) {
+    if (result.output !== null) {
+      addEdge(ctx, "parallel_combine", result.nodeId, nodeId, {
+        sourceStuff: result.output.digest,
+        targetStuff: combined.digest
+      });
+    }
+  }
+  node.io.outputs = [ioItem(combined, inv.resultName)];
+  return { nodeId, output: combined, eachOutputs };
+}
+function finishCondition(ctx, node, blueprint, nodeId, scope, inv) {
+  var _a, _b, _c, _d;
+  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)
+    );
+  }
+  const targets = [];
+  const byRef = /* @__PURE__ */ new Map();
+  const addRoute = (value, ref, isDefault) => {
+    if (ref === "" || ref === "fail" || ref === "continue") return;
+    const existing = byRef.get(ref);
+    if (existing !== void 0) {
+      existing.values.push(value);
+      existing.viaDefault || (existing.viaDefault = isDefault);
+      return;
+    }
+    const entry = { values: [value], ref, viaDefault: isDefault };
+    byRef.set(ref, entry);
+    targets.push(entry);
+  };
+  for (const [value, target] of Object.entries(blueprint.outcome_map)) {
+    addRoute(value, target, false);
+  }
+  addRoute("default", blueprint.default_outcome, true);
+  const results = [];
+  for (const entry of targets) {
+    const idSegment = entry.viaDefault && entry.values.length === 1 ? "default" : `outcome_${entry.values[0]}`;
+    const result = walkPipe(
+      ctx,
+      entry.ref,
+      blueprint.domain_code,
+      `${nodeId}/${idSegment}`,
+      nodeId,
+      new Map(conditionScope),
+      {
+        // The runtime stores whichever branch runs under the condition's own
+        // slot name, so every branch's output carries it (dry-run parity).
+        resultName: inv.resultName,
+        outputMultiplicity: null,
+        outcomeValue: entry.values.join(" | ")
+      }
+    );
+    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: [] };
+}
+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);
+    if (bound !== void 0) {
+      listStuff = bound;
+    } else {
+      listStuff = mintStuff(
+        ctx,
+        `input:${params.input_list_stuff_name}`,
+        params.input_list_stuff_name,
+        nativeConceptInfo("Anything"),
+        true
+      );
+      node.io.inputs.push(ioItem(listStuff));
+    }
+  }
+  let itemStuff = null;
+  const branchScope = new Map(scope);
+  if (params.input_item_stuff_name !== "" && listStuff !== null) {
+    itemStuff = mintStuff(
+      ctx,
+      `${nodeId}:${params.input_item_stuff_name}`,
+      params.input_item_stuff_name,
+      listStuff.concept,
+      null
+    );
+    branchScope.set(params.input_item_stuff_name, itemStuff);
+  }
+  const batchMultiplicity = formatBatchMultiplicity(listStuff == null ? void 0 : listStuff.multiplicity);
+  addNodeTag(node, "batch_multiplicity", batchMultiplicity);
+  let branchResult = null;
+  if (blueprint.branch_pipe_code !== "") {
+    branchResult = walkPipe(
+      ctx,
+      blueprint.branch_pipe_code,
+      blueprint.domain_code,
+      `${nodeId}/batch_branch`,
+      nodeId,
+      branchScope,
+      { resultName: null, outputMultiplicity: null }
+    );
+    const branchNode = ctx.nodes.find((candidate) => candidate.id === (branchResult == null ? void 0 : branchResult.nodeId));
+    if (branchNode !== void 0) {
+      addNodeTag(branchNode, "batch_multiplicity", batchMultiplicity);
+    }
+  }
+  const aggConcept = (_b = (_a = branchResult == null ? void 0 : branchResult.output) == null ? void 0 : _a.concept) != null ? _b : blueprint.output.concept;
+  const aggName = (_c = inv.resultName) != null ? _c : snakeCase(aggConcept.code);
+  const aggregate = mintStuff(ctx, `${nodeId}:${aggName}`, aggName, aggConcept, true);
+  if (branchResult !== null && listStuff !== null && itemStuff !== null) {
+    addEdge(ctx, "batch_item", nodeId, branchResult.nodeId, {
+      sourceStuff: listStuff.digest,
+      targetStuff: itemStuff.digest
+    });
+  }
+  if ((branchResult == null ? void 0 : branchResult.output) != null) {
+    addEdge(ctx, "batch_aggregate", branchResult.nodeId, nodeId, {
+      sourceStuff: branchResult.output.digest,
+      targetStuff: aggregate.digest
+    });
+  }
+  node.io.outputs = [ioItem(aggregate)];
+  return { nodeId, output: aggregate, eachOutputs: [] };
+}
+function walkInlineBatch(ctx, sub, domain, nodeId, parentId, scope) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const params = sub.batch_params;
+  const aliasIdx = sub.pipe_code.lastIndexOf("->");
+  const refTail = aliasIdx === -1 ? sub.pipe_code : sub.pipe_code.slice(aliasIdx + 2);
+  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 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"),
+    multiplicity: null
+  };
+  const baseCode = `${branchTail}_batch`;
+  let code = baseCode;
+  for (let suffix = 2; ; suffix++) {
+    const existing = ctx.pipeRegistry[`${domain}.${code}`];
+    if (existing === void 0 || existing.type === "PipeBatch" && existing.branch_pipe_code === sub.pipe_code && existing.batch_params.input_list_stuff_name === params.input_list_stuff_name && existing.batch_params.input_item_stuff_name === params.input_item_stuff_name) {
+      break;
+    }
+    code = `${baseCode}_${suffix}`;
+  }
+  const blueprint = {
+    type: "PipeBatch",
+    pipe_category: "PipeController",
+    code,
+    domain_code: domain,
+    description: `Batch processing for ${branchTail}`,
+    inputs: { [params.input_list_stuff_name]: { concept: listConcept, multiplicity: null } },
+    output: { concept: outputSpec.concept, multiplicity: null },
+    branch_pipe_code: sub.pipe_code,
+    batch_params: params
+  };
+  (_g = (_e = ctx.pipeRegistry)[_f = `${domain}.${code}`]) != null ? _g : _e[_f] = blueprint;
+  const ioInputs = bindInputs(ctx, blueprint, scope);
+  const inv = {
+    resultName: sub.output_name,
+    outputMultiplicity: sub.output_multiplicity
+  };
+  const node = emitNode(ctx, {
+    id: nodeId,
+    kind: "controller",
+    pipeCode: code,
+    pipeType: "PipeBatch",
+    description: blueprint.description,
+    domainCode: domain,
+    ioInputs,
+    parentId,
+    inv
+  });
+  return finishBatch(ctx, node, blueprint, nodeId, scope, inv);
+}
+
+// src/static-graph/validationIssues.ts
+function staticDiagnosticsToValidationIssues(diagnostics) {
+  return diagnostics.map((diagnostic) => ({
+    severity: diagnostic.severity,
+    message: diagnostic.message,
+    context: diagnostic.path,
+    origin: "static"
+  }));
+}
+export {
+  NATIVE_CONCEPT_CODES,
+  NATIVE_DOMAIN,
+  UNKNOWN_DOMAIN,
+  buildStaticGraphSpec,
+  buildStaticGraphSpecFromToml,
+  mergeBundles,
+  parseConceptRef,
+  parseMthdsBundle,
+  staticDiagnosticsToValidationIssues
+};
+//# sourceMappingURL=index.js.map