@pipelex/mthds-form 0.33.0 → 0.34.0

package/dist/{chunk-IBBAJXIO.js → chunk-XIWBKV7T.js}

@@ -1,5 +1,5 @@
 import { pruneEmptyOptionals, healStringWrappers } from './chunk-E6BIXJ6C.js';
-import { isFilled, mustBeFilled, fieldFilled } from './chunk-XO5OENNF.js';
+import { isFilled, mustBeFilled, fieldFilled } from './chunk-TF4RTKLH.js';
 import { gatingFieldsFromInputs } from './chunk-Y2ND6W4W.js';
 import { prepareSchemaForRjsf } from './chunk-LBFZXYCY.js';
 import { inputMustBeFilled, isOptionalInput, isPluralInput } from './chunk-WYH56SOZ.js';
@@ -95,5 +95,5 @@ function gateRunInputs(contract, data) {
 }
 
 export { apiInputsFromSchemaData, buildRunInputsSchema, gateRunInputs, prepareRunInputs, validateRunInputs };
-//# sourceMappingURL=chunk-IBBAJXIO.js.map
-//# sourceMappingURL=chunk-IBBAJXIO.js.map
+//# sourceMappingURL=chunk-XIWBKV7T.js.map
+//# sourceMappingURL=chunk-XIWBKV7T.js.map

