@pipelex/mthds-form 0.2.0 → 0.4.0

package/README.md

@@ -21,9 +21,10 @@ import { FieldRenderer } from '@pipelex/mthds-form/react'; // the controls
 import { buildRunFields, computeReadiness, getPipeIOContract } from '@pipelex/mthds-form';
 import { FieldRenderer } from '@pipelex/mthds-form/react';
 
-const contract = getPipeIOContract(method.pipe_io_contracts, pipeCode, method.domain);
+const contract = getPipeIOContract(method.pipe_io_contracts, method.domain, pipeCode);
 const fields = buildRunFields(contract.inputs);
-const { canRun } = computeReadiness(fields, values);
+const { missing } = computeReadiness(fields, values);
+const canRun = missing.length === 0;
 
 return fields.map((field) => (
   <FieldRenderer
@@ -36,6 +37,10 @@ return fields.map((field) => (
 ));
 ```
 
+The lookup takes its arguments in wire order — **contracts, domain, pipe code** — and both of the last two are strings, so swapping them typechecks. It resolves anyway against a map keyed by bare pipe code, and fails only against one keyed by namespaced `pipe_ref`, a long way from the call.
+
+`computeReadiness` reports `{ total, ready, missing }` — `missing` names the inputs still to fill, so it is both the Run gate and what a form tells the user is left.
+
 `buildRunFields` is the only function that reads JSON Schema. Everything downstream — rendering, readiness, validation messaging — reads the `RunField` descriptor it returns. That is the load-bearing rule of the package, and [docs/architecture.md](docs/architecture.md) explains what it buys.
 
 Submitting goes through the gate: `buildRunInputsSchema` → `prepareRunInputs` → `validateRunInputs` → `apiInputsFromSchemaData`. The verdict is structured (`RunInputError[]`), and `describeValidationError` renders it for a person.

package/dist/chunk-6XD6UZSU.js

@@ -0,0 +1,28 @@
+// src/core/descriptor.ts
+function conceptCategory(field) {
+  switch (field.kind) {
+    case "text":
+    case "prose":
+      return "text";
+    case "date":
+      return "date";
+    case "document":
+      return "document";
+    case "image":
+      return "image";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return "choice";
+    case "list":
+      return "list";
+    default:
+      return "structured";
+  }
+}
+
+export { conceptCategory };
+//# sourceMappingURL=chunk-6XD6UZSU.js.map
+//# sourceMappingURL=chunk-6XD6UZSU.js.map

package/dist/chunk-6XD6UZSU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/descriptor.ts"],"names":[],"mappings":";AAkKO,SAAS,gBAAgB,KAAA,EAAkC;AAChE,EAAA,QAAQ,MAAM,IAAA;AAAM,IAClB,KAAK,MAAA;AAAA,IACL,KAAK,OAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,UAAA;AACH,MAAA,OAAO,UAAA;AAAA,IACT,KAAK,OAAA;AACH,MAAA,OAAO,OAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,OAAO,QAAA;AAAA,IACT,KAAK,SAAA;AACH,MAAA,OAAO,SAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,QAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT;AACE,MAAA,OAAO,YAAA;AAAA;AAEb","file":"chunk-6XD6UZSU.js","sourcesContent":["/**\n * The `RunField` descriptor - the consumer-facing currency of the form kernel.\n *\n * A method's inputs arrive from the API as a map of variable name →\n * `PipeInputContract` ({ concept_ref, json_schema }). That JSON Schema is rich\n * (Pydantic-generated) and not pleasant to render directly. `buildRunFields`\n * (in `derive.ts`) normalizes it once into a flat, recursive `RunField[]`\n * descriptor that the presentational field components consume - so the\n * components never touch raw JSON Schema, and stories can describe any input\n * shape declaratively.\n *\n * Pure module: no React, no API calls. Trivially unit-testable.\n */\n\nexport type RunFieldKind =\n  | 'text' // short single-line string\n  | 'prose' // long free-text (textarea)\n  | 'date' // a calendar date (schema `format: date` or `date-time`)\n  | 'number' // integer or float\n  | 'boolean' // true/false\n  | 'enum' // pick one of a fixed set\n  | 'document' // a file (PDF, docx…) by upload or URL\n  | 'image' // a file rendered with a preview\n  | 'object' // a structured concept with nested fields\n  | 'list' // an array of one element type\n  | 'unknown'; // anything we can't map → raw JSON escape hatch\n\nexport interface RunFieldCommon {\n  /** The variable identifier as written in the method (rendered in mono). */\n  name: string;\n  /** Human label; falls back to `name` when absent. */\n  title?: string;\n  /** The concept this input carries, e.g. `native.Document`, `demo.Invoice`. */\n  conceptRef?: string;\n  /** One-line helper text shown under the label. */\n  description?: string;\n  /** Required inputs always show; optional ones can collapse. */\n  required: boolean;\n  /**\n   * Whether Run waits for this input - set on TOP-LEVEL fields only, straight\n   * from `inputMustBeFilled` (see `mustBeFilled` in `readiness.ts` for why this\n   * is not the same question as `required`). Nested fields leave it undefined;\n   * they are gated through their parent's `fieldFilled`.\n   */\n  gating?: boolean;\n  /**\n   * The single property this field's value sits inside on the wire, when its\n   * concept declares a scalar content model: `native.Text` is `TextContent\n   * {text}`, `native.Number` is `NumberContent {number}`, `native.YesNo` is\n   * `YesNoContent {yes_no}`. The control still holds the plain scalar; the\n   * value bridge wraps into this property on the way out and unwraps on the way\n   * back in.\n   *\n   * A property NAME, never a schema - the descriptor stays the only currency\n   * and `buildRunFields` stays the only reader of JSON Schema. Absent whenever\n   * the value is already the whole content (a structured concept, a file, a\n   * child property of a structure): wrapping those would double-nest them.\n   */\n  contentKey?: string;\n}\n\nexport interface TextRunField extends RunFieldCommon {\n  kind: 'text';\n  placeholder?: string;\n}\n\nexport interface ProseRunField extends RunFieldCommon {\n  kind: 'prose';\n  placeholder?: string;\n}\n\nexport interface DateRunField extends RunFieldCommon {\n  kind: 'date';\n  /**\n   * True when the backing schema is `format: date-time`: the stored value is a\n   * full RFC 3339 timestamp (`2026-07-06T00:00:00Z`) so it passes the API's\n   * `date-time` validation, even though the control only asks for a day. False\n   * for a bare `format: date`, where the value stays `YYYY-MM-DD`.\n   */\n  datetime: boolean;\n}\n\nexport interface NumberRunField extends RunFieldCommon {\n  kind: 'number';\n  integer: boolean;\n  min?: number;\n  max?: number;\n}\n\nexport interface BooleanRunField extends RunFieldCommon {\n  kind: 'boolean';\n}\n\nexport interface EnumRunField extends RunFieldCommon {\n  kind: 'enum';\n  options: string[];\n}\n\nexport interface FileRunField extends RunFieldCommon {\n  kind: 'document' | 'image';\n  /** Accept hint shown to the user, e.g. \"PDF, PNG, JPG\". */\n  accept?: string;\n}\n\nexport interface ObjectRunField extends RunFieldCommon {\n  kind: 'object';\n  fields: RunField[];\n}\n\nexport interface ListRunField extends RunFieldCommon {\n  kind: 'list';\n  /** The element descriptor (its `name` is unused; the index labels items). */\n  item: RunField;\n  /**\n   * The FEWEST items the slot accepts, when the schema states a lower bound.\n   * Absent for a variable `Concept[]` list, which demands none.\n   *\n   * Read off the array schema's `minItems` rather than off the contract's\n   * `item_count`, which states the same number: this exists so `fieldFilled` can\n   * answer the question **ajv** answers, and `minItems` is the keyword ajv\n   * reads. pipelex emits `minItems`/`maxItems` = N for a `[N]` slot and neither\n   * for `[]`, so on a top-level slot the two sources agree by construction.\n   *\n   * A schema may still state a lower bound alone - `mapSchema` recurses, so a\n   * nested array inside a structured concept reaches here with whatever its\n   * model declared and no MTHDS multiplicity behind it. Gating on that bound is\n   * the same rule, and it is the direction that cannot leave readiness more\n   * permissive than the gate.\n   */\n  itemCount?: number;\n  /**\n   * The MOST items the slot accepts, off the schema's `maxItems`.\n   *\n   * A separate field because it is a separate fact, and conflating them is a\n   * bug that hides: `itemCount` was read as a minimum by readiness and as a\n   * maximum by the control that stops offering `Add`, which agree only while\n   * a contract states both bounds equal. A list told \"at least two\" was then\n   * presented as a list of exactly two.\n   */\n  maxItemCount?: number;\n}\n\nexport interface UnknownRunField extends RunFieldCommon {\n  kind: 'unknown';\n}\n\nexport type RunField =\n  | TextRunField\n  | ProseRunField\n  | DateRunField\n  | NumberRunField\n  | BooleanRunField\n  | EnumRunField\n  | FileRunField\n  | ObjectRunField\n  | ListRunField\n  | UnknownRunField;\n\n/** The short, friendly category label for a concept_ref (drives the pill dot). */\nexport type ConceptCategory =\n  'text' | 'date' | 'document' | 'image' | 'number' | 'boolean' | 'choice' | 'structured' | 'list';\n\nexport function conceptCategory(field: RunField): ConceptCategory {\n  switch (field.kind) {\n    case 'text':\n    case 'prose':\n      return 'text';\n    case 'date':\n      return 'date';\n    case 'document':\n      return 'document';\n    case 'image':\n      return 'image';\n    case 'number':\n      return 'number';\n    case 'boolean':\n      return 'boolean';\n    case 'enum':\n      return 'choice';\n    case 'list':\n      return 'list';\n    default:\n      return 'structured';\n  }\n}\n"]}

package/dist/chunk-7BMOPXDY.js

@@ -0,0 +1,205 @@
+import { collectSchemaDefs, resolveSchemaIndirection, schemaTypeOf } from './chunk-O4O3QNVC.js';
+import { ownProp, hasOwnProp } from './chunk-V3OV2XQT.js';
+import { asCalendarDate } from './chunk-GKV77RAS.js';
+import { splitListConcept, isWireTextConcept, isWireDocumentLikeConcept } from './chunk-NMT7BRLO.js';
+
+// src/core/wire-format.ts
+function isListConcept(conceptCode) {
+  const { base, isList } = splitListConcept(conceptCode);
+  return { isList, baseConcept: base ?? "" };
+}
+var isTextConcept = isWireTextConcept;
+var isDocumentLikeConcept = isWireDocumentLikeConcept;
+function deflateInput(value, conceptCode) {
+  const { isList, baseConcept } = isListConcept(conceptCode);
+  if (isList) {
+    const items = Array.isArray(value) ? value : [];
+    return items.map((item) => deflateListItem(item, baseConcept));
+  }
+  return deflateSingleValue(value, baseConcept);
+}
+function deflateListItem(value, concept) {
+  if (isTextConcept(concept)) {
+    if (value && typeof value === "object" && "text" in value) {
+      return value.text;
+    }
+    return typeof value === "string" ? value : String(value ?? "");
+  }
+  if (isDocumentLikeConcept(concept)) {
+    if (value && typeof value === "object" && "url" in value) {
+      return value.url;
+    }
+    if (typeof value === "string") return value;
+    return "";
+  }
+  return { concept, content: unwrapAllWrappers(value) };
+}
+function deflateSingleValue(value, concept) {
+  if (isTextConcept(concept)) {
+    if (value && typeof value === "object" && "text" in value) {
+      return value.text;
+    }
+    return typeof value === "string" ? value : String(value ?? "");
+  }
+  if (isDocumentLikeConcept(concept)) {
+    if (value && typeof value === "object" && "url" in value) {
+      return value.url;
+    }
+    if (typeof value === "string") return value;
+    return "";
+  }
+  return { concept, content: unwrapAllWrappers(value) };
+}
+function inflateInput(value, conceptCode) {
+  const { isList, baseConcept } = isListConcept(conceptCode);
+  if (isList) {
+    const unwrapped = isWrappedForm(value) ? value.content : value;
+    let items;
+    if (Array.isArray(unwrapped)) {
+      items = unwrapped;
+    } else if (unwrapped != null && typeof unwrapped === "object") {
+      items = [unwrapped];
+    } else {
+      items = [];
+    }
+    return items.map((item) => inflateSingleValue(item, baseConcept));
+  }
+  return inflateSingleValue(value, baseConcept);
+}
+var DOCUMENT_FIELDS = /* @__PURE__ */ new Set(["url", "public_url", "mime_type", "filename", "title", "snippet"]);
+function looksLikeDocument(obj) {
+  return Object.keys(obj).some((k) => DOCUMENT_FIELDS.has(k));
+}
+function isWrappedForm(value) {
+  return !!value && typeof value === "object" && "concept" in value && "content" in value && typeof value.concept === "string";
+}
+function inflateSingleValue(value, concept) {
+  if (isWrappedForm(value) && (isTextConcept(concept) || isDocumentLikeConcept(concept))) {
+    return inflateSingleValue(value.content, concept);
+  }
+  if (isTextConcept(concept)) {
+    if (typeof value === "string") {
+      return { text: value };
+    }
+    if (value && typeof value === "object" && "text" in value) {
+      return value;
+    }
+    return { text: "" };
+  }
+  if (isDocumentLikeConcept(concept)) {
+    if (typeof value === "string") {
+      return { url: value };
+    }
+    if (value && typeof value === "object" && "url" in value) {
+      return value;
+    }
+    if (value && typeof value === "object" && looksLikeDocument(value)) {
+      return { ...value, url: "" };
+    }
+    return { url: "" };
+  }
+  return unwrapAllWrappers(value);
+}
+function unwrapAllWrappers(value) {
+  let current = value;
+  while (isWrappedForm(current)) {
+    current = current.content;
+  }
+  if (current && typeof current === "object" && !Array.isArray(current) && "content" in current) {
+    return current.content;
+  }
+  return current;
+}
+function resolveConceptCode(schema) {
+  const code = schema.concept_ref;
+  if (!code) return "";
+  if (!code.endsWith("[]") && schema.json_schema?.type === "array") {
+    return code + "[]";
+  }
+  return code;
+}
+function deflateAllInputs(formData, inputSchemas) {
+  const result = {};
+  for (const [stuffName, schema] of Object.entries(inputSchemas)) {
+    result[stuffName] = deflateInput(ownProp(formData, stuffName), resolveConceptCode(schema));
+  }
+  return result;
+}
+function healStringWrappers(value, rawSchema, defs) {
+  if (!rawSchema || value == null) return value;
+  const allDefs = defs ?? collectSchemaDefs(rawSchema, {}, { traverseArrays: false });
+  const schema = resolveSchemaIndirection(rawSchema, allDefs);
+  const type = schemaTypeOf(schema);
+  if (type === "string" && schema.format === "date" && typeof value === "string") {
+    return asCalendarDate(value) ?? value;
+  }
+  if (type === "string") {
+    if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 1 && typeof value.text === "string") {
+      return value.text;
+    }
+    return value;
+  }
+  if (type === "object" && typeof value === "object" && !Array.isArray(value)) {
+    const props = schema.properties;
+    if (!props) return value;
+    const out = { ...value };
+    for (const [key, propSchema] of Object.entries(props)) {
+      if (hasOwnProp(out, key)) out[key] = healStringWrappers(out[key], propSchema, allDefs);
+    }
+    return out;
+  }
+  if (type === "array" && Array.isArray(value)) {
+    const items = schema.items;
+    return value.map((item) => healStringWrappers(item, items, allDefs));
+  }
+  return value;
+}
+function isEmptyAfterPruning(value) {
+  if (value === "" || value === null || value === void 0) return true;
+  return typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function pruneEmptyOptionals(value, rawSchema, defs) {
+  if (!rawSchema || value == null) return value;
+  const allDefs = defs ?? collectSchemaDefs(rawSchema, {}, { traverseArrays: false });
+  const schema = resolveSchemaIndirection(rawSchema, allDefs);
+  const type = schemaTypeOf(schema);
+  if (type === "array" && Array.isArray(value)) {
+    const items = schema.items;
+    return value.map((item) => pruneEmptyOptionals(item, items, allDefs));
+  }
+  if (type !== "object" || typeof value !== "object" || Array.isArray(value)) return value;
+  const props = schema.properties;
+  if (!props) return value;
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const propSchema = ownProp(props, key);
+    if (!propSchema) {
+      out[key] = raw;
+      continue;
+    }
+    const pruned = pruneEmptyOptionals(raw, propSchema, allDefs);
+    if (isEmptyAfterPruning(pruned) && !required.has(key)) continue;
+    out[key] = pruned;
+  }
+  return out;
+}
+function inflateAllInputs(simplifiedData, inputSchemas) {
+  const result = {};
+  for (const [stuffName, value] of Object.entries(simplifiedData)) {
+    const schema = ownProp(inputSchemas, stuffName);
+    if (schema) {
+      result[stuffName] = healStringWrappers(
+        inflateInput(value, resolveConceptCode(schema)),
+        schema.json_schema
+      );
+    } else {
+      result[stuffName] = value;
+    }
+  }
+  return result;
+}
+
+export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode };
+//# sourceMappingURL=chunk-7BMOPXDY.js.map
+//# sourceMappingURL=chunk-7BMOPXDY.js.map

package/dist/chunk-7BMOPXDY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/wire-format.ts"],"names":[],"mappings":"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","file":"chunk-7BMOPXDY.js","sourcesContent":["/**\n * Converts between the simplified inputs.json format and the full RJSF form format.\n *\n * The inputs.json file uses a SIMPLIFIED format for users:\n * - Text:       \"my text\"                     (instead of { text: \"my text\" })\n * - Document:   \"file.pdf\" or { url: \"...\" }  (instead of { url: \"...\", ... })\n * - Image:      same as Document\n * - Text[]:     [\"t1\", \"t2\"]\n * - Document[]: [\"f1.pdf\"] or [{ url: \"...\" }]\n * - Custom:     { concept, content }           (no simplification)\n *\n * The RJSF form uses the FULL concept structure from the json_schema.\n *\n * Two directions:\n * - deflate: form (full) → inputs.json (simplified) - for writing inputs.json / API calls\n * - inflate: inputs.json (simplified) → form (full)  - for populating the form from inputs.json\n */\n\nimport { asCalendarDate } from './date-format';\nimport { isWireDocumentLikeConcept, isWireTextConcept, splitListConcept } from './native-concepts';\nimport { hasOwnProp, ownProp } from './own-property';\nimport { collectSchemaDefs, resolveSchemaIndirection, schemaTypeOf } from './schema-utils';\n\n/** The wire-format view of the native-concept taxonomy (which concept codes use\n *  simplified formats) lives in `native-concepts.ts` - including the record of\n *  where it drifts from the field mapper's view. */\nfunction isListConcept(conceptCode: string): { isList: boolean; baseConcept: string } {\n  const { base, isList } = splitListConcept(conceptCode);\n  return { isList, baseConcept: base ?? '' };\n}\n\nconst isTextConcept = isWireTextConcept;\nconst isDocumentLikeConcept = isWireDocumentLikeConcept;\n\n// ─── Deflate: form (full) → inputs.json (simplified) ──────────────────────\n\n/**\n * Convert a single form value to the simplified inputs.json format.\n * Used when writing inputs.json and when calling the run API.\n *\n * Rules:\n * - Text { text: \"hello\" } → \"hello\"\n * - Document { url: \"file.pdf\", ... } → \"file.pdf\" (if only url) or { url, ... }\n * - Image: same as Document\n * - Page: same as Document\n * - List types → array of deflated items\n * - Custom → { concept, content }\n */\nexport function deflateInput(value: unknown, conceptCode: string): unknown {\n  const { isList, baseConcept } = isListConcept(conceptCode);\n\n  if (isList) {\n    const items = Array.isArray(value) ? value : [];\n    // pipelex accepts Sequence[str] for list inputs, not list of dicts.\n    // Always simplify list items to their scalar form (URL string for docs, plain string for text).\n    return items.map((item) => deflateListItem(item, baseConcept));\n  }\n\n  return deflateSingleValue(value, baseConcept);\n}\n\n/** Deflate a single item within a list - always reduces to the simplest scalar form. */\nfunction deflateListItem(value: unknown, concept: string): unknown {\n  if (isTextConcept(concept)) {\n    if (value && typeof value === 'object' && 'text' in value) {\n      return (value as { text: string }).text;\n    }\n    return typeof value === 'string' ? value : String(value ?? '');\n  }\n\n  if (isDocumentLikeConcept(concept)) {\n    // Always extract just the URL for list items - pipelex resolves metadata at runtime\n    if (value && typeof value === 'object' && 'url' in value) {\n      return (value as { url: string }).url;\n    }\n    if (typeof value === 'string') return value;\n    return '';\n  }\n\n  // Custom structured concept → { concept, content }.\n  //\n  // IDEMPOTENT ON PURPOSE - see `unwrapAllWrappers`. Wrapping unconditionally\n  // corrupted persisted inputs: a host panel seeds the form with the RAW\n  // stored value when the input schemas aren't loaded yet (no dry run yet),\n  // so the form could hold an ALREADY-wrapped value; the next change deflated\n  // it again and saved `{ concept, content: { concept, content: {...} } }`.\n  // Wrapping exactly once, whatever we're handed, makes that unreachable.\n  return { concept, content: unwrapAllWrappers(value) };\n}\n\nfunction deflateSingleValue(value: unknown, concept: string): unknown {\n  if (isTextConcept(concept)) {\n    // { text: \"hello\" } → \"hello\"\n    if (value && typeof value === 'object' && 'text' in value) {\n      return (value as { text: string }).text;\n    }\n    // Already a string (passthrough)\n    return typeof value === 'string' ? value : String(value ?? '');\n  }\n\n  if (isDocumentLikeConcept(concept)) {\n    // Always extract just the URL - pipelex resolves metadata at runtime.\n    // A bare dict without a 'concept' key is rejected by StuffFactory.\n    if (value && typeof value === 'object' && 'url' in value) {\n      return (value as { url: string }).url;\n    }\n    // Already a string URL (passthrough)\n    if (typeof value === 'string') return value;\n    return '';\n  }\n\n  // Custom structured concept → { concept, content }.\n  //\n  // IDEMPOTENT ON PURPOSE - see `unwrapAllWrappers`. Wrapping unconditionally\n  // corrupted persisted inputs: a host panel seeds the form with the RAW\n  // stored value when the input schemas aren't loaded yet (no dry run yet),\n  // so the form could hold an ALREADY-wrapped value; the next change deflated\n  // it again and saved `{ concept, content: { concept, content: {...} } }`.\n  // Wrapping exactly once, whatever we're handed, makes that unreachable.\n  return { concept, content: unwrapAllWrappers(value) };\n}\n\n// ─── Inflate: inputs.json (simplified) → form (full) ──────────────────────\n\n/**\n * Convert a simplified inputs.json value to the full form structure.\n * Used when populating the RJSF form from inputs.json.\n *\n * Rules:\n * - \"hello\" → { text: \"hello\" } (for Text concepts)\n * - \"file.pdf\" → { url: \"file.pdf\" } (for Document/Image/Page concepts)\n * - { url: \"...\" } → passthrough (already full)\n * - [\"t1\", \"t2\"] → inflated array of items\n * - { concept, content } → content (for custom concepts)\n */\nexport function inflateInput(value: unknown, conceptCode: string): unknown {\n  const { isList, baseConcept } = isListConcept(conceptCode);\n\n  if (isList) {\n    // The sandbox may write the wrapped form at the LIST level:\n    // { concept: \"native.Document\", content: [item, item] } - pipelex accepts it.\n    // Unwrap before the array check, otherwise the wrapper itself gets treated\n    // as a single list item and inflates to one empty entry.\n    const unwrapped = isWrappedForm(value) ? value.content : value;\n    // Handle: array (correct), single object (legacy/form default), or null/undefined\n    let items: unknown[];\n    if (Array.isArray(unwrapped)) {\n      items = unwrapped;\n    } else if (unwrapped != null && typeof unwrapped === 'object') {\n      // Single object instead of array (e.g., {\"url\": \"\"} from form default) - wrap it\n      items = [unwrapped];\n    } else {\n      items = [];\n    }\n    return items.map((item) => inflateSingleValue(item, baseConcept));\n  }\n\n  return inflateSingleValue(value, baseConcept);\n}\n\n/** Known optional fields on DocumentContent (from pipelex Pydantic model). */\nconst DOCUMENT_FIELDS = new Set(['url', 'public_url', 'mime_type', 'filename', 'title', 'snippet']);\n\n/** Returns true if the object looks like a DocumentContent (has any known doc field). */\nfunction looksLikeDocument(obj: Record<string, unknown>): boolean {\n  return Object.keys(obj).some((k) => DOCUMENT_FIELDS.has(k));\n}\n\n/**\n * Detect the fully-qualified wrapper form `{ concept: \"...\", content: ... }`.\n * pipelex accepts this for any concept (native or custom), and the mthds-inputs\n * agent skill writes it by default for disambiguation. We unwrap before applying\n * concept-specific inflation so the form populates correctly.\n */\nfunction isWrappedForm(value: unknown): value is { concept: string; content: unknown } {\n  return (\n    !!value &&\n    typeof value === 'object' &&\n    'concept' in value &&\n    'content' in value &&\n    typeof (value as { concept: unknown }).concept === 'string'\n  );\n}\n\nfunction inflateSingleValue(value: unknown, concept: string): unknown {\n  // Unwrap { concept, content } for native concepts - the content IS the value.\n  // For custom concepts we unwrap below (historical behaviour) but after concept-specific checks.\n  if (isWrappedForm(value) && (isTextConcept(concept) || isDocumentLikeConcept(concept))) {\n    return inflateSingleValue(value.content, concept);\n  }\n\n  if (isTextConcept(concept)) {\n    // \"hello\" → { text: \"hello\" }\n    if (typeof value === 'string') {\n      return { text: value };\n    }\n    // Already full structure { text: \"...\" }\n    if (value && typeof value === 'object' && 'text' in value) {\n      return value;\n    }\n    return { text: '' };\n  }\n\n  if (isDocumentLikeConcept(concept)) {\n    // \"file.pdf\" → { url: \"file.pdf\" }\n    if (typeof value === 'string') {\n      return { url: value };\n    }\n    // Already full structure { url: \"...\" }\n    if (value && typeof value === 'object' && 'url' in value) {\n      return value;\n    }\n    // Object without url key but with other document fields (e.g. from RJSF defaults)\n    // Ensure the required url field is present\n    if (value && typeof value === 'object' && looksLikeDocument(value as Record<string, unknown>)) {\n      return { ...(value as Record<string, unknown>), url: '' };\n    }\n    return { url: '' };\n  }\n\n  // Custom structured: unwrap { concept, content } → content.\n  //\n  // Unwrap REPEATEDLY. `deflateSingleValue` used to wrap unconditionally, so a\n  // form change made while the input schemas weren't loaded yet re-wrapped an\n  // already-wrapped value and persisted `{ concept, content: { concept,\n  // content: {...} } }` to DynamoDB. Unwrapping a single level left the FORM\n  // holding `{ concept, content }` - properties no schema declares, so RJSF\n  // matched nothing and rendered every field empty, with the real values\n  // sitting one level deeper. Deflate is idempotent now, but the corrupted\n  // shape survives in persisted inputData, so this heals it on read.\n  return unwrapAllWrappers(value);\n}\n\n/** Strip every `{ concept, content }` layer - one, or the double wrap a\n *  non-idempotent deflate persisted. */\nfunction unwrapAllWrappers(value: unknown): unknown {\n  let current = value;\n  while (isWrappedForm(current)) {\n    current = current.content;\n  }\n  // A `{ content }` with no `concept` is the historical half-wrapper.\n  if (current && typeof current === 'object' && !Array.isArray(current) && 'content' in current) {\n    return (current as { content: unknown }).content;\n  }\n  return current;\n}\n\n// ─── Schema helpers ─────────────────────────────────────────────────────\n\ninterface InputSchema {\n  concept_ref: string;\n  json_schema?: Record<string, unknown>;\n}\n\n/**\n * The validation API returns concept_ref WITHOUT the [] suffix for list inputs.\n * The array-ness is only encoded in json_schema.type === \"array\".\n * This helper resolves the correct concept ref by checking the schema.\n */\nexport function resolveConceptCode(schema: InputSchema): string {\n  const code = schema.concept_ref;\n  // Defensive: a malformed/partial contract entry (missing concept) must\n  // degrade, never throw and blank the whole input panel.\n  if (!code) return '';\n  if (!code.endsWith('[]') && (schema.json_schema as Record<string, unknown>)?.type === 'array') {\n    return code + '[]';\n  }\n  return code;\n}\n\n// ─── Batch helpers for full inputData objects ────────────────────────────\n\n/**\n * Deflate all inputs from form format to simplified inputs.json format.\n * Used by InputConfigPanel when preparing data for the run API.\n */\nexport function deflateAllInputs(\n  formData: Record<string, unknown>,\n  inputSchemas: Record<string, InputSchema>,\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n  for (const [stuffName, schema] of Object.entries(inputSchemas)) {\n    result[stuffName] = deflateInput(ownProp(formData, stuffName), resolveConceptCode(schema));\n  }\n  return result;\n}\n\n/**\n * Heal values against their json_schema: the run-form bridge used to\n * double-wrap plain string properties as `{ text: \"...\" }` (fixed in\n * run-values.ts, but the corrupted shape survives in persisted inputData -\n * store and server copies). Wherever the schema expects a string but the\n * value is a lone `{ text: string }` wrapper, unwrap it. Walks nested\n * objects and arrays, resolving `#/$defs/...` refs against the root schema;\n * anything already valid passes through untouched.\n */\nexport function healStringWrappers(\n  value: unknown,\n  rawSchema: Record<string, unknown> | undefined,\n  defs?: Record<string, Record<string, unknown>>,\n): unknown {\n  if (!rawSchema || value == null) return value;\n\n  // Resolve $ref / nullable-anyOf indirection (Pydantic emits `{$ref}` for\n  // nested models and `anyOf: [T, {type:'null'}]` for optionals). The `$defs`\n  // walk deliberately keeps its historical no-array-traversal mode - see\n  // `CollectDefsOptions` in schema-utils.\n  const allDefs = defs ?? collectSchemaDefs(rawSchema, {}, { traverseArrays: false });\n  const schema = resolveSchemaIndirection(rawSchema, allDefs);\n  const type = schemaTypeOf(schema);\n\n  // A `format: date` field takes a calendar date ALONE. `DateContent` in pipelex\n  // enforces that with a `mode=\"before\"` validator (`_reject_lax_temporal`) that\n  // deliberately closes pydantic's lax coercion - a datetime string on `date`\n  // would silently drop its time and offset (DT3, \"no silent midnight\"), so the\n  // runner answers a 500, not a coercion.\n  //\n  // An agent-written or hand-written inputs.json says `\"2026-07-06T00:00:00Z\"`\n  // anyway - that is how every system exports a date. So NORMALIZE it here to\n  // the day it denotes rather than forwarding it to fail at the runner: the\n  // padding is noise, and dropping noise is not the fidelity loss DT3 forbids.\n  // A value carrying a REAL time (15:40) returns null and is left untouched -\n  // it must fail, because silently discarding it is precisely the corruption\n  // the rule exists to prevent.\n  if (type === 'string' && schema.format === 'date' && typeof value === 'string') {\n    return asCalendarDate(value) ?? value;\n  }\n\n  if (type === 'string') {\n    if (\n      typeof value === 'object' &&\n      !Array.isArray(value) &&\n      Object.keys(value).length === 1 &&\n      typeof (value as { text?: unknown }).text === 'string'\n    ) {\n      return (value as { text: string }).text;\n    }\n    return value;\n  }\n  if (type === 'object' && typeof value === 'object' && !Array.isArray(value)) {\n    const props = schema.properties as Record<string, Record<string, unknown>> | undefined;\n    if (!props) return value;\n    const out = { ...(value as Record<string, unknown>) };\n    for (const [key, propSchema] of Object.entries(props)) {\n      if (hasOwnProp(out, key)) out[key] = healStringWrappers(out[key], propSchema, allDefs);\n    }\n    return out;\n  }\n  if (type === 'array' && Array.isArray(value)) {\n    const items = schema.items as Record<string, unknown> | undefined;\n    return value.map((item) => healStringWrappers(item, items, allDefs));\n  }\n  return value;\n}\n\n/** Nothing left worth sending, once this value has itself been pruned. */\nfunction isEmptyAfterPruning(value: unknown): boolean {\n  if (value === '' || value === null || value === undefined) return true;\n  // An object whose every property was itself pruned away carries nothing, and\n  // that is what an untouched OPTIONAL STRUCTURED input looks like by the time\n  // it reaches here - a shell of empty children, emptied out. Keeping the `{}`\n  // handed it to ajv against the concept's full schema, which rejected the run\n  // for a required child of an input the method said may be omitted. Dropping\n  // it is the same judgement the wire payload already makes one step later\n  // (`apiInputsFromSchemaData` omits it as unfilled); making the prune agree is\n  // what stops the gate from failing a run it was about to omit anyway.\n  //\n  // An empty ARRAY is deliberately NOT empty: a plural slot is never absent in\n  // MTHDS - its empty form IS the empty list - so dropping it would invent an\n  // absence the method cannot express.\n  return typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0;\n}\n\n/**\n * Drop optional properties the user never filled, so an untouched field cannot\n * fail validation or reach the API as an empty string.\n *\n * RJSF fills EVERY unset string property with `\"\"` on mount. That is harmless\n * for a plain string, but `prepareSchemaForRjsf` collapses pydantic's\n * `anyOf: [T, null]` by dropping the null branch, so an optional *constrained*\n * field - `DateContent.time`, declared `datetime.time | None` and rendered\n * `{ type: \"string\", format: \"time\" }` - is left demanding a well-formed time.\n * `\"\"` is not one, and the run was blocked on a field the user never opened.\n *\n * Pruning is the semantically correct repair, not a validation dodge: for\n * pipelex an absent optional field IS `None`, and `\"\"` would fail pydantic at\n * the runner just as it fails ajv here. Only properties absent from their\n * parent's `required` are dropped - an empty REQUIRED field must still fail, so\n * the user is told about it.\n *\n * What counts as empty is `isEmptyAfterPruning`, and it includes an optional\n * STRUCTURE the user never opened, on exactly the same grounds.\n */\nexport function pruneEmptyOptionals(\n  value: unknown,\n  rawSchema: Record<string, unknown> | undefined,\n  defs?: Record<string, Record<string, unknown>>,\n): unknown {\n  if (!rawSchema || value == null) return value;\n\n  const allDefs = defs ?? collectSchemaDefs(rawSchema, {}, { traverseArrays: false });\n  const schema = resolveSchemaIndirection(rawSchema, allDefs);\n  const type = schemaTypeOf(schema);\n\n  if (type === 'array' && Array.isArray(value)) {\n    const items = schema.items as Record<string, unknown> | undefined;\n    return value.map((item) => pruneEmptyOptionals(item, items, allDefs));\n  }\n  if (type !== 'object' || typeof value !== 'object' || Array.isArray(value)) return value;\n\n  const props = schema.properties as Record<string, Record<string, unknown>> | undefined;\n  if (!props) return value;\n  const required = new Set(Array.isArray(schema.required) ? (schema.required as string[]) : []);\n  const out: Record<string, unknown> = {};\n  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {\n    const propSchema = ownProp(props, key);\n    if (!propSchema) {\n      out[key] = raw;\n      continue;\n    }\n    const pruned = pruneEmptyOptionals(raw, propSchema, allDefs);\n    if (isEmptyAfterPruning(pruned) && !required.has(key)) continue;\n    out[key] = pruned;\n  }\n  return out;\n}\n\n/**\n * Inflate all inputs from simplified inputs.json format to form format.\n * Used by onInputUpdate when receiving inputs.json changes from the sandbox.\n */\nexport function inflateAllInputs(\n  simplifiedData: Record<string, unknown>,\n  inputSchemas: Record<string, InputSchema>,\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n  for (const [stuffName, value] of Object.entries(simplifiedData)) {\n    const schema = ownProp(inputSchemas, stuffName);\n    if (schema) {\n      result[stuffName] = healStringWrappers(\n        inflateInput(value, resolveConceptCode(schema)),\n        schema.json_schema,\n      );\n    } else {\n      // Unknown input - pass through unchanged\n      result[stuffName] = value;\n    }\n  }\n  return result;\n}\n"]}

package/dist/chunk-GKV77RAS.js

@@ -0,0 +1,46 @@
+// src/core/date-format.ts
+var FULL_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var ZERO_TIME_DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})[T ]00:00(?::00(?:\.0+)?)?(?:Z|z|[+-]\d{2}:?\d{2})?$/;
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|z|[+-]\d{2}:?\d{2})?$/;
+function isRealCalendarDate(value) {
+  const match = FULL_DATE_RE.exec(value);
+  if (!match) return false;
+  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+  if (month < 1 || month > 12) return false;
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function asCalendarDate(value) {
+  if (isRealCalendarDate(value)) return value;
+  const zeroTime = ZERO_TIME_DATE_TIME_RE.exec(value);
+  if (zeroTime && isRealCalendarDate(zeroTime[1])) return zeroTime[1];
+  return null;
+}
+function dayWithinDateTime(value) {
+  if (asCalendarDate(value) !== null) return null;
+  const match = DATE_TIME_RE.exec(value);
+  if (!match || !isRealCalendarDate(match[1])) return null;
+  return match[1];
+}
+function isAcceptableDate(value) {
+  return isRealCalendarDate(value);
+}
+function isAcceptableDateTime(value) {
+  if (isRealCalendarDate(value)) return true;
+  const match = DATE_TIME_RE.exec(value);
+  if (!match || !isRealCalendarDate(match[1])) return false;
+  const [hours, minutes, seconds] = [Number(match[2]), Number(match[3]), Number(match[4] ?? 0)];
+  return hours <= 23 && minutes <= 59 && seconds <= 59;
+}
+function toDateInputValue(value) {
+  if (typeof value !== "string") return "";
+  return asCalendarDate(value) ?? value.slice(0, 10);
+}
+function toStoredDateValue(day, datetime) {
+  if (!day) return void 0;
+  return datetime ? `${day}T00:00:00Z` : day;
+}
+
+export { asCalendarDate, dayWithinDateTime, isAcceptableDate, isAcceptableDateTime, toDateInputValue, toStoredDateValue };
+//# sourceMappingURL=chunk-GKV77RAS.js.map
+//# sourceMappingURL=chunk-GKV77RAS.js.map

package/dist/chunk-GKV77RAS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/date-format.ts"],"names":[],"mappings":";AAqCA,IAAM,YAAA,GAAe,2BAAA;AAOrB,IAAM,sBAAA,GACJ,0EAAA;AAGF,IAAM,YAAA,GACJ,0FAAA;AAGF,SAAS,mBAAmB,KAAA,EAAwB;AAClD,EAAA,MAAM,KAAA,GAAQ,YAAA,CAAa,IAAA,CAAK,KAAK,CAAA;AACrC,EAAA,IAAI,CAAC,OAAO,OAAO,KAAA;AACnB,EAAA,MAAM,CAAC,MAAM,KAAA,EAAO,GAAG,IAAI,CAAC,MAAA,CAAO,MAAM,CAAC,CAAC,GAAG,MAAA,CAAO,KAAA,CAAM,CAAC,CAAC,CAAA,EAAG,OAAO,KAAA,CAAM,CAAC,CAAC,CAAC,CAAA;AAChF,EAAA,IAAI,KAAA,GAAQ,CAAA,IAAK,KAAA,GAAQ,EAAA,EAAI,OAAO,KAAA;AACpC,EAAA,MAAM,IAAA,GAAO,IAAI,IAAA,CAAK,IAAA,CAAK,IAAI,IAAA,EAAM,KAAA,GAAQ,CAAA,EAAG,GAAG,CAAC,CAAA;AACpD,EAAA,OACE,IAAA,CAAK,cAAA,EAAe,KAAM,IAAA,IAAQ,IAAA,CAAK,WAAA,EAAY,KAAM,KAAA,GAAQ,CAAA,IAAK,IAAA,CAAK,UAAA,EAAW,KAAM,GAAA;AAEhG;AAQO,SAAS,eAAe,KAAA,EAA8B;AAC3D,EAAA,IAAI,kBAAA,CAAmB,KAAK,CAAA,EAAG,OAAO,KAAA;AACtC,EAAA,MAAM,QAAA,GAAW,sBAAA,CAAuB,IAAA,CAAK,KAAK,CAAA;AAClD,EAAA,IAAI,QAAA,IAAY,mBAAmB,QAAA,CAAS,CAAC,CAAE,CAAA,EAAG,OAAO,SAAS,CAAC,CAAA;AACnE,EAAA,OAAO,IAAA;AACT;AAeO,SAAS,kBAAkB,KAAA,EAA8B;AAC9D,EAAA,IAAI,cAAA,CAAe,KAAK,CAAA,KAAM,IAAA,EAAM,OAAO,IAAA;AAC3C,EAAA,MAAM,KAAA,GAAQ,YAAA,CAAa,IAAA,CAAK,KAAK,CAAA;AACrC,EAAA,IAAI,CAAC,SAAS,CAAC,kBAAA,CAAmB,MAAM,CAAC,CAAE,GAAG,OAAO,IAAA;AACrD,EAAA,OAAO,MAAM,CAAC,CAAA;AAChB;AAoBO,SAAS,iBAAiB,KAAA,EAAwB;AACvD,EAAA,OAAO,mBAAmB,KAAK,CAAA;AACjC;AAGO,SAAS,qBAAqB,KAAA,EAAwB;AAC3D,EAAA,IAAI,kBAAA,CAAmB,KAAK,CAAA,EAAG,OAAO,IAAA;AACtC,EAAA,MAAM,KAAA,GAAQ,YAAA,CAAa,IAAA,CAAK,KAAK,CAAA;AACrC,EAAA,IAAI,CAAC,SAAS,CAAC,kBAAA,CAAmB,MAAM,CAAC,CAAE,GAAG,OAAO,KAAA;AACrD,EAAA,MAAM,CAAC,OAAO,OAAA,EAAS,OAAO,IAAI,CAAC,MAAA,CAAO,MAAM,CAAC,CAAC,GAAG,MAAA,CAAO,KAAA,CAAM,CAAC,CAAC,CAAA,EAAG,OAAO,KAAA,CAAM,CAAC,CAAA,IAAK,CAAC,CAAC,CAAA;AAC5F,EAAA,OAAO,KAAA,IAAS,EAAA,IAAM,OAAA,IAAW,EAAA,IAAM,OAAA,IAAW,EAAA;AACpD;AAGO,SAAS,iBAAiB,KAAA,EAAmC;AAClE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,EAAU,OAAO,EAAA;AACtC,EAAA,OAAO,eAAe,KAAK,CAAA,IAAK,KAAA,CAAM,KAAA,CAAM,GAAG,EAAE,CAAA;AACnD;AAOO,SAAS,iBAAA,CAAkB,KAAa,QAAA,EAAuC;AACpF,EAAA,IAAI,CAAC,KAAK,OAAO,MAAA;AACjB,EAAA,OAAO,QAAA,GAAW,CAAA,EAAG,GAAG,CAAA,UAAA,CAAA,GAAe,GAAA;AACzC","file":"chunk-GKV77RAS.js","sourcesContent":["/**\n * Pure conversions between a stored date value and what a native `<input\n * type=\"date\">` shows, plus the leniency rules our schema validation uses.\n * Kept React-free so both the runner's `DateField` and the RJSF `DateWidget`\n * share one source of truth (and it's trivially unit-tested).\n *\n * Two schema shapes reach us, and they are NOT interchangeable:\n *   - an MTHDS `type = \"date\"` structure field compiles to `format: date-time`,\n *     so its value round-trips as a full RFC 3339 timestamp;\n *   - `native.Date`'s own `date` field is a python `datetime.date`, i.e.\n *     `format: date` - a bare `YYYY-MM-DD`.\n *\n * ## Why these rules exist\n *\n * The runtime (pydantic) is LENIENT in both directions, and our client used to\n * be stricter than the contract it was enforcing: `ajv`'s stock `format: \"date\"`\n * accepts a bare `YYYY-MM-DD` and nothing else, so a hand-written\n * `\"2026-07-06T00:00:00Z\"` in an `inputs.json` was rejected here even though\n * pydantic accepts it happily and coerces it to `date(2026, 7, 6)`. The run\n * never even reached the runner. These predicates mirror pydantic exactly\n * (measured, not assumed):\n *\n *   format: date       \"2026-07-06\"                -> date(2026, 7, 6)\n *                      \"2026-07-06T00:00:00Z\"      -> date(2026, 7, 6)\n *                      \"2026-07-06T00:00:00+02:00\" -> date(2026, 7, 6)   (literal date, no UTC shift)\n *                      \"2026-07-06T15:40:00Z\"      -> REJECTED \"should have zero time\"\n *   format: date-time  \"2026-07-06\"                -> datetime(2026, 7, 6, 0, 0)\n *                      \"2026-07-06T00:00:00Z\"      -> datetime(2026, 7, 6, 0, 0, tz)\n *\n * A midnight-padded timestamp is unambiguously \"just a day\", so take it. A real\n * time is data - refusing it is the point (`DateContentError`: \"no silent\n * midnight\"), because silently dropping 15:40 corrupts the value. And an\n * ambiguous `06/07/2026` is never accepted by anyone: 6 July or June 7 depends\n * on who's reading, and guessing wrong fails silently.\n */\n\n/** `YYYY-MM-DD`, no time. */\nconst FULL_DATE_RE = /^(\\d{4})-(\\d{2})-(\\d{2})$/;\n\n/**\n * A datetime whose clock reads exactly zero - optional seconds, optional\n * all-zero fraction, optional `Z`/offset. `00:00:01` and `00:00:00.001` do NOT\n * match: they carry a real time.\n */\nconst ZERO_TIME_DATE_TIME_RE =\n  /^(\\d{4}-\\d{2}-\\d{2})[T ]00:00(?::00(?:\\.0+)?)?(?:Z|z|[+-]\\d{2}:?\\d{2})?$/;\n\n/** Any RFC 3339-ish datetime we can hand to the runtime as a date-time. */\nconst DATE_TIME_RE =\n  /^(\\d{4}-\\d{2}-\\d{2})[T ](\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.\\d+)?)?(?:Z|z|[+-]\\d{2}:?\\d{2})?$/;\n\n/** Guards against `2026-02-30` - a well-formed string that isn't a real day. */\nfunction isRealCalendarDate(value: string): boolean {\n  const match = FULL_DATE_RE.exec(value);\n  if (!match) return false;\n  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];\n  if (month < 1 || month > 12) return false;\n  const date = new Date(Date.UTC(year, month - 1, day));\n  return (\n    date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day\n  );\n}\n\n/**\n * The calendar day a value denotes, or `null` when it doesn't denote one.\n * Accepts a bare date or a midnight-padded timestamp; the day is taken\n * LITERALLY from the string (never shifted through a timezone), matching\n * pydantic - `2026-07-06T00:00:00+02:00` is 2026-07-06, not the 5th.\n */\nexport function asCalendarDate(value: string): string | null {\n  if (isRealCalendarDate(value)) return value;\n  const zeroTime = ZERO_TIME_DATE_TIME_RE.exec(value);\n  if (zeroTime && isRealCalendarDate(zeroTime[1]!)) return zeroTime[1]!;\n  return null;\n}\n\n/**\n * The calendar day inside a value that carries a REAL time - precisely the case\n * `asCalendarDate` refuses. `null` when the value isn't a timestamp at all, or\n * when it IS already an acceptable day (nothing to report).\n *\n * This exists to EXPLAIN, never to coerce. `2026-07-06T14:30:00+02:00` is\n * rejected for a `format: date` field, and the rejection is right (DT3, \"no\n * silent midnight\" - dropping 14:30 corrupts the value). But telling the user\n * \"pick a valid date\" while the picker shows them a perfectly good 06/07/2026\n * reads as a lie: `toDateInputValue` renders the day, the stored value carries\n * the time, and only one of those is what gets validated. Naming both the value\n * we hold and the day it would have to become is what makes the error legible.\n */\nexport function dayWithinDateTime(value: string): string | null {\n  if (asCalendarDate(value) !== null) return null;\n  const match = DATE_TIME_RE.exec(value);\n  if (!match || !isRealCalendarDate(match[1]!)) return null;\n  return match[1]!;\n}\n\n/**\n * What `format: \"date\"` accepts: a bare `YYYY-MM-DD`, and nothing else.\n *\n * DO NOT relax this to take a midnight-padded timestamp. `DateContent` in\n * pipelex carries a `mode=\"before\"` field validator (`_reject_lax_temporal`)\n * that deliberately CLOSES pydantic's lax coercion for exactly this case:\n *\n *   \"A Date's `date` field takes a calendar date alone; a string carrying a\n *    time (e.g. '2026-07-07T00:00:00') would drop it - put the time and offset\n *    in `time` instead.\"\n *\n * That rule (DT3, \"no silent midnight\") is the concept's whole point, so a\n * lenient client here does not help anyone: it just forwards the value and the\n * runner answers with a 500 instead of the field saying so up front.\n *\n * The leniency belongs in `asCalendarDate` - normalize the pasted timestamp to\n * the day it denotes, then this passes. Accept-and-fix, not accept-and-forward.\n */\nexport function isAcceptableDate(value: string): boolean {\n  return isRealCalendarDate(value);\n}\n\n/** What `format: \"date-time\"` should accept - a bare day is midnight. */\nexport function isAcceptableDateTime(value: string): boolean {\n  if (isRealCalendarDate(value)) return true;\n  const match = DATE_TIME_RE.exec(value);\n  if (!match || !isRealCalendarDate(match[1]!)) return false;\n  const [hours, minutes, seconds] = [Number(match[2]), Number(match[3]), Number(match[4] ?? 0)];\n  return hours <= 23 && minutes <= 59 && seconds <= 59;\n}\n\n/** The `YYYY-MM-DD` a native date input shows, from any stored date/date-time. */\nexport function toDateInputValue(value: string | undefined): string {\n  if (typeof value !== 'string') return '';\n  return asCalendarDate(value) ?? value.slice(0, 10);\n}\n\n/**\n * The value to store for a picked day. A `date-time` field becomes midnight-UTC\n * (`2026-07-06T00:00:00Z`); a plain `date` field keeps the bare `YYYY-MM-DD`.\n * An empty day clears the value.\n */\nexport function toStoredDateValue(day: string, datetime: boolean): string | undefined {\n  if (!day) return undefined;\n  return datetime ? `${day}T00:00:00Z` : day;\n}\n"]}

