@mcp-native/react-native 0.2.0 → 0.4.0

package/dist/v1.js

@@ -1,5 +1,6 @@
-import { A2UI_V1_MAX_COMPONENTS, A2uiParseError, validateA2uiV1SurfaceState, } from "@mcp-native/a2ui";
-import { parseJsonObject, parseJsonValue } from "@mcp-native/core";
+import { A2UI_V1_MAX_COMPONENTS, A2UI_V1_MAX_SOURCE_LENGTH, A2uiParseError, evaluateA2uiV1FormatString, validateA2uiV1SurfaceState, } from "@mcp-native/a2ui";
+import { JSON_MAX_STRING_LENGTH, JSON_MAX_VALUES, parseJsonObject, parseJsonValue, } from "@mcp-native/core";
+import { ISO_4217_CURRENCY_CODES } from "./iso-4217.js";
 export const A2UI_V1_NATIVE_COMPONENT_NAMES = Object.freeze([
     "Button",
     "Card",
@@ -11,21 +12,197 @@ 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) {
-    const validated = validateA2uiV1SurfaceState(surface, policy);
-    const context = {
+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, tolerateInvalidLocalOpenUrls);
+    return adaptComponent("root", "root", context, undefined);
+}
+/** Resolves one validated event against the latest renderer-local data model. */
+export function resolveA2uiV1NativeEvent(surface, policy, sourceComponentId, dataModel, options = {}) {
+    if (typeof sourceComponentId !== "string" || sourceComponentId.length === 0) {
+        throw new A2uiParseError("Expected a non-empty A2UI source component id");
+    }
+    const parsedOptions = parseEventResolutionOptions(options);
+    const context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale);
+    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) {
+        throw new A2uiParseError(`A2UI native event source ${JSON.stringify(sourceComponentId)} is ambiguous without its template instance key`);
+    }
+    return events[0];
+}
+/** 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, includeDisabled));
+    }
+    return events;
+}
+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");
+    const validated = validateA2uiV1SurfaceState(dataModel === undefined ? surface : { ...surface, dataModel: localDataModel }, policy);
+    return {
         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) {
+    const parsed = parseOptionsObject(options, "A2UI native render plan options", [
+        "dataModel",
+        "locale",
+    ]);
+    return {
+        ...(parsed.dataModel === undefined
+            ? {}
+            : { dataModel: parseJsonObject(parsed.dataModel, "options.dataModel") }),
+        ...(parsed.locale === undefined
+            ? {}
+            : { locale: parseLocale(parsed.locale, "options.locale") }),
+    };
+}
+function parseEventResolutionOptions(options) {
+    const parsed = parseOptionsObject(options, "A2UI native event 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 event instance key");
+    }
+    return {
+        ...(parsed.instanceKey === undefined ? {} : { instanceKey: parsed.instanceKey }),
+        ...(parsed.locale === undefined
+            ? {}
+            : { 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") }),
     };
-    return adaptComponent("root", "root", context);
 }
-function adaptComponent(id, key, context) {
+function parseOptionsObject(value, label, allowedKeys) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new A2uiParseError(`Expected ${label} to be an object`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new A2uiParseError(`Expected plain ${label}`);
+    }
+    const parsed = value;
+    const unknownKey = Object.keys(parsed).find((key) => !allowedKeys.includes(key));
+    if (unknownKey !== undefined) {
+        throw new A2uiParseError(`Unexpected ${label.slice(0, -1)} ${JSON.stringify(unknownKey)}`);
+    }
+    return parsed;
+}
+function parseLocale(value, path) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 128) {
+        throw new A2uiParseError(`Expected a non-empty BCP 47 locale at ${path}`);
+    }
+    try {
+        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 canonicalLocale;
+    }
+    catch (cause) {
+        if (cause instanceof A2uiParseError) {
+            throw cause;
+        }
+        throw new A2uiParseError(`Invalid BCP 47 locale ${JSON.stringify(value)} at ${path}`, {
+            cause,
+        });
+    }
+}
+function adaptComponent(id, key, context, scope) {
     context.renderNodeCount += 1;
     if (context.renderNodeCount > A2UI_V1_NATIVE_MAX_RENDER_NODES) {
         throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${A2UI_V1_NATIVE_MAX_RENDER_NODES} nodes`);
@@ -41,19 +218,19 @@ function adaptComponent(id, key, context) {
     try {
         switch (component.component) {
             case "Row":
-                return adaptContainer(component, key, "row", undefined, context);
+                return adaptContainer(component, key, "row", undefined, context, scope);
             case "Column":
-                return adaptContainer(component, key, "column", undefined, context);
+                return adaptContainer(component, key, "column", undefined, context, scope);
             case "List":
-                return adaptList(component, key, context);
+                return adaptList(component, key, context, scope);
             case "Card":
-                return adaptCard(component, key, context);
+                return adaptCard(component, key, context, scope);
             case "Text":
-                return adaptText(component, key, context);
+                return adaptText(component, key, context, scope);
             case "Button":
-                return adaptButton(component, key, context);
+                return adaptButton(component, key, context, scope);
             case "TextField":
-                return adaptTextField(component, key, context);
+                return adaptTextField(component, key, context, scope);
             default:
                 throw new A2uiParseError(`A2UI component ${JSON.stringify(id)} uses ${JSON.stringify(component.component)}, which the native adapter does not support`);
         }
@@ -62,7 +239,7 @@ function adaptComponent(id, key, context) {
         context.visiting.delete(id);
     }
 }
-function adaptContainer(component, key, layout, variant, context) {
+function adaptContainer(component, key, layout, variant, context, scope) {
     if (!Array.isArray(component.children)) {
         throw new A2uiParseError(`A2UI native adapter does not yet support dynamic children at components.${component.id}.children`);
     }
@@ -70,168 +247,976 @@ function adaptContainer(component, key, layout, variant, context) {
     if (variant !== undefined) {
         props.variant = variant;
     }
+    addContainerLayoutProps(component, props);
+    addCommonProps(component, props, context, scope);
+    return {
+        key,
+        component: "View",
+        props,
+        children: component.children.map((childId, index) => adaptComponent(childId, appendInstanceKey(key, childId, index), context, scope)),
+    };
+}
+function addContainerLayoutProps(component, props) {
     if (component.justify !== undefined) {
-        props.justify = expectString(component.justify, `components.${component.id}.justify`);
+        const justify = expectString(component.justify, `components.${component.id}.justify`);
+        if (justify === "stretch") {
+            throw new A2uiParseError(`A2UI native adapter does not support main-axis stretch at components.${component.id}.justify`);
+        }
+        props.justify = justify;
     }
     if (component.align !== undefined) {
         props.align = expectString(component.align, `components.${component.id}.align`);
     }
-    addCommonProps(component, props, context);
+}
+function adaptList(component, key, context, scope) {
+    if (Array.isArray(component.children)) {
+        return adaptContainer(component, key, component.direction === "horizontal" ? "row" : "column", "list", context, scope);
+    }
+    const template = expectObject(component.children, `components.${component.id}.children`);
+    const pointer = expectAbsoluteBinding(template.path, `components.${component.id}.children.path`);
+    const componentId = expectString(template.componentId, `components.${component.id}.children.componentId`);
+    const value = parseJsonValue(resolveJsonPointer(context.dataModel, pointer, `components.${component.id}.children`), `components.${component.id}.children`);
+    if (!Array.isArray(value)) {
+        throw new A2uiParseError(`Expected an array at components.${component.id}.children path ${JSON.stringify(pointer)}`);
+    }
+    const props = {
+        layout: component.direction === "horizontal" ? "row" : "column",
+        variant: "list",
+    };
+    addContainerLayoutProps(component, props);
+    addCommonProps(component, props, context, scope);
     return {
         key,
         component: "View",
         props,
-        children: component.children.map((childId, index) => adaptComponent(childId, `${key}/${childId}:${index}`, context)),
+        children: value.map((item, index) => adaptComponent(componentId, appendInstanceKey(key, componentId, index), context, {
+            value: item,
+            pointer: appendPointerToken(pointer, String(index)),
+            index,
+        })),
     };
 }
-function adaptList(component, key, context) {
-    return adaptContainer(component, key, component.direction === "horizontal" ? "row" : "column", "list", context);
-}
-function adaptCard(component, key, context) {
+function adaptCard(component, key, context, scope) {
     const childId = expectString(component.child, `components.${component.id}.child`);
     const props = { layout: "column", variant: "card" };
-    addCommonProps(component, props, context);
+    addCommonProps(component, props, context, scope);
     return {
         key,
         component: "View",
         props,
-        children: [adaptComponent(childId, `${key}/${childId}:0`, context)],
+        children: [adaptComponent(childId, appendInstanceKey(key, childId, 0), context, scope)],
     };
 }
-function adaptText(component, key, context) {
+function adaptText(component, key, context, scope) {
     const props = {
-        children: resolveDynamicString(component.text, `components.${component.id}.text`, context),
+        children: resolveDynamicString(component.text, `components.${component.id}.text`, context, scope),
     };
     if (component.variant !== undefined) {
         props.variant = component.variant;
     }
-    addCommonProps(component, props, context);
+    addCommonProps(component, props, context, scope);
     return { key, component: "Text", props };
 }
-function adaptButton(component, key, context) {
-    rejectUnsupportedChecks(component);
+function adaptButton(component, key, context, scope) {
     const childId = expectString(component.child, `components.${component.id}.child`);
     const child = context.surface.components.get(childId);
     if (child?.component !== "Text") {
         throw new A2uiParseError(`A2UI native Button ${JSON.stringify(component.id)} requires a Text child`);
     }
     const props = {
-        title: resolveDynamicString(child.text, `components.${child.id}.text`, context),
-        event: resolveButtonEvent(component, context),
+        title: resolveDynamicString(child.text, `components.${child.id}.text`, 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);
+    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) {
-    rejectUnsupportedChecks(component);
+function adaptTextField(component, key, context, scope) {
     const componentPath = `components.${component.id}`;
-    const label = resolveDynamicString(component.label, `${componentPath}.label`, context);
+    const label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
     const props = {
         label,
         placeholder: component.placeholder === undefined
             ? label
-            : resolveDynamicString(component.placeholder, `${componentPath}.placeholder`, context),
+            : resolveDynamicString(component.placeholder, `${componentPath}.placeholder`, context, scope),
     };
     if (component.value !== undefined) {
-        props.value = resolveDynamicString(component.value, `${componentPath}.value`, context);
+        props.value = resolveDynamicString(component.value, `${componentPath}.value`, context, scope);
         if (isBinding(component.value)) {
-            props.binding = expectAbsoluteBinding(component.value.path, `${componentPath}.value.path`);
+            props.binding = resolveBindingPointer(component.value.path, `${componentPath}.value.path`, scope);
         }
     }
     if (component.variant !== undefined) {
         props.variant = component.variant;
     }
-    addCommonProps(component, props, context);
+    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 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 resolveButtonEvent(component, context) {
+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`);
     const eventContext = expectOptionalObject(event.context, `components.${component.id}.action.event.context`);
     const resolvedContext = {};
     for (const [name, value] of Object.entries(eventContext ?? {})) {
-        defineJsonProperty(resolvedContext, name, resolveDynamicValue(value, `components.${component.id}.action.event.context.${name}`, context));
+        defineJsonProperty(resolvedContext, name, resolveDynamicValue(value, `components.${component.id}.action.event.context.${name}`, context, scope));
     }
     const userMessage = event.userMessage === undefined
         ? undefined
-        : resolveDynamicString(event.userMessage, `components.${component.id}.action.event.userMessage`, context);
+        : resolveDynamicString(event.userMessage, `components.${component.id}.action.event.userMessage`, context, scope);
+    return {
+        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 {
-        name: eventName,
-        surfaceId: context.surface.surfaceId,
-        sourceComponentId: component.id,
-        ...(userMessage === undefined ? {} : { userMessage }),
-        context: parseJsonObject(resolvedContext, `components.${component.id}.action.event.context`),
+        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 addCommonProps(component, props, context) {
+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) {
-        props.weight = expectFiniteNumber(component.weight, `components.${component.id}.weight`);
+        const weight = expectFiniteNumber(component.weight, `components.${component.id}.weight`);
+        if (weight < 0) {
+            throw new A2uiParseError(`A2UI native adapter does not support negative weight at components.${component.id}.weight`);
+        }
+        props.weight = weight;
     }
     if (component.accessibility === undefined) {
         return;
     }
     const accessibility = expectObject(component.accessibility, `components.${component.id}.accessibility`);
     if (accessibility.label !== undefined) {
-        props.accessibilityLabel = resolveDynamicString(accessibility.label, `components.${component.id}.accessibility.label`, context);
+        props.accessibilityLabel = resolveDynamicString(accessibility.label, `components.${component.id}.accessibility.label`, context, scope);
     }
     if (accessibility.description !== undefined) {
-        props.accessibilityHint = resolveDynamicString(accessibility.description, `components.${component.id}.accessibility.description`, context);
+        props.accessibilityHint = resolveDynamicString(accessibility.description, `components.${component.id}.accessibility.description`, context, scope);
     }
     if (accessibility.live !== undefined) {
         props.accessibilityLive = accessibility.live;
     }
     if (accessibility.hidden !== undefined) {
-        props.accessibilityHidden = resolveDynamicBoolean(accessibility.hidden, `components.${component.id}.accessibility.hidden`, context);
+        props.accessibilityHidden = resolveDynamicBoolean(accessibility.hidden, `components.${component.id}.accessibility.hidden`, context, scope);
     }
 }
-function resolveDynamicString(value, path, context) {
-    const resolved = resolveDynamicValue(value, path, context);
+function resolveDynamicString(value, path, context, scope) {
+    const resolved = resolveDynamicValue(value, path, context, scope);
     return expectString(resolved, path);
 }
-function resolveDynamicBoolean(value, path, context) {
-    const resolved = resolveDynamicValue(value, path, context);
+function resolveDynamicBoolean(value, path, context, scope) {
+    const resolved = resolveDynamicValue(value, path, context, scope);
     if (typeof resolved !== "boolean") {
         throw new A2uiParseError(`Expected a boolean at ${path}`);
     }
     return resolved;
 }
-function resolveDynamicValue(value, path, context) {
+function resolveDynamicValue(value, path, context, scope) {
     if (value === undefined) {
         throw new A2uiParseError(`Missing dynamic value at ${path}`);
     }
     if (isFunctionCall(value)) {
+        if (value.call === "@index") {
+            if (scope === undefined) {
+                throw new A2uiParseError(`A2UI native adapter cannot evaluate @index outside a template at ${path}`);
+            }
+            const args = value.args === undefined ? undefined : expectObject(value.args, `${path}.args`);
+            const offset = args?.offset === undefined
+                ? 0
+                : 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);
+        }
+        if (value.call === "and" || value.call === "or") {
+            return resolveBooleanList(value, path, context, scope);
+        }
+        if (value.call === "not") {
+            const args = expectObject(value.args, `${path}.args`);
+            return !resolveDynamicBoolean(args.value, `${path}.args.value`, context, scope);
+        }
+        if (value.call === "formatString") {
+            const args = expectObject(value.args, `${path}.args`);
+            const source = expectString(args.value, `${path}.args.value`);
+            const result = evaluateA2uiV1FormatString(source, (expression, index) => {
+                return resolveDynamicValue(expression, `${path}.args.value.interpolations[${index}]`, context, scope);
+            }, `${path}.args.value`, (expressionCount) => {
+                context.formatStringExpressionCount += expressionCount;
+                if (context.formatStringExpressionCount > JSON_MAX_VALUES) {
+                    throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${JSON_MAX_VALUES} formatString expressions`);
+                }
+            });
+            return recordFormattedString(result, path, context);
+        }
         throw new A2uiParseError(`A2UI native adapter does not execute function ${JSON.stringify(value.call)} at ${path}`);
     }
     if (isBinding(value)) {
-        const pointer = expectAbsoluteBinding(value.path, `${path}.path`);
-        return parseJsonValue(resolveJsonPointer(context.dataModel, pointer, path), path);
+        const pointer = expectString(value.path, `${path}.path`);
+        if (pointer.startsWith("/") || scope === undefined) {
+            const absolutePointer = expectAbsoluteBinding(pointer, `${path}.path`);
+            return parseJsonValue(resolveJsonPointer(context.dataModel, absolutePointer, path), path);
+        }
+        return parseJsonValue(resolveRelativePointer(scope.value, pointer, path), path);
     }
     return parseJsonValue(value, path);
 }
+function resolveDynamicNumber(value, path, context, scope) {
+    const resolved = resolveDynamicValue(value, path, context, scope);
+    if (typeof resolved !== "number" || !Number.isFinite(resolved)) {
+        throw new A2uiParseError(`Expected a finite number at ${path}`);
+    }
+    return resolved;
+}
+function resolveNumberFormat(call, path, context, scope) {
+    const args = expectObject(call.args, `${path}.args`);
+    const value = resolveDynamicNumber(args.value, `${path}.args.value`, context, scope);
+    const decimals = args.decimals === undefined
+        ? undefined
+        : parseDecimalPlaces(resolveDynamicNumber(args.decimals, `${path}.args.decimals`, context, scope), `${path}.args.decimals`);
+    const grouping = args.grouping === undefined
+        ? true
+        : resolveDynamicBoolean(args.grouping, `${path}.args.grouping`, context, scope);
+    const currency = call.call === "formatCurrency"
+        ? parseCurrencyCode(resolveDynamicString(args.currency, `${path}.args.currency`, context, scope), `${path}.args.currency`)
+        : undefined;
+    const formatter = getNumberFormat(context, decimals, grouping, currency, path);
+    try {
+        return recordFormattedString(formatter.format(value), path, context);
+    }
+    catch (cause) {
+        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`);
+    const value = resolveDynamicNumber(args.value, `${path}.args.value`, context, scope);
+    const forms = new Map();
+    for (const category of PLURAL_CATEGORIES) {
+        if (args[category] !== undefined) {
+            forms.set(category, resolveDynamicString(args[category], `${path}.args.${category}`, context, scope));
+        }
+    }
+    const other = forms.get("other");
+    if (other === undefined) {
+        throw new A2uiParseError(`Missing plural fallback at ${path}.args.other`);
+    }
+    const category = getPluralRules(context, path).select(value);
+    return recordFormattedString(forms.get(category) ?? other, path, context);
+}
+function getPluralRules(context, path) {
+    const key = context.locale ?? "";
+    const cached = context.pluralRules.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    try {
+        if (context.locale !== undefined &&
+            Intl.PluralRules.supportedLocalesOf(context.locale, { localeMatcher: "lookup" }).length === 0) {
+            throw new A2uiParseError(`Locale ${JSON.stringify(context.locale)} does not support plural rules at ${path}`);
+        }
+        const rules = new Intl.PluralRules(context.locale, { type: "cardinal" });
+        context.pluralRules.set(key, rules);
+        return rules;
+    }
+    catch (cause) {
+        if (cause instanceof A2uiParseError) {
+            throw cause;
+        }
+        throw new A2uiParseError(`A2UI native adapter could not construct plural rules at ${path}`, {
+            cause,
+        });
+    }
+}
+function resolveBooleanList(call, path, context, scope) {
+    const args = expectObject(call.args, `${path}.args`);
+    if (!Array.isArray(args.values) || args.values.length < 2) {
+        throw new A2uiParseError(`Expected at least two boolean values at ${path}.args.values`);
+    }
+    const values = args.values.map((value, index) => resolveDynamicBoolean(value, `${path}.args.values[${index}]`, context, scope));
+    return call.call === "and" ? values.every(Boolean) : values.some(Boolean);
+}
+function parseDecimalPlaces(value, path) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 100) {
+        throw new A2uiParseError(`Expected decimal places from 0 through 100 at ${path}`);
+    }
+    return value;
+}
+function parseCurrencyCode(value, path) {
+    const currency = value.toUpperCase();
+    if (!/^[A-Z]{3}$/.test(currency) || !ISO_4217_CURRENCY_CODES.has(currency)) {
+        throw new A2uiParseError(`Expected a current ISO 4217 currency code at ${path}`);
+    }
+    return currency;
+}
+function getNumberFormat(context, decimals, grouping, currency, path) {
+    const key = JSON.stringify([
+        context.locale ?? null,
+        currency ?? null,
+        decimals ?? null,
+        grouping,
+    ]);
+    const cached = context.numberFormats.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const options = {
+        useGrouping: grouping,
+        ...(currency === undefined ? {} : { style: "currency", currency }),
+        ...(decimals === undefined
+            ? {}
+            : { minimumFractionDigits: decimals, maximumFractionDigits: decimals }),
+    };
+    try {
+        const formatter = new Intl.NumberFormat(context.locale, options);
+        context.numberFormats.set(key, formatter);
+        return formatter;
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Invalid number-format options at ${path}`, { cause });
+    }
+}
+function recordFormattedString(value, path, context) {
+    if (value.length > JSON_MAX_STRING_LENGTH) {
+        throw new A2uiParseError(`A2UI formatted output at ${path} exceeds maximum length of ${JSON_MAX_STRING_LENGTH}`);
+    }
+    context.formattedStringLength += value.length;
+    if (context.formattedStringLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum formatted-string length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+    }
+    return value;
+}
 function resolveJsonPointer(document, pointer, path) {
     if (pointer === "") {
         return document;
     }
+    return resolvePointerTokens(document, pointer.slice(1).split("/"), pointer, path);
+}
+function resolveRelativePointer(document, pointer, path) {
+    if (pointer === "") {
+        return document;
+    }
+    return resolvePointerTokens(document, pointer.split("/"), pointer, path);
+}
+function resolvePointerTokens(document, encodedTokens, pointer, path) {
     let cursor = document;
-    for (const encodedToken of pointer.slice(1).split("/")) {
+    for (const encodedToken of encodedTokens) {
         const token = decodePointerToken(encodedToken, pointer);
         if (Array.isArray(cursor)) {
             if (!/^(0|[1-9][0-9]*)$/.test(token)) {
@@ -251,6 +1236,25 @@ function resolveJsonPointer(document, pointer, path) {
     }
     return cursor;
 }
+function resolveBindingPointer(value, path, scope) {
+    const pointer = expectString(value, path);
+    if (pointer.startsWith("/") || scope === undefined) {
+        return expectAbsoluteBinding(pointer, path);
+    }
+    return pointer === "" ? scope.pointer : `${scope.pointer}/${pointer}`;
+}
+function appendPointerToken(pointer, encodedToken) {
+    return `${pointer}/${encodedToken}`;
+}
+function appendInstanceKey(parentKey, componentId, index) {
+    // Component IDs are arbitrary strings. Escape every key delimiter, including the escape marker,
+    // so distinct component paths cannot collapse to the same renderer-only dispatch identity.
+    const encodedId = componentId
+        .replaceAll("%", "%25")
+        .replaceAll("/", "%2F")
+        .replaceAll(":", "%3A");
+    return `${parentKey}/${encodedId}:${index}`;
+}
 function expectAbsoluteBinding(value, path) {
     const pointer = expectString(value, path);
     if (pointer !== "" && !pointer.startsWith("/")) {