@pipelex/mthds-form 0.4.0 → 0.6.0

package/dist/core/contracts.d.ts

@@ -1,16 +1,30 @@
+import { PresenceMarker, PipeIOContracts, PipeIOContract, PipeInputContract } from 'mthds/protocol';
+export { IOMultiplicity, PipeIOContract, PipeIOContracts, PipeInputContract, PipeOutputContract } from 'mthds/protocol';
+
 /**
- * The typed `pipe_io_contracts` mirror and its gating predicates.
+ * The `pipe_io_contracts` types and the kernel's gating predicates over them.
+ *
+ * The types are the STANDARD'S, imported from `mthds/protocol` and re-exported
+ * under the names this package has always exported. `pipe_io_contracts` is an
+ * MTHDS artifact - the standard specifies it (the "Pipe I/O Contracts" page)
+ * and its TypeScript client declares it - so this module states no shape of its
+ * own any more. What it keeps is the half that is genuinely the kernel's: the
+ * predicates that turn a declared slot into a gating answer, and the lookup
+ * that tolerates both key conventions a real payload arrives with.
  *
- * 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.
+ * `mthds` is a TYPES-ONLY peer dependency: every import here is `import type`,
+ * so nothing survives into `dist/` and no consumer ships the standard's CLI.
+ * `scripts/assert-bundle.mjs` holds that on the built graph and lint holds it
+ * on the source. See docs/dependency-budget.md.
  *
  * 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.
  */
+
 /**
- * The authored presence marker on an input slot, verbatim.
+ * The authored presence marker on an input slot, verbatim - the standard's
+ * `PresenceMarker` under the name this package exports.
  *
  * - `plain` - no marker: the caller must supply the input.
  * - `optional` (`?`) - the caller may omit it and the pipe handles the absence
@@ -18,56 +32,13 @@
  * - `force` (`!`) - a use-site assertion that the value IS present. It must be
  *   supplied, exactly like `plain`; the distinction is the authored assertion,
  *   which lint and graph surfaces read and a form does not.
- */
-type InputPresence = 'plain' | 'optional' | 'force';
-/**
- * How many items a slot carries.
  *
- * - `single` - one item. `Concept[1]` is single too: no list framing.
- * - `variable` (`Concept[]`) - a list of any length, the empty list included.
- * - `fixed` (`Concept[N]`, N > 1) - a list of exactly `item_count` items.
+ * Kept as an alias rather than renamed because a consumer imports it by this
+ * name; a host that would rather read the standard's spelling has `mthds`
+ * installed through this package's peer and can import `PresenceMarker`
+ * straight from `mthds/protocol`.
  */
