@pipelex/mthds-form 0.4.0 → 0.6.0

package/dist/core/index.js

@@ -1,16 +1,20 @@
 export { describeValidationError, displayValue, valueAtProperty } from '../chunk-RPA7DNSK.js';
-export { apiInputsFromRunValues, fieldsForContract, inputDataFromWorkingMemory, outputsFromPipeOutput, rjsfDataFromRunValues, runValuesFromStore, setValueAtPath, storeInputDataFromRunValues } from '../chunk-WXBSM2CE.js';
-export { conceptCategory } from '../chunk-6XD6UZSU.js';
-export { apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs } from '../chunk-XEPD5VJQ.js';
-export { normalizeSchemaForRjsf, prepareSchemaForRjsf } from '../chunk-KFZ5MZOM.js';
-export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode } from '../chunk-7BMOPXDY.js';
+export { apiInputsFromRunValues, fieldsForContract, inputDataFromWorkingMemory, outputsFromPipeOutput, rjsfDataFromRunValues, runValuesFromStore, setValueAtPath, storeInputDataFromRunValues } from '../chunk-T4NSAGOS.js';
+export { getPipeOutputForm } from '../chunk-IIU3YK4O.js';
+export { collectStuffFiles } from '../chunk-4BSBBG2T.js';
+export { 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 '../chunk-45C2MKK6.js';
+export { buildResultField, buildRunFields, getPipeInputForm } from '../chunk-J4L32LD6.js';
+export { conceptCategory } from '../chunk-25I6JDIK.js';
+export { DOCUMENT_FORMATS, IMAGE_FORMATS, acceptLabelForKind, acceptMapForKind, formatsForKind, isAcceptedFile } from '../chunk-2JWRG53S.js';
+export { apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs } from '../chunk-R7B7ID25.js';
+export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode } from '../chunk-GCXV76WU.js';
+export { normalizeSchemaForRjsf, prepareSchemaForRjsf } from '../chunk-LBFZXYCY.js';
 export { computeReadiness, fieldFilled, isFilled, mustBeFilled } from '../chunk-PM55AHRO.js';
