@jini-ai/agentic 0.4.3 → 0.4.5

package/dist/a2ui/agent-to-renderer.js

@@ -1,191 +0,0 @@
-/**
- * @module agent-to-renderer
- *
- * A2UI v1.0 agent→renderer envelope — mirrors `specification/v1_0/json/agent_to_renderer.json`
- * (fetched from https://github.com/a2ui-project/a2ui, `main` branch, this session). Every
- * required/optional field and every `additionalProperties: false` closure below was copied
- * directly from that JSON Schema, not guessed. See `common-types.ts`'s module doc for the overall
- * scope note (wire shape only; catalog membership is a separate runtime concern).
- *
- * The six message kinds, each keyed by version + exactly one message-type key
- * (`createSurface` | `updateComponents` | `updateDataModel` | `deleteSurface` | `callFunction` +
- * `functionCallId` | `actionResponse` + `actionId`):
- * `CreateSurfaceMessage`, `UpdateComponentsMessage`, `UpdateDataModelMessage`,
- * `DeleteSurfaceMessage`, `CallFunctionMessage`, `ActionResponseMessage`.
- *
- * `parseAgentToRendererMessage` is a hand-written dispatcher, not a plain `z.union(...)`: zod's
- * union error for a 6-branch, all-`.strict()` union is an unreadable dump of all 6 branches'
- * failures at once. Real renderers need to tell an agent *specifically* "you sent no version",
- * "you sent two message-type keys", or "`updateComponents` is missing `surfaceId`" — so this
- * dispatcher inspects the envelope's own shape first (which key is present) and only then
- * validates against the one matching schema, matching what `renderer_to_agent.json`'s own error
- * schema anticipates (`VALIDATION_FAILED` with a JSON-Pointer `path` into the offending field).
- */
-import { z } from 'zod';
-import { ComponentIdSchema, FunctionCallSchema, CallIdSchema } from './common-types.js';
-const PROTOCOL_VERSION = 'v1.0';
-/**
- * A component's wire shape is only closed by its *catalog's* own per-type schema (e.g. `Text`
- * requires `text`, forbids unknown extra keys via that type's own `unevaluatedProperties: false`)
- * — a shape this module cannot know statically, since a renderer may be configured with any
- * catalog. This schema validates only what every component, in every catalog, always carries:
- * an `id` and a `component` type-name string. `catalog.ts`/`interpreter.ts` layer the closed,
- * per-type check on top at runtime (component-type whitelisting against the active catalog).
- */
-export const WireComponentSchema = z
-    .object({
-    id: ComponentIdSchema,
-    component: z.string().min(1),
-})
-    .passthrough();
-/** `agent_to_renderer.json#/$defs/ComponentsList` — "A list containing UI components for the surface." `minItems: 1`. */
-export const ComponentsListSchema = z.array(WireComponentSchema).min(1);
-export const CreateSurfaceMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    createSurface: z
-        .object({
-        surfaceId: z.string(),
-        catalogId: z.string(),
-        surfaceProperties: z.record(z.string(), z.unknown()).optional(),
-        sendDataModel: z.boolean().optional(),
-        components: ComponentsListSchema.optional(),
-        dataModel: z.record(z.string(), z.unknown()).optional(),
-    })
-        .strict(),
-})
-    .strict();
-export const UpdateComponentsMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    updateComponents: z
-        .object({
-        surfaceId: z.string(),
-        components: ComponentsListSchema,
-    })
-        .strict(),
-})
-    .strict();
-/**
- * `value` is required by the real schema (`"required": ["surfaceId", "value"]`, re-fetched and
- * checked 2026-07-29) — but declaring it `z.unknown()` did not make it so. In Zod 3 a key whose
- * schema accepts `undefined` is satisfied by the key being absent entirely, and `undefined`
- * inhabits `unknown`; `z.unknown().isOptional()` is literally `true`. So `{updateDataModel:
- * {surfaceId: "s1"}}` parsed clean, and `interpreter.ts` then wrote that missing value at the
- * default `'/'` pointer — replacing the surface's whole data model with `undefined`, silently,
- * with no error message and no way for the agent to learn it had happened.
- *
- * Presence is therefore asserted on the object rather than on the field: there is no Zod 3 schema
- * for "any value, but it has to be there," because optionality is decided by the field's *type*.
- * `'value' in body` rather than a `!== undefined` check, so every legal JSON value — `null`
- * (the spec's own delete verb), `false`, `0`, `""` — is still accepted as content.
- *
- * The same limitation leaves `value` typed `value?: unknown` on the inferred type. That is
- * unavoidable in Zod 3 for an `unknown`-typed key (`undefined extends unknown`), and is why this
- * is enforced at runtime rather than trusted to the type.
- */
-export const UpdateDataModelMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    updateDataModel: z
-        .object({
-        surfaceId: z.string(),
-        path: z.string().optional(),
-        value: z.unknown(),
-    })
-        .strict()
-        .refine((body) => 'value' in body, {
-        message: 'updateDataModel requires an explicit "value" (use null to delete the key at "path")',
-        path: ['value'],
-    }),
-})
-    .strict();
-export const DeleteSurfaceMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    deleteSurface: z.object({ surfaceId: z.string() }).strict(),
-})
-    .strict();
-export const CallFunctionMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    functionCallId: CallIdSchema,
-    wantResponse: z.boolean().optional(),
-    callFunction: FunctionCallSchema,
-})
-    .strict();
-export const ActionResponseMessageSchema = z
-    .object({
-    version: z.literal(PROTOCOL_VERSION),
-    actionId: z.string(),
-    actionResponse: z
-        .union([
-        z.object({ value: z.unknown() }).strict(),
-        z.object({ error: z.object({ code: z.string(), message: z.string() }).strict() }).strict(),
-    ])
-        .refine((v) => ('value' in v) !== ('error' in v), 'exactly one of value/error is required'),
-})
-    .strict();
-const MESSAGE_KEY_SCHEMAS = {
-    createSurface: CreateSurfaceMessageSchema,
-    updateComponents: UpdateComponentsMessageSchema,
-    updateDataModel: UpdateDataModelMessageSchema,
-    deleteSurface: DeleteSurfaceMessageSchema,
-    callFunction: CallFunctionMessageSchema,
-    actionResponse: ActionResponseMessageSchema,
-};
-/** Exported so `interpreter.ts` can look up "which of the *known* message-type keys is present" the same way this module's own dispatcher does, instead of guessing from raw object-key order (which could pick up an unrelated extra top-level key first). */
-export const AGENT_TO_RENDERER_MESSAGE_KEYS = Object.keys(MESSAGE_KEY_SCHEMAS);
-const MESSAGE_KEYS = AGENT_TO_RENDERER_MESSAGE_KEYS;
-/**
- * Validates a raw (untrusted, possibly-malformed) value as one A2UI agent→renderer envelope.
- * Never throws — every failure mode (missing `version`, an unrecognized/absent message-type key,
- * two message-type keys at once, or a structurally invalid message body) returns a tagged
- * `ParseFailure` instead, mirroring how a real renderer must degrade on the wire: reject the one
- * bad message with a specific reason, not crash the whole connection.
- */
-export function parseAgentToRendererMessage(raw) {
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-        return { ok: false, code: 'VALIDATION_FAILED', message: 'envelope must be a JSON object' };
-    }
-    const obj = raw;
-    if (!('version' in obj)) {
-        return { ok: false, code: 'MISSING_VERSION', message: 'envelope is missing the required "version" field' };
-    }
-    if (obj.version !== PROTOCOL_VERSION) {
-        return {
-            ok: false,
-            code: 'UNSUPPORTED_VERSION',
-            message: `envelope declares version ${JSON.stringify(obj.version)}, this renderer only supports "${PROTOCOL_VERSION}"`,
-        };
-    }
-    const presentKeys = MESSAGE_KEYS.filter((key) => key in obj);
-    if (presentKeys.length === 0) {
-        return {
-            ok: false,
-            code: 'NO_MESSAGE_KEY',
-            message: `envelope has "version" but none of the known message-type keys (${MESSAGE_KEYS.join(', ')})`,
-        };
-    }
-    if (presentKeys.length > 1) {
-        return {
-            ok: false,
-            code: 'AMBIGUOUS_MESSAGE',
-            message: `envelope has more than one message-type key at once: ${presentKeys.join(', ')}`,
-        };
-    }
-    const key = presentKeys[0];
-    const schema = MESSAGE_KEY_SCHEMAS[key];
-    const result = schema.safeParse(obj);
-    if (!result.success) {
-        // zod only ever returns `success: false` with a non-empty `error.issues` — there is no zod
-        // code path that produces a failed `SafeParseReturnType` with zero issues. Asserted directly
-        // (not defensively branched-and-left-untested) per this package's own testing discipline: a
-        // branch that cannot occur given an upstream guarantee gets removed, not fake-covered.
-        const firstIssue = result.error.issues[0];
-        const path = `/${firstIssue.path.join('/')}`;
-        return { ok: false, code: 'VALIDATION_FAILED', message: `${key}: ${firstIssue.message} at ${path}`, path };
-    }
-    return { ok: true, message: result.data };
-}
-//# sourceMappingURL=agent-to-renderer.js.map