package/dist/chunk-HARYEWNG.js

@@ -0,0 +1,31 @@
+import { ownProp } from './chunk-V3OV2XQT.js';
+
+// src/core/contracts.ts
+function buildPipeRef(domain, pipeCode) {
+  return `${domain}.${pipeCode}`;
+}
+function getPipeIOContract(pipeIoContracts, domain, pipeCode) {
+  if (!pipeIoContracts || !pipeCode) return void 0;
+  if (domain) {
+    const byRef = ownProp(pipeIoContracts, buildPipeRef(domain, pipeCode));
+    if (byRef) return byRef;
+  }
+  return ownProp(pipeIoContracts, pipeCode);
+}
+function isOptionalInput(input) {
+  return input.presence === "optional";
+}
+function isPluralInput(input) {
+  return input.json_schema?.type === "array";
+}
+function isFixedCountInput(input) {
+  return input.multiplicity === "fixed";
+}
+function inputMustBeFilled(input) {
+  if (isOptionalInput(input)) return false;
+  return !isPluralInput(input) || isFixedCountInput(input);
+}
+
+export { buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput };
+//# sourceMappingURL=chunk-HARYEWNG.js.map
+//# sourceMappingURL=chunk-HARYEWNG.js.map

package/dist/chunk-HARYEWNG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/contracts.ts"],"names":[],"mappings":";;;AAiFO,SAAS,YAAA,CAAa,QAAgB,QAAA,EAA0B;AACrE,EAAA,OAAO,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,QAAQ,CAAA,CAAA;AAC9B;AAkBO,SAAS,iBAAA,CACd,eAAA,EACA,MAAA,EACA,QAAA,EAC4B;AAC5B,EAAA,IAAI,CAAC,eAAA,IAAmB,CAAC,QAAA,EAAU,OAAO,MAAA;AAC1C,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,MAAM,QAAQ,OAAA,CAAQ,eAAA,EAAiB,YAAA,CAAa,MAAA,EAAQ,QAAQ,CAAC,CAAA;AACrE,IAAA,IAAI,OAAO,OAAO,KAAA;AAAA,EACpB;AACA,EAAA,OAAO,OAAA,CAAQ,iBAAiB,QAAQ,CAAA;AAC1C;AAWO,SAAS,gBAAgB,KAAA,EAAmC;AACjE,EAAA,OAAO,MAAM,QAAA,KAAa,UAAA;AAC5B;AAcO,SAAS,cAAc,KAAA,EAAmC;AAC/D,EAAA,OAAQ,KAAA,CAAM,aAAgD,IAAA,KAAS,OAAA;AACzE;AASO,SAAS,kBAAkB,KAAA,EAAmC;AACnE,EAAA,OAAO,MAAM,YAAA,KAAiB,OAAA;AAChC;AAqBO,SAAS,kBAAkB,KAAA,EAAmC;AACnE,EAAA,IAAI,eAAA,CAAgB,KAAK,CAAA,EAAG,OAAO,KAAA;AACnC,EAAA,OAAO,CAAC,aAAA,CAAc,KAAK,CAAA,IAAK,kBAAkB,KAAK,CAAA;AACzD","file":"chunk-HARYEWNG.js","sourcesContent":["/**\n * The typed `pipe_io_contracts` mirror and its gating predicates.\n *\n * Mirrors pipelex's `PipeIOContract` (pipelex/pipeline/pipe_io_contracts.py).\n * The SDK deliberately keeps `pipe_io_contracts` opaque, so the kernel is the\n * canonical TS home for this shape until the D-track specs it.\n *\n * The map itself is keyed by namespaced pipe ref (`<domain>.<pipe_code>`),\n * NOT bare pipe code - use `getPipeIOContract` to look entries up by the bare\n * codes the UI tracks.\n */\n\nimport { ownProp } from './own-property';\n\n/**\n * The authored presence marker on an input slot, verbatim.\n *\n * - `plain` - no marker: the caller must supply the input.\n * - `optional` (`?`) - the caller may omit it and the pipe handles the absence\n *   itself.\n * - `force` (`!`) - a use-site assertion that the value IS present. It must be\n *   supplied, exactly like `plain`; the distinction is the authored assertion,\n *   which lint and graph surfaces read and a form does not.\n */\nexport type InputPresence = 'plain' | 'optional' | 'force';\n\n/**\n * How many items a slot carries.\n *\n * - `single` - one item. `Concept[1]` is single too: no list framing.\n * - `variable` (`Concept[]`) - a list of any length, the empty list included.\n * - `fixed` (`Concept[N]`, N > 1) - a list of exactly `item_count` items.\n */\nexport type IOMultiplicity = 'single' | 'variable' | 'fixed';\n\nexport interface PipeInputContract {\n  concept_ref: string;\n  /** The declared presence marker - see `InputPresence`. */\n  presence: InputPresence;\n  /** The declared multiplicity - see `IOMultiplicity`. */\n  multiplicity: IOMultiplicity;\n  /**\n   * The exact item count, non-null exactly when `multiplicity` is `fixed`. The\n   * slot is always on the wire, `null` off the fixed arm.\n   */\n  item_count: number | null;\n  /**\n   * The input's JSON Schema. A plural slot (`variable` or `fixed`) is an array\n   * wrapper around the item schema, and a `fixed` one additionally carries\n   * `minItems` / `maxItems` set to `item_count` - which is what makes the gate's\n   * ajv pass enforce the declared count without the kernel restating it.\n   */\n  json_schema: Record<string, unknown>;\n}\n\nexport interface PipeOutputContract {\n  concept_ref: string;\n  multiplicity: IOMultiplicity;\n  /** As on the input: non-null exactly on the `fixed` arm, always on the wire. */\n  item_count: number | null;\n  /**\n   * `true` when the output is declared optional (`?`) - the pipe may resolve it\n   * as a recorded absence instead of a value.\n   *\n   * Deliberately still a boolean while the INPUT side carries three-valued\n   * `presence`: output presence is genuinely two-valued, because `!` is\n   * rejected on an output. The asymmetry is the wire's, not ours.\n   */\n  optional: boolean;\n}\n\nexport interface PipeIOContract {\n  inputs: Record<string, PipeInputContract>;\n  output: PipeOutputContract;\n}\n\n/** The `pipe_io_contracts` map: namespaced `pipe_ref` → IO contract. */\nexport type PipeIOContracts = Record<string, PipeIOContract>;\n\n/** Namespaced pipe ref (`<domain>.<pipe_code>`) - the identity convention the\n *  validate artifacts key on. */\nexport function buildPipeRef(domain: string, pipeCode: string): string {\n  return `${domain}.${pipeCode}`;\n}\n\n/**\n * Look up a pipe's IO contract by pipe code, tolerant of both key conventions.\n *\n * The map may be keyed by namespaced `pipe_ref` (`<domain>.<code>`, the\n * canonical convention) OR by bare pipe code - the current hosted `/validate`\n * keys `pipe_structures` by bare code, and methods persisted before the\n * pipe_ref re-keying also carry bare-code keys. Try the namespaced ref first\n * (when the caller supplies a domain), then fall back to the bare code.\n * Returns `undefined` (never crashes) when neither matches.\n *\n * Both lookups read OWN properties only. A bare index returned the inherited\n * `Object` constructor for a pipe code named `constructor` (or `toString`, …) -\n * a truthy non-contract that sailed straight through the `if (!contract)` guard\n * hosts are shown writing, so a pipe that does not exist rendered as one taking\n * no inputs instead of reaching the host's not-found path. See `ownProp`.\n */\nexport function getPipeIOContract(\n  pipeIoContracts: PipeIOContracts | null | undefined,\n  domain: string | null | undefined,\n  pipeCode: string | null | undefined,\n): PipeIOContract | undefined {\n  if (!pipeIoContracts || !pipeCode) return undefined;\n  if (domain) {\n    const byRef = ownProp(pipeIoContracts, buildPipeRef(domain, pipeCode));\n    if (byRef) return byRef;\n  }\n  return ownProp(pipeIoContracts, pipeCode);\n}\n\n/**\n * True when the method declared the input omittable (`?`).\n *\n * The ONE reader of `presence` in the package: everything that asks \"may this\n * be absent?\" - the descriptor's `required`, the gate's `required` list, the\n * payload builders that omit an unfilled input - goes through here, so a\n * marker the wire adds later cannot mean one thing on one surface and another\n * elsewhere. `force` (`!`) reads as NOT optional, like `plain`.\n */\nexport function isOptionalInput(input: PipeInputContract): boolean {\n  return input.presence === 'optional';\n}\n\n/**\n * True when the input carries a plural concept (`Image[]`, `Image[3]`): its\n * JSON Schema is an array wrapper.\n *\n * Deliberately a SCHEMA test rather than a read of the declared `multiplicity`,\n * even though the wire now states both. The schema is what `buildRunFields`\n * maps and therefore what the user is shown; a predicate reading the other\n * field could disagree with the rendered control, which is the exact failure\n * mode `mustBeFilled` (readiness.ts) exists to prevent. The two agree by\n * construction upstream - pipelex wraps the schema in an array exactly when it\n * reports `variable` or `fixed`.\n */\nexport function isPluralInput(input: PipeInputContract): boolean {\n  return (input.json_schema as { type?: unknown } | undefined)?.type === 'array';\n}\n\n/**\n * True when the slot declares an EXACT number of items (`Concept[N]`), whose\n * count is `item_count`.\n *\n * The distinction that matters to the gate: a variable list can legitimately be\n * empty, a fixed one cannot.\n */\nexport function isFixedCountInput(input: PipeInputContract): boolean {\n  return input.multiplicity === 'fixed';\n}\n\n/**\n * True when the user MUST put a value in before a run can start.\n *\n * Two declarations relieve an input of that duty, for different reasons:\n * - **optional (`?`)** - the method itself states the caller may omit it;\n * - **variable-plural (`[]`)** - the empty list is a legitimate value and the\n *   language cannot declare \"at least one\", so gating on it would invent a\n *   constraint the method never made.\n *\n * Everything else gates: `plain`, `force` (`!`), and a **fixed-count** list\n * (`[N]`), which is a list whose empty form the method has explicitly ruled out.\n * This is the derivation the input-form descriptor spec states for `gating`.\n *\n * Emptiness is all this predicate answers for - WHETHER a slot gates, never how\n * much it needs. A fixed-count list that holds fewer items than it declares\n * gates here and is refused by `fieldFilled`, which reads the declared count off\n * the descriptor's `itemCount`, and by the gate's ajv pass on the schema's\n * `minItems`. All three read the one number the method stated.\n */\nexport function inputMustBeFilled(input: PipeInputContract): boolean {\n  if (isOptionalInput(input)) return false;\n  return !isPluralInput(input) || isFixedCountInput(input);\n}\n"]}

