@pipelex/mthds-ui 0.14.0 → 0.16.0

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

@@ -1,7 +1,8 @@
-import { C as ConceptInfo, P as PipeBlueprintUnion, G as GraphSpec, V as ValidationIssue } from '../types-CIH1Ae16.js';
+import { C as ConceptInfo, P as PipeBlueprintUnion, G as GraphSpec, V as ValidationIssue } from '../types-DM_Ws3oW.js';
+export { P as ParsedPipeRef, m as makePipeRef, p as parsePipeRef } from '../pipeRefs-BQJO5nh5.js';
 
 type DiagnosticSeverity = "error" | "warning";
-type DiagnosticCode = "toml-parse-error" | "missing-domain" | "invalid-bundle-shape" | "invalid-concept-entry" | "invalid-pipe-entry" | "unknown-pipe-type" | "invalid-concept-ref" | "missing-pipe-output" | "invalid-sub-pipe" | "incomplete-batch-spec" | "duplicate-concept" | "duplicate-pipe" | "unresolved-pipe-ref" | "cyclic-pipe-ref" | "missing-main-pipe" | "no-entry-pipe" | "conflicting-input-concept";
+type DiagnosticCode = "toml-parse-error" | "missing-domain" | "invalid-bundle-shape" | "invalid-concept-entry" | "invalid-pipe-entry" | "unknown-pipe-type" | "retired-signature-tag" | "invalid-concept-ref" | "missing-pipe-output" | "invalid-sub-pipe" | "incomplete-batch-spec" | "duplicate-concept" | "duplicate-pipe" | "unresolved-pipe-ref" | "cyclic-pipe-ref" | "missing-main-pipe" | "no-entry-pipe" | "conflicting-input-concept";
 /**
  * A non-fatal note collected while parsing or merging. `error` means a whole
  * unit could not be interpreted (unparseable TOML, a skipped pipe); `warning`
@@ -13,6 +14,19 @@ interface Diagnostic {
     message: string;
     /** TOML-style locator for the offending entry, e.g. `pipe.analyze_candidate.output`. */
     path?: string;
+    /**
+     * Domain of the bundle namespace the diagnostic belongs to — the declaring-file
+     * identity a host needs to qualify a `pipe.<code>` locator into a full pipe ref
+     * (`domain_code.pipe_code`). Stamped wherever the owning namespace is known:
+     * per-file diagnostics get their bundle's domain ({@link UNKNOWN_DOMAIN} when
+     * the bundle declares none), merge/walk diagnostics the namespace being
+     * processed, and entry selection stamps the diagnostics it can attribute (a
+     * missing or unresolvable `main_pipe` names its declaring domain). Absent only
+     * when no owning bundle can be resolved: unparseable TOML, or entry selection
+     * with no resolvable owner (no bundles, no pipes anywhere, or a host-supplied
+     * entry ref that matches nothing).
+     */
+    domain_code?: string;
 }
 /**
  * One `.mthds` file, parsed and normalized. Pipes are narrowed to the same
@@ -113,7 +127,7 @@ declare function buildStaticGraphSpecFromToml(tomlTexts: string | string[], opti
  * The TOML-style `path` becomes the locator chip; `origin: "static"` lets the
  * panel (and the host's issue policy) distinguish them from validator verdicts.
  * When the path identifies a pipe declaration or a precise invocation, the
- * targeting fields (`pipeCode` / `nodeId`) are filled so the viewer can
+ * targeting fields (`pipeRef` / `nodeId`) are filled so the viewer can
  * decorate the affected graph nodes.
  */
 declare function staticDiagnosticsToValidationIssues(diagnostics: Diagnostic[]): ValidationIssue[];

package/dist/static-graph/index.js

