@realitycollective/uix-devtools 0.1.0-preview.0 → 0.1.0-preview.2

package/CHANGELOG.md

@@ -13,5 +13,26 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - `@realitycollective/xrblocks-uiextensions` - EXPERIMENTAL Google XR Blocks / plain three.js adapter: panel document, window host, follow and scale maths, desktop controls and locomotion, pointer forwarding.
 - `@realitycollective/uix-devtools` - dev-only tooling: edit-session launch gate, runtime UIKitML compilation, and the `uix-dev` CLI (Cloudflare quick tunnel, QR onboarding, environment doctor).
 - Demo clients: the IWSDK showcase, the devtools playground, and the multiplatform lab that picks its pipeline from the hardware.
+- `uixComponentSet`, exported from `@realitycollective/iwsdk-uiextensions`. Pass it to `spatialUI.componentSets` so the IWSDK 0.5 parser accepts the `<uix-*>` control elements. Without it a panel using any control fails to parse and never attaches. No equivalent is needed on the three.js or XR Blocks adapters.
+- `WindowHandle` and `WindowOptionsBase` in `@realitycollective/webxr-uiextensions`. `WindowHandle` is what every adapter's `createWindow` hands back: an `id`, a `panel` that is `undefined` until the adapter has attached the document, and `onReady(listener)`, which runs once and fires immediately if the panel is already there. `WindowOptionsBase` holds the options every adapter understands, and both adapters' option types now extend it, so an option name means the same thing on each. `createWindow` itself stays adapter-specific, because the `config` payload differs per engine.
+- `WindowHost.supportsStandalonePanels`. It says whether `createPanel` works on a host, rather than leaving callers to find out by catching. `false` on the IWSDK host, where the ECS owns panel lifecycles and `createPanel` throws; `true` on the three.js / XR Blocks host.
+- `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.
+
+### Changed
+
+- **Controls are declared as custom elements rather than attributes.** `<uix-stepper>` replaces `<div data-uix="stepper">`, and each part is its own element: `<uix-value>`, `<uix-line>`, `<uix-label>` and so on, replacing `data-uix-role`. Parameters are unchanged and stay `data-uix-*`. This is what makes one markup file portable: IWSDK 0.5 parses with `@drawcall/uikitml`, which rejects every `data-*` attribute on a built-in tag but accepts custom tags declared in a component set, while the three.js and XR Blocks parser accepts custom tags with no registration at all. Both expose the declared tag on `userData.customElement.componentName`, so the engine-free upgraders read one contract on every adapter.
+- The expandable label's `toggle` part is now `<uix-more>`. As an element the old name would have collided with the `<uix-toggle>` control.
+- `@realitycollective/iwsdk-uiextensions` targets **IWSDK 0.5.x**: peer range `>=0.5.0 <0.6.0`, developed against `@iwsdk/core` 0.5.3. `PanelUI` in 0.5 declares a single field, `config`, holding the URL of the UIKitML **source**; the compiled JSON it took on 0.4.x, and the `@iwsdk/vite-plugin-uikitml` step that produced it, are both gone. `maxWidth` and `maxHeight` were removed from the component schema, and ECS ignores unknown fields silently, so a panel that still writes them is mis-sized with no error. Size through `createUIWindow`, which routes to `UIWindow.targetWidth/Height`.
+- `UixWindowHost` resolves a window's `config` by fetching the `.uikitml` source and parsing it, where it previously fetched compiled JSON. Supplying `loadConfig` is no longer necessary for an ordinary panel; override it only for an unusual transport.
+- `compilePanelSource` in `@realitycollective/uix-devtools` serves the **source** on its `blob:` URL rather than compiled JSON, matching what 0.5 fetches. `CompiledPanel.json` is now `CompiledPanel.source`, and the `resolveFile` option is gone because the 0.5 parser has no `<link ref>` stylesheet resolution; put shared rules in a `<style>` block, of which several are allowed and merge. Validation now runs on `@drawcall/uikitml`, pinned to the version `@iwsdk/core` depends on, so a source that passes here is one `PanelUISystem` will accept and no second parser enters the tree.
+- Example and demo markup uses `rgba()` or eight-digit hex rather than `background-opacity`, which the 0.5 parser removed. Both parsers accept the replacement, so one stylesheet serves every adapter.
+- The IWSDK component kit is selected by name, `spatialUI: { kit: 'horizon' }`, rather than by passing an imported kit module. The kits now live inside the parser.
+- `@types/three` is pinned to `0.184.0` across the workspace. IWSDK 0.5.3 and xrblocks resolved different copies, and two copies of the three typings make structurally identical `Object3D` types mutually unassignable, which surfaces as spurious errors far from their cause.
+- `onPanelReady` on the IWSDK host announces bare panels as well as managed windows. A `PanelUI` entity with no `UIWindow`, or with an empty `windowId`, used to be dropped silently; it is now announced with `kind: 'panel'` and its config path as the id. Listeners that only want managed windows should check `kind`.
+- `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.
 
 [0.1.0]: https://github.com/realitycollective/WebXR-UIExtensions/commits/main

