@ankhorage/zora 25.7.0 → 25.8.1

package/src/features/matrix-grid/application/createMatrixGridSparseIndex.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'bun:test';
+
+import { createMatrixGridSparseIndex } from './createMatrixGridSparseIndex';
+import { getMatrixGridNextFocusId } from './getMatrixGridNextFocusId';
+
+describe('createMatrixGridSparseIndex', () => {
+  test('indexes more than 10k sparse cells without creating placement rectangles', () => {
+    const layout = {
+      columns: Array.from({ length: 1_000 }, (_, index) => ({ id: `column-${index}`, size: 10 })),
+      rows: Array.from({ length: 1_000 }, (_, index) => ({ id: `row-${index}`, size: 10 })),
+    };
+    const cells = layout.rows.flatMap((row) =>
+      layout.columns.slice(0, 10).map((column) => ({
+        columnId: column.id,
+        id: `${row.id}-${column.id}`,
+        rowId: row.id,
+      })),
+    );
+    const index = createMatrixGridSparseIndex(layout, [...cells].reverse());
+
+    expect(index.entries).toHaveLength(10_000);
+    expect(index.entries[0]).toEqual({
+      cell: cells.at(-1),
+      columnIndex: 9,
+      id: 'row-999-column-9',
+      rowIndex: 999,
+    });
+    expect(getMatrixGridNextFocusId(index, 'row-500-column-5', 'ArrowRight')).toBe(
+      'row-500-column-6',
+    );
+    expect(getMatrixGridNextFocusId(index, 'row-500-column-5', 'ArrowDown')).toBe(
+      'row-501-column-5',
+    );
+  });
+});

package/src/features/matrix-grid/application/createMatrixGridSparseIndex.ts

@@ -0,0 +1,105 @@
+import type { GridMatrixCell, GridMatrixLayout } from '@ankhorage/grid-view';
+
+/*** Build a geometry-independent lookup for sparse matrix navigation, selection, and focus recovery. */
+export function createMatrixGridSparseIndex(
+  layout: GridMatrixLayout,
+  cells: readonly GridMatrixCell[],
+): MatrixGridSparseIndex {
+  const rowIndexes = new Map(layout.rows.map((row, index) => [row.id, index]));
+  const columnIndexes = new Map(layout.columns.map((column, index) => [column.id, index]));
+  const entries = cells.map((cell) => createSparseEntry(cell, rowIndexes, columnIndexes));
+  const entriesByRow = groupEntries(entries, 'columnIndex');
+  const entriesByColumn = groupEntries(entries, 'rowIndex');
+  const orderedEntries = [...entries].sort(compareRowThenColumn);
+
+  return {
+    cellById: new Map(entries.map((entry) => [entry.id, entry.cell])),
+    entries,
+    entriesByColumn,
+    entriesByRow,
+    firstId: orderedEntries.at(0)?.id ?? null,
+    positionById: new Map(entries.map((entry) => [entry.id, entry])),
+  };
+}
+
+/*** Resolve validated matrix coordinates once without materializing every cell rectangle. */
+function createSparseEntry(
+  cell: GridMatrixCell,
+  rowIndexes: ReadonlyMap<string, number>,
+  columnIndexes: ReadonlyMap<string, number>,
+): MatrixGridSparseIndexEntry {
+  const rowIndex = rowIndexes.get(cell.rowId);
+  const columnIndex = columnIndexes.get(cell.columnId);
+  if (rowIndex === undefined || columnIndex === undefined) {
+    throw new Error(`Matrix cell ${cell.id} references an unknown row or column.`);
+  }
+  return { cell, columnIndex, id: cell.id, rowIndex };
+}
+
+/*** Group and sort directional neighbours so arrow navigation is logarithmic within one axis. */
+function groupEntries(
+  entries: readonly MatrixGridSparseIndexEntry[],
+  axis: 'columnIndex' | 'rowIndex',
+): ReadonlyMap<number, readonly MatrixGridSparseIndexEntry[]> {
+  const groups = new Map<number, MatrixGridSparseIndexEntry[]>();
+  for (const entry of entries) {
+    const groupKey = axis === 'columnIndex' ? entry.rowIndex : entry.columnIndex;
+    const group = groups.get(groupKey) ?? [];
+    group.push(entry);
+    groups.set(groupKey, group);
+  }
+  return new Map(
+    [...groups].map(([key, group]) => [
+      key,
+      group.sort((left, right) => compareAxisThenId(left, right, axis)),
+    ]),
+  );
+}
+
+/*** Keep the initial roving target deterministic even when sparse input arrives in arbitrary order. */
+function compareRowThenColumn(
+  left: MatrixGridSparseIndexEntry,
+  right: MatrixGridSparseIndexEntry,
+): number {
+  return (
+    left.rowIndex - right.rowIndex ||
+    left.columnIndex - right.columnIndex ||
+    left.id.localeCompare(right.id)
+  );
+}
+
+/*** Sort a row or column by its navigated coordinate and stable identity. */
+function compareAxisThenId(
+  left: MatrixGridSparseIndexEntry,
+  right: MatrixGridSparseIndexEntry,
+  axis: 'columnIndex' | 'rowIndex',
+): number {
+  return (
+    getAxisCoordinate(left, axis) - getAxisCoordinate(right, axis) ||
+    left.id.localeCompare(right.id)
+  );
+}
+
+/*** Read a selected coordinate without dynamically indexing an object. */
+function getAxisCoordinate(
+  entry: MatrixGridSparseIndexEntry,
+  axis: 'columnIndex' | 'rowIndex',
+): number {
+  return axis === 'columnIndex' ? entry.columnIndex : entry.rowIndex;
+}
+
+export type MatrixGridSparseIndex = Readonly<{
+  cellById: ReadonlyMap<string, GridMatrixCell>;
+  entries: readonly MatrixGridSparseIndexEntry[];
+  entriesByColumn: ReadonlyMap<number, readonly MatrixGridSparseIndexEntry[]>;
+  entriesByRow: ReadonlyMap<number, readonly MatrixGridSparseIndexEntry[]>;
+  firstId: string | null;
+  positionById: ReadonlyMap<string, MatrixGridSparseIndexEntry>;
+}>;
+
+export type MatrixGridSparseIndexEntry = Readonly<{
+  cell: GridMatrixCell;
+  columnIndex: number;
+  id: string;
+  rowIndex: number;
+}>;

