@pipelex/mthds-form 0.4.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @pipelex/mthds-form
 
-The input form for MTHDS methods, as a library: a headless kernel that turns a method's declared input contract into a renderable descriptor and gates what may be run, plus a themeable React control set that renders that descriptor.
+The input form for MTHDS methods, as a library: a headless kernel that maps the method's wire-stated input form and contracts onto a renderable descriptor and gates what may be run, plus a themeable React control set that renders that descriptor.
 
 It exists because "the form" is one problem that keeps being solved separately. A method declares its inputs; something has to decide what widget each input deserves, whether the Run button may light up, what shape the values take on the wire, and what a validation failure says to a person. That logic belongs in one place with tests around it, not copied into each surface that happens to need a form.
 
@@ -15,14 +15,22 @@ import { FieldRenderer } from '@pipelex/mthds-form/react'; // the controls
 
 `./react` is the control set — one control per field kind behind a single dispatch point, styled with Tailwind classes over standard shadcn/ui tokens. `react` and `react-dom` are optional peer dependencies, so a consumer that only wants the kernel never installs them.
 
+`mthds` is a peer dependency too, and a required one, but it is **types only**: the wire types of `pipe_io_contracts` belong to the MTHDS standard, so this package re-exports the standard's declarations instead of restating them. Every import of it is an `import type` and is erased at build, so it costs an install entry and no shipped bytes. See [docs/dependency-budget.md](docs/dependency-budget.md).
+
 ## The shape of a form
 
 ```tsx
-import { buildRunFields, computeReadiness, getPipeIOContract } from '@pipelex/mthds-form';
+import {
+  buildRunFields,
+  computeReadiness,
+  getPipeInputForm,
+  getPipeIOContract,
+} from '@pipelex/mthds-form';
 import { FieldRenderer } from '@pipelex/mthds-form/react';
 
 const contract = getPipeIOContract(method.pipe_io_contracts, method.domain, pipeCode);
-const fields = buildRunFields(contract.inputs);
+const descriptor = getPipeInputForm(method.input_form, method.domain, pipeCode);
+const fields = buildRunFields(descriptor, contract.inputs);
 const { missing } = computeReadiness(fields, values);
 const canRun = missing.length === 0;
 
@@ -37,11 +45,11 @@ return fields.map((field) => (
 ));
 ```
 
-The lookup takes its arguments in wire order — **contracts, domain, pipe code** — and both of the last two are strings, so swapping them typechecks. It resolves anyway against a map keyed by bare pipe code, and fails only against one keyed by namespaced `pipe_ref`, a long way from the call.
+`pipe_io_contracts` is always on a valid validate report; `input_form` is its sibling presentation view, opted into with `views: ["input_form"]` on the validate request. Both lookups take their arguments in wire order — **the map, domain, pipe code** — and the last two are strings, so swapping them typechecks. They resolve anyway against a map keyed by bare pipe code, and fail only against one keyed by namespaced `pipe_ref`, a long way from the call.
 
 `computeReadiness` reports `{ total, ready, missing }` — `missing` names the inputs still to fill, so it is both the Run gate and what a form tells the user is left.
 
-`buildRunFields` is the only function that reads JSON Schema. Everything downstream — rendering, readiness, validation messaging — reads the `RunField` descriptor it returns. That is the load-bearing rule of the package, and [docs/architecture.md](docs/architecture.md) explains what it buys.
+The wire descriptor states what each field IS; `buildRunFields` maps it structurally, consulting the contract's `json_schema` only for two facts the wire omits (the scalar wrapper key and nested list bounds). Everything downstream — rendering, readiness, validation messaging — reads the `RunField` descriptor it returns. That is the load-bearing rule of the package, and [docs/architecture.md](docs/architecture.md) explains what it buys.
 
 Submitting goes through the gate: `buildRunInputsSchema` → `prepareRunInputs` → `validateRunInputs` → `apiInputsFromSchemaData`. The verdict is structured (`RunInputError[]`), and `describeValidationError` renders it for a person.
 
@@ -56,7 +64,8 @@ The controls carry Tailwind classes over the standard shadcn/ui semantic tokens
 | [docs/architecture.md](docs/architecture.md) | the descriptor currency, the one-function seam, the module map |
 | [docs/dependency-budget.md](docs/dependency-budget.md) | what each layer may depend on, and how that is enforced |
 | [docs/theming.md](docs/theming.md) | the token contract and host setup |
-| [docs/derivation-swap.md](docs/derivation-swap.md) | how the descriptor moves server-side without touching consumers |
+| [docs/wire-correspondence.md](docs/wire-correspondence.md) | the name-for-name wire ↔ `RunField` mapping |
+| [docs/derivation-swap.md](docs/derivation-swap.md) | the record of the swap to the wire descriptor — what changed, what survived |
 
 ## Development
 

package/dist/{chunk-6XD6UZSU.js → chunk-25I6JDIK.js}

@@ -24,5 +24,5 @@ function conceptCategory(field) {
 }
 
 export { conceptCategory };
-//# sourceMappingURL=chunk-6XD6UZSU.js.map
-//# sourceMappingURL=chunk-6XD6UZSU.js.map
+//# sourceMappingURL=chunk-25I6JDIK.js.map
+//# sourceMappingURL=chunk-25I6JDIK.js.map

