@mcp-native/react-native 0.3.0 → 0.5.0

package/dist/v1.js

@@ -12,13 +12,22 @@ export const A2UI_V1_NATIVE_COMPONENT_NAMES = Object.freeze([
 ]);
 /** Maximum expanded native-plan nodes, including repeated component references. */
 export const A2UI_V1_NATIVE_MAX_RENDER_NODES = A2UI_V1_MAX_COMPONENTS;
+/** Maximum canonical HTTP(S) URL retained for one supported local action. */
+export const A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH = 8_192;
 /**
  * Converts a policy-validated A2UI v1 surface into the existing host-owned
  * native render plan. Unsupported renderer semantics fail closed.
  */
 export function createA2uiV1NativeRenderPlan(surface, policy, options = {}) {
+    return createNativeRenderPlan(surface, policy, options, false);
+}
+/** Internal mounted-surface path that keeps temporary renderer-local URL edits non-dispatchable. */
+export function createA2uiV1NativeRenderPlanForLocalEdits(surface, policy, options = {}) {
+    return createNativeRenderPlan(surface, policy, options, true);
+}
+function createNativeRenderPlan(surface, policy, options, tolerateInvalidLocalOpenUrls) {
     const parsedOptions = parseRenderPlanOptions(options);
-    const context = createAdapterContext(surface, policy, parsedOptions.dataModel, parsedOptions.locale);
+    const context = createAdapterContext(surface, policy, parsedOptions.dataModel, parsedOptions.locale, tolerateInvalidLocalOpenUrls);
     return adaptComponent("root", "root", context, undefined);
 }
 /** Resolves one validated event against the latest renderer-local data model. */
@@ -28,8 +37,13 @@ export function resolveA2uiV1NativeEvent(surface, policy, sourceComponentId, dat
     }
     const parsedOptions = parseEventResolutionOptions(options);
     const context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale);
-    const events = findNativeEvents(adaptComponent("root", "root", context, undefined), sourceComponentId, parsedOptions.instanceKey);
+    const plan = adaptComponent("root", "root", context, undefined);
+    const events = findNativeEvents(plan, sourceComponentId, parsedOptions.instanceKey);
     if (events.length === 0) {
+        const disabledEvents = findNativeEvents(plan, sourceComponentId, parsedOptions.instanceKey, true);
+        if (disabledEvents.length > 0) {
+            throw new A2uiParseError(`A2UI native event source ${JSON.stringify(sourceComponentId)} is disabled by failed renderer checks`);
+        }
         throw new A2uiParseError(`A2UI native event source ${JSON.stringify(sourceComponentId)} is not a reachable supported Button`);
     }
     if (events.length > 1) {
@@ -37,19 +51,54 @@ export function resolveA2uiV1NativeEvent(surface, policy, sourceComponentId, dat
     }
     return events[0];
 }
-function findNativeEvents(element, sourceComponentId, instanceKey) {
+/** Resolves one supported local URL action against the latest renderer-local data model. */
+export function resolveA2uiV1NativeOpenUrl(surface, policy, sourceComponentId, dataModel, options = {}) {
+    if (typeof sourceComponentId !== "string" || sourceComponentId.length === 0) {
+        throw new A2uiParseError("Expected a non-empty A2UI openUrl source component id");
+    }
+    const parsedOptions = parseOpenUrlResolutionOptions(options);
+    const context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale);
+    const plan = adaptComponent("root", "root", context, undefined);
+    const openUrls = findNativeOpenUrls(plan, sourceComponentId, parsedOptions.instanceKey);
+    if (openUrls.length === 0) {
+        const disabledOpenUrls = findNativeOpenUrls(plan, sourceComponentId, parsedOptions.instanceKey, true);
+        if (disabledOpenUrls.length > 0) {
+            throw new A2uiParseError(`A2UI native openUrl source ${JSON.stringify(sourceComponentId)} is disabled by failed renderer checks`);
+        }
+        throw new A2uiParseError(`A2UI native openUrl source ${JSON.stringify(sourceComponentId)} is not a reachable supported Button`);
+    }
+    if (openUrls.length > 1) {
+        throw new A2uiParseError(`A2UI native openUrl source ${JSON.stringify(sourceComponentId)} is ambiguous without its template instance key`);
+    }
+    return openUrls[0];
+}
+function findNativeEvents(element, sourceComponentId, instanceKey, includeDisabled = false) {
     const events = [];
     const event = element.props.event;
     if (event?.sourceComponentId === sourceComponentId &&
+        (includeDisabled || element.props.disabled !== true) &&
         (instanceKey === undefined || event.instanceKey === instanceKey)) {
         events.push(event);
     }
     for (const child of element.children ?? []) {
-        events.push(...findNativeEvents(child, sourceComponentId, instanceKey));
+        events.push(...findNativeEvents(child, sourceComponentId, instanceKey, includeDisabled));
     }
     return events;
 }