package/src/features/matrix-grid/application/getMatrixGridNextFocusId.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'bun:test';
+
+import { createMatrixGridSparseIndex } from './createMatrixGridSparseIndex';
+import { getMatrixGridNextFocusId } from './getMatrixGridNextFocusId';
+
+const cells = [
+  {
+    columnId: 'a',
+    columnIndex: 0,
+    height: 1,
+    id: 'a1',
+    rowId: '1',
+    rowIndex: 0,
+    width: 1,
+    x: 0,
+    y: 0,
+  },
+  {
+    columnId: 'c',
+    columnIndex: 2,
+    height: 1,
+    id: 'c1',
+    rowId: '1',
+    rowIndex: 0,
+    width: 1,
+    x: 2,
+    y: 0,
+  },
+  {
+    columnId: 'a',
+    columnIndex: 0,
+    height: 1,
+    id: 'a3',
+    rowId: '3',
+    rowIndex: 2,
+    width: 1,
+    x: 0,
+    y: 2,
+  },
+  {
+    columnId: 'c',
+    columnIndex: 2,
+    height: 1,
+    id: 'c3',
+    rowId: '3',
+    rowIndex: 2,
+    width: 1,
+    x: 2,
+    y: 2,
+  },
+] as const;
+
+const layout = {
+  columns: [
+    { id: 'a', size: 1 },
+    { id: 'b', size: 1 },
+    { id: 'c', size: 1 },
+  ],
+  rows: [
+    { id: '1', size: 1 },
+    { id: '2', size: 1 },
+    { id: '3', size: 1 },
+  ],
+} as const;
+
+const index = createMatrixGridSparseIndex(layout, cells);
+
+describe('getMatrixGridNextFocusId', () => {
+  test('moves over sparse rows and columns without materializing missing cells', () => {
+    expect(getMatrixGridNextFocusId(index, 'a1', 'ArrowRight')).toBe('c1');
+    expect(getMatrixGridNextFocusId(index, 'c3', 'ArrowLeft')).toBe('a3');
+    expect(getMatrixGridNextFocusId(index, 'a1', 'ArrowDown')).toBe('a3');
+    expect(getMatrixGridNextFocusId(index, 'c3', 'ArrowUp')).toBe('c1');
+  });
+
+  test('retains focus at a sparse edge and initializes from the first real cell', () => {
+    expect(getMatrixGridNextFocusId(index, 'a1', 'ArrowLeft')).toBe('a1');
+    expect(getMatrixGridNextFocusId(index, null, 'ArrowRight')).toBe('a1');
+    expect(
+      getMatrixGridNextFocusId(createMatrixGridSparseIndex(layout, []), null, 'ArrowRight'),
+    ).toBeNull();
+  });
+
+  test('chooses geometric neighbours from an intentionally unsorted sparse input', () => {
+    const unsorted = createMatrixGridSparseIndex(layout, [cells[3], cells[1], cells[2], cells[0]]);
+
+    expect(getMatrixGridNextFocusId(unsorted, 'a1', 'ArrowRight')).toBe('c1');
+    expect(getMatrixGridNextFocusId(unsorted, 'c3', 'ArrowLeft')).toBe('a3');
+    expect(getMatrixGridNextFocusId(unsorted, 'a1', 'ArrowDown')).toBe('a3');
+    expect(getMatrixGridNextFocusId(unsorted, 'c3', 'ArrowUp')).toBe('c1');
+    expect(getMatrixGridNextFocusId(unsorted, null, 'ArrowRight')).toBe('a1');
+  });
+});

package/src/features/matrix-grid/application/getMatrixGridNextFocusId.ts

@@ -0,0 +1,112 @@
+import type {
+  MatrixGridSparseIndex,
+  MatrixGridSparseIndexEntry,
+} from './createMatrixGridSparseIndex';
+
+/*** Resolve arrow-key focus among existing sparse cells without inventing placeholder geometry. */
+export function getMatrixGridNextFocusId(
+  index: MatrixGridSparseIndex,
+  currentId: string | null,
+  key: string,
+): string | null {
+  const current = currentId === null ? undefined : index.positionById.get(currentId);
+  if (!current) return index.firstId;
+
+  return resolveDirectionalCandidate(index, current, key)?.id ?? current.id;
+}
+
+/*** Find the closest existing sparse cell along the requested matrix axis. */
+function resolveDirectionalCandidate(
+  index: MatrixGridSparseIndex,
+  current: MatrixGridSparseIndexEntry,
+  key: string,
+): MatrixGridSparseIndexEntry | undefined {
+  switch (key) {
+    case 'ArrowLeft':
+      return findDirectionalNeighbour(
+        index.entriesByRow.get(current.rowIndex),
+        current,
+        'columnIndex',
+        -1,
+      );
+    case 'ArrowRight':
+      return findDirectionalNeighbour(
+        index.entriesByRow.get(current.rowIndex),
+        current,
+        'columnIndex',
+        1,
+      );
+    case 'ArrowUp':
+      return findDirectionalNeighbour(
+        index.entriesByColumn.get(current.columnIndex),
+        current,
+        'rowIndex',
+        -1,
+      );
+    case 'ArrowDown':
+      return findDirectionalNeighbour(
+        index.entriesByColumn.get(current.columnIndex),
+        current,
+        'rowIndex',
+        1,
+      );
+    default:
+      return undefined;
+  }
+}
+
+/*** Read the nearest strictly directional neighbour from a pre-sorted sparse axis. */
+function findDirectionalNeighbour(
+  entries: readonly MatrixGridSparseIndexEntry[] | undefined,
+  current: MatrixGridSparseIndexEntry,
+  axis: 'columnIndex' | 'rowIndex',
+  direction: -1 | 1,
+): MatrixGridSparseIndexEntry | undefined {
+  if (!entries) return undefined;
+  const coordinate = getAxisCoordinate(current, axis);
+  const insertionIndex = findFirstGreaterOrEqual(entries, coordinate, axis);
+  if (direction === -1) return insertionIndex === 0 ? undefined : entries[insertionIndex - 1];
+  return entries[findFirstGreater(entries, coordinate, axis)];
+}
+
+/*** Locate the first entry strictly after a matrix coordinate in a sorted sparse axis. */
+function findFirstGreater(
+  entries: readonly MatrixGridSparseIndexEntry[],
+  coordinate: number,
+  axis: 'columnIndex' | 'rowIndex',
+): number {
+  let lower = 0;
+  let upper = entries.length;
+  while (lower < upper) {
+    const middle = Math.floor((lower + upper) / 2);
+    const entry = entries.at(middle);
+    if (entry && getAxisCoordinate(entry, axis) <= coordinate) lower = middle + 1;
+    else upper = middle;
+  }
+  return lower;
+}
+
+/*** Locate the first index at or after a matrix coordinate in a sorted sparse axis. */
+function findFirstGreaterOrEqual(
+  entries: readonly MatrixGridSparseIndexEntry[],
+  coordinate: number,
+  axis: 'columnIndex' | 'rowIndex',
+): number {
+  let lower = 0;
+  let upper = entries.length;
+  while (lower < upper) {
+    const middle = Math.floor((lower + upper) / 2);
+    const entry = entries.at(middle);
+    if (entry && getAxisCoordinate(entry, axis) < coordinate) lower = middle + 1;
+    else upper = middle;
+  }
+  return lower;
+}
+
+/*** Read a selected coordinate without dynamically indexing sparse entries. */
+function getAxisCoordinate(
+  entry: MatrixGridSparseIndexEntry,
+  axis: 'columnIndex' | 'rowIndex',
+): number {
+  return axis === 'columnIndex' ? entry.columnIndex : entry.rowIndex;
+}