@@ -1,6 +1,8 @@
 import {
-  KNOWN_PIPE_TYPES
-} from "../chunk-GS2KODND.js";
+  KNOWN_PIPE_TYPES,
+  makePipeRef,
+  parsePipeRef
+} from "../chunk-HURB2U53.js";
 import {
   __spreadProps,
   __spreadValues
@@ -26,22 +28,28 @@ function boolOrNull(value) {
 // src/static-graph/conceptRefs.ts
 var NATIVE_DOMAIN = "native";
 var NATIVE_CONCEPT_DESCRIPTIONS = {
-  Dynamic: "Dynamically typed content",
+  Dynamic: "A dynamic concept",
   Text: "A text",
   Image: "An image",
   Document: "A document",
   Html: "HTML content",
-  TextAndImages: "A text with images",
+  TextAndImages: "A text and an image",
   Number: "A number",
-  Page: "The content of a page of a document",
-  JSON: "JSON content",
-  SearchResult: "A search result",
+  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 multiple contents"
+  Composite: "A named composition of contents"
 };
 var NATIVE_CONCEPT_CODES = new Set(
   Object.keys(NATIVE_CONCEPT_DESCRIPTIONS)
 );
+function isNativeConceptCode(code) {
+  return Object.hasOwn(NATIVE_CONCEPT_DESCRIPTIONS, code);
+}
 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;
@@ -58,11 +66,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,
+    description: NATIVE_CONCEPT_DESCRIPTIONS[code],
     structure_class_name: `${code}Content`,
     refines: null
   };
@@ -78,14 +85,14 @@ function stubConceptInfo(code, domain) {
 }
 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);
+    return isNativeConceptCode(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)) {
+  if (parts.domain === null && isNativeConceptCode(parts.code)) {
     return nativeConceptInfo(parts.code);
   }
   return stubConceptInfo(parts.code, currentDomain);
@@ -234,18 +241,41 @@ function normalizeConstruct(raw) {
   }
   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;
+var SIGNATURE_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "inputs",
+  "output",
+  "signature_for"
+]);
+function resolvePipeTypeTag(code, raw, ctx) {
   const typeValue = raw.type;
-  if (typeof typeValue !== "string" || !KNOWN_PIPE_TYPES.has(typeValue)) {
+  if (typeValue === void 0) {
+    const isSignature = raw.output !== void 0 && Object.keys(raw).every((key) => SIGNATURE_ONLY_KEYS.has(key));
+    if (isSignature) return "PipeSignature";
+  } else if (typeValue === "PipeSignature") {
     ctx.diagnostics.push({
-      severity: "error",
-      code: "unknown-pipe-type",
-      message: `pipe "${code}": unknown pipe type ${JSON.stringify(typeValue)} \u2014 pipe skipped`,
+      severity: "warning",
+      code: "retired-signature-tag",
+      message: `pipe "${code}": \`type = "PipeSignature"\` is no longer a pipe type \u2014 delete the \`type\` line. A pipe with no \`type\` and no implementation is a signature (contract only).`,
       path: `pipe.${code}.type`
     });
-    return null;
+    return "PipeSignature";
   }
+  if (typeof typeValue === "string" && KNOWN_PIPE_TYPES.has(typeValue)) {
+    return 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;
+}
+function normalizePipe(code, raw, ctx) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const typeValue = resolvePipeTypeTag(code, raw, ctx);
+  if (typeValue === null) return null;
   const type = typeValue;
   const base = {
     code,
@@ -321,7 +351,6 @@ function normalizePipe(code, raw, ctx) {
         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,
@@ -433,7 +462,7 @@ function normalizePipe(code, raw, ctx) {
       return __spreadProps(__spreadValues({}, base), {
         type,
         pipe_category: null,
-        signature_for: signatureFor !== null && KNOWN_PIPE_TYPES.has(signatureFor) ? signatureFor : null
+        signature_for: signatureFor !== null && signatureFor !== "PipeSignature" && KNOWN_PIPE_TYPES.has(signatureFor) ? signatureFor : null
       });
     }
     default: {
@@ -449,7 +478,9 @@ var FIELD_TYPE_TO_JSON = {
   integer: { type: "integer" },
   number: { type: "number" },
   boolean: { type: "boolean" },
-  date: { type: "string", format: "date-time" },
+  date: { type: "string", format: "date" },
+  datetime: { type: "string", format: "date-time" },
+  time: { type: "string", format: "time" },
   list: { type: "array" },
   dict: { type: "object" },
   concept: { type: "object" }
@@ -496,7 +527,7 @@ 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)) {
+  if (!declaredCodes.has(parts.code) && isNativeConceptCode(parts.code)) {
     return `${NATIVE_DOMAIN}.${parts.code}`;
   }
   return `${domain}.${parts.code}`;
@@ -559,7 +590,7 @@ function emptyBundle() {
   };
 }
 function parseMthdsBundle(tomlText) {
-  var _a;
+  var _a, _b;
   const diagnostics = [];
   let root;
   try {
@@ -613,6 +644,9 @@ function parseMthdsBundle(tomlText) {
       }
     }
   }
+  for (const diagnostic of diagnostics) {
+    (_b = diagnostic.domain_code) != null ? _b : diagnostic.domain_code = domain;
+  }
   return { bundle, diagnostics };
 }
 
@@ -651,7 +685,8 @@ function mergeBundles(bundles) {
           severity: "warning",
           code: "duplicate-concept",
           message: `concept "${domain}.${code}" declared more than once \u2014 keeping the first declaration`,
-          path: `concept.${code}`
+          path: `concept.${code}`,
+          domain_code: domain
         });
         continue;
       }
@@ -663,7 +698,8 @@ function mergeBundles(bundles) {
           severity: "warning",
           code: "duplicate-pipe",
           message: `pipe "${domain}.${code}" declared more than once \u2014 keeping the first declaration`,
-          path: `pipe.${code}`
+          path: `pipe.${code}`,
+          domain_code: domain
         });
         continue;
       }