package/dist/chunk-25I6JDIK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/descriptor.ts"],"names":[],"mappings":";AA6MO,SAAS,gBAAgB,KAAA,EAAkC;AAChE,EAAA,QAAQ,MAAM,IAAA;AAAM,IAClB,KAAK,MAAA;AAAA,IACL,KAAK,OAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,UAAA;AACH,MAAA,OAAO,UAAA;AAAA,IACT,KAAK,OAAA;AACH,MAAA,OAAO,OAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,OAAO,QAAA;AAAA,IACT,KAAK,SAAA;AACH,MAAA,OAAO,SAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,QAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT;AACE,MAAA,OAAO,YAAA;AAAA;AAEb","file":"chunk-25I6JDIK.js","sourcesContent":["/**\n * The `RunField` descriptor - the consumer-facing currency of the form kernel.\n *\n * A method's inputs arrive from the API as two sibling artifacts: the wire\n * input-form descriptor (`input_form`, the ordered presentation view the MTHDS\n * standard specifies) and the `pipe_io_contracts` entry whose `json_schema`\n * stays the validation contract. `buildRunFields` (in `derive.ts`) maps the\n * wire descriptor structurally onto this `RunField[]` shape - so the\n * presentational field components never touch either wire artifact directly,\n * and stories can describe any input shape declaratively.\n *\n * Pure module: no React, no API calls. Trivially unit-testable.\n */\n\nimport type { InputPresence } from './contracts';\n\nexport type RunFieldKind =\n  | 'text' // short single-line string\n  | 'prose' // long free-text (textarea)\n  | 'date' // a calendar date (schema `format: date` or `date-time`)\n  | 'number' // integer or float\n  | 'boolean' // true/false\n  | 'enum' // pick one of a fixed set\n  | 'document' // a file (PDF, docx…) by upload or URL\n  | 'image' // a file rendered with a preview\n  | 'object' // a structured concept with nested fields\n  | 'list' // an array of one element type\n  | 'unknown'; // anything we can't map → raw JSON escape hatch\n\nexport interface RunFieldCommon {\n  /** The variable identifier as written in the method (rendered in mono). */\n  name: string;\n  /** Human label; falls back to `name` when absent. */\n  title?: string;\n  /** The concept this input carries, e.g. `native.Document`, `demo.Invoice`. */\n  conceptRef?: string;\n  /**\n   * The concept's refinement chain, immediate parent first, walked to its end\n   * (`['legal.BaseClause', 'native.Text']`). Straight off the wire descriptor;\n   * absent when the concept refines nothing. \"Does this refine `native.X`?\" is\n   * a membership test on this list, never shape sniffing.\n   */\n  refines?: string[];\n  /** One-line helper text shown under the label. */\n  description?: string;\n  /** Required inputs always show; optional ones can collapse. */\n  required: boolean;\n  /**\n   * The authored presence marker of the pipe's input slot, verbatim - set on\n   * TOP-LEVEL fields only, like `gating`. `required` is its two-valued\n   * projection (`presence !== 'optional'`); the marker itself is carried so a\n   * renderer can distinguish the authored `!` assertion from a plain slot.\n   */\n  presence?: InputPresence;\n  /**\n   * The value applied when the caller omits the field - present only when a\n   * default was AUTHORED, never the `null` a schema projection attaches to an\n   * optional field. A defaulted field always arrives `required: false`.\n   */\n  defaultValue?: unknown;\n  /** Example values for the field, when the wire carries any. */\n  examples?: unknown[];\n  /**\n   * The node's effective intent hints - the flat `string → string` merge the\n   * language defines, carried verbatim. Non-normative: a renderer that ignores\n   * them stays correct, and nothing in the kernel's gating reads them.\n   */\n  hints?: Record<string, string>;\n  /**\n   * Whether Run waits for this input - set on TOP-LEVEL fields only, straight\n   * from `inputMustBeFilled` (see `mustBeFilled` in `readiness.ts` for why this\n   * is not the same question as `required`). Nested fields leave it undefined;\n   * they are gated through their parent's `fieldFilled`.\n   */\n  gating?: boolean;\n  /**\n   * The single property this field's value sits inside on the wire, when its\n   * concept declares a scalar content model: `native.Text` is `TextContent\n   * {text}`, `native.Number` is `NumberContent {number}`, `native.YesNo` is\n   * `YesNoContent {yes_no}`. The control still holds the plain scalar; the\n   * value bridge wraps into this property on the way out and unwraps on the way\n   * back in.\n   *\n   * A property NAME, never a schema - the descriptor stays the only currency\n   * and `buildRunFields` stays the only reader of JSON Schema. Absent whenever\n   * the value is already the whole content (a structured concept, a file, a\n   * child property of a structure): wrapping those would double-nest them.\n   */\n  contentKey?: string;\n}\n\n/**\n * The constraint slots the two text kinds share, mapped from the wire's\n * `min_length` / `max_length` / `pattern` / `format`. `format` is the open\n * string set carrying schema formats the `date` kind does not absorb\n * (`'time'`, `'uri'`, …); a renderer may hint on it and ignore it safely.\n */\nexport interface TextConstraints {\n  minLength?: number;\n  maxLength?: number;\n  pattern?: string;\n  format?: string;\n}\n\nexport interface TextRunField extends RunFieldCommon, TextConstraints {\n  kind: 'text';\n  placeholder?: string;\n}\n\nexport interface ProseRunField extends RunFieldCommon, TextConstraints {\n  kind: 'prose';\n  placeholder?: string;\n}\n\nexport interface DateRunField extends RunFieldCommon {\n  kind: 'date';\n  /**\n   * The wire's `datetime` flag - true when the value carries a time of day\n   * (the backing schema is `format: date-time`): the stored value is a full\n   * RFC 3339 timestamp (`2026-07-06T00:00:00Z`) so it passes the API's\n   * `date-time` validation, even though the control only asks for a day. False\n   * for a bare calendar date, where the value stays `YYYY-MM-DD`.\n   */\n  datetime: boolean;\n}\n\nexport interface NumberRunField extends RunFieldCommon {\n  kind: 'number';\n  integer: boolean;\n  min?: number;\n  max?: number;\n}\n\nexport interface BooleanRunField extends RunFieldCommon {\n  kind: 'boolean';\n}\n\nexport interface EnumRunField extends RunFieldCommon {\n  kind: 'enum';\n  options: string[];\n}\n\nexport interface FileRunField extends RunFieldCommon {\n  kind: 'document' | 'image';\n  /** Accept hint shown to the user, e.g. \"PDF, PNG, JPG\". */\n  accept?: string;\n}\n\nexport interface ObjectRunField extends RunFieldCommon {\n  kind: 'object';\n  fields: RunField[];\n}\n\nexport interface ListRunField extends RunFieldCommon {\n  kind: 'list';\n  /** The element descriptor (its `name` is unused; the index labels items). */\n  item: RunField;\n  /**\n   * The FEWEST items the slot accepts. Absent for a variable `Concept[]` list,\n   * which demands none.\n   *\n   * On a top-level slot this is the wire descriptor's `item_count` (present\n   * exactly on a fixed `[N]` slot); an engine emits `minItems`/`maxItems` = N\n   * on the same slot's schema, so the number `fieldFilled` gates on and the\n   * keyword ajv reads agree by construction.\n   *\n   * The wire never puts `item_count` on a NESTED list, but the model behind a\n   * structured concept may state `minItems` on an array property of its own -\n   * so on nested nodes this is read off the schema, which is the direction\n   * that cannot leave readiness more permissive than the gate.\n   */\n  itemCount?: number;\n  /**\n   * The MOST items the slot accepts, off the schema's `maxItems` (which a\n   * fixed `[N]` slot also states as N).\n   *\n   * A separate field because it is a separate fact, and conflating them is a\n   * bug that hides: `itemCount` was read as a minimum by readiness and as a\n   * maximum by the control that stops offering `Add`, which agree only while\n   * a contract states both bounds equal. A list told \"at least two\" was then\n   * presented as a list of exactly two.\n   */\n  maxItemCount?: number;\n}\n\nexport interface UnknownRunField extends RunFieldCommon {\n  kind: 'unknown';\n}\n\nexport type RunField =\n  | TextRunField\n  | ProseRunField\n  | DateRunField\n  | NumberRunField\n  | BooleanRunField\n  | EnumRunField\n  | FileRunField\n  | ObjectRunField\n  | ListRunField\n  | UnknownRunField;\n\n/** The short, friendly category label for a concept_ref (drives the pill dot). */\nexport type ConceptCategory =\n  'text' | 'date' | 'document' | 'image' | 'number' | 'boolean' | 'choice' | 'structured' | 'list';\n\nexport function conceptCategory(field: RunField): ConceptCategory {\n  switch (field.kind) {\n    case 'text':\n    case 'prose':\n      return 'text';\n    case 'date':\n      return 'date';\n    case 'document':\n      return 'document';\n    case 'image':\n      return 'image';\n    case 'number':\n      return 'number';\n    case 'boolean':\n      return 'boolean';\n    case 'enum':\n      return 'choice';\n    case 'list':\n      return 'list';\n    default:\n      return 'structured';\n  }\n}\n"]}