-export { buildRunFields } from '../chunk-VMLXO5JS.js';
-export { collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, schemaTypeOf } from '../chunk-O4O3QNVC.js';
-export { buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from '../chunk-HARYEWNG.js';
-import '../chunk-V3OV2XQT.js';
 export { validateRunInputsSchema } from '../chunk-VTPUDBSJ.js';
 export { asCalendarDate, dayWithinDateTime, isAcceptableDate, isAcceptableDateTime, toDateInputValue, toStoredDateValue } from '../chunk-GKV77RAS.js';
-import '../chunk-NMT7BRLO.js';
+import '../chunk-YEVVR6FE.js';
+export { collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, schemaTypeOf } from '../chunk-OD3VYXUY.js';
+export { buildPipeRef, getPipeIOContract, inputMustBeFilled, isFixedCountInput, isOptionalInput, isPluralInput } from '../chunk-XYQ7NXQZ.js';
+import '../chunk-V3OV2XQT.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/core/native-content.d.ts

@@ -0,0 +1,219 @@
+/**
+ * How to READ the native content models — the result side's twin of
+ * `./file-formats`.
+ *
+ * A renderer handed a result knows the field's `kind` from the descriptor, and
+ * for the kinds whose value is a structured content model rather than a bare
+ * scalar (`document`, `image`, `date`) it must then read that model's members.
+ * **That is reading the standard, not sniffing at it.** The distinction is the
+ * whole reason this module exists as data rather than as heuristics inside a
+ * control: a reader keyed by a STATED kind consults a pinned definition, where
+ * a reader that works out *which* kind it is holding by counting properties is
+ * guessing — and guessing is exactly what [../../docs/derivation-swap.md]
+ * records removing from the input side.
+ *
+ * ## Where each shape comes from
+ *
+ * `native.Image` and `native.Document` are pinned by the standard, in
+ * `docs/spec/native-concepts.md` § "The Pinned Set (MTHDS 1.0.0)". Both carry a
+ * required `url` — a storage URI, an HTTP(S) URL, or a base64 data URL — and
+ * optional presentation members beside it. Nothing here adds a member the spec
+ * does not state.
+ *
+ * `native.Date` is pinned the same way (`{date, time}`), but a `date` FIELD
+ * inside a structured concept is not a `native.Date` value: it is a python
+ * `datetime.date`, and the serialization layer stamps it with its class. So a
+ * date arrives in one of three legal shapes, all three of which a run really
+ * produces:
+ *
+ *   "2026-03-14"                                             a plain ISO string
+ *   { date: "2026-03-14", __class__: "date", … }             a typed scalar
+ *   { date: "2026-03-14", time: "15:40:00" }                 native.Date
+ *
+ * The typed-scalar envelope is the one shape the standard does NOT pin — it is
+ * a serialization fact, measured off a real run rather than read off a spec —
+ * and it is called out as such here so nobody mistakes it for normative.
+ *
+ * This module lives in core, not beside the control that renders it, for the
+ * reason `file-formats.ts` established: a host that shows a result its own way
+ * needs the same answer the control uses, and two copies of an answer is two
+ * places for it to drift. Pure data and pure functions — no React.
+ */
+/**
+ * `native.Document`, read.
+ *
+ * `url` is the only required member; everything else is a producer's courtesy,
+ * so a reader that demands any of them describes a value the standard permits
+ * as malformed.
+ */
+interface DocumentContentView {
+    url: string;
+    publicUrl?: string;
+    mimeType?: string;
+    filename?: string;
+    title?: string;
+    snippet?: string;
+}
+/** `native.Image`, read. `width`/`height` are optional but PAIRED by the spec. */
+interface ImageContentView {
+    url: string;
+    publicUrl?: string;
+    caption?: string;
+    mimeType?: string;
+    filename?: string;
+    width?: number;
+    height?: number;
+    sourcePrompt?: string;
+}
+/** `native.Date` (and the typed-scalar envelope a nested `date` field arrives in). */
+interface DateContentView {
+    /** ISO 8601 calendar date, `YYYY-MM-DD`. */
+    date: string;
+    /** ISO 8601 time of day, present only when the source stated one. */
+    time?: string;
+}
+/**
+ * Read a `document`-kind value. `undefined` when the value carries no `url`,
+ * which is the one member the standard requires — a caller renders its own
+ * absence rather than being handed a half-value to test.
+ */
+declare function readDocumentContent(value: unknown): DocumentContentView | undefined;
+/** Read an `image`-kind value. Same contract as `readDocumentContent`. */
+declare function readImageContent(value: unknown): ImageContentView | undefined;
+/**
+ * `native.Html`, read.
+ *
+ * The only content model here that is NOT reached by a field kind, and the
+ * reason is a deliberate decision of the standard: the kind vocabulary has no
+ * `html` member, so a `native.Html` value is an `object` node over its two
+ * declared fields. That is right for the descriptor — the kinds name how a value
+ * is ENTERED, and markup is entered as text — and wrong for a result view, which
+ * would otherwise print a page's source at a reader.
+ *
+ * So this one is keyed by CONCEPT rather than by kind, through
+ * `isNativeHtmlNode` below. That is a membership test on facts the descriptor
+ * states (`concept_ref`, `refines`), which the standard's own page calls out as
+ * the supported way to ask "does this refine `native.X`?" — the opposite of
+ * inspecting a value to guess what it is.
+ */
+interface HtmlContentView {
+    /** The markup itself. The one required member. */
+    innerHtml: string;
+    /** A class name for a wrapper a consumer may put around it, when stated. */
+    cssClass?: string;
+}
+/** Read an `native.Html` value. `undefined` when it carries no markup. */
+declare function readHtmlContent(value: unknown): HtmlContentView | undefined;
+/** The concept refs whose content model is multi-property, spelled once each. */
+declare const NATIVE_HTML_CONCEPT_REF = "native.Html";
+declare const NATIVE_DATE_CONCEPT_REF = "native.Date";
+declare const NATIVE_COMPOSITE_CONCEPT_REF = "native.Composite";
+/** One member of a composite: the name it was composed under, and its content. */
+interface CompositeMember {
+    name: string;
+    value: unknown;
+}
+/**
+ * Read a `native.Composite` — a named composition of contents.
+ *
+ * The members are returned in the order the payload states them, which is the
+ * order the method composed them in and the only order there is: a composite
+ * declares no fields, so there is no authored order to prefer over it.
+ *
+ * `undefined` for anything that is not a record, so the caller falls back.
+ */
+declare function readCompositeContent(value: unknown): CompositeMember[] | undefined;
+/**
+ * Whether a descriptor node carries markup — its concept IS `native.Html`, or
+ * refines it.
+ *
+ * The refinement chain is checked, not just the leaf, because a method may
+ * declare `legal.ClauseMarkup` refining `native.Html` and a reader of that result
+ * wants the markup rendered just the same. `refines` is on the wire for exactly
+ * this question.
+ */
+declare function isNativeHtmlNode(node: {
+    conceptRef?: string;
+    refines?: readonly string[];
+}): boolean;
+/**
+ * Whether a node IS a `native.Date` — the other content model the kind
+ * vocabulary cannot name.
+ *
+ * `native.Date` is `{date, time}`, two properties, so nothing unwraps it and its
+ * node is an `object`. Correct for the descriptor and wrong for a reader: a date
+ * result rendered structurally is a two-field card whose second field says "not
+ * provided", where the answer is a date. The `date` ARM already reads exactly
+ * this model — `readDateContent` takes `{date, time}` — it just never fires,
+ * because the kind says `object`.
+ *
+ * A `date` FIELD inside a structure is a different thing and needs none of this:
+ * it carries `kind: "date"` already.
+ */
+declare function isNativeDateNode(node: {
+    conceptRef?: string;
+    refines?: readonly string[];
+}): boolean;
+/**
+ * Whether a node is a `native.Composite` — a named bag of contents.
+ *
+ * The third concept the kind vocabulary cannot name, and the one where it is
+ * least able to: a composite declares no members at all, so its descriptor is
+ * `kind: "unknown"` and its payload schema is `{additionalProperties: true}`
+ * with no properties. Both are TRUE — the standard's escape hatch, honestly
+ * used — and both leave a renderer with nothing to read, so the default
+ * fallback prints the whole thing as a JSON blob.
+ *
+ * That is the worst available answer to a value that is, by definition, a map
+ * of ordinary `StuffContent`s. Keyed by concept, a renderer can at least show
+ * the members as the named things they are. See `CompositeValue`.
+ */
+declare function isNativeCompositeNode(node: {
+    conceptRef?: string;
+    refines?: readonly string[];
+}): boolean;
+/**
+ * Read a `date`-kind value, in any of the three shapes a run produces.
+ *
+ * The `date` member is read one level deep, because `native.Date`'s own `date`
+ * member is a `datetime.date` and therefore arrives inside the same typed-scalar
+ * envelope the whole value may already be wrapped in. One level is enough and
+ * the recursion is bounded on purpose: a second envelope would be a
+ * serialization bug, and following it forever would turn one into a hang.
+ */
+declare function readDateContent(value: unknown): DateContentView | undefined;
+/** `{date}` / `{date, time}` as one line, which is how both are read aloud. */
+declare function formatDateContent(content: DateContentView): string;
+/**
+ * Whether a browser can paint this URL as-is.
+ *
+ * A `pipelex-storage://` reference cannot be resolved client-side — that is the
+ * upload seam's job (see [../../docs/upload-seam.md]) — so a renderer with no
+ * resolver must show the reference rather than a broken `<img>`. `file:` is
+ * deliberately NOT viewable: a run on a developer's machine writes one, and a
+ * browser refuses to load it from a page served over http.
+ *
+ * **A root-relative path counts**, and leaving it out was a real bug rather
+ * than an omission. A host's URL resolver naturally hands back a path on its
+ * OWN origin — `/api/assets/…`, an authenticated route that streams the object
+ * — which is the whole point of resolving rather than exposing storage. This
+ * predicate rejected it for having no scheme, so the resolved URL was thrown
+ * away and the arms fell back to the payload's `public_url`: a presigned URL
+ * that had already expired. The image stayed broken with the fix in place.
+ *
+ * `//host/path` is deliberately excluded. It is protocol-relative, so it points
+ * at another origin while looking like a path.
+ */
+declare function isViewableUrl(url: string | undefined): url is string;
+/**
+ * The typed-scalar markers the serialization layer stamps onto a value.
+ *
+ * Exported so a host can recognise (and strip) them; nothing in the kernel
+ * BRANCHES on them, which is the point — a reader keyed by these would be
+ * reading the serializer instead of the standard.
+ */
+declare const TYPED_SCALAR_MARKERS: readonly ["__class__", "__module__"];
+/** Whether a record carries the typed-scalar markers. Informational. */
+declare function hasTypedScalarMarkers(value: unknown): boolean;
+
+export { type CompositeMember, type DateContentView, type DocumentContentView, type HtmlContentView, type 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 };

package/dist/core/native-content.js

@@ -0,0 +1,4 @@
+export { 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 '../chunk-45C2MKK6.js';
+import '../chunk-V3OV2XQT.js';
+//# sourceMappingURL=native-content.js.map
+//# sourceMappingURL=native-content.js.map

package/dist/core/{native-concepts.js.map → native-content.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"native-concepts.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"native-content.js"}

package/dist/core/normalize-schema.js

@@ -1,4 +1,4 @@
-export { normalizeSchemaForRjsf, prepareSchemaForRjsf } from '../chunk-KFZ5MZOM.js';
-export { hoistDefsToRoot } from '../chunk-O4O3QNVC.js';
+export { normalizeSchemaForRjsf, prepareSchemaForRjsf } from '../chunk-LBFZXYCY.js';
+export { hoistDefsToRoot } from '../chunk-OD3VYXUY.js';
 //# sourceMappingURL=normalize-schema.js.map
 //# sourceMappingURL=normalize-schema.js.map

package/dist/core/output-form.d.ts

@@ -0,0 +1,45 @@
+import { OutputForm, PipeOutputFormDescriptor } from 'mthds/protocol';
+export { OutputForm, PipeOutputFormDescriptor } from 'mthds/protocol';
+
+/**
+ * The output-form descriptor lookup.
+ *
+ * **This module used to declare the artifact; now it only addresses it.** The
+ * types come from `mthds/protocol`, exactly as the input side's do — the
+ * standard grew `output_form` as a page of its own, and grew `json_schema` on
+ * the output contract in the same version, so a renderer reads both off the wire
+ * instead of having them supplied beside it. What is left here is the twin of
+ * `getPipeInputForm`: the lookup, and the tolerance for the same two key
+ * conventions. [docs/contract-mirror.md](../../docs/contract-mirror.md) states
+ * the rule this now obeys — the contract types are the standard's, not this
+ * package's, and a member this package wants on one is a change to the standard
+ * before it is a change here.
+ *
+ * **An output is a concept ref exactly like an input is.** Same concept, same
+ * structure, same field kinds, same nesting; what differs is only the three SLOT
+ * facts an output has none of (an authored `name`, the three-valued `presence`,
+ * `gating`), all three optional on the standard's node precisely so a node can
+ * exist without them. That is why `buildResultField` maps an output node through
+ * the very mapper `buildRunFields` uses, and why there is no second node union
+ * anywhere in this package.
+ *
+ * | | Inputs | Outputs |
+ * | --- | --- | --- |
+ * | identity, plurality, optionality | `pipe_io_contracts` | `pipe_io_contracts` |
+ * | shape / JSON Schema | `json_schema` on the input contract | `json_schema` on the output contract |
+ * | presentation view | `input_form` | `output_form` |
+ *
+ * The two rows that used to read "nothing" are the change this package was built
+ * against while it was still a proposal; `wip/output-form-standard-change.md` is
+ * the argument that landed it. The one asymmetry the language keeps is
+ * `presence` versus `optional`: `!` MUST NOT appear on an output, so a
+ * three-valued output marker would have an arm nothing could ever produce.
+ */
+
+/**
+ * Look a pipe's output descriptor up by code — the exact twin of
+ * `getPipeInputForm`, tolerant of the same two key conventions.
+ */
+declare function getPipeOutputForm(outputForm: OutputForm | null | undefined, domain: string | null | undefined, pipeCode: string | null | undefined): PipeOutputFormDescriptor | undefined;
+
+export { getPipeOutputForm };

package/dist/core/output-form.js

@@ -0,0 +1,5 @@
+export { getPipeOutputForm } from '../chunk-IIU3YK4O.js';
+import '../chunk-XYQ7NXQZ.js';
+import '../chunk-V3OV2XQT.js';
+//# sourceMappingURL=output-form.js.map
+//# sourceMappingURL=output-form.js.map

package/dist/core/output-form.js.map

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

package/dist/core/readiness.d.ts

@@ -1,4 +1,6 @@
 import { RunField } from './descriptor.js';
+import './contracts.js';
+import 'mthds/protocol';
 
 /**
  * Value readiness - the helpers the runner uses to decide whether the Run

package/dist/core/schema-utils.d.ts

@@ -47,6 +47,18 @@ declare function derefSchema(schema: JsonSchema, defs: Record<string, JsonSchema
  * the callers did inline.
  */
 declare function resolveSchemaIndirection(schema: JsonSchema, defs: Record<string, JsonSchema>): JsonSchema;
+/**
+ * Resolve one schema node to its fixpoint under `derefSchema` +
+ * `collapseNullable`, so a nullable REFERENCE - pydantic's `anyOf: [{$ref},
+ * {type:'null'}]` for an Optional concept-typed field - resolves the same way
+ * a bare `$ref` or an inline nullable does. One pass of either helper cannot:
+ * collapsing the nullable surfaces a `$ref` that was inside a branch, and
+ * dereferencing can surface a nullable the definition holds. Sibling keys
+ * still merge over the definition (`derefSchema`'s semantics - unlike
+ * `resolveSchemaIndirection`, which replaces). Identity is the fixpoint test:
+ * both helpers return the schema unchanged when they have nothing to do.
+ */
+declare function resolveSchemaNode(schema: JsonSchema, defs: Record<string, JsonSchema>): JsonSchema;
 interface CollectDefsOptions {
     /**
      * Whether the walk descends into JSON arrays (`anyOf`/`allOf` branches,
@@ -71,4 +83,4 @@ declare function collectSchemaDefs(schema: JsonSchema, into: Record<string, Json
  */
 declare function hoistDefsToRoot(schema: JsonSchema): JsonSchema;
 
-export { type CollectDefsOptions, type JsonSchema, collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, schemaTypeOf };
+export { type CollectDefsOptions, type JsonSchema, collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, resolveSchemaNode, schemaTypeOf };

package/dist/core/schema-utils.js

@@ -1,3 +1,3 @@
-export { collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, schemaTypeOf } from '../chunk-O4O3QNVC.js';
+export { collapseNullable, collectSchemaDefs, derefSchema, flattenAnyOf, hoistDefsToRoot, resolveSchemaIndirection, resolveSchemaNode, schemaTypeOf } from '../chunk-OD3VYXUY.js';
 //# sourceMappingURL=schema-utils.js.map
 //# sourceMappingURL=schema-utils.js.map

package/dist/core/stuff-files.d.ts

@@ -0,0 +1,52 @@
+import { RunField } from './descriptor.js';
+import './contracts.js';
+import 'mthds/protocol';
+
+/**
+ * One file a stuff carries: what to fetch, and what to call it once saved.
+ */
+interface StuffFile {
+    /**
+     * The durable reference or URL the value states, for a file held BY
+     * REFERENCE. Absent for inline content, which needs no fetch.
+     */
+    url?: string;
+    /**
+     * The content itself, for a file the stuff carries INLINE — markup, today.
+     * Exactly one of `url` and `text` is set.
+     */
+    text?: string;
+    /** The extension to save inline content under, without the dot. */
+    extension?: string;
+    /**
+     * The URL that works outside this session, when the value carries one. A host
+     * whose display URL is session-scoped (an owner-checked proxy route) needs
+     * this for anything that leaves the browser.
+     */
+    publicUrl?: string;
+    /** The file's own name when it states one — otherwise the caller derives it. */
+    filename?: string;
+    mimeType?: string;
+    /** Where it sat, dotted: `report.attachments.2.scan`. Names a saved file. */
+    path: string;
+    kind: 'image' | 'document' | 'markup';
+}
+/**
+ * Every file inside a stuff, found by walking the DESCRIPTOR — never the value.
+ *
+ * The distinction is the whole point. A payload walk would have to decide what
+ * a file is by looking at it: an object with a `url`, a string that ends in
+ * `.pdf`. That is the guessing this package exists to remove, and it is wrong in
+ * both directions — a method whose output legitimately has a `url` field of its
+ * own is not a document, and a stored image whose reference carries no extension
+ * is. The descriptor already states `kind: "image"` or `kind: "document"`, so
+ * the walk reads the declaration and consults the value only for the members
+ * that declaration promises.
+ *
+ * Ordering is the authored one, depth-first, which is the order the rendered
+ * view puts them in — so a download of three images numbers them the way the
+ * reader saw them.
+ */
+declare function collectStuffFiles(field: RunField, value: unknown): StuffFile[];
+
+export { type StuffFile, collectStuffFiles };

package/dist/core/stuff-files.js

@@ -0,0 +1,5 @@
+export { collectStuffFiles } from '../chunk-4BSBBG2T.js';
+import '../chunk-45C2MKK6.js';
+import '../chunk-V3OV2XQT.js';
+//# sourceMappingURL=stuff-files.js.map
+//# sourceMappingURL=stuff-files.js.map

package/dist/core/stuff-files.js.map

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

package/dist/core/values.d.ts

@@ -1,5 +1,6 @@
+import { PipeInputContract, PipeIOContract, PipeInputFormDescriptor } from 'mthds/protocol';
 import { RunField } from './descriptor.js';
-import { PipeInputContract, PipeIOContract } from './contracts.js';
+import './contracts.js';
 
 /**
  * Bridges the `MethodRunner`'s field values to the rest of the host.
@@ -80,8 +81,14 @@ declare function outputsFromPipeOutput(pipeOutput: unknown, inputKeys: string[])
  * 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[];
+/**
+ * Field descriptors for a method's main pipe - the wire descriptor mapped over
+ * the contract, or `[]` while either artifact has not arrived yet. The
+ * descriptor comes back from `validate` beside `pipe_io_contracts` when the
+ * request opts in with `views: ["input_form"]`; `getPipeInputForm` is the
+ * lookup that matches `getPipeIOContract`.
+ */
+declare function fieldsForContract(contract: PipeIOContract | undefined, descriptor: PipeInputFormDescriptor | 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.

package/dist/core/values.js

@@ -1,11 +1,11 @@
-export { apiInputsFromRunValues, fieldsForContract, inputDataFromWorkingMemory, outputsFromPipeOutput, rjsfDataFromRunValues, runValuesFromStore, setValueAtPath, storeInputDataFromRunValues } from '../chunk-WXBSM2CE.js';
-import '../chunk-7BMOPXDY.js';
+export { apiInputsFromRunValues, fieldsForContract, inputDataFromWorkingMemory, outputsFromPipeOutput, rjsfDataFromRunValues, runValuesFromStore, setValueAtPath, storeInputDataFromRunValues } from '../chunk-T4NSAGOS.js';
+import '../chunk-J4L32LD6.js';
+import '../chunk-2JWRG53S.js';
+import '../chunk-GCXV76WU.js';
 import '../chunk-PM55AHRO.js';
-import '../chunk-VMLXO5JS.js';
-import '../chunk-O4O3QNVC.js';
-import '../chunk-HARYEWNG.js';
-import '../chunk-V3OV2XQT.js';
 import '../chunk-GKV77RAS.js';
-import '../chunk-NMT7BRLO.js';
+import '../chunk-OD3VYXUY.js';
+import '../chunk-XYQ7NXQZ.js';
+import '../chunk-V3OV2XQT.js';
 //# sourceMappingURL=values.js.map
 //# sourceMappingURL=values.js.map

package/dist/core/wire-format.js

@@ -1,7 +1,6 @@
-export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode } from '../chunk-7BMOPXDY.js';
-import '../chunk-O4O3QNVC.js';
-import '../chunk-V3OV2XQT.js';
+export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode } from '../chunk-GCXV76WU.js';
 import '../chunk-GKV77RAS.js';
-import '../chunk-NMT7BRLO.js';
+import '../chunk-OD3VYXUY.js';
+import '../chunk-V3OV2XQT.js';
 //# sourceMappingURL=wire-format.js.map
 //# sourceMappingURL=wire-format.js.map