@jini-ai/agentic 0.3.7 → 0.4.1

package/dist/core/a2ui/interpreter.js

@@ -46,12 +46,7 @@ import { buildActionMessage, buildFunctionResponseMessage, buildGenericErrorMess
 import { setAtPointer } from './json-pointer.js';
 import { isComponentAllowed } from './catalog.js';
 import { resolveDynamicValue } from './resolve.js';
-import { isLocalFunctionAction, } from './common-types.js';
-let actionIdCounter = 0;
-function nextActionId() {
-    actionIdCounter += 1;
-    return `a2ui-action-${actionIdCounter}-${Date.now().toString(36)}`;
-}
+import {} from './common-types.js';
 /**
  * Best-effort `surfaceId` extraction from a raw envelope's message-type-keyed body, without
  * assuming the envelope is well-formed. Used only to attribute a parse failure to a surface when
@@ -77,7 +72,7 @@ function bestEffortSurfaceId(raw, key) {
  * Exported and pure — it only reads `parsed`/`raw`, so the surfaceId-attribution rule can be
  * tested directly, without a live interpreter instance.
  */
-export function buildParseFailureResult(parsed, raw) {
+export function buildParseFailureResult({ parsed, raw }, _optional = {}) {
     if (parsed.code === 'MISSING_VERSION'
         || parsed.code === 'UNSUPPORTED_VERSION'
         || parsed.code === 'NO_MESSAGE_KEY'
@@ -103,7 +98,7 @@ export function buildParseFailureResult(parsed, raw) {
         // (`bestEffortSurfaceId` requires that) — so this specific combination (object-shaped raw,
         // yet no `path`) cannot occur. Asserted, not defensively branched, per this package's
         // testing discipline (see the zod-issues-array comments elsewhere in this file).
-        return { rendererMessages: [buildValidationFailedMessage(surfaceId, parsed.path, parsed.message)] };
+        return { rendererMessages: [buildValidationFailedMessage({ surfaceId, path: parsed.path, message: parsed.message })] };
     }
     return { rendererMessages: [], unattributedViolation: parsed.message };
 }
@@ -116,23 +111,23 @@ export function buildParseFailureResult(parsed, raw) {
  * data model, and a resolution failure becomes a typed refusal rather than a thrown error" can be
  * tested without a live interpreter instance.
  */
-export function runLocalFunctionAction(dataModel, catalog, action) {
-    const result = resolveDynamicValue(action.functionCall, { dataModel, catalog, side: 'renderer' });
+export function runLocalFunctionAction({ dataModel, catalog, action }, _optional = {}) {
+    const result = resolveDynamicValue({ value: action.functionCall, ctx: { dataModel, catalog, side: 'renderer' } });
     return result.ok ? { ok: true, kind: 'local', result: result.value } : { ok: false, reason: result.detail };
 }
-export function createA2uiInterpreter(catalog) {
+export function createA2uiInterpreter({ catalog, clock, ids }, _optional = {}) {
     const surfaces = new Map();
     const listeners = new Set();
     function notify() {
         for (const listener of listeners)
-            listener();
+            listener({});
     }
     function applyComponentsList(surface, wireComponents) {
         const errors = [];
         wireComponents.forEach((wireComponent, index) => {
             const { id, component: type, ...rest } = wireComponent;
-            if (!isComponentAllowed(catalog, type)) {
-                errors.push(buildValidationFailedMessage(surface.surfaceId, `/components/${index}/component`, `Component type "${type}" is not in catalog "${catalog.catalogId}" — refused, not rendered.`));
+            if (!isComponentAllowed({ catalog, componentType: type })) {
+                errors.push(buildValidationFailedMessage({ surfaceId: surface.surfaceId, path: `/components/${index}/component`, message: `Component type "${type}" is not in catalog "${catalog.catalogId}" — refused, not rendered.` }));
                 return;
             }
             const spec = catalog.components.get(type);
@@ -145,7 +140,7 @@ export function createA2uiInterpreter(catalog) {
                 // instead, so it has to be spliced back in here or the only place a human sees this (this
                 // string, not the sibling `path` pointer on the built message) never says which prop.
                 const field = issue.path.length > 0 ? issue.path.join('.') : '(root)';
-                errors.push(buildValidationFailedMessage(surface.surfaceId, `/components/${index}/${issue.path.join('/')}`, `Component "${id}" (${type}) failed catalog validation: ${field}: ${issue.message}`));
+                errors.push(buildValidationFailedMessage({ surfaceId: surface.surfaceId, path: `/components/${index}/${issue.path.join('/')}`, message: `Component "${id}" (${type}) failed catalog validation: ${field}: ${issue.message}` }));
                 return;
             }
             surface.components.set(id, { id, component: type, props: parsed.data });
@@ -155,10 +150,10 @@ export function createA2uiInterpreter(catalog) {
     function handleCreateSurface(message) {
         const { surfaceId, catalogId, components, dataModel } = message.createSurface;
         if (catalogId !== catalog.catalogId) {
-            return [buildValidationFailedMessage(surfaceId, '/createSurface/catalogId', `Unknown catalogId "${catalogId}" — this renderer only has "${catalog.catalogId}" loaded.`)];
+            return [buildValidationFailedMessage({ surfaceId, path: '/createSurface/catalogId', message: `Unknown catalogId "${catalogId}" — this renderer only has "${catalog.catalogId}" loaded.` })];
         }
         if (surfaces.has(surfaceId)) {
-            return [buildValidationFailedMessage(surfaceId, '/createSurface/surfaceId', `Surface "${surfaceId}" already exists — delete it before recreating (per spec).`)];
+            return [buildValidationFailedMessage({ surfaceId, path: '/createSurface/surfaceId', message: `Surface "${surfaceId}" already exists — delete it before recreating (per spec).` })];
         }
         const surface = {
             surfaceId,
@@ -175,7 +170,7 @@ export function createA2uiInterpreter(catalog) {
         const { surfaceId, components } = message.updateComponents;
         const surface = surfaces.get(surfaceId);
         if (!surface) {
-            return [buildValidationFailedMessage(surfaceId, '/updateComponents/surfaceId', `Unknown surfaceId "${surfaceId}" — createSurface must be sent first.`)];
+            return [buildValidationFailedMessage({ surfaceId, path: '/updateComponents/surfaceId', message: `Unknown surfaceId "${surfaceId}" — createSurface must be sent first.` })];
         }
         return applyComponentsList(surface, components);
     }
@@ -183,15 +178,15 @@ export function createA2uiInterpreter(catalog) {
         const { surfaceId, path, value } = message.updateDataModel;
         const surface = surfaces.get(surfaceId);
         if (!surface) {
-            return [buildValidationFailedMessage(surfaceId, '/updateDataModel/surfaceId', `Unknown surfaceId "${surfaceId}" — createSurface must be sent first.`)];
+            return [buildValidationFailedMessage({ surfaceId, path: '/updateDataModel/surfaceId', message: `Unknown surfaceId "${surfaceId}" — createSurface must be sent first.` })];
         }
-        surface.dataModel = setAtPointer(surface.dataModel, path ?? '/', value);
+        surface.dataModel = setAtPointer({ doc: surface.dataModel, pointer: path ?? '/', value });
         return [];
     }
     function handleDeleteSurface(message) {
         const { surfaceId } = message.deleteSurface;
         if (!surfaces.has(surfaceId)) {
-            return [buildValidationFailedMessage(surfaceId, '/deleteSurface/surfaceId', `Unknown surfaceId "${surfaceId}" — nothing to delete.`)];
+            return [buildValidationFailedMessage({ surfaceId, path: '/deleteSurface/surfaceId', message: `Unknown surfaceId "${surfaceId}" — nothing to delete.` })];
         }
         // Dropping the whole SurfaceState also drops its pendingActions map — any actionResponse that
         // arrives afterward for an actionId that lived here simply won't be found (handled gracefully
@@ -202,10 +197,10 @@ export function createA2uiInterpreter(catalog) {
     }
     function handleCallFunction(message) {
         const { functionCallId, callFunction, wantResponse } = message;
-        const result = resolveDynamicValue(callFunction, { dataModel: undefined, catalog, side: 'agent' });
+        const result = resolveDynamicValue({ value: callFunction, ctx: { dataModel: undefined, catalog, side: 'agent' } });
         if (!result.ok) {
             const code = result.reason === 'FUNCTION_NOT_CALLABLE_FROM_SIDE' || result.reason === 'FUNCTION_NOT_REGISTERED' ? 'INVALID_FUNCTION_CALL' : result.reason;
-            return [buildGenericErrorMessage(code, result.detail, { functionCallId })];
+            return [buildGenericErrorMessage({ code, message: result.detail, target: { functionCallId } })];
         }
         if (!wantResponse)
             return [];
@@ -213,7 +208,7 @@ export function createA2uiInterpreter(catalog) {
         // `undefined`: a `returnType: 'void'` function (the catalog has three) resolves to
         // `undefined`, and passing that straight through built a message whose `value` vanished on
         // serialization — one this package's own `parseRendererToAgentMessage` correctly refuses.
-        return [buildFunctionResponseMessage({ functionCallId, call: callFunction.call, value: result.value ?? null })];
+        return [buildFunctionResponseMessage({ payload: { functionCallId, call: callFunction.call, value: result.value ?? null } })];
     }
     function handleActionResponse(message) {
         const { actionId, actionResponse } = message;
@@ -223,7 +218,7 @@ export function createA2uiInterpreter(catalog) {
                 continue;
             surface.pendingActions.delete(actionId);
             if ('value' in actionResponse && pending.responsePath) {
-                surface.dataModel = setAtPointer(surface.dataModel, pending.responsePath, actionResponse.value);
+                surface.dataModel = setAtPointer({ doc: surface.dataModel, pointer: pending.responsePath, value: actionResponse.value });
             }
             return [];
         }
@@ -246,32 +241,32 @@ export function createA2uiInterpreter(catalog) {
             return handleCallFunction(message);
         return handleActionResponse(message);
     }
-    function applyAgentMessage(raw) {
-        const parsed = parseAgentToRendererMessage(raw);
+    function applyAgentMessage({ raw }, _optional = {}) {
+        const parsed = parseAgentToRendererMessage({ raw });
         if (!parsed.ok)
-            return buildParseFailureResult(parsed, raw);
+            return buildParseFailureResult({ parsed, raw });
         const rendererMessages = dispatchAgentMessage(parsed.message);
         notify();
         return { rendererMessages };
     }
-    function getSurface(surfaceId) {
+    function getSurface({ surfaceId }, _optional = {}) {
         const surface = surfaces.get(surfaceId);
         if (!surface)
             return undefined;
         return { surfaceId: surface.surfaceId, catalogId: surface.catalogId, components: surface.components, dataModel: surface.dataModel };
     }
-    function getRoot(surfaceId) {
+    function getRoot({ surfaceId }, _optional = {}) {
         return surfaces.get(surfaceId)?.components.get('root');
     }
-    function resolve(surfaceId, value, itemBasePath, itemIndex) {
+    function resolve({ surfaceId, value }, { itemBasePath, itemIndex } = {}) {
         const surface = surfaces.get(surfaceId);
         const itemScope = itemBasePath !== undefined && itemIndex !== undefined ? { basePath: itemBasePath, index: itemIndex } : undefined;
-        return resolveDynamicValue(value, { dataModel: surface?.dataModel, catalog, side: 'renderer', ...(itemScope ? { itemScope } : {}) });
+        return resolveDynamicValue({ value, ctx: { dataModel: surface?.dataModel, catalog, side: 'renderer' } }, { itemScope });
     }
     function resolveActionContext(context, surfaceId) {
         const resolved = {};
         for (const [key, value] of Object.entries(context ?? {})) {
-            const result = resolve(surfaceId, value);
+            const result = resolve({ surfaceId, value });
             resolved[key] = result.ok ? result.value : null;
         }
         return resolved;
@@ -292,7 +287,7 @@ export function createA2uiInterpreter(catalog) {
     /** Builds the `action` wire envelope for an agent-event action, registering a pending response if `wantResponse` was set. */
     function buildAgentEventAction(surface, surfaceId, componentId, event, now) {
         const { name, context, wantResponse, responsePath } = event;
-        const actionId = wantResponse ? nextActionId() : undefined;
+        const actionId = wantResponse ? ids.next({}) : undefined;
         if (actionId) {
             surface.pendingActions.set(actionId, { name, sourceComponentId: componentId, responsePath });
         }
@@ -300,20 +295,20 @@ export function createA2uiInterpreter(catalog) {
             name,
             surfaceId,
             sourceComponentId: componentId,
-            timestamp: new Date(now()).toISOString(),
+            timestamp: new Date(now({})).toISOString(),
             context: resolveActionContext(context, surfaceId),
             ...(wantResponse !== undefined ? { wantResponse } : {}),
             ...(actionId !== undefined ? { actionId } : {}),
         };
-        return { ok: true, kind: 'agent', message: buildActionMessage(payload) };
+        return { ok: true, kind: 'agent', message: buildActionMessage({ payload }) };
     }
-    function buildAction(surfaceId, componentId, now = Date.now) {
+    function buildAction({ surfaceId, componentId }, { now } = {}) {
         const target = resolveActionTarget(surfaceId, componentId);
         if (!target.ok)
             return target;
         const { surface, action } = target;
-        if (isLocalFunctionAction(action)) {
-            return runLocalFunctionAction(surface.dataModel, catalog, action);
+        if ('functionCall' in action) {
+            return runLocalFunctionAction({ dataModel: surface.dataModel, catalog, action });
         }
         // `ActionSchema` (validated when this component's props were ingested — see
         // `applyComponentsList`) is a closed 2-branch union: `{event}` | `{functionCall}`. Having
@@ -322,18 +317,18 @@ export function createA2uiInterpreter(catalog) {
         // malformed third shape could never have made it into `component.props.action` in the first
         // place. (Not defensively branched-and-left-untested, per this package's own testing
         // discipline — see the zod-issues-array comments above for the same principle.)
-        return buildAgentEventAction(surface, surfaceId, componentId, action.event, now);
+        return buildAgentEventAction(surface, surfaceId, componentId, action.event, now ?? (() => clock.nowMs()));
     }
     return {
         applyAgentMessage,
         getSurface,
-        listSurfaceIds: () => [...surfaces.keys()],
+        listSurfaceIds: (_required) => [...surfaces.keys()],
         getRoot,
         buildAction,
         resolve,
-        subscribe: (listener) => {
+        subscribe: ({ listener }) => {
             listeners.add(listener);
-            return () => listeners.delete(listener);
+            return (_required) => { listeners.delete(listener); };
         },
     };
 }

package/dist/core/a2ui/json-pointer.d.ts

@@ -22,10 +22,18 @@ export interface PointerGetResult {
     readonly value: unknown;
 }
 /** Splits a non-root pointer into its unescaped reference tokens. `pointer` must start with `/`. */
-export declare function parsePointerTokens(pointer: string): string[];
-export declare function joinPointer(base: string, ...tokens: string[]): string;
+export declare function parsePointerTokens({ pointer }: {
+    pointer: string;
+}, _optional?: Record<string, never>): string[];
+export declare function joinPointer({ base, tokens }: {
+    base: string;
+    tokens: string[];
+}, _optional?: Record<string, never>): string;
 /** Reads the value at `pointer` in `doc`. Never throws on a non-resolving path — `found: false` degrades sanely, matching this port's "a bad binding must not crash the renderer" adversarial requirement (see `resolve.ts`). */
-export declare function getAtPointer(doc: unknown, pointer: string): PointerGetResult;
+export declare function getAtPointer({ doc, pointer }: {
+    doc: unknown;
+    pointer: string;
+}, _optional?: Record<string, never>): PointerGetResult;
 /**
  * Writes `value` at `pointer` in `doc`, returning a **new** document (the original is never
  * mutated — every intermediate object on the path is shallow-copied). Missing intermediate
@@ -44,5 +52,9 @@ export declare function getAtPointer(doc: unknown, pointer: string): PointerGetR
  * for the same class of bug — this is the specific root cause it would otherwise have had to
  * catch).
  */
-export declare function setAtPointer(doc: unknown, pointer: string, value: unknown): unknown;
+export declare function setAtPointer({ doc, pointer, value }: {
+    doc: unknown;
+    pointer: string;
+    value: unknown;
+}, _optional?: Record<string, never>): unknown;
 //# sourceMappingURL=json-pointer.d.ts.map

package/dist/core/a2ui/json-pointer.js

@@ -55,7 +55,7 @@ function escapeToken(token) {
     return token.replaceAll('~', '~0').replaceAll('/', '~1');
 }
 /** Splits a non-root pointer into its unescaped reference tokens. `pointer` must start with `/`. */
-export function parsePointerTokens(pointer) {
+export function parsePointerTokens({ pointer }, _optional = {}) {
     if (pointer === '')
         return [];
     if (!pointer.startsWith('/')) {
@@ -63,17 +63,17 @@ export function parsePointerTokens(pointer) {
     }
     return pointer.slice(1).split('/').map(unescapeToken);
 }
-export function joinPointer(base, ...tokens) {
-    const baseTokens = base === '' || base === '/' ? [] : parsePointerTokens(base);
+export function joinPointer({ base, tokens }, _optional = {}) {
+    const baseTokens = base === '' || base === '/' ? [] : parsePointerTokens({ pointer: base });
     return '/' + [...baseTokens, ...tokens].map(escapeToken).join('/');
 }
 /** Reads the value at `pointer` in `doc`. Never throws on a non-resolving path — `found: false` degrades sanely, matching this port's "a bad binding must not crash the renderer" adversarial requirement (see `resolve.ts`). */
-export function getAtPointer(doc, pointer) {
+export function getAtPointer({ doc, pointer }, _optional = {}) {
     if (isRootPointer(pointer))
         return { found: true, value: doc };
     let tokens;
     try {
-        tokens = parsePointerTokens(pointer);
+        tokens = parsePointerTokens({ pointer });
     }
     catch {
         return { found: false, value: undefined };
@@ -118,12 +118,12 @@ export function getAtPointer(doc, pointer) {
  * for the same class of bug — this is the specific root cause it would otherwise have had to
  * catch).
  */
-export function setAtPointer(doc, pointer, value) {
+export function setAtPointer({ doc, pointer, value }, _optional = {}) {
     if (isRootPointer(pointer))
         return value;
     let tokens;
     try {
-        tokens = parsePointerTokens(pointer);
+        tokens = parsePointerTokens({ pointer });
     }
     catch {
         return doc;

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

@@ -321,14 +321,26 @@ export declare const ErrorMessageSchema: z.ZodObject<{
 }>;
 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: {
+export declare function buildActionMessage({ payload }: {
+    payload: ActionMessagePayload;
+}, _optional?: Record<string, never>): ActionMessage;
+export declare function buildFunctionResponseMessage({ payload }: {
+    payload: FunctionResponsePayload;
+}, _optional?: Record<string, never>): FunctionResponseMessage;
+export declare function buildValidationFailedMessage({ surfaceId, path, message }: {
     surfaceId: string;
-} | {
-    functionCallId: string;
-}): ErrorMessage;
+    path: string;
+    message: string;
+}, _optional?: Record<string, never>): ErrorMessage;
+export declare function buildGenericErrorMessage({ code, message, target }: {
+    code: string;
+    message: string;
+    target: {
+        surfaceId: string;
+    } | {
+        functionCallId: string;
+    };
+}, _optional?: Record<string, never>): ErrorMessage;
 export interface RendererParseFailure {
     readonly ok: false;
     readonly reason: string;
@@ -338,5 +350,7 @@ export interface RendererParseSuccess {
     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;
+export declare function parseRendererToAgentMessage({ raw }: {
+    raw: unknown;
+}, _optional?: Record<string, never>): RendererParseSuccess | RendererParseFailure;
 //# sourceMappingURL=renderer-to-agent.d.ts.map

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

@@ -72,21 +72,21 @@ export const FunctionResponseMessageSchema = z
 export const ErrorMessageSchema = z
     .object({ version: z.literal(PROTOCOL_VERSION), error: ErrorPayloadSchema })
     .strict();
-export function buildActionMessage(payload) {
+export function buildActionMessage({ payload }, _optional = {}) {
     return { version: PROTOCOL_VERSION, action: payload };
 }
-export function buildFunctionResponseMessage(payload) {
+export function buildFunctionResponseMessage({ payload }, _optional = {}) {
     return { version: PROTOCOL_VERSION, functionResponse: payload };
 }
-export function buildValidationFailedMessage(surfaceId, path, message) {
+export function buildValidationFailedMessage({ surfaceId, path, message }, _optional = {}) {
     return { version: PROTOCOL_VERSION, error: { code: 'VALIDATION_FAILED', surfaceId, path, message } };
 }
-export function buildGenericErrorMessage(code, message, target) {
+export function buildGenericErrorMessage({ code, message, target }, _optional = {}) {
     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) {
+export function parseRendererToAgentMessage({ raw }, _optional = {}) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         return { ok: false, reason: 'envelope must be a JSON object' };
     }

package/dist/core/a2ui/resolve.d.ts

@@ -10,7 +10,7 @@ export interface ResolveContext {
     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;
+    readonly itemScope?: ItemScope | undefined;
 }
 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 {
@@ -24,5 +24,10 @@ export interface ResolveOk {
 }
 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;
+export declare function resolveDynamicValue({ value, ctx }: {
+    value: unknown;
+    ctx: Omit<ResolveContext, 'itemScope'>;
+}, { itemScope }?: {
+    itemScope?: ItemScope | undefined;
+}): ResolveResult;
 //# sourceMappingURL=resolve.d.ts.map

package/dist/core/a2ui/resolve.js

@@ -45,12 +45,12 @@ function resolveBindingPath(path, ctx) {
     const absolute = path.startsWith('/')
         ? path
         : ctx.itemScope
-            ? joinPointer(ctx.itemScope.basePath, String(ctx.itemScope.index), ...parsePointerTokens(`/${path}`))
+            ? joinPointer({ base: ctx.itemScope.basePath, tokens: [String(ctx.itemScope.index), ...parsePointerTokens({ pointer: `/${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);
+    const result = getAtPointer({ doc: ctx.dataModel, pointer: absolute });
     if (!result.found) {
         return { ok: false, reason: 'PATH_NOT_FOUND', detail: `no value at "${absolute}" in the current data model` };
     }
@@ -62,16 +62,16 @@ function resolveFunctionCall(call, ctx) {
             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);
+        const offsetResult = offsetArg === undefined ? { ok: true, value: 0 } : resolveDynamicValue({ value: offsetArg, ctx: ctx }, { itemScope: ctx.itemScope });
         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)) {
+    if (!isFunctionRegistered({ catalog: ctx.catalog, functionName: 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 callableFrom = callableFromOf({ catalog: ctx.catalog, functionName: call.call });
     const allowed = callableFrom === 'rendererOrAgent' || (callableFrom === 'rendererOnly' && ctx.side === 'renderer') || (callableFrom === 'agentOnly' && ctx.side === 'agent');
     if (!allowed) {
         return {
@@ -131,14 +131,15 @@ function resolveArgValue(argValue, ctx) {
         }
         return { ok: true, value: resolvedItems };
     }
-    return resolveDynamicValue(argValue, ctx);
+    return resolveDynamicValue({ value: argValue, ctx: ctx }, { itemScope: ctx.itemScope });
 }
 /** Resolves any `Dynamic*` value (`DynamicString`/`DynamicNumber`/`DynamicBoolean`/`DynamicStringList`/`DynamicValue` all share this one shape: literal | `DataBinding` | `FunctionCall`). */
-export function resolveDynamicValue(value, ctx) {
+export function resolveDynamicValue({ value, ctx }, { itemScope } = {}) {
+    const context = { ...ctx, ...(itemScope === undefined ? {} : { itemScope }) };
     if (isDataBinding(value))
-        return resolveBindingPath(value.path, ctx);
+        return resolveBindingPath(value.path, context);
     if (isFunctionCall(value))
-        return resolveFunctionCall(value, ctx);
+        return resolveFunctionCall(value, context);
     return { ok: true, value };
 }
 //# sourceMappingURL=resolve.js.map

package/dist/core/a2ui/tree.d.ts

@@ -10,7 +10,7 @@
  * Scope: only the *static array* form of `ChildList` (`common_types.json#/$defs/ChildList`'s
  * first `oneOf` branch) is walked here. The *template* form (`{componentId, path}`, generating N
  * children from a data-model list) is accepted by the wire schema (`ChildListSchema`) but not
- * expanded by this port — see `../source-map.md` for why (a distinct, substantially larger
+ * expanded by this port — see `../archived provenance ledger` for why (a distinct, substantially larger
  * rendering feature: item-scoped relative-path resolution, `@index`, per-item React keys for one
  * shared component definition rendered N times). A `getChildIds` callback that always returns
  * `[]` for a template-shaped `children` value is a safe, honest way to consume this module without
@@ -62,5 +62,11 @@ export declare const MAX_RENDER_NODES = 50000;
  * which is both what makes the iterative form equivalent (an ancestor set IS the path from the
  * root) and what removes the old walk's quadratic set-copying cost.
  */
-export declare function flattenRenderTree<C extends ComponentLike>(components: ReadonlyMap<string, C>, rootId: string, getChildIds: (component: C) => readonly string[]): RenderNode[];
+export declare function flattenRenderTree<C extends ComponentLike>({ components, rootId, getChildIds }: {
+    components: ReadonlyMap<string, C>;
+    rootId: string;
+    getChildIds: (required: {
+        component: C;
+    }) => readonly string[];
+}, _optional?: Record<string, never>): RenderNode[];
 //# sourceMappingURL=tree.d.ts.map

package/dist/core/a2ui/tree.js

@@ -35,7 +35,7 @@ export const MAX_RENDER_NODES = 50_000;
  * which is both what makes the iterative form equivalent (an ancestor set IS the path from the
  * root) and what removes the old walk's quadratic set-copying cost.
  */
-export function flattenRenderTree(components, rootId, getChildIds) {
+export function flattenRenderTree({ components, rootId, getChildIds }, _optional = {}) {
     const output = [];
     /** Ids on the path from the root to the node being visited — the recursive walk's `ancestors`. */
     const ancestors = new Set();
@@ -64,7 +64,7 @@ export function flattenRenderTree(components, rootId, getChildIds) {
         ancestors.add(id);
         stack.push({ leave: id });
         // Pushed in reverse so the first child is popped first, preserving pre-order.
-        const childIds = getChildIds(component);
+        const childIds = getChildIds({ component });
         for (let index = childIds.length - 1; index >= 0; index -= 1) {
             stack.push({ id: childIds[index], depth: depth + 1 });
         }

package/dist/core/ag-ui.d.ts

@@ -52,14 +52,18 @@ export interface AgUiToolResultMessage {
  * @param capability - The capability to expose.
  * @returns The tool entry for `RunAgentInput.tools`.
  */
-export declare function toAgUiTool(capability: CapabilityDef): AgUiTool;
+export declare function toAgUiTool({ capability }: {
+    capability: CapabilityDef;
+}, _optional?: Record<string, never>): AgUiTool;
 /**
  * Projects a whole manifest.
  *
  * @param capabilities - Capabilities to expose, already filtered by whatever policy applies.
  * @returns One tool per capability, in manifest order.
  */
-export declare function toAgUiTools(capabilities: readonly CapabilityDef[]): readonly AgUiTool[];
+export declare function toAgUiTools({ capabilities }: {
+    capabilities: readonly CapabilityDef[];
+}, _optional?: Record<string, never>): readonly AgUiTool[];
 /**
  * Builds the result message for a completed frontend tool call.
  *
@@ -72,11 +76,15 @@ export declare function toAgUiTools(capabilities: readonly CapabilityDef[]): rea
  * @param outcome - What happened.
  * @returns The `role: "tool"` message to send back.
  */
-export declare function createAgUiToolResult(messageId: string, toolCallId: string, outcome: {
-    ok: true;
-    output: unknown;
-} | {
-    ok: false;
-    error: string;
-}): AgUiToolResultMessage;
+export declare function createAgUiToolResult({ messageId, toolCallId, outcome }: {
+    messageId: string;
+    toolCallId: string;
+    outcome: {
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    };
+}, _optional?: Record<string, never>): AgUiToolResultMessage;
 //# sourceMappingURL=ag-ui.d.ts.map

package/dist/core/ag-ui.js

@@ -19,7 +19,7 @@ export const AG_UI_TOOL_CALL_EVENTS = {
  * @param capability - The capability to expose.
  * @returns The tool entry for `RunAgentInput.tools`.
  */
-export function toAgUiTool(capability) {
+export function toAgUiTool({ capability }, _optional = {}) {
     return {
         name: capability.id,
         description: capability.description,
@@ -32,8 +32,8 @@ export function toAgUiTool(capability) {
  * @param capabilities - Capabilities to expose, already filtered by whatever policy applies.
  * @returns One tool per capability, in manifest order.
  */
-export function toAgUiTools(capabilities) {
-    return capabilities.map(toAgUiTool);
+export function toAgUiTools({ capabilities }, _optional = {}) {
+    return capabilities.map(capability => toAgUiTool({ capability }));
 }
 /**
  * JSON, or a description of why there is none — always a string, which `JSON.stringify` alone is
@@ -76,7 +76,7 @@ function encodeToolContent(output) {
  * @param outcome - What happened.
  * @returns The `role: "tool"` message to send back.
  */
-export function createAgUiToolResult(messageId, toolCallId, outcome) {
+export function createAgUiToolResult({ messageId, toolCallId, outcome }, _optional = {}) {
     const content = outcome.ok
         ? typeof outcome.output === 'string' ? outcome.output : encodeToolContent(outcome.output)
         : JSON.stringify({ error: outcome.error });

package/dist/core/annotated-actions-script.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Framework-free script asset for data-toolname/data-tooldescription actions.
+ * Native tool* forms remain the browser's responsibility. No polyfill, transport,
+ * field-value reader, arbitrary selector input or cross-origin exposure is added.
+ * The host owns consent copy and its browser preference key. This string asset
+ * can be inlined into static exports without importing a DOM runtime on Node.
+ */
+export declare function createAnnotatedActionsScript({ preferenceKey, confirmationMessage, confirmationMessages }: {
+    preferenceKey?: string;
+    confirmationMessage?: string;
+    confirmationMessages?: Readonly<Record<string, string>>;
+}, _optional?: Record<string, never>): string;
+//# sourceMappingURL=annotated-actions-script.d.ts.map