@ng-forge/dynamic-forms 1.2.0-next.9 → 1.3.0-next.1

package/types/ng-forge-dynamic-forms-internal.d.ts

@@ -83,6 +83,45 @@ interface FieldMeta {
     [key: string]: string | number | boolean | undefined;
 }
 
+/**
+ * Per-field WebMCP exposure policy.
+ *
+ * WebMCP tools are callable by any agent that reaches the page, so what a field
+ * lets an agent read and write is a security decision, not a formatting one.
+ * Sensible defaults are derived from the field itself (see below); this
+ * overrides them where the author knows better.
+ *
+ * Defaults, applied when a key is left unset:
+ *
+ * | Field | `readable` | `writable` |
+ * | --- | --- | --- |
+ * | `type: 'hidden'` | `false` | `false` |
+ * | `props.type === 'password'` | `false` | `true` |
+ * | `readonly: true`, or a `derivation` | `true` | `false` |
+ * | anything else | `true` | `true` |
+ *
+ * @experimental
+ */
+interface FieldWebMcpOptions {
+    /**
+     * Whether an agent may read this field's value back in a tool response.
+     *
+     * A field that is not readable is still reported by name, so the agent knows
+     * it exists and whether it currently holds a value — only the value itself is
+     * withheld.
+     */
+    readable?: boolean;
+    /** Whether an agent may write this field. A write to a non-writable field is rejected. */
+    writable?: boolean;
+}
+/**
+ * A field's WebMCP exposure policy. `false` is shorthand for hiding the field
+ * from agents entirely (`{ readable: false, writable: false }`).
+ *
+ * @experimental
+ */
+type FieldWebMcpConfig = FieldWebMcpOptions | false;
+
 /**
  * Base interface for all dynamic form field definitions.
  *
@@ -168,6 +207,17 @@ interface FieldDef<TProps, TMeta extends FieldMeta = FieldMeta> {
     skipDefaultWrappers?: boolean;
     /** Addons rendered inside this field's slots (typically `prefix` / `suffix`). */
     addons?: ReadonlyArray<AnyAddon>;
+    /**
+     * What a browser AI agent may read and write on this field, when the form
+     * opts in through `options.webMcp`. Ignored otherwise.
+     *
+     * Defaults are derived from the field (a password input is not readable, a
+     * `readonly` or derived field is not writable, a `hidden` field type is
+     * neither); `false` hides the field from agents entirely.
+     *
+     * @experimental
+     */
+    webMcp?: FieldWebMcpConfig;
 }
 type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
 /**
@@ -1695,6 +1745,67 @@ interface FormOptions {
      * @default undefined (uses global setting)
      */
     emitFormValueOnEvents?: boolean;
+    /**
+     * Exposes this form to browser AI agents as WebMCP tools.
+     *
+     * Requires the `withExperimentalWebMcp()` feature on `provideDynamicForm(...)`. Registers
+     * `fill_{name}`, which applies a partial patch of values and reports the
+     * form's state back. Submission stays off unless `allowSubmit` is set.
+     *
+     * Experimental: WebMCP is an emerging standard and Angular's underlying APIs
+     * are marked experimental, so this may change outside a major version.
+     *
+     * @example
+     * ```typescript
+     * options: { webMcp: { name: 'invoice', description: 'Create an invoice for a customer.' } }
+     * ```
+     *
+     * @default undefined (form is not exposed to agents)
+     */
+    webMcp?: WebMcpToolOptions;
+}
+/** Identifies a form's WebMCP tools to connected AI agents. */
+interface WebMcpToolOptions {
+    /**
+     * Base name for this form's tools, used as `fill_{name}` and (when submission
+     * is allowed) `submit_{name}`. Must be unique across every form on the page.
+     */
+    name: string;
+    /** What this form is for, and when an agent should reach for it. */
+    description: string;
+    /**
+     * Whether an agent may submit this form directly.
+     *
+     * Off by default. Every registered tool is callable by any agent that reaches
+     * the page, including one acting on injected instructions from elsewhere, so
+     * submission is treated as the consequential step and kept opt-in. With it
+     * off, an agent can still fill the form and a human presses the button.
+     *
+     * Leave it off for anything that spends money, sends a message, or cannot be
+     * undone.
+     *
+     * @default false
+     */
+    allowSubmit?: boolean;
+    /**
+     * How much of the form a tool response hands back to the agent.
+     *
+     * `'changed'` (the default) returns only the values the call itself set, plus
+     * which fields apply, which are still empty, and any validation errors. That
+     * is enough for an agent to orient itself and correct its own work without
+     * being handed every value the form already held — prefilled personal data,
+     * identifiers, anything a user typed before the agent arrived.
+     *
+     * `'all'` returns the whole model, minus fields whose `webMcp.readable` is
+     * off. Choose it deliberately: every registered tool is callable by any agent
+     * that reaches the page, and Chrome's guidance is that even a read-only tool
+     * can reveal user information.
+     *
+     * @see https://developer.chrome.com/docs/ai/webmcp/secure-tools
+     *
+     * @default 'changed'
+     */
+    readback?: 'changed' | 'all';
 }
 /** Options for controlling submit button disabled behavior. */
 interface SubmitButtonOptions {
@@ -3173,7 +3284,7 @@ interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta, TNullabl
     nullable?: TNullable;
 }
 declare function isCheckedField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseCheckedField<TProps, TMeta, boolean>;
-type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
+type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons' | 'webMcp';
 type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
 
 /**
@@ -3197,7 +3308,7 @@ interface BaseValueField<TProps, TValue, TMeta extends FieldMeta = FieldMeta, TN
     nullable?: TNullable;
 }
 declare function isValueField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseValueField<TProps, ValueType, TMeta, boolean>;
-type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'valueType' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas' | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
+type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'valueType' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas' | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons' | 'webMcp';
 type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
 
 /** Base interface for all form events in the dynamic form system. */
@@ -3907,4 +4018,4 @@ declare abstract class FieldErrorsWrapperBase implements FieldWrapper, FieldErro
 declare function provideFieldErrorDisplay(wrapper: () => Type<FieldErrorDisplayClaim>): Provider;
 
 export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, EventBus, ExpressionParser, ExpressionParserError, FIELD_ERROR_DISPLAY, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FieldErrorsWrapperBase, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_COMPONENT_LOAD_CACHE, WRAPPER_REGISTRY, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createDebouncedLogicFunction, createDefaultDerivationLogConfig, createDynamicValueFunction, createFieldValueProxy, createFormFieldStateMap, createFormStateLogicFunction, createInitializationTracker, createLogicFunction, createResolvedErrorsSignal, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getChangedKeysWithin, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldErrors, injectFieldSignalContext, injectFieldsSupportingAddons, injectNonFieldEvaluationContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, provideFieldErrorDisplay, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowError, rowFieldMapper, runPresetAction, setupInitializationTracking, shouldLog, shouldShowErrors, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
-export type { ASTNode, AddonActionContext, AddonActionHandler, AddonActionPreset, AddonShapeValidator, AddonSlot, AddonTypeDefinition, AddonTypeRegistryRef, AddonTypeSchema, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, ContainerValidation, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldErrorDisplayClaim, FieldErrors, FieldErrorsOptions, FieldErrorsWrapper, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormModel, InferFormValue, InitialPageConfig, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedError, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowErrorSpec, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorAttachment, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };
+export type { ASTNode, AddonActionContext, AddonActionHandler, AddonActionPreset, AddonShapeValidator, AddonSlot, AddonTypeDefinition, AddonTypeRegistryRef, AddonTypeSchema, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, ContainerValidation, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldErrorDisplayClaim, FieldErrors, FieldErrorsOptions, FieldErrorsWrapper, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWebMcpConfig, FieldWebMcpOptions, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormModel, InferFormValue, InitialPageConfig, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedError, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowErrorSpec, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorAttachment, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WebMcpToolOptions, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };

package/types/ng-forge-dynamic-forms.d.ts

@@ -3,7 +3,7 @@ import * as _angular_forms_signals from '@angular/forms/signals';
 import { FieldTree } from '@angular/forms/signals';
 import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
 import { FormEvent, FieldDef, RegisteredFieldTypes, InferFormModel, FormConfig, FormOptions, EventBus, LazyComponentLoader, WrapperTypeDefinition, FieldTypeDefinition, InferFormValue as InferFormValue$1, DerivationLogLevel, Logger, ValueExclusionConfig, ValidationExecutionConfig, TextAddon, WrapperFieldInputs, TemplateAddon, ComponentAddon, BaseAddon, AddonTypeDefinition, AddonActionHandler, ArrayItemDefinition } from '@ng-forge/dynamic-forms/internal';
-export { AddonActionContext, AddonActionPreset, AddonSlot, AddonTypeDefinition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, InitialPageConfig, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowErrorSpec, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WithInputSignals, WrapperConfig, WrapperTypeDefinition, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError } from '@ng-forge/dynamic-forms/internal';
+export { AddonActionContext, AddonActionPreset, AddonSlot, AddonTypeDefinition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, InitialPageConfig, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowErrorSpec, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WebMcpToolOptions, WithInputSignals, WrapperConfig, WrapperTypeDefinition, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError } from '@ng-forge/dynamic-forms/internal';
 import * as _angular_core from '@angular/core';
 import { Type, Injector, Signal, EnvironmentInjector, WritableSignal, Provider, EnvironmentProviders, TemplateRef } from '@angular/core';
 import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
@@ -231,6 +231,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
         excludeValueIfReadonly?: boolean;
         validateWhenHidden?: boolean;
         emitFormValueOnEvents?: boolean;
+        webMcp?: _ng_forge_dynamic_forms.WebMcpToolOptions;
     }>;
     /** Field signal context for injection into child components */
     fieldSignalContext: Signal<_ng_forge_dynamic_forms_internal.FieldSignalContext<TModel>>;
@@ -259,6 +260,21 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Whether to render the form template */
     private derivationReady;
     shouldRender: Signal<boolean>;