-function createAdapterContext(surface, policy, dataModel, locale) {
+function findNativeOpenUrls(element, sourceComponentId, instanceKey, includeDisabled = false) {
+    const openUrls = [];
+    const openUrl = element.props.openUrl;
+    if (openUrl?.sourceComponentId === sourceComponentId &&
+        (includeDisabled || element.props.disabled !== true) &&
+        (instanceKey === undefined || openUrl.instanceKey === instanceKey)) {
+        openUrls.push(openUrl);
+    }
+    for (const child of element.children ?? []) {
+        openUrls.push(...findNativeOpenUrls(child, sourceComponentId, instanceKey, includeDisabled));
+    }
+    return openUrls;
+}
+function createAdapterContext(surface, policy, dataModel, locale, tolerateInvalidLocalOpenUrls = false) {
     const localDataModel = dataModel === undefined
         ? parseJsonObject(surface.dataModel, "surface.dataModel")
         : parseJsonObject(dataModel, "options.dataModel");
@@ -58,12 +107,17 @@ function createAdapterContext(surface, policy, dataModel, locale) {
         surface: validated,
         dataModel: parseJsonObject(validated.dataModel, "surface.dataModel"),
         locale,
+        dateFormats: new Map(),
         numberFormats: new Map(),
         pluralRules: new Map(),
         visiting: new Set(),
+        tolerateInvalidLocalOpenUrls,
         formatStringExpressionCount: 0,
         formattedStringLength: 0,
+        openUrlLength: 0,
         renderNodeCount: 0,
+        validationCheckCount: 0,
+        validationOutputLength: 0,
     };
 }
 function parseRenderPlanOptions(options) {
@@ -96,6 +150,22 @@ function parseEventResolutionOptions(options) {
             : { locale: parseLocale(parsed.locale, "options.locale") }),
     };
 }
+function parseOpenUrlResolutionOptions(options) {
+    const parsed = parseOptionsObject(options, "A2UI native openUrl resolution options", [
+        "instanceKey",
+        "locale",
+    ]);
+    if (parsed.instanceKey !== undefined &&
+        (typeof parsed.instanceKey !== "string" || parsed.instanceKey.length === 0)) {
+        throw new A2uiParseError("Expected a non-empty A2UI native openUrl instance key");
+    }
+    return {
+        ...(parsed.instanceKey === undefined ? {} : { instanceKey: parsed.instanceKey }),
+        ...(parsed.locale === undefined
+            ? {}
+            : { locale: parseLocale(parsed.locale, "options.locale") }),
+    };
+}
 function parseOptionsObject(value, label, allowedKeys) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new A2uiParseError(`Expected ${label} to be an object`);