package/dist/chunk-KFZ5MZOM.js

@@ -0,0 +1,44 @@
+import { flattenAnyOf, hoistDefsToRoot } from './chunk-O4O3QNVC.js';
+
+// src/core/normalize-schema.ts
+function normalizeSchemaForRjsf(schema) {
+  let normalized = flattenAnyOf(schema);
+  if (normalized.properties && typeof normalized.properties === "object") {
+    const props = normalized.properties;
+    const normalizedProps = {};
+    for (const [key, value] of Object.entries(props)) {
+      normalizedProps[key] = value && typeof value === "object" ? normalizeSchemaForRjsf(value) : value;
+    }
+    normalized = { ...normalized, properties: normalizedProps };
+  }
+  if (normalized.items && typeof normalized.items === "object" && !Array.isArray(normalized.items)) {
+    normalized = {
+      ...normalized,
+      items: normalizeSchemaForRjsf(normalized.items)
+    };
+  }
+  if (Array.isArray(normalized.anyOf)) {
+    normalized = {
+      ...normalized,
+      anyOf: normalized.anyOf.map(
+        (branch) => typeof branch === "object" && branch !== null ? normalizeSchemaForRjsf(branch) : branch
+      )
+    };
+  }
+  if (normalized.$defs && typeof normalized.$defs === "object" && !Array.isArray(normalized.$defs)) {
+    const defs = normalized.$defs;
+    const normalizedDefs = {};
+    for (const [key, value] of Object.entries(defs)) {
+      normalizedDefs[key] = value && typeof value === "object" ? normalizeSchemaForRjsf(value) : value;
+    }
+    normalized = { ...normalized, $defs: normalizedDefs };
+  }
+  return normalized;
+}
+function prepareSchemaForRjsf(schema) {
+  return normalizeSchemaForRjsf(hoistDefsToRoot(schema));
+}
+
+export { normalizeSchemaForRjsf, prepareSchemaForRjsf };
+//# sourceMappingURL=chunk-KFZ5MZOM.js.map
+//# sourceMappingURL=chunk-KFZ5MZOM.js.map

