@mcp-native/react-native 0.6.0 → 0.8.0

package/dist/v1.js

@@ -1,19 +1,53 @@
-import { A2UI_V1_MAX_COMPONENTS, A2UI_V1_MAX_SOURCE_LENGTH, A2uiParseError, evaluateA2uiV1FormatString, validateA2uiV1SurfaceState, } from "@mcp-native/a2ui";
+import { A2UI_V1_MAX_COMPONENTS, A2UI_V1_MAX_SOURCE_LENGTH, A2uiParseError, evaluateA2uiV1FormatString, validateA2uiV1HostExtensionComponent, 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";
+import { A2UI_V1_NATIVE_ICON_NAMES } from "./component-adapters.js";
 export const A2UI_V1_NATIVE_COMPONENT_NAMES = Object.freeze([
+    "AudioPlayer",
     "Button",
     "Card",
+    "CheckBox",
+    "ChoicePicker",
     "Column",
+    "DateTimeInput",
+    "Divider",
+    "Icon",
+    "Image",
     "List",
+    "Modal",
     "Row",
+    "Slider",
+    "Tabs",
     "Text",
     "TextField",
+    "Video",
 ]);
 /** 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;
+/** Maximum canonical HTTP(S) image URL retained for one image component. */
+export const A2UI_V1_NATIVE_MAX_IMAGE_URL_LENGTH = 8_192;
+/** Maximum choice options expanded into trusted host props in one render pass. */
+export const A2UI_V1_NATIVE_MAX_CHOICE_OPTIONS = 1_024;
+export const A2UI_V1_NATIVE_MAX_IMAGE_REDIRECT_ORIGINS = 64;
+export const A2UI_V1_NATIVE_MAX_IMAGE_BYTES = 104_857_600;
+export const A2UI_V1_NATIVE_MAX_IMAGE_DIMENSION = 16_384;
+export const A2UI_V1_NATIVE_MAX_IMAGE_PIXELS = 268_435_456;
+export const A2UI_V1_NATIVE_MAX_IMAGE_REDIRECTS = 10;
+/** Maximum reachable Image instances in one expanded surface. Checked before host policy calls. */
+export const A2UI_V1_NATIVE_MAX_IMAGES = 64;
+/** Maximum sum of host-granted transfer bytes across one expanded render plan. */
+export const A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_BYTES = A2UI_V1_NATIVE_MAX_IMAGE_BYTES;
+/** Maximum sum of host-granted decoded pixels across one expanded render plan. */
+export const A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_PIXELS = A2UI_V1_NATIVE_MAX_IMAGE_PIXELS;
+export const A2UI_V1_NATIVE_MAX_MEDIA = 16;
+export const A2UI_V1_NATIVE_MAX_MEDIA_URL_LENGTH = 8_192;
+export const A2UI_V1_NATIVE_MAX_MEDIA_MIME_TYPES = 32;
+export const A2UI_V1_NATIVE_MAX_MEDIA_REDIRECT_ORIGINS = 64;
+export const A2UI_V1_NATIVE_MAX_MEDIA_REDIRECTS = 10;
+export const A2UI_V1_NATIVE_MAX_MEDIA_BYTES = 2_147_483_648;
+export const A2UI_V1_NATIVE_MAX_TOTAL_MEDIA_BYTES = 2_147_483_648;
 /**
  * Converts a policy-validated A2UI v1 surface into the existing host-owned
  * native render plan. Unsupported renderer semantics fail closed.
@@ -27,7 +61,7 @@ export function createA2uiV1NativeRenderPlanForLocalEdits(surface, policy, optio
 }
 function createNativeRenderPlan(surface, policy, options, tolerateInvalidLocalOpenUrls) {
     const parsedOptions = parseRenderPlanOptions(options);
-    const context = createAdapterContext(surface, policy, parsedOptions.dataModel, parsedOptions.locale, tolerateInvalidLocalOpenUrls);
+    const context = createAdapterContext(surface, policy, parsedOptions.dataModel, parsedOptions.locale, tolerateInvalidLocalOpenUrls, parsedOptions.imagePolicy, parsedOptions.mediaPolicy, parsedOptions.hostExtensionPolicy);
     return adaptComponent("root", "root", context, undefined);
 }
 /** Resolves one validated event against the latest renderer-local data model. */
@@ -36,7 +70,7 @@ export function resolveA2uiV1NativeEvent(surface, policy, sourceComponentId, dat
         throw new A2uiParseError("Expected a non-empty A2UI source component id");
     }
     const parsedOptions = parseEventResolutionOptions(options);
-    const context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale);
+    const context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale, false, undefined, undefined, undefined, false);
     const plan = adaptComponent("root", "root", context, undefined);
     const events = findNativeEvents(plan, sourceComponentId, parsedOptions.instanceKey);
     if (events.length === 0) {
@@ -57,7 +91,7 @@ export function resolveA2uiV1NativeOpenUrl(surface, policy, sourceComponentId, d
         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 context = createAdapterContext(surface, policy, dataModel, parsedOptions.locale, false, undefined, undefined, undefined, false);
     const plan = adaptComponent("root", "root", context, undefined);
     const openUrls = findNativeOpenUrls(plan, sourceComponentId, parsedOptions.instanceKey);
     if (openUrls.length === 0) {
@@ -98,7 +132,7 @@ function findNativeOpenUrls(element, sourceComponentId, instanceKey, includeDisa
     }
     return openUrls;
 }
-function createAdapterContext(surface, policy, dataModel, locale, tolerateInvalidLocalOpenUrls = false) {
+function createAdapterContext(surface, policy, dataModel, locale, tolerateInvalidLocalOpenUrls = false, imagePolicy, mediaPolicy, hostExtensionPolicy, authorizeResources = true) {
     const localDataModel = dataModel === undefined
         ? parseJsonObject(surface.dataModel, "surface.dataModel")
         : parseJsonObject(dataModel, "options.dataModel");
@@ -112,9 +146,29 @@ function createAdapterContext(surface, policy, dataModel, locale, tolerateInvali
         pluralRules: new Map(),
         visiting: new Set(),
         tolerateInvalidLocalOpenUrls,
+        imagePolicy,
+        mediaPolicy,
+        hostExtensionPolicy,
+        hostExtensions: policy.hostExtensions,
+        authorizeResources,
+        choiceOptionCount: 0,
+        choiceOptionOutputLength: 0,
         formatStringExpressionCount: 0,
         formattedStringLength: 0,
         openUrlLength: 0,
+        imageUrlLength: 0,
+        imageCount: 0,
+        imageMaximumBytes: 0,
+        imageMaximumDecodedPixels: 0,
+        imageRedirectOriginCount: 0,
+        imageResourcePolicyOutputLength: 0,
+        mediaCount: 0,
+        mediaUrlLength: 0,
+        mediaMaximumBytes: 0,
+        mediaMimeTypeCount: 0,
+        mediaRedirectOriginCount: 0,
+        mediaPolicyOutputLength: 0,
+        hostExtensionCounts: new Map(),
         renderNodeCount: 0,
         validationCheckCount: 0,
         validationOutputLength: 0,
@@ -123,8 +177,14 @@ function createAdapterContext(surface, policy, dataModel, locale, tolerateInvali
 function parseRenderPlanOptions(options) {
     const parsed = parseOptionsObject(options, "A2UI native render plan options", [
         "dataModel",
+        "hostExtensionPolicy",
+        "imagePolicy",
         "locale",
+        "mediaPolicy",
     ]);
+    const imagePolicy = parseOptionalImagePolicy(parsed.imagePolicy, "options.imagePolicy");
+    const mediaPolicy = parseOptionalPolicy(parsed.mediaPolicy, "options.mediaPolicy");
+    const hostExtensionPolicy = parseOptionalPolicy(parsed.hostExtensionPolicy, "options.hostExtensionPolicy");
     return {
         ...(parsed.dataModel === undefined
             ? {}
@@ -132,6 +192,9 @@ function parseRenderPlanOptions(options) {
         ...(parsed.locale === undefined
             ? {}
             : { locale: parseLocale(parsed.locale, "options.locale") }),
+        ...(imagePolicy === undefined ? {} : { imagePolicy }),
+        ...(mediaPolicy === undefined ? {} : { mediaPolicy }),
+        ...(hostExtensionPolicy === undefined ? {} : { hostExtensionPolicy }),
     };
 }
 function parseEventResolutionOptions(options) {
@@ -166,6 +229,18 @@ function parseOpenUrlResolutionOptions(options) {
             : { locale: parseLocale(parsed.locale, "options.locale") }),
     };
 }
+function parseOptionalImagePolicy(value, path) {
+    if (value !== undefined && typeof value !== "function") {
+        throw new A2uiParseError(`Expected a function at ${path}`);
+    }
+    return value;
+}
+function parseOptionalPolicy(value, path) {
+    if (value !== undefined && typeof value !== "function") {
+        throw new A2uiParseError(`Expected a function at ${path}`);
+    }
+    return value;
+}
 function parseOptionsObject(value, label, allowedKeys) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new A2uiParseError(`Expected ${label} to be an object`);
@@ -227,12 +302,34 @@ function adaptComponent(id, key, context, scope) {
                 return adaptCard(component, key, context, scope);
             case "Text":
                 return adaptText(component, key, context, scope);
+            case "Image":
+                return adaptImage(component, key, context, scope);
+            case "Video":
+                return adaptMedia(component, key, "video", context, scope);
+            case "AudioPlayer":
+                return adaptMedia(component, key, "audio", context, scope);
+            case "Icon":
+                return adaptIcon(component, key, context, scope);
+            case "Divider":
+                return adaptDivider(component, key, context, scope);
             case "Button":
                 return adaptButton(component, key, context, scope);
             case "TextField":
                 return adaptTextField(component, key, context, scope);
+            case "CheckBox":
+                return adaptCheckBox(component, key, context, scope);
+            case "ChoicePicker":
+                return adaptChoicePicker(component, key, context, scope);
+            case "Slider":
+                return adaptSlider(component, key, context, scope);
+            case "DateTimeInput":
+                return adaptDateTimeInput(component, key, context, scope);
+            case "Tabs":
+                return adaptTabs(component, key, context, scope);
+            case "Modal":
+                return adaptModal(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`);
+                return adaptHostExtension(component, key, context, scope);
         }
     }
     finally {
@@ -317,6 +414,221 @@ function adaptText(component, key, context, scope) {
     addCommonProps(component, props, context, scope);
     return { key, component: "Text", props };
 }
+function adaptImage(component, key, context, scope) {
+    context.imageCount += 1;
+    if (context.imageCount > A2UI_V1_NATIVE_MAX_IMAGES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${A2UI_V1_NATIVE_MAX_IMAGES} images`);
+    }
+    const path = `components.${component.id}.url`;
+    const url = normalizeHttpUrl(resolveDynamicString(component.url, path, context, scope), path, "image", A2UI_V1_NATIVE_MAX_IMAGE_URL_LENGTH);
+    context.imageUrlLength += url.length;
+    if (context.imageUrlLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum image URL length of ${A2UI_V1_MAX_SOURCE_LENGTH} at ${path}`);
+    }
+    const props = {
+        uri: url,
+        fit: component.fit ?? "fill",
+        variant: component.variant ?? "mediumFeature",
+    };
+    if (context.authorizeResources) {
+        props.resourcePolicy = authorizeImageResource(component.id, key, url, `components.${component.id}.imagePolicy`, context);
+    }
+    if (component.description !== undefined) {
+        props.description = resolveDynamicString(component.description, `components.${component.id}.description`, context, scope);
+    }
+    addCommonProps(component, props, context, scope);
+    if (props.accessibilityLabel === undefined && props.description !== undefined) {
+        props.accessibilityLabel = props.description;
+    }
+    return { key, component: "Image", props };
+}
+function authorizeImageResource(componentId, key, url, path, context) {
+    const request = Object.freeze({
+        url,
+        surfaceId: context.surface.surfaceId,
+        sourceComponentId: componentId,
+        instanceKey: key,
+    });
+    if (context.imagePolicy === undefined) {
+        throw new A2uiParseError(`A2UI image resource ${JSON.stringify(componentId)} requires an explicit host image policy`);
+    }
+    let decision;
+    try {
+        decision = context.imagePolicy(request);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`A2UI image resource ${JSON.stringify(componentId)} host policy failed`, { cause });
+    }
+    if (decision === false) {
+        throw new A2uiParseError(`A2UI image resource ${JSON.stringify(componentId)} URL is denied by host policy`);
+    }
+    const resourcePolicy = parseImageResourcePolicy(decision, path, context);
+    context.imageMaximumBytes += resourcePolicy.maximumBytes;
+    if (context.imageMaximumBytes > A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_BYTES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum total image transfer budget of ${A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_BYTES} bytes`);
+    }
+    context.imageMaximumDecodedPixels += resourcePolicy.maximumDecodedPixels;
+    if (context.imageMaximumDecodedPixels > A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_PIXELS) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum total decoded image budget of ${A2UI_V1_NATIVE_MAX_TOTAL_IMAGE_PIXELS} pixels`);
+    }
+    return resourcePolicy;
+}
+function adaptMedia(component, key, kind, context, scope) {
+    context.mediaCount += 1;
+    if (context.mediaCount > A2UI_V1_NATIVE_MAX_MEDIA) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${A2UI_V1_NATIVE_MAX_MEDIA} media components`);
+    }
+    const path = `components.${component.id}.url`;
+    const url = normalizeHttpUrl(resolveDynamicString(component.url, path, context, scope), path, kind, A2UI_V1_NATIVE_MAX_MEDIA_URL_LENGTH);
+    context.mediaUrlLength += url.length;
+    if (context.mediaUrlLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds cumulative media URL length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+    }
+    const props = { uri: url };
+    if (context.authorizeResources) {
+        props.resourcePolicy = authorizeMediaResource(component.id, key, kind, url, context);
+    }
+    if (kind === "video" && component.posterUrl !== undefined) {
+        const posterPath = `components.${component.id}.posterUrl`;
+        const posterUrl = normalizeHttpUrl(resolveDynamicString(component.posterUrl, posterPath, context, scope), posterPath, "video poster", A2UI_V1_NATIVE_MAX_IMAGE_URL_LENGTH);
+        context.imageCount += 1;
+        if (context.imageCount > A2UI_V1_NATIVE_MAX_IMAGES) {
+            throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${A2UI_V1_NATIVE_MAX_IMAGES} image resources`);
+        }
+        context.imageUrlLength += posterUrl.length;
+        if (context.imageUrlLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+            throw new A2uiParseError(`Expanded A2UI native plan exceeds cumulative image URL length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+        }
+        props.posterUri = posterUrl;
+        if (context.authorizeResources) {
+            props.posterResourcePolicy = authorizeImageResource(component.id, `${key}:poster`, posterUrl, `components.${component.id}.posterPolicy`, context);
+        }
+    }
+    if (kind === "audio" && component.description !== undefined) {
+        props.description = resolveDynamicString(component.description, `components.${component.id}.description`, context, scope);
+    }
+    addCommonProps(component, props, context, scope);
+    if (props.accessibilityLabel === undefined) {
+        props.accessibilityLabel =
+            kind === "audio" && typeof props.description === "string"
+                ? props.description
+                : kind === "audio"
+                    ? "Audio"
+                    : "Video";
+    }
+    return { key, component: kind === "video" ? "Video" : "AudioPlayer", props };
+}
+function authorizeMediaResource(componentId, key, kind, url, context) {
+    if (context.mediaPolicy === undefined) {
+        throw new A2uiParseError(`A2UI ${kind} ${JSON.stringify(componentId)} requires an explicit host media policy`);
+    }
+    const sourceOrigin = parseHttpUrlOrigin(url, `components.${componentId}.url`);
+    const request = Object.freeze({
+        kind,
+        url,
+        sourceOrigin,
+        surfaceId: context.surface.surfaceId,
+        sourceComponentId: componentId,
+        instanceKey: key,
+    });
+    let decision;
+    try {
+        decision = context.mediaPolicy(request);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`A2UI ${kind} ${JSON.stringify(componentId)} host policy failed`, {
+            cause,
+        });
+    }
+    if (decision === false) {
+        throw new A2uiParseError(`A2UI ${kind} ${JSON.stringify(componentId)} URL is denied by host policy`);
+    }
+    const resourcePolicy = parseMediaResourcePolicy(decision, request, `components.${componentId}.mediaPolicy`, context);
+    context.mediaMaximumBytes += resourcePolicy.maximumBytes;
+    if (context.mediaMaximumBytes > A2UI_V1_NATIVE_MAX_TOTAL_MEDIA_BYTES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum total media transfer budget of ${A2UI_V1_NATIVE_MAX_TOTAL_MEDIA_BYTES} bytes`);
+    }
+    return resourcePolicy;
+}
+function adaptHostExtension(component, key, context, scope) {
+    const hostExtensions = context.hostExtensions;
+    if (hostExtensions === undefined) {
+        throw new A2uiParseError(`A2UI component ${JSON.stringify(component.id)} uses an unavailable host extension`);
+    }
+    const validated = validateA2uiV1HostExtensionComponent(hostExtensions, component, `components.${component.id}`);
+    const manifest = validated.manifest;
+    const countKey = `${manifest.catalogId}\u0000${manifest.componentName}`;
+    const count = (context.hostExtensionCounts.get(countKey) ?? 0) + 1;
+    if (count > manifest.limits.maximumInstances) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${manifest.limits.maximumInstances} instances for ${JSON.stringify(manifest.componentName)}`);
+    }
+    context.hostExtensionCounts.set(countKey, count);
+    const props = {
+        extensionId: manifest.extensionId,
+        catalogId: manifest.catalogId,
+        schemaVersion: manifest.schemaVersion,
+        componentName: manifest.componentName,
+        manifestFingerprint: validated.manifestFingerprint,
+        semanticProps: validated.props,
+        sourceComponentId: component.id,
+        surfaceId: context.surface.surfaceId,
+    };
+    if (context.authorizeResources) {
+        if (context.hostExtensionPolicy === undefined) {
+            throw new A2uiParseError(`Host extension ${JSON.stringify(manifest.componentName)} requires an explicit capability policy`);
+        }
+        const request = Object.freeze({
+            extensionId: manifest.extensionId,
+            catalogId: manifest.catalogId,
+            schemaVersion: manifest.schemaVersion,
+            componentName: manifest.componentName,
+            surfaceId: context.surface.surfaceId,
+            sourceComponentId: component.id,
+            instanceKey: key,
+            platform: hostExtensions.platform,
+            semanticProps: validated.props,
+            permissionNeeds: manifest.permissionNeeds,
+            resourceNeeds: manifest.resourceNeeds,
+        });
+        let decision;
+        try {
+            decision = context.hostExtensionPolicy(request);
+        }
+        catch (cause) {
+            throw new A2uiParseError(`Host extension ${JSON.stringify(manifest.componentName)} capability policy failed`, { cause });
+        }
+        if (decision === false) {
+            throw new A2uiParseError(`Host extension ${JSON.stringify(manifest.componentName)} is denied by capability policy`);
+        }
+        props.capabilityGrant = parseHostExtensionCapabilityGrant(decision, manifest.permissionNeeds, manifest.resourceNeeds, `components.${component.id}.hostExtensionPolicy`);
+    }
+    addCommonProps(component, props, context, scope);
+    if (manifest.accessibility.requiresLabel && props.accessibilityLabel === undefined) {
+        throw new A2uiParseError(`Host extension ${JSON.stringify(manifest.componentName)} requires an accessibility label`);
+    }
+    return { key, component: "HostExtension", props };
+}
+function adaptIcon(component, key, context, scope) {
+    const path = `components.${component.id}.name`;
+    if (component.name !== null &&
+        typeof component.name === "object" &&
+        !Array.isArray(component.name) &&
+        Object.hasOwn(component.name, "svgPath")) {
+        throw new A2uiParseError(`A2UI native Icon ${JSON.stringify(component.id)} requires a pinned semantic icon name at ${path}; svgPath is not supported`);
+    }
+    const name = resolveDynamicString(component.name, path, context, scope);
+    if (!A2UI_V1_NATIVE_ICON_NAMES.includes(name)) {
+        throw new A2uiParseError(`A2UI native Icon ${JSON.stringify(component.id)} requires a pinned semantic icon name at ${path}; svgPath is not supported`);
+    }
+    const props = { name };
+    addCommonProps(component, props, context, scope);
+    return { key, component: "Icon", props };
+}
+function adaptDivider(component, key, context, scope) {
+    const props = { axis: component.axis ?? "horizontal" };
+    addCommonProps(component, props, context, scope);
+    return { key, component: "Divider", props };
+}
 function adaptButton(component, key, context, scope) {
     const childId = expectString(component.child, `components.${component.id}.child`);
     const child = context.surface.components.get(childId);
@@ -364,6 +676,244 @@ function adaptTextField(component, key, context, scope) {
     }
     return { key, component: "TextInput", props };
 }
+function adaptCheckBox(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    const label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
+    const props = {
+        label,
+        value: resolveDynamicBoolean(component.value, `${componentPath}.value`, context, scope),
+    };
+    addBindingProp(component.value, `${componentPath}.value`, props, scope);
+    addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "input");
+    if (props.accessibilityLabel === undefined) {
+        props.accessibilityLabel = label;
+    }
+    return { key, component: "CheckBox", props };
+}
+function adaptChoicePicker(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    if (!Array.isArray(component.options)) {
+        throw new A2uiParseError(`Expected an array at ${componentPath}.options`);
+    }
+    context.choiceOptionCount += component.options.length;
+    if (context.choiceOptionCount > A2UI_V1_NATIVE_MAX_CHOICE_OPTIONS) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${A2UI_V1_NATIVE_MAX_CHOICE_OPTIONS} choice options`);
+    }
+    const optionValues = new Set();
+    const options = component.options.map((value, index) => {
+        const option = expectObject(value, `${componentPath}.options[${index}]`);
+        const label = resolveDynamicString(option.label, `${componentPath}.options[${index}].label`, context, scope);
+        const optionValue = expectString(option.value, `${componentPath}.options[${index}].value`);
+        if (optionValues.has(optionValue)) {
+            throw new A2uiParseError(`A2UI ChoicePicker ${JSON.stringify(component.id)} contains duplicate option value ${JSON.stringify(optionValue)}`);
+        }
+        optionValues.add(optionValue);
+        context.choiceOptionOutputLength += label.length + optionValue.length;
+        if (context.choiceOptionOutputLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+            throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum choice-option output length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+        }
+        return Object.freeze({ label, value: optionValue });
+    });
+    const selected = resolveDynamicStringList(component.value, `${componentPath}.value`, context, scope);
+    if (new Set(selected).size !== selected.length) {
+        throw new A2uiParseError(`A2UI ChoicePicker ${JSON.stringify(component.id)} contains duplicate selected values`);
+    }
+    for (const value of selected) {
+        if (!optionValues.has(value)) {
+            throw new A2uiParseError(`A2UI ChoicePicker ${JSON.stringify(component.id)} selects unknown value ${JSON.stringify(value)}`);
+        }
+    }
+    const variant = component.variant ?? "mutuallyExclusive";
+    if (variant === "mutuallyExclusive" && selected.length > 1) {
+        throw new A2uiParseError(`A2UI ChoicePicker ${JSON.stringify(component.id)} allows at most one selected value`);
+    }
+    const props = {
+        options: Object.freeze(options),
+        value: Object.freeze(selected),
+        variant,
+        displayStyle: component.displayStyle ?? "checkbox",
+        filterable: component.filterable ?? false,
+    };
+    if (component.label !== undefined) {
+        props.label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
+    }
+    addBindingProp(component.value, `${componentPath}.value`, props, scope);
+    addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "input");
+    if (props.accessibilityLabel === undefined) {
+        if (props.label === undefined) {
+            throw new A2uiParseError(`A2UI native ChoicePicker ${JSON.stringify(component.id)} requires label or accessibility.label`);
+        }
+        props.accessibilityLabel = props.label;
+    }
+    return { key, component: "ChoicePicker", props };
+}
+function adaptSlider(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    const minimum = component.min === undefined ? 0 : expectFiniteNumber(component.min, `${componentPath}.min`);
+    const maximum = expectFiniteNumber(component.max, `${componentPath}.max`);
+    if (minimum >= maximum) {
+        throw new A2uiParseError(`Expected ${componentPath}.min to be less than max`);
+    }
+    const value = resolveDynamicNumber(component.value, `${componentPath}.value`, context, scope);
+    if (value < minimum || value > maximum) {
+        throw new A2uiParseError(`Expected ${componentPath}.value to be within min and max`);
+    }
+    let step;
+    if (component.steps !== undefined) {
+        const steps = expectFiniteNumber(component.steps, `${componentPath}.steps`);
+        if (!Number.isInteger(steps) || steps < 1 || steps > JSON_MAX_VALUES) {
+            throw new A2uiParseError(`Expected ${componentPath}.steps to be an integer from 1 through ${JSON_MAX_VALUES}`);
+        }
+        step = (maximum - minimum) / steps;
+        if (!Number.isFinite(step) || step <= 0) {
+            throw new A2uiParseError(`A2UI Slider ${JSON.stringify(component.id)} has invalid range`);
+        }
+        if (!isSliderStepValue(value, minimum, step)) {
+            throw new A2uiParseError(`A2UI Slider ${JSON.stringify(component.id)} value does not align with its steps`);
+        }
+    }
+    const props = {
+        value,
+        minimum,
+        maximum,
+        ...(step === undefined ? {} : { step }),
+    };
+    if (component.label !== undefined) {
+        props.label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
+    }
+    addBindingProp(component.value, `${componentPath}.value`, props, scope);
+    addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "input");
+    if (props.accessibilityLabel === undefined) {
+        if (props.label === undefined) {
+            throw new A2uiParseError(`A2UI native Slider ${JSON.stringify(component.id)} requires label or accessibility.label`);
+        }
+        props.accessibilityLabel = props.label;
+    }
+    return { key, component: "Slider", props };
+}
+function isSliderStepValue(value, minimum, step) {
+    const offset = (value - minimum) / step;
+    return (Math.abs(offset - Math.round(offset)) <= Number.EPSILON * Math.max(1, Math.abs(offset)) * 8);
+}
+function adaptDateTimeInput(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    const enableDate = component.enableDate === true;
+    const enableTime = component.enableTime === true;
+    if (!enableDate && !enableTime) {
+        throw new A2uiParseError(`A2UI DateTimeInput ${JSON.stringify(component.id)} must enable date, time, or both`);
+    }
+    const value = resolveDynamicString(component.value, `${componentPath}.value`, context, scope);
+    validateDateTimeInputValue(value, enableDate, enableTime, `${componentPath}.value`, true);
+    const minimum = component.min === undefined
+        ? undefined
+        : resolveDynamicString(component.min, `${componentPath}.min`, context, scope);
+    const maximum = component.max === undefined
+        ? undefined
+        : resolveDynamicString(component.max, `${componentPath}.max`, context, scope);
+    if (minimum !== undefined) {
+        validateDateTimeInputValue(minimum, enableDate, enableTime, `${componentPath}.min`, false);
+    }
+    if (maximum !== undefined) {
+        validateDateTimeInputValue(maximum, enableDate, enableTime, `${componentPath}.max`, false);
+    }
+    if (minimum !== undefined &&
+        maximum !== undefined &&
+        dateTimeInputSortValue(minimum, enableDate, enableTime, `${componentPath}.min`) >
+            dateTimeInputSortValue(maximum, enableDate, enableTime, `${componentPath}.max`)) {
+        throw new A2uiParseError(`Expected ${componentPath}.min not to exceed max`);
+    }
+    const valueSort = value.length === 0
+        ? undefined
+        : dateTimeInputSortValue(value, enableDate, enableTime, `${componentPath}.value`);
+    if (valueSort !== undefined &&
+        minimum !== undefined &&
+        valueSort < dateTimeInputSortValue(minimum, enableDate, enableTime, `${componentPath}.min`)) {
+        throw new A2uiParseError(`Expected ${componentPath}.value not to be earlier than min`);
+    }
+    if (valueSort !== undefined &&
+        maximum !== undefined &&
+        valueSort > dateTimeInputSortValue(maximum, enableDate, enableTime, `${componentPath}.max`)) {
+        throw new A2uiParseError(`Expected ${componentPath}.value not to be later than max`);
+    }
+    const props = {
+        value,
+        enableDate,
+        enableTime,
+        ...(minimum === undefined ? {} : { minimum }),
+        ...(maximum === undefined ? {} : { maximum }),
+    };
+    if (component.label !== undefined) {
+        props.label = resolveDynamicString(component.label, `${componentPath}.label`, context, scope);
+    }
+    addBindingProp(component.value, `${componentPath}.value`, props, scope);
+    addCommonProps(component, props, context, scope);
+    addValidationProps(component, props, context, scope, "input");
+    if (props.accessibilityLabel === undefined) {
+        if (props.label === undefined) {
+            throw new A2uiParseError(`A2UI native DateTimeInput ${JSON.stringify(component.id)} requires label or accessibility.label`);
+        }
+        props.accessibilityLabel = props.label;
+    }
+    return { key, component: "DateTimeInput", props };
+}
+function adaptTabs(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    if (!Array.isArray(component.tabs) || component.tabs.length === 0) {
+        throw new A2uiParseError(`Expected a non-empty array at ${componentPath}.tabs`);
+    }
+    const tabs = component.tabs.map((value, index) => {
+        const tab = expectObject(value, `${componentPath}.tabs[${index}]`);
+        return Object.freeze({
+            title: resolveDynamicString(tab.title, `${componentPath}.tabs[${index}].title`, context, scope),
+        });
+    });
+    const props = { tabs: Object.freeze(tabs) };
+    addCommonProps(component, props, context, scope);
+    return {
+        key,
+        component: "Tabs",
+        props,
+        children: component.tabs.map((value, index) => {
+            const tab = expectObject(value, `${componentPath}.tabs[${index}]`);
+            const childId = expectString(tab.child, `${componentPath}.tabs[${index}].child`);
+            return adaptComponent(childId, appendInstanceKey(key, childId, index), context, scope);
+        }),
+    };
+}
+function adaptModal(component, key, context, scope) {
+    const componentPath = `components.${component.id}`;
+    const triggerId = expectString(component.trigger, `${componentPath}.trigger`);
+    const contentId = expectString(component.content, `${componentPath}.content`);
+    if (context.surface.components.get(triggerId)?.component !== "Button") {
+        throw new A2uiParseError(`A2UI native Modal ${JSON.stringify(component.id)} requires a Button trigger`);
+    }
+    const props = {};
+    addCommonProps(component, props, context, scope);
+    return {
+        key,
+        component: "Modal",
+        props,
+        children: [
+            adaptComponent(triggerId, appendInstanceKey(key, triggerId, 0), context, scope),
+            adaptComponent(contentId, appendInstanceKey(key, contentId, 1), context, scope),
+        ],
+    };
+}
+function addBindingProp(value, path, props, scope) {
+    if (value !== undefined && isBinding(value)) {
+        props.binding = resolveBindingPointer(value.path, `${path}.path`, scope);
+    }
+}
+function resolveDynamicStringList(value, path, context, scope) {
+    const resolved = resolveDynamicValue(value, path, context, scope);
+    if (!Array.isArray(resolved) || resolved.some((item) => typeof item !== "string")) {
+        throw new A2uiParseError(`Expected an array of strings at ${path}`);
+    }
+    return [...resolved];
+}
 function addValidationProps(component, props, context, scope, target) {
     if (component.checks === undefined) {
         return;
@@ -608,15 +1158,18 @@ function resolveButtonAction(component, key, context, scope) {
     };
 }
 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}`);