@@ -116,10 +186,12 @@ function parseLocale(value, path) {
         throw new A2uiParseError(`Expected a non-empty BCP 47 locale at ${path}`);
     }
     try {
-        if (Intl.NumberFormat.supportedLocalesOf(value, { localeMatcher: "lookup" }).length === 0) {
+        const canonicalLocale = Intl.getCanonicalLocales(value)[0];
+        if (Intl.NumberFormat.supportedLocalesOf(canonicalLocale, { localeMatcher: "lookup" }).length ===
+            0) {
             throw new A2uiParseError(`Unsupported BCP 47 locale ${JSON.stringify(value)} at ${path}`);
         }
-        return new Intl.NumberFormat(value).resolvedOptions().locale;
+        return canonicalLocale;
     }
     catch (cause) {
         if (cause instanceof A2uiParseError) {
@@ -246,7 +318,6 @@ function adaptText(component, key, context, scope) {
     return { key, component: "Text", props };
 }
 function adaptButton(component, key, context, scope) {
-    rejectUnsupportedChecks(component);
     const childId = expectString(component.child, `components.${component.id}.child`);
     const child = context.surface.components.get(childId);
     if (child?.component !== "Text") {
@@ -254,19 +325,21 @@ function adaptButton(component, key, context, scope) {
     }
     const props = {
         title: resolveDynamicString(child.text, `components.${child.id}.text`, context, scope),
-        event: resolveButtonEvent(component, key, context, scope),
+        // Validate action input even while checks disable dispatch, so inactive state cannot conceal
+        // malformed or host-denied dynamic semantics.
+        ...resolveButtonAction(component, key, context, scope),
     };
     if (component.variant !== undefined) {
         props.variant = component.variant;
     }
     addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "button");
     if (props.accessibilityLabel === undefined) {
         props.accessibilityLabel = props.title;
     }
     return { key, component: "Button", props };
 }
 function adaptTextField(component, key, context, scope) {
-    rejectUnsupportedChecks(component);
     const componentPath = `components.${component.id}`;
     const label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
     const props = {
@@ -285,20 +358,233 @@ function adaptTextField(component, key, context, scope) {
         props.variant = component.variant;
     }
     addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "input");
     if (props.accessibilityLabel === undefined) {
         props.accessibilityLabel = label;
     }
     return { key, component: "TextInput", props };
 }
-function rejectUnsupportedChecks(component) {
-    if (component.checks !== undefined) {
-        throw new A2uiParseError(`A2UI native adapter does not yet support renderer-side checks at components.${component.id}.checks`);
+function addValidationProps(component, props, context, scope, target) {
+    if (component.checks === undefined) {
+        return;
+    }
+    if (!Array.isArray(component.checks)) {
+        throw new A2uiParseError(`Expected an array at components.${component.id}.checks`);
+    }
+    const messages = [];
+    let valid = true;
+    for (const [index, value] of component.checks.entries()) {
+        context.validationCheckCount += 1;
+        if (context.validationCheckCount > JSON_MAX_VALUES) {
+            throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${JSON_MAX_VALUES} renderer checks`);
+        }
+        const path = `components.${component.id}.checks[${index}]`;
+        const check = expectObject(value, path);
+        // The pinned Candidate's CheckRule prose says ValidationResult object, but its Checkable
+        // contract and reference implementation use a boolean. Follow that executable contract.
+        if (!resolveDynamicBoolean(check.condition, `${path}.condition`, context, scope)) {
+            valid = false;
+            if (check.message !== undefined) {
+                messages.push(expectString(check.message, `${path}.message`));
+            }
+        }
+    }
+    if (valid) {
+        return;
+    }
+    props[target === "button" ? "disabled" : "invalid"] = true;
+    if (messages.length === 0) {
+        return;
+    }
+    const existingHint = typeof props.accessibilityHint === "string" ? props.accessibilityHint : undefined;
+    const validationHintLength = messages.reduce((length, message, index) => length + message.length + (index === 0 ? 0 : 1), 0);
+    const outputLength = validationHintLength + (existingHint === undefined ? 0 : existingHint.length + 1);
+    if (outputLength > JSON_MAX_STRING_LENGTH) {
+        throw new A2uiParseError(`A2UI validation output at components.${component.id}.checks exceeds maximum length of ${JSON_MAX_STRING_LENGTH}`);
+    }
+    context.validationOutputLength += outputLength;
+    if (context.validationOutputLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum validation-output length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+    }
+    props.validationMessages = Object.freeze(messages);
+    const validationHint = messages.join(" ");
+    props.accessibilityHint =
+        existingHint === undefined ? validationHint : `${existingHint} ${validationHint}`;
+}
+const VALIDATION_FUNCTION_NAMES = new Set([
+    "required",
+    "regex",
+    "length",
+    "numeric",
+    "email",
+]);
+const A2UI_V1_MAX_REGEX_PATTERN_LENGTH = 256;
+const A2UI_V1_MAX_REGEX_INPUT_LENGTH = 4_096;
+const A2UI_V1_MAX_REGEX_REPEAT = 4_096;
+const EMAIL_PATTERN = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+function resolveValidationFunction(call, path, context, scope) {
+    const args = expectObject(call.args, `${path}.args`);
+    if (call.call === "required") {
+        const value = resolveDynamicValue(args.value, `${path}.args.value`, context, scope);
+        return !(value === null ||
+            (typeof value === "string" && value.length === 0) ||
+            (Array.isArray(value) && value.length === 0));
+    }
+    if (call.call === "regex") {
+        const value = resolveDynamicString(args.value, `${path}.args.value`, context, scope);
+        const pattern = expectString(args.pattern, `${path}.args.pattern`);
+        if (value.length > A2UI_V1_MAX_REGEX_INPUT_LENGTH) {
+            return false;
+        }
+        return compileValidationRegex(pattern, path).test(value);
+    }
+    if (call.call === "length") {
+        const value = resolveDynamicString(args.value, `${path}.args.value`, context, scope);
+        const bounds = parseValidationBounds(args, path, true);
+        return ((bounds.min === undefined || value.length >= bounds.min) &&
+            (bounds.max === undefined || value.length <= bounds.max));
+    }
+    if (call.call === "numeric") {
+        const value = resolveDynamicNumber(args.value, `${path}.args.value`, context, scope);
+        const bounds = parseValidationBounds(args, path, false);
+        return ((bounds.min === undefined || value >= bounds.min) &&
+            (bounds.max === undefined || value <= bounds.max));
+    }
+    const value = resolveDynamicString(args.value, `${path}.args.value`, context, scope);
+    return value.length <= 320 && EMAIL_PATTERN.test(value);
+}
+function parseValidationBounds(args, path, integer) {
+    const parseBound = (name) => {
+        if (args[name] === undefined) {
+            return undefined;
+        }
+        const value = expectFiniteNumber(args[name], `${path}.args.${name}`);
+        if (integer && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new A2uiParseError(`Expected a non-negative safe integer at ${path}.args.${name}`);
+        }
+        return value;
+    };
+    const min = parseBound("min");
+    const max = parseBound("max");
+    if (min === undefined && max === undefined) {
+        throw new A2uiParseError(`Expected min or max at ${path}.args`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+        throw new A2uiParseError(`Expected min not to exceed max at ${path}.args`);
     }
+    return { min, max };
 }
-function resolveButtonEvent(component, key, context, scope) {
+function compileValidationRegex(pattern, path) {
+    if (pattern.length > A2UI_V1_MAX_REGEX_PATTERN_LENGTH) {
+        throw new A2uiParseError(`A2UI regex pattern at ${path}.args.pattern exceeds maximum length of ${A2UI_V1_MAX_REGEX_PATTERN_LENGTH}`);
+    }
+    let escaped = false;
+    let inCharacterClass = false;
+    let variableRepeatCount = 0;
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (escaped) {
+            if (/[1-9kPp]/.test(character)) {
+                throwUnsupportedValidationRegex(pattern, path);
+            }
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (inCharacterClass) {
+            if (character === "]") {
+                inCharacterClass = false;
+            }
+            continue;
+        }
+        if (character === "[") {
+            inCharacterClass = true;
+            continue;
+        }
+        if (character === "(" || character === ")" || character === "|") {
+            throwUnsupportedValidationRegex(pattern, path);
+        }
+        if (character === "*" || character === "+" || character === "?") {
+            variableRepeatCount += 1;
+            continue;
+        }
+        if (character === "{") {
+            const repeat = /^\{(0|[1-9][0-9]*)(?:,(0|[1-9][0-9]*)?)?\}/.exec(pattern.slice(index));
+            if (repeat === null) {
+                throwUnsupportedValidationRegex(pattern, path);
+            }
+            const min = Number(repeat[1]);
+            const max = repeat[2] === undefined || repeat[2] === "" ? undefined : Number(repeat[2]);
+            if (min > A2UI_V1_MAX_REGEX_REPEAT ||
+                (max !== undefined && (max < min || max > A2UI_V1_MAX_REGEX_REPEAT))) {
+                throwUnsupportedValidationRegex(pattern, path);
+            }
+            if (repeat[0].includes(",") && max !== min) {
+                variableRepeatCount += 1;
+            }
+            index += repeat[0].length - 1;
+            continue;
+        }
+        if (character === "}") {
+            throwUnsupportedValidationRegex(pattern, path);
+        }
+    }
+    if (variableRepeatCount > 1) {
+        throwUnsupportedValidationRegex(pattern, path);
+    }
+    try {
+        return new RegExp(pattern);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Invalid regex pattern at ${path}.args.pattern`, { cause });
+    }
+}
+function throwUnsupportedValidationRegex(pattern, path) {
+    throw new A2uiParseError(`Unsupported potentially expensive regex pattern ${JSON.stringify(pattern)} at ${path}.args.pattern`);
+}
+function resolveButtonAction(component, key, context, scope) {
     const action = expectObject(component.action, `components.${component.id}.action`);
+    if (Object.hasOwn(action, "functionCall")) {
+        const call = expectObject(action.functionCall, `components.${component.id}.action.functionCall`);
+        const name = expectString(call.call, `components.${component.id}.action.functionCall.call`);
+        if (name !== "openUrl") {
+            throw new A2uiParseError(`A2UI native Button ${JSON.stringify(component.id)} does not support local function ${JSON.stringify(name)}`);
+        }
+        const args = expectObject(call.args, `components.${component.id}.action.functionCall.args`);
+        const path = `components.${component.id}.action.functionCall.args.url`;
+        const resolvedUrl = resolveDynamicString(args.url, path, context, scope);
+        let normalizedUrl;
+        try {
+            normalizedUrl = normalizeOpenUrl(resolvedUrl, path);
+        }
+        catch (error) {
+            if (!context.tolerateInvalidLocalOpenUrls || !(error instanceof A2uiParseError)) {
+                throw error;
+            }
+            return {
+                disabled: true,
+                invalidLocalOpenUrl: {
+                    surfaceId: context.surface.surfaceId,
+                    sourceComponentId: component.id,
+                    instanceKey: key,
+                },
+            };
+        }
+        const url = recordOpenUrl(normalizedUrl, path, context);
+        return {
+            openUrl: {
+                url,
+                surfaceId: context.surface.surfaceId,
+                sourceComponentId: component.id,
+                instanceKey: key,
+            },
+        };
+    }
     if (!Object.hasOwn(action, "event")) {
-        throw new A2uiParseError(`A2UI native Button ${JSON.stringify(component.id)} does not support local function actions`);
+        throw new A2uiParseError(`A2UI native Button ${JSON.stringify(component.id)} requires an event or supported local function action`);
     }
     const event = expectObject(action.event, `components.${component.id}.action.event`);
     const eventName = expectString(event.name, `components.${component.id}.action.event.name`);
@@ -311,14 +597,88 @@ function resolveButtonEvent(component, key, context, scope) {
         ? undefined
         : resolveDynamicString(event.userMessage, `components.${component.id}.action.event.userMessage`, context, scope);
     return {
-        name: eventName,
-        surfaceId: context.surface.surfaceId,
-        sourceComponentId: component.id,
-        instanceKey: key,
-        ...(userMessage === undefined ? {} : { userMessage }),
-        context: parseJsonObject(resolvedContext, `components.${component.id}.action.event.context`),
+        event: {
+            name: eventName,
+            surfaceId: context.surface.surfaceId,
+            sourceComponentId: component.id,
+            instanceKey: key,
+            ...(userMessage === undefined ? {} : { userMessage }),
+            context: parseJsonObject(resolvedContext, `components.${component.id}.action.event.context`),
+        },
     };
 }
+function normalizeOpenUrl(value, path) {
+    if (value.length === 0 || value.length > A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH) {
+        throw new A2uiParseError(`Expected an HTTP(S) URL up to ${A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH} characters at ${path}`);
+    }
+    if (/\s|\p{Cf}/u.test(value) || hasAsciiControlCharacter(value)) {
+        throw new A2uiParseError(`Expected an HTTP(S) URL without whitespace, control, or Unicode format characters at ${path}`);
+    }
+    const UrlConstructor = globalThis.URL;
+    if (UrlConstructor === undefined) {
+        throw new A2uiParseError(`The host runtime cannot validate an openUrl value at ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = new UrlConstructor(value);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Expected an absolute HTTP(S) URL at ${path}`, { cause });
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new A2uiParseError(`Expected an HTTP(S) URL at ${path}`);
+    }
+    if (parsed.username.length > 0 || parsed.password.length > 0) {
+        throw new A2uiParseError(`A2UI openUrl does not allow URL credentials at ${path}`);
+    }
+    if (parsed.href.length > A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH) {
+        throw new A2uiParseError(`Canonical A2UI openUrl at ${path} exceeds maximum length of ${A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH}`);
+    }
+    return parsed.href;
+}
+function hasAsciiControlCharacter(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 31 || code === 127) {
+            return true;
+        }
+    }
+    return false;
+}
+function recordOpenUrl(value, path, context) {
+    context.openUrlLength += value.length;
+    if (context.openUrlLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum openUrl length of ${A2UI_V1_MAX_SOURCE_LENGTH} at ${path}`);
+    }
+    return value;
+}
+/** Revalidates an untrusted URL descriptor before it crosses into a host component callback. */
+export function parseA2uiV1NativeOpenUrlDescriptor(value, path) {
+    const descriptor = parseJsonObject(value, path);
+    const allowedKeys = new Set(["instanceKey", "sourceComponentId", "surfaceId", "url"]);
+    for (const key of Object.keys(descriptor)) {
+        if (!allowedKeys.has(key)) {
+            throw new A2uiParseError(`Unexpected field ${JSON.stringify(key)} at ${path}`);
+        }
+    }
+    const instanceKey = descriptor.instanceKey;
+    if (instanceKey !== undefined && (typeof instanceKey !== "string" || instanceKey.length === 0)) {
+        throw new A2uiParseError(`Expected a non-empty string at ${path}.instanceKey`);
+    }
+    return {
+        url: normalizeOpenUrl(expectString(descriptor.url, `${path}.url`), `${path}.url`),
+        surfaceId: expectNonEmptyString(descriptor.surfaceId, `${path}.surfaceId`),
+        sourceComponentId: expectNonEmptyString(descriptor.sourceComponentId, `${path}.sourceComponentId`),
+        ...(instanceKey === undefined ? {} : { instanceKey }),
+    };
+}
+function expectNonEmptyString(value, path) {
+    const result = expectString(value, path);
+    if (result.length === 0) {
+        throw new A2uiParseError(`Expected a non-empty string at ${path}`);
+    }
+    return result;
+}
 function addCommonProps(component, props, context, scope) {
     if (component.weight !== undefined) {
         const weight = expectFiniteNumber(component.weight, `components.${component.id}.weight`);
@@ -370,9 +730,15 @@ function resolveDynamicValue(value, path, context, scope) {
                 : resolveDynamicNumber(args.offset, `${path}.args.offset`, context, scope);
             return scope.index + offset;
         }
+        if (VALIDATION_FUNCTION_NAMES.has(value.call)) {
+            return resolveValidationFunction(value, path, context, scope);
+        }
         if (value.call === "formatNumber" || value.call === "formatCurrency") {
             return resolveNumberFormat(value, path, context, scope);
         }
+        if (value.call === "formatDate") {
+            return resolveDateFormat(value, path, context, scope);
+        }
         if (value.call === "pluralize") {
             return resolvePluralize(value, path, context, scope);
         }
@@ -435,6 +801,308 @@ function resolveNumberFormat(call, path, context, scope) {
         throw new A2uiParseError(`A2UI native adapter could not execute ${JSON.stringify(call.call)} at ${path}`, { cause });
     }
 }
+const DATE_NUMBER = /^[+-]?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
+const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const RFC_3339_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|([+-])(\d{2}):(\d{2}))$/;
+const A2UI_V1_MAX_DATE_PATTERN_TOKENS = 128;
+const DATE_PATTERN_TOKENS = Object.freeze([
+    "MMMM",
+    "EEEE",
+    "yyyy",
+    "MMM",
+    "MM",
+    "dd",
+    "hh",
+    "HH",
+    "mm",
+    "ss",
+    "yy",
+    "M",
+    "d",
+    "E",
+    "h",
+    "H",
+    "a",
+]);
+const DATE_PATTERN_TOKEN_SET = new Set(DATE_PATTERN_TOKENS);
+function resolveDateFormat(call, path, context, scope) {
+    const args = expectObject(call.args, `${path}.args`);
+    const value = resolveDynamicValue(args.value, `${path}.args.value`, context, scope);
+    const pattern = resolveDynamicString(args.format, `${path}.args.format`, context, scope);
+    const date = parseDateValue(value, `${path}.args.value`);
+    const result = formatDatePattern(date, pattern, path, context);
+    return recordFormattedString(result, path, context);
+}
+function parseDateValue(value, path) {
+    if (typeof value === "number") {
+        return dateFromEpoch(value, path);
+    }
+    if (typeof value !== "string") {
+        throw new A2uiParseError(`Expected a date string or finite epoch number at ${path}`);
+    }
+    if (DATE_NUMBER.test(value)) {
+        return dateFromEpoch(Number(value), path);
+    }
+    const dateOnly = DATE_ONLY.exec(value);
+    if (dateOnly !== null) {
+        const year = Number(dateOnly[1]);
+        const month = Number(dateOnly[2]);
+        const day = Number(dateOnly[3]);
+        validateCalendarDate(year, month, day, path);
+        const date = new Date(0);
+        date.setFullYear(year, month - 1, day);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    const timestamp = RFC_3339_TIMESTAMP.exec(value);
+    if (timestamp === null) {
+        throw new A2uiParseError(`Expected an RFC 3339 timestamp, yyyy-MM-dd date, or finite epoch number at ${path}`);
+    }
+    const year = Number(timestamp[1]);
+    const month = Number(timestamp[2]);
+    const day = Number(timestamp[3]);
+    const hour = Number(timestamp[4]);
+    const minute = Number(timestamp[5]);
+    const second = Number(timestamp[6]);
+    validateCalendarDate(year, month, day, path);
+    if (hour > 23 || minute > 59 || second > 59) {
+        throw new A2uiParseError(`Invalid RFC 3339 time at ${path}`);
+    }
+    const fraction = timestamp[7] ?? "";
+    const millisecond = Number(fraction.slice(0, 3).padEnd(3, "0"));
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, millisecond);
+    if (timestamp[8] !== "Z") {
+        const offsetHour = Number(timestamp[10]);
+        const offsetMinute = Number(timestamp[11]);
+        if (offsetHour > 23 || offsetMinute > 59) {
+            throw new A2uiParseError(`Invalid RFC 3339 offset at ${path}`);
+        }
+        const direction = timestamp[9] === "+" ? 1 : -1;
+        date.setTime(date.getTime() - direction * (offsetHour * 60 + offsetMinute) * 60_000);
+    }
+    if (!Number.isFinite(date.getTime())) {
+        throw new A2uiParseError(`Date value is outside the supported range at ${path}`);
+    }
+    return date;
+}
+function dateFromEpoch(value, path) {
+    if (!Number.isFinite(value)) {
+        throw new A2uiParseError(`Expected a date string or finite epoch number at ${path}`);
+    }
+    const milliseconds = Math.abs(value) > 10_000_000_000 ? value : value * 1_000;
+    const date = new Date(milliseconds);
+    if (!Number.isFinite(date.getTime())) {
+        throw new A2uiParseError(`Epoch value is outside the supported date range at ${path}`);
+    }
+    return date;
+}
+function validateCalendarDate(year, month, day, path) {
+    const candidate = new Date(0);
+    candidate.setUTCFullYear(year, month - 1, day);
+    candidate.setUTCHours(0, 0, 0, 0);
+    if (year < 1 ||
+        month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        candidate.getUTCFullYear() !== year ||
+        candidate.getUTCMonth() !== month - 1 ||
+        candidate.getUTCDate() !== day) {
+        throw new A2uiParseError(`Invalid calendar date at ${path}`);
+    }
+}
+function formatDatePattern(date, pattern, path, context) {
+    const parts = parseDatePattern(pattern, path);
+    const hasDay = parts.some((part) => part.kind === "token" && (part.value === "d" || part.value === "dd"));
+    return parts
+        .map((part) => part.kind === "literal"
+        ? part.value
+        : formatDateToken(date, part.value, hasDay, path, context))
+        .join("");
+}
+function parseDatePattern(pattern, path) {
+    const parts = [];
+    let tokenCount = 0;
+    for (let index = 0; index < pattern.length;) {
+        if (pattern[index] === "'") {
+            const literal = readQuotedDateLiteral(pattern, index, path);
+            parts.push({ kind: "literal", value: literal.value });
+            index = literal.end;
+            continue;
+        }
+        const character = pattern[index];
+        if (/[A-Za-z]/.test(character)) {
+            let end = index + 1;
+            while (pattern[end] === character) {
+                end += 1;
+            }
+            const field = pattern.slice(index, end);
+            if (!DATE_PATTERN_TOKEN_SET.has(field)) {
+                throw new A2uiParseError(`Unsupported Unicode date pattern token ${JSON.stringify(field)} at ${path}.args.format`);
+            }
+            tokenCount += 1;
+            if (tokenCount > A2UI_V1_MAX_DATE_PATTERN_TOKENS) {
+                throw new A2uiParseError(`A2UI date pattern at ${path}.args.format exceeds maximum of ${A2UI_V1_MAX_DATE_PATTERN_TOKENS} tokens`);
+            }
+            parts.push({ kind: "token", value: field });
+            index = end;
+            continue;
+        }
+        const previous = parts.at(-1);
+        if (previous?.kind === "literal") {
+            parts[parts.length - 1] = { kind: "literal", value: previous.value + character };
+        }
+        else {
+            parts.push({ kind: "literal", value: character });
+        }
+        index += 1;
+    }
+    if (parts.some((part) => part.kind === "token" && (part.value === "h" || part.value === "hh")) &&
+        !parts.some((part) => part.kind === "token" && part.value === "a")) {
+        throw new A2uiParseError(`A2UI date pattern at ${path}.args.format requires token "a" when using "h" or "hh"`);
+    }
+    return parts;
+}
+function readQuotedDateLiteral(pattern, start, path) {
+    if (pattern[start + 1] === "'") {
+        return { end: start + 2, value: "'" };
+    }
+    let value = "";
+    for (let index = start + 1; index < pattern.length; index += 1) {
+        if (pattern[index] !== "'") {
+            value += pattern[index];
+            continue;
+        }
+        if (pattern[index + 1] === "'") {
+            value += "'";
+            index += 1;
+            continue;
+        }
+        return { end: index + 1, value };
+    }
+    throw new A2uiParseError(`Unterminated quoted literal at ${path}.args.format`);
+}
+function formatDateToken(date, token, hasDay, path, context) {
+    const cacheKey = `${token}:${hasDay ? "day" : "standalone"}`;
+    const cached = context.dateFormats.get(cacheKey);
+    const formatter = cached ?? createDateTokenFormatter(token, hasDay, path, context.locale);
+    context.dateFormats.set(cacheKey, formatter);
+    const partType = datePartType(token);
+    const part = formatter.formatToParts(date).find((candidate) => candidate.type === partType);
+    if (part === undefined) {
+        throw new A2uiParseError(`A2UI native adapter could not format token ${token} at ${path}`);
+    }
+    if (token === "yyyy") {
+        return normalizeLocalizedDateNumber(part.value, 4, path, context);
+    }
+    if (token === "MM" ||
+        token === "dd" ||
+        token === "hh" ||
+        token === "HH" ||
+        token === "mm" ||
+        token === "ss") {
+        return normalizeLocalizedDateNumber(part.value, 2, path, context);
+    }
+    if (token === "M" || token === "d" || token === "h" || token === "H") {
+        return normalizeLocalizedDateNumber(part.value, 1, path, context);
+    }
+    return part.value;
+}
+function normalizeLocalizedDateNumber(value, width, path, context) {
+    const length = Array.from(value).length;
+    if ((width === 1 && length === 1) || (width > 1 && length >= width)) {
+        return value;
+    }
+    const key = JSON.stringify([context.locale ?? null, "date-zero"]);
+    let formatter = context.numberFormats.get(key);
+    if (formatter === undefined) {
+        try {
+            formatter = new Intl.NumberFormat(context.locale, { useGrouping: false });
+            context.numberFormats.set(key, formatter);
+        }
+        catch (cause) {
+            throw new A2uiParseError(`Invalid year-format options at ${path}`, { cause });
+        }
+    }
+    const zero = formatter.formatToParts(0).find((part) => part.type === "integer")?.value;
+    if (zero === undefined) {
+        throw new A2uiParseError(`A2UI native adapter could not localize a padded year at ${path}`);
+    }
+    if (width === 1) {
+        let normalized = value;
+        while (Array.from(normalized).length > 1 && normalized.startsWith(zero)) {
+            normalized = normalized.slice(zero.length);
+        }
+        return normalized;
+    }
+    return `${zero.repeat(width - length)}${value}`;
+}
+function createDateTokenFormatter(token, hasDay, path, locale) {
+    const options = token === "yy"
+        ? { year: "2-digit" }
+        : token === "yyyy"
+            ? { year: "numeric" }
+            : token === "M"
+                ? { month: "numeric", ...(hasDay ? { day: "numeric" } : {}) }
+                : token === "MM"
+                    ? { month: "2-digit", ...(hasDay ? { day: "numeric" } : {}) }
+                    : token === "MMM"
+                        ? { month: "short", ...(hasDay ? { day: "numeric" } : {}) }
+                        : token === "MMMM"
+                            ? { month: "long", ...(hasDay ? { day: "numeric" } : {}) }
+                            : token === "d"
+                                ? { day: "numeric" }
+                                : token === "dd"
+                                    ? { day: "2-digit" }
+                                    : token === "E"
+                                        ? { weekday: "short" }
+                                        : token === "EEEE"
+                                            ? { weekday: "long" }
+                                            : token === "h" || token === "hh" || token === "a"
+                                                ? {
+                                                    hour: token === "hh" ? "2-digit" : "numeric",
+                                                    hourCycle: "h12",
+                                                }
+                                                : token === "H" || token === "HH"
+                                                    ? {
+                                                        hour: token === "HH" ? "2-digit" : "numeric",
+                                                        hourCycle: "h23",
+                                                    }
+                                                    : token === "mm"
+                                                        ? { minute: "2-digit" }
+                                                        : { second: "2-digit" };
+    try {
+        return new Intl.DateTimeFormat(locale, options);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Invalid date-format options at ${path}`, { cause });
+    }
+}
+function datePartType(token) {
+    if (token === "yy" || token === "yyyy") {
+        return "year";
+    }
+    if (token === "M" || token === "MM" || token === "MMM" || token === "MMMM") {
+        return "month";
+    }
+    if (token === "d" || token === "dd") {
+        return "day";
+    }
+    if (token === "E" || token === "EEEE") {
+        return "weekday";
+    }
+    if (token === "h" || token === "hh" || token === "H" || token === "HH") {
+        return "hour";
+    }
+    if (token === "mm") {
+        return "minute";
+    }
+    if (token === "ss") {
+        return "second";
+    }
+    return "dayPeriod";
+}
 const PLURAL_CATEGORIES = Object.freeze(["zero", "one", "two", "few", "many", "other"]);
 function resolvePluralize(call, path, context, scope) {
     const args = expectObject(call.args, `${path}.args`);