@jini-ai/agentic 0.3.6 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,94 @@
+# @jini-ai/agentic
+
+## 0.4.0 — 2026-10-02
+
+### BREAKING
+
+- Primitive ports converge into core; installation modules use concept paths and page-capability descriptions use host-neutral messages.
+- Distribution includes runtime output, release documentation and required assets only. Process records and per-job neutrality checks are no longer part of the package surface.
+
+## Unreleased — shared clocks and neutral navigation
+
+### BREAKING
+
+- Remove GenUiClockPort and A2uiClockPort; gen-ui/A2UI factories accept core Clock.nowMs(). A2UI sequence IDs and explicit per-event now callbacks retain their contracts.
+
+### Changed
+
+- Export defaultAgenticMessages with a neutral navigation description; hosts replace existing capability descriptor copy before projection.
+- Skill validation/live-registration/layout tests now live under the behavior-named install test directory. The process supplement lives outside the published package; layout rationale remains in its JSDoc.
+
+
+## Unreleased
+
+### Integration of extracted APIs
+
+- Complete `./skills/install` and `./skills/install/node` exports and Node runtime metadata. Reconcile shared layout/filesystem/archive/YAML contracts, expose layout and live-registration helpers, and provide `createSkillFetchAdapter` for explicitly supplied native fetch. This completes the previously pending subpath export work described below.
+- Include supplemental validation, explicit layout, live-registration and package-neutrality contracts from the extraction jobs, plus package-surface and native-fetch adapter integration tests. The filesystem factory is available from both Node skill entries; universal root/core exports stay independent of Node modules.
+- **BREAKING:** Public agent-control, DOM, MCP-UI, GenUI and A2UI functions, constructors and ports take required and optional argument objects. Encoder/interpreter factories require clock/ID ports; model-context detection requires a host-candidate port. Skill HTTP calls now use `fetch({ url }, requestOptions)`, and `SkillInputError` takes `{ message }` with optional `{ cause }`. Export names and wire formats remain intact. See `API.md` for migration examples; consumer rewiring and verification remain pending.
+
+- Add bounded skill installation/state, GitHub import, streaming archive ports and live registration under `skills/install`, with required host layout and dependencies. Add a separate Node filesystem adapter. Subpath exports pending coordinator edit; verification not run (owner directive).
+
+## 0.1.2
+
+### Patch Changes
+
+- Add top-level `main`/`types` fields alongside the existing `exports` map. A consumer on
+  TypeScript's classic `moduleResolution: "node"` (node10) — which ignores `package.json#exports`
+  entirely — could not resolve this package's types at all (`TS2307: Cannot find module`) even
+  after the previous exports-map fix restored `require()` at runtime; type resolution and runtime
+  resolution are separate algorithms. Verified against a real external consumer (whose
+  tsconfig uses this legacy resolution mode): adding these two fields, with its tsconfig completely
+  unchanged, made the error disappear. Also fixes absolute-path `require()` (distinct from a bare
+  specifier, which already worked) for the same reason — `main` was previously absent.
+
+  Purely additive: every modern resolver (Node's own runtime `exports` resolution, TypeScript's
+  `bundler`/`node16`/`nodenext`) prefers `exports` over `main`/`types` when both are present, so
+  this changes nothing for a consumer already on a modern resolver.
+
+- Updated dependencies
+  - @jini-ai/protocol@0.1.2
+
+## 0.1.1
+
+### Patch Changes
+
+- Add a `"default"` export condition to every published package's `exports` map — every one of
+  them lacked it, which meant `require()` failed with `ERR_PACKAGE_PATH_NOT_EXPORTED` for any
+  CommonJS consumer (found via a real external integration attempt; Node needs `require(esm)`
+  support, i.e. Node >=22.12, for this to resolve).
+
+  `@jini-ai/agent-runtime`:
+
+  - **New**: `RuntimeBuildOptions.permissionMode` (`'bypass' | 'restricted'`) lets a caller opt a
+    run OUT of the auto-approve-every-permission-prompt flag every def with one
+    (`bypassPermissions` / `--yolo` / `--dangerously-skip-permissions`) previously pushed
+    unconditionally, with no way to turn it off. Omitting it keeps today's default (bypass)
+    behavior unchanged.
+  - **New**: `ClaudeStreamEvent`, `CopilotStreamEvent`, and `QoderEvent` are now real exported
+    discriminated unions instead of `Record<string, unknown>` — a real external consumer guessed a
+    nonexistent field name (`event.text` instead of the actual `event.delta`) against the old
+    untyped sink and silently lost every streamed token with no compile or runtime error.
+  - Fixed a doc/implementation mismatch in `claude-stream.ts`: the module doc claimed `tool_result`
+    events carry `{ tool_use_id, content, is_error }`; the actual emitted shape is
+    `{ toolUseId, content, isError }`.
+
+  `@jini-ai/daemon`: `AgentExecutorRunInput.permissionMode` forwards the new
+  `RuntimeBuildOptions.permissionMode` through to `buildArgs`, so a host can actually reach the new
+  opt-out from the daemon's real run-input surface, not just from `@jini-ai/agent-runtime` in
+  isolation.
+
+  `@jini-ai/agentic`: `setAtPointer` no longer throws on a malformed (e.g. missing leading `/`)
+  `updateDataModel` path — degrades to a no-op like its sibling `getAtPointer`, matching this
+  package's own "a bad binding must not crash the renderer" contract. That path is agent-authored
+  wire data with no error boundary above it in any host, so the uncaught throw could unmount an
+  entire chat UI from ~40 bytes of malformed input.
+
+  `@jini-ai/chat-react`: a local (client-resolved) A2UI button action is no longer a silent no-op —
+  `A2uiSurfaceCard` now surfaces the resolved value. New `ExtEventErrorBoundary` confines a
+  `kind: 'ext'` event group's renderer to its own card instead of letting a render/effect-phase
+  throw from agent-controlled content unmount the whole chat root (there was no error boundary
+  anywhere in this package or its hosts before this).
+
+- Updated dependencies
+  - @jini-ai/protocol@0.1.1

