@pipelex/mthds-ui 0.22.0 → 0.24.0

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

@@ -2,7 +2,7 @@ import { C as ConceptInfo, P as PipeBlueprintUnion, a as PresenceMarker, b as Gr
 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" | "retired-signature-tag" | "invalid-concept-ref" | "missing-pipe-output" | "invalid-sub-pipe" | "incomplete-batch-spec" | "duplicate-concept" | "duplicate-pipe" | "signature-type-mismatch" | "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" | "unknown-input-slot-key" | "missing-pipe-output" | "invalid-sub-pipe" | "incomplete-batch-spec" | "duplicate-concept" | "duplicate-pipe" | "signature-type-mismatch" | "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`
@@ -85,6 +85,36 @@ interface ConceptRefParts {
 }
 /** Parse a concept ref string into its parts. Returns null when the ref is not interpretable. */
 declare function parseConceptRef(raw: unknown): ConceptRefParts | null;
+interface InputSlotParts {
+    /** The slot's concept ref parts, or null when the slot is not interpretable. */
+    ref: ConceptRefParts | null;
+    /**
+     * True when an expanded slot table declares no `concept` at all. The key is
+     * required, so there is no ref for a diagnostic to be about — the caller says
+     * the key is missing rather than blaming a ref the author never wrote.
+     */
+    missingConcept: boolean;
+    /** Keys of an expanded slot table this version of the standard does not define. */
+    unknownKeys: string[];
+    /**
+     * True when the table is not a slot table at all but the wreckage of an
+     * unquoted dotted input name — see {@link looksLikeUnquotedDottedName}.
+     */
+    dottedName: boolean;
+}
+/**
+ * Read one `inputs` value, whichever form authored it.
+ *
+ * `hints` is parsed as a known key and then dropped: intent hints are
+ * presentational, and the standard routes them to renderers through the
+ * input-form descriptor, not the GraphSpec (see `docs/static-graph.md`).
+ * Their shape is not checked here for the same reason — a malformed `hints`
+ * table is content this module never reads, so it is the validator's to
+ * report, not the renderer's. An unknown key is different: it may well be
+ * where a future standard puts something that changes the slot, so it is
+ * named rather than passed over.
+ */
+declare function parseInputSlot(raw: unknown): InputSlotParts;
 
 /**
  * Parse one `.mthds` TOML string. Returns whatever could be interpreted plus
@@ -134,4 +164,4 @@ declare function buildStaticGraphSpecFromToml(tomlTexts: string | string[], opti
  */
 declare function staticDiagnosticsToValidationIssues(diagnostics: Diagnostic[]): ValidationIssue[];
 
-export { type ConceptRefParts, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type DomainNamespace, type MergedMethodSet, NATIVE_CONCEPT_CODES, NATIVE_DOMAIN, type ParseMthdsBundleResult, type ParsedBundle, type StaticGraphOptions, type StaticGraphResult, UNKNOWN_DOMAIN, buildStaticGraphSpec, buildStaticGraphSpecFromToml, mergeBundles, parseConceptRef, parseMthdsBundle, staticDiagnosticsToValidationIssues };
+export { type ConceptRefParts, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type DomainNamespace, type InputSlotParts, type MergedMethodSet, NATIVE_CONCEPT_CODES, NATIVE_DOMAIN, type ParseMthdsBundleResult, type ParsedBundle, type StaticGraphOptions, type StaticGraphResult, UNKNOWN_DOMAIN, buildStaticGraphSpec, buildStaticGraphSpecFromToml, mergeBundles, parseConceptRef, parseInputSlot, parseMthdsBundle, staticDiagnosticsToValidationIssues };

package/dist/static-graph/index.js

@@ -17,6 +17,9 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
+function authoredRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
 function strOrNull(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
@@ -70,6 +73,32 @@ function parseConceptRef(raw) {
     presence: presenceFromSymbol(presence)
   };
 }
+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 parseInputSlot(raw) {
+  if (!isPlainObject(raw)) {
+    return {
+      ref: parseConceptRef(raw),
+      missingConcept: false,
+      unknownKeys: [],
+      dottedName: false
+    };
+  }
+  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)
+  };
+}
 function qualifiedStructureClassName(domain, code) {
   return `${domain.replaceAll(".", "\xB7")}__${code}`;
 }
@@ -98,22 +127,32 @@ function resolveConceptInfo(parts, currentDomain, localConcepts) {
   if (parts.domain !== null && parts.domain !== currentDomain) {
     return stubConceptInfo(parts.code, parts.domain);
   }
-  const local = localConcepts[parts.code];
-  if (local) return local;
+  if (Object.hasOwn(localConcepts, parts.code)) return localConcepts[parts.code];
   if (parts.domain === null && isNativeConceptCode(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;
+function stuffSpecFromParts(parts, currentDomain, localConcepts) {
   return {
     concept: resolveConceptInfo(parts, currentDomain, localConcepts),
     multiplicity: parts.multiplicity,
     presence: parts.presence
   };
 }
+function resolveStuffSpec(raw, currentDomain, localConcepts) {
+  const parts = parseConceptRef(raw);
+  return parts === null ? null : stuffSpecFromParts(parts, currentDomain, localConcepts);
+}
+function resolveInputSlot(raw, currentDomain, localConcepts) {
+  const { ref, missingConcept, unknownKeys, dottedName } = parseInputSlot(raw);
+  return {
+    spec: ref === null ? null : stuffSpecFromParts(ref, currentDomain, localConcepts),
+    missingConcept,
+    unknownKeys,
+    dottedName
+  };
+}
 
 // src/static-graph/parseMthdsBundle.ts
 import { parse as parseToml } from "smol-toml";
@@ -135,7 +174,7 @@ function stringArrayOrNull(value) {
   return value.filter((item) => typeof item === "string");
 }
 function normalizeInputs(raw, pipeCode, ctx) {
-  const inputs = {};
+  const inputs = authoredRecord();
   if (raw === void 0 || raw === null) return inputs;
   if (!isPlainObject(raw)) {
     ctx.diagnostics.push({
@@ -146,13 +185,34 @@ function normalizeInputs(raw, pipeCode, ctx) {
     });
     return inputs;
   }
-  for (const [name, ref] of Object.entries(raw)) {
-    const spec = resolveStuffSpec(ref, ctx.domain, ctx.concepts);
+  for (const [name, slot] of Object.entries(raw)) {
+    const { spec, missingConcept, unknownKeys, dottedName } = resolveInputSlot(
+      slot,
+      ctx.domain,
+      ctx.concepts
+    );
+    if (dottedName) {
+      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}`
+      });
+      continue;
+    }
+    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}`
+      });
+    }
     if (spec === null) {
       ctx.diagnostics.push({
         severity: "warning",
         code: "invalid-concept-ref",
-        message: `pipe "${pipeCode}": input "${name}" has an uninterpretable concept ref \u2014 skipped`,
+        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}`
       });
       continue;