+    return normalizeHttpUrl(value, path, "openUrl", A2UI_V1_NATIVE_MAX_OPEN_URL_LENGTH);
+}
+function normalizeHttpUrl(value, path, label, maximumLength) {
+    if (value.length === 0 || value.length > maximumLength) {
+        throw new A2uiParseError(`Expected an HTTP(S) URL up to ${maximumLength} 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}`);
+        throw new A2uiParseError(`The host runtime cannot validate an ${label} value at ${path}`);
     }
     let parsed;
     try {
@@ -629,13 +1182,231 @@ function normalizeOpenUrl(value, path) {
         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}`);
+        throw new A2uiParseError(`A2UI ${label} 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}`);
+    if (parsed.href.length > maximumLength) {
+        throw new A2uiParseError(`Canonical A2UI ${label} at ${path} exceeds maximum length of ${maximumLength}`);
     }
     return parsed.href;
 }
+function parseImageResourcePolicy(value, path, context) {
+    const policy = parseJsonObject(value, path);
+    const allowedKeys = new Set([
+        "allowedRedirectOrigins",
+        "cacheMode",
+        "maximumBytes",
+        "maximumDecodedHeight",
+        "maximumDecodedPixels",
+        "maximumDecodedWidth",
+        "maximumRedirects",
+    ]);
+    for (const key of Object.keys(policy)) {
+        if (!allowedKeys.has(key)) {
+            throw new A2uiParseError(`Unexpected field ${JSON.stringify(key)} at ${path}`);
+        }
+    }
+    if (!Array.isArray(policy.allowedRedirectOrigins) ||
+        policy.allowedRedirectOrigins.length > A2UI_V1_NATIVE_MAX_IMAGE_REDIRECT_ORIGINS) {
+        throw new A2uiParseError(`Expected at most ${A2UI_V1_NATIVE_MAX_IMAGE_REDIRECT_ORIGINS} redirect origins at ${path}.allowedRedirectOrigins`);
+    }
+    context.imageRedirectOriginCount += policy.allowedRedirectOrigins.length;
+    if (context.imageRedirectOriginCount > JSON_MAX_VALUES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${JSON_MAX_VALUES} image redirect origins`);
+    }
+    const origins = policy.allowedRedirectOrigins.map((origin, index) => parseExactHttpOrigin(origin, `${path}.allowedRedirectOrigins[${index}]`));
+    if (new Set(origins).size !== origins.length) {
+        throw new A2uiParseError(`Expected unique redirect origins at ${path}.allowedRedirectOrigins`);
+    }
+    context.imageResourcePolicyOutputLength += origins.reduce((length, origin) => length + origin.length, 0);
+    if (context.imageResourcePolicyOutputLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum image-policy output length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+    }
+    const cacheMode = policy.cacheMode;
+    if (cacheMode !== "default" && cacheMode !== "no-store") {
+        throw new A2uiParseError(`Expected a closed cache mode at ${path}.cacheMode`);
+    }
+    const maximumBytes = parseBoundedPositiveInteger(policy.maximumBytes, A2UI_V1_NATIVE_MAX_IMAGE_BYTES, `${path}.maximumBytes`);
+    const maximumDecodedWidth = parseBoundedPositiveInteger(policy.maximumDecodedWidth, A2UI_V1_NATIVE_MAX_IMAGE_DIMENSION, `${path}.maximumDecodedWidth`);
+    const maximumDecodedHeight = parseBoundedPositiveInteger(policy.maximumDecodedHeight, A2UI_V1_NATIVE_MAX_IMAGE_DIMENSION, `${path}.maximumDecodedHeight`);
+    const maximumDecodedPixels = parseBoundedPositiveInteger(policy.maximumDecodedPixels, A2UI_V1_NATIVE_MAX_IMAGE_PIXELS, `${path}.maximumDecodedPixels`);
+    if (maximumDecodedPixels > maximumDecodedWidth * maximumDecodedHeight) {
+        throw new A2uiParseError(`Expected ${path}.maximumDecodedPixels not to exceed the declared dimensions`);
+    }
+    const maximumRedirects = parseBoundedNonNegativeInteger(policy.maximumRedirects, A2UI_V1_NATIVE_MAX_IMAGE_REDIRECTS, `${path}.maximumRedirects`);
+    return Object.freeze({
+        allowedRedirectOrigins: Object.freeze(origins),
+        cacheMode,
+        maximumBytes,
+        maximumDecodedHeight,
+        maximumDecodedPixels,
+        maximumDecodedWidth,
+        maximumRedirects,
+    });
+}
+function parseMediaResourcePolicy(value, request, path, context) {
+    const policy = parseJsonObject(value, path);
+    const allowedKeys = new Set([
+        "allowedMimeTypes",
+        "allowedRedirectOrigins",
+        "allowsAutoplay",
+        "allowsBackgroundPlayback",
+        "allowsExternalRoutes",
+        "maximumBytes",
+        "maximumRedirects",
+        "requiresUserActivation",
+        "sourceOrigin",
+    ]);
+    for (const key of Object.keys(policy)) {
+        if (!allowedKeys.has(key)) {
+            throw new A2uiParseError(`Unexpected field ${JSON.stringify(key)} at ${path}`);
+        }
+    }
+    const sourceOrigin = parseExactHttpOrigin(policy.sourceOrigin, `${path}.sourceOrigin`);
+    if (sourceOrigin !== request.sourceOrigin) {
+        throw new A2uiParseError(`Expected ${path}.sourceOrigin to match the requested media origin`);
+    }
+    if (!Array.isArray(policy.allowedRedirectOrigins) ||
+        policy.allowedRedirectOrigins.length > A2UI_V1_NATIVE_MAX_MEDIA_REDIRECT_ORIGINS) {
+        throw new A2uiParseError(`Expected at most ${A2UI_V1_NATIVE_MAX_MEDIA_REDIRECT_ORIGINS} redirect origins at ${path}.allowedRedirectOrigins`);
+    }
+    context.mediaRedirectOriginCount += policy.allowedRedirectOrigins.length;
+    if (context.mediaRedirectOriginCount > JSON_MAX_VALUES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${JSON_MAX_VALUES} media redirect origins`);
+    }
+    const allowedRedirectOrigins = policy.allowedRedirectOrigins.map((origin, index) => parseExactHttpOrigin(origin, `${path}.allowedRedirectOrigins[${index}]`));
+    if (new Set(allowedRedirectOrigins).size !== allowedRedirectOrigins.length) {
+        throw new A2uiParseError(`Expected unique redirect origins at ${path}.allowedRedirectOrigins`);
+    }
+    if (!Array.isArray(policy.allowedMimeTypes) ||
+        policy.allowedMimeTypes.length === 0 ||
+        policy.allowedMimeTypes.length > A2UI_V1_NATIVE_MAX_MEDIA_MIME_TYPES) {
+        throw new A2uiParseError(`Expected one through ${A2UI_V1_NATIVE_MAX_MEDIA_MIME_TYPES} MIME types at ${path}.allowedMimeTypes`);
+    }
+    context.mediaMimeTypeCount += policy.allowedMimeTypes.length;
+    if (context.mediaMimeTypeCount > JSON_MAX_VALUES) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds maximum of ${JSON_MAX_VALUES} media MIME types`);
+    }
+    const mimePrefix = request.kind === "video" ? "video/" : "audio/";
+    const allowedMimeTypes = policy.allowedMimeTypes.map((mimeType, index) => {
+        const parsed = expectString(mimeType, `${path}.allowedMimeTypes[${index}]`);
+        if (parsed !== parsed.toLowerCase() ||
+            !parsed.startsWith(mimePrefix) ||
+            !/^(?:audio|video)\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(parsed)) {
+            throw new A2uiParseError(`Expected an exact lower-case ${request.kind} MIME type at ${path}.allowedMimeTypes[${index}]`);
+        }
+        return parsed;
+    });
+    if (new Set(allowedMimeTypes).size !== allowedMimeTypes.length) {
+        throw new A2uiParseError(`Expected unique MIME types at ${path}.allowedMimeTypes`);
+    }
+    context.mediaPolicyOutputLength +=
+        sourceOrigin.length +
+            allowedRedirectOrigins.reduce((total, origin) => total + origin.length, 0) +
+            allowedMimeTypes.reduce((total, mimeType) => total + mimeType.length, 0);
+    if (context.mediaPolicyOutputLength > A2UI_V1_MAX_SOURCE_LENGTH) {
+        throw new A2uiParseError(`Expanded A2UI native plan exceeds media-policy output length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+    }
+    const maximumBytes = parseBoundedPositiveInteger(policy.maximumBytes, A2UI_V1_NATIVE_MAX_MEDIA_BYTES, `${path}.maximumBytes`);
+    const maximumRedirects = parseBoundedNonNegativeInteger(policy.maximumRedirects, A2UI_V1_NATIVE_MAX_MEDIA_REDIRECTS, `${path}.maximumRedirects`);
+    const allowsAutoplay = parsePolicyBoolean(policy.allowsAutoplay, `${path}.allowsAutoplay`);
+    const allowsBackgroundPlayback = parsePolicyBoolean(policy.allowsBackgroundPlayback, `${path}.allowsBackgroundPlayback`);
+    const allowsExternalRoutes = parsePolicyBoolean(policy.allowsExternalRoutes, `${path}.allowsExternalRoutes`);
+    const requiresUserActivation = parsePolicyBoolean(policy.requiresUserActivation, `${path}.requiresUserActivation`);
+    if (allowsAutoplay && requiresUserActivation) {
+        throw new A2uiParseError(`A2UI media policy cannot allow autoplay while requiring user activation at ${path}`);
+    }
+    return Object.freeze({
+        sourceOrigin,
+        allowedRedirectOrigins: Object.freeze(allowedRedirectOrigins),
+        allowedMimeTypes: Object.freeze(allowedMimeTypes),
+        maximumBytes,
+        maximumRedirects,
+        allowsAutoplay,
+        allowsBackgroundPlayback,
+        allowsExternalRoutes,
+        requiresUserActivation,
+    });
+}
+function parseHostExtensionCapabilityGrant(value, permissionNeeds, resourceNeeds, path) {
+    const grant = parseJsonObject(value, path);
+    const keys = Object.keys(grant);
+    if (keys.some((key) => key !== "permissions" && key !== "resources")) {
+        throw new A2uiParseError(`Unexpected host-extension capability grant field at ${path}`);
+    }
+    const permissions = parseExactGrantNames(grant.permissions, permissionNeeds, `${path}.permissions`);
+    const resources = parseExactGrantNames(grant.resources, resourceNeeds, `${path}.resources`);
+    return Object.freeze({ permissions, resources });
+}
+function parseExactGrantNames(value, expected, path) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new A2uiParseError(`Expected an array of capability identifiers at ${path}`);
+    }
+    const names = value;
+    if (new Set(names).size !== names.length) {
+        throw new A2uiParseError(`Expected unique capability identifiers at ${path}`);
+    }
+    const actualSet = new Set(names);
+    if (actualSet.size !== expected.length || expected.some((name) => !actualSet.has(name))) {
+        throw new A2uiParseError(`Expected ${path} to exactly grant the manifest-declared needs`);
+    }
+    return Object.freeze([...expected]);
+}
+function parsePolicyBoolean(value, path) {
+    if (typeof value !== "boolean") {
+        throw new A2uiParseError(`Expected a boolean at ${path}`);
+    }
+    return value;
+}
+function parseHttpUrlOrigin(value, path) {
+    const UrlConstructor = globalThis.URL;
+    if (UrlConstructor === undefined) {
+        throw new A2uiParseError(`The host runtime cannot validate a media origin at ${path}`);
+    }
+    try {
+        return new UrlConstructor(value).origin;
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Expected an HTTP(S) media URL at ${path}`, { cause });
+    }
+}
+function parseExactHttpOrigin(value, path) {
+    const origin = expectString(value, path);
+    if (/\s|\p{Cf}/u.test(origin) || hasAsciiControlCharacter(origin)) {
+        throw new A2uiParseError(`Expected an exact HTTP(S) origin at ${path}`);
+    }
+    const UrlConstructor = globalThis.URL;
+    if (UrlConstructor === undefined) {
+        throw new A2uiParseError(`The host runtime cannot validate a resource origin at ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = new UrlConstructor(origin);
+    }
+    catch (cause) {
+        throw new A2uiParseError(`Expected an exact HTTP(S) origin at ${path}`, { cause });
+    }
+    if ((parsed.protocol !== "https:" && parsed.protocol !== "http:") ||
+        parsed.username.length > 0 ||
+        parsed.password.length > 0 ||
+        parsed.origin !== origin) {
+        throw new A2uiParseError(`Expected an exact HTTP(S) origin at ${path}`);
+    }
+    return parsed.origin;
+}
+function parseBoundedPositiveInteger(value, maximum, path) {
+    const result = expectFiniteNumber(value, path);
+    if (!Number.isInteger(result) || result < 1 || result > maximum) {
+        throw new A2uiParseError(`Expected an integer from 1 through ${maximum} at ${path}`);
+    }
+    return result;
+}
+function parseBoundedNonNegativeInteger(value, maximum, path) {
+    const result = expectFiniteNumber(value, path);
+    if (!Number.isInteger(result) || result < 0 || result > maximum) {
+        throw new A2uiParseError(`Expected an integer from 0 through ${maximum} at ${path}`);
+    }
+    return result;
+}
 function hasAsciiControlCharacter(value) {
     for (let index = 0; index < value.length; index += 1) {
         const code = value.charCodeAt(index);
@@ -803,6 +1574,7 @@ function resolveNumberFormat(call, path, context, scope) {
 }
 const DATE_NUMBER = /^[+-]?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
 const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const TIME_ONLY = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|([+-])(\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([
@@ -825,6 +1597,98 @@ const DATE_PATTERN_TOKENS = Object.freeze([
     "a",
 ]);
 const DATE_PATTERN_TOKEN_SET = new Set(DATE_PATTERN_TOKENS);
+function validateDateTimeInputValue(value, enableDate, enableTime, path, allowEmpty) {
+    if (allowEmpty && value.length === 0) {
+        return;
+    }
+    if (enableDate && enableTime) {
+        parseDateValue(value, path);
+        if (RFC_3339_TIMESTAMP.exec(value) === null) {
+            throw new A2uiParseError(`Expected an RFC 3339 date-time at ${path}`);
+        }
+        return;
+    }
+    if (enableDate) {
+        const match = DATE_ONLY.exec(value);
+        if (match === null) {
+            throw new A2uiParseError(`Expected a yyyy-MM-dd date at ${path}`);
+        }
+        validateCalendarDate(Number(match[1]), Number(match[2]), Number(match[3]), path);
+        return;
+    }
+    parseTimeOnly(value, path);
+}
+/** Internal mounted-renderer guard for values emitted by a trusted host date/time component. */
+export function validateA2uiV1NativeDateTimeInputChange(value, enableDate, enableTime, minimum, maximum, path) {
+    if (!enableDate && !enableTime) {
+        throw new A2uiParseError(`A2UI DateTimeInput at ${path} must enable date, time, or both`);
+    }
+    validateDateTimeInputValue(value, enableDate, enableTime, `${path}.value`, true);
+    if (minimum !== undefined) {
+        validateDateTimeInputValue(minimum, enableDate, enableTime, `${path}.minimum`, false);
+    }
+    if (maximum !== undefined) {
+        validateDateTimeInputValue(maximum, enableDate, enableTime, `${path}.maximum`, false);
+    }
+    const minimumSort = minimum === undefined
+        ? undefined
+        : dateTimeInputSortValue(minimum, enableDate, enableTime, `${path}.minimum`);
+    const maximumSort = maximum === undefined
+        ? undefined
+        : dateTimeInputSortValue(maximum, enableDate, enableTime, `${path}.maximum`);
+    if (minimumSort !== undefined && maximumSort !== undefined && minimumSort > maximumSort) {
+        throw new A2uiParseError(`Expected ${path}.minimum not to exceed maximum`);
+    }
+    if (value.length === 0) {
+        return;
+    }
+    const valueSort = dateTimeInputSortValue(value, enableDate, enableTime, `${path}.value`);
+    if (minimumSort !== undefined && valueSort < minimumSort) {
+        throw new A2uiParseError(`Expected ${path}.value not to be earlier than minimum`);
+    }
+    if (maximumSort !== undefined && valueSort > maximumSort) {
+        throw new A2uiParseError(`Expected ${path}.value not to be later than maximum`);
+    }
+}
+function dateTimeInputSortValue(value, enableDate, enableTime, path) {
+    if (enableDate && enableTime) {
+        return parseDateValue(value, path).getTime();
+    }
+    if (enableDate) {
+        const match = DATE_ONLY.exec(value);
+        if (match === null) {
+            throw new A2uiParseError(`Expected a yyyy-MM-dd date at ${path}`);
+        }
+        validateCalendarDate(Number(match[1]), Number(match[2]), Number(match[3]), path);
+        return Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+    }
+    return parseTimeOnly(value, path);
+}
+function parseTimeOnly(value, path) {
+    const match = TIME_ONLY.exec(value);
+    if (match === null) {
+        throw new A2uiParseError(`Expected an ISO 8601 time at ${path}`);
+    }
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    const second = Number(match[3] ?? "0");
+    if (hour > 23 || minute > 59 || second > 59) {
+        throw new A2uiParseError(`Invalid ISO 8601 time at ${path}`);
+    }
+    const fraction = match[4] ?? "";
+    const millisecond = Number(fraction.slice(0, 3).padEnd(3, "0"));
+    let result = ((hour * 60 + minute) * 60 + second) * 1_000 + millisecond;
+    if (match[5] !== undefined && match[5] !== "Z") {
+        const offsetHour = Number(match[7]);
+        const offsetMinute = Number(match[8]);
+        if (offsetHour > 23 || offsetMinute > 59) {
+            throw new A2uiParseError(`Invalid ISO 8601 time offset at ${path}`);
+        }
+        const direction = match[6] === "+" ? 1 : -1;
+        result -= direction * (offsetHour * 60 + offsetMinute) * 60_000;
+    }
+    return result;
+}
 function resolveDateFormat(call, path, context, scope) {
     const args = expectObject(call.args, `${path}.args`);
     const value = resolveDynamicValue(args.value, `${path}.args.value`, context, scope);