package/README.md

@@ -28,8 +28,8 @@ point additionally needs a real DOM (browser or jsdom) at runtime — see Entry
 - **The generic page-capability manifest** — `PAGE_CAPABILITIES` (`page.find_elements`,
   `page.click`, and friends — every verb addresses a published `data-agent-element` handle, never
   a caller-supplied selector or script), `PageDriver`/`FindElementsFilter`, and
-  `executePageCapability(driver, capabilityId, input)` to run one.
-- **The `data-agent-*` markup convention** — `agentHandle('save', { role, label, page })` returns
+  `executePageCapability({ driver, capabilityId, input })` to run one.
+- **The `data-agent-*` markup convention** — `agentHandle({ handle: 'save' }, { role, label, page })` returns
   spreadable attribute props (pure data, works with React/Vue/Svelte/anything); plus the
   attribute-name constants, `AGENT_ELEMENT_ROLES`, `isValidElementHandle`, and
   `resolveHandleSelector` for a driver to resolve a handle back to a DOM node.
@@ -40,7 +40,7 @@ point additionally needs a real DOM (browser or jsdom) at runtime — see Entry
 - **Genuine AG-UI projection** — `toAgUiTool`/`toAgUiTools`, `createAgUiToolResult`,
   `AG_UI_TOOL_CALL_EVENTS`. Real conformance: emits AG-UI's own `parameters` field name and its
   canonical `TOOL_CALL_START`/`TOOL_CALL_ARGS`/`TOOL_CALL_END` event names.
-- **GenUI run-stream protocol** (`./gen-ui`, re-exported at root) — `createGenUiEncoder` and the
+- **GenUI run-stream protocol** (re-exported at root and `./core`) — `createGenUiEncoder` and the
   six dotted-lowercase event kinds (`GenUiEvent`: `agent.message`, `tool_call`, `state_update`,
   `ui.surface_requested`, `ui.surface_responded`, `run.lifecycle`). **Not AG-UI** — it shares zero
   event names with the real protocol above; it's a de-branded port of one product's own run-event