@@ -514,7 +574,7 @@ function fieldSchema(spec) {
 }
 function deriveJsonSchema(structure, title, description) {
   if (!isPlainObject(structure)) return void 0;
-  const properties = {};
+  const properties = authoredRecord();
   const required = [];
   for (const [name, spec] of Object.entries(structure)) {
     if (typeof spec === "string") {
@@ -552,7 +612,7 @@ function qualifyRefines(raw, domain, declaredCodes, conceptCode, diagnostics) {
 }
 function parseConcepts(raw, domain, diagnostics) {
   var _a, _b;
-  const concepts = {};
+  const concepts = authoredRecord();
   if (raw === void 0) return concepts;
   if (!isPlainObject(raw)) {
     diagnostics.push({
@@ -603,8 +663,8 @@ function emptyBundle() {
     description: null,
     main_pipe: null,
     system_prompt: null,
-    concepts: {},
-    pipes: {}
+    concepts: authoredRecord(),
+    pipes: authoredRecord()
   };
 }
 function parseMthdsBundle(tomlText) {
@@ -675,7 +735,7 @@ function enrichPipeConcepts(pipe, domains) {
     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 = {};
+  const inputs = authoredRecord();
   for (const [name, spec] of Object.entries(pipe.inputs)) {
     inputs[name] = enrichSpec(spec);
   }
@@ -684,13 +744,17 @@ function enrichPipeConcepts(pipe, domains) {
 function mergeBundles(bundles) {
   var _a, _b, _c;
   const diagnostics = [];
-  const domains = {};
+  const domains = authoredRecord();
   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: {} };
+    const namespace = (_b = domains[domain]) != null ? _b : domains[domain] = {
+      domain,
+      concepts: authoredRecord(),
+      pipes: authoredRecord()
+    };
     if (mainDomain === null && bundle.domain !== null) mainDomain = bundle.domain;
     if (mainPipe === null && bundle.main_pipe !== null) {
       mainPipe = bundle.main_pipe;
@@ -1370,6 +1434,7 @@ export {
   makePipeRef,
   mergeBundles,
   parseConceptRef,
+  parseInputSlot,
   parseMthdsBundle,
   parsePipeRef,
   staticDiagnosticsToValidationIssues