ngx-t-forms-types 0.0.30 → 0.0.33

package/dist/interfaces/formInput/WorkflowDocumentPicker.d.ts

@@ -5,6 +5,8 @@ import { IBasicFormInput } from "./BasicFormInputInterface.js";
 export interface IWorkflowDocumentPicker extends IBasicFormInput {
     workflowPickerConfig: IWorkflowDocumentPickerConfig;
     [AllFormInputPrimaryKeys.AllowMultipleSelection]: boolean;
+    /** @see ISelectInputInterface.selectUpto */
+    selectUpto?: number;
 }
 /**
  * Document-picker configuration.

package/dist/schemas/FormInputSchema.js

@@ -1,6 +1,6 @@
 import Joi from 'joi';
-import { AllFormInputPrimaryKeys, SpecialElementKeys } from '../interfaces/FormBuilder/index.js';
-import { AdjudicationSteps, AutocapitalizeOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput/index.js';
+import { AllFormInputPrimaryKeys, FormInputKeys, SpecialElementKeys } from '../interfaces/FormBuilder/index.js';
+import { AdjudicationSteps, AutocapitalizeOptions, AutocompleteOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput/index.js';
 // import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface.js';
 // import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface.js';
 // import { MscoaInputConfigSchema } from './MscoaConfigSchema.js';
@@ -49,6 +49,45 @@ export const baseFormColumnInputsSchema = Joi.object({
     [AllFormInputPrimaryKeys.Max]: Joi.alternatives().try(Joi.number(), Joi.string(), Joi.date()).optional(),
     [AllFormInputPrimaryKeys.MinLength]: Joi.alternatives().try(Joi.number(), Joi.string()).optional(),
     [AllFormInputPrimaryKeys.MaxLength]: Joi.alternatives().try(Joi.number(), Joi.string()).optional(),
+    [FormInputKeys.Pattern]: Joi.string().allow('').optional(),
+    // --- presentation members declared on IBasicFormInput ----------------------
+    //
+    // These were declared on the interfaces and listed in DefaultInputConfig, but
+    // never here — and because Joi rejects unknown keys, a column carrying one
+    // failed the WHOLE form with '"Slides > Columns > Placeholder" is not
+    // allowed'. Empty strings are allowed throughout: the settings panel writes
+    // '' when an author clears a text row, and rejecting that made clearing a
+    // prefix a validation error.
+    [FormInputKeys.Placeholder]: Joi.string().allow('').optional(),
+    [FormInputKeys.Autocomplete]: Joi.string().valid(...Object.values(AutocompleteOptions)).optional(),
+    [FormInputKeys.Disabled]: Joi.boolean().optional(),
+    [FormInputKeys.PrefixText]: Joi.string().allow('').optional(),
+    [FormInputKeys.SuffixText]: Joi.string().allow('').optional(),
+    [FormInputKeys.PrefixIcon]: Joi.string().allow('').optional(),
+    [FormInputKeys.SuffixIcon]: Joi.string().allow('').optional(),
+    // Only meaningful alongside allowMultipleSelection; a single-selection
+    // control is already capped at one. `min(1)` because "select up to zero" is
+    // not a limit, it is a disabled control.
+    [FormInputKeys.SelectUpto]: Joi.number().integer().min(1).optional(),
+    // formControlNames of columns inside a multipleInput group to total.
+    [FormInputKeys.ShowTotalsOf]: Joi.array().items(Joi.string()).optional(),
+    // --- matrix table ---------------------------------------------------------
+    //
+    // Declared by IMatrixInput and accepted here so a stored form carrying either
+    // still validates. No element offers them: ElementTypes.MatrixTable is
+    // commented out of the enum, so nothing can currently be built with one.
+    //
+    // `columnsConfig` is keyed by column name and typed
+    // `TableColumnConfigInterface | any`, so its values are only checked to be
+    // objects — constraining them further here would reject the `any` half the
+    // interface explicitly permits.
+    [FormInputKeys.MatrixTableConfig]: Joi.object({
+        dataSource: Joi.string().required()
+    }).optional(),
+    [FormInputKeys.TableConfig]: Joi.object({
+        displayedColumnsInOrder: Joi.array().items(Joi.string()).required(),
+        columnsConfig: Joi.object().pattern(Joi.string(), Joi.object()).required()
+    }).optional(),
     [AllFormInputPrimaryKeys.LinkedSegmentId]: Joi.string().optional(),
     [AllFormInputPrimaryKeys.MscoaConfig]: MscoaInputConfigSchema.optional(),
     [AllFormInputPrimaryKeys.SystemDefault]: Joi.boolean().optional(),

package/dist/schemas/MatOptionsSchema.js

@@ -59,6 +59,13 @@ const APIDataFetchingConfigurationSchema = Joi.object({
     capturedQuery: queryTemplateSchema.optional(),
     // The endpoint's Postman description, verbatim; display-only (Docs tab).
     capturedDocs: Joi.string().allow('').optional(),
+    // Opt-out of the automatic read-only lock on a value the tower owns. On a
+    // SCALAR it is gap-filling on an 'api' slot: a manually entered value stands
+    // whenever the fetch contributes nothing. On a COMPLEX value (the input
+    // declares dataType 'object' or 'array') it is also offered on a 'local'
+    // slot, and the tower re-merges each new derived value over the live one as a
+    // delta instead of replacing it. Only meaningful on a value slot.
+    allowManualValueEntry: Joi.boolean().optional(),
     backEndConfig: Joi.object({
         // Optional: a 'template'-mode fetch shapes its body from payloadTemplate and
         // carries no mapping; GET fetches never had one. Readers default it to [].

package/dist/schemas/MscoaConfigSchema.js

@@ -16,6 +16,7 @@ export const DualCashExclusionRuleSchema = Joi.object({
     id: Joi.string().optional(),
     pattern: Joi.string().required(),
     flags: Joi.string().allow('').optional(),
+    matchField: Joi.string().allow('').optional(),
     segment: Joi.string().allow('').optional(),
     description: Joi.string().allow('').optional()
 });

package/dist/schemas/index.d.ts

@@ -1,4 +1,5 @@
 import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema.js";
 import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema.js";
 import { DatabaseFormSchema, FormSchema, validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema.js";
-export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };
+import { MscoaInputConfigSchema, validateMscoaInputConfig } from "./MscoaConfigSchema.js";
+export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration, MscoaInputConfigSchema, validateMscoaInputConfig };

package/dist/schemas/index.js

@@ -1,4 +1,5 @@
 import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema.js";
 import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema.js";
 import { DatabaseFormSchema, FormSchema, validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema.js";
-export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };
+import { MscoaInputConfigSchema, validateMscoaInputConfig } from "./MscoaConfigSchema.js";
+export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration, MscoaInputConfigSchema, validateMscoaInputConfig };

package/dist/skillet/authoring-rules.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Form-wide authoring rules from the Form Creation Guide, stated once.
+ *
+ * ## Why these are not on the members they concern
+ *
+ * Hashbrown names every hoisted `$defs` entry by camel-casing the node's
+ * DESCRIPTION, and every `$ref` repeats that name in full. A member shared by
+ * every element — `label`, `formControlName`, `colSize` — is referenced once
+ * per element per nesting level, so each character of its description is paid
+ * around forty times in the full column schema. Measured before this split,
+ * `$ref` names were 58% of the full schema and 44% of the common one, and the
+ * seven most-shared members accounted for most of that.
+ *
+ * So a shared member's description carries its definition and the one rule
+ * that has to be read at that member, and the guidance that applies across the
+ * form is stated here, on the root, which is emitted exactly once. The
+ * sentences are the guide's — see `doc/features/skillet-internals.md`, "Where
+ * the prose comes from" — and they are the ones a model needs before it writes
+ * any field rather than while it writes one.
+ *
+ * `createFormDraftSchema()` composes these into the form's description. A
+ * caller using `createColumnSchema()` on its own has no root to carry them and
+ * should put {@link describeAuthoringRules} in the system prompt instead.
+ */
+/**
+ * The shape of a control name: lowerCamelCase, letters and digits only.
+ *
+ * Narrower than the engine, which also allows underscores — narrower is the
+ * permitted direction, and one convention is easier to follow than two.
+ * Exported so a test can hold the reserved-names rule to it: a reserved name
+ * the pattern would accept must be named in the rules, and one it rejects
+ * need not be.
+ */
+export declare const CONTROL_NAME_PATTERN = "^[a-z][a-zA-Z0-9]*$";
+/**
+ * The rules, one sentence group each, in the order the guide states them:
+ * naming, words, types, what the engine reads, layout, error timing.
+ */
+export declare const AUTHORING_RULES: readonly string[];
+/** The rules as one paragraph, for a form description or a system prompt. */
+export declare function describeAuthoringRules(): string;