@@ -55,21 +55,37 @@ point additionally needs a real DOM (browser or jsdom) at runtime — see Entry
 import { PAGE_CAPABILITIES, executePageCapability, agentHandle, type PageDriver } from '@jini-ai/agentic';
 
 // A component publishes itself once, in whatever framework renders it:
-// <button {...agentHandle('save', { role: 'button', label: 'Save changes' })}>Save</button>
+// <button {...agentHandle({ handle: 'save' }, { role: 'button', label: 'Save changes' })}>Save</button>
 
 declare const driver: PageDriver; // e.g. createDomPageDriver(...) from '@jini-ai/agentic/dom'
 
-const elements = await executePageCapability(driver, 'page.find_elements', { role: 'button' });
+const elements = await executePageCapability({ driver, capabilityId: 'page.find_elements', input: { role: 'button' } });
 console.log(PAGE_CAPABILITIES.map((c) => c.id)); // every verb an outside caller may invoke
 ```
 
+All public functions and ports take a required argument object, followed by an optional settings
+object. For example, `driver.fill({ handle, text })` and
+`driver.selectOption({ handle, option }, { selected: false })`. A method with no required values
+receives `{}`, such as `driver.findElements({}, { role: 'button' })`.
+
+`createGenUiEncoder({ clock })` requires a `clock.nowMs()` port; encode with
+`encoder.encode({ event, runId }, { seq })`. `createA2uiInterpreter({ catalog, clock, ids })`
+requires `clock.nowMs()` and `ids.next({})` ports. WebMCP projection receives an execution port as
+`toWebMcpTool({ capability, execute }, options)`, calling `execute({ id, args })`.
+`getAgentModelContext({ host })` reads `host.candidates({})` in host-defined priority order and
+returns an argument-object adapter to the first installed native WebMCP surface. A browser host
+can return `[document.modelContext, navigator.modelContext]` from that port.
+
 ## Entry points
 
 | subpath | what's behind it | extra dep it pulls in |
 |---|---|---|
 | `.` | Capability vocabulary, `PAGE_CAPABILITIES`, `data-agent-*` markup helpers, WebMCP/AG-UI projections, GenUI protocol, MCP-UI wire helpers. Zero DOM, zero transport. | none beyond `@jini-ai/protocol`, `zod` |
+| `./core` | The same framework-free agent-control surface as the root. | none |
 | `./dom` | `createDomPageDriver`/`currentAgentPage` — the one `PageDriver` that reads and writes a real DOM subtree, compiled under its own DOM-lib `tsconfig`. Also WebMCP feature detection (`getAgentModelContext`). `@jini-ai/chat-react` is its one in-repo consumer. | a real DOM (browser or jsdom) |
 | `./a2ui` | The real A2UI v1.0 wire types and a minimal client-side interpreter (`common-types`, `agent-to-renderer`, `renderer-to-agent`, `catalog`, `json-pointer`, `resolve`, `tree`, `interpreter`) — zero DOM dependency. | none |
+| `./skills/install` | Bounded bundle validation, archive/GitHub import, installation/state, explicit layout and live-registration factories. | Node runtime; injected filesystem, YAML, archive, HTTP, IDs and tool-source ports |
+| `./skills/install/node` | `createNodeSkillFilesystem({})`, a bounded no-follow filesystem adapter. | Node runtime |
 
 ## What's swappable
 
@@ -86,7 +102,18 @@ attribute names, and the wire shapes of both the GenUI and A2UI protocols.
 DOM at runtime — see Entry points above).
 ESM only — ships `"type": "module"` with no CommonJS `require` build.
 
+The two skill entries are `node` runtime entries. They use Node paths and byte buffers and are
+kept out of the universal root/core barrels. Every storage root, workspace-directory segment,
+state filename and tool-ID mapping is supplied by the host. The installer never executes scripts.
+Wrap an explicitly supplied native fetch with `createSkillFetchAdapter({ fetch })`, or implement
+`SkillFetchPort` as `fetch({ url }, requestOptions)`. YAML and ZIP parsing remain injected ports;
+this package adds no parser dependency. See [API.md](https://github.com/AINSEP/Jini/blob/main/packages/agentic/API.md) for construction and migration.
+
 ## Provenance
 
-See [source-map.md](./source-map.md) for per-file provenance, the AG-UI/GenUI naming history, and
+See the archived provenance ledger for per-file provenance, the AG-UI/GenUI naming history, and
 the A2UI spec-parity gap list. Apache-2.0, inherited from Open Design — see the repo `NOTICE`.
+
+`defaultAgenticMessages` (root / `./core`) supplies the neutral navigation description. Hosts
+replace copy through the existing `CapabilityDef.description` before projecting model tools;
+IDs, schemas and capability policy remain intact. Both UI interpreters accept core `Clock`.

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

@@ -608,6 +608,8 @@ export interface ParseSuccess {
  * `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 declare function parseAgentToRendererMessage(raw: unknown): ParseSuccess | ParseFailure;