-type IOMultiplicity = 'single' | 'variable' | 'fixed';
-interface PipeInputContract {
-    concept_ref: string;
-    /** The declared presence marker - see `InputPresence`. */
-    presence: InputPresence;
-    /** The declared multiplicity - see `IOMultiplicity`. */
-    multiplicity: IOMultiplicity;
-    /**
-     * The exact item count, non-null exactly when `multiplicity` is `fixed`. The
-     * slot is always on the wire, `null` off the fixed arm.
-     */
-    item_count: number | null;
-    /**
-     * The input's JSON Schema. A plural slot (`variable` or `fixed`) is an array
-     * wrapper around the item schema, and a `fixed` one additionally carries
-     * `minItems` / `maxItems` set to `item_count` - which is what makes the gate's
-     * ajv pass enforce the declared count without the kernel restating it.
-     */
-    json_schema: Record<string, unknown>;
-}
-interface PipeOutputContract {
-    concept_ref: string;
-    multiplicity: IOMultiplicity;
-    /** As on the input: non-null exactly on the `fixed` arm, always on the wire. */
-    item_count: number | null;
-    /**
-     * `true` when the output is declared optional (`?`) - the pipe may resolve it
-     * as a recorded absence instead of a value.
-     *
-     * Deliberately still a boolean while the INPUT side carries three-valued
-     * `presence`: output presence is genuinely two-valued, because `!` is
-     * rejected on an output. The asymmetry is the wire's, not ours.
-     */
-    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>;
+type InputPresence = PresenceMarker;
 /** Namespaced pipe ref (`<domain>.<pipe_code>`) - the identity convention the
  *  validate artifacts key on. */
 declare function buildPipeRef(domain: string, pipeCode: string): string;
@@ -107,8 +78,8 @@ declare function isOptionalInput(input: PipeInputContract): boolean;
  * maps and therefore what the user is shown; a predicate reading the other
  * field could disagree with the rendered control, which is the exact failure
  * mode `mustBeFilled` (readiness.ts) exists to prevent. The two agree by
- * construction upstream - pipelex wraps the schema in an array exactly when it
- * reports `variable` or `fixed`.
+ * construction upstream - the engine wraps the schema in an array exactly when
+ * it reports `variable` or `fixed`.
  */
 declare function isPluralInput(input: PipeInputContract): boolean;
 /**
@@ -140,4 +111,4 @@ declare function isFixedCountInput(input: PipeInputContract): boolean;
  */
 declare function inputMustBeFilled(input: PipeInputContract): boolean;
 
-export { type IOMultiplicity, type InputPresence, type PipeIOContract, type PipeIOContracts, type PipeInputContract, type PipeOutputContract, buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput };
+export { type InputPresence, buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput };

package/dist/core/contracts.js

@@ -1,4 +1,4 @@
-export { buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from '../chunk-HARYEWNG.js';
+export { buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from '../chunk-XYQ7NXQZ.js';
 import '../chunk-V3OV2XQT.js';
 //# sourceMappingURL=contracts.js.map
 //# sourceMappingURL=contracts.js.map

package/dist/core/derive.d.ts

@@ -1,20 +1,88 @@
-import { PipeInputContract } from './contracts.js';
+import { InputFormField, PipeInputFormDescriptor, PipeInputContract, InputForm } from 'mthds/protocol';
 import { RunField } from './descriptor.js';
+import './contracts.js';
 
 /**
- * The ONE derivation function: `PipeInputContract` map → `RunField[]`.
+ * The ONE derivation function: wire input-form descriptor → `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.
+ * `buildRunFields` maps the standard's per-pipe descriptor STRUCTURALLY onto
+ * the kernel's `RunField` shape. It decides nothing: what a field IS - its
+ * kind, its constraints, its refinement chain, whether Run gates on it - is
+ * stated by the wire, derived by the engine from the resolved library. The
+ * heuristics that used to live here (native-concept sets, the url-bearing
+ * object test, the depth-based prose/label rule) are deleted, not bypassed;
+ * docs/derivation-swap.md is the record of that swap and of every behaviour
+ * that moved with it.
+ *
+ * The contract is still consulted, for exactly two facts the wire deliberately
+ * does not carry:
+ *
+ * - **`contentKey`** - the single property a native scalar's value sits inside
+ *   on the wire (`TextContent {text}`, `NumberContent {number}`). A renderer
+ *   holds the bare scalar; the value bridge wraps by this name. It is read off
+ *   the contract's `json_schema` because it is a fact about the PAYLOAD shape,
+ *   which is the schema's job - the descriptor describes the form, never the
+ *   payload.
+ * - **Nested list bounds** - the wire puts `item_count` only on a top-level
+ *   fixed `[N]` slot, but the model behind a structured concept may state
+ *   `minItems`/`maxItems` on an array property of its own, and ajv enforces
+ *   them. Reading them off the schema is what keeps readiness from being more
+ *   permissive than the gate.
+ *
+ * Both are structural reads (a property count, two keywords ajv itself
+ * enforces), not judgements - the mapper stays honest about owning no taxonomy.
  */
 
 /**
- * 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).
+ * Look up a pipe's input-form descriptor by pipe code, tolerant of both key
+ * conventions - the exact mirror of `getPipeIOContract`, because the standard
+ * keys `input_form` by the same `pipe_ref` set as `pipe_io_contracts` and a
+ * host tracks the same bare codes either way.
+ */
+declare function getPipeInputForm(inputForm: InputForm | null | undefined, domain: string | null | undefined, pipeCode: string | null | undefined): PipeInputFormDescriptor | undefined;
+/**
+ * Map a pipe's wire input-form descriptor onto the kernel's field descriptors,
+ * with the pipe's input contracts beside it for the two schema-derived facts.
+ *
+ * The order is the DESCRIPTOR's - authored input order, the fact the contract's
+ * `inputs` map deliberately does not carry. `required`, `presence` and `gating`
+ * are taken from the wire verbatim: the standard's top-level type ties
+ * `required` to the presence marker, and `gating` is the producer-derived
+ * answer `mustBeFilled` reads - the kernel re-derives none of them.
+ */
+/**
+ * The same mapping, for a single node that belongs to no slot — a pipe's OUTPUT.
+ *
+ * `buildRunFields` maps a descriptor's fields and then stamps each with the slot
+ * facts (`presence`, `gating`) the wire states per input. An output has no slot,
+ * so this stamps nothing: the node arrives without them and leaves without them,
+ * which is exactly what the standard's optional members are for.
+ *
+ * Everything else is shared, deliberately. An output is a concept ref like an
+ * input is, so its kinds, its nesting, its list bounds and its `contentKey` are
+ * the same questions with the same answers — and a second mapper would be a
+ * second place for them to drift.
+ *
+ * ## `schema` is REQUIRED, and that is the whole point
+ *
+ * It was optional once, and the renderer paid for it: with no schema it could
+ * not know that `native.Text`'s payload sits under `text`, so it worked the
+ * unwrapping out by COUNTING the value's properties, and worked a plural payload
+ * out by looking for an `items` key. Both are shape sniffing — the exact pattern
+ * [../../docs/derivation-swap.md] records deleting from the input side, where
+ * `contentKey` is read off a schema and handed to a control as a property NAME.
+ *
+ * So the parameter is required, the two heuristics are gone, and what the
+ * argument must be is stated precisely: **the schema of the PAYLOAD**, which for
+ * every kind but `object` is the content model that wraps it —
+ * `TextContent {text}` for a `native.Text` output, `ListContent {items}` for a
+ * plural one. That is a change the standard has to make on the output contract
+ * (see `./output-form`); until it does, a producer supplies it beside the
+ * descriptor.
  */
-declare function buildRunFields(inputs: Record<string, PipeInputContract>): RunField[];
+declare function buildResultField(descriptor: {
+    field: InputFormField;
+}, schema: Record<string, unknown>): RunField;
+declare function buildRunFields(descriptor: PipeInputFormDescriptor, inputs: Record<string, PipeInputContract>): RunField[];
 
-export { buildRunFields };
+export { buildResultField, buildRunFields, getPipeInputForm };

package/dist/core/derive.js

@@ -1,7 +1,7 @@
-export { buildRunFields } from '../chunk-VMLXO5JS.js';
-import '../chunk-O4O3QNVC.js';
-import '../chunk-HARYEWNG.js';
+export { buildResultField, buildRunFields, getPipeInputForm } from '../chunk-J4L32LD6.js';
+import '../chunk-2JWRG53S.js';
+import '../chunk-OD3VYXUY.js';
+import '../chunk-XYQ7NXQZ.js';
 import '../chunk-V3OV2XQT.js';
-import '../chunk-NMT7BRLO.js';
 //# sourceMappingURL=derive.js.map
 //# sourceMappingURL=derive.js.map

package/dist/core/descriptor.d.ts

@@ -1,16 +1,20 @@
+import { InputPresence } from './contracts.js';
+import 'mthds/protocol';
+
 /**
  * The `RunField` descriptor - the consumer-facing currency of the form kernel.
  *
- * A method's inputs arrive from the API as a map of variable name →
- * `PipeInputContract` ({ concept_ref, json_schema }). That JSON Schema is rich
- * (Pydantic-generated) and not pleasant to render directly. `buildRunFields`
- * (in `derive.ts`) normalizes it once into a flat, recursive `RunField[]`
- * descriptor that the presentational field components consume - so the
- * components never touch raw JSON Schema, and stories can describe any input
- * shape declaratively.
+ * A method's inputs arrive from the API as two sibling artifacts: the wire
+ * input-form descriptor (`input_form`, the ordered presentation view the MTHDS
+ * standard specifies) and the `pipe_io_contracts` entry whose `json_schema`
+ * stays the validation contract. `buildRunFields` (in `derive.ts`) maps the
+ * wire descriptor structurally onto this `RunField[]` shape - so the
+ * presentational field components never touch either wire artifact directly,
+ * and stories can describe any input shape declaratively.
  *
  * Pure module: no React, no API calls. Trivially unit-testable.
  */
+
 type RunFieldKind = 'text' | 'prose' | 'date' | 'number' | 'boolean' | 'enum' | 'document' | 'image' | 'object' | 'list' | 'unknown';
 interface RunFieldCommon {
     /** The variable identifier as written in the method (rendered in mono). */
@@ -19,10 +23,38 @@ interface RunFieldCommon {
     title?: string;
     /** The concept this input carries, e.g. `native.Document`, `demo.Invoice`. */
     conceptRef?: string;
+    /**
+     * The concept's refinement chain, immediate parent first, walked to its end
+     * (`['legal.BaseClause', 'native.Text']`). Straight off the wire descriptor;
+     * absent when the concept refines nothing. "Does this refine `native.X`?" is
+     * a membership test on this list, never shape sniffing.
+     */
+    refines?: string[];
     /** One-line helper text shown under the label. */
     description?: string;
     /** Required inputs always show; optional ones can collapse. */
     required: boolean;
+    /**
+     * The authored presence marker of the pipe's input slot, verbatim - set on
+     * TOP-LEVEL fields only, like `gating`. `required` is its two-valued
+     * projection (`presence !== 'optional'`); the marker itself is carried so a
+     * renderer can distinguish the authored `!` assertion from a plain slot.
+     */
+    presence?: InputPresence;
+    /**
+     * The value applied when the caller omits the field - present only when a
+     * default was AUTHORED, never the `null` a schema projection attaches to an
+     * optional field. A defaulted field always arrives `required: false`.
+     */
+    defaultValue?: unknown;
+    /** Example values for the field, when the wire carries any. */
+    examples?: unknown[];
+    /**
+     * The node's effective intent hints - the flat `string → string` merge the
+     * language defines, carried verbatim. Non-normative: a renderer that ignores
+     * them stays correct, and nothing in the kernel's gating reads them.
+     */
+    hints?: Record<string, string>;
     /**
      * Whether Run waits for this input - set on TOP-LEVEL fields only, straight
      * from `inputMustBeFilled` (see `mustBeFilled` in `readiness.ts` for why this
@@ -45,21 +77,34 @@ interface RunFieldCommon {
      */
     contentKey?: string;
 }
-interface TextRunField extends RunFieldCommon {
+/**
+ * The constraint slots the two text kinds share, mapped from the wire's
+ * `min_length` / `max_length` / `pattern` / `format`. `format` is the open
+ * string set carrying schema formats the `date` kind does not absorb
+ * (`'time'`, `'uri'`, …); a renderer may hint on it and ignore it safely.
+ */
+interface TextConstraints {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+}
+interface TextRunField extends RunFieldCommon, TextConstraints {
     kind: 'text';
     placeholder?: string;
 }
-interface ProseRunField extends RunFieldCommon {
+interface ProseRunField extends RunFieldCommon, TextConstraints {
     kind: 'prose';
     placeholder?: string;
 }
 interface DateRunField extends RunFieldCommon {
     kind: 'date';
     /**
-     * True when the backing schema is `format: date-time`: the stored value is a
-     * full RFC 3339 timestamp (`2026-07-06T00:00:00Z`) so it passes the API's
+     * The wire's `datetime` flag - true when the value carries a time of day
+     * (the backing schema is `format: date-time`): the stored value is a full
+     * RFC 3339 timestamp (`2026-07-06T00:00:00Z`) so it passes the API's
      * `date-time` validation, even though the control only asks for a day. False
-     * for a bare `format: date`, where the value stays `YYYY-MM-DD`.
+     * for a bare calendar date, where the value stays `YYYY-MM-DD`.
      */
     datetime: boolean;
 }
@@ -90,24 +135,23 @@ interface ListRunField extends RunFieldCommon {
     /** The element descriptor (its `name` is unused; the index labels items). */
     item: RunField;
     /**
-     * The FEWEST items the slot accepts, when the schema states a lower bound.
-     * Absent for a variable `Concept[]` list, which demands none.
+     * The FEWEST items the slot accepts. Absent for a variable `Concept[]` list,
+     * which demands none.
      *
-     * Read off the array schema's `minItems` rather than off the contract's
-     * `item_count`, which states the same number: this exists so `fieldFilled` can
-     * answer the question **ajv** answers, and `minItems` is the keyword ajv
-     * reads. pipelex emits `minItems`/`maxItems` = N for a `[N]` slot and neither
-     * for `[]`, so on a top-level slot the two sources agree by construction.
+     * On a top-level slot this is the wire descriptor's `item_count` (present
+     * exactly on a fixed `[N]` slot); an engine emits `minItems`/`maxItems` = N
+     * on the same slot's schema, so the number `fieldFilled` gates on and the
+     * keyword ajv reads agree by construction.
      *
-     * A schema may still state a lower bound alone - `mapSchema` recurses, so a
-     * nested array inside a structured concept reaches here with whatever its
-     * model declared and no MTHDS multiplicity behind it. Gating on that bound is
-     * the same rule, and it is the direction that cannot leave readiness more
-     * permissive than the gate.
+     * The wire never puts `item_count` on a NESTED list, but the model behind a
+     * structured concept may state `minItems` on an array property of its own -
+     * so on nested nodes this is read off the schema, which is the direction
+     * that cannot leave readiness more permissive than the gate.
      */
     itemCount?: number;
     /**
-     * The MOST items the slot accepts, off the schema's `maxItems`.
+     * The MOST items the slot accepts, off the schema's `maxItems` (which a
+     * fixed `[N]` slot also states as N).
      *
      * A separate field because it is a separate fact, and conflating them is a
      * bug that hides: `itemCount` was read as a minimum by readiness and as a
@@ -125,4 +169,4 @@ type RunField = TextRunField | ProseRunField | DateRunField | NumberRunField | B
 type ConceptCategory = 'text' | 'date' | 'document' | 'image' | 'number' | 'boolean' | 'choice' | 'structured' | 'list';
 declare function conceptCategory(field: RunField): ConceptCategory;
 
-export { type BooleanRunField, type ConceptCategory, type DateRunField, type EnumRunField, type FileRunField, type ListRunField, type NumberRunField, type ObjectRunField, type ProseRunField, type RunField, type RunFieldCommon, type RunFieldKind, type TextRunField, type UnknownRunField, conceptCategory };
+export { type BooleanRunField, type ConceptCategory, type DateRunField, type EnumRunField, type FileRunField, type ListRunField, type NumberRunField, type ObjectRunField, type ProseRunField, type RunField, type RunFieldCommon, type RunFieldKind, type TextConstraints, type TextRunField, type UnknownRunField, conceptCategory };

package/dist/core/descriptor.js

@@ -1,3 +1,3 @@
-export { conceptCategory } from '../chunk-6XD6UZSU.js';
+export { conceptCategory } from '../chunk-25I6JDIK.js';
 //# sourceMappingURL=descriptor.js.map
 //# sourceMappingURL=descriptor.js.map

package/dist/core/file-formats.d.ts

@@ -0,0 +1,102 @@
+/**
+ * What a `document` or an `image` slot actually accepts.
+ *
+ * **This is a client-side mirror of a runtime fact, and the fact was measured
+ * rather than read off a list.** The wire says a slot's kind is `document` or
+ * `image` and stops there — which bytes a runtime can decode is a property of
+ * that runtime, not of the method — so the list has to live on this side, and
+ * the only honest place is one module that says where it came from.
+ *
+ * There is no single enum to copy. In `pipelex`, what a slot accepts is derived
+ * per model:
+ *
+ *   ModelSpec.supported_document_types = {"pdf","docx","pptx"} & set(inputs)
+ *   ModelSpec.is_vision_supported      = "images" in inputs
+ *
+ * so the effective set is that vocabulary intersected with the **model deck's**
+ * declared `inputs`. No model in the shipped deck declares `docx` or `pptx`;
+ * every LLM entry is `["text", "images", "pdf"]`, and the default extract model
+ * (`azure-document-intelligence`) is `["image", "pdf"]`.
+ *
+ * Confirmed by running each format end to end:
+ *
+ * | Format | PipeExtract | PipeLLM |
+ * | --- | --- | --- |
+ * | PDF  | yes | yes |
+ * | PNG  | yes | n/a |
+ * | JPEG | yes | n/a |
+ * | WEBP | no  | no  |
+ * | DOCX | no  | no — `does not support docx documents` |
+ * | PPTX | no  | no — detected as `zip`, so it never even reaches the check |
+ *
+ * The gateway states its own list in the failure: *"Supported formats:
+ * application/pdf, image/jpeg, image/png as base64 data URLs."*
+ *
+ * Images were measured the same way: PNG, JPEG and WEBP pass; BMP and TIFF fail
+ * on the provider's image enum; GIF fails too, though it is *in* that enum — it
+ * arrives at the provider as a document block rather than an image one, which
+ * looks like a routing bug upstream rather than an unsupported format.
+ *
+ * **A document slot's PNG and JPEG only work in an extract pipe.** The
+ * descriptor never says which operator consumes the slot, so this table cannot
+ * distinguish them; it matches the extract model's declared inputs, because
+ * extraction is the operator that actually reads a document's bytes.
+ *
+ * What was here before was built on `DocumentFormat` (PDF/DOCX/PPTX), an enum
+ * that is referenced nowhere in the runtime outside commented-out code and is
+ * being deleted. A dead enum is the worst kind of source: it reads exactly like
+ * a live one.
+ *
+ * A stale entry here is worse than no list at all, because it refuses a file the
+ * runtime would have taken. If the deck grows a format, this table moves with it.
+ *
+ * Pure data. No React, no ajv, nothing imported.
+ */
+/** One accepted format: its MIME type and the extensions that carry it. */
+interface FileFormat {
+    mimeType: string;
+    /** Leading dot, lowercase — the shape a file input's `accept` wants. */
+    extensions: string[];
+    /** How the format is named to a user, uppercase. */
+    label: string;
+}
+/**
+ * What a `document` slot takes: PDF, plus the two image formats the extract
+ * model reads as a single-page document.
+ */
+declare const DOCUMENT_FORMATS: readonly FileFormat[];
+/**
+ * What an `image` slot takes: PNG, JPEG, WEBP — all three measured through the
+ * vision path.
+ *
+ * `.jpg` and `.jpeg` both ride `image/jpeg`. `JPG` is the label because that is
+ * the spelling the runtime uses, but a file named `.jpeg` is the same bytes and
+ * must not be refused over its spelling.
+ */
+declare const IMAGE_FORMATS: readonly FileFormat[];
+declare function formatsForKind(kind: 'document' | 'image'): readonly FileFormat[];
+/** `"PDF, DOCX, PPTX"` — the hint shown under a dropzone. */
+declare function acceptLabelForKind(kind: 'document' | 'image'): string;
+/**
+ * Whether a picked file is one this kind accepts.
+ *
+ * Checks the MIME type first and falls back to the extension, because a
+ * browser's `File.type` is empty often enough to matter: an OS with no handler
+ * registered for `.docx` reports `''`, and refusing that file would be refusing
+ * a valid one over a fact about the user's machine. A wrong-but-present MIME
+ * type is still a rejection — that is the case this exists for.
+ */
+declare function isAcceptedFile(kind: 'document' | 'image', file: {
+    name: string;
+    type: string;
+}): boolean;
+/**
+ * The accept map a file input wants: MIME type to extensions.
+ *
+ * Shaped for `react-dropzone`'s `accept`, which is the same shape the DOM's
+ * `accept` attribute is built from. Listing extensions BESIDE the MIME type is
+ * what makes the empty-`File.type` case above work in the OS picker too.
+ */
+declare function acceptMapForKind(kind: 'document' | 'image'): Record<string, string[]>;
+
+export { DOCUMENT_FORMATS, type FileFormat, IMAGE_FORMATS, acceptLabelForKind, acceptMapForKind, formatsForKind, isAcceptedFile };

package/dist/core/file-formats.js

@@ -0,0 +1,3 @@
+export { DOCUMENT_FORMATS, IMAGE_FORMATS, acceptLabelForKind, acceptMapForKind, formatsForKind, isAcceptedFile } from '../chunk-2JWRG53S.js';
+//# sourceMappingURL=file-formats.js.map
+//# sourceMappingURL=file-formats.js.map

package/dist/core/file-formats.js.map

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

package/dist/core/gate.d.ts

@@ -1,5 +1,5 @@
 import { RunInputError } from './gate-validator.js';
-import { PipeInputContract, PipeIOContract } from './contracts.js';
+import { PipeInputContract, PipeIOContract } from 'mthds/protocol';
 
 type Dict = Record<string, unknown>;
 /**

package/dist/core/gate.js

@@ -1,13 +1,12 @@
-export { apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs } from '../chunk-XEPD5VJQ.js';
-import '../chunk-KFZ5MZOM.js';
-import '../chunk-7BMOPXDY.js';
+export { apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs } from '../chunk-R7B7ID25.js';
+import '../chunk-GCXV76WU.js';
+import '../chunk-LBFZXYCY.js';
 import '../chunk-PM55AHRO.js';
-import '../chunk-VMLXO5JS.js';
-import '../chunk-O4O3QNVC.js';
-import '../chunk-HARYEWNG.js';
-import '../chunk-V3OV2XQT.js';
 import '../chunk-VTPUDBSJ.js';
 import '../chunk-GKV77RAS.js';
-import '../chunk-NMT7BRLO.js';
+import '../chunk-YEVVR6FE.js';
+import '../chunk-OD3VYXUY.js';
+import '../chunk-XYQ7NXQZ.js';
+import '../chunk-V3OV2XQT.js';
 //# sourceMappingURL=gate.js.map
 //# sourceMappingURL=gate.js.map

package/dist/core/gating-fields.d.ts

@@ -0,0 +1,38 @@
+import { PipeInputContract } from 'mthds/protocol';
+import { RunField } from './descriptor.js';
+import './contracts.js';
+
+/**
+ * The gate's own field tree - structural, schema-derived, and private.
+ *
+ * `gateRunInputs` re-applies the Run button's emptiness rule with
+ * `mustBeFilled`/`fieldFilled`, which read a `RunField` tree. The RENDER tree
+ * is built from the wire input-form descriptor - but the gate must not require
+ * that artifact: the descriptor is a presentation view, and the workspace
+ * doctrine is that a machine consumer never needs it to validate a payload -
+ * `json_schema` keeps that job. A server holds contracts; it may never have
+ * asked for the view.
+ *
+ * So the gate walks the contract's `json_schema` into the MINIMAL tree the
+ * emptiness predicates read: `object` nodes with their required children,
+ * `list` nodes with their declared bounds, and opaque leaves. This is not a
+ * revival of the deleted heuristics - it reads exactly the keywords ajv itself
+ * enforces (`type`, `properties`, `required`, `items`, `minItems`, `maxItems`)
+ * and decides nothing about what a field IS. No kind here ever reaches a
+ * renderer: the tree exists for one call inside `gateRunInputs` and is not
+ * exported from the package.
+ *
+ * Agreement with the browser's readiness (which runs over the render tree) is
+ * held by construction - both trees take required children and list bounds
+ * from the same model the engine derived both artifacts from - and asserted in
+ * `gate-agreement.test.ts`, which runs both sides over one table.
+ */
+
+/**
+ * The tree `gateRunInputs`' emptiness re-check runs over, one node per input,
+ * with `gating` stamped from the contract - the same `inputMustBeFilled` the
+ * Run button's `required` list is built from.
+ */
+declare function gatingFieldsFromInputs(inputs: Record<string, PipeInputContract>): RunField[];
+
+export { gatingFieldsFromInputs };

package/dist/core/gating-fields.js

@@ -0,0 +1,6 @@
+export { gatingFieldsFromInputs } from '../chunk-YEVVR6FE.js';
+import '../chunk-OD3VYXUY.js';
+import '../chunk-XYQ7NXQZ.js';
+import '../chunk-V3OV2XQT.js';
+//# sourceMappingURL=gating-fields.js.map
+//# sourceMappingURL=gating-fields.js.map

package/dist/core/gating-fields.js.map

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

package/dist/core/index.d.ts

@@ -1,7 +1,12 @@
-export { BooleanRunField, ConceptCategory, DateRunField, EnumRunField, FileRunField, ListRunField, NumberRunField, ObjectRunField, ProseRunField, RunField, RunFieldCommon, RunFieldKind, TextRunField, UnknownRunField, conceptCategory } from './descriptor.js';
-export { buildRunFields } from './derive.js';
+export { BooleanRunField, ConceptCategory, DateRunField, EnumRunField, FileRunField, ListRunField, NumberRunField, ObjectRunField, ProseRunField, RunField, RunFieldCommon, RunFieldKind, TextConstraints, TextRunField, UnknownRunField, conceptCategory } from './descriptor.js';
+export { IOMultiplicity, InputForm, InputFormTopLevelField, OutputForm, PipeIOContract, PipeIOContracts, PipeInputContract, PipeInputFormDescriptor, PipeOutputContract, PipeOutputFormDescriptor } from 'mthds/protocol';
+export { buildResultField, buildRunFields, getPipeInputForm } from './derive.js';
+export { getPipeOutputForm } from './output-form.js';
+export { StuffFile, collectStuffFiles } from './stuff-files.js';
+export { DOCUMENT_FORMATS, FileFormat, IMAGE_FORMATS, acceptLabelForKind, acceptMapForKind, formatsForKind, isAcceptedFile } from './file-formats.js';
+export { CompositeMember, DateContentView, DocumentContentView, HtmlContentView, ImageContentView, NATIVE_COMPOSITE_CONCEPT_REF, NATIVE_DATE_CONCEPT_REF, NATIVE_HTML_CONCEPT_REF, TYPED_SCALAR_MARKERS, formatDateContent, hasTypedScalarMarkers, isNativeCompositeNode, isNativeDateNode, isNativeHtmlNode, isViewableUrl, readCompositeContent, readDateContent, readDocumentContent, readHtmlContent, readImageContent } from './native-content.js';
 export { Readiness, computeReadiness, fieldFilled, isFilled, mustBeFilled } from './readiness.js';
-export { IOMultiplicity, InputPresence, PipeIOContract, PipeIOContracts, PipeInputContract, PipeOutputContract, buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from './contracts.js';
+export { InputPresence, buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from './contracts.js';
 export { RunInputsGateResult, RunInputsVerdict, apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs } from './gate.js';
 export { RunInputError, validateRunInputsSchema } from './gate-validator.js';
 export { OutputEntry, apiInputsFromRunValues, fieldsForContract, inputDataFromWorkingMemory, outputsFromPipeOutput, rjsfDataFromRunValues, runValuesFromStore, setValueAtPath, storeInputDataFromRunValues } from './values.js';