package/dist/chunk-2JWRG53S.js

@@ -0,0 +1,33 @@
+// src/core/file-formats.ts
+var DOCUMENT_FORMATS = [
+  { mimeType: "application/pdf", extensions: [".pdf"], label: "PDF" },
+  { mimeType: "image/jpeg", extensions: [".jpg", ".jpeg"], label: "JPG" },
+  { mimeType: "image/png", extensions: [".png"], label: "PNG" }
+];
+var IMAGE_FORMATS = [
+  { mimeType: "image/png", extensions: [".png"], label: "PNG" },
+  { mimeType: "image/jpeg", extensions: [".jpg", ".jpeg"], label: "JPG" },
+  { mimeType: "image/webp", extensions: [".webp"], label: "WEBP" }
+];
+function formatsForKind(kind) {
+  return kind === "image" ? IMAGE_FORMATS : DOCUMENT_FORMATS;
+}
+function acceptLabelForKind(kind) {
+  return formatsForKind(kind).map((format) => format.label).join(", ");
+}
+function isAcceptedFile(kind, file) {
+  const formats = formatsForKind(kind);
+  const mimeType = file.type.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  if (mimeType) return formats.some((format) => format.mimeType === mimeType);
+  const name = file.name.toLowerCase();
+  return formats.some((format) => format.extensions.some((ext) => name.endsWith(ext)));
+}
+function acceptMapForKind(kind) {
+  const map = {};
+  for (const format of formatsForKind(kind)) map[format.mimeType] = [...format.extensions];
+  return map;
+}
+
+export { DOCUMENT_FORMATS, IMAGE_FORMATS, acceptLabelForKind, acceptMapForKind, formatsForKind, isAcceptedFile };
+//# sourceMappingURL=chunk-2JWRG53S.js.map
+//# sourceMappingURL=chunk-2JWRG53S.js.map