package/dist/skillet/authoring-rules.js

@@ -0,0 +1,61 @@
+import { RESERVED_CONTROL_NAMES } from './workflow-context.js';
+/**
+ * Form-wide authoring rules from the Form Creation Guide, stated once.
+ *
+ * ## Why these are not on the members they concern
+ *
+ * Hashbrown names every hoisted `$defs` entry by camel-casing the node's
+ * DESCRIPTION, and every `$ref` repeats that name in full. A member shared by
+ * every element — `label`, `formControlName`, `colSize` — is referenced once
+ * per element per nesting level, so each character of its description is paid
+ * around forty times in the full column schema. Measured before this split,
+ * `$ref` names were 58% of the full schema and 44% of the common one, and the
+ * seven most-shared members accounted for most of that.
+ *
+ * So a shared member's description carries its definition and the one rule
+ * that has to be read at that member, and the guidance that applies across the
+ * form is stated here, on the root, which is emitted exactly once. The
+ * sentences are the guide's — see `doc/features/skillet-internals.md`, "Where
+ * the prose comes from" — and they are the ones a model needs before it writes
+ * any field rather than while it writes one.
+ *
+ * `createFormDraftSchema()` composes these into the form's description. A
+ * caller using `createColumnSchema()` on its own has no root to carry them and
+ * should put {@link describeAuthoringRules} in the system prompt instead.
+ */
+/**
+ * The shape of a control name: lowerCamelCase, letters and digits only.
+ *
+ * Narrower than the engine, which also allows underscores — narrower is the
+ * permitted direction, and one convention is easier to follow than two.
+ * Exported so a test can hold the reserved-names rule to it: a reserved name
+ * the pattern would accept must be named in the rules, and one it rejects
+ * need not be.
+ */
+export const CONTROL_NAME_PATTERN = '^[a-z][a-zA-Z0-9]*$';
+/**
+ * The reserved names the pattern alone does not stop.
+ *
+ * `_id` and the `SYSTEM_*` inputs fail the pattern and need no mention;
+ * `reference`, `status` and `data` pass it, so the rule has to carry them.
+ * Filtered at evaluation rather than listed by hand, so the sentence says
+ * exactly what the pattern leaves open — no more, which would be noise, and no
+ * less, which would be a hole.
+ */
+const RESERVED_WELL_FORMED_NAMES = RESERVED_CONTROL_NAMES.filter((name) => new RegExp(CONTROL_NAME_PATTERN).test(name));
+/**
+ * The rules, one sentence group each, in the order the guide states them:
+ * naming, words, types, what the engine reads, layout, error timing.
+ */
+export const AUTHORING_RULES = [
+    `Control names are unique across the whole form and across every other form of the same workflow unless the same answer is deliberately carried forward, never change once the form is live, and are never one of the names the transaction document already owns: ${RESERVED_WELL_FORMED_NAMES.join(', ')}.`,
+    "A label never explains — that is the hint's job. Required fields are marked automatically, so add '(optional)' to the label of a field that is not required. A hint gives the format ('As it appears on your ID document, 13 digits'), the source ('Top right of the invoice, starts with INV') or the reason for asking something sensitive ('Used only to send delivery updates by SMS'); every field that could be misunderstood gets one.",
+    'Set type and dataType to the data. A number is never left as text: the engine compares strictly, so a number stored as text never equals a number. A phone number is type tel with dataType string.',
+    'A review decision toggle, a date the engine schedules on and any value a decision gate reads are always required and never conditionally hidden.',
+    'Related short values share one row (start and end as 6 and 6; quantity, unit price and line total as 4, 4 and 4); a textarea, an item list, a picker, an uploader or a signature never shares a row; the same kind of field keeps the same width all the way down a slide.',
+    'Errors are shown only after the user has left a field, so onlySetTempErrorOnTouch is true on nearly every field.',
+];
+/** The rules as one paragraph, for a form description or a system prompt. */
+export function describeAuthoringRules() {
+    return AUTHORING_RULES.join(' ');
+}