package/src/features/matrix-grid/application/resolveMatrixGridSelection.test.ts

@@ -2,9 +2,70 @@ import { describe, expect, test } from 'bun:test';
 
 import { resolveMatrixGridSelection } from './resolveMatrixGridSelection';
 
+const cells = [
+  {
+    columnId: 'a',
+    columnIndex: 0,
+    height: 1,
+    id: 'a1',
+    rowId: '1',
+    rowIndex: 0,
+    width: 1,
+    x: 0,
+    y: 0,
+  },
+  {
+    columnId: 'b',
+    columnIndex: 1,
+    height: 1,
+    id: 'b1',
+    rowId: '1',
+    rowIndex: 0,
+    width: 1,
+    x: 1,
+    y: 0,
+  },
+  {
+    columnId: 'a',
+    columnIndex: 0,
+    height: 1,
+    id: 'a2',
+    rowId: '2',
+    rowIndex: 1,
+    width: 1,
+    x: 0,
+    y: 1,
+  },
+  {
+    columnId: 'b',
+    columnIndex: 1,
+    height: 1,
+    id: 'b2',
+    rowId: '2',
+    rowIndex: 1,
+    width: 1,
+    x: 1,
+    y: 1,
+  },
+] as const;
+
 describe('resolveMatrixGridSelection', () => {
   test('preserves the canonical single and multi selection intent rules', () => {
-    expect(resolveMatrixGridSelection(['a'], 'b', 'toggle', 'single')).toEqual(['b']);
-    expect(resolveMatrixGridSelection(['a'], 'b', 'toggle', 'multi')).toEqual(['a', 'b']);
+    expect(resolveMatrixGridSelection(cells, ['a1'], 'b1', 'a1', 'toggle', 'single')).toEqual([
+      'b1',
+    ]);
+    expect(resolveMatrixGridSelection(cells, ['a1'], 'b1', 'a1', 'toggle', 'multi')).toEqual([
+      'a1',
+      'b1',
+    ]);
+  });
+
+  test('uses the selection contract for a sparse rectangular shift range', () => {
+    expect(resolveMatrixGridSelection(cells, ['a1'], 'b2', 'a1', 'range', 'multi')).toEqual([
+      'a1',
+      'b1',
+      'a2',
+      'b2',
+    ]);
   });
 });

package/src/features/matrix-grid/application/resolveMatrixGridSelection.ts

@@ -2,14 +2,37 @@ import { applySelectionIntent, type SelectionIntent } from '@ankhorage/utility/s
 
 import type { SelectionMode } from '../../../types/selection';
 