package/dist/chunk-2JWRG53S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/file-formats.ts"],"names":[],"mappings":";AAoEO,IAAM,gBAAA,GAA0C;AAAA,EACrD,EAAE,UAAU,iBAAA,EAAmB,UAAA,EAAY,CAAC,MAAM,CAAA,EAAG,OAAO,KAAA,EAAM;AAAA,EAClE,EAAE,UAAU,YAAA,EAAc,UAAA,EAAY,CAAC,MAAA,EAAQ,OAAO,CAAA,EAAG,KAAA,EAAO,KAAA,EAAM;AAAA,EACtE,EAAE,UAAU,WAAA,EAAa,UAAA,EAAY,CAAC,MAAM,CAAA,EAAG,OAAO,KAAA;AACxD;AAUO,IAAM,aAAA,GAAuC;AAAA,EAClD,EAAE,UAAU,WAAA,EAAa,UAAA,EAAY,CAAC,MAAM,CAAA,EAAG,OAAO,KAAA,EAAM;AAAA,EAC5D,EAAE,UAAU,YAAA,EAAc,UAAA,EAAY,CAAC,MAAA,EAAQ,OAAO,CAAA,EAAG,KAAA,EAAO,KAAA,EAAM;AAAA,EACtE,EAAE,UAAU,YAAA,EAAc,UAAA,EAAY,CAAC,OAAO,CAAA,EAAG,OAAO,MAAA;AAC1D;AAEO,SAAS,eAAe,IAAA,EAAmD;AAChF,EAAA,OAAO,IAAA,KAAS,UAAU,aAAA,GAAgB,gBAAA;AAC5C;AAGO,SAAS,mBAAmB,IAAA,EAAoC;AACrE,EAAA,OAAO,cAAA,CAAe,IAAI,CAAA,CACvB,GAAA,CAAI,CAAC,WAAW,MAAA,CAAO,KAAK,CAAA,CAC5B,IAAA,CAAK,IAAI,CAAA;AACd;AAWO,SAAS,cAAA,CACd,MACA,IAAA,EACS;AACT,EAAA,MAAM,OAAA,GAAU,eAAe,IAAI,CAAA;AACnC,EAAA,MAAM,QAAA,GAAW,IAAA,CAAK,IAAA,CAAK,KAAA,CAAM,GAAA,EAAK,CAAC,CAAA,CAAE,CAAC,CAAA,EAAG,IAAA,EAAK,CAAE,WAAA,EAAY,IAAK,EAAA;AACrE,EAAA,IAAI,QAAA,SAAiB,OAAA,CAAQ,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,aAAa,QAAQ,CAAA;AAC1E,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,IAAA,CAAK,WAAA,EAAY;AACnC,EAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,UAAA,CAAW,IAAA,CAAK,CAAC,GAAA,KAAQ,IAAA,CAAK,QAAA,CAAS,GAAG,CAAC,CAAC,CAAA;AACrF;AASO,SAAS,iBAAiB,IAAA,EAAsD;AACrF,EAAA,MAAM,MAAgC,EAAC;AACvC,EAAA,KAAA,MAAW,MAAA,IAAU,cAAA,CAAe,IAAI,CAAA,EAAG,GAAA,CAAI,MAAA,CAAO,QAAQ,CAAA,GAAI,CAAC,GAAG,MAAA,CAAO,UAAU,CAAA;AACvF,EAAA,OAAO,GAAA;AACT","file":"chunk-2JWRG53S.js","sourcesContent":["/**\n * What a `document` or an `image` slot actually accepts.\n *\n * **This is a client-side mirror of a runtime fact, and the fact was measured\n * rather than read off a list.** The wire says a slot's kind is `document` or\n * `image` and stops there — which bytes a runtime can decode is a property of\n * that runtime, not of the method — so the list has to live on this side, and\n * the only honest place is one module that says where it came from.\n *\n * There is no single enum to copy. In `pipelex`, what a slot accepts is derived\n * per model:\n *\n *   ModelSpec.supported_document_types = {\"pdf\",\"docx\",\"pptx\"} & set(inputs)\n *   ModelSpec.is_vision_supported      = \"images\" in inputs\n *\n * so the effective set is that vocabulary intersected with the **model deck's**\n * declared `inputs`. No model in the shipped deck declares `docx` or `pptx`;\n * every LLM entry is `[\"text\", \"images\", \"pdf\"]`, and the default extract model\n * (`azure-document-intelligence`) is `[\"image\", \"pdf\"]`.\n *\n * Confirmed by running each format end to end:\n *\n * | Format | PipeExtract | PipeLLM |\n * | --- | --- | --- |\n * | PDF  | yes | yes |\n * | PNG  | yes | n/a |\n * | JPEG | yes | n/a |\n * | WEBP | no  | no  |\n * | DOCX | no  | no — `does not support docx documents` |\n * | PPTX | no  | no — detected as `zip`, so it never even reaches the check |\n *\n * The gateway states its own list in the failure: *\"Supported formats:\n * application/pdf, image/jpeg, image/png as base64 data URLs.\"*\n *\n * Images were measured the same way: PNG, JPEG and WEBP pass; BMP and TIFF fail\n * on the provider's image enum; GIF fails too, though it is *in* that enum — it\n * arrives at the provider as a document block rather than an image one, which\n * looks like a routing bug upstream rather than an unsupported format.\n *\n * **A document slot's PNG and JPEG only work in an extract pipe.** The\n * descriptor never says which operator consumes the slot, so this table cannot\n * distinguish them; it matches the extract model's declared inputs, because\n * extraction is the operator that actually reads a document's bytes.\n *\n * What was here before was built on `DocumentFormat` (PDF/DOCX/PPTX), an enum\n * that is referenced nowhere in the runtime outside commented-out code and is\n * being deleted. A dead enum is the worst kind of source: it reads exactly like\n * a live one.\n *\n * A stale entry here is worse than no list at all, because it refuses a file the\n * runtime would have taken. If the deck grows a format, this table moves with it.\n *\n * Pure data. No React, no ajv, nothing imported.\n */\n\n/** One accepted format: its MIME type and the extensions that carry it. */\nexport interface FileFormat {\n  mimeType: string;\n  /** Leading dot, lowercase — the shape a file input's `accept` wants. */\n  extensions: string[];\n  /** How the format is named to a user, uppercase. */\n  label: string;\n}\n\n/**\n * What a `document` slot takes: PDF, plus the two image formats the extract\n * model reads as a single-page document.\n */\nexport const DOCUMENT_FORMATS: readonly FileFormat[] = [\n  { mimeType: 'application/pdf', extensions: ['.pdf'], label: 'PDF' },\n  { mimeType: 'image/jpeg', extensions: ['.jpg', '.jpeg'], label: 'JPG' },\n  { mimeType: 'image/png', extensions: ['.png'], label: 'PNG' },\n];\n\n/**\n * What an `image` slot takes: PNG, JPEG, WEBP — all three measured through the\n * vision path.\n *\n * `.jpg` and `.jpeg` both ride `image/jpeg`. `JPG` is the label because that is\n * the spelling the runtime uses, but a file named `.jpeg` is the same bytes and\n * must not be refused over its spelling.\n */\nexport const IMAGE_FORMATS: readonly FileFormat[] = [\n  { mimeType: 'image/png', extensions: ['.png'], label: 'PNG' },\n  { mimeType: 'image/jpeg', extensions: ['.jpg', '.jpeg'], label: 'JPG' },\n  { mimeType: 'image/webp', extensions: ['.webp'], label: 'WEBP' },\n];\n\nexport function formatsForKind(kind: 'document' | 'image'): readonly FileFormat[] {\n  return kind === 'image' ? IMAGE_FORMATS : DOCUMENT_FORMATS;\n}\n\n/** `\"PDF, DOCX, PPTX\"` — the hint shown under a dropzone. */\nexport function acceptLabelForKind(kind: 'document' | 'image'): string {\n  return formatsForKind(kind)\n    .map((format) => format.label)\n    .join(', ');\n}\n\n/**\n * Whether a picked file is one this kind accepts.\n *\n * Checks the MIME type first and falls back to the extension, because a\n * browser's `File.type` is empty often enough to matter: an OS with no handler\n * registered for `.docx` reports `''`, and refusing that file would be refusing\n * a valid one over a fact about the user's machine. A wrong-but-present MIME\n * type is still a rejection — that is the case this exists for.\n */\nexport function isAcceptedFile(\n  kind: 'document' | 'image',\n  file: { name: string; type: string },\n): boolean {\n  const formats = formatsForKind(kind);\n  const mimeType = file.type.split(';', 1)[0]?.trim().toLowerCase() ?? '';\n  if (mimeType) return formats.some((format) => format.mimeType === mimeType);\n  const name = file.name.toLowerCase();\n  return formats.some((format) => format.extensions.some((ext) => name.endsWith(ext)));\n}\n\n/**\n * The accept map a file input wants: MIME type to extensions.\n *\n * Shaped for `react-dropzone`'s `accept`, which is the same shape the DOM's\n * `accept` attribute is built from. Listing extensions BESIDE the MIME type is\n * what makes the empty-`File.type` case above work in the OS picker too.\n */\nexport function acceptMapForKind(kind: 'document' | 'image'): Record<string, string[]> {\n  const map: Record<string, string[]> = {};\n  for (const format of formatsForKind(kind)) map[format.mimeType] = [...format.extensions];\n  return map;\n}\n"]}

package/dist/chunk-45C2MKK6.js

@@ -0,0 +1,94 @@
+import { ownProp, hasOwnProp } from './chunk-V3OV2XQT.js';
+
+// src/core/native-content.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readText(record, key) {
+  const value = ownProp(record, key);
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(record, key) {
+  const value = ownProp(record, key);
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readDocumentContent(value) {
+  if (!isRecord(value)) return void 0;
+  const url = readText(value, "url");
+  if (url === void 0) return void 0;
+  return {
+    url,
+    publicUrl: readText(value, "public_url"),
+    mimeType: readText(value, "mime_type"),
+    filename: readText(value, "filename"),
+    title: readText(value, "title"),
+    snippet: readText(value, "snippet")
+  };
+}
+function readImageContent(value) {
+  if (!isRecord(value)) return void 0;
+  const url = readText(value, "url");
+  if (url === void 0) return void 0;
+  return {
+    url,
+    publicUrl: readText(value, "public_url"),
+    caption: readText(value, "caption"),
+    mimeType: readText(value, "mime_type"),
+    filename: readText(value, "filename"),
+    width: readNumber(value, "width"),
+    height: readNumber(value, "height"),
+    sourcePrompt: readText(value, "source_prompt")
+  };
+}
+function readHtmlContent(value) {
+  if (!isRecord(value)) return void 0;
+  const innerHtml = readText(value, "inner_html");
+  if (innerHtml === void 0) return void 0;
+  return { innerHtml, cssClass: readText(value, "css_class") };
+}
+var NATIVE_HTML_CONCEPT_REF = "native.Html";
+var NATIVE_DATE_CONCEPT_REF = "native.Date";
+var NATIVE_COMPOSITE_CONCEPT_REF = "native.Composite";
+function readCompositeContent(value) {
+  if (!isRecord(value)) return void 0;
+  return Object.entries(value).map(([name, member]) => ({ name, value: member }));
+}
+function isNativeHtmlNode(node) {
+  return refinesNative(node, NATIVE_HTML_CONCEPT_REF);
+}
+function isNativeDateNode(node) {
+  return refinesNative(node, NATIVE_DATE_CONCEPT_REF);
+}
+function isNativeCompositeNode(node) {
+  return refinesNative(node, NATIVE_COMPOSITE_CONCEPT_REF);
+}
+function refinesNative(node, ref) {
+  if (node.conceptRef === ref) return true;
+  return node.refines?.includes(ref) ?? false;
+}
+function readDateContent(value) {
+  if (typeof value === "string") {
+    return value.length > 0 ? { date: value } : void 0;
+  }
+  if (!isRecord(value)) return void 0;
+  const inner = ownProp(value, "date");
+  const date = typeof inner === "string" ? inner : isRecord(inner) ? readText(inner, "date") : void 0;
+  if (date === void 0) return void 0;
+  return { date, time: readText(value, "time") };
+}
+function formatDateContent(content) {
+  return content.time ? `${content.date} ${content.time}` : content.date;
+}
+function isViewableUrl(url) {
+  if (!url) return false;
+  if (/^\/(?!\/)/.test(url)) return true;
+  return /^https?:/i.test(url) || /^data:/i.test(url) || /^blob:/i.test(url);
+}
+var TYPED_SCALAR_MARKERS = ["__class__", "__module__"];
+function hasTypedScalarMarkers(value) {
+  return isRecord(value) && TYPED_SCALAR_MARKERS.every((marker) => hasOwnProp(value, marker));
+}
+
+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 };
+//# sourceMappingURL=chunk-45C2MKK6.js.map
+//# sourceMappingURL=chunk-45C2MKK6.js.map