package/dist/skillet/extra-members.d.ts

@@ -0,0 +1,143 @@
+import { s } from '@hashbrownai/core';
+import type { FormColumnInputs } from '../interfaces/Form/index.js';
+import { FormInputKeys, SpecialElementKeys } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { AssertNever } from './internal/coupling.js';
+import { type TableConfigDraft } from './members/table.js';
+/**
+ * The members an element can carry that `AllFormInputPrimaryKeys` does not
+ * declare.
+ *
+ * `DefaultInputConfig[element].properties` is typed
+ * `Array<FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys>`, and it
+ * uses all three. Keying the main registry on `AllFormInputPrimaryKeys` alone
+ * left fourteen keys unresolvable at assembly time, including `pattern` and
+ * `placeholder` — properties too ordinary for a form generator to do without.
+ *
+ * ## `properties` is not a property list
+ *
+ * It is the list of ROWS the settings panel shows for that element, which is a
+ * superset of what the input stores. `matOptionsApiCall` and
+ * `showAllMcoaSegments` open editors; they are not keys on a form input and no
+ * interface declares them. Those are recorded in {@link EDITOR_ONLY_KEYS} and
+ * skipped during assembly — absent by intent, not by oversight.
+ *
+ * Enum membership does not decide this, which is worth stating because it looks
+ * like it should: `multipleInputAvailableOperations` sits in
+ * `SpecialElementKeys` beside the editor directives, yet `IMultiple` really
+ * does declare it. The test that settles it is whether an interface declares
+ * the key, so that is the test used.
+ */
+/** The type an extra member must produce, read off the real interface. */
+type MemberValue<K extends string> = K extends keyof FormColumnInputs ? NonNullable<FormColumnInputs[K]> : unknown;
+/**
+ * Keys that open an editor rather than store a value. They appear in
+ * `properties` and must never appear in a generation schema.
+ */
+export declare const EDITOR_ONLY_KEYS: readonly [SpecialElementKeys.FormValueFromInputSelector, SpecialElementKeys.FormInputSelector, SpecialElementKeys.MatOptionsApiCall, SpecialElementKeys.MatOptionsRequiredInputs, SpecialElementKeys.MatOptionsApiValueAccessRules, SpecialElementKeys.DefaultCalculatedFieldRules, SpecialElementKeys.MatOptionsItemType, SpecialElementKeys.MatOptionsSelectionOptions, SpecialElementKeys.DefaultValuePipe, SpecialElementKeys.DefaultCurrencySelect, SpecialElementKeys.DefaultDecimalNumberInput, SpecialElementKeys.Default, SpecialElementKeys.ShowAllMcoaSegments];
+/**
+ * Extra members still to be modelled.
+ *
+ * The four date bounds are all typed `Date`. A model emits JSON, so the best it
+ * can produce is an ISO string, which is not assignable to `Date` — they need
+ * the same draft-and-expand treatment as `matOptions` rather than a quiet
+ * mistyping. `tableConfig` and `matrixTableConfig` are nested configuration
+ * objects awaiting their own modules.
+ */
+export declare const PENDING_EXTRA_MEMBERS: readonly [FormInputKeys.StartMinDate, FormInputKeys.StartMaxDate, FormInputKeys.EndMinDate, FormInputKeys.EndMaxDate];
+/**
+ * Extra members whose schema produces an AUTHORING DRAFT rather than the stored
+ * shape — the same category `DRAFT_INPUT_MEMBERS` defines in
+ * `input-members.ts`, for keys that live in the other two enums.
+ *
+ * `tableConfig` is the only one. Its `columnsConfig` is keyed by column name —
+ * an index signature, which Skillet has no node for — so the model emits an
+ * ARRAY of columns each carrying its own key, and the application folds that
+ * into the record. See `members/table.ts`.
+ */
+export declare const DRAFT_EXTRA_MEMBERS: readonly [FormInputKeys.TableConfig];
+/** The draft each drafted extra member is held to. */
+interface ExtraMemberDrafts {
+    [FormInputKeys.TableConfig]: TableConfigDraft;
+}
+export declare const extraDraftMemberSchemas: {
+    tableConfig: s.ObjectType<{
+        displayedColumnsInOrder: s.ArrayType<s.StringType>;
+        columns: s.ArrayType<s.ObjectType<{
+            key: s.StringType;
+            type: s.EnumType<["caluculated", "property", "checkBox", "primaryKey"]>;
+            property: s.StringType;
+            label: s.StringType;
+            inEdit: s.BooleanType;
+            checkUpto: s.StringType;
+            calculatedFieldRules: s.ObjectType<{
+                formula: s.StringType;
+                variables: s.ArrayType<import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+                    bindingType: "field";
+                    variable: string;
+                    label: string;
+                    formControlName: string;
+                } | {
+                    bindingType: "listAggregate";
+                    variable: string;
+                    label: string;
+                    formControlName: string;
+                    parentInputFormControl: string;
+                    function: import("..").CalculationFunctions;
+                    applyFunctionToCol: string;
+                    applyFunctionToLabel: string | null;
+                    filterValuesByCol: string | null;
+                    filterValuesByThisColLabel: string | null;
+                    tableCell: boolean | null;
+                }>>;
+                decimalPlaces: import("@hashbrownai/core/src/schema/base").SchemaForUnion<number | null>;
+                roundingMode: import("@hashbrownai/core/src/schema/base").SchemaForUnion<"FLOOR" | "CEIL" | "ROUND" | null>;
+                getFormulaFromAFormInput: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
+                formControlWithFormula: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+            }>;
+            reductionFunction: import("@hashbrownai/core/src/schema/base").SchemaForUnion<"sum" | null>;
+            colorScale: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+        }>>;
+    }>;
+};
+export declare const extraInputMemberSchemas: {
+    pattern: s.StringType;
+    placeholder: s.StringType;
+    autocomplete: s.EnumType<import("..").AutocompleteOptions[]>;
+    disabled: s.BooleanType;
+    prefixText: s.StringType;
+    suffixText: s.StringType;
+    prefixIcon: s.StringType;
+    suffixIcon: s.StringType;
+    selectUpto: s.IntegerType;
+    showTotalsOf: s.ArrayType<s.StringType>;
+    multipleInputAvailableOperations: s.ArrayType<s.EnumType<import("..").MultipleInputAvailableOperations[]>>;
+    matrixTableConfig: s.ObjectType<{
+        dataSource: s.StringType;
+    }>;
+};
+export type ExtraMemberKey = keyof typeof extraInputMemberSchemas;
+type EditorOnlyKey = (typeof EDITOR_ONLY_KEYS)[number];
+type PendingExtraKey = (typeof PENDING_EXTRA_MEMBERS)[number];
+type DraftExtraKey = (typeof DRAFT_EXTRA_MEMBERS)[number];
+/**
+ * Every `FormInputKeys` and `SpecialElementKeys` member is accounted for —
+ * modelled, deferred, declared editor-only, or already covered by the primary
+ * registry because both enums spell the same key.
+ */
+export type _EveryExtraKeyClassified = AssertNever<Exclude<FormInputKeys | SpecialElementKeys, ExtraMemberKey | EditorOnlyKey | PendingExtraKey | DraftExtraKey | FormInputKeys.Accept | FormInputKeys.ConditionalInputConfig | FormInputKeys.GroupBy>>;
+/** Every extra node produces a value its interface member can hold. */
+export type _NoExtraValueDrift = AssertNever<{
+    [K in ExtraMemberKey]: [
+        s.Infer<(typeof extraInputMemberSchemas)[K]>
+    ] extends [MemberValue<K>] ? never : K;
+}[ExtraMemberKey]>;
+/** Every drafted extra node produces the draft it declares. */
+export type _NoExtraDraftDrift = AssertNever<{
+    [K in DraftExtraKey]: [
+        s.Infer<(typeof extraDraftMemberSchemas)[K]>
+    ] extends [ExtraMemberDrafts[K]] ? never : K;
+}[DraftExtraKey]>;
+/** Runtime key lists, derived from the enums. */
+export declare const ALL_FORM_INPUT_KEYS: FormInputKeys[];
+export declare const ALL_SPECIAL_ELEMENT_KEYS: SpecialElementKeys[];
+export {};