+    /**
+     * What the experimental WebMCP layer is doing for this form.
+     *
+     * Injecting it is also what instantiates the gate (component providers are
+     * lazy), which is what keeps the registrar lazily loaded. Intentionally absent
+     * from `shouldRender`: agent visibility must never gate render.
+     *
+     * `'disabled'` unless `withExperimentalWebMcp()` is provided; `'idle'` until a
+     * config declares `options.webMcp`; `'active'` once its tools are registered.
+     * `'failed'` and `'unsupported'` are the two ways registration does not
+     * happen, and are worth surfacing rather than guessing at.
+     *
+     * @experimental
+     */
+    readonly webMcpStatus: Signal<_ng_forge_dynamic_forms.WebMcpStatus>;
     /** Resolved fields ready for rendering */
     protected resolvedFields: Signal<ResolvedField[]>;
     /**
@@ -618,6 +634,135 @@ declare function withFieldWindowing(config?: {
     park?: FieldParkingOption;
 }): DynamicFormFeature<'field-windowing'>;
 
+/**
+ * Enables WebMCP tool registration for forms that declare `options.webMcp`.
+ *
+ * @experimental
+ *
+ * @remarks
+ * WebMCP lets an AI agent running in the browser discover and drive a form
+ * through structured tools rather than by simulating clicks. Each opted-in form
+ * registers `fill_{name}`, which applies a partial patch of values to the form
+ * and reports back what it set, which fields apply, which are still empty, and
+ * any validation errors. Submission is a separate, per-form opt-in
+ * (`options.webMcp.allowSubmit`); without it the agent stages values and a human
+ * presses the button.
+ *
+ * The tool schema is generated from the form config, so agents see labels,
+ * option enums with their human titles, and static validator constraints rather
+ * than the bare types value-shape inference would produce. Agent arguments are
+ * validated in code before anything is written, and a call that does not parse
+ * is rejected whole rather than half-applied.
+ *
+ * Nothing is registered unless a form opts in, and the registrar module is
+ * dynamically imported, so a form without `options.webMcp` never loads it — the
+ * feature itself, the token and the form-scoped hook that decides are part of
+ * the main bundle. Registration is browser-only and no-ops where the page
+ * exposes no model context.
+ *
+ * Named `experimental` on purpose: WebMCP is a proposed standard, in an origin
+ * trial as of Chrome 149, and the browser surface underneath this may still
+ * change. Expect breaking changes outside a major version.
+ *
+ * @returns A DynamicFormFeature enabling WebMCP registration.
+ *
+ * @example
+ * ```typescript
+ * provideDynamicForm(...withMaterialFields(), withExperimentalWebMcp());
+ *
+ * const config = {
+ *   options: { webMcp: { name: 'signup', description: 'Sign a new user up.' } },
+ *   fields: [...],
+ * } as const satisfies FormConfig;
+ * ```
+ */
+declare function withExperimentalWebMcp(): DynamicFormFeature<'web-mcp'>;
+
+/**
+ * What the WebMCP layer is currently doing for this form. Reported by
+ * `DynamicForm.webMcpStatus()`; `'active'` is the only state in which an agent
+ * can see the form.
+ *
+ * @experimental
+ */
+type WebMcpStatus = 
+/** `withExperimentalWebMcp()` is not provided, or this is the server. */
+'disabled'
+/** Enabled, but the current config does not declare `options.webMcp`. */
+ | 'idle'
+/** Loading the registrar or awaiting `registerTool()`. */
+ | 'registering'
+/** Tools are registered against the browser's model context. */
+ | 'active'
+/** The browser exposes no model context, so there is nothing to register against. */
+ | 'unsupported'
+/** Registration was attempted and rejected. See the console for the reason. */
+ | 'failed';
+
+/**
+ * How a submission ended.
+ *
+ * Dispatching `FormSubmitEvent` is fire-and-forget: the submission pipeline
+ * drops a second submission through `exhaustMap`, skips submission entirely when
+ * the form is invalid or async validators are still pending, and swallows an
+ * asynchronous action failure to keep the stream alive. None of that is visible
+ * to the caller, which is fine for a button click — the user is watching the
+ * page — and wrong for anything that has to report back, an agent tool call
+ * above all.
+ *
+ * @experimental
+ */
+type SubmissionOutcome = {
+    readonly status: 'success';
+}
+/** No `submission.action` is configured; the `(submitted)` output received the value. */
+ | {
+    readonly status: 'dispatched';
+}
+/** The form was invalid, so nothing was submitted. */
+ | {
+    readonly status: 'validation-failed';
+}
+/** Async validators had not resolved, so submission was skipped. */
+ | {
+    readonly status: 'pending-validation';
+}
+/** The action ran and came back with server-side validation errors. */
+ | {
+    readonly status: 'server-errors';
+}
+/** The action threw or rejected. */
+ | {
+    readonly status: 'action-failed';
+    readonly error: unknown;
+}
+/** Another submission was already in flight and this one was dropped. */
+ | {
+    readonly status: 'busy';
+}
+/** The form went away before the submission settled. */
+ | {
+    readonly status: 'cancelled';
+};
+/**
+ * The reply channel a caller attaches to `FormSubmitEvent` when it needs to know
+ * what happened.
+ *
+ * `accept()` is called by the submission handler the moment it takes the event.
+ * Because the event bus dispatches synchronously, a caller that finds its reply
+ * un-accepted once `dispatch()` returns knows the pipeline dropped the
+ * submission rather than merely not having finished it yet — which is the only
+ * way to tell "busy" apart from "still running".
+ *
+ * @experimental
+ */
+interface SubmissionReply {
+    /** Marks the submission as taken by the pipeline. */
+    accept(): void;
+    /** Reports the final outcome. The first call wins; later calls are ignored. */
+    settle(outcome: SubmissionOutcome): void;
+}
+
 /**
  * Configures global validation execution defaults — when validators should run
  * relative to a field's reactive state.
@@ -836,9 +981,17 @@ declare class GoToPageEvent implements FormEvent {
     options?: PageNavigationOptions | undefined);
 }
 
-/** Event dispatched to submit the form (the action behind a `submit` button). */
+/**
+ * Event dispatched to submit the form (the action behind a `submit` button).
+ *
+ * A caller that needs to know how the submission ended passes a
+ * {@link SubmissionReply}; the submission handler reports back through it. A
+ * button click passes nothing and stays fire-and-forget, as before.
+ */
 declare class FormSubmitEvent implements FormEvent {
+    readonly reply?: SubmissionReply | undefined;
     readonly type: "submit";
+    constructor(reply?: SubmissionReply | undefined);
 }
 
 /** Event dispatched to advance a paged form to the next page. */
@@ -1079,5 +1232,5 @@ interface ArrayItemContext {
     formValue?: unknown;
 }
 
