@gravionlabs/helix-zod 22.0.0

package/fesm2022/gravionlabs-helix-zod.mjs

@@ -0,0 +1,974 @@
+import { NgComponentOutlet } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, input, computed, ChangeDetectionStrategy, Component, output, Injector, signal, untracked, Directive, model, makeEnvironmentProviders } from '@angular/core';
+import { validateStandardSchema, hidden, disabled, readonly, required, applyEach, applyWhenValue, form, submit, FormField, transformedValue } from '@angular/forms/signals';
+import { z, ZodIssueCode } from 'zod';
+import { ValidatorKey } from '@gravionlabs/helix-core/validators';
+import { HelixFormField, HelixSelect } from '@gravionlabs/helix-shell';
+
+/**
+ * Multi-provider token holding widget registrations. Later registrations win,
+ * so consumer widgets registered after the built-ins override them.
+ */
+const HELIX_DYNAMIC_FIELD_WIDGETS = new InjectionToken('HELIX_DYNAMIC_FIELD_WIDGETS');
+/** Optional app-level error message resolver used by all built-in widgets. */
+const HELIX_ERROR_MESSAGE_RESOLVER = new InjectionToken('HELIX_ERROR_MESSAGE_RESOLVER');
+/** Resolves the widget component registered for a widget kind. */
+class HelixFieldWidgetResolver {
+    #registrations = inject(HELIX_DYNAMIC_FIELD_WIDGETS, { optional: true }) ?? [];
+    resolve(widget) {
+        const flat = this.#registrations.flat();
+        for (let i = flat.length - 1; i >= 0; i--) {
+            if (flat[i].widget === widget)
+                return flat[i].component;
+        }
+        throw new Error(`[HelixFieldWidgetResolver] No widget registered for kind "${widget}". ` +
+            (typeof ngDevMode !== 'undefined' && ngDevMode
+                ? `Did you forget provideHelixDynamicForms() or a custom { widgets: [...] } registration?`
+                : ''));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixFieldWidgetResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixFieldWidgetResolver, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixFieldWidgetResolver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Dispatches one field descriptor to its registered widget component.
+ *
+ * Handles `hidden()` centrally: a hidden field renders nothing, per the
+ * signal-forms guidance to `@if` on the hidden state.
+ *
+ * Imports no widget statically — composite widgets (object/array/union) import
+ * this component, and built-in registrations live in
+ * `provideHelixDynamicForms()`, which breaks the import cycle.
+ */
+class HelixDynamicField {
+    field = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
+    descriptor = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "descriptor" }] : /* istanbul ignore next */ []));
+    #resolver = inject(HelixFieldWidgetResolver);
+    component = computed(() => this.#resolver.resolve(this.descriptor().widget), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "component" }] : /* istanbul ignore next */ []));
+    outletInputs = computed(() => ({
+        field: this.field(),
+        descriptor: this.descriptor(),
+    }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "outletInputs" }] : /* istanbul ignore next */ []));
+    hiddenState = computed(() => this.field()().hidden(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hiddenState" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDynamicField, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixDynamicField, isStandalone: true, selector: "helix-dynamic-field", inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, descriptor: { classPropertyName: "descriptor", publicName: "descriptor", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: "@if (!hiddenState()) {\n  <ng-container [ngComponentOutlet]=\"component()\" [ngComponentOutletInputs]=\"outletInputs()\" />\n}\n", styles: [":host{display:block;width:100%}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDynamicField, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-dynamic-field', standalone: true, imports: [NgComponentOutlet], changeDetection: ChangeDetectionStrategy.OnPush, template: "@if (!hiddenState()) {\n  <ng-container [ngComponentOutlet]=\"component()\" [ngComponentOutletInputs]=\"outletInputs()\" />\n}\n", styles: [":host{display:block;width:100%}\n"] }]
+        }], propDecorators: { field: [{ type: i0.Input, args: [{ isSignal: true, alias: "field", required: true }] }], descriptor: [{ type: i0.Input, args: [{ isSignal: true, alias: "descriptor", required: true }] }] } });
+
+/**
+ * Builds the signal-forms schema for a Zod-driven dynamic form:
+ *
+ * 1. Root-level `validateStandardSchema(rootPath, zodSchema)` — Zod issue
+ *    paths route errors onto the matching child fields, including cross-field
+ *    `.refine()` errors with a `path`.
+ * 2. Conditional field state from {@link HelixFieldMeta} predicates
+ *    (`hiddenWhen`/`disabledWhen`/`readonlyWhen`/`requiredWhen`), evaluated
+ *    against the root form value.
+ * 3. `meta.extraSchema` escape-hatch rules per field.
+ * 4. `applyEach` for array items and `applyWhenValue` for discriminated-union
+ *    variants, so variant/item rules stay dormant unless active.
+ */
+function buildHelixSchema(zodSchema, root) {
+    return (rootPath) => {
+        validateStandardSchema(rootPath, zodSchema);
+        applyDescriptorRules(rootPath, root, rootPath);
+    };
+}
+/** Reads the root form value from any nested logic context. */
+function rootValueOf(ctx, rootPath) {
+    return ctx.valueOf(rootPath);
+}
+function applyConditionRules(path, descriptor, rootPath) {
+    const meta = descriptor.meta;
+    if (meta.hiddenWhen) {
+        hidden(path, (ctx) => !!meta.hiddenWhen?.(rootValueOf(ctx, rootPath)));
+    }
+    if (meta.disabledWhen) {
+        disabled(path, (ctx) => meta.disabledWhen?.(rootValueOf(ctx, rootPath)) ?? false);
+    }
+    if (meta.readonlyWhen) {
+        readonly(path, (ctx) => !!meta.readonlyWhen?.(rootValueOf(ctx, rootPath)));
+    }
+    if (meta.requiredWhen) {
+        required(path, {
+            when: (ctx) => !!meta.requiredWhen?.(rootValueOf(ctx, rootPath)),
+        });
+    }
+    meta.extraSchema?.(path);
+}
+function applyDescriptorRules(path, descriptor, rootPath) {
+    // Root-level conditions make no sense on the form itself — only on fields.
+    if (path !== rootPath)
+        applyConditionRules(path, descriptor, rootPath);
+    for (const child of descriptor.children ?? []) {
+        applyDescriptorRules(path[child.key], child, rootPath);
+    }
+    if (descriptor.itemDescriptor) {
+        const item = descriptor.itemDescriptor;
+        applyEach(path, ((itemPath) => {
+            applyDescriptorRules(itemPath, item, rootPath);
+        }));
+    }
+    if (descriptor.union) {
+        const { discriminator, variants } = descriptor.union;
+        for (const [tag, variant] of variants) {
+            applyWhenValue(path, ((value) => value?.[discriminator] === tag), ((variantPath) => {
+                // The union field itself carries the variant's children.
+                for (const child of variant.children ?? []) {
+                    applyDescriptorRules(variantPath[child.key], child, rootPath);
+                }
+            }));
+        }
+    }
+}
+
+const defOf$1 = (schema) => schema._zod.def;
+/**
+ * Builds a fully-populated initial model value for a Zod schema — signal forms
+ * require a concrete model shape up front.
+ *
+ * Rules: `.default()` wins; strings → `''`; numbers/dates → `null` (paired
+ * with parse-transforming widgets); booleans → `false`; enums → first option;
+ * arrays → `[]`; objects → recursed shape; discriminated unions → default of
+ * the first variant; `optional`/`nullable` leaves without a more specific
+ * default → `undefined` / `null`.
+ */
+function buildDefaultValue(schema) {
+    const def = defOf$1(schema);
+    switch (def.type) {
+        case 'default': {
+            const dv = def['defaultValue'];
+            return typeof dv === 'function' ? dv() : dv;
+        }
+        case 'optional': {
+            // Optional leaves default to undefined; optional containers still need a
+            // concrete shape so the field tree has navigable paths.
+            const inner = schema.unwrap();
+            return isLeaf(inner) ? undefined : buildDefaultValue(inner);
+        }
+        case 'readonly':
+        case 'nonoptional':
+            return buildDefaultValue(schema.unwrap());
+        case 'nullable':
+            return null;
+        case 'string':
+            return '';
+        case 'number':
+        case 'int':
+        case 'date':
+            return null;
+        case 'boolean':
+            return false;
+        case 'enum': {
+            const options = schema.options;
+            return options[0];
+        }
+        case 'literal': {
+            const values = def['values'];
+            return values[0];
+        }
+        case 'array':
+            return [];
+        case 'object': {
+            const shape = schema.shape;
+            const value = {};
+            for (const [key, child] of Object.entries(shape)) {
+                value[key] = buildDefaultValue(child);
+            }
+            return value;
+        }
+        case 'union': {
+            const options = schema.options;
+            return buildDefaultValue(options[0]);
+        }
+        default:
+            return undefined;
+    }
+}
+function isLeaf(schema) {
+    const type = defOf$1(schema).type;
+    return type !== 'object' && type !== 'array' && type !== 'union';
+}
+
+/**
+ * Typed registry backing {@link helixMeta}. Checked before the zod global
+ * registry by {@link readHelixMeta}.
+ */
+const helixFieldMetaRegistry = z.registry();
+/**
+ * Attaches Helix UI metadata to a Zod schema and returns the **same** instance.
+ *
+ * Prefer this over `.meta()`, which clones the schema — metadata must live on
+ * the exact instance composed into the `z.object()` shape for the walker to
+ * find it.
+ *
+ * @example
+ * const UserSchema = z.object({
+ *   email: helixMeta(z.email(), { label: 'E-mail', placeholder: 'you@example.com' }),
+ * });
+ */
+function helixMeta(schema, meta) {
+    helixFieldMetaRegistry.add(schema, meta);
+    return schema;
+}
+const WRAPPER_TYPES$1 = new Set(['optional', 'nullable', 'default', 'readonly', 'nonoptional']);
+function metaOf(schema) {
+    const registered = helixFieldMetaRegistry.get(schema);
+    if (registered)
+        return registered;
+    const globalMeta = schema.meta();
+    if (!globalMeta)
+        return undefined;
+    const { title, description, helix, ...rest } = globalMeta;
+    const mapped = { ...rest };
+    if (title !== undefined)
+        mapped.label = title;
+    if (description !== undefined)
+        mapped.hint = description;
+    return { ...mapped, ...helix };
+}
+/**
+ * Reads {@link HelixFieldMeta} from a Zod schema: the typed registry first,
+ * then the zod global registry (`.meta()` — `title` → `label`,
+ * `description` → `hint`, `helix` key merged on top).
+ *
+ * Wrapper types (`optional`, `nullable`, `default`, `readonly`) are unwrapped
+ * and their metadata merged — outermost wins.
+ */
+function readHelixMeta(schema) {
+    const layers = [];
+    let current = schema;
+    while (current) {
+        const meta = metaOf(current);
+        if (meta)
+            layers.push(meta);
+        const def = current._zod.def;
+        current = WRAPPER_TYPES$1.has(def.type) ? current.unwrap() : undefined;
+    }
+    // Innermost first so outer layers overwrite inner ones.
+    return layers.reverse().reduce((acc, layer) => ({ ...acc, ...layer }), {});
+}
+
+const WRAPPER_TYPES = new Set(['optional', 'nullable', 'default', 'readonly', 'nonoptional']);
+/** Native `<input type>` per input-based widget kind. */
+const INPUT_TYPES = {
+    text: 'text',
+    email: 'email',
+    password: 'password',
+    number: 'number',
+    date: 'date',
+};
+function defOf(schema) {
+    return schema._zod.def;
+}
+/** Peels optional/nullable/default/readonly wrappers, tracking requiredness. */
+function unwrap(schema) {
+    let inner = schema;
+    let required = true;
+    while (WRAPPER_TYPES.has(defOf(inner).type)) {
+        const type = defOf(inner).type;
+        if (type === 'optional' || type === 'nullable' || type === 'default')
+            required = false;
+        if (type === 'nonoptional')
+            required = true;
+        inner = inner.unwrap();
+    }
+    return { inner, required };
+}
+function normalizeOptions(options) {
+    if (!options)
+        return undefined;
+    return options.map((o) => typeof o === 'string' ? { label: o, value: o } : o);
+}
+function inferWidget(inner) {
+    const def = defOf(inner);
+    switch (def.type) {
+        case 'string':
+            return def['format'] === 'email' ? 'email' : 'text';
+        case 'number':
+        case 'int':
+            return 'number';
+        case 'boolean':
+            return 'checkbox';
+        case 'date':
+            return 'date';
+        case 'enum':
+        case 'literal':
+            return 'select';
+        case 'array':
+            return 'array';
+        case 'object':
+            return 'object';
+        case 'union':
+            return def['discriminator'] !== undefined ? 'union' : null;
+        default:
+            return null;
+    }
+}
+function enumOptions(inner) {
+    const def = defOf(inner);
+    if (def.type === 'enum') {
+        const values = inner.options;
+        return values.map((v) => ({ label: String(v), value: v }));
+    }
+    if (def.type === 'literal') {
+        const values = def['values'];
+        return values.map((v) => ({ label: String(v), value: v }));
+    }
+    return undefined;
+}
+/** Reads the discriminator literal of a union variant's tag field. */
+function discriminatorValue(variant, discriminator) {
+    const shape = variant.shape;
+    const tagDef = defOf(unwrap(shape[discriminator]).inner);
+    const values = tagDef['values'];
+    if (!values?.length) {
+        throw new Error(`[zodToFieldDescriptors] Discriminated union variant has no literal value for ` +
+            `discriminator "${discriminator}".`);
+    }
+    return values[0];
+}
+function walk(schema, key, path) {
+    const meta = readHelixMeta(schema);
+    const { inner, required } = unwrap(schema);
+    const def = defOf(inner);
+    const inferred = inferWidget(inner);
+    const widget = meta.widget ?? inferred;
+    if (widget === null || widget === undefined) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            throw new Error(`[zodToFieldDescriptors] Zod type "${def.type}" at path "${path.join('.')}" has no ` +
+                `automatic widget mapping. Set { widget: '...' } via helixMeta() to render it with a ` +
+                `registered (custom) widget.`);
+        }
+        // Production: render nothing rather than crash — fall through as plain text.
+        return {
+            key,
+            path,
+            widget: 'text',
+            meta,
+            zodType: inner,
+            zodSource: schema,
+            required,
+            inputType: 'text',
+        };
+    }
+    const descriptor = {
+        key,
+        path,
+        widget,
+        meta,
+        zodType: inner,
+        zodSource: schema,
+        required,
+        inputType: INPUT_TYPES[widget],
+        options: normalizeOptions(meta.options) ?? enumOptions(inner),
+    };
+    if (def.type === 'object') {
+        const shape = inner.shape;
+        const children = Object.entries(shape).map(([childKey, childSchema], index) => ({
+            index,
+            descriptor: walk(childSchema, childKey, [...path, childKey]),
+        }));
+        children.sort((a, b) => (a.descriptor.meta.order ?? Number.MAX_SAFE_INTEGER) -
+            (b.descriptor.meta.order ?? Number.MAX_SAFE_INTEGER) || a.index - b.index);
+        descriptor.children = children.map((c) => c.descriptor);
+    }
+    if (def.type === 'array') {
+        descriptor.itemDescriptor = walk(def['element'], '', path);
+    }
+    if (widget === 'union' && def.type === 'union') {
+        const discriminator = def['discriminator'];
+        const variants = new Map();
+        for (const variant of inner.options) {
+            variants.set(discriminatorValue(variant, discriminator), walk(variant, key, path));
+        }
+        descriptor.union = { discriminator, variants };
+    }
+    return descriptor;
+}
+/**
+ * Walks an annotated `z.object()` schema and produces the recursive
+ * {@link HelixFieldDescriptor} tree consumed by the dynamic form renderer.
+ *
+ * Widget inference: string→text (`z.email()`→email), number→number,
+ * boolean→checkbox, date→date, enum/literal→select, array→array,
+ * object→object, discriminated union→union. Anything else requires a
+ * `widget` override in {@link HelixFieldMeta} (throws in dev mode otherwise).
+ */
+function zodToFieldDescriptors(schema) {
+    return walk(schema, '', []);
+}
+
+/**
+ * Renders a complete signal form from an annotated Zod object schema.
+ *
+ * - Validation: root-level `validateStandardSchema` — Zod issues are routed to
+ *   the matching fields.
+ * - Model: pass your own `WritableSignal` via `model`, or let the component
+ *   derive an initial value from the schema (`buildDefaultValue`).
+ * - Swapping the `schema` input recreates the form and resets its state.
+ * - `submitted` emits the **parsed** (`schema.parse`) value on valid submit.
+ *
+ * Requires `provideHelixDynamicForms()` in the injector chain.
+ */
+class HelixDynamicForm {
+    schema = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "schema" }] : /* istanbul ignore next */ []));
+    /** Optional external model — omit to derive the initial value from the schema. */
+    model = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "model" }] : /* istanbul ignore next */ []));
+    submitLabel = input('Submit', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "submitLabel" }] : /* istanbul ignore next */ []));
+    showSubmit = input(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "showSubmit" }] : /* istanbul ignore next */ []));
+    submitted = output();
+    #injector = inject(Injector);
+    descriptors = computed(() => zodToFieldDescriptors(this.schema()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "descriptors" }] : /* istanbul ignore next */ []));
+    #model = computed(() => this.model() ?? signal(buildDefaultValue(this.schema())), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "#model" }] : /* istanbul ignore next */ []));
+    /** The form's `FieldTree` — recreated (state reset) when the schema changes. */
+    formTree = computed(() => {
+        const model = this.#model();
+        const schema = this.schema();
+        const root = this.descriptors();
+        return untracked(() => form(model, buildHelixSchema(schema, root), { injector: this.#injector }));
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "formTree" }] : /* istanbul ignore next */ []));
+    childField(descriptor) {
+        return this.formTree()[descriptor.key];
+    }
+    async handleSubmit(event) {
+        event.preventDefault();
+        await submit(this.formTree(), async (tree) => {
+            this.submitted.emit(this.schema().parse(tree().value()));
+            return undefined;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDynamicForm, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixDynamicForm, isStandalone: true, selector: "helix-dynamic-form", inputs: { schema: { classPropertyName: "schema", publicName: "schema", isSignal: true, isRequired: true, transformFunction: null }, model: { classPropertyName: "model", publicName: "model", isSignal: true, isRequired: false, transformFunction: null }, submitLabel: { classPropertyName: "submitLabel", publicName: "submitLabel", isSignal: true, isRequired: false, transformFunction: null }, showSubmit: { classPropertyName: "showSubmit", publicName: "showSubmit", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { submitted: "submitted" }, ngImport: i0, template: "<form class=\"helix-dynamic-form\" novalidate (submit)=\"handleSubmit($event)\">\n  @for (child of descriptors().children ?? []; track child.key) {\n    <helix-dynamic-field [field]=\"childField(child)\" [descriptor]=\"child\" />\n  }\n\n  @if (showSubmit()) {\n    <button\n      type=\"submit\"\n      class=\"helix-dynamic-form__submit\"\n      [disabled]=\"formTree()().submitting()\"\n    >\n      {{ submitLabel() }}\n    </button>\n  }\n</form>\n", styles: [":host{display:block;width:100%}.helix-dynamic-form{display:flex;flex-direction:column;gap:1rem}.helix-dynamic-form__submit{align-self:flex-start;padding:.5rem 1.25rem;font-family:inherit;font-size:1rem;color:var(--h-primary-contrast-color);background-color:var(--h-primary-color);border:1px solid var(--h-primary-color);border-radius:var(--h-border-radius-md);cursor:pointer;transition:background-color .2s}.helix-dynamic-form__submit:hover:not(:disabled){background-color:var(--h-primary-hover-color)}.helix-dynamic-form__submit:disabled{cursor:default;opacity:.6}\n"], dependencies: [{ kind: "component", type: HelixDynamicField, selector: "helix-dynamic-field", inputs: ["field", "descriptor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDynamicForm, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-dynamic-form', standalone: true, imports: [HelixDynamicField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<form class=\"helix-dynamic-form\" novalidate (submit)=\"handleSubmit($event)\">\n  @for (child of descriptors().children ?? []; track child.key) {\n    <helix-dynamic-field [field]=\"childField(child)\" [descriptor]=\"child\" />\n  }\n\n  @if (showSubmit()) {\n    <button\n      type=\"submit\"\n      class=\"helix-dynamic-form__submit\"\n      [disabled]=\"formTree()().submitting()\"\n    >\n      {{ submitLabel() }}\n    </button>\n  }\n</form>\n", styles: [":host{display:block;width:100%}.helix-dynamic-form{display:flex;flex-direction:column;gap:1rem}.helix-dynamic-form__submit{align-self:flex-start;padding:.5rem 1.25rem;font-family:inherit;font-size:1rem;color:var(--h-primary-contrast-color);background-color:var(--h-primary-color);border:1px solid var(--h-primary-color);border-radius:var(--h-border-radius-md);cursor:pointer;transition:background-color .2s}.helix-dynamic-form__submit:hover:not(:disabled){background-color:var(--h-primary-hover-color)}.helix-dynamic-form__submit:disabled{cursor:default;opacity:.6}\n"] }]
+        }], propDecorators: { schema: [{ type: i0.Input, args: [{ isSignal: true, alias: "schema", required: true }] }], model: [{ type: i0.Input, args: [{ isSignal: true, alias: "model", required: false }] }], submitLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "submitLabel", required: false }] }], showSubmit: [{ type: i0.Input, args: [{ isSignal: true, alias: "showSubmit", required: false }] }], submitted: [{ type: i0.Output, args: ["submitted"] }] } });
+
+// Mirrors Validators' internal EMPTY_VALUES — defined locally to avoid
+// depending on unexported internals of @gravionlabs/helix-core.
+const EMPTY_VALUES = ['', null, undefined];
+const isEmptyValue = (v) => EMPTY_VALUES.includes(v);
+/**
+ * Maps a single `ZodIssue` to the corresponding `ValidatorKey`.
+ *
+ * NOTE: Zod v4 breaking changes accounted for here:
+ *   - `invalid_string` → `invalid_format` with `format` property (not `validation`)
+ *   - `too_small`/`too_big` use `origin` instead of `type`
+ *   - `not_integer` removed → `invalid_type` with `expected: 'int'`
+ *   - `invalid_type` for null/undefined no longer has a `received` field;
+ *     detected via the `value` parameter instead
+ *
+ * Returns `null` for issue codes with no automatic mapping — caller handles
+ * these via `fallbackKey` (Option B).
+ */
+function zodIssueToHelixKey(issue, value) {
+    switch (issue.code) {
+        case ZodIssueCode.invalid_type:
+            // Zod v4 dropped the `received` field on invalid_type issues.
+            // Detect required (null/undefined) errors by checking the control value directly.
+            if (isEmptyValue(value))
+                return ValidatorKey.Required;
+            // integer: Zod v4 changed not_integer → invalid_type { expected: 'int' }
+            if (issue.expected === 'int')
+                return ValidatorKey.Integer;
+            // numeric type mismatch
+            if (issue.expected === 'number' ||
+                issue.expected === 'float') {
+                return ValidatorKey.Number;
+            }
+            return null;
+        case ZodIssueCode.invalid_format:
+            // Zod v4: replaces invalid_string for all format-based string validations.
+            // The `format` property holds the validation name.
+            {
+                const fmt = issue.format;
+                if (fmt === 'email')
+                    return ValidatorKey.Email;
+                if (fmt === 'regex')
+                    return ValidatorKey.Pattern;
+                if (fmt === 'datetime' || fmt === 'date' || fmt === 'time')
+                    return ValidatorKey.Date;
+            }
+            return null;
+        case ZodIssueCode.too_small:
+            // Zod v4: uses `origin` instead of `type` to identify the validated construct.
+            {
+                const origin = issue.origin;
+                if (origin === 'string' || origin === 'array')
+                    return ValidatorKey.MinLength;
+                if (origin === 'number')
+                    return ValidatorKey.Min;
+            }
+            return null;
+        case ZodIssueCode.too_big:
+            {
+                const origin = issue.origin;
+                if (origin === 'string' || origin === 'array')
+                    return ValidatorKey.MaxLength;
+                if (origin === 'number')
+                    return ValidatorKey.Max;
+            }
+            return null;
+        case ZodIssueCode.custom:
+            return null; // must be handled via fallbackKey (Option B)
+        default:
+            return null;
+    }
+}
+
+/** Built-in signal-forms error kinds → ValidatorKey. */
+const NG_KIND_TO_HELIX = {
+    required: ValidatorKey.Required,
+    min: ValidatorKey.Min,
+    max: ValidatorKey.Max,
+    minLength: ValidatorKey.MinLength,
+    maxLength: ValidatorKey.MaxLength,
+    pattern: ValidatorKey.Pattern,
+    email: ValidatorKey.Email,
+};
+/**
+ * Maps a signal-forms `ValidationError` to the `ValidatorKey` message
+ * convention shared with `HelixZodValidators.fromZod`.
+ *
+ * @param error The signal-forms validation error.
+ * @param value The current field value — used to distinguish Required from
+ *              type errors on Zod `invalid_type` issues (Zod v4 dropped the
+ *              `received` field).
+ */
+function helixErrorKey(error, value) {
+    if (error.kind === 'standardSchema') {
+        const issue = error.issue;
+        return zodIssueToHelixKey(issue, value);
+    }
+    return NG_KIND_TO_HELIX[error.kind] ?? null;
+}
+function defaultMessage(error) {
+    if (error.kind === 'standardSchema') {
+        const issue = error.issue;
+        return issue.message ?? null;
+    }
+    return error.message ?? null;
+}
+/**
+ * Returns the message of the first displayable error, mirroring
+ * `HelixFormField`'s first-error convention.
+ *
+ * Order of precedence per error: `resolver` result → Zod issue message /
+ * signal-forms error message. Errors yielding no message are skipped.
+ */
+function helixFirstErrorMessage(errors, options = {}) {
+    for (const error of errors) {
+        const resolved = options.resolver?.(error, helixErrorKey(error, options.value));
+        const message = resolved ?? defaultMessage(error);
+        if (message)
+            return message;
+    }
+    return null;
+}
+
+/**
+ * Base class for dynamic-form widgets. A widget is a standalone component with
+ * the two inputs below; `HelixDynamicField` instantiates it via
+ * `NgComponentOutlet` and feeds them in.
+ */
+class HelixFieldWidgetBase {
+    field = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
+    descriptor = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "descriptor" }] : /* istanbul ignore next */ []));
+    #errorResolver = inject(HELIX_ERROR_MESSAGE_RESOLVER, { optional: true });
+    state = computed(() => this.field()(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    /** Touched-gated first error message — mirrors `HelixFormField.activeError`. */
+    firstError = computed(() => {
+        const state = this.state();
+        if (!state.touched())
+            return null;
+        return helixFirstErrorMessage(state.errors(), {
+            value: state.value(),
+            resolver: this.#errorResolver ?? undefined,
+        });
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "firstError" }] : /* istanbul ignore next */ []));
+    label = computed(() => this.descriptor().meta.label ?? humanize(this.descriptor().key), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []));
+    hint = computed(() => this.descriptor().meta.hint, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hint" }] : /* istanbul ignore next */ []));
+    placeholder = computed(() => this.descriptor().meta.placeholder ?? '', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "placeholder" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixFieldWidgetBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.6", type: HelixFieldWidgetBase, isStandalone: true, inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, descriptor: { classPropertyName: "descriptor", publicName: "descriptor", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixFieldWidgetBase, decorators: [{
+            type: Directive
+        }], propDecorators: { field: [{ type: i0.Input, args: [{ isSignal: true, alias: "field", required: true }] }], descriptor: [{ type: i0.Input, args: [{ isSignal: true, alias: "descriptor", required: true }] }] } });
+/** `firstName` → `First name` — fallback label when meta provides none. */
+function humanize(key) {
+    if (!key)
+        return '';
+    const words = key
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .toLowerCase();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+/** Built-in widget for `z.array()` fields — item list with add/remove. */
+class HelixArrayWidget extends HelixFieldWidgetBase {
+    itemFields = computed(() => {
+        const length = (this.state().value() ?? []).length;
+        return Array.from({ length }, (_, index) => this.field()[index]);
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "itemFields" }] : /* istanbul ignore next */ []));
+    addLabel = computed(() => this.descriptor().meta.addLabel ?? 'Add', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "addLabel" }] : /* istanbul ignore next */ []));
+    removeLabel = computed(() => this.descriptor().meta.removeLabel ?? 'Remove', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "removeLabel" }] : /* istanbul ignore next */ []));
+    add() {
+        const item = this.descriptor().itemDescriptor;
+        if (!item)
+            return;
+        const value = buildDefaultValue(item.zodSource);
+        this.state().value.update((current) => [...(current ?? []), value]);
+    }
+    removeAt(index) {
+        this.state().value.update((current) => (current ?? []).filter((_, i) => i !== index));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixArrayWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixArrayWidget, isStandalone: true, selector: "helix-array-widget", usesInheritance: true, ngImport: i0, template: "<div class=\"helix-array-widget\">\n  @if (label(); as l) {\n    <div class=\"helix-array-widget__label\">{{ l }}</div>\n  }\n\n  @for (itemField of itemFields(); track $index) {\n    <div class=\"helix-array-widget__item\">\n      <helix-dynamic-field [field]=\"itemField\" [descriptor]=\"descriptor().itemDescriptor!\" />\n      <button\n        type=\"button\"\n        class=\"helix-array-widget__remove\"\n        (click)=\"removeAt($index)\"\n      >\n        {{ removeLabel() }}\n      </button>\n    </div>\n  }\n\n  <button type=\"button\" class=\"helix-array-widget__add\" (click)=\"add()\">{{ addLabel() }}</button>\n\n  @if (firstError(); as err) {\n    <small class=\"helix-array-widget__message helix-array-widget__message--error\">{{ err }}</small>\n  } @else if (hint(); as h) {\n    <small class=\"helix-array-widget__message helix-array-widget__message--hint\">{{ h }}</small>\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-array-widget{display:flex;flex-direction:column;gap:.75rem}.helix-array-widget__label{font-size:.875rem;font-weight:500;color:var(--h-text-color)}.helix-array-widget__item{display:flex;align-items:flex-start;gap:.5rem}.helix-array-widget__item helix-dynamic-field{flex:1}.helix-array-widget__add,.helix-array-widget__remove{padding:.375rem .75rem;font-family:inherit;font-size:.875rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);cursor:pointer;transition:border-color .2s}.helix-array-widget__add:hover,.helix-array-widget__remove:hover{border-color:var(--h-primary-color)}.helix-array-widget__add{align-self:flex-start}.helix-array-widget__message{font-size:.75rem}.helix-array-widget__message--hint{color:var(--h-text-muted-color)}.helix-array-widget__message--error{color:var(--h-red-500)}\n"], dependencies: [{ kind: "component", type: HelixDynamicField, selector: "helix-dynamic-field", inputs: ["field", "descriptor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixArrayWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-array-widget', standalone: true, imports: [HelixDynamicField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"helix-array-widget\">\n  @if (label(); as l) {\n    <div class=\"helix-array-widget__label\">{{ l }}</div>\n  }\n\n  @for (itemField of itemFields(); track $index) {\n    <div class=\"helix-array-widget__item\">\n      <helix-dynamic-field [field]=\"itemField\" [descriptor]=\"descriptor().itemDescriptor!\" />\n      <button\n        type=\"button\"\n        class=\"helix-array-widget__remove\"\n        (click)=\"removeAt($index)\"\n      >\n        {{ removeLabel() }}\n      </button>\n    </div>\n  }\n\n  <button type=\"button\" class=\"helix-array-widget__add\" (click)=\"add()\">{{ addLabel() }}</button>\n\n  @if (firstError(); as err) {\n    <small class=\"helix-array-widget__message helix-array-widget__message--error\">{{ err }}</small>\n  } @else if (hint(); as h) {\n    <small class=\"helix-array-widget__message helix-array-widget__message--hint\">{{ h }}</small>\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-array-widget{display:flex;flex-direction:column;gap:.75rem}.helix-array-widget__label{font-size:.875rem;font-weight:500;color:var(--h-text-color)}.helix-array-widget__item{display:flex;align-items:flex-start;gap:.5rem}.helix-array-widget__item helix-dynamic-field{flex:1}.helix-array-widget__add,.helix-array-widget__remove{padding:.375rem .75rem;font-family:inherit;font-size:.875rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);cursor:pointer;transition:border-color .2s}.helix-array-widget__add:hover,.helix-array-widget__remove:hover{border-color:var(--h-primary-color)}.helix-array-widget__add{align-self:flex-start}.helix-array-widget__message{font-size:.75rem}.helix-array-widget__message--hint{color:var(--h-text-muted-color)}.helix-array-widget__message--error{color:var(--h-red-500)}\n"] }]
+        }] });
+
+/** Built-in widget for boolean fields — checkbox with inline label. */
+class HelixCheckboxWidget extends HelixFieldWidgetBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixCheckboxWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixCheckboxWidget, isStandalone: true, selector: "helix-checkbox-widget", usesInheritance: true, ngImport: i0, template: "<div class=\"helix-checkbox-widget\">\n  <label class=\"helix-checkbox-widget__label\">\n    <input class=\"helix-checkbox-widget__input\" type=\"checkbox\" [formField]=\"field()\" />\n    <span>{{ label() }}</span>\n  </label>\n\n  @if (firstError(); as err) {\n    <small class=\"helix-checkbox-widget__message helix-checkbox-widget__message--error\">{{ err }}</small>\n  } @else if (hint(); as h) {\n    <small class=\"helix-checkbox-widget__message helix-checkbox-widget__message--hint\">{{ h }}</small>\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-checkbox-widget{display:flex;flex-direction:column;gap:.5rem}.helix-checkbox-widget__label{display:inline-flex;align-items:center;gap:.5rem;font-size:.875rem;color:var(--h-text-color);cursor:pointer}.helix-checkbox-widget__input{accent-color:var(--h-primary-color);width:1rem;height:1rem}.helix-checkbox-widget__message{font-size:.75rem}.helix-checkbox-widget__message--hint{color:var(--h-text-muted-color)}.helix-checkbox-widget__message--error{color:var(--h-red-500)}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixCheckboxWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-checkbox-widget', standalone: true, imports: [FormField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"helix-checkbox-widget\">\n  <label class=\"helix-checkbox-widget__label\">\n    <input class=\"helix-checkbox-widget__input\" type=\"checkbox\" [formField]=\"field()\" />\n    <span>{{ label() }}</span>\n  </label>\n\n  @if (firstError(); as err) {\n    <small class=\"helix-checkbox-widget__message helix-checkbox-widget__message--error\">{{ err }}</small>\n  } @else if (hint(); as h) {\n    <small class=\"helix-checkbox-widget__message helix-checkbox-widget__message--hint\">{{ h }}</small>\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-checkbox-widget{display:flex;flex-direction:column;gap:.5rem}.helix-checkbox-widget__label{display:inline-flex;align-items:center;gap:.5rem;font-size:.875rem;color:var(--h-text-color);cursor:pointer}.helix-checkbox-widget__input{accent-color:var(--h-primary-color);width:1rem;height:1rem}.helix-checkbox-widget__message{font-size:.75rem}.helix-checkbox-widget__message--hint{color:var(--h-text-muted-color)}.helix-checkbox-widget__message--error{color:var(--h-red-500)}\n"] }]
+        }] });
+
+function toIsoDate(value) {
+    const y = value.getFullYear().toString().padStart(4, '0');
+    const m = (value.getMonth() + 1).toString().padStart(2, '0');
+    const d = value.getDate().toString().padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}
+/**
+ * Native `<input type="date">` exposed as a signal-forms `FormValueControl`
+ * with a `Date | null` model — string↔Date conversion via `transformedValue`.
+ */
+class HelixDateInput {
+    value = model.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    disabled = input(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []));
+    readonly = input(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+    touched = model(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "touched" }] : /* istanbul ignore next */ []));
+    rawValue = transformedValue(this.value, {
+        parse: (raw) => {
+            if (raw === '')
+                return { value: null };
+            const parsed = new Date(`${raw}T00:00:00`);
+            if (Number.isNaN(parsed.getTime())) {
+                return { error: { kind: 'parse', message: `"${raw}" is not a valid date` } };
+            }
+            return { value: parsed };
+        },
+        format: (value) => (value ? toIsoDate(value) : ''),
+    });
+    onInput(event) {
+        this.rawValue.set(event.target.value);
+    }
+    onBlur() {
+        this.touched.set(true);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDateInput, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.6", type: HelixDateInput, isStandalone: true, selector: "helix-date-input", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null }, touched: { classPropertyName: "touched", publicName: "touched", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", touched: "touchedChange" }, ngImport: i0, template: "<input\n  class=\"helix-date-input__input\"\n  type=\"date\"\n  [value]=\"rawValue()\"\n  [disabled]=\"disabled()\"\n  [readonly]=\"readonly()\"\n  (input)=\"onInput($event)\"\n  (blur)=\"onBlur()\"\n/>\n", styles: [":host{display:block;width:100%}.helix-date-input__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-date-input__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-date-input__input:disabled,.helix-date-input__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-date-input__input::placeholder{color:var(--h-text-muted-color)}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDateInput, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-date-input', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: "<input\n  class=\"helix-date-input__input\"\n  type=\"date\"\n  [value]=\"rawValue()\"\n  [disabled]=\"disabled()\"\n  [readonly]=\"readonly()\"\n  (input)=\"onInput($event)\"\n  (blur)=\"onBlur()\"\n/>\n", styles: [":host{display:block;width:100%}.helix-date-input__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-date-input__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-date-input__input:disabled,.helix-date-input__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-date-input__input::placeholder{color:var(--h-text-muted-color)}\n"] }]
+        }], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: true }] }, { type: i0.Output, args: ["valueChange"] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], touched: [{ type: i0.Input, args: [{ isSignal: true, alias: "touched", required: false }] }, { type: i0.Output, args: ["touchedChange"] }] } });
+
+/** Built-in widget for `z.date()` fields. */
+class HelixDateWidget extends HelixFieldWidgetBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDateWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.6", type: HelixDateWidget, isStandalone: true, selector: "helix-date-widget", usesInheritance: true, ngImport: i0, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <helix-date-input [formField]=\"field()\" />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }, { kind: "component", type: HelixDateInput, selector: "helix-date-input", inputs: ["value", "disabled", "readonly", "touched"], outputs: ["valueChange", "touchedChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixDateWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-date-widget', standalone: true, imports: [FormField, HelixFormField, HelixDateInput], changeDetection: ChangeDetectionStrategy.OnPush, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <helix-date-input [formField]=\"field()\" />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}\n"] }]
+        }] });
+
+/** Built-in widget for numeric fields. */
+class HelixNumberWidget extends HelixFieldWidgetBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixNumberWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.6", type: HelixNumberWidget, isStandalone: true, selector: "helix-number-widget", usesInheritance: true, ngImport: i0, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <input\n    class=\"helix-number-widget__input\"\n    type=\"number\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-number-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-number-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-number-widget__input:disabled,.helix-number-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-number-widget__input::placeholder{color:var(--h-text-muted-color)}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixNumberWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-number-widget', standalone: true, imports: [FormField, HelixFormField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <input\n    class=\"helix-number-widget__input\"\n    type=\"number\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-number-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-number-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-number-widget__input:disabled,.helix-number-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-number-widget__input::placeholder{color:var(--h-text-muted-color)}\n"] }]
+        }] });
+
+/** Built-in widget for nested `z.object()` fields — fieldset + recursion. */
+class HelixObjectWidget extends HelixFieldWidgetBase {
+    childField(key) {
+        return this.field()[key];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixObjectWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixObjectWidget, isStandalone: true, selector: "helix-object-widget", usesInheritance: true, ngImport: i0, template: "<fieldset class=\"helix-object-widget\">\n  @if (label(); as l) {\n    <legend class=\"helix-object-widget__legend\">{{ l }}</legend>\n  }\n  @if (hint(); as h) {\n    <small class=\"helix-object-widget__hint\">{{ h }}</small>\n  }\n\n  @for (child of descriptor().children ?? []; track child.key) {\n    <helix-dynamic-field [field]=\"childField(child.key)\" [descriptor]=\"child\" />\n  }\n</fieldset>\n", styles: [":host{display:block;width:100%}.helix-object-widget{display:flex;flex-direction:column;gap:1rem;margin:0;padding:1rem;border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md)}.helix-object-widget__legend{padding:0 .5rem;font-size:.875rem;font-weight:600;color:var(--h-text-color)}.helix-object-widget__hint{font-size:.75rem;color:var(--h-text-muted-color)}\n"], dependencies: [{ kind: "component", type: HelixDynamicField, selector: "helix-dynamic-field", inputs: ["field", "descriptor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixObjectWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-object-widget', standalone: true, imports: [HelixDynamicField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<fieldset class=\"helix-object-widget\">\n  @if (label(); as l) {\n    <legend class=\"helix-object-widget__legend\">{{ l }}</legend>\n  }\n  @if (hint(); as h) {\n    <small class=\"helix-object-widget__hint\">{{ h }}</small>\n  }\n\n  @for (child of descriptor().children ?? []; track child.key) {\n    <helix-dynamic-field [field]=\"childField(child.key)\" [descriptor]=\"child\" />\n  }\n</fieldset>\n", styles: [":host{display:block;width:100%}.helix-object-widget{display:flex;flex-direction:column;gap:1rem;margin:0;padding:1rem;border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md)}.helix-object-widget__legend{padding:0 .5rem;font-size:.875rem;font-weight:600;color:var(--h-text-color)}.helix-object-widget__hint{font-size:.75rem;color:var(--h-text-muted-color)}\n"] }]
+        }] });
+
+/**
+ * Built-in widget for enum/select fields — wraps `HelixSelect`, which the
+ * signal-forms `FormField` directive binds via its `ControlValueAccessor`.
+ */
+class HelixSelectWidget extends HelixFieldWidgetBase {
+    selectOptions = computed(() => [...(this.descriptor().options ?? [])], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "selectOptions" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixSelectWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.6", type: HelixSelectWidget, isStandalone: true, selector: "helix-select-widget", usesInheritance: true, ngImport: i0, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <helix-select\n    [options]=\"selectOptions()\"\n    [placeholder]=\"placeholder()\"\n    [disabled]=\"state().disabled()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }, { kind: "component", type: HelixSelect, selector: "helix-select", inputs: ["options", "optionLabel", "optionValue", "placeholder", "disabled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixSelectWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-select-widget', standalone: true, imports: [FormField, HelixFormField, HelixSelect], changeDetection: ChangeDetectionStrategy.OnPush, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <helix-select\n    [options]=\"selectOptions()\"\n    [placeholder]=\"placeholder()\"\n    [disabled]=\"state().disabled()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}\n"] }]
+        }] });
+
+/** Built-in widget for `text`, `email` and `password` fields. */
+class HelixTextWidget extends HelixFieldWidgetBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixTextWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.6", type: HelixTextWidget, isStandalone: true, selector: "helix-text-widget", usesInheritance: true, ngImport: i0, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <input\n    class=\"helix-text-widget__input\"\n    [type]=\"descriptor().inputType ?? 'text'\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-text-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-text-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-text-widget__input:disabled,.helix-text-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-text-widget__input::placeholder{color:var(--h-text-muted-color)}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixTextWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-text-widget', standalone: true, imports: [FormField, HelixFormField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <input\n    class=\"helix-text-widget__input\"\n    [type]=\"descriptor().inputType ?? 'text'\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  />\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-text-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-text-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-text-widget__input:disabled,.helix-text-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-text-widget__input::placeholder{color:var(--h-text-muted-color)}\n"] }]
+        }] });
+
+/** Built-in widget for multiline text (`widget: 'textarea'`). */
+class HelixTextareaWidget extends HelixFieldWidgetBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixTextareaWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.6", type: HelixTextareaWidget, isStandalone: true, selector: "helix-textarea-widget", usesInheritance: true, ngImport: i0, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <textarea\n    class=\"helix-textarea-widget__input\"\n    rows=\"4\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  ></textarea>\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-textarea-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-textarea-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-textarea-widget__input:disabled,.helix-textarea-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-textarea-widget__input::placeholder{color:var(--h-text-muted-color)}.helix-textarea-widget__input{resize:vertical}\n"], dependencies: [{ kind: "directive", type: FormField, selector: "[formField]", inputs: ["formField"], exportAs: ["formField"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixTextareaWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-textarea-widget', standalone: true, imports: [FormField, HelixFormField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n  <textarea\n    class=\"helix-textarea-widget__input\"\n    rows=\"4\"\n    [placeholder]=\"placeholder()\"\n    [formField]=\"field()\"\n  ></textarea>\n</helix-form-field>\n", styles: [":host{display:block;width:100%}.helix-textarea-widget__input{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-textarea-widget__input:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-textarea-widget__input:disabled,.helix-textarea-widget__input[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-textarea-widget__input::placeholder{color:var(--h-text-muted-color)}.helix-textarea-widget__input{resize:vertical}\n"] }]
+        }] });
+
+/**
+ * Built-in widget for `z.discriminatedUnion()` fields: a discriminator select
+ * plus the active variant's fields.
+ *
+ * Switching the discriminator **resets** the union value to the new variant's
+ * default (preserving the discriminator) — mandatory so the model always
+ * matches the active variant's shape and all field paths exist.
+ */
+class HelixUnionWidget extends HelixFieldWidgetBase {
+    discriminator = computed(() => this.descriptor().union?.discriminator ?? '', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "discriminator" }] : /* istanbul ignore next */ []));
+    tags = computed(() => [...(this.descriptor().union?.variants.keys() ?? [])], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "tags" }] : /* istanbul ignore next */ []));
+    activeTag = computed(() => this.state().value()?.[this.discriminator()], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "activeTag" }] : /* istanbul ignore next */ []));
+    variantChildren = computed(() => {
+        const variant = this.descriptor().union?.variants.get(this.activeTag());
+        return (variant?.children ?? []).filter((c) => c.key !== this.discriminator());
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "variantChildren" }] : /* istanbul ignore next */ []));
+    childField(key) {
+        return this.field()[key];
+    }
+    onTagChange(event) {
+        const index = Number.parseInt(event.target.value, 10);
+        const tag = this.tags()[index];
+        const variant = this.descriptor().union?.variants.get(tag);
+        if (variant === undefined || tag === this.activeTag())
+            return;
+        const next = buildDefaultValue(variant.zodSource);
+        next[this.discriminator()] = tag;
+        this.state().value.set(next);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixUnionWidget, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: HelixUnionWidget, isStandalone: true, selector: "helix-union-widget", usesInheritance: true, ngImport: i0, template: "<div class=\"helix-union-widget\">\n  <helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n    <div class=\"helix-union-widget__select-wrapper\">\n      <select\n        class=\"helix-union-widget__select\"\n        [disabled]=\"state().disabled()\"\n        (change)=\"onTagChange($event)\"\n      >\n        @for (tag of tags(); track tag) {\n          <option [value]=\"$index\" [selected]=\"tag === activeTag()\">{{ tag }}</option>\n        }\n      </select>\n      <i class=\"helix-union-widget__icon pi pi-chevron-down\"></i>\n    </div>\n  </helix-form-field>\n\n  @for (child of variantChildren(); track child.key) {\n    <helix-dynamic-field [field]=\"childField(child.key)\" [descriptor]=\"child\" />\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-union-widget{display:flex;flex-direction:column;gap:1rem}.helix-union-widget__select-wrapper{position:relative;display:flex;width:100%}.helix-union-widget__select{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-union-widget__select:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-union-widget__select:disabled,.helix-union-widget__select[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-union-widget__select::placeholder{color:var(--h-text-muted-color)}.helix-union-widget__select{padding-right:2.5rem;appearance:none;cursor:pointer}.helix-union-widget__icon{position:absolute;top:50%;right:.75rem;transform:translateY(-50%);pointer-events:none;color:var(--h-text-muted-color);font-size:.875rem}\n"], dependencies: [{ kind: "component", type: HelixDynamicField, selector: "helix-dynamic-field", inputs: ["field", "descriptor"] }, { kind: "component", type: HelixFormField, selector: "helix-form-field", inputs: ["label", "control", "hint", "error", "showLabel", "showHint"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: HelixUnionWidget, decorators: [{
+            type: Component,
+            args: [{ selector: 'helix-union-widget', standalone: true, imports: [HelixDynamicField, HelixFormField], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"helix-union-widget\">\n  <helix-form-field [label]=\"label()\" [hint]=\"hint()\" [error]=\"firstError()\">\n    <div class=\"helix-union-widget__select-wrapper\">\n      <select\n        class=\"helix-union-widget__select\"\n        [disabled]=\"state().disabled()\"\n        (change)=\"onTagChange($event)\"\n      >\n        @for (tag of tags(); track tag) {\n          <option [value]=\"$index\" [selected]=\"tag === activeTag()\">{{ tag }}</option>\n        }\n      </select>\n      <i class=\"helix-union-widget__icon pi pi-chevron-down\"></i>\n    </div>\n  </helix-form-field>\n\n  @for (child of variantChildren(); track child.key) {\n    <helix-dynamic-field [field]=\"childField(child.key)\" [descriptor]=\"child\" />\n  }\n</div>\n", styles: [":host{display:block;width:100%}.helix-union-widget{display:flex;flex-direction:column;gap:1rem}.helix-union-widget__select-wrapper{position:relative;display:flex;width:100%}.helix-union-widget__select{width:100%;padding:.5rem .75rem;font-family:inherit;font-size:1rem;color:var(--h-text-color);background-color:var(--h-content-background);border:1px solid var(--h-content-border-color);border-radius:var(--h-border-radius-md);transition:border-color .2s,box-shadow .2s}.helix-union-widget__select:focus{outline:0 none;outline-offset:0;border-color:var(--h-primary-color);box-shadow:0 0 0 .2rem var(--h-primary-100)}.helix-union-widget__select:disabled,.helix-union-widget__select[readonly]{cursor:default;background-color:var(--h-content-disabled-background);color:var(--h-text-disabled-color);opacity:1}.helix-union-widget__select::placeholder{color:var(--h-text-muted-color)}.helix-union-widget__select{padding-right:2.5rem;appearance:none;cursor:pointer}.helix-union-widget__icon{position:absolute;top:50%;right:.75rem;transform:translateY(-50%);pointer-events:none;color:var(--h-text-muted-color);font-size:.875rem}\n"] }]
+        }] });
+
+const BUILT_IN_WIDGETS = [
+    { widget: 'text', component: HelixTextWidget },
+    { widget: 'email', component: HelixTextWidget },
+    { widget: 'password', component: HelixTextWidget },
+    { widget: 'textarea', component: HelixTextareaWidget },
+    { widget: 'number', component: HelixNumberWidget },
+    { widget: 'checkbox', component: HelixCheckboxWidget },
+    { widget: 'select', component: HelixSelectWidget },
+    { widget: 'date', component: HelixDateWidget },
+    { widget: 'object', component: HelixObjectWidget },
+    { widget: 'array', component: HelixArrayWidget },
+    { widget: 'union', component: HelixUnionWidget },
+];
+/**
+ * Provides the dynamic-form widget registry (built-in widgets included) and
+ * optional configuration. Add it to `ApplicationConfig.providers` or a route's
+ * `providers`.
+ */
+function provideHelixDynamicForms(config = {}) {
+    const providers = [
+        { provide: HELIX_DYNAMIC_FIELD_WIDGETS, multi: true, useValue: BUILT_IN_WIDGETS },
+        // Re-provide the resolver here so it is created in THIS environment
+        // injector and sees the registrations above. The `providedIn: 'root'`
+        // fallback instance cannot see route-scoped providers.
+        HelixFieldWidgetResolver,
+    ];
+    if (config.widgets?.length) {
+        providers.push({ provide: HELIX_DYNAMIC_FIELD_WIDGETS, multi: true, useValue: config.widgets });
+    }
+    if (config.errorMessageResolver) {
+        providers.push({
+            provide: HELIX_ERROR_MESSAGE_RESOLVER,
+            useValue: config.errorMessageResolver,
+        });
+    }
+    return makeEnvironmentProviders(providers);
+}
+
+/**
+ * Navigates a `FieldTree` by a root-relative property path
+ * (e.g. `['address', 'city']`).
+ */
+function fieldAtPath(tree, path) {
+    let current = tree;
+    for (const key of path) {
+        current = current[key];
+        if (current === undefined) {
+            throw new Error(`[fieldAtPath] No field at path "${path.join('.')}" (missing key "${key}").`);
+        }
+    }
+    return current;
+}
+
+const HelixZodValidators = {
+    /**
+     * Converts a Zod field schema into a Helix-compatible Angular `ValidatorFn`.
+     *
+     * Each `ZodIssue` is mapped to its `ValidatorKey`. `HelixFormField` reads
+     * those keys directly — no template changes required.
+     *
+     * All issues from a single `safeParse` are processed simultaneously, producing
+     * one `ValidationErrors` key per issue — equivalent to stacking multiple
+     * `Validators` calls.
+     *
+     * ### Known gaps
+     * - `ValidatorKey.OneOf` / `AllOf` — `z.enum()` produces `invalid_value`,
+     *   which has no automatic mapping. Use `fallbackKey` or continue using
+     *   `Validators.oneOf` / `Validators.allOf`.
+     * - `invalid_type` for `boolean` expected — Helix has no `Boolean` key.
+     *   Use `fallbackKey` or `Validators.pattern`.
+     *
+     * @param schema    A Zod field schema (e.g. `UserSchema.shape.email`).
+     *                  Do NOT pass schemas with `.transform()` — use the
+     *                  input-only (pre-transform) variant for form controls.
+     * @param options   `allowEmpty` (default `true`) and optional `fallbackKey`
+     *                  for `.refine()` / `custom` validators.
+     *
+     * @example
+     * // Standard field — no fallbackKey needed
+     * HelixZodValidators.fromZod(UserSchema.shape.email)
+     *
+     * @example
+     * // Schema with .refine() — fallbackKey required (Option B)
+     * HelixZodValidators.fromZod(
+     *   z.string().refine(v => !banned.includes(v), 'Username not allowed'),
+     *   { fallbackKey: ValidatorKey.Pattern },
+     * )
+     *
+     * @example
+     * // Required field — disable allowEmpty so empty value triggers Required / MinLength
+     * HelixZodValidators.fromZod(UserSchema.shape.name, { allowEmpty: false })
+     */
+    fromZod(schema, options = {}) {
+        const { fallbackKey, allowEmpty = true } = options;
+        return (control) => {
+            const value = control.value;
+            // Replicate Validators' allowEmpty = true default:
+            // skip Zod entirely for empty values unless the caller opts out.
+            if (allowEmpty && isEmptyValue(value)) {
+                return null;
+            }
+            const result = schema.safeParse(value);
+            if (result.success)
+                return null;
+            const errors = {};
+            for (const issue of result.error.issues) {
+                const key = zodIssueToHelixKey(issue, value);
+                if (key !== null) {
+                    errors[key] = issue.message;
+                    continue;
+                }
+                // No automatic mapping — apply Option B logic.
+                if (fallbackKey !== undefined) {
+                    errors[fallbackKey] = issue.message;
+                }
+                else {
+                    // ngDevMode is set by Angular's build toolchain:
+                    // true in development builds, false (tree-shaken) in production.
+                    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+                        throw new Error(`[HelixZodValidators.fromZod] Zod issue code "${issue.code}" has no ` +
+                            `automatic ValidatorKey mapping.\n` +
+                            `Pass { fallbackKey: ValidatorKey.xxx } as the second argument.\n` +
+                            `Failing issue: ${JSON.stringify(issue, null, 2)}`);
+                    }
+                    // Production: skip the unmapped issue silently.
+                    // The control remains invalid if other issues produce mapped errors.
+                }
+            }
+            return Object.keys(errors).length ? errors : null;
+        };
+    },
+};
+
+/*
+ * Public API Surface of @gravionlabs/helix-zod
+ */
+// Dynamic forms — components
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { HELIX_DYNAMIC_FIELD_WIDGETS, HELIX_ERROR_MESSAGE_RESOLVER, HelixArrayWidget, HelixCheckboxWidget, HelixDateInput, HelixDateWidget, HelixDynamicField, HelixDynamicForm, HelixFieldWidgetBase, HelixFieldWidgetResolver, HelixNumberWidget, HelixObjectWidget, HelixSelectWidget, HelixTextWidget, HelixTextareaWidget, HelixUnionWidget, HelixZodValidators, buildDefaultValue, buildHelixSchema, fieldAtPath, helixErrorKey, helixFieldMetaRegistry, helixFirstErrorMessage, helixMeta, provideHelixDynamicForms, readHelixMeta, zodToFieldDescriptors };
+//# sourceMappingURL=gravionlabs-helix-zod.mjs.map