package/dist/skillet/extra-members.js

@@ -0,0 +1,79 @@
+import { s } from '@hashbrownai/core';
+import { FormInputKeys, SpecialElementKeys, } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { enumValues } from './internal/coupling.js';
+import { describe } from './internal/editor-guidance.js';
+import { autocompleteSchema, multipleInputOperationSchema } from './shared-types.js';
+import { matrixTableConfigSchema, tableConfigSchema, } from './members/table.js';
+/**
+ * Keys that open an editor rather than store a value. They appear in
+ * `properties` and must never appear in a generation schema.
+ */
+export const EDITOR_ONLY_KEYS = [
+    SpecialElementKeys.FormValueFromInputSelector,
+    SpecialElementKeys.FormInputSelector,
+    SpecialElementKeys.MatOptionsApiCall,
+    SpecialElementKeys.MatOptionsRequiredInputs,
+    SpecialElementKeys.MatOptionsApiValueAccessRules,
+    SpecialElementKeys.DefaultCalculatedFieldRules,
+    SpecialElementKeys.MatOptionsItemType,
+    SpecialElementKeys.MatOptionsSelectionOptions,
+    SpecialElementKeys.DefaultValuePipe,
+    SpecialElementKeys.DefaultCurrencySelect,
+    SpecialElementKeys.DefaultDecimalNumberInput,
+    SpecialElementKeys.Default,
+    SpecialElementKeys.ShowAllMcoaSegments,
+];
+/**
+ * Extra members still to be modelled.
+ *
+ * The four date bounds are all typed `Date`. A model emits JSON, so the best it
+ * can produce is an ISO string, which is not assignable to `Date` — they need
+ * the same draft-and-expand treatment as `matOptions` rather than a quiet
+ * mistyping. `tableConfig` and `matrixTableConfig` are nested configuration
+ * objects awaiting their own modules.
+ */
+export const PENDING_EXTRA_MEMBERS = [
+    FormInputKeys.StartMinDate,
+    FormInputKeys.StartMaxDate,
+    FormInputKeys.EndMinDate,
+    FormInputKeys.EndMaxDate,
+];
+/**
+ * Extra members whose schema produces an AUTHORING DRAFT rather than the stored
+ * shape — the same category `DRAFT_INPUT_MEMBERS` defines in
+ * `input-members.ts`, for keys that live in the other two enums.
+ *
+ * `tableConfig` is the only one. Its `columnsConfig` is keyed by column name —
+ * an index signature, which Skillet has no node for — so the model emits an
+ * ARRAY of columns each carrying its own key, and the application folds that
+ * into the record. See `members/table.ts`.
+ */
+export const DRAFT_EXTRA_MEMBERS = [FormInputKeys.TableConfig];
+export const extraDraftMemberSchemas = {
+    [FormInputKeys.TableConfig]: tableConfigSchema,
+};
+export const extraInputMemberSchemas = {
+    [FormInputKeys.Pattern]: s.string(describe("A regular expression the typed value must match, as a JavaScript pattern without delimiters. Only for a code with a fixed shape that nothing looks up, such as an ID number or an order reference; never on a lookup key such as a supplier number, where the endpoint's error is the check.", FormInputKeys.Pattern)),
+    // Each authored sentence below is the DEFINITION only. The advice that goes
+    // with it — give an example, turn autofill off for one-time values, when a
+    // selection cap applies at all — is written once, on the editor row, and
+    // composed in by `describe()`. Saying it in both places produced descriptions
+    // that made the same point twice in slightly different words.
+    [FormInputKeys.Placeholder]: s.string(describe('Ghost text shown inside the field while it is empty. Prefer none: it disappears as the user types and screen readers may skip it, so anything that matters belongs in the hint.', FormInputKeys.Placeholder)),
+    [FormInputKeys.Autocomplete]: autocompleteSchema,
+    [FormInputKeys.Disabled]: s.boolean(describe('Whether the control is rendered but cannot be interacted with.', FormInputKeys.Disabled)),
+    [FormInputKeys.PrefixText]: s.string(describe('Short static text shown before the field, for example a currency symbol. It stops the user typing the unit into the box.', FormInputKeys.PrefixText)),
+    [FormInputKeys.SuffixText]: s.string(describe('Short static text shown after the field, for example a unit such as kg or %. It stops the user typing the unit into the box.', FormInputKeys.SuffixText)),
+    [FormInputKeys.PrefixIcon]: s.string(describe('Name of the Material icon shown before the field.', FormInputKeys.PrefixIcon)),
+    [FormInputKeys.SuffixIcon]: s.string(describe('Name of the Material icon shown after the field.', FormInputKeys.SuffixIcon)),
+    // The applicability rule is the valuable half here: the editor row declares
+    // `allowMultipleSelection === true`, and Skillet cannot express that
+    // structurally, so it arrives as the sentence a model actually needs.
+    [FormInputKeys.SelectUpto]: s.integer(describe('The most options the user may choose at once.', FormInputKeys.SelectUpto), { minimum: 1 }),
+    [FormInputKeys.ShowTotalsOf]: s.array(describe("The formControlNames of columns inside this list whose values are summed and shown as a total. For the user's eyes only: a total used anywhere else must also be a calculated field on the form itself.", FormInputKeys.ShowTotalsOf), s.string('A formControlName inside this list to total.')),
+    [SpecialElementKeys.MultipleInputAvailableOperations]: s.array(describe("Which operations the user may perform on the rows of this repeatable group: usually 'add', 'remove' and 'update'; add 'lockEditOnFormSubmit' when rows must not change once submitted.", SpecialElementKeys.MultipleInputAvailableOperations), multipleInputOperationSchema),
+    [FormInputKeys.MatrixTableConfig]: matrixTableConfigSchema,
+};
+/** Runtime key lists, derived from the enums. */
+export const ALL_FORM_INPUT_KEYS = enumValues(FormInputKeys);
+export const ALL_SPECIAL_ELEMENT_KEYS = enumValues(SpecialElementKeys);