+type MatrixGridSelectionIntent = SelectionIntent | 'range';
+
 /*** Apply ZORA's canonical selection intent while retaining the configured selection mode. */
 export function resolveMatrixGridSelection(
+  cells: readonly MatrixGridSelectionCell[],
   selectedIds: readonly string[],
   cellId: string,
-  intent: SelectionIntent,
+  anchorId: string | null,
+  intent: MatrixGridSelectionIntent,
   mode: SelectionMode,
 ): readonly string[] {
-  return mode === 'single'
-    ? applySelectionIntent(selectedIds, cellId, 'replace')
-    : applySelectionIntent(selectedIds, cellId, intent);
+  if (mode === 'single') return applySelectionIntent(selectedIds, cellId, 'replace');
+  if (intent !== 'range') return applySelectionIntent(selectedIds, cellId, intent);
+
+  const anchor = cells.find((cell) => cell.id === anchorId);
+  const target = cells.find((cell) => cell.id === cellId);
+  if (!anchor || !target) return applySelectionIntent(selectedIds, cellId, 'replace');
+
+  return cells
+    .filter(
+      (cell) =>
+        cell.rowIndex >= Math.min(anchor.rowIndex, target.rowIndex) &&
+        cell.rowIndex <= Math.max(anchor.rowIndex, target.rowIndex) &&
+        cell.columnIndex >= Math.min(anchor.columnIndex, target.columnIndex) &&
+        cell.columnIndex <= Math.max(anchor.columnIndex, target.columnIndex),
+    )
+    .map((cell) => cell.id);
 }
+
+type MatrixGridSelectionCell = Readonly<{
+  columnIndex: number;
+  id: string;
+  rowIndex: number;
+}>;

package/src/features/registry/ZORA_COMPONENT_REGISTRY.ts

@@ -47,6 +47,7 @@ import {
   GameOverlay,
 } from '../game/public';
 import { Gradient } from '../gradient/public';
+import { GridInteractions } from '../grid-interactions/public';
 import { GridLineOverlay, GridRuler } from '../grid-rulers/public';
 import { GridView, TileGrid } from '../grid-view/public';
 import { Hero } from '../hero/public';