package/dist/chunk-45C2MKK6.js.map

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

package/dist/chunk-4BSBBG2T.js

@@ -0,0 +1,80 @@
+import { isNativeHtmlNode, readHtmlContent, readDocumentContent, readImageContent } from './chunk-45C2MKK6.js';
+import { ownProp } from './chunk-V3OV2XQT.js';
+
+// src/core/stuff-files.ts
+function collectStuffFiles(field, value) {
+  const found = [];
+  walk(field, value, [], found);
+  return found;
+}
+function walk(field, raw, path, out) {
+  const value = unwrapContent(field, raw);
+  const here = path.length > 0 ? path : [field.name];
+  if (isNativeHtmlNode(field)) {
+    const content = readHtmlContent(value);
+    if (content?.innerHtml) {
+      out.push({
+        text: content.innerHtml,
+        extension: "html",
+        path: here.join("."),
+        kind: "markup"
+      });
+    }
+    return;
+  }
+  switch (field.kind) {
+    case "image": {
+      const content = readImageContent(value);
+      if (content?.url) {
+        out.push({
+          url: content.url,
+          publicUrl: content.publicUrl,
+          filename: content.filename,
+          mimeType: content.mimeType,
+          path: here.join("."),
+          kind: "image"
+        });
+      }
+      return;
+    }
+    case "document": {
+      const content = readDocumentContent(value);
+      if (content?.url) {
+        out.push({
+          url: content.url,
+          publicUrl: content.publicUrl,
+          filename: content.filename,
+          mimeType: content.mimeType,
+          path: here.join("."),
+          kind: "document"
+        });
+      }
+      return;
+    }
+    case "object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+      const record = value;
+      for (const child of field.fields) {
+        walk(child, ownProp(record, child.name), [...here, child.name], out);
+      }
+      return;
+    }
+    case "list": {
+      if (!Array.isArray(value)) return;
+      value.forEach((entry, index) => walk(field.item, entry, [...here, String(index)], out));
+      return;
+    }
+    default:
+      return;
+  }
+}
+function unwrapContent(field, value) {
+  if (!field.contentKey) return value;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+  const unwrapped = ownProp(value, field.contentKey);
+  return unwrapped === void 0 ? value : unwrapped;
+}
+
+export { collectStuffFiles };
+//# sourceMappingURL=chunk-4BSBBG2T.js.map
+//# sourceMappingURL=chunk-4BSBBG2T.js.map

