@pipelex/mthds-form 0.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,615 @@
+import { R as RunField } from '../descriptor-X6MwFIWu.js';
+export { B as BooleanRunField, C as ConceptCategory, D as DateRunField, E as EnumRunField, F as FileRunField, L as ListRunField, N as NumberRunField, O as ObjectRunField, P as ProseRunField, a as RunFieldCommon, b as RunFieldKind, T as TextRunField, U as UnknownRunField, c as conceptCategory } from '../descriptor-X6MwFIWu.js';
+
+/**
+ * The typed `pipe_io_contracts` mirror and its gating predicates.
+ *
+ * Mirrors pipelex's `PipeIOContract` (pipelex/pipeline/pipe_io_contracts.py).
+ * The SDK deliberately keeps `pipe_io_contracts` opaque, so the kernel is the
+ * canonical TS home for this shape until the D-track specs it.
+ *
+ * The map itself is keyed by namespaced pipe ref (`<domain>.<pipe_code>`),
+ * NOT bare pipe code - use `getPipeIOContract` to look entries up by the bare
+ * codes the UI tracks.
+ */
+interface PipeInputContract {
+    concept_ref: string;
+    json_schema: Record<string, unknown>;
+    /**
+     * `true` when the input is declared optional (`?`) - the caller may omit it
+     * and the pipe handles the absence itself. Plain and force (`!`) inputs
+     * report `false`. Absent on contracts persisted before the API carried the
+     * flag, so read it as "optional only when explicitly true".
+     */
+    optional?: boolean;
+}
+interface PipeOutputContract {
+    concept_ref: string;
+    multiplicity: 'single' | 'variable';
+    /** `true` when the output is declared optional (`?`) - the pipe may resolve
+     *  it as a recorded absence instead of a value. */
+    optional?: boolean;
+}
+interface PipeIOContract {
+    inputs: Record<string, PipeInputContract>;
+    output: PipeOutputContract;
+}
+/** The `pipe_io_contracts` map: namespaced `pipe_ref` → IO contract. */
+type PipeIOContracts = Record<string, PipeIOContract>;
+/** Namespaced pipe ref (`<domain>.<pipe_code>`) - the identity convention the
+ *  validate artifacts key on. */
+declare function buildPipeRef(domain: string, pipeCode: string): string;
+/**
+ * Look up a pipe's IO contract by pipe code, tolerant of both key conventions.
+ *
+ * The map may be keyed by namespaced `pipe_ref` (`<domain>.<code>`, the
+ * canonical convention) OR by bare pipe code - the current hosted `/validate`
+ * keys `pipe_structures` by bare code, and methods persisted before the
+ * pipe_ref re-keying also carry bare-code keys. Try the namespaced ref first
+ * (when the caller supplies a domain), then fall back to the bare code.
+ * Returns `undefined` (never crashes) when neither matches.
+ */
+declare function getPipeIOContract(pipeIoContracts: PipeIOContracts | null | undefined, domain: string | null | undefined, pipeCode: string | null | undefined): PipeIOContract | undefined;
+/**
+ * True when the input carries a plural concept (`Image[]`): its JSON Schema is
+ * an array wrapper. A plural slot is never "absent" in MTHDS - its empty form
+ * IS the empty list - so the UI must treat "nothing entered" as a real value.
+ */
+declare function isPluralInput(input: PipeInputContract): boolean;
+/**
+ * True when the user MUST put a value in before a run can start.
+ *
+ * Two declarations relieve an input of that duty, for different reasons:
+ * - **optional (`?`)** - the method itself states the caller may omit it;
+ * - **plural (`[]`)** - the empty list is a legitimate value and no method can
+ *   declare "at least one", so gating on it would invent a constraint the
+ *   method never made.
+ *
+ * Everything else (plain and force `!`) still gates: that is the whole point of
+ * the Run button telling you what is missing.
+ */
+declare function inputMustBeFilled(input: PipeInputContract): boolean;
+
+/**
+ * The ONE derivation function: `PipeInputContract` map → `RunField[]`.
+ *
+ * Everything heuristic stays module-private behind `buildRunFields`: the
+ * native-concept taxonomy, `isDocumentObject`, the depth-based prose/label
+ * rule, the `accept` strings, list splitting. Nothing here is exported except
+ * the function itself - so the M1 milestone can swap the source of the
+ * descriptor (server-derived) without touching consumers.
+ */
+
+/**
+ * Convert the API's per-input contracts into the runner's field descriptors.
+ * The map's insertion order is preserved (required-first is the caller's job).
+ */
+declare function buildRunFields(inputs: Record<string, PipeInputContract>): RunField[];
+
+/**
+ * Value readiness - the helpers the runner uses to decide whether the Run
+ * button may fire and which inputs are still missing.
+ */
+
+/** True when a value is meaningfully filled (not empty / blank / empty container). */
+declare function isFilled(value: unknown): boolean;
+/** True when every required field has a value. */
+declare function fieldFilled(field: RunField, value: unknown): boolean;
+interface Readiness {
+    total: number;
+    ready: number;
+    missing: string[];
+}
+/**
+ * True when the user must put a value in this field before the run can start.
+ *
+ * Distinct from `required`, which also drives layout (a required field always
+ * shows; an optional one may collapse). A **plural** field stays required - it
+ * is a first-class input and keeps its place in the form - but it never gates:
+ * a plural slot is never "absent" in MTHDS, its empty form IS the empty list,
+ * and no method can declare "at least one item".
+ *
+ * **For a field the app built, the answer comes from `inputMustBeFilled`**
+ * (`contracts.ts`) - the SAME predicate the method viewer's Run button, its ajv
+ * `required` list and its missing-inputs toast all read. `buildRunFields`
+ * stamps it onto `gating`. This used to be re-derived here as
+ * `required && kind !== 'list'`: the same rule expressed against the MAPPED
+ * field instead of the contract, and the two could disagree - `kind` is `'list'`
+ * for a `conceptRef` ending in `[]` OR an array schema, while the contract's
+ * plural test is the array schema alone, so a plural input carrying a non-array
+ * schema gated on one surface and not the other.
+ *
+ * The shape heuristic survives only as the fallback for a **hand-authored**
+ * `RunField` - story fixtures and unit tests, which have no contract to consult
+ * and therefore nothing to disagree with. Every field the app renders comes from
+ * `buildRunFields` and carries `gating`, so the app is on the contract's answer
+ * alone.
+ */
+declare function mustBeFilled(field: RunField): boolean;
+/** How many gating top-level inputs are satisfied by the current values. */
+declare function computeReadiness(fields: RunField[], values: Record<string, unknown>): Readiness;
+
+/**
+ * One validation error, in the shape the app reads (`property`, `message`,
+ * `name`, `stack`, `params.format`). Structurally a superset-compatible twin of
+ * RJSF's `RJSFValidationError`, so surfaces still holding RJSF form errors (the
+ * method editor's Inputs panel) can hand them to the same message renderer.
+ */
+interface RunInputError {
+    /** The ajv keyword that failed (`required`, `format`, `type`, …). */
+    name?: string;
+    /** Dotted path into the form data (`.quote_date.date`); for a `required`
+     *  error the missing property name is appended (top-level: no leading dot). */
+    property?: string;
+    message?: string;
+    params?: Record<string, unknown>;
+    /** The human line: `property message`, or `'title' message` when the parent
+     *  schema titles the field. */
+    stack: string;
+    schemaPath?: string;
+}
+/**
+ * Validate `data` against `schema`, returning mapped errors (empty = valid).
+ * MUTATES `data` where ajv coerces (`"20"` → `20`) - deliberate and relied on:
+ * the string the user typed is stored as a number going forward.
+ */
+declare function validateRunInputsSchema(data: unknown, schema: object): RunInputError[];
+
+type Dict$1 = Record<string, unknown>;
+/**
+ * Combine the per-input schemas into one object schema.
+ *
+ * Each input variable becomes a property, titled with the variable name and
+ * described with the concept code. Only the inputs the method actually demands
+ * land in `required` - an optional (`?`) or plural (`[]`) input must not block
+ * the form (see `inputMustBeFilled`).
+ */
+declare function buildRunInputsSchema(inputs: Record<string, PipeInputContract>): Dict$1;
+/**
+ * Last-gate repair, in two passes against the exact schema ajv validates.
+ *
+ * 1. **HEAL** - persisted `inputData` may still carry the legacy double-wrapped
+ *    `{ text: { text } }` shape (or a form's state may lag a store fix).
+ * 2. **PRUNE** - RJSF fills every unset string with `""` on mount, which an
+ *    optional CONSTRAINED field rejects (`DateContent.time` is `format: "time"`)
+ *    - blocking a run on a field the user never opened. An absent optional field
+ *    is what pipelex means by `None` anyway, so dropping it is the semantically
+ *    correct repair, not a validation dodge.
+ */
+declare function prepareRunInputs(data: Dict$1, schema: Dict$1): Dict$1;
+interface RunInputsVerdict {
+    isValid: boolean;
+    /** Variable names the scan could pin a missing required field on. */
+    missingInputs: string[];
+    /** Raw ajv errors, for when the scan cannot name anything. */
+    errors: RunInputError[];
+}
+/**
+ * Validate PREPARED data against the combined schema.
+ *
+ * `missingInputs` is reported by VARIABLE NAME - the name on the node the user
+ * clicks - never by `concept_ref`, which used to produce "Missing required
+ * fields in: native.Text" and named neither the input at fault nor, when several
+ * inputs share a concept, which of them. Inputs the method declared omittable
+ * are skipped: an empty `?` input is not a missing one.
+ *
+ * The scan can come up empty even on an invalid form (a wrong value shape, a
+ * nested mismatch); `errors` is what the caller falls back to then, so a failure
+ * is never undiagnosable.
+ */
+declare function validateRunInputs(preparedData: Dict$1, inputs: Record<string, PipeInputContract>, schema: Dict$1): RunInputsVerdict;
+/**
+ * Build the `{ concept, content }` map a run expects, from PREPARED data.
+ *
+ * The two ways a method says "this may be nothing" land differently on the wire:
+ * - an **optional (`?`)** input left blank is OMITTED, so the runtime records a
+ *   real absence the method can branch on - sending `{ text: "" }` would look
+ *   like the caller supplied an empty string;
+ * - a **plural (`[]`)** input keeps its key, because a plural slot is never
+ *   absent - its empty form IS the empty list, and the runtime requires the key.
+ *   When that list is EMPTY it is sent BARE, without the envelope: the envelope
+ *   is the runtime's "explicit form", which bypasses the top-down shaper and
+ *   hands the value to the bottom-up factory, and that factory types a list from
+ *   its first item - so an empty list there raises "Cannot create Stuff from
+ *   empty list in content". The bare form keeps the shaper, which reads the
+ *   DECLARED concept and builds the empty list correctly. (pipelex/#1096 makes
+ *   the envelope agree; the bare form runs today and stays correct after.)
+ */
+declare function apiInputsFromSchemaData(preparedData: Dict$1, inputs: Record<string, PipeInputContract>): Dict$1;
+
+/**
+ * Bridges the `MethodRunner`'s field values to the rest of the app.
+ *
+ * The method-store keeps inputs in the *simplified* format and runs send the
+ * *full* RJSF form shape - both already handled by `inflate/deflateAllInputs`.
+ * The only gap is that a few field controls use a friendlier value than RJSF:
+ * text is a plain string (RJSF wraps it `{ text }`) and a file is `{ url,
+ * filename }`. `fromRjsf`/`toRjsf` translate just those, so store reads/writes
+ * and run payloads stay byte-for-byte compatible with the proven playground path.
+ *
+ * Pure module - no React, unit-tested.
+ */
+
+type Dict = Record<string, unknown>;
+type InputSchemas = Record<string, PipeInputContract>;
+/** Seed the runner's form values from the method-store's simplified inputData. */
+declare function runValuesFromStore(inputData: Dict | undefined, fields: RunField[], inputSchemas: InputSchemas): Dict;
+/**
+ * The runner's form values in **schema shape** - the same shape the MethodViewer's
+ * RJSF form holds, and therefore the shape `gate.ts` validates
+ * against the per-input JSON Schemas.
+ *
+ * Deliberately stops short of `deflateAllInputs`: deflation is the STORE's
+ * compact form, and ajv validates the full one.
+ */
+declare function rjsfDataFromRunValues(values: Dict, fields: RunField[]): Dict;
+/** Convert the runner's form values back to the store's simplified inputData. */
+declare function storeInputDataFromRunValues(values: Dict, fields: RunField[], inputSchemas: InputSchemas): Dict;
+/**
+ * Build the `{ concept, content }` map a run expects from the form values.
+ *
+ * The two ways a method says "this may be nothing" land differently on the wire,
+ * and both matter:
+ * - an **optional (`?`)** input left blank is OMITTED, so the runtime records a
+ *   real absence the method can branch on - sending `{ text: "" }` would look
+ *   like the caller supplied an empty string;
+ * - a **plural (`[]`)** input keeps its key, because a plural slot is never
+ *   absent - its empty form IS the empty list, and the runtime requires the key.
+ *   When that list is EMPTY it is sent BARE, without the envelope: the envelope
+ *   is the runtime's "explicit form", which bypasses the top-down shaper and
+ *   hands the value to the bottom-up factory, and that factory types a list from
+ *   its first item - so an empty list there raises "Cannot create Stuff from
+ *   empty list in content". The bare form keeps the shaper, which reads the
+ *   DECLARED concept and builds the empty list correctly. (pipelex/#1096 makes
+ *   the envelope agree; the bare form runs today and stays correct after.)
+ */
+declare function apiInputsFromRunValues(values: Dict, fields: RunField[], inputSchemas: InputSchemas): Record<string, unknown>;
+/** One named output pulled out of a run's working memory, ready to render. */
+interface OutputEntry {
+    /** The output variable key (mono). */
+    key: string;
+    conceptRef?: string;
+    value: unknown;
+}
+/**
+ * Split a run's pipe output into the main result and any intermediate outputs,
+ * excluding the inputs. The main output's identity comes from the working
+ * memory's `main_stuff` alias (the authoritative pointer to the output variable)
+ * - so its label is the REAL stuff name, not a positional guess. Falls back to
+ * the last produced stuff only when the alias is absent.
+ */
+declare function outputsFromPipeOutput(pipeOutput: unknown, inputKeys: string[]): {
+    main: OutputEntry;
+    intermediates: OutputEntry[];
+} | null;
+/**
+ * Recover the inputs a run was executed with from its working memory. The run's
+ * `working_memory.root` holds every named stuff - inputs AND outputs - keyed by
+ * variable name; we pull the entries whose keys are declared inputs and deflate
+ * their `content` (the full form shape) back into the store's simplified
+ * `inputData`. Lets the runner repopulate the form for a past/shared run - the
+ * inputs that produced the result. Returns `null` when no inputs are present.
+ */
+declare function inputDataFromWorkingMemory(workingMemory: unknown, inputSchemas: InputSchemas): Dict | null;
+/** Field descriptors for a method's main pipe. */
+declare function fieldsForContract(contract: PipeIOContract | undefined): RunField[];
+/**
+ * Immutably set a value at a dotted/indexed path (`a.0.b`). Used to write an
+ * uploaded file's URL back to a field anywhere in the (possibly nested) tree.
+ */
+declare function setValueAtPath(root: Dict, path: string[], value: unknown): Dict;
+
+/**
+ * Converts between the simplified inputs.json format and the full RJSF form format.
+ *
+ * The inputs.json file uses a SIMPLIFIED format for users:
+ * - Text:       "my text"                     (instead of { text: "my text" })
+ * - Document:   "file.pdf" or { url: "..." }  (instead of { url: "...", ... })
+ * - Image:      same as Document
+ * - Text[]:     ["t1", "t2"]
+ * - Document[]: ["f1.pdf"] or [{ url: "..." }]
+ * - Custom:     { concept, content }           (no simplification)
+ *
+ * The RJSF form uses the FULL concept structure from the json_schema.
+ *
+ * Two directions:
+ * - deflate: form (full) → inputs.json (simplified) - for writing inputs.json / API calls
+ * - inflate: inputs.json (simplified) → form (full)  - for populating the form from inputs.json
+ */
+/**
+ * Convert a single form value to the simplified inputs.json format.
+ * Used when writing inputs.json and when calling the run API.
+ *
+ * Rules:
+ * - Text { text: "hello" } → "hello"
+ * - Document { url: "file.pdf", ... } → "file.pdf" (if only url) or { url, ... }
+ * - Image: same as Document
+ * - Page: same as Document
+ * - List types → array of deflated items
+ * - Custom → { concept, content }
+ */
+declare function deflateInput(value: unknown, conceptCode: string): unknown;
+/**
+ * Convert a simplified inputs.json value to the full form structure.
+ * Used when populating the RJSF form from inputs.json.
+ *
+ * Rules:
+ * - "hello" → { text: "hello" } (for Text concepts)
+ * - "file.pdf" → { url: "file.pdf" } (for Document/Image/Page concepts)
+ * - { url: "..." } → passthrough (already full)
+ * - ["t1", "t2"] → inflated array of items
+ * - { concept, content } → content (for custom concepts)
+ */
+declare function inflateInput(value: unknown, conceptCode: string): unknown;
+interface InputSchema {
+    concept_ref: string;
+    json_schema?: Record<string, unknown>;
+}
+/**
+ * The validation API returns concept_ref WITHOUT the [] suffix for list inputs.
+ * The array-ness is only encoded in json_schema.type === "array".
+ * This helper resolves the correct concept ref by checking the schema.
+ */
+declare function resolveConceptCode(schema: InputSchema): string;
+/**
+ * Deflate all inputs from form format to simplified inputs.json format.
+ * Used by InputConfigPanel when preparing data for the run API.
+ */
+declare function deflateAllInputs(formData: Record<string, unknown>, inputSchemas: Record<string, InputSchema>): Record<string, unknown>;
+/**
+ * Heal values against their json_schema: the run-form bridge used to
+ * double-wrap plain string properties as `{ text: "..." }` (fixed in
+ * run-values.ts, but the corrupted shape survives in persisted inputData -
+ * store and server copies). Wherever the schema expects a string but the
+ * value is a lone `{ text: string }` wrapper, unwrap it. Walks nested
+ * objects and arrays, resolving `#/$defs/...` refs against the root schema;
+ * anything already valid passes through untouched.
+ */
+declare function healStringWrappers(value: unknown, rawSchema: Record<string, unknown> | undefined, defs?: Record<string, Record<string, unknown>>): unknown;
+/**
+ * Drop optional properties the user never filled, so an untouched field cannot
+ * fail validation or reach the API as an empty string.
+ *
+ * RJSF fills EVERY unset string property with `""` on mount. That is harmless
+ * for a plain string, but `prepareSchemaForRjsf` collapses pydantic's
+ * `anyOf: [T, null]` by dropping the null branch, so an optional *constrained*
+ * field - `DateContent.time`, declared `datetime.time | None` and rendered
+ * `{ type: "string", format: "time" }` - is left demanding a well-formed time.
+ * `""` is not one, and the run was blocked on a field the user never opened.
+ *
+ * Pruning is the semantically correct repair, not a validation dodge: for
+ * pipelex an absent optional field IS `None`, and `""` would fail pydantic at
+ * the runner just as it fails ajv here. Only properties absent from their
+ * parent's `required` are dropped - an empty REQUIRED field must still fail, so
+ * the user is told about it.
+ */
+declare function pruneEmptyOptionals(value: unknown, rawSchema: Record<string, unknown> | undefined, defs?: Record<string, Record<string, unknown>>): unknown;
+/**
+ * Inflate all inputs from simplified inputs.json format to form format.
+ * Used by onInputUpdate when receiving inputs.json changes from the sandbox.
+ */
+declare function inflateAllInputs(simplifiedData: Record<string, unknown>, inputSchemas: Record<string, InputSchema>): Record<string, unknown>;
+
+/**
+ * Pure conversions between a stored date value and what a native `<input
+ * type="date">` shows, plus the leniency rules our schema validation uses.
+ * Kept React-free so both the runner's `DateField` and the RJSF `DateWidget`
+ * share one source of truth (and it's trivially unit-tested).
+ *
+ * Two schema shapes reach us, and they are NOT interchangeable:
+ *   - an MTHDS `type = "date"` structure field compiles to `format: date-time`,
+ *     so its value round-trips as a full RFC 3339 timestamp;
+ *   - `native.Date`'s own `date` field is a python `datetime.date`, i.e.
+ *     `format: date` - a bare `YYYY-MM-DD`.
+ *
+ * ## Why these rules exist
+ *
+ * The runtime (pydantic) is LENIENT in both directions, and our client used to
+ * be stricter than the contract it was enforcing: `ajv`'s stock `format: "date"`
+ * accepts a bare `YYYY-MM-DD` and nothing else, so a hand-written
+ * `"2026-07-06T00:00:00Z"` in an `inputs.json` was rejected here even though
+ * pydantic accepts it happily and coerces it to `date(2026, 7, 6)`. The run
+ * never even reached the runner. These predicates mirror pydantic exactly
+ * (measured, not assumed):
+ *
+ *   format: date       "2026-07-06"                -> date(2026, 7, 6)
+ *                      "2026-07-06T00:00:00Z"      -> date(2026, 7, 6)
+ *                      "2026-07-06T00:00:00+02:00" -> date(2026, 7, 6)   (literal date, no UTC shift)
+ *                      "2026-07-06T15:40:00Z"      -> REJECTED "should have zero time"
+ *   format: date-time  "2026-07-06"                -> datetime(2026, 7, 6, 0, 0)
+ *                      "2026-07-06T00:00:00Z"      -> datetime(2026, 7, 6, 0, 0, tz)
+ *
+ * A midnight-padded timestamp is unambiguously "just a day", so take it. A real
+ * time is data - refusing it is the point (`DateContentError`: "no silent
+ * midnight"), because silently dropping 15:40 corrupts the value. And an
+ * ambiguous `06/07/2026` is never accepted by anyone: 6 July or June 7 depends
+ * on who's reading, and guessing wrong fails silently.
+ */
+/**
+ * The calendar day a value denotes, or `null` when it doesn't denote one.
+ * Accepts a bare date or a midnight-padded timestamp; the day is taken
+ * LITERALLY from the string (never shifted through a timezone), matching
+ * pydantic - `2026-07-06T00:00:00+02:00` is 2026-07-06, not the 5th.
+ */
+declare function asCalendarDate(value: string): string | null;
+/**
+ * The calendar day inside a value that carries a REAL time - precisely the case
+ * `asCalendarDate` refuses. `null` when the value isn't a timestamp at all, or
+ * when it IS already an acceptable day (nothing to report).
+ *
+ * This exists to EXPLAIN, never to coerce. `2026-07-06T14:30:00+02:00` is
+ * rejected for a `format: date` field, and the rejection is right (DT3, "no
+ * silent midnight" - dropping 14:30 corrupts the value). But telling the user
+ * "pick a valid date" while the picker shows them a perfectly good 06/07/2026
+ * reads as a lie: `toDateInputValue` renders the day, the stored value carries
+ * the time, and only one of those is what gets validated. Naming both the value
+ * we hold and the day it would have to become is what makes the error legible.
+ */
+declare function dayWithinDateTime(value: string): string | null;
+/**
+ * What `format: "date"` accepts: a bare `YYYY-MM-DD`, and nothing else.
+ *
+ * DO NOT relax this to take a midnight-padded timestamp. `DateContent` in
+ * pipelex carries a `mode="before"` field validator (`_reject_lax_temporal`)
+ * that deliberately CLOSES pydantic's lax coercion for exactly this case:
+ *
+ *   "A Date's `date` field takes a calendar date alone; a string carrying a
+ *    time (e.g. '2026-07-07T00:00:00') would drop it - put the time and offset
+ *    in `time` instead."
+ *
+ * That rule (DT3, "no silent midnight") is the concept's whole point, so a
+ * lenient client here does not help anyone: it just forwards the value and the
+ * runner answers with a 500 instead of the field saying so up front.
+ *
+ * The leniency belongs in `asCalendarDate` - normalize the pasted timestamp to
+ * the day it denotes, then this passes. Accept-and-fix, not accept-and-forward.
+ */
+declare function isAcceptableDate(value: string): boolean;
+/** What `format: "date-time"` should accept - a bare day is midnight. */
+declare function isAcceptableDateTime(value: string): boolean;
+/** The `YYYY-MM-DD` a native date input shows, from any stored date/date-time. */
+declare function toDateInputValue(value: string | undefined): string;
+/**
+ * The value to store for a picked day. A `date-time` field becomes midnight-UTC
+ * (`2026-07-06T00:00:00Z`); a plain `date` field keeps the bare `YYYY-MM-DD`.
+ * An empty day clears the value.
+ */
+declare function toStoredDateValue(day: string, datetime: boolean): string | undefined;
+
+/** The message keys this module renders, relative to the caller's namespace
+ *  (the app passes its `method.editor` translator). */
+type ValidationMessageKey = 'inputPanel.aDateField' | 'inputPanel.pickValidDate' | 'inputPanel.pickValidDateEmpty' | 'inputPanel.dateCarriesTime' | 'inputPanel.invalidValue' | 'inputPanel.invalidValueWithData';
+/**
+ * The translate function the caller injects. Typed on the EXACT keys this
+ * module uses - not a loose `(key: string) => string` - for two reasons: a
+ * typo'd key still fails the build here, and next-intl's translator (whose
+ * `key` parameter is the namespace's real key union, a SUPERSET of these)
+ * remains assignable by parameter contravariance. Kernel-owned: this module
+ * must not import next-intl's types.
+ */
+type Translate = (key: ValidationMessageKey, values?: Record<string, string>) => string;
+/**
+ * The value the validator actually rejected, read back out of the submitted data.
+ *
+ * RJSF builds `property` from ajv's `instancePath` by swapping `/` for `.`
+ * (`.quote_date.date`), so the segments index straight into the form data.
+ * Array indices arrive as digit strings and index arrays natively.
+ */
+declare function valueAtProperty(data: unknown, property: string | undefined): unknown;
+/**
+ * The rejected value rendered for a toast, or `null` when there is nothing
+ * worth showing (an absent or blank value - "you left it empty" is what the
+ * message says on its own, and `“”` adds noise).
+ */
+declare function displayValue(value: unknown): string | null;
+/**
+ * One validation error as a human line naming the offending value.
+ *
+ * The date branch is special-cased because ajv's own complaint (`'Date' must
+ * match format "date-time"`) is opaque, and because the carries-a-time case has
+ * a specific fix the user cannot guess: move the time into the sibling `time`
+ * field, which is exactly what the runtime's own error says.
+ */
+declare function describeValidationError(error: RunInputError, t: Translate, formData: unknown): string;
+
+/**
+ * The ONE place JSON-Schema plumbing lives for the run form kernel: nullable
+ * `anyOf` collapsing, `$defs` collection/hoisting, `$ref` resolution, and type
+ * extraction. Consolidated from three drifted private copies (`field-model.ts`,
+ * `normalize-schema.ts`, `input-format.ts`) during the form-kernel extraction.
+ *
+ * Two collapse engines are exported ON PURPOSE - their semantics genuinely
+ * differ, and each caller's observable behavior is characterized and preserved
+ * (see `schema-utils-characterization.test.ts`):
+ *
+ * - `collapseNullable` (the field mapper's rule): collapse ONLY when exactly one
+ *   non-null branch remains, dropping the null. A multi-branch union stays an
+ *   `anyOf` and maps to the raw-JSON escape hatch.
+ * - `flattenAnyOf` (the RJSF/ajv rule): a union of simple primitives becomes a
+ *   `type` ARRAY (null preserved as a type entry - ajv validates `type:
+ *   ["number","null"]` natively); a 2-branch nullable non-primitive drops the
+ *   null branch.
+ *
+ * Whether these converge (and which semantics win) is an M1 question, decided
+ * when the descriptor derivation moves server-side - not silently here.
+ */
+type JsonSchema = Record<string, unknown>;
+/** Pydantic emits `anyOf: [T, {type:'null'}]` for Optional[T]; collapse to T.
+ *  Collapses ONLY when exactly one non-null branch remains; the branch merges
+ *  OVER the outer schema (its constraints win). */
+declare function collapseNullable(schema: JsonSchema): JsonSchema;
+/**
+ * The RJSF/ajv collapse: a union of simple primitives flattens to a `type`
+ * array (`anyOf: [{string},{null}]` → `type: ["string","null"]`, which RJSF
+ * renders as a plain input instead of a sub-schema picker); an exactly-two
+ * `[T, {null}]` union of anything else drops the null branch and merges T over
+ * the outer schema. Anything else passes through unchanged.
+ */
+declare function flattenAnyOf(schema: JsonSchema): JsonSchema;
+/** The schema's non-null type: a bare `type` string, or the first non-null
+ *  entry of a `type` array (`["number","null"]` → `"number"`). */
+declare function schemaTypeOf(schema: JsonSchema): string | undefined;
+/** Resolve `{ $ref: "#/$defs/Foo" }` against a collected `$defs` map. Sibling
+ *  keys on the referencing schema override the definition's. */
+declare function derefSchema(schema: JsonSchema, defs: Record<string, JsonSchema>): JsonSchema;
+/**
+ * Resolve the indirection layers pydantic puts in front of a value schema - a
+ * `#/$defs/...` ref, a nullable `anyOf: [T, {null}]` wrapper, or a stack of
+ * both - until a plain schema remains. This is the resolver `healStringWrappers`
+ * and `pruneEmptyOptionals` apply before reading `type`. Unlike `derefSchema`
+ * it REPLACES the schema with the definition (no sibling merge) - exactly what
+ * the callers did inline.
+ */
+declare function resolveSchemaIndirection(schema: JsonSchema, defs: Record<string, JsonSchema>): JsonSchema;
+interface CollectDefsOptions {
+    /**
+     * Whether the walk descends into JSON arrays (`anyOf`/`allOf` branches,
+     * tuple `items`). The field mapper always has (so a def declared inside an
+     * `anyOf` branch resolves); the wire-format heal path historically has NOT -
+     * both behaviors are characterized, and each caller states its mode
+     * explicitly until M1 retires the difference.
+     */
+    traverseArrays: boolean;
+}
+/**
+ * Collect every nested `$defs` entry into one flat map so `#/$defs/...` refs
+ * resolve from anywhere. First definition of a name wins. The input schema is
+ * NOT modified (see `hoistDefsToRoot` for the stripping variant).
+ */
+declare function collectSchemaDefs(schema: JsonSchema, into: Record<string, JsonSchema>, options: CollectDefsOptions): Record<string, JsonSchema>;
+/**
+ * Hoist every nested `$defs` to the schema root, so a wrapper schema composed
+ * from several pydantic sub-schemas keeps its `#/$defs/...` refs resolvable.
+ * (Pydantic emits one `$defs` per model; composing models as properties of a
+ * wrapper object leaves those maps below the root the refs point to.)
+ */
+declare function hoistDefsToRoot(schema: JsonSchema): JsonSchema;
+
+/**
+ * Normalizes a JSON Schema for RJSF compatibility.
+ *
+ * Pydantic v2 generates `anyOf: [{type: "string"}, {type: "null"}]` for optional
+ * fields (`str | None`). RJSF renders this as a dropdown selector asking the user
+ * to pick a sub-schema, which is terrible UX. The normalizer flattens those
+ * patterns on every node (see `flattenAnyOf` in `schema-utils.ts` for the exact
+ * rules) and hoists nested `$defs` to the root so composed sub-schemas keep
+ * their refs resolvable.
+ *
+ * The collapse and hoist engines live in `schema-utils.ts` - the
+ * consolidated home for the kernel's JSON-Schema plumbing; this module owns the
+ * recursive application over a whole schema tree.
+ */
+
+/**
+ * Recursively normalize a JSON Schema for RJSF.
+ * Walks the entire schema tree and flattens anyOf patterns on every node.
+ */
+declare function normalizeSchemaForRjsf(schema: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Prepare a schema for RJSF: hoist all nested `$defs` to the root, then normalize
+ * anyOf patterns. Call this on any schema that composes multiple sub-schemas
+ * (each of which may ship its own `$defs`).
+ */
+declare function prepareSchemaForRjsf(schema: Record<string, unknown>): Record<string, unknown>;
+
+export { type CollectDefsOptions, type JsonSchema, type OutputEntry, type PipeIOContract, type PipeIOContracts, type PipeInputContract, type PipeOutputContract, type Readiness, RunField, type RunInputError, type RunInputsVerdict, type Translate, type ValidationMessageKey, apiInputsFromRunValues, apiInputsFromSchemaData, asCalendarDate, buildPipeRef, buildRunFields, buildRunInputsSchema, collapseNullable, collectSchemaDefs, computeReadiness, dayWithinDateTime, deflateAllInputs, deflateInput, derefSchema, describeValidationError, displayValue, fieldFilled, fieldsForContract, flattenAnyOf, getPipeIOContract, healStringWrappers, hoistDefsToRoot, inflateAllInputs, inflateInput, inputDataFromWorkingMemory, inputMustBeFilled, isAcceptableDate, isAcceptableDateTime, isFilled, isPluralInput, mustBeFilled, normalizeSchemaForRjsf, outputsFromPipeOutput, prepareRunInputs, prepareSchemaForRjsf, pruneEmptyOptionals, resolveConceptCode, resolveSchemaIndirection, rjsfDataFromRunValues, runValuesFromStore, schemaTypeOf, setValueAtPath, storeInputDataFromRunValues, toDateInputValue, toStoredDateValue, validateRunInputs, validateRunInputsSchema, valueAtProperty };

package/dist/core/index.js

@@ -0,0 +1,3 @@
+export { apiInputsFromRunValues, apiInputsFromSchemaData, asCalendarDate, buildPipeRef, buildRunFields, buildRunInputsSchema, collapseNullable, collectSchemaDefs, computeReadiness, conceptCategory, dayWithinDateTime, deflateAllInputs, deflateInput, derefSchema, describeValidationError, displayValue, fieldFilled, fieldsForContract, flattenAnyOf, getPipeIOContract, healStringWrappers, hoistDefsToRoot, inflateAllInputs, inflateInput, inputDataFromWorkingMemory, inputMustBeFilled, isAcceptableDate, isAcceptableDateTime, isFilled, isPluralInput, mustBeFilled, normalizeSchemaForRjsf, outputsFromPipeOutput, prepareRunInputs, prepareSchemaForRjsf, pruneEmptyOptionals, resolveConceptCode, resolveSchemaIndirection, rjsfDataFromRunValues, runValuesFromStore, schemaTypeOf, setValueAtPath, storeInputDataFromRunValues, toDateInputValue, toStoredDateValue, validateRunInputs, validateRunInputsSchema, valueAtProperty } from '../chunk-DAP47OGP.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}