@realitycollective/webxr-uiextensions 0.1.0-preview.2 → 0.1.0-preview.3

package/CHANGELOG.md

@@ -19,6 +19,7 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - `PanelReadyEvent.kind`, either `window` or `panel`. `window` means the panel came from the adapter's window factory and is managed by the window manager. `panel` means a bare panel the adapter noticed, whose `id` is then the adapter's best stable identifier for it - the config path on IWSDK. The field is optional, so existing listeners keep compiling.
 - `createWindow` on the IWSDK scene host, returning an `IwsdkWindowHandle`: a `WindowHandle` plus the ECS `entity`. It spawns through `createUIWindow`, names the window `uix-window-<n>` when no id is given, and resolves `panel` and `onReady` once the document attaches, so wiring one window needs neither an ECS query nor a filtered `onPanelReady`. `createUIWindow` is unchanged and still returns the entity.
 - `getPanelHandle(entity)` in `@realitycollective/iwsdk-uiextensions`: the panel handle for an entity you already hold, or `undefined` while IWSDK is still loading its document.
+- `windowHostContractCases()` in `@realitycollective/webxr-uiextensions`, with `WindowHostContractCase` and `WindowHostContractSetup` - the `WindowHost` conformance suite as data rather than as tests. Each case is a `name` plus a `run(setup)` that throws an `Error` on failure, so an adapter runs the suite in its own test runner and needs nothing from this repository's `test/` folder. It was previously an in-repo vitest helper that only the two shipped adapters could reach, which left an adapter author outside this repository with no way to prove conformance. Both adapters now run the shipped cases through a three-line wrapper.
 
 ### Changed
 
@@ -34,5 +35,6 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - `id` is optional in the XR Blocks host's `CreateWindowOptions`; a window created without one is named `uix-window-<n>`, as on IWSDK. The options also accept `movable` for parity, but this host has no title-bar drag of its own yet, so the flag is recorded and not acted on.
 - The XR Blocks window handle gains `panel` - the document, which already implements `PanelHandle` - and `onReady`, which fires synchronously because uikitml interprets the markup during `createWindow`. The interface is now named `XrBlocksWindowHandle`, with `WindowHandle` kept as an alias, because the core exports a `WindowHandle` of its own.
 - Coverage gates `packages/iwsdk-uiextensions/src/factory.ts` and `src/scene-host.ts` at the same 100% as the core. `new World()` from `@iwsdk/core` constructs headlessly - no renderer, no WebGL, no XR session - so the factories, the scene host and its ECS query all run for real in a node test. The per-frame ECS systems still need a live world and stay outside the gate.
+- `@realitycollective/webxr-uiextensions` takes its geometry vocabulary from `@realitycollective/webxr-input` at `^0.1.1` rather than redeclaring it. `Vec3Tuple`, `QuatTuple`, `HeadPose`, `HeadPoseSource` and `PointerSample` are now that package's types, re-exported under the same names, so no import changes for a consumer. `PointerSample` is its `RayTuple`, which is what lets an input provider written against the shared contracts feed this contract unchanged. It is the core's only runtime dependency: the contracts package is engine-free and carries none of its own, and `test/architecture.test.ts` now allows exactly that one name and fails on any other.
 
 [0.1.0]: https://github.com/realitycollective/WebXR-UIExtensions/commits/main

package/README.md

@@ -10,7 +10,9 @@ The core of the Reality Collective UI Extensions. It provides:
 - **Markup upgrading** - code that turns a plain element carrying a `data-uix` attribute into a working control, so you write markup rather than components.
 - **Adapter interfaces** - what an engine package must implement to host all of the above.
 
-**This package has zero runtime dependencies and imports no 3D engine.** A test, `test/architecture.test.ts`, fails the moment `three`, `@iwsdk/*`, `@pmndrs/*` or `xrblocks` appears anywhere in `src/`. That is what lets the same interface run unchanged on every three.js WebXR runtime.
+**This package imports no 3D engine.** A test, `test/architecture.test.ts`, fails the moment `three`, `@iwsdk/*`, `@pmndrs/*` or `xrblocks` appears anywhere in `src/`. That is what lets the same interface run unchanged on every three.js WebXR runtime.
+
+It carries exactly one runtime dependency, [`@realitycollective/webxr-input`](https://www.npmjs.com/package/@realitycollective/webxr-input), and the same test fails on any other. That package is the shared contracts vocabulary: plain tuples and records, no engine imports and no dependencies of its own. `Vec3Tuple`, `QuatTuple`, `HeadPose`, `HeadPoseSource` and `PointerSample` come from there rather than being redeclared here, so a pose or a ray means the same thing to the Interactions family and to this one, and one input stack drives both. All five are re-exported from this package, so importing them from here keeps working.
 
 ## You probably want an adapter, not this package
 
@@ -34,6 +36,9 @@ src/chrome/     window chrome conventions: contractual element ids
 src/adapter.ts  the platform-adapter contract: PanelHost, PanelHandle,
                 WindowHost, WindowHandle, WindowOptionsBase, HeadPoseSource,
                 PointerInputSource (plain tuples, no engine)
+src/contract-cases.ts
+                windowHostContractCases() - the WindowHost conformance suite
+                as data, for an adapter to run in its own test runner
 ```
 
 ## Writing an adapter
@@ -44,7 +49,7 @@ An adapter supplies three capabilities and drives the core from its frame loop:
 2. **Input** - deliver press/move/release into the core's `HoldToDrag` + drag math, or wire chrome clicks straight to `WindowManager`.
 3. **Viewer pose** - implement `HeadPoseSource` for follow mode and body-locked regions.
 
-The IWSDK adapter is the reference implementation; the XR Blocks adapter shows the same contract bound without an ECS.
+The IWSDK adapter is the reference implementation; the XR Blocks adapter shows the same contract bound without an ECS. When yours runs, prove it with the shipped conformance suite below.
 
 ### The window surface
 
@@ -58,6 +63,35 @@ The IWSDK adapter is the reference implementation; the XR Blocks adapter shows t
 
 Options are shared even though `createWindow` is not: every adapter's option type extends `WindowOptionsBase` (`id`, `title`, `dockMode`, `position`, `maxWidth`/`maxHeight`, `movable`, `closable`, `minimizable`, `pinnable`, `followOffset`/`followSpeed`/`followTolerance`, `region`). An option means the same thing everywhere, so one `SceneWindow` maps onto every adapter with no translation table.
 
+### Proving a new adapter conforms
+
+`windowHostContractCases()` is the `WindowHost` conformance suite, shipped as data rather than as tests. Each case is a `name` plus a `run(setup)` that returns silently on success and throws an `Error` describing the failure otherwise, so an adapter runs them in whatever test runner it already has. It ships runner-free because an adapter written outside this repository cannot reach into this one's `test/` folder, and because no adapter should have to install this repo's runner to prove itself.
+
+An adapter's test file is a loop:
+
+```ts
+import { windowHostContractCases } from '@realitycollective/webxr-uiextensions';
+import type { WindowHostContractSetup } from '@realitycollective/webxr-uiextensions';
+
+function makeSetup(): WindowHostContractSetup {
+  const host = createMyHost();
+  return {
+    host,
+    createWindow: (id) => host.createWindow({ id, config: myConfig() }),
+    // Only where the panel arrives after the window does:
+    attach: (id) => deliverThePanelFor(id),
+    // Only where supportsStandalonePanels is true:
+    panelConfig: myConfig(),
+  };
+}
+
+for (const contractCase of windowHostContractCases()) {
+  it(contractCase.name, () => contractCase.run(makeSetup()));
+}
+```
+
+`makeSetup()` runs once per case, because the cases spawn windows of their own and do not clean up after themselves. `attach` and `panelConfig` are both optional: leave `attach` out when a window's panel exists as soon as the window does, and `panelConfig` out when the host reports `supportsStandalonePanels: false`. Both shipped adapters run this suite, so a case failing on yours is a real difference in behaviour, not a difference in test style.
+
 ## Testing
 
 ```bash

package/dist/adapter.d.ts

@@ -25,23 +25,27 @@
  *  - `@realitycollective/xrblocks-uiextensions` - Google XR Blocks / plain
  *    three.js (experimental)
  *
- * The interfaces use plain tuples/records only - no engine, no three.js.
+ * The interfaces use plain tuples/records only - no engine, no three.js. The
+ * geometry vocabulary itself comes from `@realitycollective/webxr-input`, the
+ * engine-free contracts package both extension families share, so a pose or a
+ * ray means the same thing to Interactions and to UI Extensions and one input
+ * stack drives both. The names below are re-exported, so importing them from
+ * this package keeps working.
  */
+import type { RayTuple, Vec3Tuple } from '@realitycollective/webxr-input';
 import type { DockModeValue } from './core/dock-state.js';
 import type { UixElement } from './controls/element.js';
-/** Position as [x, y, z] in meters, world space unless stated otherwise. */
-export type Vec3Tuple = [number, number, number];
-/** Orientation quaternion as [x, y, z, w]. */
-export type QuatTuple = [number, number, number, number];
-/** A viewer (head) pose sample. */
-export interface HeadPose {
-    position: Vec3Tuple;
-    quaternion: QuatTuple;
-}
-/** Supplies the viewer pose each frame - camera on desktop, HMD in XR. */
-export interface HeadPoseSource {
-    getHeadPose(): HeadPose;
-}
+/**
+ * The shared geometry vocabulary, re-exported so this package stays the one
+ * import an adapter needs:
+ *
+ *  - `Vec3Tuple` - position as [x, y, z] in meters, world space unless stated
+ *  - `QuatTuple` - orientation quaternion as [x, y, z, w]
+ *  - `HeadPose` - a viewer (head) pose sample
+ *  - `HeadPoseSource` - supplies that pose each frame, camera on desktop and
+ *    HMD in XR
+ */
+export type { HeadPose, HeadPoseSource, QuatTuple, Vec3Tuple, } from '@realitycollective/webxr-input';
 /**
  * A live spatial panel created from compiled UIKitML JSON.
  * The `root` is traversable with the core's `walk`/`findRole` helpers and
@@ -170,13 +174,13 @@ export interface WindowOptionsBase {
     /** Dock straight into this region on spawn. */
     region?: string;
 }
-/** One pointer/ray interaction stream, engine-normalised. */
-export interface PointerSample {
-    /** Pointer world position (ray origin or touch point). */
-    origin: Vec3Tuple;
-    /** Normalised pointing direction. */
-    direction: Vec3Tuple;
-}
+/**
+ * One pointer/ray interaction stream, engine-normalised: a world-space
+ * `origin` (ray origin or touch point) and a normalised `direction`. It is
+ * the Input package's `RayTuple`, which is what lets a provider written
+ * against `@realitycollective/webxr-input` feed this contract unchanged.
+ */
+export type PointerSample = RayTuple;
 /**
  * Delivers press-move-release for one interaction source (a controller ray,
  * a hand pinch, a mouse). The core's `hold-to-drag` and `drag-math` consume

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Platform-adapter contract.\n *\n * The core package owns every UX decision - window lifecycle, dock state,\n * region slot math, drag math, control models - and knows nothing about any\n * engine. An engine adapter supplies the three capabilities the core cannot\n * provide for itself, and drives the core from its own frame loop:\n *\n *  - {@link PanelHost}: turn compiled UIKitML JSON into a live spatial panel\n *  - {@link PointerInputSource}: deliver ray/pointer press-move-release\n *  - {@link HeadPoseSource}: the viewer pose, for follow mode & body-lock\n *\n * On top of those, {@link WindowHost} adds the portable window surface:\n * {@link WindowHost.onPanelReady} for readiness, {@link PanelReadyEvent.kind}\n * to tell a managed window from a bare panel, and\n * {@link WindowHost.supportsStandalonePanels} to say whether `createPanel` is\n * usable at all. Each adapter's own `createWindow` returns a\n * {@link WindowHandle} and takes options extending {@link WindowOptionsBase},\n * so window code reads the same on every engine even though the `config`\n * payload does not.\n *\n * Known adapters:\n *  - `@realitycollective/iwsdk-uiextensions` - Meta IWSDK (ECS systems bind\n *    these capabilities to `@iwsdk/core` components)\n *  - `@realitycollective/xrblocks-uiextensions` - Google XR Blocks / plain\n *    three.js (experimental)\n *\n * The interfaces use plain tuples/records only - no engine, no three.js.\n */\nimport type { DockModeValue } from './core/dock-state.js';\nimport type { UixElement } from './controls/element.js';\n\n/** Position as [x, y, z] in meters, world space unless stated otherwise. */\nexport type Vec3Tuple = [number, number, number];\n\n/** Orientation quaternion as [x, y, z, w]. */\nexport type QuatTuple = [number, number, number, number];\n\n/** A viewer (head) pose sample. */\nexport interface HeadPose {\n  position: Vec3Tuple;\n  quaternion: QuatTuple;\n}\n\n/** Supplies the viewer pose each frame - camera on desktop, HMD in XR. */\nexport interface HeadPoseSource {\n  getHeadPose(): HeadPose;\n}\n\n/**\n * A live spatial panel created from compiled UIKitML JSON.\n * The `root` is traversable with the core's `walk`/`findRole` helpers and\n * the `data-uix` control upgraders - identical markup works on every\n * adapter.\n */\nexport interface PanelHandle {\n  /** Root element of the interpreted panel (UixElement-conformant). */\n  readonly root: UixElement;\n  /** Look up an element by its markup `id`. */\n  getElementById(id: string): UixElement | undefined;\n  /** Constrain the panel to fit within width × height meters. */\n  setTargetDimensions(width: number, height: number): void;\n  /** Release panel resources. */\n  dispose(): void;\n}\n\n/** Creates spatial panels - the engine-specific half of UIKitML rendering. */\nexport interface PanelHost {\n  /**\n   * Create a panel from compiled UIKitML JSON (the `{ element, classes }`\n   * shape produced by the build plugin or by\n   * `@realitycollective/uix-devtools`' `compilePanelSource`).\n   */\n  createPanel(configJson: unknown): PanelHandle;\n}\n\n/**\n * A window whose panel has finished loading and is ready to be wired.\n * Delivered by {@link WindowHost.onPanelReady}.\n */\nexport interface PanelReadyEvent {\n  /** The window's id, as given to the scene descriptor / create call. */\n  id: string;\n  /** The live panel - traverse it, or look elements up by markup id. */\n  panel: PanelHandle;\n  /**\n   * What became ready.\n   *\n   * - `window` - created through the adapter's window factory and managed by\n   *   the window manager, so `id` is the id the caller asked for.\n   * - `panel` - a bare panel the adapter noticed. `id` is then the adapter's\n   *   best stable identifier for it, which on IWSDK is the panel's config\n   *   path.\n   *\n   * Left optional so existing listeners keep compiling; adapters set it.\n   */\n  kind?: 'window' | 'panel';\n}\n\n/**\n * The engine-agnostic surface an app needs to build a UI: spawn windows and\n * regions from portable data, observe when panels become wireable, and reach\n * the shared `WindowManager`.\n *\n * Panels load asynchronously on every adapter (IWSDK fetches the config;\n * uikit lays out over following frames), so app code must never assume a\n * panel exists immediately after creating its window. {@link onPanelReady}\n * is the portable answer - it replaces engine-specific discovery (ECS\n * queries on IWSDK, polling anywhere else) and fires for panels that became\n * ready before the listener was registered, so wiring order never matters.\n */\nexport interface WindowHost extends PanelHost {\n  /**\n   * Whether {@link PanelHost.createPanel} works on this host. When `false`\n   * the method is not available and throws; spawn a window instead, so the\n   * engine owns the panel lifecycle. IWSDK is `false`, three.js/XR Blocks is\n   * `true`.\n   */\n  readonly supportsStandalonePanels: boolean;\n  /**\n   * Subscribe to panel readiness. Late subscribers are replayed the windows\n   * that are already live. Returns an unsubscribe function.\n   */\n  onPanelReady(listener: (event: PanelReadyEvent) => void): () => void;\n}\n\n/**\n * A window an adapter spawned, before its panel necessarily exists.\n *\n * `createWindow` itself stays adapter-specific because the `config` payload\n * differs per engine, but what it hands back is the same everywhere: an id, a\n * panel once there is one, and a one-shot readiness callback.\n */\nexport interface WindowHandle {\n  /** The window's id - the one passed in, or one the adapter generated. */\n  readonly id: string;\n  /**\n   * The live panel, or `undefined` until the adapter has attached the\n   * document. IWSDK loads and parses the markup over later frames; the\n   * three.js host interprets it during `createWindow`, so there it is set\n   * straight away.\n   */\n  readonly panel: PanelHandle | undefined;\n  /**\n   * Run `listener` once, when the panel is attached. Fires immediately if it\n   * already is, so wiring order never matters. Returns an unsubscribe\n   * function for the case where the caller gives up first.\n   */\n  onReady(listener: (panel: PanelHandle) => void): () => void;\n}\n\n/**\n * The window options every adapter understands.\n *\n * An adapter's own `CreateWindowOptions` extends this and adds only what its\n * engine needs - chiefly `config`, whose type differs (IWSDK takes a source\n * path, the three.js host takes parsed markup). Keeping the rest here is what\n * lets one `SceneWindow` map onto every adapter without a translation table.\n */\nexport interface WindowOptionsBase {\n  /** Stable window id. Adapters generate one when it is absent. */\n  id?: string;\n  /** Title text written into the window chrome's title element. */\n  title?: string;\n  dockMode?: DockModeValue;\n  /** World position for world-locked windows. */\n  position?: Vec3Tuple;\n  /** Fit the panel into this box in meters, preserving aspect ratio. */\n  maxWidth?: number;\n  maxHeight?: number;\n  /** Whether the title bar drags the window. */\n  movable?: boolean;\n  closable?: boolean;\n  minimizable?: boolean;\n  pinnable?: boolean;\n  /** Head-relative offset used in body-follow mode (meters). */\n  followOffset?: Vec3Tuple;\n  followSpeed?: number;\n  followTolerance?: number;\n  /** Dock straight into this region on spawn. */\n  region?: string;\n}\n\n/** One pointer/ray interaction stream, engine-normalised. */\nexport interface PointerSample {\n  /** Pointer world position (ray origin or touch point). */\n  origin: Vec3Tuple;\n  /** Normalised pointing direction. */\n  direction: Vec3Tuple;\n}\n\n/**\n * Delivers press-move-release for one interaction source (a controller ray,\n * a hand pinch, a mouse). The core's `hold-to-drag` and `drag-math` consume\n * these; the adapter decides what constitutes press/release.\n */\nexport interface PointerInputSource {\n  onPress(listener: (sample: PointerSample) => void): () => void;\n  onMove(listener: (sample: PointerSample) => void): () => void;\n  onRelease(listener: (sample: PointerSample) => void): () => void;\n}\n"]}
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Platform-adapter contract.\n *\n * The core package owns every UX decision - window lifecycle, dock state,\n * region slot math, drag math, control models - and knows nothing about any\n * engine. An engine adapter supplies the three capabilities the core cannot\n * provide for itself, and drives the core from its own frame loop:\n *\n *  - {@link PanelHost}: turn compiled UIKitML JSON into a live spatial panel\n *  - {@link PointerInputSource}: deliver ray/pointer press-move-release\n *  - {@link HeadPoseSource}: the viewer pose, for follow mode & body-lock\n *\n * On top of those, {@link WindowHost} adds the portable window surface:\n * {@link WindowHost.onPanelReady} for readiness, {@link PanelReadyEvent.kind}\n * to tell a managed window from a bare panel, and\n * {@link WindowHost.supportsStandalonePanels} to say whether `createPanel` is\n * usable at all. Each adapter's own `createWindow` returns a\n * {@link WindowHandle} and takes options extending {@link WindowOptionsBase},\n * so window code reads the same on every engine even though the `config`\n * payload does not.\n *\n * Known adapters:\n *  - `@realitycollective/iwsdk-uiextensions` - Meta IWSDK (ECS systems bind\n *    these capabilities to `@iwsdk/core` components)\n *  - `@realitycollective/xrblocks-uiextensions` - Google XR Blocks / plain\n *    three.js (experimental)\n *\n * The interfaces use plain tuples/records only - no engine, no three.js. The\n * geometry vocabulary itself comes from `@realitycollective/webxr-input`, the\n * engine-free contracts package both extension families share, so a pose or a\n * ray means the same thing to Interactions and to UI Extensions and one input\n * stack drives both. The names below are re-exported, so importing them from\n * this package keeps working.\n */\nimport type { RayTuple, Vec3Tuple } from '@realitycollective/webxr-input';\nimport type { DockModeValue } from './core/dock-state.js';\nimport type { UixElement } from './controls/element.js';\n\n/**\n * The shared geometry vocabulary, re-exported so this package stays the one\n * import an adapter needs:\n *\n *  - `Vec3Tuple` - position as [x, y, z] in meters, world space unless stated\n *  - `QuatTuple` - orientation quaternion as [x, y, z, w]\n *  - `HeadPose` - a viewer (head) pose sample\n *  - `HeadPoseSource` - supplies that pose each frame, camera on desktop and\n *    HMD in XR\n */\nexport type {\n  HeadPose,\n  HeadPoseSource,\n  QuatTuple,\n  Vec3Tuple,\n} from '@realitycollective/webxr-input';\n\n/**\n * A live spatial panel created from compiled UIKitML JSON.\n * The `root` is traversable with the core's `walk`/`findRole` helpers and\n * the `data-uix` control upgraders - identical markup works on every\n * adapter.\n */\nexport interface PanelHandle {\n  /** Root element of the interpreted panel (UixElement-conformant). */\n  readonly root: UixElement;\n  /** Look up an element by its markup `id`. */\n  getElementById(id: string): UixElement | undefined;\n  /** Constrain the panel to fit within width × height meters. */\n  setTargetDimensions(width: number, height: number): void;\n  /** Release panel resources. */\n  dispose(): void;\n}\n\n/** Creates spatial panels - the engine-specific half of UIKitML rendering. */\nexport interface PanelHost {\n  /**\n   * Create a panel from compiled UIKitML JSON (the `{ element, classes }`\n   * shape produced by the build plugin or by\n   * `@realitycollective/uix-devtools`' `compilePanelSource`).\n   */\n  createPanel(configJson: unknown): PanelHandle;\n}\n\n/**\n * A window whose panel has finished loading and is ready to be wired.\n * Delivered by {@link WindowHost.onPanelReady}.\n */\nexport interface PanelReadyEvent {\n  /** The window's id, as given to the scene descriptor / create call. */\n  id: string;\n  /** The live panel - traverse it, or look elements up by markup id. */\n  panel: PanelHandle;\n  /**\n   * What became ready.\n   *\n   * - `window` - created through the adapter's window factory and managed by\n   *   the window manager, so `id` is the id the caller asked for.\n   * - `panel` - a bare panel the adapter noticed. `id` is then the adapter's\n   *   best stable identifier for it, which on IWSDK is the panel's config\n   *   path.\n   *\n   * Left optional so existing listeners keep compiling; adapters set it.\n   */\n  kind?: 'window' | 'panel';\n}\n\n/**\n * The engine-agnostic surface an app needs to build a UI: spawn windows and\n * regions from portable data, observe when panels become wireable, and reach\n * the shared `WindowManager`.\n *\n * Panels load asynchronously on every adapter (IWSDK fetches the config;\n * uikit lays out over following frames), so app code must never assume a\n * panel exists immediately after creating its window. {@link onPanelReady}\n * is the portable answer - it replaces engine-specific discovery (ECS\n * queries on IWSDK, polling anywhere else) and fires for panels that became\n * ready before the listener was registered, so wiring order never matters.\n */\nexport interface WindowHost extends PanelHost {\n  /**\n   * Whether {@link PanelHost.createPanel} works on this host. When `false`\n   * the method is not available and throws; spawn a window instead, so the\n   * engine owns the panel lifecycle. IWSDK is `false`, three.js/XR Blocks is\n   * `true`.\n   */\n  readonly supportsStandalonePanels: boolean;\n  /**\n   * Subscribe to panel readiness. Late subscribers are replayed the windows\n   * that are already live. Returns an unsubscribe function.\n   */\n  onPanelReady(listener: (event: PanelReadyEvent) => void): () => void;\n}\n\n/**\n * A window an adapter spawned, before its panel necessarily exists.\n *\n * `createWindow` itself stays adapter-specific because the `config` payload\n * differs per engine, but what it hands back is the same everywhere: an id, a\n * panel once there is one, and a one-shot readiness callback.\n */\nexport interface WindowHandle {\n  /** The window's id - the one passed in, or one the adapter generated. */\n  readonly id: string;\n  /**\n   * The live panel, or `undefined` until the adapter has attached the\n   * document. IWSDK loads and parses the markup over later frames; the\n   * three.js host interprets it during `createWindow`, so there it is set\n   * straight away.\n   */\n  readonly panel: PanelHandle | undefined;\n  /**\n   * Run `listener` once, when the panel is attached. Fires immediately if it\n   * already is, so wiring order never matters. Returns an unsubscribe\n   * function for the case where the caller gives up first.\n   */\n  onReady(listener: (panel: PanelHandle) => void): () => void;\n}\n\n/**\n * The window options every adapter understands.\n *\n * An adapter's own `CreateWindowOptions` extends this and adds only what its\n * engine needs - chiefly `config`, whose type differs (IWSDK takes a source\n * path, the three.js host takes parsed markup). Keeping the rest here is what\n * lets one `SceneWindow` map onto every adapter without a translation table.\n */\nexport interface WindowOptionsBase {\n  /** Stable window id. Adapters generate one when it is absent. */\n  id?: string;\n  /** Title text written into the window chrome's title element. */\n  title?: string;\n  dockMode?: DockModeValue;\n  /** World position for world-locked windows. */\n  position?: Vec3Tuple;\n  /** Fit the panel into this box in meters, preserving aspect ratio. */\n  maxWidth?: number;\n  maxHeight?: number;\n  /** Whether the title bar drags the window. */\n  movable?: boolean;\n  closable?: boolean;\n  minimizable?: boolean;\n  pinnable?: boolean;\n  /** Head-relative offset used in body-follow mode (meters). */\n  followOffset?: Vec3Tuple;\n  followSpeed?: number;\n  followTolerance?: number;\n  /** Dock straight into this region on spawn. */\n  region?: string;\n}\n\n/**\n * One pointer/ray interaction stream, engine-normalised: a world-space\n * `origin` (ray origin or touch point) and a normalised `direction`. It is\n * the Input package's `RayTuple`, which is what lets a provider written\n * against `@realitycollective/webxr-input` feed this contract unchanged.\n */\nexport type PointerSample = RayTuple;\n\n/**\n * Delivers press-move-release for one interaction source (a controller ray,\n * a hand pinch, a mouse). The core's `hold-to-drag` and `drag-math` consume\n * these; the adapter decides what constitutes press/release.\n */\nexport interface PointerInputSource {\n  onPress(listener: (sample: PointerSample) => void): () => void;\n  onMove(listener: (sample: PointerSample) => void): () => void;\n  onRelease(listener: (sample: PointerSample) => void): () => void;\n}\n"]}

package/dist/contract-cases.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The shared `WindowHost` contract, shipped as data rather than as tests.
+ *
+ * Every adapter promises the same four things, whatever engine sits behind
+ * it: it says whether bare panels work and behaves accordingly,
+ * `createWindow` hands back a {@link WindowHandle}, `onReady` fires exactly
+ * once and replays for a late subscriber, and `onPanelReady` replays too.
+ * Running one suite from every adapter is what keeps those promises from
+ * drifting apart, and gives a new adapter a starting test for free.
+ *
+ * The suite is runner-free on purpose. Every adapter repository already has
+ * its own test runner, and an adapter written outside this repository cannot
+ * reach into this one's `test/` folder, so the checks ship as plain objects
+ * that throw an `Error` on failure and the adapter iterates them.
+ *
+ * `createWindow` itself is adapter-specific - IWSDK takes a config PATH, the
+ * three.js host takes parsed markup - so the caller supplies a
+ * {@link WindowHostContractSetup} that wraps those differences.
+ */
+import type { WindowHandle, WindowHost } from './adapter.js';
+/**
+ * Everything a case needs to drive one adapter. Build a FRESH one per case:
+ * cases spawn windows of their own and do not clean up after themselves.
+ */
+export interface WindowHostContractSetup {
+    /** The host under test. */
+    host: WindowHost;
+    /** Spawn one window with this id, using whatever config the adapter needs. */
+    createWindow(id: string): WindowHandle;
+    /**
+     * Attach the panel for a window, where the adapter attaches asynchronously.
+     * Omit it when the panel exists as soon as the window does.
+     */
+    attach?: (id: string) => void;
+    /** A config `createPanel` accepts, for hosts that support bare panels. */
+    panelConfig?: unknown;
+}
+/**
+ * One check a {@link WindowHost} implementation must pass. `run` returns
+ * silently on success and throws an `Error` describing the failure
+ * otherwise, so any test runner can host it.
+ */
+export interface WindowHostContractCase {
+    name: string;
+    run(setup: WindowHostContractSetup): void;
+}
+/**
+ * The shared host conformance suite. An adapter's test file is a loop:
+ *
+ * ```ts
+ * for (const contractCase of windowHostContractCases()) {
+ *   it(contractCase.name, () => contractCase.run(makeSetup()));
+ * }
+ * ```
+ *
+ * `makeSetup()` runs per case, so each case gets a host of its own.
+ */
+export declare function windowHostContractCases(): readonly WindowHostContractCase[];