package/dist/chunk-4BSBBG2T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/stuff-files.ts"],"names":[],"mappings":"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","file":"chunk-4BSBBG2T.js","sourcesContent":["import { ownProp } from './own-property';\nimport {\n  isNativeHtmlNode,\n  readDocumentContent,\n  readHtmlContent,\n  readImageContent,\n} from './native-content';\nimport type { RunField } from './descriptor';\n\n/**\n * One file a stuff carries: what to fetch, and what to call it once saved.\n */\nexport interface StuffFile {\n  /**\n   * The durable reference or URL the value states, for a file held BY\n   * REFERENCE. Absent for inline content, which needs no fetch.\n   */\n  url?: string;\n  /**\n   * The content itself, for a file the stuff carries INLINE — markup, today.\n   * Exactly one of `url` and `text` is set.\n   */\n  text?: string;\n  /** The extension to save inline content under, without the dot. */\n  extension?: string;\n  /**\n   * The URL that works outside this session, when the value carries one. A host\n   * whose display URL is session-scoped (an owner-checked proxy route) needs\n   * this for anything that leaves the browser.\n   */\n  publicUrl?: string;\n  /** The file's own name when it states one — otherwise the caller derives it. */\n  filename?: string;\n  mimeType?: string;\n  /** Where it sat, dotted: `report.attachments.2.scan`. Names a saved file. */\n  path: string;\n  kind: 'image' | 'document' | 'markup';\n}\n\n/**\n * Every file inside a stuff, found by walking the DESCRIPTOR — never the value.\n *\n * The distinction is the whole point. A payload walk would have to decide what\n * a file is by looking at it: an object with a `url`, a string that ends in\n * `.pdf`. That is the guessing this package exists to remove, and it is wrong in\n * both directions — a method whose output legitimately has a `url` field of its\n * own is not a document, and a stored image whose reference carries no extension\n * is. The descriptor already states `kind: \"image\"` or `kind: \"document\"`, so\n * the walk reads the declaration and consults the value only for the members\n * that declaration promises.\n *\n * Ordering is the authored one, depth-first, which is the order the rendered\n * view puts them in — so a download of three images numbers them the way the\n * reader saw them.\n */\nexport function collectStuffFiles(field: RunField, value: unknown): StuffFile[] {\n  const found: StuffFile[] = [];\n  walk(field, value, [], found);\n  return found;\n}\n\nfunction walk(field: RunField, raw: unknown, path: string[], out: StuffFile[]): void {\n  const value = unwrapContent(field, raw);\n  const here = path.length > 0 ? path : [field.name];\n\n  // Markup, before the kind switch, exactly as the renderer takes it: a\n  // `native.Html` node's KIND is `object` (its content model has two members),\n  // so the switch below would walk into it looking for files and find none.\n  //\n  // It is a file even though nothing stores it as one. The stuff IS a page —\n  // the reader is looking at a rendered report — and handing them a JSON\n  // envelope with the page inside it as a string is the same mistake as handing\n  // them a URL instead of a picture. `isNativeHtmlNode` asks the descriptor\n  // whether the concept refines `native.Html`, which is the standard's own way\n  // to ask; it never looks at the value to decide.\n  if (isNativeHtmlNode(field)) {\n    const content = readHtmlContent(value);\n    if (content?.innerHtml) {\n      out.push({\n        text: content.innerHtml,\n        extension: 'html',\n        path: here.join('.'),\n        kind: 'markup',\n      });\n    }\n    return;\n  }\n\n  switch (field.kind) {\n    case 'image': {\n      const content = readImageContent(value);\n      if (content?.url) {\n        out.push({\n          url: content.url,\n          publicUrl: content.publicUrl,\n          filename: content.filename,\n          mimeType: content.mimeType,\n          path: here.join('.'),\n          kind: 'image',\n        });\n      }\n      return;\n    }\n    case 'document': {\n      const content = readDocumentContent(value);\n      if (content?.url) {\n        out.push({\n          url: content.url,\n          publicUrl: content.publicUrl,\n          filename: content.filename,\n          mimeType: content.mimeType,\n          path: here.join('.'),\n          kind: 'document',\n        });\n      }\n      return;\n    }\n    case 'object': {\n      if (typeof value !== 'object' || value === null || Array.isArray(value)) return;\n      const record = value as Record<string, unknown>;\n      for (const child of field.fields) {\n        walk(child, ownProp(record, child.name), [...here, child.name], out);\n      }\n      return;\n    }\n    case 'list': {\n      if (!Array.isArray(value)) return;\n      // The element descriptor's own `name` is unused by the standard, so the\n      // index is what identifies an entry — the same thing the rendered list\n      // shows beside each row.\n      value.forEach((entry, index) => walk(field.item, entry, [...here, String(index)], out));\n      return;\n    }\n    default:\n      // Every other kind is a scalar. It cannot contain a file, and a `native`\n      // node with no declared members (an `unknown` kind — a composite, say)\n      // states nothing a walk could follow, so there is nothing to look at.\n      return;\n  }\n}\n\n/**\n * The one unwrap path, matching the renderer's: a content model is opened by\n * the property the schema named, and by nothing else.\n */\nfunction unwrapContent(field: RunField, value: unknown): unknown {\n  if (!field.contentKey) return value;\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return value;\n  const unwrapped = ownProp(value as Record<string, unknown>, field.contentKey);\n  return unwrapped === undefined ? value : unwrapped;\n}\n"]}

package/dist/{chunk-7BMOPXDY.js → chunk-GCXV76WU.js}

@@ -1,15 +1,23 @@
-import { collectSchemaDefs, resolveSchemaIndirection, schemaTypeOf } from './chunk-O4O3QNVC.js';
-import { ownProp, hasOwnProp } from './chunk-V3OV2XQT.js';
 import { asCalendarDate } from './chunk-GKV77RAS.js';
-import { splitListConcept, isWireTextConcept, isWireDocumentLikeConcept } from './chunk-NMT7BRLO.js';
+import { collectSchemaDefs, resolveSchemaIndirection, schemaTypeOf } from './chunk-OD3VYXUY.js';
+import { ownProp, hasOwnProp } from './chunk-V3OV2XQT.js';
 
 // src/core/wire-format.ts
+function nativeSet(...names) {
+  return new Set(names.flatMap((n) => [n, `native.${n}`]));
+}
+var WIRE_TEXT_CONCEPTS = nativeSet("Text");
+var WIRE_DOCUMENT_LIKE_CONCEPTS = nativeSet("Document", "Image", "Page");
+function isTextConcept(concept) {
+  return WIRE_TEXT_CONCEPTS.has(concept);
+}
+function isDocumentLikeConcept(concept) {
+  return WIRE_DOCUMENT_LIKE_CONCEPTS.has(concept);
+}
 function isListConcept(conceptCode) {
-  const { base, isList } = splitListConcept(conceptCode);
-  return { isList, baseConcept: base ?? "" };
+  if (conceptCode.endsWith("[]")) return { isList: true, baseConcept: conceptCode.slice(0, -2) };
+  return { isList: false, baseConcept: conceptCode };
 }
-var isTextConcept = isWireTextConcept;
-var isDocumentLikeConcept = isWireDocumentLikeConcept;
 function deflateInput(value, conceptCode) {
   const { isList, baseConcept } = isListConcept(conceptCode);
   if (isList) {
@@ -201,5 +209,5 @@ function inflateAllInputs(simplifiedData, inputSchemas) {
 }
 
 export { deflateAllInputs, deflateInput, healStringWrappers, inflateAllInputs, inflateInput, pruneEmptyOptionals, resolveConceptCode };
-//# sourceMappingURL=chunk-7BMOPXDY.js.map
-//# sourceMappingURL=chunk-7BMOPXDY.js.map
+//# sourceMappingURL=chunk-GCXV76WU.js.map
+//# sourceMappingURL=chunk-GCXV76WU.js.map

package/dist/chunk-GCXV76WU.js.map

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

package/dist/chunk-IIU3YK4O.js

@@ -0,0 +1,16 @@
+import { buildPipeRef } from './chunk-XYQ7NXQZ.js';
+import { ownProp } from './chunk-V3OV2XQT.js';
+
+// src/core/output-form.ts
+function getPipeOutputForm(outputForm, domain, pipeCode) {
+  if (!outputForm || !pipeCode) return void 0;
+  if (domain) {
+    const byRef = ownProp(outputForm, buildPipeRef(domain, pipeCode));
+    if (byRef) return byRef;
+  }
+  return ownProp(outputForm, pipeCode);
+}
+
+export { getPipeOutputForm };
+//# sourceMappingURL=chunk-IIU3YK4O.js.map
+//# sourceMappingURL=chunk-IIU3YK4O.js.map

package/dist/chunk-IIU3YK4O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/output-form.ts"],"names":[],"mappings":";;;;AA6CO,SAAS,iBAAA,CACd,UAAA,EACA,MAAA,EACA,QAAA,EACsC;AACtC,EAAA,IAAI,CAAC,UAAA,IAAc,CAAC,QAAA,EAAU,OAAO,MAAA;AACrC,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,MAAM,QAAQ,OAAA,CAAQ,UAAA,EAAY,YAAA,CAAa,MAAA,EAAQ,QAAQ,CAAC,CAAA;AAChE,IAAA,IAAI,OAAO,OAAO,KAAA;AAAA,EACpB;AACA,EAAA,OAAO,OAAA,CAAQ,YAAY,QAAQ,CAAA;AACrC","file":"chunk-IIU3YK4O.js","sourcesContent":["/**\n * The output-form descriptor lookup.\n *\n * **This module used to declare the artifact; now it only addresses it.** The\n * types come from `mthds/protocol`, exactly as the input side's do — the\n * standard grew `output_form` as a page of its own, and grew `json_schema` on\n * the output contract in the same version, so a renderer reads both off the wire\n * instead of having them supplied beside it. What is left here is the twin of\n * `getPipeInputForm`: the lookup, and the tolerance for the same two key\n * conventions. [docs/contract-mirror.md](../../docs/contract-mirror.md) states\n * the rule this now obeys — the contract types are the standard's, not this\n * package's, and a member this package wants on one is a change to the standard\n * before it is a change here.\n *\n * **An output is a concept ref exactly like an input is.** Same concept, same\n * structure, same field kinds, same nesting; what differs is only the three SLOT\n * facts an output has none of (an authored `name`, the three-valued `presence`,\n * `gating`), all three optional on the standard's node precisely so a node can\n * exist without them. That is why `buildResultField` maps an output node through\n * the very mapper `buildRunFields` uses, and why there is no second node union\n * anywhere in this package.\n *\n * | | Inputs | Outputs |\n * | --- | --- | --- |\n * | identity, plurality, optionality | `pipe_io_contracts` | `pipe_io_contracts` |\n * | shape / JSON Schema | `json_schema` on the input contract | `json_schema` on the output contract |\n * | presentation view | `input_form` | `output_form` |\n *\n * The two rows that used to read \"nothing\" are the change this package was built\n * against while it was still a proposal; `wip/output-form-standard-change.md` is\n * the argument that landed it. The one asymmetry the language keeps is\n * `presence` versus `optional`: `!` MUST NOT appear on an output, so a\n * three-valued output marker would have an arm nothing could ever produce.\n */\n\nimport type { OutputForm, PipeOutputFormDescriptor } from 'mthds/protocol';\nimport { buildPipeRef } from './contracts';\nimport { ownProp } from './own-property';\n\nexport type { OutputForm, PipeOutputFormDescriptor };\n\n/**\n * Look a pipe's output descriptor up by code — the exact twin of\n * `getPipeInputForm`, tolerant of the same two key conventions.\n */\nexport function getPipeOutputForm(\n  outputForm: OutputForm | null | undefined,\n  domain: string | null | undefined,\n  pipeCode: string | null | undefined,\n): PipeOutputFormDescriptor | undefined {\n  if (!outputForm || !pipeCode) return undefined;\n  if (domain) {\n    const byRef = ownProp(outputForm, buildPipeRef(domain, pipeCode));\n    if (byRef) return byRef;\n  }\n  return ownProp(outputForm, pipeCode);\n}\n"]}