package/dist/chunk-KFZ5MZOM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/normalize-schema.ts"],"names":[],"mappings":";;;AAsBO,SAAS,uBAAuB,MAAA,EAA0D;AAE/F,EAAA,IAAI,UAAA,GAAa,aAAa,MAAM,CAAA;AAGpC,EAAA,IAAI,UAAA,CAAW,UAAA,IAAc,OAAO,UAAA,CAAW,eAAe,QAAA,EAAU;AACtE,IAAA,MAAM,QAAQ,UAAA,CAAW,UAAA;AACzB,IAAA,MAAM,kBAA2C,EAAC;AAClD,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AAChD,MAAA,eAAA,CAAgB,GAAG,IACjB,KAAA,IAAS,OAAO,UAAU,QAAA,GACtB,sBAAA,CAAuB,KAAgC,CAAA,GACvD,KAAA;AAAA,IACR;AACA,IAAA,UAAA,GAAa,EAAE,GAAG,UAAA,EAAY,UAAA,EAAY,eAAA,EAAgB;AAAA,EAC5D;AAGA,EAAA,IACE,UAAA,CAAW,KAAA,IACX,OAAO,UAAA,CAAW,KAAA,KAAU,QAAA,IAC5B,CAAC,KAAA,CAAM,OAAA,CAAQ,UAAA,CAAW,KAAK,CAAA,EAC/B;AACA,IAAA,UAAA,GAAa;AAAA,MACX,GAAG,UAAA;AAAA,MACH,KAAA,EAAO,sBAAA,CAAuB,UAAA,CAAW,KAAgC;AAAA,KAC3E;AAAA,EACF;AAGA,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,UAAA,CAAW,KAAK,CAAA,EAAG;AACnC,IAAA,UAAA,GAAa;AAAA,MACX,GAAG,UAAA;AAAA,MACH,KAAA,EAAQ,WAAW,KAAA,CAAoC,GAAA;AAAA,QAAI,CAAC,WAC1D,OAAO,MAAA,KAAW,YAAY,MAAA,KAAW,IAAA,GACrC,sBAAA,CAAuB,MAAiC,CAAA,GACxD;AAAA;AACN,KACF;AAAA,EACF;AAGA,EAAA,IACE,UAAA,CAAW,KAAA,IACX,OAAO,UAAA,CAAW,KAAA,KAAU,QAAA,IAC5B,CAAC,KAAA,CAAM,OAAA,CAAQ,UAAA,CAAW,KAAK,CAAA,EAC/B;AACA,IAAA,MAAM,OAAO,UAAA,CAAW,KAAA;AACxB,IAAA,MAAM,iBAA0C,EAAC;AACjD,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,KAAK,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA,EAAG;AAC/C,MAAA,cAAA,CAAe,GAAG,IAChB,KAAA,IAAS,OAAO,UAAU,QAAA,GACtB,sBAAA,CAAuB,KAAgC,CAAA,GACvD,KAAA;AAAA,IACR;AACA,IAAA,UAAA,GAAa,EAAE,GAAG,UAAA,EAAY,KAAA,EAAO,cAAA,EAAe;AAAA,EACtD;AAEA,EAAA,OAAO,UAAA;AACT;AAOO,SAAS,qBAAqB,MAAA,EAA0D;AAC7F,EAAA,OAAO,sBAAA,CAAuB,eAAA,CAAgB,MAAM,CAAC,CAAA;AACvD","file":"chunk-KFZ5MZOM.js","sourcesContent":["/**\n * Normalizes a JSON Schema for RJSF compatibility.\n *\n * Pydantic v2 generates `anyOf: [{type: \"string\"}, {type: \"null\"}]` for optional\n * fields (`str | None`). RJSF renders this as a dropdown selector asking the user\n * to pick a sub-schema, which is terrible UX. The normalizer flattens those\n * patterns on every node (see `flattenAnyOf` in `schema-utils.ts` for the exact\n * rules) and hoists nested `$defs` to the root so composed sub-schemas keep\n * their refs resolvable.\n *\n * The collapse and hoist engines live in `schema-utils.ts` - the\n * consolidated home for the kernel's JSON-Schema plumbing; this module owns the\n * recursive application over a whole schema tree.\n */\nimport { flattenAnyOf, hoistDefsToRoot } from './schema-utils';\n\nexport { hoistDefsToRoot };\n\n/**\n * Recursively normalize a JSON Schema for RJSF.\n * Walks the entire schema tree and flattens anyOf patterns on every node.\n */\nexport function normalizeSchemaForRjsf(schema: Record<string, unknown>): Record<string, unknown> {\n  // Flatten anyOf at this level\n  let normalized = flattenAnyOf(schema);\n\n  // Recurse into properties\n  if (normalized.properties && typeof normalized.properties === 'object') {\n    const props = normalized.properties as Record<string, unknown>;\n    const normalizedProps: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(props)) {\n      normalizedProps[key] =\n        value && typeof value === 'object'\n          ? normalizeSchemaForRjsf(value as Record<string, unknown>)\n          : value;\n    }\n    normalized = { ...normalized, properties: normalizedProps };\n  }\n\n  // Recurse into items (array schemas)\n  if (\n    normalized.items &&\n    typeof normalized.items === 'object' &&\n    !Array.isArray(normalized.items)\n  ) {\n    normalized = {\n      ...normalized,\n      items: normalizeSchemaForRjsf(normalized.items as Record<string, unknown>),\n    };\n  }\n\n  // Recurse into anyOf branches that weren't flattened (complex unions)\n  if (Array.isArray(normalized.anyOf)) {\n    normalized = {\n      ...normalized,\n      anyOf: (normalized.anyOf as Record<string, unknown>[]).map((branch) =>\n        typeof branch === 'object' && branch !== null\n          ? normalizeSchemaForRjsf(branch as Record<string, unknown>)\n          : branch,\n      ),\n    };\n  }\n\n  // Recurse into $defs so nested definitions (e.g. ImageSize) also get anyOf normalized\n  if (\n    normalized.$defs &&\n    typeof normalized.$defs === 'object' &&\n    !Array.isArray(normalized.$defs)\n  ) {\n    const defs = normalized.$defs as Record<string, unknown>;\n    const normalizedDefs: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(defs)) {\n      normalizedDefs[key] =\n        value && typeof value === 'object'\n          ? normalizeSchemaForRjsf(value as Record<string, unknown>)\n          : value;\n    }\n    normalized = { ...normalized, $defs: normalizedDefs };\n  }\n\n  return normalized;\n}\n\n/**\n * Prepare a schema for RJSF: hoist all nested `$defs` to the root, then normalize\n * anyOf patterns. Call this on any schema that composes multiple sub-schemas\n * (each of which may ship its own `$defs`).\n */\nexport function prepareSchemaForRjsf(schema: Record<string, unknown>): Record<string, unknown> {\n  return normalizeSchemaForRjsf(hoistDefsToRoot(schema));\n}\n"]}

package/dist/chunk-NMT7BRLO.js

@@ -0,0 +1,40 @@
+// src/core/native-concepts.ts
+function nativeSet(...names) {
+  return new Set(names.flatMap((n) => [n, `native.${n}`]));
+}
+var TEXT_CONCEPTS = nativeSet("Text");
+var DATE_CONCEPTS = nativeSet("Date");
+var HTML_CONCEPTS = nativeSet("HTML");
+var DOCUMENT_CONCEPTS = nativeSet("Document");
+var PAGE_CONCEPTS = nativeSet("Page");
+var IMAGE_CONCEPTS = nativeSet("Image");
+var NUMBER_CONCEPTS = nativeSet("Number");
+var YES_NO_CONCEPTS = nativeSet("YesNo");
+var FIELD_TEXT_CONCEPTS = /* @__PURE__ */ new Set([
+  ...TEXT_CONCEPTS,
+  ...DATE_CONCEPTS
+]);
+var FIELD_DOCUMENT_CONCEPTS = /* @__PURE__ */ new Set([
+  ...DOCUMENT_CONCEPTS,
+  ...PAGE_CONCEPTS
+]);
+function isWireTextConcept(concept) {
+  return TEXT_CONCEPTS.has(concept);
+}
+function isWireDocumentLikeConcept(concept) {
+  return DOCUMENT_CONCEPTS.has(concept) || IMAGE_CONCEPTS.has(concept) || PAGE_CONCEPTS.has(concept);
+}
+var TEXT_WRAPPER_CONCEPTS = /* @__PURE__ */ new Set([
+  ...TEXT_CONCEPTS,
+  ...DATE_CONCEPTS,
+  ...HTML_CONCEPTS
+]);
+function splitListConcept(conceptRef) {
+  if (!conceptRef) return { isList: false };
+  if (conceptRef.endsWith("[]")) return { base: conceptRef.slice(0, -2), isList: true };
+  return { base: conceptRef, isList: false };
+}
+
+export { DATE_CONCEPTS, DOCUMENT_CONCEPTS, FIELD_DOCUMENT_CONCEPTS, FIELD_TEXT_CONCEPTS, HTML_CONCEPTS, IMAGE_CONCEPTS, NUMBER_CONCEPTS, PAGE_CONCEPTS, TEXT_CONCEPTS, TEXT_WRAPPER_CONCEPTS, YES_NO_CONCEPTS, isWireDocumentLikeConcept, isWireTextConcept, splitListConcept };
+//# sourceMappingURL=chunk-NMT7BRLO.js.map
+//# sourceMappingURL=chunk-NMT7BRLO.js.map

package/dist/chunk-NMT7BRLO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/native-concepts.ts"],"names":[],"mappings":";AAqCA,SAAS,aAAa,KAAA,EAAsC;AAC1D,EAAA,OAAO,IAAI,GAAA,CAAI,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,KAAM,CAAC,CAAA,EAAG,CAAA,OAAA,EAAU,CAAC,CAAA,CAAE,CAAC,CAAC,CAAA;AACzD;AAEO,IAAM,aAAA,GAAgB,UAAU,MAAM;AACtC,IAAM,aAAA,GAAgB,UAAU,MAAM;AAEtC,IAAM,aAAA,GAAgB,UAAU,MAAM;AACtC,IAAM,iBAAA,GAAoB,UAAU,UAAU;AAC9C,IAAM,aAAA,GAAgB,UAAU,MAAM;AACtC,IAAM,cAAA,GAAiB,UAAU,OAAO;AACxC,IAAM,eAAA,GAAkB,UAAU,QAAQ;AAC1C,IAAM,eAAA,GAAkB,UAAU,OAAO;AAMzC,IAAM,mBAAA,uBAA+C,GAAA,CAAI;AAAA,EAC9D,GAAG,aAAA;AAAA,EACH,GAAG;AACL,CAAC;AAGM,IAAM,uBAAA,uBAAmD,GAAA,CAAI;AAAA,EAClE,GAAG,iBAAA;AAAA,EACH,GAAG;AACL,CAAC;AAOM,SAAS,kBAAkB,OAAA,EAA0B;AAC1D,EAAA,OAAO,aAAA,CAAc,IAAI,OAAO,CAAA;AAClC;AAGO,SAAS,0BAA0B,OAAA,EAA0B;AAClE,EAAA,OACE,iBAAA,CAAkB,GAAA,CAAI,OAAO,CAAA,IAAK,cAAA,CAAe,IAAI,OAAO,CAAA,IAAK,aAAA,CAAc,GAAA,CAAI,OAAO,CAAA;AAE9F;AAmBO,IAAM,qBAAA,uBAAiD,GAAA,CAAI;AAAA,EAChE,GAAG,aAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG;AACL,CAAC;AAKM,SAAS,iBAAiB,UAAA,EAG/B;AACA,EAAA,IAAI,CAAC,UAAA,EAAY,OAAO,EAAE,QAAQ,KAAA,EAAM;AACxC,EAAA,IAAI,UAAA,CAAW,QAAA,CAAS,IAAI,CAAA,EAAG,OAAO,EAAE,IAAA,EAAM,UAAA,CAAW,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA,EAAG,QAAQ,IAAA,EAAK;AACpF,EAAA,OAAO,EAAE,IAAA,EAAM,UAAA,EAAY,MAAA,EAAQ,KAAA,EAAM;AAC3C","file":"chunk-NMT7BRLO.js","sourcesContent":["/**\n * The native-concept taxonomy, stated ONCE - with each call path's historical\n * view exported explicitly, because the three copies this consolidates had\n * DRIFTED and K1 preserved each path's observable behavior exactly (see\n * `concept-taxonomy-characterization.test.ts`).\n *\n * The sets below spell the codes MTHDS actually defines (the `native` domain of\n * the language spec). That is not pedantry: a set that named a concept the\n * language does not have is what broke `native.Number`, because the render path\n * knew the concept and the value path did not.\n *\n * The drift, recorded for M1 (where the server-derived descriptor retires this\n * module entirely):\n *\n * | concept | field mapper (render)     | wire format (deflate/inflate) | value bridge (content wrapper) |\n * | ------- | ------------------------- | ----------------------------- | ------------------------------ |\n * | Text    | text/prose                | bare string                   | `{text}`, from `TextContent`   |\n * | Number  | number                    | `{concept, content}`          | `{number}`, from `NumberContent` |\n * | YesNo   | boolean                   | `{concept, content}`          | `{yes_no}`, from `YesNoContent` |\n * | Date    | text/prose (NOT a picker) | CUSTOM `{concept, content}`   | `{text}` - WRONG, see below    |\n * | Html    | nested object             | `{concept, content}`          | -                              |\n * | Page    | document                  | document-like (bare URL)      | -                              |\n *\n * A `Date` input therefore ships as `{concept: \"native.Date\", content: {text}}`\n * today - consistent end-to-end, but not `DateContent {date, time}`. Changing\n * that is a wire-visible fix and belongs to M1, not here.\n *\n * `HTML_CONCEPTS` below spells the code `HTML`; the language spells it `Html`\n * (`NativeConceptCode.HTML = \"Html\"`), so the set matches nothing a real\n * contract carries and `native.Html` falls through to the generic object\n * dispatch - a nested card over `HtmlContent {inner_html, css_class}`, which\n * round-trips correctly. Correcting the spelling would route `native.Html` into\n * the prose-plus-`{text}` drift above and BREAK inputs that work today, so the\n * spelling is left alone deliberately and goes with the Date fix at M1.\n */\n\n/** Both spellings a concept ref uses: bare (`Text`) and namespaced (`native.Text`). */\nfunction nativeSet(...names: string[]): ReadonlySet<string> {\n  return new Set(names.flatMap((n) => [n, `native.${n}`]));\n}\n\nexport const TEXT_CONCEPTS = nativeSet('Text');\nexport const DATE_CONCEPTS = nativeSet('Date');\n/** Deliberately the code the language does NOT use - see the header. */\nexport const HTML_CONCEPTS = nativeSet('HTML');\nexport const DOCUMENT_CONCEPTS = nativeSet('Document');\nexport const PAGE_CONCEPTS = nativeSet('Page');\nexport const IMAGE_CONCEPTS = nativeSet('Image');\nexport const NUMBER_CONCEPTS = nativeSet('Number');\nexport const YES_NO_CONCEPTS = nativeSet('YesNo');\n\n// ─── The field mapper's view (field-model.ts) ───────────────────────────────\n\n/** Concepts the mapper renders as text/prose - `Date` deliberately included\n *  (a `native.Date` input renders as prose today, not as a date picker). */\nexport const FIELD_TEXT_CONCEPTS: ReadonlySet<string> = new Set([\n  ...TEXT_CONCEPTS,\n  ...DATE_CONCEPTS,\n]);\n\n/** Concepts the mapper renders as a document upload - `Page` folded in. */\nexport const FIELD_DOCUMENT_CONCEPTS: ReadonlySet<string> = new Set([\n  ...DOCUMENT_CONCEPTS,\n  ...PAGE_CONCEPTS,\n]);\n\n// ─── The wire format's view (input-format.ts) ───────────────────────────────\n\n/** True when the simplified wire form is a bare string (`{text} ↔ \"...\"`).\n *  `Date` is NOT here: it travels through the custom-concept `{concept,\n *  content}` branch (the drift the header records). */\nexport function isWireTextConcept(concept: string): boolean {\n  return TEXT_CONCEPTS.has(concept);\n}\n\n/** True when the simplified wire form is a bare URL string. */\nexport function isWireDocumentLikeConcept(concept: string): boolean {\n  return (\n    DOCUMENT_CONCEPTS.has(concept) || IMAGE_CONCEPTS.has(concept) || PAGE_CONCEPTS.has(concept)\n  );\n}\n\n// ─── The value bridge's view (run-values.ts) ────────────────────────────────\n\n/**\n * The FALLBACK text wrapper, for a text concept whose contract declares no\n * single-property content model to read the wrapper name off.\n *\n * The wrapper property is normally derived from the declared schema, in\n * `derive.ts`, and travels on the descriptor as `RunField.contentKey` - so the\n * value bridge wraps by name and holds no taxonomy of its own. This set is what\n * answers when that derivation finds nothing:\n *\n * - `native.Text` with a degenerate contract (a bare `{type: 'object'}`, or a\n *   bare `{type: 'string'}`) still wraps as `{text}`, as it always has;\n * - `native.Date` declares `DateContent {date, time}` - two properties, so no\n *   single wrapper - and this set is what keeps it wrapping as `{text}`. That\n *   is the recorded drift, preserved on purpose until M1.\n */\nexport const TEXT_WRAPPER_CONCEPTS: ReadonlySet<string> = new Set([\n  ...TEXT_CONCEPTS,\n  ...DATE_CONCEPTS,\n  ...HTML_CONCEPTS,\n]);\n\n// ─── List refs ──────────────────────────────────────────────────────────────\n\n/** A concept ref like `native.Document[]` → base `native.Document`, isList true. */\nexport function splitListConcept(conceptRef: string | undefined): {\n  base?: string;\n  isList: boolean;\n} {\n  if (!conceptRef) return { isList: false };\n  if (conceptRef.endsWith('[]')) return { base: conceptRef.slice(0, -2), isList: true };\n  return { base: conceptRef, isList: false };\n}\n"]}