package/dist/{chunk-IBBAJXIO.js.map → chunk-XIWBKV7T.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/gate.ts"],"names":[],"mappings":"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","file":"chunk-IBBAJXIO.js","sourcesContent":["/**\n * The gate every run passes through, whichever surface starts it.\n *\n * A host may offer more than one place to run a method - a schema-driven\n * inputs panel (an RJSF form) and a standalone run page (a bespoke field\n * renderer), say. **Only the rendering of inputs differs.** Everything between\n * \"the user pressed Run\" and \"the payload goes on the wire\" lives here, so\n * those surfaces cannot drift:\n *\n *   1. `buildRunInputsSchema` - the combined JSON Schema, whose `required` list\n *      is `inputMustBeFilled` (optional `?` and variable-plural `[]` never\n *      block; a fixed-count `[N]` list does).\n *   2. `prepareRunInputs` - heal legacy wrappers, then prune empty optionals.\n *   3. `validateRunInputs` - ajv, plus the missing-input scan that names the\n *      VARIABLE at fault.\n *   4. `apiInputsFromSchemaData` - the `{concept, content}` payload, built from\n *      the PREPARED data so the pruning reaches the wire too.\n *\n * **`gateRunInputs` is that whole chain as one call**, and it is what a server\n * should use. The four steps stay exported because a host that renders its own\n * panel needs the schema and the verdict separately, but assembling them is not\n * a host's job: the step between validation and the payload is an emptiness\n * check with four look-alike predicates to choose from, only two of which are\n * the ones the Run button reads, and choosing the near-miss pair produces a\n * server that is more permissive than the button in front of it.\n *\n * This module is pure: no React, no toasts, no i18n. Each caller renders the\n * verdict in its own idiom.\n */\nimport { inputMustBeFilled, isOptionalInput, isPluralInput } from './contracts';\nimport { gatingFieldsFromInputs } from './gating-fields';\nimport { fieldFilled, isFilled, mustBeFilled } from './readiness';\nimport { validateRunInputsSchema, type RunInputError } from './gate-validator';\nimport { healStringWrappers, pruneEmptyOptionals } from './wire-format';\nimport { prepareSchemaForRjsf } from './normalize-schema';\nimport { ownProp } from './own-property';\nimport type { PipeIOContract, PipeInputContract } from './contracts';\n\ntype Dict = Record<string, unknown>;\n\n/**\n * Combine the per-input schemas into one object schema.\n *\n * Each input variable becomes a property, titled with the variable name and\n * described with the concept code. Only the inputs the method actually demands\n * land in `required` - an optional (`?`) or variable-plural (`[]`) input must\n * not block the form (see `inputMustBeFilled`).\n *\n * The per-input schema travels verbatim, which is how a fixed-count (`[N]`)\n * list's declared count reaches ajv: pipelex states it as `minItems`/`maxItems`\n * on the array wrapper, so the count is enforced here without the kernel\n * restating it.\n */\nexport function buildRunInputsSchema(inputs: Record<string, PipeInputContract>): Dict {\n  const properties: Dict = {};\n  const required: string[] = [];\n\n  for (const [varName, input] of Object.entries(inputs)) {\n    const inputSchema = { ...input.json_schema } as Dict;\n    inputSchema.title = varName;\n    if (input.concept_ref && input.concept_ref !== varName) {\n      inputSchema.description = input.concept_ref;\n    }\n    properties[varName] = inputSchema;\n    if (inputMustBeFilled(input)) required.push(varName);\n  }\n\n  return prepareSchemaForRjsf({ type: 'object', properties, required });\n}\n\n/**\n * Last-gate repair, in two passes against the exact schema ajv validates.\n *\n * 1. **HEAL** - persisted `inputData` may still carry the legacy double-wrapped\n *    `{ text: { text } }` shape (or a form's state may lag a store fix).\n * 2. **PRUNE** - RJSF fills every unset string with `\"\"` on mount, which an\n *    optional CONSTRAINED field rejects (`DateContent.time` is `format: \"time\"`)\n *    - blocking a run on a field the user never opened. An absent optional field\n *    is what pipelex means by `None` anyway, so dropping it is the semantically\n *    correct repair, not a validation dodge.\n */\nexport function prepareRunInputs(data: Dict, schema: Dict): Dict {\n  return pruneEmptyOptionals(healStringWrappers(data, schema), schema) as Dict;\n}\n\nexport interface RunInputsVerdict {\n  isValid: boolean;\n  /** Variable names the scan could pin a missing required field on. */\n  missingInputs: string[];\n  /** Raw ajv errors, for when the scan cannot name anything. */\n  errors: RunInputError[];\n}\n\n/**\n * Validate PREPARED data against the combined schema.\n *\n * `missingInputs` is reported by VARIABLE NAME - the name on the node the user\n * clicks - never by `concept_ref`, which used to produce \"Missing required\n * fields in: native.Text\" and named neither the input at fault nor, when several\n * inputs share a concept, which of them. Inputs the method declared omittable\n * are skipped: an empty `?` input is not a missing one.\n *\n * The scan can come up empty even on an invalid form (a wrong value shape, a\n * nested mismatch); `errors` is what the caller falls back to then, so a failure\n * is never undiagnosable.\n *\n * `preparedData` is `unknown` for the same reason `gateRunInputs`' `data` is: on\n * a public endpoint the body is whatever was sent, and ajv must be shown that\n * rather than a repair of it, or `must be object` is a verdict no caller can\n * ever receive. The name-the-variable scan below needs something indexable, so\n * a body that is not a record scans against nothing and names every input the\n * method demands - which is the honest answer for a body that carried none.\n */\nexport function validateRunInputs(\n  preparedData: unknown,\n  inputs: Record<string, PipeInputContract>,\n  schema: Dict,\n): RunInputsVerdict {\n  const errors = validateRunInputsSchema(preparedData, schema);\n  if (errors.length === 0) return { isValid: true, missingInputs: [], errors: [] };\n\n  const record0 =\n    typeof preparedData === 'object' && preparedData !== null && !Array.isArray(preparedData)\n      ? (preparedData as Dict)\n      : undefined;\n  const missingInputs: string[] = [];\n  for (const [varName, input] of Object.entries(inputs)) {\n    if (!inputMustBeFilled(input)) continue;\n    const varData = ownProp(record0, varName);\n    // A demanded input that is not there at all is missing whatever its concept\n    // declares inside. The check has to come BEFORE the required-children one:\n    // a struct whose concept demands no child used to fall out of the scan\n    // here, so the run was refused by the combined schema's `required` list\n    // while the scan named nothing and the caller could only quote ajv.\n    if (varData == null) {\n      missingInputs.push(varName);\n      continue;\n    }\n    const inputSchema = input.json_schema as Dict;\n    const requiredFields = (inputSchema.required as string[]) || [];\n    if (requiredFields.length === 0) continue;\n    if (typeof varData !== 'object') {\n      missingInputs.push(varName);\n      continue;\n    }\n    const record = varData as Dict;\n    if (\n      requiredFields.some((f) => {\n        const child = ownProp(record, f);\n        return child === undefined || child === '';\n      })\n    ) {\n      missingInputs.push(varName);\n    }\n  }\n\n  return { isValid: false, missingInputs, errors };\n}\n\n/**\n * Build the `{ concept, content }` map a run expects, from PREPARED data.\n *\n * The two ways a method says \"this may be nothing\" land differently on the wire:\n * - an **optional (`?`)** input left blank is OMITTED, so the runtime records a\n *   real absence the method can branch on - sending `{ text: \"\" }` would look\n *   like the caller supplied an empty string;\n * - a **plural (`[]`)** input keeps its key, because a plural slot is never\n *   absent - its empty form IS the empty list, and the runtime requires the key.\n *   When that list is EMPTY it is sent BARE, without the envelope: the envelope\n *   is the runtime's \"explicit form\", which bypasses the top-down shaper and\n *   hands the value to the bottom-up factory, and that factory types a list from\n *   its first item - so an empty list there raises \"Cannot create Stuff from\n *   empty list in content\". The bare form keeps the shaper, which reads the\n *   DECLARED concept and builds the empty list correctly. (pipelex/#1096 makes\n *   the envelope agree; the bare form runs today and stays correct after.)\n *\n * A fixed-count (`[N]`) list takes that same empty-list path, and an empty one\n * is not a payload the method can accept. It is unreachable through the gate,\n * which demands the input and rejects a short list on `minItems`; building the\n * payload straight from unvalidated data is what would reach it, and inventing\n * a different absence here would only hide that.\n */\nexport function apiInputsFromSchemaData(\n  preparedData: Dict,\n  inputs: Record<string, PipeInputContract>,\n): Dict {\n  const out: Dict = {};\n  for (const [varName, input] of Object.entries(inputs)) {\n    const raw = ownProp(preparedData, varName);\n    if (isOptionalInput(input) && !isFilled(raw)) continue;\n    if (isPluralInput(input) && !isFilled(raw)) {\n      out[varName] = [];\n      continue;\n    }\n    const content = isPluralInput(input) && !Array.isArray(raw) ? [] : raw;\n    out[varName] = { concept: input.concept_ref, content };\n  }\n  return out;\n}\n\n// ─── The whole chain, as one call ────────────────────────────────────────────\n\n/** The gate's verdict: the payload to send, or why the run may not start. */\nexport type RunInputsGateResult =\n  | { ok: true; inputs: Dict }\n  | {\n      ok: false;\n      /** Variable names the caller left empty or short. */\n      missingInputs: string[];\n      /** Raw ajv errors, for when the scan cannot name anything. */\n      errors: RunInputError[];\n      /** The repaired data the verdict was reached on - what\n       *  `describeValidationError` needs to quote the value it received. */\n      preparedData: Dict;\n    };\n\n/**\n * One schema object per contract, for the lifetime of the process.\n *\n * `buildRunInputsSchema` is a pure function of the contract, so rebuilding it is\n * *semantically* free - but validation runs through a module-level ajv whose\n * compiled-schema cache is keyed on **schema object identity** and is never\n * evicted. A fresh object per call therefore misses every time and retains\n * another compiled validator. On a publicly callable server endpoint that is\n * unbounded growth driven by the cheapest request there is: an empty body,\n * rejected in a fraction of a millisecond, costing nothing to send.\n *\n * Weakly keyed so the map never pins a contract that goes out of scope. The\n * schema a run has been gated against is pinned for the process lifetime anyway\n * by ajv's own cache; the point is that the NUMBER of them is bounded by the\n * number of distinct contracts rather than by traffic.\n */\nconst SCHEMA_CACHE = new WeakMap<PipeIOContract, Dict>();\n\nfunction schemaForContract(contract: PipeIOContract): Dict {\n  const cached = SCHEMA_CACHE.get(contract);\n  if (cached) return cached;\n  const schema = buildRunInputsSchema(contract.inputs);\n  SCHEMA_CACHE.set(contract, schema);\n  return schema;\n}\n\n/**\n * Gate a run: repair the caller's data, validate it against the contract,\n * refuse anything the Run button would have refused, and build the payload.\n *\n * Returns a verdict rather than throwing. A server endpoint must not throw\n * across the boundary to its client - frameworks routinely strip the message to\n * an opaque digest in a production build - and a rejection here is an ordinary\n * outcome, not an exceptional one.\n *\n * **`data` is `unknown` because that is what it is.** A run endpoint is public\n * and no framework enforces a declared parameter type, so the argument is\n * whatever the caller put in the body. The chain indexes the payload by\n * variable name without first checking it is indexable, so a `null` body would\n * throw *after* ajv had already reported `must be object` and before any\n * verdict came back.\n *\n * So the two uses are separated rather than collapsed into one repair. **ajv\n * judges the value the caller actually sent**, which is what makes `must be\n * object` the verdict for a body that is not one; the indexing that follows\n * uses a safe `{}` stand-in, which is what keeps the gate from throwing. Repair\n * FIRST - coercing a non-object to `{}` before validating - is the shape that\n * looks equivalent and is not: a contract whose inputs are all optional has an\n * empty `required` list, so `{}` validates, and `gateRunInputs(\"garbage\", …)`\n * came back `ok: true` on a body the caller never meant as a run. Fail-closed\n * costs a malformed caller an error it earned; the other direction bills a run.\n *\n * **The schema alone is not the rule.** ajv's `required` asserts only that a\n * key is PRESENT, and a content model carries no `minLength` - so a required\n * input that arrived empty (`{document: {url: \"\"}}`, `{text: {text: \"\"}}`)\n * satisfies the schema. That is the natural payload, not a contrived one:\n * `rjsfDataFromRunValues({}, fields)` emits exactly that when nothing is\n * selected. So the gate re-applies the emptiness rule using\n * `computeReadiness`'s OWN two functions over the same derived fields, which is\n * the only way to be sure the two sides cannot disagree.\n *\n * Picking a pair that merely looks equivalent is not enough, and this is the\n * whole reason the assembly lives here rather than in each host: the obvious\n * choice, `inputMustBeFilled` + `isFilled`, agrees on every leaf kind and\n * diverges on a structured concept in BOTH directions - `isFilled` on an object\n * is `some(child filled)` where `fieldFilled` is `every(required child\n * filled)`. That accepts a half-filled struct the browser refuses (a paid run\n * past a disabled button) and rejects a filled all-optional struct the browser\n * accepts. A host whose methods happen to use only native concepts has no test\n * that can catch either.\n */\nexport function gateRunInputs(contract: PipeIOContract, data: unknown): RunInputsGateResult {\n  const isRecord = typeof data === 'object' && data !== null && !Array.isArray(data);\n  const payload = isRecord ? (data as Dict) : {};\n  const schema = schemaForContract(contract);\n  const preparedData = prepareRunInputs(payload, schema);\n\n  // The value ajv is shown is the caller's, not the stand-in - see above.\n  const verdict = validateRunInputs(isRecord ? preparedData : data, contract.inputs, schema);\n  if (!verdict.isValid) {\n    return {\n      ok: false,\n      missingInputs: verdict.missingInputs,\n      errors: verdict.errors,\n      preparedData,\n    };\n  }\n\n  // The SELECTION is half the rule, and leaving it out is what made the two\n  // halves disagree. `computeReadiness` reckons with an input the method\n  // demands AND one it left optional that the user has touched - because a\n  // structure with something in it owes its concept every field the concept\n  // declares. Filtering on `mustBeFilled` alone dropped the second kind, so a\n  // half-filled optional struct was refused by the button and accepted here.\n  //\n  // ajv cannot cover for it: a required child that is a plain string arrives as\n  // `''`, which satisfies `required`. And the payload builder below then SENDS\n  // that input, because `isFilled` is exactly what it tests. Which is the rule\n  // stated properly: the gate holds to its concept precisely the inputs it is\n  // about to put on the wire, and nothing it will omit.\n  //\n  // The tree the predicates run over is the gate's own, walked structurally\n  // from the same `json_schema` ajv just validated - NOT the render tree, which\n  // is built from the input-form descriptor. A server validating a payload must\n  // never need that presentation artifact; see `gating-fields.ts`.\n  const missingInputs = gatingFieldsFromInputs(contract.inputs)\n    .filter((field) => mustBeFilled(field) || isFilled(ownProp(preparedData, field.name)))\n    .filter((field) => !fieldFilled(field, ownProp(preparedData, field.name)))\n    .map((field) => field.name);\n  if (missingInputs.length) return { ok: false, missingInputs, errors: [], preparedData };\n\n  return { ok: true, inputs: apiInputsFromSchemaData(preparedData, contract.inputs) };\n}\n"]}
+{"version":3,"sources":["../src/core/gate.ts"],"names":[],"mappings":"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","file":"chunk-XIWBKV7T.js","sourcesContent":["/**\n * The gate every run passes through, whichever surface starts it.\n *\n * A host may offer more than one place to run a method - a schema-driven\n * inputs panel (an RJSF form) and a standalone run page (a bespoke field\n * renderer), say. **Only the rendering of inputs differs.** Everything between\n * \"the user pressed Run\" and \"the payload goes on the wire\" lives here, so\n * those surfaces cannot drift:\n *\n *   1. `buildRunInputsSchema` - the combined JSON Schema, whose `required` list\n *      is `inputMustBeFilled` (optional `?` and variable-plural `[]` never\n *      block; a fixed-count `[N]` list does).\n *   2. `prepareRunInputs` - heal legacy wrappers, then prune empty optionals.\n *   3. `validateRunInputs` - ajv, plus the missing-input scan that names the\n *      VARIABLE at fault.\n *   4. `apiInputsFromSchemaData` - the `{concept, content}` payload, built from\n *      the PREPARED data so the pruning reaches the wire too.\n *\n * **`gateRunInputs` is that whole chain as one call**, and it is what a server\n * should use. The four steps stay exported because a host that renders its own\n * panel needs the schema and the verdict separately, but assembling them is not\n * a host's job: the step between validation and the payload is an emptiness\n * check with four look-alike predicates to choose from, only two of which are\n * the ones the Run button reads, and choosing the near-miss pair produces a\n * server that is more permissive than the button in front of it.\n *\n * This module is pure: no React, no toasts, no i18n. Each caller renders the\n * verdict in its own idiom.\n */\nimport { inputMustBeFilled, isOptionalInput, isPluralInput } from './contracts';\nimport { gatingFieldsFromInputs } from './gating-fields';\nimport { fieldFilled, isFilled, mustBeFilled } from './readiness';\nimport { validateRunInputsSchema, type RunInputError } from './gate-validator';\nimport { healStringWrappers, pruneEmptyOptionals } from './wire-format';\nimport { prepareSchemaForRjsf } from './normalize-schema';\nimport { ownProp } from './own-property';\nimport type { PipeIOContract, PipeInputContract } from './contracts';\n\ntype Dict = Record<string, unknown>;\n\n/**\n * Combine the per-input schemas into one object schema.\n *\n * Each input variable becomes a property, titled with the variable name and\n * described with the concept code. Only the inputs the method actually demands\n * land in `required` - an optional (`?`) or variable-plural (`[]`) input must\n * not block the form (see `inputMustBeFilled`).\n *\n * The per-input schema travels verbatim, which is how a fixed-count (`[N]`)\n * list's declared count reaches ajv: pipelex states it as `minItems`/`maxItems`\n * on the array wrapper, so the count is enforced here without the kernel\n * restating it.\n */\nexport function buildRunInputsSchema(inputs: Record<string, PipeInputContract>): Dict {\n  const properties: Dict = {};\n  const required: string[] = [];\n\n  for (const [varName, input] of Object.entries(inputs)) {\n    const inputSchema = { ...input.json_schema } as Dict;\n    inputSchema.title = varName;\n    if (input.concept_ref && input.concept_ref !== varName) {\n      inputSchema.description = input.concept_ref;\n    }\n    properties[varName] = inputSchema;\n    if (inputMustBeFilled(input)) required.push(varName);\n  }\n\n  return prepareSchemaForRjsf({ type: 'object', properties, required });\n}\n\n/**\n * Last-gate repair, in two passes against the exact schema ajv validates.\n *\n * 1. **HEAL** - persisted `inputData` may still carry the legacy double-wrapped\n *    `{ text: { text } }` shape (or a form's state may lag a store fix).\n * 2. **PRUNE** - RJSF fills every unset string with `\"\"` on mount, which an\n *    optional CONSTRAINED field rejects (`DateContent.time` is `format: \"time\"`)\n *    - blocking a run on a field the user never opened. An absent optional field\n *    is what pipelex means by `None` anyway, so dropping it is the semantically\n *    correct repair, not a validation dodge.\n */\nexport function prepareRunInputs(data: Dict, schema: Dict): Dict {\n  return pruneEmptyOptionals(healStringWrappers(data, schema), schema) as Dict;\n}\n\nexport interface RunInputsVerdict {\n  isValid: boolean;\n  /** Variable names the scan could pin a missing required field on. */\n  missingInputs: string[];\n  /** Raw ajv errors, for when the scan cannot name anything. */\n  errors: RunInputError[];\n}\n\n/**\n * Validate PREPARED data against the combined schema.\n *\n * `missingInputs` is reported by VARIABLE NAME - the name on the node the user\n * clicks - never by `concept_ref`, which used to produce \"Missing required\n * fields in: native.Text\" and named neither the input at fault nor, when several\n * inputs share a concept, which of them. Inputs the method declared omittable\n * are skipped: an empty `?` input is not a missing one.\n *\n * The scan can come up empty even on an invalid form (a wrong value shape, a\n * nested mismatch); `errors` is what the caller falls back to then, so a failure\n * is never undiagnosable.\n *\n * `preparedData` is `unknown` for the same reason `gateRunInputs`' `data` is: on\n * a public endpoint the body is whatever was sent, and ajv must be shown that\n * rather than a repair of it, or `must be object` is a verdict no caller can\n * ever receive. The name-the-variable scan below needs something indexable, so\n * a body that is not a record scans against nothing and names every input the\n * method demands - which is the honest answer for a body that carried none.\n */\nexport function validateRunInputs(\n  preparedData: unknown,\n  inputs: Record<string, PipeInputContract>,\n  schema: Dict,\n): RunInputsVerdict {\n  const errors = validateRunInputsSchema(preparedData, schema);\n  if (errors.length === 0) return { isValid: true, missingInputs: [], errors: [] };\n\n  const record0 =\n    typeof preparedData === 'object' && preparedData !== null && !Array.isArray(preparedData)\n      ? (preparedData as Dict)\n      : undefined;\n  const missingInputs: string[] = [];\n  for (const [varName, input] of Object.entries(inputs)) {\n    if (!inputMustBeFilled(input)) continue;\n    const varData = ownProp(record0, varName);\n    // A demanded input that is not there at all is missing whatever its concept\n    // declares inside. The check has to come BEFORE the required-children one:\n    // a struct whose concept demands no child used to fall out of the scan\n    // here, so the run was refused by the combined schema's `required` list\n    // while the scan named nothing and the caller could only quote ajv.\n    if (varData == null) {\n      missingInputs.push(varName);\n      continue;\n    }\n    const inputSchema = input.json_schema as Dict;\n    const requiredFields = (inputSchema.required as string[]) || [];\n    if (requiredFields.length === 0) continue;\n    if (typeof varData !== 'object') {\n      missingInputs.push(varName);\n      continue;\n    }\n    const record = varData as Dict;\n    if (\n      requiredFields.some((f) => {\n        const child = ownProp(record, f);\n        return child === undefined || child === '';\n      })\n    ) {\n      missingInputs.push(varName);\n    }\n  }\n\n  return { isValid: false, missingInputs, errors };\n}\n\n/**\n * Build the `{ concept, content }` map a run expects, from PREPARED data.\n *\n * The two ways a method says \"this may be nothing\" land differently on the wire:\n * - an **optional (`?`)** input left blank is OMITTED, so the runtime records a\n *   real absence the method can branch on - sending `{ text: \"\" }` would look\n *   like the caller supplied an empty string;\n * - a **plural (`[]`)** input keeps its key, because a plural slot is never\n *   absent - its empty form IS the empty list, and the runtime requires the key.\n *   When that list is EMPTY it is sent BARE, without the envelope: the envelope\n *   is the runtime's \"explicit form\", which bypasses the top-down shaper and\n *   hands the value to the bottom-up factory, and that factory types a list from\n *   its first item - so an empty list there raises \"Cannot create Stuff from\n *   empty list in content\". The bare form keeps the shaper, which reads the\n *   DECLARED concept and builds the empty list correctly. (pipelex/#1096 makes\n *   the envelope agree; the bare form runs today and stays correct after.)\n *\n * A fixed-count (`[N]`) list takes that same empty-list path, and an empty one\n * is not a payload the method can accept. It is unreachable through the gate,\n * which demands the input and rejects a short list on `minItems`; building the\n * payload straight from unvalidated data is what would reach it, and inventing\n * a different absence here would only hide that.\n */\nexport function apiInputsFromSchemaData(\n  preparedData: Dict,\n  inputs: Record<string, PipeInputContract>,\n): Dict {\n  const out: Dict = {};\n  for (const [varName, input] of Object.entries(inputs)) {\n    const raw = ownProp(preparedData, varName);\n    if (isOptionalInput(input) && !isFilled(raw)) continue;\n    if (isPluralInput(input) && !isFilled(raw)) {\n      out[varName] = [];\n      continue;\n    }\n    const content = isPluralInput(input) && !Array.isArray(raw) ? [] : raw;\n    out[varName] = { concept: input.concept_ref, content };\n  }\n  return out;\n}\n\n// ─── The whole chain, as one call ────────────────────────────────────────────\n\n/** The gate's verdict: the payload to send, or why the run may not start. */\nexport type RunInputsGateResult =\n  | { ok: true; inputs: Dict }\n  | {\n      ok: false;\n      /** Variable names the caller left empty or short. */\n      missingInputs: string[];\n      /** Raw ajv errors, for when the scan cannot name anything. */\n      errors: RunInputError[];\n      /** The repaired data the verdict was reached on - what\n       *  `describeValidationError` needs to quote the value it received. */\n      preparedData: Dict;\n    };\n\n/**\n * One schema object per contract, for the lifetime of the process.\n *\n * `buildRunInputsSchema` is a pure function of the contract, so rebuilding it is\n * *semantically* free - but validation runs through a module-level ajv whose\n * compiled-schema cache is keyed on **schema object identity** and is never\n * evicted. A fresh object per call therefore misses every time and retains\n * another compiled validator. On a publicly callable server endpoint that is\n * unbounded growth driven by the cheapest request there is: an empty body,\n * rejected in a fraction of a millisecond, costing nothing to send.\n *\n * Weakly keyed so the map never pins a contract that goes out of scope. The\n * schema a run has been gated against is pinned for the process lifetime anyway\n * by ajv's own cache; the point is that the NUMBER of them is bounded by the\n * number of distinct contracts rather than by traffic.\n */\nconst SCHEMA_CACHE = new WeakMap<PipeIOContract, Dict>();\n\nfunction schemaForContract(contract: PipeIOContract): Dict {\n  const cached = SCHEMA_CACHE.get(contract);\n  if (cached) return cached;\n  const schema = buildRunInputsSchema(contract.inputs);\n  SCHEMA_CACHE.set(contract, schema);\n  return schema;\n}\n\n/**\n * Gate a run: repair the caller's data, validate it against the contract,\n * refuse anything the Run button would have refused, and build the payload.\n *\n * Returns a verdict rather than throwing. A server endpoint must not throw\n * across the boundary to its client - frameworks routinely strip the message to\n * an opaque digest in a production build - and a rejection here is an ordinary\n * outcome, not an exceptional one.\n *\n * **`data` is `unknown` because that is what it is.** A run endpoint is public\n * and no framework enforces a declared parameter type, so the argument is\n * whatever the caller put in the body. The chain indexes the payload by\n * variable name without first checking it is indexable, so a `null` body would\n * throw *after* ajv had already reported `must be object` and before any\n * verdict came back.\n *\n * So the two uses are separated rather than collapsed into one repair. **ajv\n * judges the value the caller actually sent**, which is what makes `must be\n * object` the verdict for a body that is not one; the indexing that follows\n * uses a safe `{}` stand-in, which is what keeps the gate from throwing. Repair\n * FIRST - coercing a non-object to `{}` before validating - is the shape that\n * looks equivalent and is not: a contract whose inputs are all optional has an\n * empty `required` list, so `{}` validates, and `gateRunInputs(\"garbage\", …)`\n * came back `ok: true` on a body the caller never meant as a run. Fail-closed\n * costs a malformed caller an error it earned; the other direction bills a run.\n *\n * **The schema alone is not the rule.** ajv's `required` asserts only that a\n * key is PRESENT, and a content model carries no `minLength` - so a required\n * input that arrived empty (`{document: {url: \"\"}}`, `{text: {text: \"\"}}`)\n * satisfies the schema. That is the natural payload, not a contrived one:\n * `rjsfDataFromRunValues({}, fields)` emits exactly that when nothing is\n * selected. So the gate re-applies the emptiness rule using\n * `computeReadiness`'s OWN two functions over the same derived fields, which is\n * the only way to be sure the two sides cannot disagree.\n *\n * Picking a pair that merely looks equivalent is not enough, and this is the\n * whole reason the assembly lives here rather than in each host: the obvious\n * choice, `inputMustBeFilled` + `isFilled`, agrees on every leaf kind and\n * diverges on a structured concept in BOTH directions - `isFilled` on an object\n * is `some(child filled)` where `fieldFilled` is `every(required child\n * filled)`. That accepts a half-filled struct the browser refuses (a paid run\n * past a disabled button) and rejects a filled all-optional struct the browser\n * accepts. A host whose methods happen to use only native concepts has no test\n * that can catch either.\n */\nexport function gateRunInputs(contract: PipeIOContract, data: unknown): RunInputsGateResult {\n  const isRecord = typeof data === 'object' && data !== null && !Array.isArray(data);\n  const payload = isRecord ? (data as Dict) : {};\n  const schema = schemaForContract(contract);\n  const preparedData = prepareRunInputs(payload, schema);\n\n  // The value ajv is shown is the caller's, not the stand-in - see above.\n  const verdict = validateRunInputs(isRecord ? preparedData : data, contract.inputs, schema);\n  if (!verdict.isValid) {\n    return {\n      ok: false,\n      missingInputs: verdict.missingInputs,\n      errors: verdict.errors,\n      preparedData,\n    };\n  }\n\n  // The SELECTION is half the rule, and leaving it out is what made the two\n  // halves disagree. `computeReadiness` reckons with an input the method\n  // demands AND one it left optional that the user has touched - because a\n  // structure with something in it owes its concept every field the concept\n  // declares. Filtering on `mustBeFilled` alone dropped the second kind, so a\n  // half-filled optional struct was refused by the button and accepted here.\n  //\n  // ajv cannot cover for it: a required child that is a plain string arrives as\n  // `''`, which satisfies `required`. And the payload builder below then SENDS\n  // that input, because `isFilled` is exactly what it tests. Which is the rule\n  // stated properly: the gate holds to its concept precisely the inputs it is\n  // about to put on the wire, and nothing it will omit.\n  //\n  // The tree the predicates run over is the gate's own, walked structurally\n  // from the same `json_schema` ajv just validated - NOT the render tree, which\n  // is built from the input-form descriptor. A server validating a payload must\n  // never need that presentation artifact; see `gating-fields.ts`.\n  const missingInputs = gatingFieldsFromInputs(contract.inputs)\n    .filter((field) => mustBeFilled(field) || isFilled(ownProp(preparedData, field.name)))\n    .filter((field) => !fieldFilled(field, ownProp(preparedData, field.name)))\n    .map((field) => field.name);\n  if (missingInputs.length) return { ok: false, missingInputs, errors: [], preparedData };\n\n  return { ok: true, inputs: apiInputsFromSchemaData(preparedData, contract.inputs) };\n}\n"]}

package/dist/{chunk-4SRSGZWM.js → chunk-XYS5KCXB.js}

@@ -1,5 +1,6 @@
 import { isNativeValueNode, readDateContent, formatDateContent, isNativeHtmlNode, isNativeDateNode, isNativeCompositeNode } from './chunk-QQK6Y55E.js';
-import { APP_STYLES } from './chunk-3GO65HWP.js';
+import { APP_STYLES } from './chunk-PNNWNRPG.js';
+import { isFilled } from './chunk-TF4RTKLH.js';
 import { hasOwnProp } from './chunk-V3OV2XQT.js';
 import { defineSchema, defineCatalog, validateSpec, compileSpecStream } from '@json-render/core';
 import { z } from 'zod';
@@ -958,9 +959,10 @@ function condBranches(value) {
 }
 
 // src/generative/share-amount.ts
+var DECIMAL = /^[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?$/i;
 function shareAmount(raw) {
   if (typeof raw === "number") return raw;
-  if (typeof raw === "string" && raw.trim() !== "") return Number(raw);
+  if (typeof raw === "string" && DECIMAL.test(raw.trim())) return Number(raw);
   return Number.NaN;
 }
 
@@ -980,6 +982,9 @@ function isRecord(value) {
 }
 function specMalformation(spec) {
   if (!isRecord(spec)) return `it is ${shown(spec)}, not a structure`;
+  if (spec.root !== void 0 && typeof spec.root !== "string") {
+    return `its "root" is ${shown(spec.root)}, not an element's key`;
+  }
   if (!isRecord(spec.elements)) return 'it has no "elements" map';
   for (const [key, element] of Object.entries(spec.elements)) {
     const at = JSON.stringify(key);
@@ -990,15 +995,26 @@ function specMalformation(spec) {
       return `the element ${at} has "props" that are not a structure`;
     if (children != null && !Array.isArray(children))
       return `the element ${at} has "children" that are not a list`;
+    const child = Array.isArray(children) ? firstNotAKey(children) : void 0;
+    if (child)
+      return `the element ${at} has a child that is ${shown(child.entry)}, not an element's key`;
     if (slots != null && (!isRecord(slots) || !Object.values(slots).every(Array.isArray))) {
       return `the element ${at} has "slots" that are not lists`;
     }
+    const slotted = isRecord(slots) ? firstNotAKey(Object.values(slots).flatMap((entries) => entries)) : void 0;
+    if (slotted) {
+      return `the element ${at} has a slot entry that is ${shown(slotted.entry)}, not an element's key`;
+    }
     if (repeat !== void 0 && !repeatsOver(repeat)) {
       return `the element ${at} has a "repeat" that names no "statePath"`;
     }
   }
   return void 0;
 }
+function firstNotAKey(entries) {
+  for (const entry of entries) if (typeof entry !== "string") return { entry };
+  return void 0;
+}
 function repeatsOver(repeat) {
   if (!isRecord(repeat)) return false;
   const { statePath } = repeat;
@@ -1325,27 +1341,67 @@ function nonScalarReads(spec, parents, root, fieldAt) {
       const branches = depth < MAX_COND_DEPTH ? condBranches(value) : void 0;
       return branches ? branches.flatMap((branch) => outcomes(branch, depth + 1)) : [value];
     };
+    const amountPathRefusal = (path) => {
+      const field = isUnder(root, path) ? fieldAt(path) : void 0;
+      if (field && field.kind !== "number" && field.kind !== "unknown") {
+        return `reads ${path}, which holds ${kindWords(field.kind)}, not a number`;
+      }
+      return void 0;
+    };
+    const amountRefusal = (amount) => {
+      if (Number.isFinite(shareAmount(amount)) || readsIndex(amount)) return void 0;
+      const path = readPath(amount);
+      if (path === void 0) {
+        const shown2 = isExpression(amount) ? "an expression that reads no number" : String(JSON.stringify(amount ?? null));
+        return `is ${shown2}, not a number`;
+      }
+      return amountPathRefusal(path);
+    };
+    if (element.type === "ProportionBar") {
+      const props = element.props ?? {};
+      for (const prop of ["total", "of"]) {
+        const refusals = outcomes(props[prop]).filter((outcome) => outcome !== null && outcome !== void 0).map(
+          (outcome) => readsIndex(outcome) ? "is the repeat's index, not an amount" : amountRefusal(outcome)
+        ).filter((refusal) => refusal !== void 0);
+        for (const refusal of new Set(refusals)) {
+          problems.push(
+            `${key}: ProportionBar's ${prop} ${refusal}; a total or a ceiling is a number, or reads a path that holds one with { "$state" }`
+          );
+        }
+      }
+    }
     const inlineShares = (entries) => {
       if (element.type !== "ProportionBar") return entries;
       const { labelKey, valueKey } = element.props ?? {};
       if (typeof labelKey !== "string" || typeof valueKey !== "string") return entries;
       const how = `each part is written as a structure with ${memberWords(labelKey)} member and ${memberWords(valueKey)} member holding a number, or the whole list is read with { "$state" }`;
-      const amountRefused = (part, amount) => {
-        if (Number.isFinite(shareAmount(amount)) || readsIndex(amount)) return false;
-        const path = readPath(amount);
-        if (path === void 0) {
-          const shown2 = isExpression(amount) ? "an expression that reads no number" : String(JSON.stringify(amount ?? null));
-          problems.push(`${part}'s ${JSON.stringify(valueKey)} is ${shown2}, not a number; ${how}`);
-          return true;
+      const templateAmount = (amount) => {
+        if (expressionForm(amount) !== "$template") return void 0;
+        const text = amount.$template;
+        const sole = /^\s*(\$\{[^}]+\})\s*$/.exec(text)?.[1];
+        if (sole !== void 0) {
+          const [path] = interpolatedPaths(sole, itemPath);
+          return path === void 0 ? "more" : { path };
         }
-        const field = isUnder(root, path) ? fieldAt(path) : void 0;
-        if (field && field.kind !== "number" && field.kind !== "unknown") {
-          problems.push(
-            `${part}'s ${JSON.stringify(valueKey)} reads ${path}, which holds ${kindWords(field.kind)}, not a number; ${how}`
-          );
-          return true;
+        return interpolatedPaths(text, itemPath).length > 0 ? "more" : { text };
+      };
+      const inlineAmountRefusal = (amount) => {
+        if (expressionForm(amount) === "$computed") {
+          return "is a $computed, which a page has no function to resolve, not a number";
         }
-        return false;
+        const written = templateAmount(amount);
+        if (written === void 0) return amountRefusal(amount);
+        if (written === "more") {
+          return "is a template that writes text beside its value, not a number";
+        }
+        if ("path" in written) return amountPathRefusal(written.path);
+        return Number.isFinite(shareAmount(written.text)) ? void 0 : `is a template that writes ${JSON.stringify(written.text)} out, not a number`;
+      };
+      const amountRefused = (part, amount) => {
+        const refusal = inlineAmountRefusal(amount);
+        if (refusal === void 0) return false;
+        problems.push(`${part}'s ${JSON.stringify(valueKey)} ${refusal}; ${how}`);
+        return true;
       };
       const sharePart = (part, entry) => {
         if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
@@ -1413,6 +1469,7 @@ function nonScalarReads(spec, parents, root, fieldAt) {
       }
     };
     for (const [prop, value] of Object.entries(element.props ?? {})) {
+      if (element.type === "ProportionBar" && (prop === "total" || prop === "of")) continue;
       const items = listy?.get(prop);
       if (items === void 0 || Array.isArray(value)) {
         walk(prop, prop === "items" && Array.isArray(value) ? inlineShares(value) : value);
@@ -1472,10 +1529,16 @@ function isOffered(path, offered) {
   if (offered.bound.has(path) || offered.repeated.has(path)) return true;
   return offered.delegated.some((at) => path === at || path.startsWith(`${at}/`));
 }
-function uncoveredUnder(field, path, offered) {
+function uncoveredUnder(field, path, offered, seeded) {
   if (isOffered(path, offered)) return [];
   if (field.kind === "object") {
-    return field.fields.filter((child) => child.required).flatMap((child) => uncoveredUnder(child, joinPath(path, child.name), offered));
+    const seededBelow = seeded && field.required && field.defaultValue === void 0;
+    const under = (child) => uncoveredUnder(child, joinPath(path, child.name), offered, seededBelow);
+    const required = field.fields.filter((child) => child.required);
+    if (required.length > 0) return required.flatMap(under);
+    return field.fields.some(
+      (child) => seededBelow && isFilled(child.defaultValue) || under(child).length === 0
+    ) ? [] : [path];
   }
   return [path];
 }
@@ -1490,14 +1553,75 @@ function descriptorMalformation(descriptor) {
   if (typeof descriptor !== "object" || descriptor === null) {
     return "the layout has no descriptor to be checked against";
   }
-  const { inputs, result } = descriptor;
-  if (inputs != null && !Array.isArray(inputs)) {
-    return `the descriptor's "inputs" is not a list of fields`;
+  try {
+    const budget = { fields: 0 };
+    const { inputs, result } = descriptor;
+    if (inputs != null && !Array.isArray(inputs)) {
+      return `the descriptor's "inputs" is not a list of fields`;
+    }
+    for (const [index, input] of (inputs ?? []).entries()) {
+      const problem = fieldMalformation(input, `input ${index + 1}`, /* @__PURE__ */ new Set(), budget);
+      if (problem !== void 0) return `the descriptor's ${problem}`;
+    }
+    if (result != null) {
+      if (!isField(result)) return `the descriptor's "result" is not a field`;
+      const problem = fieldMalformation(result, '"result"', /* @__PURE__ */ new Set(), budget);
+      if (problem !== void 0) return `the descriptor's ${problem}`;
+    }
+    return void 0;
+  } catch (error) {
+    let said;
+    try {
+      said = String(error);
+    } catch {
+      said = "an error that cannot be written out";
+    }
+    return `the descriptor cannot be read (${said})`;
   }
-  if (result != null && (typeof result !== "object" || Array.isArray(result) || typeof result.kind !== "string")) {
-    return `the descriptor's "result" is not a field`;
+}
+var MAX_FIELD_DEPTH = 64;
+var MAX_DESCRIPTOR_FIELDS = 1e4;
+function isField(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.kind === "string" && typeof value.name === "string";
+}
+function fieldMalformation(value, subject, ancestors, budget) {
+  if (++budget.fields > MAX_DESCRIPTOR_FIELDS) {
+    return `fields number more than ${MAX_DESCRIPTOR_FIELDS}, counted at each place one is held`;
+  }
+  if (!isField(value)) return `${subject} is not a field`;
+  const named = `${subject} (${JSON.stringify(value.name)})`;
+  if (ancestors.has(value)) return `${named} contains itself`;
+  if (ancestors.size >= MAX_FIELD_DEPTH) {
+    return `${named} is nested more than ${MAX_FIELD_DEPTH} fields deep`;
+  }
+  ancestors.add(value);
+  try {
+    if (value.kind === "object") {
+      const { fields } = value;
+      if (!Array.isArray(fields)) return `${named} has no list of member "fields"`;
+      for (const [index, member] of fields.entries()) {
+        const problem = fieldMalformation(
+          member,
+          `${named} member ${index + 1}`,
+          ancestors,
+          budget
+        );
+        if (problem !== void 0) return problem;
+      }
+    }
+    if (value.kind === "list") {
+      const problem = fieldMalformation(
+        value.item,
+        `${named} item`,
+        ancestors,
+        budget
+      );
+      if (problem !== void 0) return problem;
+    }
+    return void 0;
+  } finally {
+    ancestors.delete(value);
   }
-  return void 0;
 }
 function fitCheck(descriptor, spec) {
   try {
@@ -1581,7 +1705,7 @@ function collectLayoutProblems(descriptor, spec) {
   };
   for (const field of inputs) {
     if (!field.required) continue;
-    for (const path of uncoveredUnder(field, joinPath(INPUTS_ROOT, field.name), offered)) {
+    for (const path of uncoveredUnder(field, joinPath(INPUTS_ROOT, field.name), offered, true)) {
       problems.push(`${path} is required, and the layout offers nowhere to enter it`);
     }
   }
@@ -2072,12 +2196,15 @@ var REPAIR_ATTEMPTS = 2;
 function layoutCheck(spec, { frame, descriptor }) {
   const refused = (line) => ({ problems: [line], checksFailed: false });
   if (!FRAMES.includes(frame)) {
-    return refused(
-      `the layout names the frame ${JSON.stringify(frame)}, which is none of ${FRAMES.join(", ")}`
-    );
+    return {
+      problems: [
+        `the layout is checked against the frame ${JSON.stringify(frame)}, which is none of ${FRAMES.join(", ")}`
+      ],
+      checksFailed: true
+    };
   }
   const misshapen = descriptorMalformation(descriptor);
-  if (misshapen !== void 0) return refused(misshapen);
+  if (misshapen !== void 0) return { problems: [misshapen], checksFailed: true };
   const malformed = specMalformation(spec);
   if (malformed !== void 0) return refused(malformedLine(malformed));
   try {
@@ -2443,5 +2570,5 @@ function findFixture(fixtures, pipeRef, id) {
 }
 
 export { COMPONENT_NAMES, COMPONENT_RENDERINGS, COMPOSER_COMPONENTS, CUSTOM_COMPONENTS, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, FRAMES, FRAME_COMPONENTS, ICON_NAMES, INPUTS_ROOT, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, REPAIR_ATTEMPTS, RESULT_COMPONENTS, RESULT_ROOT, absoluteHatchPath, baseCatalog, catalog, componentNamesFor, definitionChain, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, frameCatalog, frameComponents, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutCheck, layoutCheckProblems, layoutFits, layoutProblems, payloadToState, promptHashSubject, repeatBasePathOf, resultBrief, resultFieldAtPath, seedLine, segmentsUnder, shareAmount, specFromJsonl, specToJsonl, unwrapped, validateAgainstCatalog };
-//# sourceMappingURL=chunk-4SRSGZWM.js.map
-//# sourceMappingURL=chunk-4SRSGZWM.js.map
+//# sourceMappingURL=chunk-XYS5KCXB.js.map
+//# sourceMappingURL=chunk-XYS5KCXB.js.map