+export declare function parseAgentToRendererMessage({ raw }: {
+    raw: unknown;
+}, _optional?: Record<string, never>): ParseSuccess | ParseFailure;
 export {};
 //# sourceMappingURL=agent-to-renderer.d.ts.map

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

@@ -144,7 +144,7 @@ const MESSAGE_KEYS = AGENT_TO_RENDERER_MESSAGE_KEYS;
  * `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) {
+export function parseAgentToRendererMessage({ raw }, _optional = {}) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         return { ok: false, code: 'VALIDATION_FAILED', message: 'envelope must be a JSON object' };
     }

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

@@ -17,7 +17,7 @@
  * 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
+ * implemented** — see `../archived provenance ledger` 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` /
@@ -60,14 +60,23 @@ export interface Catalog {
     readonly components: ReadonlyMap<string, ComponentSpec>;
     readonly functions: ReadonlyMap<string, FunctionSpec>;
 }
-export declare function isComponentAllowed(catalog: Catalog, componentType: string): boolean;
+export declare function isComponentAllowed({ catalog, componentType }: {
+    catalog: Catalog;
+    componentType: string;
+}, _optional?: Record<string, never>): 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;
+export declare function callableFromOf({ catalog, functionName }: {
+    catalog: Catalog;
+    functionName: string;
+}, _optional?: Record<string, never>): CallableFrom;
+export declare function isFunctionRegistered({ catalog, functionName }: {
+    catalog: Catalog;
+    functionName: string;
+}, _optional?: Record<string, never>): 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;
+export declare function createLabCatalog(_required: Record<string, never>, _optional?: Record<string, never>): Catalog;
 //# sourceMappingURL=catalog.d.ts.map

package/dist/core/a2ui/catalog.js

@@ -17,7 +17,7 @@
  * 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