-export { ActivePageInitializedEvent, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, FormSubmitEvent, GoToPageEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PagerStateEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createWrappers, isWrappersBundle, provideDynamicForm, sanitizeFormConfig, withAddonActions, withCustomAddon, withEventFormValue, withFieldWindowing, withLegacyStatusClasses, withLoggerConfig, withPagePreload, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
-export type { AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, FieldParkingOption, InferWrapperRegistry, PageNavigationOptions, PagerState, SanitizeFormConfigOptions, SanitizedFormConfig, WrapperRegistration, WrappersBundle };
+export { ActivePageInitializedEvent, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, FormSubmitEvent, GoToPageEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PagerStateEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createWrappers, isWrappersBundle, provideDynamicForm, sanitizeFormConfig, withAddonActions, withCustomAddon, withEventFormValue, withExperimentalWebMcp, withFieldWindowing, withLegacyStatusClasses, withLoggerConfig, withPagePreload, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
+export type { AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, FieldParkingOption, InferWrapperRegistry, PageNavigationOptions, PagerState, SanitizeFormConfigOptions, SanitizedFormConfig, SubmissionOutcome, SubmissionReply, WebMcpStatus, WrapperRegistration, WrappersBundle };

package/fesm2022/ng-forge-dynamic-forms-container-field.component-DfQ0y-77.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ng-forge-dynamic-forms-container-field.component-DfQ0y-77.mjs","mappings":";;;;;AAuDc;AACK;;AAEA;AACE;AACF;AACA;AACA;AACA;;;AAIA;AACA;;;;;AAIjB;;;;AAGS;;AACA;;;;AAGQ;;AAEE;AAGf;AACA;;;AAGA;AACE;;;AAKI;;AAIP;AAIc;AAOjB;AACE;AAQA;;;AAGE;AACD;;;AAnEgB;;;;;;;AAZlB;;;;AATS;;;;;;;;AAYR;AACA;AACA;AACA;AACA;AACA;;AAgBgD","names":[],"ignoreList":[],"sources":["../../../../packages/dynamic-forms/src/lib/fields/container/container-field.component.ts"],"sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  computed,\n  DestroyRef,\n  EnvironmentInjector,\n  inject,\n  Injector,\n  input,\n  TemplateRef,\n  viewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { DfFieldOutlet } from '../../directives/df-field-outlet/df-field-outlet.directive';\nimport { derivedFromDeferred } from '@ng-forge/dynamic-forms/internal';\nimport { createFieldResolutionPipe, ResolvedField } from '../../utils/resolve-field/resolve-field';\nimport {\n  computeContainerHostClasses,\n  initializationComponentPath,\n  setupContainerInitEffect,\n} from '../../utils/container-utils/container-utils';\nimport { ContainerField } from '@ng-forge/dynamic-forms/internal';\nimport { injectFieldRegistry } from '../../utils/inject-field-registry/inject-field-registry';\nimport { EventBus } from '@ng-forge/dynamic-forms/internal';\nimport { FieldDef } from '@ng-forge/dynamic-forms/internal';\nimport { DynamicFormLogger } from '@ng-forge/dynamic-forms/internal';\nimport { WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_REGISTRY } from '@ng-forge/dynamic-forms/internal';\nimport { DEFAULT_WRAPPERS } from '@ng-forge/dynamic-forms/internal';\nimport { isSameWrapperChain, resolveWrappers } from '../../utils/resolve-wrappers/resolve-wrappers';\nimport { createWrapperChainController } from '../../utils/wrapper-chain/wrapper-chain-controller';\nimport { GROUP_CONTEXT } from '@ng-forge/dynamic-forms/internal';\n\n/** Layout container that wraps child fields with UI chrome. */\n@Component({\n  selector: 'div[container-field]',\n  imports: [DfFieldOutlet],\n  template: `\n    <ng-template #childrenTpl>\n      @for (field of resolvedFields(); track field.key) {\n        <ng-container *dfFieldOutlet=\"field; environmentInjector: environmentInjector\" />\n      }\n    </ng-template>\n    <ng-container #wrapperContainer></ng-container>\n  `,\n  styleUrl: './container-field.component.scss',\n  host: {\n    '[class]': 'hostClasses()',\n    '[class.disabled]': 'disabled()',\n    '[class.df-container-hidden]': 'hidden()',\n    '[attr.aria-hidden]': 'hidden() || null',\n    '[id]': '`${key()}`',\n    '[attr.data-testid]': 'key()',\n  },\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport default class ContainerFieldComponent {\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly fieldRegistry = injectFieldRegistry();\n  private readonly injector = inject(Injector);\n  protected readonly environmentInjector = inject(EnvironmentInjector);\n  private readonly eventBus = inject(EventBus);\n  private readonly logger = inject(DynamicFormLogger);\n  private readonly wrapperAutoAssociations = inject(WRAPPER_AUTO_ASSOCIATIONS);\n  private readonly wrapperRegistry = inject(WRAPPER_REGISTRY);\n  private readonly defaultWrappersSignal = inject(DEFAULT_WRAPPERS, { optional: true });\n  private readonly groupContext = inject(GROUP_CONTEXT, { optional: true });\n\n  private readonly childrenTpl = viewChild.required('childrenTpl', { read: TemplateRef });\n  private readonly wrapperContainer = viewChild.required('wrapperContainer', { read: ViewContainerRef });\n\n  field = input.required<ContainerField>();\n  key = input.required<string>();\n  className = input<string>();\n  hidden = input(false);\n\n  readonly hostClasses = computed(() => computeContainerHostClasses('container', this.className()));\n  readonly disabled = computed(() => this.field().disabled || false);\n\n  private readonly rawFieldRegistry = computed(() => this.fieldRegistry.raw);\n  private readonly fieldsSource = computed(() => (this.field().fields || []) as FieldDef<unknown>[]);\n\n  protected readonly resolvedFields = derivedFromDeferred(\n    this.fieldsSource,\n    createFieldResolutionPipe(() => ({\n      loadTypeComponent: (type: string) => this.fieldRegistry.loadTypeComponent(type),\n      registry: this.rawFieldRegistry(),\n      injector: this.injector,\n      destroyRef: this.destroyRef,\n      onError: (fieldDef: FieldDef<unknown>, error: unknown) => {\n        const fieldKey = fieldDef.key || '<no key>';\n\n        const containerKey = this.field().key || '<no key>';\n        this.logger.error(\n          `Failed to load component for field type '${fieldDef.type}' (key: ${fieldKey}) ` +\n            `within container '${containerKey}'. Ensure the field type is registered in your field registry.`,\n          error,\n        );\n      },\n    })),\n    { initialValue: [] as ResolvedField[], injector: this.injector },\n  );\n\n  private readonly wrappers = computed(\n    () => resolveWrappers(this.field(), this.defaultWrappersSignal?.(), this.wrapperAutoAssociations, this.wrapperRegistry),\n    {\n      equal: isSameWrapperChain,\n    },\n  );\n\n  constructor() {\n    setupContainerInitEffect(\n      this.resolvedFields,\n      this.eventBus,\n      'container',\n      () => initializationComponentPath(this.field().key, this.groupContext?.groupPath()),\n      this.injector,\n    );\n\n    createWrapperChainController({\n      vcr: this.wrapperContainer,\n      wrappers: this.wrappers,\n      renderInnermost: (slot) => slot.createEmbeddedView(this.childrenTpl()),\n    });\n  }\n}\n\nexport { ContainerFieldComponent };\n"]}

package/fesm2022/ng-forge-dynamic-forms-css-wrapper.component-D_yRuLpu.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ng-forge-dynamic-forms-css-wrapper.component-D_yRuLpu.mjs","mappings":";;;;;;AAiBc;AACK;AAER;AAEA;;AACA;;AAEA;AAIL;AACD;;;;;;AArBM;AACT;AACA;;AAEA;AACE;AACD;AACF;AAI8C","names":[],"ignoreList":[],"sources":["../../../../packages/dynamic-forms/src/lib/wrappers/css/css-wrapper.component.ts"],"sourcesContent":["import { ChangeDetectionStrategy, Component, inject, Injector, input, Signal, ViewContainerRef, viewChild } from '@angular/core';\nimport { pipe, switchMap } from 'rxjs';\nimport { derivedFrom } from 'ngxtension/derived-from';\nimport { FieldWrapper } from '@ng-forge/dynamic-forms/internal';\nimport { DynamicText } from '@ng-forge/dynamic-forms/internal';\nimport { dynamicTextToObservable } from '@ng-forge/dynamic-forms/internal';\nimport { WrapperFieldInputs } from '@ng-forge/dynamic-forms/internal';\n\n/** Built-in CSS wrapper component. */\n@Component({\n  selector: 'df-css-wrapper',\n  template: `<ng-container #fieldComponent></ng-container>`,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[class]': 'resolvedClasses()',\n  },\n})\nexport default class CssWrapperComponent implements FieldWrapper {\n  private readonly injector = inject(Injector);\n\n  readonly fieldComponent = viewChild.required('fieldComponent', { read: ViewContainerRef });\n\n  readonly cssClasses = input<DynamicText>();\n  readonly fieldInputs = input<WrapperFieldInputs>();\n\n  readonly resolvedClasses: Signal<string> = derivedFrom(\n    [this.cssClasses],\n    pipe(switchMap(([value]) => dynamicTextToObservable(value, this.injector))),\n    {\n      initialValue: '',\n    },\n  );\n}\n\nexport { CssWrapperComponent };\n"]}