package/README.md

@@ -32,19 +32,23 @@ if (import.meta.env.DEV || import.meta.env.VITE_UIX_EDIT) {
 
 All parts are individually exported (`readEditToken`, `isTokenAccepted`, `resolveEditSession`) and unit-tested - see `test/gate.test.ts`.
 
-## Runtime UIKitML compilation
+## Runtime panel sources
 
 ```ts
 import { compilePanelSource } from '@realitycollective/uix-devtools';
 import { createUIWindow } from '@realitycollective/iwsdk-uiextensions';
 
-const compiled = compilePanelSource(source); // same JSON the Vite plugin emits
-if (compiled.errors.length === 0) {
-  createUIWindow(world, { id: 'live', title: 'Live', config: compiled.configUrl });
+const panel = compilePanelSource(source); // validates, then wraps in a blob: URL
+if (panel.errors.length === 0) {
+  createUIWindow(world, { id: 'live', title: 'Live', config: panel.configUrl });
 }
 ```
 
-`compilePanelSource` runs the same `parse` the build-time Vite plugin uses and serves the JSON through a `blob:` URL, which IWSDK's `PanelUI` fetches like any file - so panels can be authored, edited and respawned entirely at runtime (desktop workbench or in-headset editor). Parse problems land in `errors` instead of throwing; linked stylesheets can be resolved via the `resolveFile` option.
+`compilePanelSource` validates UIKitML with the same parser IWSDK loads (`@drawcall/uikitml`, pinned to the version `@iwsdk/core` depends on) and serves the **source** through a `blob:` URL, which `PanelUI` fetches like any file - so panels can be authored, edited and respawned entirely at runtime. Diagnostics land in `errors` instead of throwing, and a source with errors still gets a `configUrl` so the failure is visible in-world rather than silent.
+
+Pass `componentSets` to validate against the same application-defined components the world was created with; otherwise markup using them reports unknown-component diagnostics here even though it loads correctly at runtime.
+
+> **Changed in IWSDK 0.5.** On 0.4.x `PanelUI.config` pointed at JSON emitted by `@iwsdk/vite-plugin-uikitml`; that plugin was discontinued at 0.4.2. On 0.5.x `PanelUISystem` fetches `config` as text and parses the UIKitML itself, so there is no compile step left. `CompiledPanel.json` is now `CompiledPanel.source`, and the `resolveFile` option is gone - the 0.5 parser has no `<link ref>` stylesheet resolution. Put shared rules in a `<style>` block; multiple `<style>` elements are allowed and merge.
 
 ## The `uix-dev` CLI
 

package/dist/runtime-compile.d.ts

@@ -1,10 +1,33 @@
+/**
+ * Runtime UIKitML panel sources.
+ *
+ * IWSDK 0.5 changed what `PanelUI.config` points at. On 0.4.x it was a URL to
+ * the JSON the `@iwsdk/vite-plugin-uikitml` build step emitted; that plugin was
+ * discontinued at 0.4.2. On 0.5.x `PanelUISystem` fetches `config` as TEXT and
+ * parses the UIKitML source itself, so there is no compile step left to run.
+ *
+ * What remains useful at runtime is the pairing of a validated source with a
+ * `blob:` URL that `PanelUI` can load like any file:
+ *
+ *   const panel = compilePanelSource(source);
+ *   createUIWindow(world, { config: panel.configUrl, ... });
+ *
+ * This is the mechanism behind live UX editing (desktop workbench and
+ * in-headset editor alike): edit markup → revalidate → respawn the window.
+ *
+ * Validation uses the same parser IWSDK itself loads (`@drawcall/uikitml`,
+ * pinned to the version `@iwsdk/core` depends on), so a source that passes here
+ * is a source `PanelUISystem` will accept. Nothing is parsed twice at load time:
+ * the parse below exists only to produce diagnostics the editor can show.
+ */
+import { type ComponentSet } from '@drawcall/uikitml';
 export interface CompiledPanel {
-    /** Compiled panel JSON, same shape the Vite plugin writes to public/ui. */
-    json: string;
-    /** Parse diagnostics. Empty when the source compiled cleanly. */
+    /** The UIKitML source, exactly as `PanelUI.config` will fetch it. */
+    source: string;
+    /** Validation diagnostics. Empty when the source parses cleanly. */
     errors: string[];
     /**
-     * `blob:` URL serving {@link json}; hand this to `PanelUI.config`.
+     * `blob:` URL serving {@link source}; hand this to `PanelUI.config`.
      * Empty string in non-browser environments (node tests).
      */
     configUrl: string;
@@ -13,12 +36,15 @@ export interface CompiledPanel {
 }
 export interface CompileOptions {
     /**
-     * Resolver for `<link ref="...">` stylesheet references in the source -
-     * return the CSS text for a path, throw for unknown paths (reported as a
-     * diagnostic). Omit to leave linked stylesheets unresolved (inline
-     * `<style>` always works).
+     * Component sets to validate against, matching whatever the world was
+     * configured with. Omit to validate against the built-in set only - markup
+     * using kit components would then report unknown-component diagnostics here
+     * even though it loads correctly at runtime.
      */
-    resolveFile?: (filePath: string) => string;
+    componentSets?: ComponentSet[];
 }
-/** Compile UIKitML source text. Collects errors instead of throwing. */
+/**
+ * Validate UIKitML source and wrap it in a `blob:` URL for `PanelUI.config`.
+ * Collects diagnostics instead of throwing.
+ */
 export declare function compilePanelSource(source: string, options?: CompileOptions): CompiledPanel;

package/dist/runtime-compile.js

@@ -1,42 +1,49 @@
 /**
- * Runtime UIKitML compilation.
+ * Runtime UIKitML panel sources.
  *
- * The `@iwsdk/vite-plugin-uikitml` build step is literally
- * `JSON.stringify(parse(source))` - so the same `parse` from
- * `@pmndrs/uikitml` can compile panel markup live in the browser. IWSDK's
- * `PanelUI` loads its `config` with a plain `fetch()`, which accepts `blob:`
- * URLs, so a runtime-compiled panel is:
+ * IWSDK 0.5 changed what `PanelUI.config` points at. On 0.4.x it was a URL to
+ * the JSON the `@iwsdk/vite-plugin-uikitml` build step emitted; that plugin was
+ * discontinued at 0.4.2. On 0.5.x `PanelUISystem` fetches `config` as TEXT and
+ * parses the UIKitML source itself, so there is no compile step left to run.
  *
- *   const compiled = compilePanelSource(source);
- *   createUIWindow(world, { config: compiled.configUrl, ... });
+ * What remains useful at runtime is the pairing of a validated source with a
+ * `blob:` URL that `PanelUI` can load like any file:
+ *
+ *   const panel = compilePanelSource(source);
+ *   createUIWindow(world, { config: panel.configUrl, ... });
  *
  * This is the mechanism behind live UX editing (desktop workbench and
- * in-headset editor alike): edit markup → recompile → respawn the window.
+ * in-headset editor alike): edit markup → revalidate → respawn the window.
+ *
+ * Validation uses the same parser IWSDK itself loads (`@drawcall/uikitml`,
+ * pinned to the version `@iwsdk/core` depends on), so a source that passes here
+ * is a source `PanelUISystem` will accept. Nothing is parsed twice at load time:
+ * the parse below exists only to produce diagnostics the editor can show.
+ */
+import { parse } from '@drawcall/uikitml';
+/**
+ * Validate UIKitML source and wrap it in a `blob:` URL for `PanelUI.config`.
+ * Collects diagnostics instead of throwing.
  */
-import { parse } from '@pmndrs/uikitml';
-/** Compile UIKitML source text. Collects errors instead of throwing. */
 export function compilePanelSource(source, options = {}) {
     const errors = [];
-    const result = parse(source, {
-        onError: (message) => {
-            errors.push(message);
-        },
-        ...(options.resolveFile ? { resolveFile: options.resolveFile } : {}),
-    });
-    if (result.element === undefined) {
-        errors.push('UIKitML source produced no root element.');
+    const result = parse(source, options.componentSets ? { componentSets: options.componentSets } : {});
+    if (!result.success) {
+        for (const error of result.errors) {
+            errors.push(error.message);
+        }
     }
-    const json = JSON.stringify(result, null, 2);
     const blobSupported = typeof URL !== 'undefined' &&
         typeof URL.createObjectURL === 'function' &&
         typeof Blob !== 'undefined';
     /* v8 ignore start -- only reachable in environments without Blob support */
     if (!blobSupported) {
-        return { json, errors, configUrl: '', revoke: () => { } };
+        return { source, errors, configUrl: '', revoke: () => { } };
     }
     /* v8 ignore stop */
-    const blob = new Blob([json], { type: 'application/json' });
+    // text/html rather than application/json: 0.5 reads this as UIKitML source.
+    const blob = new Blob([source], { type: 'text/html' });
     const url = URL.createObjectURL(blob);
-    return { json, errors, configUrl: url, revoke: () => URL.revokeObjectURL(url) };
+    return { source, errors, configUrl: url, revoke: () => URL.revokeObjectURL(url) };
 }
 //# sourceMappingURL=runtime-compile.js.map

package/dist/runtime-compile.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-compile.js","sourceRoot":"","sources":["../src/runtime-compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AA0BxC,wEAAwE;AACxE,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,UAA0B,EAAE;IAE5B,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE;QAC3B,OAAO,EAAE,CAAC,OAAe,EAAE,EAAE;YAC3B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;QACD,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACrE,CAAC,CAAC;IAEH,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;IAC1D,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAE7C,MAAM,aAAa,GACjB,OAAO,GAAG,KAAK,WAAW;QAC1B,OAAO,GAAG,CAAC,eAAe,KAAK,UAAU;QACzC,OAAO,IAAI,KAAK,WAAW,CAAC;IAC9B,4EAA4E;IAC5E,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,CAAC;IAC3D,CAAC;IACD,oBAAoB;IAEpB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC5D,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;AAClF,CAAC","sourcesContent":["/**\n * Runtime UIKitML compilation.\n *\n * The `@iwsdk/vite-plugin-uikitml` build step is literally\n * `JSON.stringify(parse(source))` - so the same `parse` from\n * `@pmndrs/uikitml` can compile panel markup live in the browser. IWSDK's\n * `PanelUI` loads its `config` with a plain `fetch()`, which accepts `blob:`\n * URLs, so a runtime-compiled panel is:\n *\n *   const compiled = compilePanelSource(source);\n *   createUIWindow(world, { config: compiled.configUrl, ... });\n *\n * This is the mechanism behind live UX editing (desktop workbench and\n * in-headset editor alike): edit markup → recompile → respawn the window.\n */\nimport { parse } from '@pmndrs/uikitml';\n\nexport interface CompiledPanel {\n  /** Compiled panel JSON, same shape the Vite plugin writes to public/ui. */\n  json: string;\n  /** Parse diagnostics. Empty when the source compiled cleanly. */\n  errors: string[];\n  /**\n   * `blob:` URL serving {@link json}; hand this to `PanelUI.config`.\n   * Empty string in non-browser environments (node tests).\n   */\n  configUrl: string;\n  /** Release the blob URL once the panel has loaded (or on discard). */\n  revoke(): void;\n}\n\nexport interface CompileOptions {\n  /**\n   * Resolver for `<link ref=\"...\">` stylesheet references in the source -\n   * return the CSS text for a path, throw for unknown paths (reported as a\n   * diagnostic). Omit to leave linked stylesheets unresolved (inline\n   * `<style>` always works).\n   */\n  resolveFile?: (filePath: string) => string;\n}\n\n/** Compile UIKitML source text. Collects errors instead of throwing. */\nexport function compilePanelSource(\n  source: string,\n  options: CompileOptions = {},\n): CompiledPanel {\n  const errors: string[] = [];\n  const result = parse(source, {\n    onError: (message: string) => {\n      errors.push(message);\n    },\n    ...(options.resolveFile ? { resolveFile: options.resolveFile } : {}),\n  });\n\n  if (result.element === undefined) {\n    errors.push('UIKitML source produced no root element.');\n  }\n\n  const json = JSON.stringify(result, null, 2);\n\n  const blobSupported =\n    typeof URL !== 'undefined' &&\n    typeof URL.createObjectURL === 'function' &&\n    typeof Blob !== 'undefined';\n  /* v8 ignore start -- only reachable in environments without Blob support */\n  if (!blobSupported) {\n    return { json, errors, configUrl: '', revoke: () => {} };\n  }\n  /* v8 ignore stop */\n\n  const blob = new Blob([json], { type: 'application/json' });\n  const url = URL.createObjectURL(blob);\n  return { json, errors, configUrl: url, revoke: () => URL.revokeObjectURL(url) };\n}\n"]}
+{"version":3,"file":"runtime-compile.js","sourceRoot":"","sources":["../src/runtime-compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,KAAK,EAAqB,MAAM,mBAAmB,CAAC;AA0B7D;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,UAA0B,EAAE;IAE5B,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,MAAM,MAAM,GAAG,KAAK,CAClB,MAAM,EACN,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CACtE,CAAC;IACF,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,MAAM,aAAa,GACjB,OAAO,GAAG,KAAK,WAAW;QAC1B,OAAO,GAAG,CAAC,eAAe,KAAK,UAAU;QACzC,OAAO,IAAI,KAAK,WAAW,CAAC;IAC9B,4EAA4E;IAC5E,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,CAAC;IAC7D,CAAC;IACD,oBAAoB;IAEpB,4EAA4E;IAC5E,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IACvD,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;AACpF,CAAC","sourcesContent":["/**\n * Runtime UIKitML panel sources.\n *\n * IWSDK 0.5 changed what `PanelUI.config` points at. On 0.4.x it was a URL to\n * the JSON the `@iwsdk/vite-plugin-uikitml` build step emitted; that plugin was\n * discontinued at 0.4.2. On 0.5.x `PanelUISystem` fetches `config` as TEXT and\n * parses the UIKitML source itself, so there is no compile step left to run.\n *\n * What remains useful at runtime is the pairing of a validated source with a\n * `blob:` URL that `PanelUI` can load like any file:\n *\n *   const panel = compilePanelSource(source);\n *   createUIWindow(world, { config: panel.configUrl, ... });\n *\n * This is the mechanism behind live UX editing (desktop workbench and\n * in-headset editor alike): edit markup → revalidate → respawn the window.\n *\n * Validation uses the same parser IWSDK itself loads (`@drawcall/uikitml`,\n * pinned to the version `@iwsdk/core` depends on), so a source that passes here\n * is a source `PanelUISystem` will accept. Nothing is parsed twice at load time:\n * the parse below exists only to produce diagnostics the editor can show.\n */\nimport { parse, type ComponentSet } from '@drawcall/uikitml';\n\nexport interface CompiledPanel {\n  /** The UIKitML source, exactly as `PanelUI.config` will fetch it. */\n  source: string;\n  /** Validation diagnostics. Empty when the source parses cleanly. */\n  errors: string[];\n  /**\n   * `blob:` URL serving {@link source}; hand this to `PanelUI.config`.\n   * Empty string in non-browser environments (node tests).\n   */\n  configUrl: string;\n  /** Release the blob URL once the panel has loaded (or on discard). */\n  revoke(): void;\n}\n\nexport interface CompileOptions {\n  /**\n   * Component sets to validate against, matching whatever the world was\n   * configured with. Omit to validate against the built-in set only - markup\n   * using kit components would then report unknown-component diagnostics here\n   * even though it loads correctly at runtime.\n   */\n  componentSets?: ComponentSet[];\n}\n\n/**\n * Validate UIKitML source and wrap it in a `blob:` URL for `PanelUI.config`.\n * Collects diagnostics instead of throwing.\n */\nexport function compilePanelSource(\n  source: string,\n  options: CompileOptions = {},\n): CompiledPanel {\n  const errors: string[] = [];\n\n  const result = parse(\n    source,\n    options.componentSets ? { componentSets: options.componentSets } : {},\n  );\n  if (!result.success) {\n    for (const error of result.errors) {\n      errors.push(error.message);\n    }\n  }\n\n  const blobSupported =\n    typeof URL !== 'undefined' &&\n    typeof URL.createObjectURL === 'function' &&\n    typeof Blob !== 'undefined';\n  /* v8 ignore start -- only reachable in environments without Blob support */\n  if (!blobSupported) {\n    return { source, errors, configUrl: '', revoke: () => {} };\n  }\n  /* v8 ignore stop */\n\n  // text/html rather than application/json: 0.5 reads this as UIKitML source.\n  const blob = new Blob([source], { type: 'text/html' });\n  const url = URL.createObjectURL(blob);\n  return { source, errors, configUrl: url, revoke: () => URL.revokeObjectURL(url) };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realitycollective/uix-devtools",
-  "version": "0.1.0-preview.0",
+  "version": "0.1.0-preview.2",
   "description": "Developer tooling for @realitycollective/iwsdk-uiextensions - edit-session launch gate, runtime UIKitML compilation, and the uix-dev CLI (Cloudflare quick tunnel + QR onboarding for headset testing). Never ship this in a player-facing bundle.",
   "keywords": [
     "realitycollective",
@@ -41,7 +41,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@pmndrs/uikitml": "^0.1.12",
+    "@drawcall/uikitml": "0.1.8",
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {