@jini-ai/agentic 0.4.0 → 0.4.2

package/dist/a2ui/renderer-to-agent.d.ts

@@ -1,342 +0,0 @@
-/**
- * @module renderer-to-agent
- *
- * A2UI v1.0 renderer→agent envelope — mirrors `specification/v1_0/json/renderer_to_agent.json`
- * (fetched from https://github.com/a2ui-project/a2ui, `main` branch, this session). Three message
- * kinds, each envelope carrying `version` plus **exactly one** of `action` | `functionResponse` |
- * `error` (`minProperties: 2, maxProperties: 2` in the real schema — enforced below via `.refine`,
- * since zod's object schema has no direct min/max-properties primitive).
- */
-import { z } from 'zod';
-/** `renderer_to_agent.json#/properties/action` — "Reports a user-initiated action from a component." */
-export declare const ActionMessagePayloadSchema: z.ZodObject<{
-    name: z.ZodString;
-    surfaceId: z.ZodString;
-    sourceComponentId: z.ZodString;
-    /** ISO 8601 timestamp — validated as a non-empty string, not parsed as a `Date`: the real schema only declares `format: "date-time"` (an annotation, not a structural constraint zod enforces by default). */
-    timestamp: z.ZodString;
-    context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    wantResponse: z.ZodOptional<z.ZodBoolean>;
-    actionId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    surfaceId: string;
-    context: Record<string, unknown>;
-    sourceComponentId: string;
-    timestamp: string;
-    wantResponse?: boolean | undefined;
-    actionId?: string | undefined;
-}, {
-    name: string;
-    surfaceId: string;
-    context: Record<string, unknown>;
-    sourceComponentId: string;
-    timestamp: string;
-    wantResponse?: boolean | undefined;
-    actionId?: string | undefined;
-}>;
-export type ActionMessagePayload = z.infer<typeof ActionMessagePayloadSchema>;
-/**
- * `renderer_to_agent.json#/properties/functionResponse`.
- *
- * `value` is required (`"required": ["functionCallId", "call", "value"]`), and — as with
- * `updateDataModel.value`, see that schema's own note — `z.unknown()` alone does not enforce a
- * required key in Zod 3, so a response with no `value` at all validated clean. Presence is
- * asserted on the object instead. JSON has no `undefined`: a function returning nothing must say
- * `null`, which is why `interpreter.ts` encodes a void return that way rather than omitting it.
- */
-export declare const FunctionResponsePayloadSchema: z.ZodEffects<z.ZodObject<{
-    functionCallId: z.ZodString;
-    call: z.ZodString;
-    value: z.ZodUnknown;
-}, "strip", z.ZodTypeAny, {
-    call: string;
-    functionCallId: string;
-    value?: unknown;
-}, {
-    call: string;
-    functionCallId: string;
-    value?: unknown;
-}>, {
-    call: string;
-    functionCallId: string;
-    value?: unknown;
-}, {
-    call: string;
-    functionCallId: string;
-    value?: unknown;
-}>;
-export type FunctionResponsePayload = z.infer<typeof FunctionResponsePayloadSchema>;
-/**
- * `renderer_to_agent.json#/properties/error` — two mutually-exclusive shapes: a `VALIDATION_FAILED`
- * error (always carries `surfaceId` + a JSON-Pointer `path`), or a generic error (any other `code`,
- * carrying exactly one of `surfaceId` XOR `functionCallId`).
- */
-export declare const ValidationFailedErrorSchema: z.ZodObject<{
-    code: z.ZodLiteral<"VALIDATION_FAILED">;
-    surfaceId: z.ZodString;
-    path: z.ZodString;
-    message: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    surfaceId: string;
-    code: "VALIDATION_FAILED";
-    message: string;
-    path: string;
-}, {
-    surfaceId: string;
-    code: "VALIDATION_FAILED";
-    message: string;
-    path: string;
-}>;
-export type ValidationFailedError = z.infer<typeof ValidationFailedErrorSchema>;
-export declare const GenericErrorSchema: z.ZodEffects<z.ZodObject<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">>;
-export type GenericError = z.infer<typeof GenericErrorSchema>;
-export declare const ErrorPayloadSchema: z.ZodUnion<[z.ZodObject<{
-    code: z.ZodLiteral<"VALIDATION_FAILED">;
-    surfaceId: z.ZodString;
-    path: z.ZodString;
-    message: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    surfaceId: string;
-    code: "VALIDATION_FAILED";
-    message: string;
-    path: string;
-}, {
-    surfaceId: string;
-    code: "VALIDATION_FAILED";
-    message: string;
-    path: string;
-}>, z.ZodEffects<z.ZodObject<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    code: z.ZodEffects<z.ZodString, string, string>;
-    message: z.ZodString;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    functionCallId: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">>]>;
-export type ErrorPayload = z.infer<typeof ErrorPayloadSchema>;
-export declare const ActionMessageSchema: z.ZodObject<{
-    version: z.ZodLiteral<"v1.0">;
-    action: z.ZodObject<{
-        name: z.ZodString;
-        surfaceId: z.ZodString;
-        sourceComponentId: z.ZodString;
-        /** ISO 8601 timestamp — validated as a non-empty string, not parsed as a `Date`: the real schema only declares `format: "date-time"` (an annotation, not a structural constraint zod enforces by default). */
-        timestamp: z.ZodString;
-        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        wantResponse: z.ZodOptional<z.ZodBoolean>;
-        actionId: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        surfaceId: string;
-        context: Record<string, unknown>;
-        sourceComponentId: string;
-        timestamp: string;
-        wantResponse?: boolean | undefined;
-        actionId?: string | undefined;
-    }, {
-        name: string;
-        surfaceId: string;
-        context: Record<string, unknown>;
-        sourceComponentId: string;
-        timestamp: string;
-        wantResponse?: boolean | undefined;
-        actionId?: string | undefined;
-    }>;
-}, "strict", z.ZodTypeAny, {
-    version: "v1.0";
-    action: {
-        name: string;
-        surfaceId: string;
-        context: Record<string, unknown>;
-        sourceComponentId: string;
-        timestamp: string;
-        wantResponse?: boolean | undefined;
-        actionId?: string | undefined;
-    };
-}, {
-    version: "v1.0";
-    action: {
-        name: string;
-        surfaceId: string;
-        context: Record<string, unknown>;
-        sourceComponentId: string;
-        timestamp: string;
-        wantResponse?: boolean | undefined;
-        actionId?: string | undefined;
-    };
-}>;
-export type ActionMessage = z.infer<typeof ActionMessageSchema>;
-export declare const FunctionResponseMessageSchema: z.ZodObject<{
-    version: z.ZodLiteral<"v1.0">;
-    functionResponse: z.ZodEffects<z.ZodObject<{
-        functionCallId: z.ZodString;
-        call: z.ZodString;
-        value: z.ZodUnknown;
-    }, "strip", z.ZodTypeAny, {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    }, {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    }>, {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    }, {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    }>;
-}, "strict", z.ZodTypeAny, {
-    version: "v1.0";
-    functionResponse: {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    };
-}, {
-    version: "v1.0";
-    functionResponse: {
-        call: string;
-        functionCallId: string;
-        value?: unknown;
-    };
-}>;
-export type FunctionResponseMessage = z.infer<typeof FunctionResponseMessageSchema>;
-export declare const ErrorMessageSchema: z.ZodObject<{
-    version: z.ZodLiteral<"v1.0">;
-    error: z.ZodUnion<[z.ZodObject<{
-        code: z.ZodLiteral<"VALIDATION_FAILED">;
-        surfaceId: z.ZodString;
-        path: z.ZodString;
-        message: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        surfaceId: string;
-        code: "VALIDATION_FAILED";
-        message: string;
-        path: string;
-    }, {
-        surfaceId: string;
-        code: "VALIDATION_FAILED";
-        message: string;
-        path: string;
-    }>, z.ZodEffects<z.ZodObject<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">>]>;
-}, "strict", z.ZodTypeAny, {
-    error: {
-        surfaceId: string;
-        code: "VALIDATION_FAILED";
-        message: string;
-        path: string;
-    } | z.objectOutputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">;
-    version: "v1.0";
-}, {
-    error: {
-        surfaceId: string;
-        code: "VALIDATION_FAILED";
-        message: string;
-        path: string;
-    } | z.objectInputType<{
-        code: z.ZodEffects<z.ZodString, string, string>;
-        message: z.ZodString;
-        surfaceId: z.ZodOptional<z.ZodString>;
-        functionCallId: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough">;
-    version: "v1.0";
-}>;
-export type ErrorMessage = z.infer<typeof ErrorMessageSchema>;
-export type RendererToAgentMessage = ActionMessage | FunctionResponseMessage | ErrorMessage;
-export declare function buildActionMessage(payload: ActionMessagePayload): ActionMessage;
-export declare function buildFunctionResponseMessage(payload: FunctionResponsePayload): FunctionResponseMessage;
-export declare function buildValidationFailedMessage(surfaceId: string, path: string, message: string): ErrorMessage;
-export declare function buildGenericErrorMessage(code: string, message: string, target: {
-    surfaceId: string;
-} | {
-    functionCallId: string;
-}): ErrorMessage;
-export interface RendererParseFailure {
-    readonly ok: false;
-    readonly reason: string;
-}
-export interface RendererParseSuccess {
-    readonly ok: true;
-    readonly message: RendererToAgentMessage;
-}
-/** Same "inspect the shape, validate the one matching branch" dispatcher as `parseAgentToRendererMessage` — see that function's doc for why this beats a plain `z.union`. Used by tests and by anything on the agent side of this fixture that needs to validate what the browser sent. */
-export declare function parseRendererToAgentMessage(raw: unknown): RendererParseSuccess | RendererParseFailure;
-//# sourceMappingURL=renderer-to-agent.d.ts.map

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

@@ -1,111 +0,0 @@
-/**
- * @module renderer-to-agent
- *
- * A2UI v1.0 renderer→agent envelope — mirrors `specification/v1_0/json/renderer_to_agent.json`
- * (fetched from https://github.com/a2ui-project/a2ui, `main` branch, this session). Three message
- * kinds, each envelope carrying `version` plus **exactly one** of `action` | `functionResponse` |
- * `error` (`minProperties: 2, maxProperties: 2` in the real schema — enforced below via `.refine`,
- * since zod's object schema has no direct min/max-properties primitive).
- */
-import { z } from 'zod';
-import { CallIdSchema } from './common-types.js';
-const PROTOCOL_VERSION = 'v1.0';
-/** `renderer_to_agent.json#/properties/action` — "Reports a user-initiated action from a component." */
-export const ActionMessagePayloadSchema = z.object({
-    name: z.string(),
-    surfaceId: z.string(),
-    sourceComponentId: z.string(),
-    /** ISO 8601 timestamp — validated as a non-empty string, not parsed as a `Date`: the real schema only declares `format: "date-time"` (an annotation, not a structural constraint zod enforces by default). */
-    timestamp: z.string(),
-    context: z.record(z.string(), z.unknown()),
-    wantResponse: z.boolean().optional(),
-    actionId: z.string().optional(),
-});
-/**
- * `renderer_to_agent.json#/properties/functionResponse`.
- *
- * `value` is required (`"required": ["functionCallId", "call", "value"]`), and — as with
- * `updateDataModel.value`, see that schema's own note — `z.unknown()` alone does not enforce a
- * required key in Zod 3, so a response with no `value` at all validated clean. Presence is
- * asserted on the object instead. JSON has no `undefined`: a function returning nothing must say
- * `null`, which is why `interpreter.ts` encodes a void return that way rather than omitting it.
- */
-export const FunctionResponsePayloadSchema = z
-    .object({
-    functionCallId: CallIdSchema,
-    call: z.string(),
-    value: z.unknown(),
-})
-    .refine((payload) => 'value' in payload, {
-    message: 'functionResponse requires an explicit "value" (use null for a function that returns nothing)',
-    path: ['value'],
-});
-/**
- * `renderer_to_agent.json#/properties/error` — two mutually-exclusive shapes: a `VALIDATION_FAILED`
- * error (always carries `surfaceId` + a JSON-Pointer `path`), or a generic error (any other `code`,
- * carrying exactly one of `surfaceId` XOR `functionCallId`).
- */
-export const ValidationFailedErrorSchema = z
-    .object({
-    code: z.literal('VALIDATION_FAILED'),
-    surfaceId: z.string(),
-    path: z.string(),
-    message: z.string(),
-})
-    .strict();
-export const GenericErrorSchema = z
-    .object({
-    code: z.string().refine((c) => c !== 'VALIDATION_FAILED', 'code must not be VALIDATION_FAILED here'),
-    message: z.string(),
-    surfaceId: z.string().optional(),
-    functionCallId: CallIdSchema.optional(),
-})
-    .passthrough()
-    .refine((v) => ('surfaceId' in v) !== ('functionCallId' in v), 'exactly one of surfaceId/functionCallId is required');
-export const ErrorPayloadSchema = z.union([ValidationFailedErrorSchema, GenericErrorSchema]);
-export const ActionMessageSchema = z
-    .object({ version: z.literal(PROTOCOL_VERSION), action: ActionMessagePayloadSchema })
-    .strict();
-export const FunctionResponseMessageSchema = z
-    .object({ version: z.literal(PROTOCOL_VERSION), functionResponse: FunctionResponsePayloadSchema })
-    .strict();
-export const ErrorMessageSchema = z
-    .object({ version: z.literal(PROTOCOL_VERSION), error: ErrorPayloadSchema })
-    .strict();
-export function buildActionMessage(payload) {
-    return { version: PROTOCOL_VERSION, action: payload };
-}
-export function buildFunctionResponseMessage(payload) {
-    return { version: PROTOCOL_VERSION, functionResponse: payload };
-}
-export function buildValidationFailedMessage(surfaceId, path, message) {
-    return { version: PROTOCOL_VERSION, error: { code: 'VALIDATION_FAILED', surfaceId, path, message } };
-}
-export function buildGenericErrorMessage(code, message, target) {
-    return { version: PROTOCOL_VERSION, error: { code, message, ...target } };
-}
-const MESSAGE_KEYS = ['action', 'functionResponse', 'error'];
-/** Same "inspect the shape, validate the one matching branch" dispatcher as `parseAgentToRendererMessage` — see that function's doc for why this beats a plain `z.union`. Used by tests and by anything on the agent side of this fixture that needs to validate what the browser sent. */
-export function parseRendererToAgentMessage(raw) {
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-        return { ok: false, reason: 'envelope must be a JSON object' };
-    }
-    const obj = raw;
-    if (obj.version !== PROTOCOL_VERSION) {
-        return { ok: false, reason: `envelope declares version ${JSON.stringify(obj.version)}, expected "${PROTOCOL_VERSION}"` };
-    }
-    const presentKeys = MESSAGE_KEYS.filter((key) => key in obj);
-    if (presentKeys.length !== 1) {
-        return { ok: false, reason: `expected exactly one of ${MESSAGE_KEYS.join(', ')}, found ${presentKeys.length}` };
-    }
-    const key = presentKeys[0];
-    const schema = key === 'action' ? ActionMessageSchema : key === 'functionResponse' ? FunctionResponseMessageSchema : ErrorMessageSchema;
-    const result = schema.safeParse(obj);
-    if (!result.success) {
-        // Same zod guarantee as `parseAgentToRendererMessage` relies on: `success: false` implies a
-        // non-empty `issues` array — see that function's comment for why this is asserted, not branched.
-        return { ok: false, reason: result.error.issues[0].message };
-    }
-    return { ok: true, message: result.data };
-}
-//# sourceMappingURL=renderer-to-agent.js.map

package/dist/a2ui/resolve.d.ts

@@ -1,28 +0,0 @@
-import type { Catalog } from './catalog.js';
-export type ResolveSide = 'renderer' | 'agent';
-/** Set while resolving one item of a `ChildList` template (`common_types.json`'s "Collection Scope"): relative (no leading `/`) `DataBinding` paths resolve under `${basePath}/${index}/...` instead of the data-model root. */
-export interface ItemScope {
-    readonly basePath: string;
-    readonly index: number;
-}
-export interface ResolveContext {
-    readonly dataModel: unknown;
-    readonly catalog: Catalog;
-    /** Which side is *evaluating* this binding — the renderer resolving a component's own props (`'renderer'`), or something acting on the agent's behalf. A2UI's spec doesn't explicitly name a case where the agent-side evaluates a `Dynamic*` binding (that's a renderer-only concept — the agent only ever sends `callFunction` for direct RPC), but `callableFromOf` is checked against this side regardless, so a future agent-side evaluator (e.g. resolving `action.event.context` bindings before dispatch — which today happens on the renderer, see `interpreter.ts`'s `buildAction`) is covered by the same boundary without a second resolver. */
-    readonly side: ResolveSide;
-    readonly itemScope?: ItemScope;
-}
-export type ResolveFailureReason = 'PATH_NOT_FOUND' | 'FUNCTION_NOT_REGISTERED' | 'FUNCTION_NOT_CALLABLE_FROM_SIDE' | 'FUNCTION_NOT_IMPLEMENTED' | 'FUNCTION_THREW' | 'INDEX_OUTSIDE_LIST_CONTEXT' | 'RELATIVE_PATH_OUTSIDE_LIST_CONTEXT';
-export interface ResolveFailure {
-    readonly ok: false;
-    readonly reason: ResolveFailureReason;
-    readonly detail: string;
-}
-export interface ResolveOk {
-    readonly ok: true;
-    readonly value: unknown;
-}
-export type ResolveResult = ResolveOk | ResolveFailure;
-/** Resolves any `Dynamic*` value (`DynamicString`/`DynamicNumber`/`DynamicBoolean`/`DynamicStringList`/`DynamicValue` all share this one shape: literal | `DataBinding` | `FunctionCall`). */
-export declare function resolveDynamicValue(value: unknown, ctx: ResolveContext): ResolveResult;
-//# sourceMappingURL=resolve.d.ts.map

package/dist/a2ui/resolve.js

@@ -1,144 +0,0 @@
-/**
- * @module resolve
- *
- * Resolves A2UI's `Dynamic*` binding types (literal | `DataBinding` | `FunctionCall`) against a
- * surface's data model. This is the piece the task brief called out as GenUI/AG-UI having no
- * equivalent of: AG-UI's `state_update` event is "some path changed, some value" with no binding
- * *resolution* step — A2UI's `Dynamic*` types are unresolved references a renderer must actively
- * walk the data model to answer.
- *
- * **Never throws.** Every failure mode (a path that doesn't resolve, a function that isn't
- * registered, a function that crosses a `callableFrom` boundary it isn't allowed to cross, a
- * registered function whose implementation throws on the arguments it was handed, `@index`
- * used outside a list-template context) returns a tagged `ResolveFailure` instead — this is the
- * direct answer to this task's adversarial question "a binding whose path doesn't resolve — does
- * it crash or degrade sanely?": it degrades sanely, always, by construction (no code path in this
- * module can throw on bad *input data*; only a genuine programming error, e.g. calling this module
- * incorrectly, would).
- */
-import { getAtPointer, joinPointer, parsePointerTokens } from './json-pointer.js';
-import { callableFromOf, isFunctionRegistered } from './catalog.js';
-/**
- * `path` must actually be a *string*, not merely present — the same check `isFunctionCall` already
- * makes on `call`, and its absence here was a live crash rather than a nicety. `FunctionCall.args`
- * accepts a plain object (`common-types.ts`'s `ArgValueSchema` record branch), so an agent could
- * send `{path: 7}` as an arg, pass wire validation, get classified as a binding here, and blow up
- * on `path.startsWith` inside `resolveBindingPath` — a throw straight out through
- * `applyAgentMessage`, which this module's own doc says cannot happen.
- */
-function isDataBinding(value) {
-    return typeof value === 'object'
-        && value !== null
-        && !Array.isArray(value)
-        && 'path' in value
-        && typeof value.path === 'string'
-        && Object.keys(value).length === 1;
-}
-function isFunctionCall(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value) && 'call' in value && typeof value.call === 'string';
-}
-function resolveBindingPath(path, ctx) {
-    // A relative path is still RFC 6901 syntax, so its `~0`/`~1` escapes must be decoded into real
-    // token text before `joinPointer` re-escapes them. Splitting the raw string on `/` instead would
-    // hand `joinPointer` already-escaped text and double-escape it, making a relative `a~1b` resolve
-    // the literal key `a~1b` while the equivalent absolute pointer correctly resolves `a/b`.
-    const absolute = path.startsWith('/')
-        ? path
-        : ctx.itemScope
-            ? joinPointer(ctx.itemScope.basePath, String(ctx.itemScope.index), ...parsePointerTokens(`/${path}`))
-            : null;
-    if (absolute === null) {
-        return { ok: false, reason: 'RELATIVE_PATH_OUTSIDE_LIST_CONTEXT', detail: `relative path "${path}" used outside a list-template item context` };
-    }
-    const result = getAtPointer(ctx.dataModel, absolute);
-    if (!result.found) {
-        return { ok: false, reason: 'PATH_NOT_FOUND', detail: `no value at "${absolute}" in the current data model` };
-    }
-    return { ok: true, value: result.value };
-}
-function resolveFunctionCall(call, ctx) {
-    if (call.call === '@index') {
-        if (!ctx.itemScope) {
-            return { ok: false, reason: 'INDEX_OUTSIDE_LIST_CONTEXT', detail: '@index used outside a list-template item context' };
-        }
-        const offsetArg = call.args?.offset;
-        const offsetResult = offsetArg === undefined ? { ok: true, value: 0 } : resolveDynamicValue(offsetArg, ctx);
-        if (!offsetResult.ok)
-            return offsetResult;
-        const offset = typeof offsetResult.value === 'number' ? offsetResult.value : 0;
-        return { ok: true, value: ctx.itemScope.index + offset };
-    }
-    if (!isFunctionRegistered(ctx.catalog, call.call)) {
-        return { ok: false, reason: 'FUNCTION_NOT_REGISTERED', detail: `function "${call.call}" is not registered in catalog "${ctx.catalog.catalogId}"` };
-    }
-    const callableFrom = callableFromOf(ctx.catalog, call.call);
-    const allowed = callableFrom === 'rendererOrAgent' || (callableFrom === 'rendererOnly' && ctx.side === 'renderer') || (callableFrom === 'agentOnly' && ctx.side === 'agent');
-    if (!allowed) {
-        return {
-            ok: false,
-            reason: 'FUNCTION_NOT_CALLABLE_FROM_SIDE',
-            detail: `function "${call.call}" has callableFrom="${callableFrom}", not callable from the "${ctx.side}" side`,
-        };
-    }
-    const spec = ctx.catalog.functions.get(call.call);
-    if (!spec?.impl) {
-        return { ok: false, reason: 'FUNCTION_NOT_IMPLEMENTED', detail: `function "${call.call}" is registered but this renderer has no implementation for it` };
-    }
-    const resolvedArgs = {};
-    for (const [key, argValue] of Object.entries(call.args ?? {})) {
-        const argResult = resolveArgValue(argValue, ctx);
-        if (!argResult.ok)
-            return argResult;
-        resolvedArgs[key] = argResult.value;
-    }
-    // `impl` is host-supplied code handed agent-supplied arguments, and this module validates
-    // neither against the other (the catalog's per-function arg schemas are not implemented — see
-    // `catalog.ts`'s module doc). An entirely ordinary implementation therefore throws the moment an
-    // agent sends the wrong shape (`args.name.toUpperCase()` on a number), and that throw used to
-    // travel out through `applyAgentMessage` into the host's render, where nothing catches it. It is
-    // a resolution failure like any other: reported, not propagated.
-    try {
-        return { ok: true, value: spec.impl(resolvedArgs) };
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        return { ok: false, reason: 'FUNCTION_THREW', detail: `function "${call.call}" threw while evaluating: ${detail}` };
-    }
-}
-/**
- * Resolves one `FunctionCall` arg value, recursing into arrays element-by-element. Real
- * basic-catalog functions commonly type an arg as an *array* of `Dynamic*` values (e.g. `and`/`or`'s
- * `values: DynamicBoolean[]`, confirmed against `specification/v1_0/catalogs/basic/catalog.json`'s
- * own function definitions and the spec repo's `button_checks.json` conformance fixture, both
- * fetched this session) — `common_types.json`'s generic `DynamicValue` schema's own `array` branch
- * has no `items` sub-schema (it does not itself promise recursive binding resolution), so this
- * per-element recursion is a deliberate generalization by this port, not a literal requirement of
- * that one generic type — done because without it, an array-of-`DynamicBoolean` arg's own nested
- * `DataBinding`/`FunctionCall` entries would pass through unresolved (as raw, non-boolean objects)
- * to a function's `impl`, silently producing wrong results instead of a clean failure or a correct
- * answer. `resolveDynamicValue` itself is left alone (a literal-array `DynamicValue` at the top
- * level — e.g. a `DynamicStringList`'s literal-array branch — still passes through as-is, matching
- * the generic type's own contract); only this arg-resolution path recurses.
- */
-function resolveArgValue(argValue, ctx) {
-    if (Array.isArray(argValue)) {
-        const resolvedItems = [];
-        for (const item of argValue) {
-            const itemResult = resolveArgValue(item, ctx);
-            if (!itemResult.ok)
-                return itemResult;
-            resolvedItems.push(itemResult.value);
-        }
-        return { ok: true, value: resolvedItems };
-    }
-    return resolveDynamicValue(argValue, ctx);
-}
-/** Resolves any `Dynamic*` value (`DynamicString`/`DynamicNumber`/`DynamicBoolean`/`DynamicStringList`/`DynamicValue` all share this one shape: literal | `DataBinding` | `FunctionCall`). */
-export function resolveDynamicValue(value, ctx) {
-    if (isDataBinding(value))
-        return resolveBindingPath(value.path, ctx);
-    if (isFunctionCall(value))
-        return resolveFunctionCall(value, ctx);
-    return { ok: true, value };
-}
-//# sourceMappingURL=resolve.js.map