@adia-ai/a2ui 0.8.44 → 0.8.45

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog — @adia-ai/a2ui
 
+## [0.8.45] — 2026-08-20
+
+### Added
+- **ADR-0078 ratified: the in-repo a2ui runtime adopts the vendored genui v1.0 data model internally (Cell/Derived reactive primitives, RFC-6901 pointer semantics), install base and dialect wire surface unchanged.** Phased across future cuts — no runtime behavior changes ship in 0.8.45. Tracked in gh#1784.
+- **ADR-0079 ratified: `for=`-carrying components normalize to an events-only interaction contract (gh#1764/#1780).**
+
+### Changed
+- **The three independently-authored path-walker implementations in `path-pointer.js` unified, deliberately preserving each call site's real divergent edge-case semantics (empty-path, primitive mid-path, doubled-slash) rather than silently collapsing them — staging for ADR-0078's migration.**
+
+### Maintenance
+- **`catalog/` touched in this release window** (3 file(s), e.g. `catalog/catalog-a2ui_0_9.json`) — carried by the entries above.
+
 ## [0.8.44] — 2026-08-20
 
 ### Maintenance

package/catalog/catalog-a2ui_0_9.json

@@ -8896,7 +8896,7 @@
     },
     "ContextMenu": {
       "title": "ContextMenu",
-      "description": "Right-click activated menu — the OS-native context-menu pattern as a\nweb component. Distinct from `menu-ui` (which is button-triggered):\nsame item shape (`menu-item-ui` children), different trigger surface\n(`contextmenu` event), and pointer-anchored positioning instead of\nelement-anchored. Pattern: WAI-APG Menu.\n\nTwo binding modes:\n **A. Wrap.** Default-slot child becomes the target:\n `<context-menu-ui><my-table>...</my-table>...items</context-menu-ui>`.\n **B. Selector.** Point at one or more existing elements via [for]:\n `<context-menu-ui for=\"#my-table\">...items</context-menu-ui>`.\n\nOn `contextmenu` event on a target: `preventDefault()`, position the\nmenu at the pointer coords, show via Popover API. Touch long-press\n(configurable via [long-press-ms]) does the same. Shift+F10 / Menu\nkey opens at the focused target's center for keyboard users.\n",
+      "description": "Right-click activated menu — the OS-native context-menu pattern as a\nweb component. Distinct from `menu-ui` (which is button-triggered):\nsame item shape (`menu-item-ui` children), different trigger surface\n(`contextmenu` event), and pointer-anchored positioning instead of\nelement-anchored. Pattern: WAI-APG Menu.\n\nTwo binding modes:\n **A. Wrap.** Default-slot child becomes the target:\n `<context-menu-ui><my-table>...</my-table>...items</context-menu-ui>`.\n **B. Selector.** Point at one or more existing elements via\n [target-selector]:\n `<context-menu-ui target-selector=\"#my-table\">...items</context-menu-ui>`.\n\nOn `contextmenu` event on a target: `preventDefault()`, position the\nmenu at the pointer coords, show via Popover API. Touch long-press\n(configurable via [long-press-ms]) does the same. Shift+F10 / Menu\nkey opens at the focused target's center for keyboard users.\n",
       "type": "object",
       "allOf": [
         {
@@ -8911,7 +8911,7 @@
           "const": "ContextMenu"
         },
         "for": {
-          "description": "CSS selector(s) for target element(s). Empty = use default-slot child.",
+          "description": "DEPRECATED alias for [target-selector] — still a CSS selector, NOT an id-ref. Honored when [target-selector] is unset, with a one-shot console.warn pointing consumers at the replacement. New authoring should use [target-selector].",
           "type": "string",
           "default": ""
         },
@@ -8924,6 +8924,11 @@
           "description": "Programmatic open state. Set true to open at target center.",
           "type": "boolean",
           "default": false
+        },
+        "targetSelector": {
+          "description": "CSS selector(s) for target element(s). Empty = use default-slot child. Ratified name (gh#1764/#1780, ADR-0079) for what [for] used to carry — [for] means an id-ref everywhere else in AdiaUI (table-toolbar-ui, chart-legend-ui, tooltip-ui); context-menu-ui's own selector meaning predates that convention and was a same-name/ different-contract collision (ADR-0053's no-shadowing doctrine).",
+          "type": "string",
+          "default": ""
         }
       },
       "required": [
@@ -8933,7 +8938,7 @@
       "x-adiaui": {
         "anti_patterns": [
           {
-            "fix": "Wrap a target: `<context-menu-ui><my-target></my-target>...items</context-menu-ui>` OR point at one: `<context-menu-ui for=\"#my-target\">...items</context-menu-ui>`.",
+            "fix": "Wrap a target: `<context-menu-ui><my-target></my-target>...items</context-menu-ui>` OR point at one: `<context-menu-ui target-selector=\"#my-target\">...items</context-menu-ui>`.",
             "why": "No target binding — the menu never opens.",
             "wrong": "<context-menu-ui>...just items...</context-menu-ui>"
           }
@@ -16995,7 +17000,7 @@
           "default": false
         },
         "heading": {
-          "description": "Optional kicker label. Section variant renders it via ::before; primary uses it as aria-label only.",
+          "description": "Optional kicker label. Section variant renders it via ::before; primary uses it as aria-label only. For a VISIBLE kicker inside a primary-variant rail — or more than one kicker per <nav-ui> — hand-place <span data-nav-label> in the default slot instead; see slots below.",
           "type": "string",
           "default": ""
         },
@@ -17076,7 +17081,7 @@
         ],
         "slots": {
           "default": {
-            "description": "Primary slot — accepts <nav-group-ui> + <nav-item-ui> children, plus <hr data-nav-divider> for hand-placed dividers."
+            "description": "Primary slot — accepts <nav-group-ui> + <nav-item-ui> children, plus <hr data-nav-divider> for hand-placed dividers and <span data-nav-label> for hand-placed group-label kickers (titled runs of items/groups that aren't wrapped in a <nav-group-ui>). <span data-nav-label> renders with the same uppercase/tracking/muted kicker treatment as the [heading] ::before kicker, and is hidden alongside dividers whenever the primary-variant rail collapses ([collapsed] or ≤96px container width)."
           }
         },
         "states": [
@@ -22445,6 +22450,11 @@
           "type": "string",
           "default": ""
         },
+        "label-hidden": {
+          "description": "When true, [label] still sets the accessible name (aria-label) but the visible `::before` text is suppressed via the canonical sr-only technique (gh#1748, mirrors check-ui's [label-hidden], gh#1010). Use when a sibling/ancestor composition already conveys the same name visually (e.g. a scope/view-switcher select in a table-toolbar-ui [slot=\"scope\"], where the toolbar's own title already names the view) and a second visible \"Scope\"-style label would paint it twice.",
+          "type": "boolean",
+          "default": false
+        },
         "mark": {
           "description": "Renders the Adia brand mark (`<adia-mark-ui>`) as the leading visual — takes precedence over avatar and icon. Token-driven (light/dark handled internally), so it fits a scheme-switching workspace/app switcher where a static logo URL can't invert. Per-option `mark` on an `<option>`/options-array entry works the same way, scoped to that row.",
           "type": "boolean",
@@ -25854,6 +25864,21 @@
           },
           "sort-change": {
             "description": "Sort state changed. Detail: { sortState }."
+          },
+          "toolbar-columns-set": {
+            "description": "gh#1764/#1780, ADR-0079 — dispatched directly at the resolved [for] target in place of the pre-#1780 direct `target.columns =` write. table-ui listens for this on itself. Detail: { columns }."
+          },
+          "toolbar-filter-clear": {
+            "description": "gh#1764/#1780, ADR-0079 — dispatched directly at the resolved [for] target in place of the pre-#1780 direct `target.clearFilters()` call. table-ui listens for this on itself. No detail."
+          },
+          "toolbar-filter-set": {
+            "description": "gh#1764/#1780, ADR-0079 — dispatched directly at the resolved [for] target in place of the pre-#1780 direct `target.setFilter()` call. table-ui listens for this on itself. Detail: { key, value, op }; a null `value` clears that one column's filter."
+          },
+          "toolbar-paginate": {
+            "description": "gh#1764/#1780, ADR-0079 — dispatched directly at the resolved [for] target in place of the pre-#1780 direct `target.paginate =` write. table-ui listens for this on itself. Detail: { pageSize }."
+          },
+          "toolbar-search": {
+            "description": "gh#1764/#1780, ADR-0079 (events-only interaction contract) — dispatched directly at the resolved [for] target (not bubbled from this element) in place of the pre-#1780 direct `.search =` write. table-ui listens for this on itself. Detail: { value }."
           }
         },
         "examples": [

package/catalog/catalog-a2ui_0_9_rules.txt

@@ -232,7 +232,7 @@
 ## ContextMenu
 - Use <context-menu-ui> for right-click menus on a target (table row, file item, canvas object). For button-triggered menus use <menu-ui>; for popover content that is not a menu use <popover-ui> directly.
 - Items are <menu-item-ui> children inside the default slot — same shape as <menu-ui> items.
-- Bind target via wrap (default-slot first non-menu-item-ui child) OR [for] selector. The selector form is useful for whole-table or whole-canvas menus where wrapping isn't practical.
+- Bind target via wrap (default-slot first non-menu-item-ui child) OR [target-selector]. The selector form is useful for whole-table or whole-canvas menus where wrapping isn't practical. [for] still works as a deprecated alias but new authoring should use [target-selector] (gh#1764/#1780, ADR-0079).
 
 ## DateRangePicker
 - DateRangePicker.value MUST be `{from, to}` with both ISO 8601 dates, OR null. Either side null is invalid mid-state and the validator should reject it (use `input` event for partial state).
@@ -480,7 +480,8 @@
 - Authoring options: default stamping renders icon+text+badge from attributes. Named slots `icon`, `text`, `trailing` are also supported for custom content (e.g. a `<kbd slot="trailing">⌘K</kbd>` shortcut hint on a command-trigger item — see the admin-shell playground). Do NOT nest <nav-item-ui> inside another <nav-item-ui>.
 
 ## Nav
-- Composition: place <nav-ui> inside <admin-sidebar slot="leading"> wrapped in <section-ui> for app sidebars; inside an <aside data-subnav> with variant="section" for section / subnav rails; standalone on docs / auth pages. Children: <nav-group-ui>, <nav-item-ui>, optional <hr data-nav-divider>.
+- Composition: place <nav-ui> inside <admin-sidebar slot="leading"> wrapped in <section-ui> for app sidebars; inside an <aside data-subnav> with variant="section" for section / subnav rails; standalone on docs / auth pages. Children: <nav-group-ui>, <nav-item-ui>, optional <hr data-nav-divider>, optional <span data-nav-label> (hand-placed titled section header).
+- Titled nav-item groups: hand-place <span data-nav-label>Text</span> directly in the default slot, before a run of <nav-item-ui> / <nav-group-ui> children, to render a section-header kicker — the same uppercase/tracking/muted treatment as the [heading] ::before kicker on variant="section", but usable anywhere in the child list (not limited to one kicker per <nav-ui>) and always visually rendered, unlike [heading] which is aria-only on variant="primary". Hidden automatically whenever the primary-variant rail collapses ([collapsed] or ≤96px container width), same as <hr data-nav-divider>.
 - Variants: variant="primary" (default) — app sidebar; ResizeObserver collapses to icon-only ≤96px; collapsible groups open as a popover when collapsed. variant="section" — subnav rail; quieter chrome; optional [heading] kicker rendered via ::before.
 - Section-variant cascade (ADR-0015 § Nav consolidation): variant="section" on <nav-ui> cascades visually to direct <nav-group-ui> / <nav-item-ui> descendants via CSS `:not([variant])`. Children's JS state is NOT mutated; the cascade is purely visual. Explicit [variant] on a child always wins — use it to escape the cascade or style a standalone group/item.
 - Decision rule: if the user navigates AWAY (different page, route, or anchor) → <nav-ui>. If the user switches VIEWS within the same logical page → <tabs-ui>. Never use <nav-ui> as an in-page section switcher.
@@ -710,11 +711,11 @@
 - Use [slot="actions-leading"] (gh#1649) for app-owned trigger buttons that must land BEFORE the page-size select — e.g. custom Filter / Columns triggers that open the consumer's own drawer instead of the native filter/columns popovers (drop [no-filter] [no-columns] to hide the native ones when doing this). [slot="actions"] stays the trailing region AFTER the page-size select, for a primary CTA.
 - Use [chrome-only] (ADR-0076, ADIA2-9123) instead of stacking [no-filter] [no-sort] [no-columns] [no-search] individually when an app owns ALL FOUR affordances itself (its own drawer/menu). Pure OR, absolute while set — clearing an individual no-* attribute does NOT re-enable that one control; drop [chrome-only] entirely and set the three you still want off explicitly instead. Combine with [slot="actions-leading"] for the app's own Filter/Columns triggers.
 - Use <span slot="empty"> (or any markup) inside a table-toolbar-ui that also sets [range-total="0"] to show a "no results" message in the range-summary's own position, without a layout shift versus the normal "Showing X-Y of N" text (ADR-0076, REQ-E). Only fires on an EXPLICIT range-total="0" — omitting range-* entirely (loading) never shows it.
-- Read the host's [data-stage-resolved] attribute (ADR-0076 REQ-M-005, ADIA2-9123 S4-ii) to compact a consumer's own [slot="actions-leading"] content in sympathy with table-toolbar's native regions, without re-deriving the same breakpoints yourself. Informational only — mirrors the CSS-decided compaction stage (full | search-tight | icon-only | overflow), never drives table-toolbar's own rendering. Reports the pinned [stage] value when set, the live width classification otherwise; updates on both a live resize and a [stage] attribute change.
+- A plain <button-ui> slotted into [slot="actions-leading"] (e.g. the app-owned Filter/Columns triggers above) already collapses to icon-only at the SAME breakpoint as the native Filter/Sort/Columns buttons (gh#1748) — no consumer JS/CSS required. Read the host's [data-stage-resolved] attribute (ADR-0076 REQ-M-005, ADIA2-9123 S4-ii) only for compaction BEYOND plain icon-only reduction — e.g. hiding a slotted button entirely at the overflow stage, or reacting to the stage in a consumer's own drawer/menu — without re-deriving the same breakpoints yourself. Informational only — mirrors the CSS-decided compaction stage (full | search-tight | icon-only | overflow), never drives table-toolbar's own rendering. Reports the pinned [stage] value when set, the live width classification otherwise; updates on both a live resize and a [stage] attribute change.
 
 ## Table
 - Canonical composition: wrap <table-ui> in <card-ui><section bleed> for edge-to-edge tables. The [bleed] removes section padding so columns span the full card width (see apps/saas/members, billing, admin-dashboard).
-- Pair with <table-toolbar-ui for="<table-id>"> for any table that needs search / filter / sort / columns visibility. Do NOT re-implement those affordances in the card header — the toolbar auto-wires search/filter/sort/columns changes into the bound table.
+- Pair with <table-toolbar-ui for="<table-id>"> for any table that needs search / filter / sort / columns visibility. Do NOT re-implement those affordances in the card header — the toolbar auto-wires search/filter/sort/columns changes into the bound table via `toolbar-*` CustomEvents (gh#1764/#1780, ADR-0079 — events-only interaction contract; table-ui listens for toolbar-search/toolbar-filter-set/toolbar-filter-clear/ toolbar-columns-set/toolbar-paginate on itself). Any consumer, not only table-toolbar-ui, may dispatch these events directly at a table-ui instance.
 - Cells truncate single-line by default (v0.6.21 §403 truncate-default). Opt out per-table with [wrap] for whole-table multiline, or per-cell with [data-wrap] on a single column / cell.
 - [raw] is a visual-and-lifecycle chrome reset for consumer-owned body markup — render()'s early return (`if (this.raw) return;`) is unconditional: no header injection, no .data/.columns reconciliation, no empty/loading overlays, no aggregation or pagination footers, even if .columns and .data are set. Reach for it only when the consumer authors 100% of the body (spreadsheet / inline-edit style patterns wrapping a native <table>) — never to "keep the data lifecycle but skip demo seeding."
 - Listen for the `sort` event with detail.key + detail.dir (NOT .column / .direction). `cell-click` detail carries {key, row, value, dataIndex}. Per ADR-0027, table-ui composes check-ui, icon-ui, progress-ui, pagination-ui, skeleton-ui, badge-ui — consumer pages must explicitly import the ones they use.

package/catalog/tier-index.json

@@ -1,9 +1,9 @@
 {
-  "catalogId": "adia.tiers@0.8.44",
+  "catalogId": "adia.tiers@0.8.45",
   "description": "Tier index of the AdiaUI catalog contract (ADR-0050). L0-L4 ladder; every tier-N entry is a declared composition of tier-(N-1) entries. L1 `composes` edges speak A2UI component TYPE names — the R-C7 catalogs’ `components` keys (genui-system SPEC R-C13). Derived — regenerate with `npm run build:catalog-tiers`, never hand-edit.",
   "extends": {
     "catalogId": "adia.base",
-    "version": "0.8.44"
+    "version": "0.8.45"
   },
   "tiers": {
     "L0": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui",
-  "version": "0.8.44",
+  "version": "0.8.45",
   "description": "The A2UI protocol — runtime (renderer, registry, streams, surface manifest, wiring primitives, dockable base classes) plus protocol-side validation. Framework-agnostic and dependency-free; pairs with any A2UI-conformant component set. Folded from @adia-ai/a2ui-runtime + the protocol half of @adia-ai/a2ui-validator (ADR-0048).",
   "type": "module",
   "exports": {

package/path-pointer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared `/`-delimited path-walking helpers consolidating renderer.js,
+ * surface.js, and wiring-registry.js's originally-separate get/set
+ * implementations — see path-pointer.js for the per-function edge-case
+ * divergences each export preserves.
+ */
+
+/** renderer.js's original getByPath: root/falsy path returns `obj` itself;
+ *  no type guard mid-traversal. */
+export declare function getByPath(obj: object, path?: string): unknown;
+
+/** renderer.js's original updateDataModel write helper: mutates `obj` in
+ *  place, creating missing intermediate objects; no-op on a root/falsy
+ *  path (the caller handles whole-model replacement itself). */
+export declare function setByPath(obj: object, path: string | undefined, value: unknown): void;
+
+/** surface.js's original getPath: same root handling as getByPath, but a
+ *  looser splitter that doesn't drop empty segments (trailing/doubled
+ *  `/` behaves differently than getByPath for the same input). */
+export declare function getPath(obj: object, path?: string): unknown;
+
+/** surface.js's original setPath — see getPath's splitter note. */
+export declare function setPath(obj: object, path: string | undefined, value: unknown): void;
+
+/** wiring-registry.js's original getModelValue: an empty-string path
+ *  returns `undefined` (not `model`, unlike getByPath/getPath), and
+ *  traversal stops at the first non-object `current`, returning
+ *  `undefined` instead of falling through to primitive property access. */
+export declare function getModelValue(model: object | null | undefined, path?: string): unknown;

package/path-pointer.js

@@ -0,0 +1,129 @@
+/**
+ * Shared `/`-delimited path-walking helpers for `packages/gen-ui/a2ui`.
+ *
+ * Consolidates three independently-authored get/set implementations
+ * (reactivity review corpus, axis 3/4, R4 — gh#1763): renderer.js's
+ * `#getByPath`/`#updateDataModel`, surface.js's `getPath`/`setPath`, and
+ * wiring-registry.js's `getModelValue`. This is a MECHANICAL extraction —
+ * no call site's observable behavior changes. The three implementations
+ * disagreed on a few real edge cases (see per-function notes below); each
+ * disagreement is preserved here rather than silently unified, so this
+ * module exports one function PER call site's original semantics instead
+ * of a single "canonical" walker.
+ *
+ * Direction, not conformance: the vendored runtime
+ * (`packages/genui/renderer/dist/data-model.js`) implements full RFC 6901 —
+ * `~0`/`~1` escaping, `""`/`"/"` both meaning "whole document", immutable
+ * structural-sharing writes. None of the three functions below do any of
+ * that (no escaping, and the three don't even agree on what an empty path
+ * means), and this ticket does not add it — that would be a behavior
+ * change, and app-layer stores migrating to the vendored model is tracked
+ * separately. This module only stops the same non-conformant walk from
+ * being typed out three times.
+ */
+
+/** True for a path that addresses the whole document under every one of
+ *  the three original implementations: absent, `""`, or `"/"`. */
+function isRootPath(path) {
+  return !path || path === '/';
+}
+
+/** renderer.js's and wiring-registry.js's original splitter: drops every
+ *  empty segment, so a leading `/`, a trailing `/`, and a doubled `//` are
+ *  all forgiving — `"/a//b/"` walks `['a', 'b']`. */
+function splitPath(path) {
+  return path.split('/').filter(Boolean);
+}
+
+/** surface.js's original splitter: strips exactly one leading `/`, then
+ *  splits on every `/` WITHOUT dropping empty segments — a trailing or
+ *  doubled slash produces a `''` segment that looks up `undefined` rather
+ *  than being skipped. Kept verbatim; it's a real divergence from
+ *  {@link splitPath} (see `getPath`/`setPath` below), not a bug this
+ *  ticket fixes. */
+function splitPathLoose(path) {
+  return path.replace(/^\//, '').split('/');
+}
+
+// ── renderer.js semantics: getByPath / setByPath ───────────────────────
+//
+// Root/falsy path returns (or, for the setter, is left to the caller to
+// handle — see updateDataModel's own root branch) the object itself.
+// Traversal relies on optional chaining with no type guard, so indexing
+// past a primitive mid-path (e.g. `/name/length` where `name` is a string)
+// returns that primitive's own property instead of `undefined` — this
+// differs from `getModelValue` below, which blocks that case explicitly.
+
+/** @param {object} obj @param {string} path */
+export function getByPath(obj, path) {
+  if (isRootPath(path)) return obj;
+  return splitPath(path).reduce((o, k) => o?.[k], obj);
+}
+
+/** Mutates `obj` in place along `path`, creating missing intermediate
+ *  objects. No-op on a root/falsy path — renderer.js's `#updateDataModel`
+ *  handles whole-model replacement itself (`surface.dataModel = value ??
+ *  {}`), since that reassigns a variable this function has no reach to. */
+export function setByPath(obj, path, value) {
+  if (isRootPath(path)) return;
+  const parts = splitPath(path);
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null) cur[parts[i]] = {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+
+// ── surface.js semantics: getPath / setPath ────────────────────────────
+//
+// Same root-path handling as getByPath/setByPath, but walks with
+// splitPathLoose — so a trailing or doubled slash resolves differently
+// than getByPath/setByPath/getModelValue for the same input string.
+
+/** @param {object} obj @param {string} path */
+export function getPath(obj, path) {
+  if (isRootPath(path)) return obj;
+  const keys = splitPathLoose(path);
+  let current = obj;
+  for (const key of keys) {
+    if (current == null) return undefined;
+    current = current[key];
+  }
+  return current;
+}
+
+/** @param {object} obj @param {string} path @param {unknown} value */
+export function setPath(obj, path, value) {
+  if (isRootPath(path)) return;
+  const keys = splitPathLoose(path);
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] == null) current[key] = {};
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
+// ── wiring-registry.js semantics: getModelValue ────────────────────────
+//
+// Two real divergences from getByPath: (1) an empty-string path (falsy,
+// but not `"/"`) returns `undefined` here — getByPath/getPath return the
+// object itself for ANY falsy path, including `""`. (2) traversal
+// type-guards: once `current` is a non-null value that isn't an `object`,
+// this returns `undefined` immediately rather than continuing property
+// access, so `/name/length` on a string model value reads as `undefined`
+// here vs. the string's own `.length` in getByPath/getPath.
+
+/** @param {object} model @param {string} path — JSON Pointer (e.g. "/patient/name") */
+export function getModelValue(model, path) {
+  if (!path || !model) return undefined;
+  const segments = splitPath(path);
+  let current = model;
+  for (const seg of segments) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[seg];
+  }
+  return current;
+}

package/renderer.js

@@ -9,6 +9,7 @@
 
 import { resolveTag, registry } from './registry.js';
 import { applyResolvedProp, toAttr } from './prop-apply.js';
+import { getByPath, setByPath } from './path-pointer.js';
 
 export class A2UIRenderer {
   #container;
@@ -479,16 +480,11 @@ export class A2UIRenderer {
     if (typeof value !== 'object') return value;
     if (value.path) {
       const surface = surfaceId ? this.#surfaces.get(surfaceId) : null;
-      return surface ? this.#getByPath(surface.dataModel, value.path) : value.path;
+      return surface ? getByPath(surface.dataModel, value.path) : value.path;
     }
     return value;
   }
 
-  #getByPath(obj, path) {
-    if (!path || path === '/') return obj;
-    return path.split('/').filter(Boolean).reduce((o, k) => o?.[k], obj);
-  }
-
   // ── updateDataModel ──
 
   #updateDataModel({ surfaceId, path, value }) {
@@ -498,13 +494,7 @@ export class A2UIRenderer {
     if (!path || path === '/') {
       surface.dataModel = value ?? {};
     } else {
-      const parts = path.split('/').filter(Boolean);
-      let cur = surface.dataModel;
-      for (let i = 0; i < parts.length - 1; i++) {
-        if (cur[parts[i]] == null) cur[parts[i]] = {};
-        cur = cur[parts[i]];
-      }
-      cur[parts[parts.length - 1]] = value;
+      setByPath(surface.dataModel, path, value);
     }
 
     for (const [compId, comp] of surface.bindings) {

package/surface.js

@@ -10,6 +10,8 @@
  * their lifecycle and provides a shared context.
  */
 
+import { getPath, setPath } from './path-pointer.js';
+
 // ── Dock order (lowest docks first, undocks last) ──
 const DOCK_ORDER = { provider: 0, controller: 1, source: 2, action: 3, lifecycle: 4 };
 
@@ -195,28 +197,3 @@ export class Surface {
     }));
   }
 }
-
-// ── JSON Pointer helpers (simplified, "/" delimited) ────────
-
-function getPath(obj, path) {
-  if (!path || path === '/') return obj;
-  const keys = path.replace(/^\//, '').split('/');
-  let current = obj;
-  for (const key of keys) {
-    if (current == null) return undefined;
-    current = current[key];
-  }
-  return current;
-}
-
-function setPath(obj, path, value) {
-  if (!path || path === '/') return;
-  const keys = path.replace(/^\//, '').split('/');
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (current[key] == null) current[key] = {};
-    current = current[key];
-  }
-  current[keys[keys.length - 1]] = value;
-}

package/wiring-registry.js

@@ -12,6 +12,8 @@
  * A healthcare app registers CheckinController; a CRM registers PipelineController.
  */
 
+import { getModelValue } from './path-pointer.js';
+
 // ═══════════════════════════════════════════════════════════════
 // REGISTRY
 // ═══════════════════════════════════════════════════════════════
@@ -293,23 +295,6 @@ function extractValue(descriptor, ctx) {
   }
 }
 
-/**
- * Get a value from a data model by JSON Pointer path.
- * @param {object} model
- * @param {string} path — JSON Pointer (e.g., "/patient/name")
- * @returns {unknown}
- */
-function getModelValue(model, path) {
-  if (!path || !model) return undefined;
-  const segments = path.split('/').filter(Boolean);
-  let current = model;
-  for (const seg of segments) {
-    if (current == null || typeof current !== 'object') return undefined;
-    current = current[seg];
-  }
-  return current;
-}
-
 // ═══════════════════════════════════════════════════════════════
 // DEFAULT RESOLVERS
 // ═══════════════════════════════════════════════════════════════