package/dist/a2ui/catalog.d.ts

@@ -1,73 +0,0 @@
-/**
- * @module catalog
- *
- * A2UI's catalog is the spec's own named security boundary: "a JSON Schema that whitelists which
- * component types and functions may be used" (`specification/v1_0/json/catalog_definition.json`,
- * fetched from https://github.com/a2ui-project/a2ui this session). A component type or function
- * name absent from the active catalog — or a function invoked across a `callableFrom` boundary it
- * isn't permitted to cross — must be refused, not silently rendered or executed. This module is
- * that whitelist plus the closed per-component-type property shape for the small subset this port
- * actually renders; `interpreter.ts` is the code path that enforces it at message-processing time.
- *
- * **Scope**: `createLabCatalog()` below implements **all 18** of the real basic catalog's
- * components (`specification/v1_0/catalogs/basic/catalog.json`, 53KB, fetched from the spec repo
- * and read directly — every property name, type, enum member, default value, required-ness and
- * mixin below was copied field-for-field from it, not inferred from the component's name). It
- * implements 3 of that catalog's 14 **functions** (`and`/`or`/`not`, the only ones with
- * unambiguous, fully-specified semantics reachable from the fetched schema text alone — the
- * others, e.g. `formatString`/`formatDate`, depend on locale/formatting semantics not pinned down
- * by the schema text, and are deliberately not guessed at). The remaining 11 functions are **not
- * implemented** — see `../source-map.md` for the full gap list. `createLabCatalog()` also adds
- * three lab-only demo functions (`greetUser`/`logServerEvent`/`adminReset`, clearly not part of
- * the real basic catalog) purely to exercise all three `callableFrom` values end-to-end — the real
- * basic catalog's own 14 functions are all `rendererOnly`, which alone can't test the `agentOnly` /
- * `rendererOrAgent` boundary this spec explicitly calls out as security-relevant.
- *
- * Note that "implemented" here means **the protocol/validation layer**: a component type in this
- * catalog is accepted, closed-schema-validated and held in interpreter state. Whether any given
- * host renderer draws it is a separate concern this package has no opinion on.
- */
-import { z } from 'zod';
-export type CallableFrom = 'rendererOnly' | 'agentOnly' | 'rendererOrAgent';
-/** `catalog_definition.json#/$defs/FunctionDefinition` — the metadata half (not the JSON-Schema-validation half, which this port doesn't implement generically — see module doc). */
-export interface FunctionSpec {
-    readonly returnType: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'any' | 'void';
-    /** Defaults to `'rendererOnly'` per the real schema's own `default`, matched here explicitly rather than left implicit — every lookup site in this package treats an absent entry (function not registered at all) and an explicit `rendererOnly` entry identically, per the spec's "or if the function is not registered at all, the renderer MUST immediately reject" wording. */
-    readonly callableFrom: CallableFrom;
-    /** Pure implementation, only present for functions this port can actually evaluate. A function present in `functions` but with no `impl` is registered (so `callableFrom` checks against it are meaningful and testable) but cannot be evaluated — `resolve.ts` reports that as a distinct, non-crashing "not implemented" resolution failure rather than pretending it doesn't exist. */
-    readonly impl?: (args: Record<string, unknown>) => unknown;
-}
-/**
- * A coarse rendering hint, not a spec concept — the real catalog has no notion of "kind". It
- * groups the 18 component types by the shape a host renderer would draw them with, so a renderer
- * can fall back to something sane for a type it has no bespoke case for.
- */
-export type ComponentKind = 'text' | 'container' | 'button' | 'image' | 'icon' | 'video' | 'audio' | 'card' | 'tabs' | 'modal' | 'divider' | 'input';
-export interface ComponentSpec {
-    readonly kind: ComponentKind;
-    /**
-     * Validates everything on the wire component object except `id`/`component` (already checked
-     * generically by `WireComponentSchema`). Typed as `z.ZodTypeAny` rather than
-     * `z.ZodType<Record<string, unknown>>` deliberately — each concrete schema's *input* type is
-     * narrower than a bare record (known keys, some required), and zod's `parse`/`safeParse` are
-     * effectively contravariant in that position; callers (`interpreter.ts`) treat `.safeParse(...)`'s
-     * `data` as `Record<string, unknown>` via an explicit cast instead of fighting that variance here.
-     */
-    readonly propsSchema: z.ZodTypeAny;
-}
-export interface Catalog {
-    readonly catalogId: string;
-    readonly components: ReadonlyMap<string, ComponentSpec>;
-    readonly functions: ReadonlyMap<string, FunctionSpec>;
-}
-export declare function isComponentAllowed(catalog: Catalog, componentType: string): boolean;
-/** Mirrors the spec's own default: absent registration behaves exactly like an explicit `rendererOnly` entry. */
-export declare function callableFromOf(catalog: Catalog, functionName: string): CallableFrom;
-export declare function isFunctionRegistered(catalog: Catalog, functionName: string): boolean;
-/**
- * Builds the demo catalog this port's interpreter/fixture is validated against. A fresh object
- * each call (not a shared singleton) so tests can register their own `impl`s / mutate a copy
- * without cross-test leakage.
- */
-export declare function createLabCatalog(): Catalog;
-//# sourceMappingURL=catalog.d.ts.map

