@pipelex/mthds-ui 0.31.0 → 0.33.0

package/dist/static-graph/index.d.ts

@@ -1,4 +1,4 @@
-import { C as ConceptInfo, P as PipeBlueprintUnion, a as PresenceMarker, b as GraphSpec, V as ValidationIssue } from '../types-KYRgLdlh.js';
+import { C as ConceptInfo, P as PipeBlueprintUnion, a as PresenceMarker, b as GraphSpec, V as ValidationIssue } from '../types-MvxsDLCo.js';
 export { P as ParsedPipeRef, m as makePipeRef, p as parsePipeRef } from '../pipeRefs-BQJO5nh5.js';
 
 type DiagnosticSeverity = "error" | "warning";

package/dist/static-graph/index.js

@@ -7,7 +7,7 @@ import {
   KNOWN_PIPE_TYPES,
   isBindingStepSpec,
   isPluralMultiplicity
-} from "../chunk-QRO3TYZE.js";
+} from "../chunk-TMZ2JR2J.js";
 import {
   __spreadProps,
   __spreadValues
@@ -275,6 +275,7 @@ function stringArrayOrNull(value) {
   return value.filter((item) => typeof item === "string");
 }
 var PLAIN_NAME_RE = /^[a-z][a-z0-9_]*$/;
+var PRIVATE_BINDING_NAME_PREFIX = "_bound_";
 function bindingStepFor(dottedPath) {
   const plainName = dottedPath.slice(dottedPath.lastIndexOf(".") + 1);
   return `{ from = "${dottedPath}", result = "${plainName}" }`;
@@ -283,13 +284,61 @@ 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) {
+function isDottedFieldPath(name) {
   const segments = name.split(".");
-  if (segments.length > 1 && segments.every((segment) => PLAIN_NAME_RE.test(segment))) {
+  return segments.length > 1 && segments.every((segment) => PLAIN_NAME_RE.test(segment));
+}
+function invalidInputNameReason(name) {
+  if (isDottedFieldPath(name)) {
     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 reportInvalidStoredName(name, storedUnder, pipeCode, path, ctx) {
+  if (name === null || PLAIN_NAME_RE.test(name)) return;
+  let why;
+  if (name.startsWith(PRIVATE_BINDING_NAME_PREFIX)) {
+    why = `and the prefix "${PRIVATE_BINDING_NAME_PREFIX}" is reserved for the runtime's own names`;
+  } else if (name.includes(".")) {
+    why = "and an input names one whole value, so its name cannot reach into a field with a dot";
+  } else {
+    why = "and an input name is a lowercase letter followed by lowercase letters, digits and underscores";
+  }
+  ctx.diagnostics.push({
+    severity: "warning",
+    code: "invalid-input-name",
+    message: `pipe "${pipeCode}": ${storedUnder} "${name}", which is not a plain input name: a pipe reads the value through an input, ${why} \u2014 drawn as written`,
+    path
+  });
+}
+function reportInvalidBatchListName(name, branchPipeCode, pipeCode, ctx) {
+  if (name === null || PLAIN_NAME_RE.test(name)) return;
+  let why;
+  if (isDottedFieldPath(name)) {
+    const plainName = name.slice(name.lastIndexOf(".") + 1);
+    const branch = branchPipeCode === null ? "the branch pipe" : `"${branchPipeCode}"`;
+    why = `: a PipeBatch maps over a list it declares as an input of its own, so declare the list as "${plainName}" and have the calling sequence bind the field to it with a binding step (${bindingStepFor(name)}), or have the calling sequence run ${branch} in a step that batches over the field itself`;
+  } else {
+    why = ", which is a lowercase letter followed by lowercase letters, digits and underscores";
+  }
+  ctx.diagnostics.push({
+    severity: "warning",
+    code: "invalid-input-name",
+    message: `pipe "${pipeCode}": input_list_name "${name}" is not a plain input name${why} \u2014 drawn as written`,
+    path: `pipe.${pipeCode}.input_list_name`
+  });
+}
+function reportReservedBatchOver(batchOver, pipeRef, pipeCode, path, ctx) {
+  if (batchOver === null || batchOver.includes(".") || !batchOver.startsWith(PRIVATE_BINDING_NAME_PREFIX)) {
+    return;
+  }
+  ctx.diagnostics.push({
+    severity: "warning",
+    code: "invalid-input-name",
+    message: `pipe "${pipeCode}": sub-pipe "${pipeRef}" batches over "${batchOver}", which takes the prefix "${PRIVATE_BINDING_NAME_PREFIX}" the runtime reserves for the list a dotted batch_over binds, a name only the runtime writes or reads \u2014 drawn as written`,
+    path
+  });
+}
 function tomlKey(key) {
   return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
 }
@@ -359,6 +408,24 @@ function normalizeOutput(raw, pipeCode, ctx) {
   });
   return { concept: nativeConceptInfo("Anything"), multiplicity: null, presence: "plain" };
 }
+function reportSubPipeNames(raw, pipeCode, path, ctx) {
+  const pipeRef = raw.pipe;
+  reportInvalidStoredName(
+    strOrNull(raw.result),
+    `sub-pipe "${pipeRef}" stores its result under`,
+    pipeCode,
+    `${path}.result`,
+    ctx
+  );
+  reportInvalidStoredName(
+    strOrNull(raw.batch_as),
+    `sub-pipe "${pipeRef}" hands each item to its pipe under`,
+    pipeCode,
+    `${path}.batch_as`,
+    ctx
+  );
+  reportReservedBatchOver(strOrNull(raw.batch_over), pipeRef, pipeCode, `${path}.batch_over`, ctx);
+}
 function normalizeSubPipe(raw, pipeCode, path, ctx) {
   var _a;
   if (strOrNull(raw.pipe) === null) {
@@ -370,6 +437,8 @@ function normalizeSubPipe(raw, pipeCode, path, ctx) {
     });
     return null;
   }
+  const pipeRef = raw.pipe;
+  const result = strOrNull(raw.result);
   const batchOver = strOrNull(raw.batch_over);
   const batchAs = strOrNull(raw.batch_as);
   let batchParams = null;
@@ -379,22 +448,21 @@ function normalizeSubPipe(raw, pipeCode, path, ctx) {
     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`,
+      message: `pipe "${pipeCode}": sub-pipe "${pipeRef}" 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),
+    pipe_code: pipeRef,
+    output_name: result,
     output_multiplicity: outputMultiplicity,
     batch_params: batchParams
   };
 }
 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({
@@ -486,6 +554,7 @@ function normalizeSequenceSteps(raw, pipeCode, inputNames, ctx) {
     }
     const step = normalizeSubPipe(entry, pipeCode, path, ctx);
     if (step === null) return;
+    reportSubPipeNames(entry, pipeCode, path, ctx);
     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)) {
@@ -551,6 +620,7 @@ function normalizeBranchList(raw, pipeCode, ctx) {
       });
       return;
     }