package/dist/contract-cases.js

@@ -0,0 +1,100 @@
+/**
+ * The shared host conformance suite. An adapter's test file is a loop:
+ *
+ * ```ts
+ * for (const contractCase of windowHostContractCases()) {
+ *   it(contractCase.name, () => contractCase.run(makeSetup()));
+ * }
+ * ```
+ *
+ * `makeSetup()` runs per case, so each case gets a host of its own.
+ */
+export function windowHostContractCases() {
+    return CASES;
+}
+const CASES = [
+    {
+        name: 'reports whether bare panels work, and createPanel agrees',
+        run(setup) {
+            const supported = setup.host.supportsStandalonePanels;
+            assert(typeof supported === 'boolean', `supportsStandalonePanels must be a boolean, got ${typeof supported}`);
+            if (supported) {
+                try {
+                    setup.host.createPanel(setup.panelConfig);
+                }
+                catch (error) {
+                    throw new Error(`supportsStandalonePanels is true, so createPanel() must work, it threw: ${String(error)}`);
+                }
+                return;
+            }
+            assert(threw(() => setup.host.createPanel(setup.panelConfig)), 'supportsStandalonePanels is false, so createPanel() must throw rather than return an unusable panel');
+        },
+    },
+    {
+        name: 'createWindow returns a handle with an id and onReady',
+        run(setup) {
+            const handle = setup.createWindow('contract-a');
+            assert(typeof handle.id === 'string', `WindowHandle.id must be a string, got ${typeof handle.id}`);
+            assert(handle.id === 'contract-a', `createWindow("contract-a") must keep the id it was given, got "${handle.id}"`);
+            assert(typeof handle.onReady === 'function', 'a WindowHandle must implement onReady()');
+        },
+    },
+    {
+        name: 'onReady fires once when the panel attaches',
+        run(setup) {
+            const handle = setup.createWindow('contract-b');
+            const seen = [];
+            handle.onReady((panel) => seen.push(panel));
+            setup.attach?.('contract-b');
+            assert(seen.length === 1, `onReady must fire exactly once when the panel attaches, it fired ${String(seen.length)} time(s)`);
+            assert(handle.panel === seen[0], 'the panel passed to onReady must be the same one the handle reports');
+        },
+    },
+    {
+        name: 'onReady replays for a subscriber that arrives late',
+        run(setup) {
+            const handle = setup.createWindow('contract-c');
+            setup.attach?.('contract-c');
+            const seen = [];
+            const stop = handle.onReady((panel) => seen.push(panel));
+            assert(seen.length === 1, `onReady must replay for a subscriber that arrives after the panel, it fired ${String(seen.length)} time(s)`);
+            // Unsubscribing after the fact is a no-op, not an error.
+            detach(stop, 'onReady');
+            assert(seen.length === 1, 'unsubscribing after onReady has replayed must not deliver the panel again');
+        },
+    },
+    {
+        name: 'onPanelReady replays for a subscriber that arrives late',
+        run(setup) {
+            setup.createWindow('contract-d');
+            setup.attach?.('contract-d');
+            const ids = [];
+            const stop = setup.host.onPanelReady((event) => ids.push(event.id));
+            assert(ids.includes('contract-d'), `onPanelReady must replay the windows already live, expected "contract-d" among [${ids.join(', ')}]`);
+            detach(stop, 'onPanelReady');
+        },
+    },
+];
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+/** Whether `run` threw, without caring what it threw. */
+function threw(run) {
+    try {
+        run();
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function detach(stop, label) {
+    try {
+        stop();
+    }
+    catch (error) {
+        throw new Error(`the unsubscribe returned by ${label}() threw: ${String(error)}`);
+    }
+}
+//# sourceMappingURL=contract-cases.js.map

package/dist/contract-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-cases.js","sourceRoot":"","sources":["../src/contract-cases.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The shared `WindowHost` contract, shipped as data rather than as tests.\n *\n * Every adapter promises the same four things, whatever engine sits behind\n * it: it says whether bare panels work and behaves accordingly,\n * `createWindow` hands back a {@link WindowHandle}, `onReady` fires exactly\n * once and replays for a late subscriber, and `onPanelReady` replays too.\n * Running one suite from every adapter is what keeps those promises from\n * drifting apart, and gives a new adapter a starting test for free.\n *\n * The suite is runner-free on purpose. Every adapter repository already has\n * its own test runner, and an adapter written outside this repository cannot\n * reach into this one's `test/` folder, so the checks ship as plain objects\n * that throw an `Error` on failure and the adapter iterates them.\n *\n * `createWindow` itself is adapter-specific - IWSDK takes a config PATH, the\n * three.js host takes parsed markup - so the caller supplies a\n * {@link WindowHostContractSetup} that wraps those differences.\n */\nimport type { PanelHandle, WindowHandle, WindowHost } from './adapter.js';\n\n/**\n * Everything a case needs to drive one adapter. Build a FRESH one per case:\n * cases spawn windows of their own and do not clean up after themselves.\n */\nexport interface WindowHostContractSetup {\n  /** The host under test. */\n  host: WindowHost;\n  /** Spawn one window with this id, using whatever config the adapter needs. */\n  createWindow(id: string): WindowHandle;\n  /**\n   * Attach the panel for a window, where the adapter attaches asynchronously.\n   * Omit it when the panel exists as soon as the window does.\n   */\n  attach?: (id: string) => void;\n  /** A config `createPanel` accepts, for hosts that support bare panels. */\n  panelConfig?: unknown;\n}\n\n/**\n * One check a {@link WindowHost} implementation must pass. `run` returns\n * silently on success and throws an `Error` describing the failure\n * otherwise, so any test runner can host it.\n */\nexport interface WindowHostContractCase {\n  name: string;\n  run(setup: WindowHostContractSetup): void;\n}\n\n/**\n * The shared host conformance suite. An adapter's test file is a loop:\n *\n * ```ts\n * for (const contractCase of windowHostContractCases()) {\n *   it(contractCase.name, () => contractCase.run(makeSetup()));\n * }\n * ```\n *\n * `makeSetup()` runs per case, so each case gets a host of its own.\n */\nexport function windowHostContractCases(): readonly WindowHostContractCase[] {\n  return CASES;\n}\n\nconst CASES: readonly WindowHostContractCase[] = [\n  {\n    name: 'reports whether bare panels work, and createPanel agrees',\n    run(setup) {\n      const supported = setup.host.supportsStandalonePanels;\n      assert(\n        typeof supported === 'boolean',\n        `supportsStandalonePanels must be a boolean, got ${typeof supported}`,\n      );\n      if (supported) {\n        try {\n          setup.host.createPanel(setup.panelConfig);\n        } catch (error) {\n          throw new Error(\n            `supportsStandalonePanels is true, so createPanel() must work, it threw: ${String(error)}`,\n          );\n        }\n        return;\n      }\n      assert(\n        threw(() => setup.host.createPanel(setup.panelConfig)),\n        'supportsStandalonePanels is false, so createPanel() must throw rather than return an unusable panel',\n      );\n    },\n  },\n  {\n    name: 'createWindow returns a handle with an id and onReady',\n    run(setup) {\n      const handle = setup.createWindow('contract-a');\n      assert(\n        typeof handle.id === 'string',\n        `WindowHandle.id must be a string, got ${typeof handle.id}`,\n      );\n      assert(\n        handle.id === 'contract-a',\n        `createWindow(\"contract-a\") must keep the id it was given, got \"${handle.id}\"`,\n      );\n      assert(\n        typeof handle.onReady === 'function',\n        'a WindowHandle must implement onReady()',\n      );\n    },\n  },\n  {\n    name: 'onReady fires once when the panel attaches',\n    run(setup) {\n      const handle = setup.createWindow('contract-b');\n      const seen: PanelHandle[] = [];\n      handle.onReady((panel) => seen.push(panel));\n      setup.attach?.('contract-b');\n      assert(\n        seen.length === 1,\n        `onReady must fire exactly once when the panel attaches, it fired ${String(seen.length)} time(s)`,\n      );\n      assert(\n        handle.panel === seen[0],\n        'the panel passed to onReady must be the same one the handle reports',\n      );\n    },\n  },\n  {\n    name: 'onReady replays for a subscriber that arrives late',\n    run(setup) {\n      const handle = setup.createWindow('contract-c');\n      setup.attach?.('contract-c');\n      const seen: PanelHandle[] = [];\n      const stop = handle.onReady((panel) => seen.push(panel));\n      assert(\n        seen.length === 1,\n        `onReady must replay for a subscriber that arrives after the panel, it fired ${String(seen.length)} time(s)`,\n      );\n      // Unsubscribing after the fact is a no-op, not an error.\n      detach(stop, 'onReady');\n      assert(\n        seen.length === 1,\n        'unsubscribing after onReady has replayed must not deliver the panel again',\n      );\n    },\n  },\n  {\n    name: 'onPanelReady replays for a subscriber that arrives late',\n    run(setup) {\n      setup.createWindow('contract-d');\n      setup.attach?.('contract-d');\n      const ids: string[] = [];\n      const stop = setup.host.onPanelReady((event) => ids.push(event.id));\n      assert(\n        ids.includes('contract-d'),\n        `onPanelReady must replay the windows already live, expected \"contract-d\" among [${ids.join(', ')}]`,\n      );\n      detach(stop, 'onPanelReady');\n    },\n  },\n];\n\nfunction assert(condition: boolean, message: string): void {\n  if (!condition) throw new Error(message);\n}\n\n/** Whether `run` threw, without caring what it threw. */\nfunction threw(run: () => unknown): boolean {\n  try {\n    run();\n    return false;\n  } catch {\n    return true;\n  }\n}\n\nfunction detach(stop: () => void, label: string): void {\n  try {\n    stop();\n  } catch (error) {\n    throw new Error(\n      `the unsubscribe returned by ${label}() threw: ${String(error)}`,\n    );\n  }\n}\n"]}

package/dist/index.d.ts

@@ -27,3 +27,4 @@ export * from './controls/log-view.js';
 export * from './controls/upgrade.js';
 export * from './adapter.js';
 export * from './scene.js';
+export * from './contract-cases.js';

package/dist/index.js

@@ -31,4 +31,6 @@ export * from './controls/upgrade.js';
 // Platform-adapter contract + portable scene descriptors
 export * from './adapter.js';
 export * from './scene.js';
+// The WindowHost conformance suite, as data an adapter runs in its own runner
+export * from './contract-cases.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,aAAa;AACb,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AAEpC,sDAAsD;AACtD,cAAc,oBAAoB,CAAC;AAEnC,qCAAqC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAEtC,yDAAyD;AACzD,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC","sourcesContent":["/**\n * @realitycollective/webxr-uiextensions - the engine-free core.\n *\n * Everything exported here is pure TypeScript with no engine imports\n * (enforced by test/architecture.test.ts): window/dock/region/drag logic,\n * control models, the `data-uix` markup upgraders, the window chrome\n * conventions, and the platform-adapter interfaces engine packages\n * implement.\n */\n// Pure logic\nexport * from './core/events.js';\nexport * from './core/dock-state.js';\nexport * from './core/window-manager.js';\nexport * from './core/region-layout.js';\nexport * from './core/region-registry.js';\nexport * from './core/drag-math.js';\nexport * from './core/hold-to-drag.js';\nexport * from './core/stepper-model.js';\nexport * from './core/toggle-model.js';\nexport * from './core/expandable-model.js';\nexport * from './core/log-model.js';\n\n// Chrome conventions (markup ids + reference snippet)\nexport * from './chrome/markup.js';\n\n// Interface-driven control upgraders\nexport * from './controls/element.js';\nexport * from './controls/stepper.js';\nexport * from './controls/toggle.js';\nexport * from './controls/expandable-label.js';\nexport * from './controls/log-view.js';\nexport * from './controls/upgrade.js';\n\n// Platform-adapter contract + portable scene descriptors\nexport * from './adapter.js';\nexport * from './scene.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,aAAa;AACb,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AAEpC,sDAAsD;AACtD,cAAc,oBAAoB,CAAC;AAEnC,qCAAqC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAEtC,yDAAyD;AACzD,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAE3B,8EAA8E;AAC9E,cAAc,qBAAqB,CAAC","sourcesContent":["/**\n * @realitycollective/webxr-uiextensions - the engine-free core.\n *\n * Everything exported here is pure TypeScript with no engine imports\n * (enforced by test/architecture.test.ts): window/dock/region/drag logic,\n * control models, the `data-uix` markup upgraders, the window chrome\n * conventions, and the platform-adapter interfaces engine packages\n * implement.\n */\n// Pure logic\nexport * from './core/events.js';\nexport * from './core/dock-state.js';\nexport * from './core/window-manager.js';\nexport * from './core/region-layout.js';\nexport * from './core/region-registry.js';\nexport * from './core/drag-math.js';\nexport * from './core/hold-to-drag.js';\nexport * from './core/stepper-model.js';\nexport * from './core/toggle-model.js';\nexport * from './core/expandable-model.js';\nexport * from './core/log-model.js';\n\n// Chrome conventions (markup ids + reference snippet)\nexport * from './chrome/markup.js';\n\n// Interface-driven control upgraders\nexport * from './controls/element.js';\nexport * from './controls/stepper.js';\nexport * from './controls/toggle.js';\nexport * from './controls/expandable-label.js';\nexport * from './controls/log-view.js';\nexport * from './controls/upgrade.js';\n\n// Platform-adapter contract + portable scene descriptors\nexport * from './adapter.js';\nexport * from './scene.js';\n\n// The WindowHost conformance suite, as data an adapter runs in its own runner\nexport * from './contract-cases.js';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realitycollective/webxr-uiextensions",
-  "version": "0.1.0-preview.2",
+  "version": "0.1.0-preview.3",
   "description": "Engine-free core of the Reality Collective UI Extensions: windowing, docking, layout regions and control models for WebXR spatial UI, driven through platform-adapter interfaces. Pair with an engine adapter - @realitycollective/iwsdk-uiextensions (Meta IWSDK) or @realitycollective/xrblocks-uiextensions (Google XR Blocks).",
   "keywords": [
     "realitycollective",
@@ -33,6 +33,9 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
+  "dependencies": {
+    "@realitycollective/webxr-input": "^0.1.1"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/realitycollective/WebXR-UIExtensions.git",