+ * implemented** — see `../archived provenance ledger` 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` /
@@ -29,14 +29,14 @@
  */
 import { z } from 'zod';
 import { AccessibilityAttributesSchema, ActionSchema, CheckRuleSchema, ChildListSchema, ChildSchema, DataBindingSchema, DynamicBooleanSchema, DynamicNumberSchema, DynamicStringListSchema, DynamicStringSchema, } from './common-types.js';
-export function isComponentAllowed(catalog, componentType) {
+export function isComponentAllowed({ catalog, componentType }, _optional = {}) {
     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) {
+export function callableFromOf({ catalog, functionName }, _optional = {}) {
     return catalog.functions.get(functionName)?.callableFrom ?? 'rendererOnly';
 }
-export function isFunctionRegistered(catalog, functionName) {
+export function isFunctionRegistered({ catalog, functionName }, _optional = {}) {
     return catalog.functions.has(functionName);
 }
 // ---------------------------------------------------------------------------------------------
@@ -260,7 +260,7 @@ function not(args) {
  * each call (not a shared singleton) so tests can register their own `impl`s / mutate a copy
  * without cross-test leakage.
  */
-export function createLabCatalog() {
+export function createLabCatalog(_required, _optional = {}) {
     // All 18 components of the real basic catalog, in that catalog's own declaration order.
     const components = new Map([
         ['Text', { kind: 'text', propsSchema: TextPropsSchema }],

package/dist/core/a2ui/common-types.d.ts

@@ -7,7 +7,7 @@
  * was copied from the real JSON Schema `$defs`, not guessed). A2UI is a real, versioned,
  * actively-maintained spec (v1.0 is a release candidate at the time this was written) for agents
  * to stream a declarative, catalog-whitelisted component tree + JSON-Pointer-bound data model to a
- * renderer. See `../source-map.md` for provenance, what was verified against the primary source,
+ * renderer. See `../archived provenance ledger` for provenance, what was verified against the primary source,
  * and — importantly — why this was hand-rolled from the JSON Schemas rather than built on the
  * official `@a2ui/web_core` npm package (materially version-drifted: see that doc).
  *
@@ -396,6 +396,14 @@ export type AgentEventAction = Extract<Action, {
 export type LocalFunctionAction = Extract<Action, {
     functionCall: FunctionCall;
 }>;
-export declare function isAgentEventAction(action: Action): action is AgentEventAction;
-export declare function isLocalFunctionAction(action: Action): action is LocalFunctionAction;
+export declare function isAgentEventAction(required: {
+    action: Action;
+}, _optional?: Record<string, never>): required is {
+    action: AgentEventAction;
+};
+export declare function isLocalFunctionAction(required: {
+    action: Action;
+}, _optional?: Record<string, never>): required is {
+    action: LocalFunctionAction;
+};
 //# sourceMappingURL=common-types.d.ts.map

package/dist/core/a2ui/common-types.js

@@ -7,7 +7,7 @@
  * was copied from the real JSON Schema `$defs`, not guessed). A2UI is a real, versioned,
  * actively-maintained spec (v1.0 is a release candidate at the time this was written) for agents
  * to stream a declarative, catalog-whitelisted component tree + JSON-Pointer-bound data model to a
- * renderer. See `../source-map.md` for provenance, what was verified against the primary source,
+ * renderer. See `../archived provenance ledger` for provenance, what was verified against the primary source,
  * and — importantly — why this was hand-rolled from the JSON Schemas rather than built on the
  * official `@a2ui/web_core` npm package (materially version-drifted: see that doc).
  *
@@ -121,10 +121,12 @@ export const ActionSchema = z.union([
     z.object({ event: AgentActionEventSchema }).strict(),
     z.object({ functionCall: FunctionCallSchema }).strict(),
 ]);
-export function isAgentEventAction(action) {
+export function isAgentEventAction(required, _optional = {}) {
+    const { action } = required;
     return 'event' in action;
 }
-export function isLocalFunctionAction(action) {
+export function isLocalFunctionAction(required, _optional = {}) {
+    const { action } = required;
     return 'functionCall' in action;
 }
 //# sourceMappingURL=common-types.js.map

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

@@ -2,7 +2,7 @@
  * @module @jini-ai/a2ui
  *
  * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `source-map.md` for provenance, verified-against-primary-source notes,
+ * own doc for detail, and `archived provenance ledger` for provenance, verified-against-primary-source notes,
  * and the honest gap list against full v1.0 spec parity.
  */
 export * from './common-types.js';

package/dist/core/a2ui/index.js

@@ -2,7 +2,7 @@
  * @module @jini-ai/a2ui
  *
  * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `source-map.md` for provenance, verified-against-primary-source notes,
+ * own doc for detail, and `archived provenance ledger` for provenance, verified-against-primary-source notes,
  * and the honest gap list against full v1.0 spec parity.
  */
 export * from './common-types.js';

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

@@ -1,3 +1,4 @@
+import type { Clock } from "@jini-ai/core/primitives";
 import type { ParseFailure } from './agent-to-renderer.js';
 import { WireComponentSchema } from './agent-to-renderer.js';
 import type { RendererToAgentMessage } from './renderer-to-agent.js';
@@ -33,6 +34,10 @@ export type BuildActionResult = {
     readonly ok: false;
     readonly reason: string;
 };
+/** Host ports keep action IDs and timestamps deterministic and product-independent. */
+export interface A2uiIdsPort {
+    next(required: Record<string, never>): string;
+}
 /**
  * Turns a `ParseFailure` (from `parseAgentToRendererMessage`) into what `applyAgentMessage`
  * returns for it. See this module's doc, decision 4: an envelope malformed enough to carry no
@@ -44,7 +49,10 @@ export type BuildActionResult = {
  * Exported and pure — it only reads `parsed`/`raw`, so the surfaceId-attribution rule can be
  * tested directly, without a live interpreter instance.
  */
-export declare function buildParseFailureResult(parsed: ParseFailure, raw: unknown): ApplyMessageResult;
+export declare function buildParseFailureResult({ parsed, raw }: {
+    parsed: ParseFailure;
+    raw: unknown;
+}, _optional?: Record<string, never>): ApplyMessageResult;
 /**
  * Runs a component's local `functionCall` action synchronously against `dataModel` — no network
  * round trip, no pending-action bookkeeping (that only applies to the agent-event branch; see
@@ -54,18 +62,45 @@ export declare function buildParseFailureResult(parsed: ParseFailure, raw: unkno
  * data model, and a resolution failure becomes a typed refusal rather than a thrown error" can be
  * tested without a live interpreter instance.
  */
-export declare function runLocalFunctionAction(dataModel: unknown, catalog: Catalog, action: LocalFunctionAction): BuildActionResult;
+export declare function runLocalFunctionAction({ dataModel, catalog, action }: {
+    dataModel: unknown;
+    catalog: Catalog;
+    action: LocalFunctionAction;
+}, _optional?: Record<string, never>): BuildActionResult;
 export interface A2uiInterpreter {
-    applyAgentMessage(raw: unknown): ApplyMessageResult;
-    getSurface(surfaceId: string): SurfaceSnapshot | undefined;
-    listSurfaceIds(): string[];
+    applyAgentMessage(required: {
+        raw: unknown;
+    }, _optional?: Record<string, never>): ApplyMessageResult;
+    getSurface(required: {
+        surfaceId: string;
+    }, _optional?: Record<string, never>): SurfaceSnapshot | undefined;
+    listSurfaceIds(_required: Record<string, never>, _optional?: Record<string, never>): string[];
     /** `undefined` if the surface doesn't exist, or exists but has no component with id `'root'` yet (a legal, "still streaming in" state per the spec's own forward-reference tolerance). */
-    getRoot(surfaceId: string): ComponentInstance | undefined;
+    getRoot(required: {
+        surfaceId: string;
+    }, _optional?: Record<string, never>): ComponentInstance | undefined;
     /** Resolves a component's `action` prop (if any) for dispatch — builds the `action` envelope for an agent-event action, or synchronously runs a local `functionCall` action. Called by a host renderer on a real user interaction (e.g. a Button click). */
-    buildAction(surfaceId: string, componentId: string, now?: () => number): BuildActionResult;
-    resolve(surfaceId: string, value: DynamicValue, itemBasePath?: string, itemIndex?: number): ReturnType<typeof resolveDynamicValue>;
-    subscribe(listener: () => void): () => void;
+    buildAction(required: {
+        surfaceId: string;
+        componentId: string;
+    }, optional?: {
+        now?: ((required: Record<string, never>) => number) | undefined;
+    }): BuildActionResult;
+    resolve(required: {
+        surfaceId: string;
+        value: DynamicValue;
+    }, optional?: {
+        itemBasePath?: string | undefined;
+        itemIndex?: number | undefined;
+    }): ReturnType<typeof resolveDynamicValue>;
+    subscribe(required: {
+        listener: (required: Record<string, never>) => void;
+    }, _optional?: Record<string, never>): (required: Record<string, never>) => void;
 }
-export declare function createA2uiInterpreter(catalog: Catalog): A2uiInterpreter;
+export declare function createA2uiInterpreter({ catalog, clock, ids }: {
+    catalog: Catalog;
+    clock: Clock;
+    ids: A2uiIdsPort;
+}, _optional?: Record<string, never>): A2uiInterpreter;
 export { WireComponentSchema };
 //# sourceMappingURL=interpreter.d.ts.map