+    reportSubPipeNames(entry, pipeCode, path, ctx);
     branches.push(branch);
   });
   return branches;
@@ -641,7 +711,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, _m;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const typeValue = resolvePipeTypeTag(code, raw, ctx);
   if (typeValue === null) return null;
   const type = typeValue;
@@ -707,13 +777,23 @@ function normalizePipe(code, raw, ctx) {
           path: `pipe.${code}.branch_pipe_code`
         });
       }
+      const inputListName = strOrNull(raw.input_list_name);
+      const inputItemName = strOrNull(raw.input_item_name);
+      reportInvalidBatchListName(inputListName, branchPipeCode, code, ctx);
+      reportInvalidStoredName(
+        inputItemName,
+        "the batch hands each item to its branch pipe under",
+        code,
+        `pipe.${code}.input_item_name`,
+        ctx
+      );
       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 : ""
+          input_list_stuff_name: inputListName != null ? inputListName : "",
+          input_item_stuff_name: inputItemName != null ? inputItemName : ""
         }
       });
     }
@@ -746,7 +826,7 @@ function normalizePipe(code, raw, ctx) {
         type,
         pipe_category: "PipeOperator",
         llm_choice: llmChoice,
-        text_input_name: (_g = inputNames[0]) != null ? _g : "text",
+        text_input_name: (_e = inputNames[0]) != null ? _e : "text",
         output_multiplicity: null
       });
     }
@@ -765,8 +845,8 @@ function normalizePipe(code, raw, ctx) {
         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
+        image_stuff_name: (_f = imageInput == null ? void 0 : imageInput[0]) != null ? _f : null,
+        document_stuff_name: (_g = documentInput == null ? void 0 : documentInput[0]) != null ? _g : null
       });
     }
     case "PipeSearch":
@@ -774,7 +854,7 @@ function normalizePipe(code, raw, ctx) {
         type,
         pipe_category: "PipeOperator",
         search_choice: modelToString(raw.model),
-        prompt_blueprint: makeTemplate((_j = strOrNull(raw.prompt)) != null ? _j : "", "basic"),
+        prompt_blueprint: makeTemplate((_h = strOrNull(raw.prompt)) != null ? _h : "", "basic"),
         include_images_override: boolOrNull(raw.include_images),
         max_results_override: intOrNull(raw.max_results),
         from_date: strOrNull(raw.from_date),
@@ -786,7 +866,7 @@ function normalizePipe(code, raw, ctx) {
     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;
+      const seed = (_i = intOrNull(raw.seed)) != null ? _i : raw.seed === "auto" ? "auto" : null;
       return __spreadProps(__spreadValues({}, base), {
         type,
         pipe_category: "PipeOperator",
@@ -815,7 +895,7 @@ function normalizePipe(code, raw, ctx) {
       } else if (isPlainObject(rawTemplate)) {
         template = strOrNull(rawTemplate.template);
         templatingStyle = strOrNull(rawTemplate.templating_style);
-        category = (_l = strOrNull(rawTemplate.category)) != null ? _l : category;
+        category = (_j = strOrNull(rawTemplate.category)) != null ? _j : category;
         extraContext = isPlainObject(rawTemplate.extra_context) ? rawTemplate.extra_context : null;
       }
       return __spreadProps(__spreadValues({}, base), {
@@ -842,7 +922,7 @@ function normalizePipe(code, raw, ctx) {
       return __spreadProps(__spreadValues({}, base), {
         type,
         pipe_category: "PipeOperator",
-        doc_gen_format: (_m = strOrNull(raw.format)) != null ? _m : "",
+        doc_gen_format: (_k = strOrNull(raw.format)) != null ? _k : "",
         doc_gen_choice: isPlainObject(raw.model) ? raw.model : strOrNull(raw.model),
         template: strOrNull(raw.template),
         template_file: strOrNull(raw.template_file),