@@ -806,13 +842,17 @@ function pickEntryPipe(set, explicitRef, diagnostics) {
     diagnostics.push({
       severity: "warning",
       code: "unresolved-pipe-ref",
-      message: `main_pipe "${set.mainPipe}" not found \u2014 falling back to a root heuristic`
+      message: `main_pipe "${set.mainPipe}" not found \u2014 falling back to a root heuristic`,
+      // The owning bundle is known (the namespace that declares this main_pipe),
+      // so stamp it — this is not an ownerless diagnostic.
+      domain_code: fallbackDomain
     });
   } else {
     diagnostics.push({
       severity: "warning",
       code: "missing-main-pipe",
-      message: "no main_pipe declared \u2014 falling back to a root heuristic"
+      message: "no main_pipe declared \u2014 falling back to a root heuristic",
+      domain_code: fallbackDomain
     });
   }
   const domainWithPipes = [fallbackDomain, ...domainsInOrder].find(
@@ -894,7 +934,8 @@ function bindInputs(ctx, blueprint, scope) {
           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}`
+          path: `pipe.${blueprint.code}.inputs.${name}`,
+          domain_code: blueprint.domain_code
         });
       }
     }
@@ -934,7 +975,10 @@ function walkPipe(ctx, ref, currentDomain, nodeId, parentId, scope, inv) {
       severity: "warning",
       code: "unresolved-pipe-ref",
       message: `pipe ref "${ref}" cannot be resolved \u2014 node skipped`,
-      path: nodeId
+      path: nodeId,
+      // The uttering file's domain: a bare ref belongs to the namespace that
+      // wrote it, mirroring the runtime's `_qualify_pipe_ref` inference.
+      domain_code: currentDomain
     });
     return null;
   }
@@ -960,7 +1004,8 @@ function walkPipe(ctx, ref, currentDomain, nodeId, parentId, scope, inv) {
       severity: "warning",
       code: "cyclic-pipe-ref",
       message: `pipe "${qualified}" is invoked recursively \u2014 rendered as a leaf`,
-      path: nodeId
+      path: nodeId,
+      domain_code: domain
     });
     return finishLeaf(ctx, node, blueprint, nodeId, inv);
   }
@@ -1256,12 +1301,12 @@ function walkInlineBatch(ctx, sub, domain, nodeId, parentId, scope) {
 }
 
 // src/static-graph/validationIssues.ts
-function targetFromPath(path) {
+function targetFromPath(path, domainCode) {
   if (!path) return {};
   if (path.includes("/")) return { nodeId: path };
   if (path.startsWith("pipe.")) {
     const code = path.split(".")[1];
-    if (code) return { pipeCode: code };
+    if (code && domainCode) return { pipeRef: makePipeRef(domainCode, code) };
   }
   return {};
 }
@@ -1271,7 +1316,7 @@ function staticDiagnosticsToValidationIssues(diagnostics) {
     message: diagnostic.message,
     context: diagnostic.path,
     origin: "static"
-  }, targetFromPath(diagnostic.path)));
+  }, targetFromPath(diagnostic.path, diagnostic.domain_code)));
 }
 export {
   NATIVE_CONCEPT_CODES,
@@ -1279,9 +1324,11 @@ export {
   UNKNOWN_DOMAIN,
   buildStaticGraphSpec,
   buildStaticGraphSpecFromToml,
+  makePipeRef,
   mergeBundles,
   parseConceptRef,
   parseMthdsBundle,
+  parsePipeRef,
   staticDiagnosticsToValidationIssues
 };
 //# sourceMappingURL=index.js.map