package/dist/a2ui/catalog.js

@@ -1,304 +0,0 @@
-/**
- * @module catalog
- *
- * A2UI's catalog is the spec's own named security boundary: "a JSON Schema that whitelists which
- * component types and functions may be used" (`specification/v1_0/json/catalog_definition.json`,
- * fetched from https://github.com/a2ui-project/a2ui this session). A component type or function
- * name absent from the active catalog — or a function invoked across a `callableFrom` boundary it
- * isn't permitted to cross — must be refused, not silently rendered or executed. This module is
- * that whitelist plus the closed per-component-type property shape for the small subset this port
- * actually renders; `interpreter.ts` is the code path that enforces it at message-processing time.
- *
- * **Scope**: `createLabCatalog()` below implements **all 18** of the real basic catalog's
- * components (`specification/v1_0/catalogs/basic/catalog.json`, 53KB, fetched from the spec repo
- * and read directly — every property name, type, enum member, default value, required-ness and
- * mixin below was copied field-for-field from it, not inferred from the component's name). It
- * implements 3 of that catalog's 14 **functions** (`and`/`or`/`not`, the only ones with
- * unambiguous, fully-specified semantics reachable from the fetched schema text alone — the
- * others, e.g. `formatString`/`formatDate`, depend on locale/formatting semantics not pinned down
- * by the schema text, and are deliberately not guessed at). The remaining 11 functions are **not
- * implemented** — see `../source-map.md` for the full gap list. `createLabCatalog()` also adds
- * three lab-only demo functions (`greetUser`/`logServerEvent`/`adminReset`, clearly not part of
- * the real basic catalog) purely to exercise all three `callableFrom` values end-to-end — the real
- * basic catalog's own 14 functions are all `rendererOnly`, which alone can't test the `agentOnly` /
- * `rendererOrAgent` boundary this spec explicitly calls out as security-relevant.
- *
- * Note that "implemented" here means **the protocol/validation layer**: a component type in this
- * catalog is accepted, closed-schema-validated and held in interpreter state. Whether any given
- * host renderer draws it is a separate concern this package has no opinion on.
- */
-import { z } from 'zod';
-import { AccessibilityAttributesSchema, ActionSchema, CheckRuleSchema, ChildListSchema, ChildSchema, DataBindingSchema, DynamicBooleanSchema, DynamicNumberSchema, DynamicStringListSchema, DynamicStringSchema, } from './common-types.js';
-export function isComponentAllowed(catalog, componentType) {
-    return catalog.components.has(componentType);
-}
-/** Mirrors the spec's own default: absent registration behaves exactly like an explicit `rendererOnly` entry. */
-export function callableFromOf(catalog, functionName) {
-    return catalog.functions.get(functionName)?.callableFrom ?? 'rendererOnly';
-}
-export function isFunctionRegistered(catalog, functionName) {
-    return catalog.functions.has(functionName);
-}
-// ---------------------------------------------------------------------------------------------
-// Component property schemas — ported field-for-field from the real basic catalog's own
-// component definitions (`specification/v1_0/catalogs/basic/catalog.json`).
-//
-// Every one of the real catalog's 18 components is composed the same way:
-//   `allOf: [ComponentCommon, (Checkable,) {its own properties}]` + `unevaluatedProperties: false`.
-// The two builders below reproduce that composition literally — `.strict()` is Zod's equivalent of
-// the `unevaluatedProperties: false` closure, and the shared halves are spread in rather than
-// copy-pasted 18 times.
-// ---------------------------------------------------------------------------------------------
-/**
- * `common_types.json#/$defs/ComponentCommon` minus `id` — the interpreter strips `id`/`component`
- * off the wire object before per-type validation, so `accessibility` is the only part of
- * ComponentCommon that ever reaches a props schema. All 18 components `allOf` ComponentCommon, so
- * `accessibility` is legal on every one of them.
- *
- * This was a real bug before the full-catalog pass: no props schema listed `accessibility`, and
- * every schema is `.strict()`, so a spec-valid component carrying it was refused with
- * `VALIDATION_FAILED` ("Unrecognized key(s) in object: 'accessibility'"). `AccessibilityAttributes`
- * existed as a tested wire type in `common-types.ts` but nothing actually accepted it on a
- * component.
- */
-const COMMON_PROPS = { accessibility: AccessibilityAttributesSchema.optional() };
-/**
- * `weight` is **not** part of ComponentCommon — each of the 18 components re-declares it
- * individually, with an identical type and description ("The relative weight of this component
- * within a Row or Column..."). Verified identical across all 18 before hoisting it here.
- */
-const WEIGHT_PROP = { weight: z.number().optional() };
-/**
- * `common_types.json#/$defs/Checkable` — mixed in by exactly 6 of the 18 (`Button`, `TextField`,
- * `CheckBox`, `ChoicePicker`, `Slider`, `DateTimeInput`), verified against each component's own
- * `allOf` list rather than assumed from which ones "look like" form inputs. `checks` is a real
- * `CheckRule[]`, not an unvalidated array — `specification/v1_0/test/cases/button_checks.json` and
- * `checkable_components.json` both exercise nested `and`/`or`/`not`/`required` check compositions
- * these schemas must actually accept.
- */
-const CHECKABLE_PROPS = { checks: z.array(CheckRuleSchema).optional() };
-function componentProps(own) {
-    return z.object({ ...COMMON_PROPS, ...WEIGHT_PROP, ...own }).strict();
-}
-function checkableComponentProps(own) {
-    return z.object({ ...COMMON_PROPS, ...WEIGHT_PROP, ...CHECKABLE_PROPS, ...own }).strict();
-}
-const TextPropsSchema = componentProps({
-    text: DynamicStringSchema,
-    variant: z.enum(['caption', 'body']).default('body'),
-});
-const JUSTIFY_VALUES = ['start', 'center', 'end', 'spaceBetween', 'spaceAround', 'spaceEvenly', 'stretch'];
-const ALIGN_VALUES = ['center', 'end', 'start', 'stretch'];
-const ContainerPropsSchema = componentProps({
-    children: ChildListSchema,
-    justify: z.enum(JUSTIFY_VALUES).default('start'),
-    align: z.enum(ALIGN_VALUES).default('stretch'),
-});
-const ButtonPropsSchema = checkableComponentProps({
-    child: ChildSchema,
-    variant: z.enum(['default', 'primary', 'borderless']).default('default'),
-    action: ActionSchema,
-});
-const ImagePropsSchema = componentProps({
-    url: DynamicStringSchema,
-    description: DynamicStringSchema.optional(),
-    fit: z.enum(['contain', 'cover', 'fill', 'none', 'scaleDown']).default('fill'),
-    variant: z.enum(['icon', 'avatar', 'smallFeature', 'mediumFeature', 'largeFeature', 'header']).default('mediumFeature'),
-});
-/**
- * The real `Icon.name` enum, all 59 members, generated directly from the fetched catalog JSON
- * rather than typed out by hand. Note it is **not** a `DynamicString`: the spec's `oneOf` admits a
- * literal enum member, a `{svgPath}` object, or a bare `DataBinding` — but *not* a `FunctionCall`.
- */
-const ICON_NAMES = [
-    'accountCircle', 'add', 'arrowBack', 'arrowForward', 'attachFile', 'calendarToday', 'call', 'camera',
-    'check', 'close', 'delete', 'download', 'edit', 'event', 'error', 'fastForward', 'favorite',
-    'favoriteOff', 'folder', 'help', 'home', 'info', 'locationOn', 'lock', 'lockOpen', 'mail', 'menu',
-    'moreVert', 'moreHoriz', 'notificationsOff', 'notifications', 'pause', 'payment', 'person', 'phone',
-    'photo', 'play', 'print', 'refresh', 'rewind', 'search', 'send', 'settings', 'share', 'shoppingCart',
-    'skipNext', 'skipPrevious', 'star', 'starHalf', 'starOff', 'stop', 'upload', 'visibility',
-    'visibilityOff', 'volumeDown', 'volumeMute', 'volumeOff', 'volumeUp', 'warning',
-];
-const IconPropsSchema = componentProps({
-    name: z.union([
-        z.enum(ICON_NAMES),
-        z.object({ svgPath: DynamicStringSchema }).strict(),
-        DataBindingSchema,
-    ]),
-});
-const VideoPropsSchema = componentProps({
-    url: DynamicStringSchema,
-    posterUrl: DynamicStringSchema.optional(),
-});
-const AudioPlayerPropsSchema = componentProps({
-    url: DynamicStringSchema,
-    description: DynamicStringSchema.optional(),
-});
-/** `List` is layout-shaped like Row/Column but has its own distinct property set: `direction` (not `justify`). */
-const ListPropsSchema = componentProps({
-    children: ChildListSchema,
-    direction: z.enum(['vertical', 'horizontal']).default('vertical'),
-    align: z.enum(['start', 'center', 'end', 'stretch']).default('stretch'),
-});
-const CardPropsSchema = componentProps({
-    child: ChildSchema,
-});
-const TabsPropsSchema = componentProps({
-    tabs: z
-        .array(z.object({ title: DynamicStringSchema, child: ChildSchema }).strict())
-        .min(1),
-});
-const ModalPropsSchema = componentProps({
-    trigger: ChildSchema,
-    content: ChildSchema,
-});
-const DividerPropsSchema = componentProps({
-    axis: z.enum(['horizontal', 'vertical']).default('horizontal'),
-});
-const TextFieldPropsSchema = checkableComponentProps({
-    label: DynamicStringSchema,
-    value: DynamicStringSchema.optional(),
-    placeholder: DynamicStringSchema.optional(),
-    variant: z.enum(['longText', 'number', 'shortText', 'obscured']).default('shortText'),
-});
-const CheckBoxPropsSchema = checkableComponentProps({
-    label: DynamicStringSchema,
-    value: DynamicBooleanSchema,
-});
-const ChoicePickerPropsSchema = checkableComponentProps({
-    label: DynamicStringSchema.optional(),
-    variant: z.enum(['multipleSelection', 'mutuallyExclusive']).default('mutuallyExclusive'),
-    // `options.items.value` is a plain `string`, deliberately NOT a DynamicString — the real schema
-    // calls it "the stable value associated with this option", and the array has no `minItems`, so an
-    // empty `options` array is spec-legal.
-    options: z.array(z.object({ label: DynamicStringSchema, value: z.string() }).strict()),
-    value: DynamicStringListSchema,
-    displayStyle: z.enum(['checkbox', 'chips']).default('checkbox'),
-    filterable: z.boolean().default(false),
-});
-const SliderPropsSchema = checkableComponentProps({
-    label: DynamicStringSchema.optional(),
-    // `min`/`max` are plain numbers here (only `value` is dynamic), and `max` is required while
-    // `min` has a default of 0 — an asymmetry copied from the real schema, not a transcription slip.
-    min: z.number().default(0),
-    max: z.number(),
-    value: DynamicNumberSchema,
-    steps: z.number().int().min(1).optional(),
-});
-/**
- * `DateTimeInput.min`/`max` — the one place in the 18 where the real schema is genuinely ambiguous,
- * so this is a **documented judgment call** rather than a literal port.
- *
- * The real definition is `allOf: [DynamicString, {if: {type: string}, then: {oneOf: [{format: date},
- * {format: time}, {format: date-time}]}}]`. Two readings collide:
- *
- *  - JSON Schema's `format` is an *annotation* by default — a validator only asserts it if it opts
- *    in (ajv, which the spec's own conformance runner uses, needs `ajv-formats` for this). Under
- *    that reading the constraint is advisory and any string passes.
- *  - But the author explicitly wrapped it in an `if`/`then`/`oneOf`, which is only meaningful as an
- *    *assertion*. A structural wrapper around three annotations would be dead weight otherwise.
- *
- * Decision: assert it, because a validating renderer catching a malformed agent-sent bound is the
- * entire point of this layer — but assert **ISO 8601** (what the property's own description says,
- * "in ISO 8601 format") rather than RFC 3339, which is what JSON Schema's `format: time`/`date-time`
- * formally mean. RFC 3339 *requires* a UTC offset, so a literal `"09:00"` would be refused under it
- * while being perfectly good ISO 8601 and an obvious thing for an agent to send. Rejecting that
- * seemed clearly worse than accepting a value RFC 3339 purists would call under-specified.
- *
- * So: literal strings must parse as an ISO 8601 date, time, or date-time (offset optional);
- * `DataBinding`/`FunctionCall` forms are passed through unchecked, since their value isn't known
- * until resolution time. `oneOf` is implemented as "matches at least one" — the three grammars are
- * mutually exclusive in practice, so exactly-one and at-least-one coincide.
- */
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-const ISO_TIME = /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:\d{2})?$/;
-const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:\d{2})?$/;
-const IsoDateTimeBoundSchema = DynamicStringSchema.superRefine((value, ctx) => {
-    if (typeof value !== 'string')
-        return;
-    if (ISO_DATE.test(value) || ISO_TIME.test(value) || ISO_DATE_TIME.test(value))
-        return;
-    ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `literal date/time bound ${JSON.stringify(value)} is not an ISO 8601 date, time, or date-time`,
-    });
-});
-const DateTimeInputPropsSchema = checkableComponentProps({
-    value: DynamicStringSchema,
-    enableDate: z.boolean().default(false),
-    enableTime: z.boolean().default(false),
-    min: IsoDateTimeBoundSchema.optional(),
-    max: IsoDateTimeBoundSchema.optional(),
-    label: DynamicStringSchema.optional(),
-});
-/**
- * Real basic-catalog functions this port can actually evaluate (boolean combinators — unambiguous
- * from the fetched schema alone, no formatting/locale semantics to guess at). Arg shapes copied
- * field-for-field from `specification/v1_0/catalogs/basic/catalog.json`'s own function
- * definitions, cross-checked against the spec repo's own conformance fixtures
- * (`specification/v1_0/test/cases/button_checks.json`, fetched and inspected this session) — an
- * earlier version of this port had `and`/`or` reading an arbitrary flat map of args instead of the
- * real `{values: DynamicBoolean[]}` shape (a plural, array-typed, `minItems: 2` property), caught
- * by cross-referencing that real fixture rather than trusting this file's own first read of
- * `common_types.json` alone (which only shows the generic `FunctionCall` envelope, not any one
- * function's own specific `args` shape).
- */
-function and(args) {
-    const values = Array.isArray(args.values) ? args.values : [];
-    return values.length > 0 && values.every((v) => v === true);
-}
-function or(args) {
-    const values = Array.isArray(args.values) ? args.values : [];
-    return values.some((v) => v === true);
-}
-/** `not`'s arg shape (singular `value`, not `values`) was already correct — real basic catalog: `args: {value: DynamicBoolean}`. */
-function not(args) {
-    return args.value !== true;
-}
-/**
- * Builds the demo catalog this port's interpreter/fixture is validated against. A fresh object
- * each call (not a shared singleton) so tests can register their own `impl`s / mutate a copy
- * without cross-test leakage.
- */
-export function createLabCatalog() {
-    // All 18 components of the real basic catalog, in that catalog's own declaration order.
-    const components = new Map([
-        ['Text', { kind: 'text', propsSchema: TextPropsSchema }],
-        ['Image', { kind: 'image', propsSchema: ImagePropsSchema }],
-        ['Icon', { kind: 'icon', propsSchema: IconPropsSchema }],
-        ['Video', { kind: 'video', propsSchema: VideoPropsSchema }],
-        ['AudioPlayer', { kind: 'audio', propsSchema: AudioPlayerPropsSchema }],
-        ['Row', { kind: 'container', propsSchema: ContainerPropsSchema }],
-        ['Column', { kind: 'container', propsSchema: ContainerPropsSchema }],
-        ['List', { kind: 'container', propsSchema: ListPropsSchema }],
-        ['Card', { kind: 'card', propsSchema: CardPropsSchema }],
-        ['Tabs', { kind: 'tabs', propsSchema: TabsPropsSchema }],
-        ['Modal', { kind: 'modal', propsSchema: ModalPropsSchema }],
-        ['Divider', { kind: 'divider', propsSchema: DividerPropsSchema }],
-        ['Button', { kind: 'button', propsSchema: ButtonPropsSchema }],
-        ['TextField', { kind: 'input', propsSchema: TextFieldPropsSchema }],
-        ['CheckBox', { kind: 'input', propsSchema: CheckBoxPropsSchema }],
-        ['ChoicePicker', { kind: 'input', propsSchema: ChoicePickerPropsSchema }],
-        ['Slider', { kind: 'input', propsSchema: SliderPropsSchema }],
-        ['DateTimeInput', { kind: 'input', propsSchema: DateTimeInputPropsSchema }],
-    ]);
-    const functions = new Map([
-        ['and', { returnType: 'boolean', callableFrom: 'rendererOnly', impl: and }],
-        ['or', { returnType: 'boolean', callableFrom: 'rendererOnly', impl: or }],
-        ['not', { returnType: 'boolean', callableFrom: 'rendererOnly', impl: not }],
-        // Lab-only demo functions (not part of the real basic catalog) — exist purely to exercise
-        // all three callableFrom values, see module doc.
-        [
-            'greetUser',
-            {
-                returnType: 'string',
-                callableFrom: 'rendererOrAgent',
-                impl: (args) => `Hello, ${typeof args.name === 'string' ? args.name : 'there'}!`,
-            },
-        ],
-        ['logServerEvent', { returnType: 'void', callableFrom: 'agentOnly', impl: () => undefined }],
-        ['adminReset', { returnType: 'void', callableFrom: 'rendererOnly', impl: () => undefined }],
-    ]);
-    return { catalogId: 'https://a2ui.org/specification/v1_0/catalogs/basic/catalog.json#lab-subset', components, functions };
-}
-//# sourceMappingURL=catalog.js.map