package/dist/skillet/form.d.ts

@@ -0,0 +1,170 @@
+import { s } from '@hashbrownai/core';
+import { type AssertNever } from './internal/coupling.js';
+import { type AvailableApiEndpoint } from './members/mat-options.js';
+import { type ColumnSchemaOptions } from './variants.js';
+import { type WorkflowStepContext } from './workflow-context.js';
+/**
+ * The whole-form schema: slides of columns, plus how the form submits.
+ *
+ * ## This produces a draft, and it cannot not
+ *
+ * `FormSchema` requires `submissionHandle.submissionAPI` — an array of at least
+ * one full `APIDataFetchingConfiguration`, complete with `_id`, `httpEndPoint`
+ * and `httpMethod`. It is the same problem `matOptions` has, except mandatory:
+ * there is no valid form without it, and no model can author it from a prompt.
+ * `FormSlide.sectionId` is the same story on a smaller scale — an identifier
+ * the builder assigns, which a model can only fabricate.
+ *
+ * So a generated form is a {@link FormDraft}. The application supplies section
+ * ids and expands the chosen endpoint ids into stored configurations, and only
+ * then does `validateForm()` have something it can pass. Any pipeline built on
+ * this needs that expansion step; there is no arrangement of the schema that
+ * removes it.
+ *
+ * ## Streaming
+ *
+ * `streaming: true` switches the slide and column arrays to their streaming
+ * variants, so a client parses each slide as it arrives instead of waiting for
+ * the closing brace of a large form. It changes nothing about the data — only
+ * when a consumer can first see it.
+ */
+export interface SubmissionHandleDraft {
+    submissionAPI: string[];
+    /**
+     * The pre-submit gate, as an endpoint id, expanded into
+     * `FormSubmissionHandleInterface.canSubmitAPI`.
+     *
+     * Absent — not empty — on most drafts, and on every draft generated without
+     * `FormSchemaOptions.canSubmitEndpoints`: the key is only put to the model
+     * when the caller has gate endpoints to offer, and a hand-built form carries
+     * no `canSubmitAPI` key either, so a schema that always emitted one would
+     * make every generated form differ from an authored one over a member the
+     * form does not use.
+     */
+    canSubmitAPI?: string[];
+    submissionMessage: string | null;
+}
+export interface FormDraft {
+    formTitle: string;
+    /**
+     * Columns are typed loosely on purpose. The per-element variants are
+     * assembled at runtime from `DefaultInputConfig`, whose property arrays are
+     * `string[]` rather than const tuples, so there is no literal type for
+     * `s.Infer` to reconstruct. The compiler cannot describe these; the schema
+     * and `validateForm()` still constrain them.
+     */
+    slides: {
+        label: string;
+        columns: unknown[];
+    }[];
+    submissionHandle: SubmissionHandleDraft;
+}
+export interface FormSchemaOptions extends ColumnSchemaOptions {
+    /**
+     * Endpoints the form may submit to. As with `matOptions`, an empty list means
+     * the model is not asked to choose one — it emits an empty `submissionAPI`
+     * and the application fills it in.
+     */
+    submissionEndpoints?: readonly AvailableApiEndpoint[];
+    /**
+     * Endpoints that may gate submission — called with the form data, and their
+     * answer decides whether the submission proceeds.
+     *
+     * Unlike {@link submissionEndpoints} this one is genuinely optional at the
+     * schema level: `canSubmitAPI` is optional on
+     * `FormSubmissionHandleInterface` and most forms have no pre-submit check, so
+     * an empty list here removes the key from the schema entirely rather than
+     * degrading it to an empty array. That follows `matOptions`, where a source
+     * with no candidates is not offered at all — the alternative is asking a
+     * model to pick an endpoint out of an empty list, which it answers by
+     * inventing one.
+     */
+    canSubmitEndpoints?: readonly AvailableApiEndpoint[];
+    /**
+     * The workflow step this form serves, and the control names the workflow
+     * already fixes. See {@link WorkflowStepContext}: none of it is knowable
+     * from a prompt, and all of it decides what the form must contain.
+     */
+    step?: WorkflowStepContext;
+    /** Parse slides and columns incrementally as they stream in. */
+    streaming?: boolean;
+}
+declare function submissionHandleSchema(endpoints: readonly AvailableApiEndpoint[], canSubmitEndpoints: readonly AvailableApiEndpoint[]): s.ObjectType<{
+    submissionAPI: s.ArrayType<s.StringType | s.EnumType<string[]>>;
+    canSubmitAPI: s.ArrayType<s.EnumType<string[]>>;
+    submissionMessage: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+}> | s.ObjectType<{
+    submissionAPI: s.ArrayType<s.StringType | s.EnumType<string[]>>;
+    submissionMessage: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+}>;
+/** The submission-handle node, whichever endpoints the factory was given. */
+type SubmissionHandleSchema = ReturnType<typeof submissionHandleSchema>;
+/**
+ * The submission handle produces the draft it declares.
+ *
+ * The same check the per-member modules run on themselves, applied to the one
+ * nested object this file owns. It earns its keep on the `canSubmitAPI` branch
+ * in particular: that key exists only when the caller supplies
+ * `canSubmitEndpoints`, so the node's inferred type is a UNION of the two
+ * shapes, and a member added to either branch without a matching member on
+ * {@link SubmissionHandleDraft} fails here rather than at the application's
+ * expansion step.
+ */
+export type _NoSubmissionHandleDraftDrift = AssertNever<[
+    s.Infer<SubmissionHandleSchema>
+] extends [SubmissionHandleDraft] ? never : 'submissionHandle'>;
+/**
+ * Builds the form-draft schema.
+ *
+ * @param options which elements and data sources to offer, which endpoints the
+ *   form may submit to and which may gate that submission, and whether to
+ *   stream.
+ */
+export declare function createFormDraftSchema(options?: FormSchemaOptions): s.ObjectType<{
+    formTitle: s.StringType;
+    slides: s.ArrayType<s.ObjectType<{
+        label: s.StringType;
+        columns: s.ArrayType<s.HashbrownType<unknown>>;
+    }>>;
+    submissionHandle: s.ObjectType<{
+        submissionAPI: s.ArrayType<s.StringType | s.EnumType<string[]>>;
+        canSubmitAPI: s.ArrayType<s.EnumType<string[]>>;
+        submissionMessage: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+    }> | s.ObjectType<{
+        submissionAPI: s.ArrayType<s.StringType | s.EnumType<string[]>>;
+        submissionMessage: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+    }>;
+}>;
+/**
+ * Members of a generated draft the application must supply before the form is
+ * valid. Listed so the expansion step has something to check itself against.
+ *
+ * The per-member lists are pulled in rather than restated, so a module that
+ * takes on a new obligation adds it here by existing. Each entry is prefixed
+ * with the column path it hangs off, since the modules describe their own
+ * shape and do not know where in a form they sit.
+ *
+ * A module's own entries must therefore start at the MEMBER it owns —
+ * `validators[].id`, not `id` — because everything before that is added here
+ * and everything after is the module's to state. A list that skips its member
+ * name yields a path with a hole in it, which is worse than no list: it reads
+ * as authoritative and points nowhere.
+ *
+ * Three entries are not from any module and are worth reading twice:
+ *
+ * - `isCalculatedField` is derived, not authored — see `calculatedFieldSplit`
+ *   in `variants.ts`. It is required by the interface on EVERY column, so
+ *   expansion must set it on plain columns too, not only calculated ones.
+ * - `onlySetTempErrorOnTouch` is required by the interface but optional in the
+ *   schema (offered on every value-capturing element through the always-shown
+ *   editor rows), so a model may leave it null. Expansion then sets it, and the
+ *   guide's house rule says what to: true, so errors appear only after the
+ *   user leaves a field. The builder's own element templates default it to
+ *   false; the guide is explicit that this is the wrong default for nearly
+ *   every field.
+ * - the nulls. Skillet has no optional, so every unset member arrives as an
+ *   explicit `null`, and Joi rejects `null` for a typed optional key. Stripping
+ *   them is not tidying; a draft that keeps them fails validation.
+ */
+export declare const DRAFT_COMPLETION_REQUIRED: readonly ["slides[].sectionId", "slides[].columns[].id", "slides[].columns[].sectionId", "slides[].columns[].isCalculatedField (derived: calculatedFieldRules != null)", "slides[].columns[].onlySetTempErrorOnTouch (required by the interface and offered as optional; when the model leaves it null the application sets true)", "submissionHandle.submissionAPI[] (endpoint id expanded to its configuration)", "submissionHandle.canSubmitAPI[] (endpoint id expanded to its configuration; the key is present only when canSubmitEndpoints were offered, and an empty array is dropped)", ...string[], "every member emitted as null is stripped before validation"];
+export {};