@@ -200,6 +201,7 @@ const _ZORA_COMPONENT_REGISTRY = {
   FileExplorer,
   GridLineOverlay,
   GridRuler,
+  GridInteractions,
   GridView,
   TileGrid,
   TimeGrid,

package/src/features/registry/componentMeta.ts

@@ -53,6 +53,7 @@ import { gameMeasurementProbeMeta } from '../game/meta/gameMeasurementProbeMeta'
 import { gameMeta } from '../game/meta/gameMeta';
 import { gameOverlayMeta } from '../game/meta/gameOverlayMeta';
 import { gradientMeta } from '../gradient/gradientMeta';
+import { gridInteractionsMeta } from '../grid-interactions/meta';
 import { gridLineOverlayMeta, gridRulerMeta } from '../grid-rulers/meta';
 import { gridViewMeta, tileGridMeta } from '../grid-view/meta';
 import { heroMeta } from '../hero/heroMeta';
@@ -204,6 +205,7 @@ export const ZORA_COMPONENT_META: ZoraComponentMetaRegistry = finalizeFeatureMet
   MediaExplorer: mediaExplorerMeta,
   GridLineOverlay: gridLineOverlayMeta,
   GridRuler: gridRulerMeta,
+  GridInteractions: gridInteractionsMeta,
   GridView: gridViewMeta,
   TileGrid: tileGridMeta,
   TimeGrid: timeGridMeta,

package/src/features/registry/createEventCapabilities.ts

@@ -0,0 +1,108 @@
+import { areCapabilitiesEqual, isCapabilityId } from '@ankhorage/capability';
+import type { Capability } from '@ankhorage/contracts/capability';
+import type { DataSchema } from '@ankhorage/contracts/data';
+
+import type {
+  ZoraComponentEventMeta,
+  ZoraComponentEventPayloadFieldMeta,
+} from '../../types/authoring';
+import { ZORA_COMPONENT_META } from './componentMeta';
+
+/*** Projects direct-manifest ZORA event metadata into unique portable event capabilities. */
+export function createEventCapabilities(): readonly Capability[] {
+  const capabilitiesById = Object.values(ZORA_COMPONENT_META)
+    .filter((component) => component.directManifestNode)
+    .flatMap((component) => Object.values(component.events ?? {}))
+    .reduce<ReadonlyMap<Capability['id'], Capability>>(
+      (capabilities, event) => addEventCapability(capabilities, event),
+      new Map(),
+    );
+
+  return [...capabilitiesById.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+
+/*** Adds one namespaced metadata event while rejecting conflicting duplicate identities. */
+function addEventCapability(
+  capabilities: ReadonlyMap<Capability['id'], Capability>,
+  event: ZoraComponentEventMeta,
+): ReadonlyMap<Capability['id'], Capability> {
+  if (!isCapabilityId(event.eventType)) return capabilities;
+
+  const capability = createEventCapability(event);
+  const existing = capabilities.get(capability.id);
+  if (existing !== undefined && !areCapabilitiesEqual(existing, capability)) {
+    throw new Error(`ZORA event metadata defines conflicting capability "${capability.id}".`);
+  }
+
+  return new Map([...capabilities, [capability.id, capability]]);
+}
+
+/*** Converts one emitted component event into its serializable canonical descriptor. */
+function createEventCapability(event: ZoraComponentEventMeta): Capability {
+  if (!isCapabilityId(event.eventType)) {
+    throw new Error(
+      `ZORA event metadata must use a namespaced capability id: "${event.eventType}".`,
+    );
+  }
+
+  return {
+    id: event.eventType,
+    owner: '@ankhorage/zora',
+    access: ['emit'],
+    binding: { kind: 'event', bindableAs: ['source'] },
+    label: event.label,
+    ...(event.description === undefined ? {} : { description: event.description }),
+    output: { schema: createEventPayloadSchema(event.payloadFields ?? []) },
+  };
+}
+
+/*** Projects the documented event payload fields into an open object schema. */
+function createEventPayloadSchema(
+  fields: readonly ZoraComponentEventPayloadFieldMeta[],
+): DataSchema {
+  return {
+    type: 'object',
+    properties: fields.reduce<Readonly<Record<string, DataSchema>>>(addPayloadField, {}),
+  };
+}
+
+/*** Adds one dotted metadata path to an immutable object-schema property map. */
+function addPayloadField(
+  properties: Readonly<Record<string, DataSchema>>,
+  field: ZoraComponentEventPayloadFieldMeta,
+): Readonly<Record<string, DataSchema>> {
+  return addPayloadFieldAtPath(properties, field.path.split('.'), createPayloadFieldSchema(field));
+}
+
+/*** Recursively embeds a leaf schema below its documented object-property path. */
+function addPayloadFieldAtPath(
+  properties: Readonly<Record<string, DataSchema>>,
+  path: readonly string[],
+  schema: DataSchema,
+): Readonly<Record<string, DataSchema>> {
+  const [key, ...remainingPath] = path;
+  if (key === undefined || key === '') return properties;
+  if (remainingPath.length === 0) return { ...properties, [key]: schema };
+
+  const current = Object.entries(properties).find(([propertyKey]) => propertyKey === key)?.[1];
+  const nestedProperties = addPayloadFieldAtPath(current?.properties ?? {}, remainingPath, schema);
+  return {
+    ...properties,
+    [key]: { ...current, type: 'object', properties: nestedProperties },
+  };
+}
+
+/*** Maps one authoring payload-field type and annotations to its portable data schema. */
+function createPayloadFieldSchema(field: ZoraComponentEventPayloadFieldMeta): DataSchema {
+  return {
+    ...(field.type === 'object'
+      ? { type: 'object' as const }
+      : field.type === 'record'
+        ? { type: 'object' as const, additionalProperties: true }
+        : field.type === 'unknown'
+          ? {}
+          : { type: field.type }),
+    ...(field.label === undefined ? {} : { title: field.label }),
+    ...(field.description === undefined ? {} : { description: field.description }),
+  };
+}

package/src/index.ts

@@ -263,6 +263,17 @@ export type {
   GradientRendererProviderProps,
 } from './features/gradient/public';
 export { Gradient, GradientRendererProvider } from './features/gradient/public';
+export {
+  createGridInteractionsController,
+  type GridInteractionIntent,
+  type GridInteractionItem,
+  type GridInteractionPointer,
+  GridInteractions,
+  type GridInteractionsController,
+  type GridInteractionsControllerProps,
+  type GridInteractionSnap,
+  type GridInteractionsProps,
+} from './features/grid-interactions/public';
 export type {
   GridGuide,
   GridLineOverlayProps,

package/src/structureOwnership.test.ts

@@ -63,4 +63,9 @@ describe('src ownership', () => {
       expect(existsSync(path), path).toBe(false);
     }
   });
+
+  test('keeps event capability projection with the registry metadata owner', () => {
+    expect(existsSync('src/features/registry/createEventCapabilities.ts')).toBe(true);
+    expect(existsSync('src/capabilities/createEventCapabilities.ts')).toBe(false);
+  });
 });