@microsoft/webui 0.0.25 → 0.0.27

package/wasm/handler/webui_wasm_handler.d.ts

@@ -42,19 +42,26 @@ export class Protocol {
 }
 
 /**
- * A progressive HTML response driven one chunk at a time from JavaScript.
+ * A progressive HTML response driven one semantic step at a time from JavaScript.
  *
- * Every method returns the UTF-8 bytes it produced. Write them to the
- * response and apply the host's own backpressure; the session holds no
- * transport and never blocks on one.
+ * `start()`, `resume()`, and `advance()` return
+ * `{ bytes, done, boundary? }`, where `bytes` is a `Uint8Array` and a boundary is
+ * `{ instanceId, declarationId, owner, name, key }`. Boundary keys retain
+ * their authored JSON type: strings are JavaScript strings and finite numbers
+ * are JavaScript numbers.
  *
  * ```js
  * const session = protocol.streamResponse('index.html', '/');
- * const weather = session.boundary('weather-shell');
- * controller.enqueue(session.writeShell(shellState));
- * controller.enqueue(session.writeBoundary(weather, weatherState, 'updatable'));
- * controller.enqueue(session.update(weather, forecast));
- * controller.enqueue(session.finish(tailState));
+ * let step = session.start(JSON.stringify(shellState));
+ * controller.enqueue(step.bytes);
+ * while (!step.done) {
+ *   const { instanceId, name, key } = step.boundary;
+ *   const state = await loadBoundary(name, key);
+ *   step = session.resume(instanceId, JSON.stringify(state), 'updatable');
+ *   controller.enqueue(step.bytes);
+ *   step = session.advance();
+ *   controller.enqueue(step.bytes);
+ * }
  * ```
  */
 export class StreamingSession {
@@ -62,38 +69,27 @@ export class StreamingSession {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Resolve an authored boundary name to a stable integer handle.
+     * Write the parent bytes after the committed occurrence.
      *
-     * Resolve once outside the write loop; the handle costs nothing to reuse.
+     * Valid only after `resume()`. Returns the next boundary occurrence or
+     * completes the document tail.
      */
-    boundary(name: string): number;
+    advance(): object;
     /**
-     * Render the document tail and emit the terminal record.
-     */
-    finish(state_json: string): Uint8Array;
-    /**
-     * Push a projected state patch to a committed updatable boundary.
-     */
-    update(boundary: number, state_json: string): Uint8Array;
-    /**
-     * Render and commit the next boundary in declaration order.
+     * Commit the pending occurrence through its checkpoint, then stop.
      *
      * `mode` is `"final"` (default) or `"updatable"`. Only updatable
      * boundaries accept later `update()` calls.
      */
-    writeBoundary(boundary: number, state_json: string, mode?: string | null): Uint8Array;
-    /**
-     * Render everything before the first boundary.
-     */
-    writeShell(state_json: string): Uint8Array;
+    resume(instance_id: number, state_json: string, mode?: string | null): object;
     /**
-     * Number of compile-time boundaries declared by this entry.
+     * Render until the first runtime boundary occurrence or terminal.
      */
-    readonly boundaryCount: number;
+    start(state_json: string): object;
     /**
-     * Whether the terminal record has been written.
+     * Push a projected state patch to a committed updatable boundary.
      */
-    readonly finished: boolean;
+    update(instance_id: number, patch_json: string): Uint8Array;
 }
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -109,13 +105,10 @@ export interface InitOutput {
     readonly protocol_renderStream: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly protocol_streamResponse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly protocol_tokens: (a: number, b: number) => void;
-    readonly streamingsession_boundary: (a: number, b: number, c: number, d: number) => void;
-    readonly streamingsession_boundaryCount: (a: number) => number;
-    readonly streamingsession_finish: (a: number, b: number, c: number, d: number) => void;
-    readonly streamingsession_finished: (a: number) => number;
+    readonly streamingsession_advance: (a: number, b: number) => void;
+    readonly streamingsession_resume: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly streamingsession_start: (a: number, b: number, c: number, d: number) => void;
     readonly streamingsession_update: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly streamingsession_writeBoundary: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-    readonly streamingsession_writeShell: (a: number, b: number, c: number, d: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/wasm/handler/webui_wasm_handler.js

@@ -219,19 +219,26 @@ export class Protocol {
 if (Symbol.dispose) Protocol.prototype[Symbol.dispose] = Protocol.prototype.free;
 
 /**
- * A progressive HTML response driven one chunk at a time from JavaScript.
+ * A progressive HTML response driven one semantic step at a time from JavaScript.
  *
- * Every method returns the UTF-8 bytes it produced. Write them to the
- * response and apply the host's own backpressure; the session holds no
- * transport and never blocks on one.
+ * `start()`, `resume()`, and `advance()` return
+ * `{ bytes, done, boundary? }`, where `bytes` is a `Uint8Array` and a boundary is
+ * `{ instanceId, declarationId, owner, name, key }`. Boundary keys retain
+ * their authored JSON type: strings are JavaScript strings and finite numbers
+ * are JavaScript numbers.
  *
  * ```js
  * const session = protocol.streamResponse('index.html', '/');
- * const weather = session.boundary('weather-shell');
- * controller.enqueue(session.writeShell(shellState));
- * controller.enqueue(session.writeBoundary(weather, weatherState, 'updatable'));
- * controller.enqueue(session.update(weather, forecast));
- * controller.enqueue(session.finish(tailState));
+ * let step = session.start(JSON.stringify(shellState));
+ * controller.enqueue(step.bytes);
+ * while (!step.done) {
+ *   const { instanceId, name, key } = step.boundary;
+ *   const state = await loadBoundary(name, key);
+ *   step = session.resume(instanceId, JSON.stringify(state), 'updatable');
+ *   controller.enqueue(step.bytes);
+ *   step = session.advance();
+ *   controller.enqueue(step.bytes);
+ * }
  * ```
  */
 export class StreamingSession {
@@ -252,139 +259,90 @@ export class StreamingSession {
         wasm.__wbg_streamingsession_free(ptr, 0);
     }
     /**
-     * Resolve an authored boundary name to a stable integer handle.
+     * Write the parent bytes after the committed occurrence.
      *
-     * Resolve once outside the write loop; the handle costs nothing to reuse.
-     * @param {string} name
-     * @returns {number}
+     * Valid only after `resume()`. Returns the next boundary occurrence or
+     * completes the document tail.
+     * @returns {object}
      */
-    boundary(name) {
+    advance() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.streamingsession_boundary(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.streamingsession_advance(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return r0 >>> 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Number of compile-time boundaries declared by this entry.
-     * @returns {number}
-     */
-    get boundaryCount() {
-        const ret = wasm.streamingsession_boundaryCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Render the document tail and emit the terminal record.
-     * @param {string} state_json
-     * @returns {Uint8Array}
-     */
-    finish(state_json) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(state_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.streamingsession_finish(retptr, this.__wbg_ptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            if (r3) {
-                throw takeObject(r2);
-            }
-            var v2 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            return v2;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Whether the terminal record has been written.
-     * @returns {boolean}
-     */
-    get finished() {
-        const ret = wasm.streamingsession_finished(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Push a projected state patch to a committed updatable boundary.
-     * @param {number} boundary
+     * Commit the pending occurrence through its checkpoint, then stop.
+     *
+     * `mode` is `"final"` (default) or `"updatable"`. Only updatable
+     * boundaries accept later `update()` calls.
+     * @param {number} instance_id
      * @param {string} state_json
-     * @returns {Uint8Array}
+     * @param {string | null} [mode]
+     * @returns {object}
      */
-    update(boundary, state_json) {
+    resume(instance_id, state_json, mode) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(state_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.streamingsession_update(retptr, this.__wbg_ptr, boundary, ptr0, len0);
+            var ptr1 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.streamingsession_resume(retptr, this.__wbg_ptr, instance_id, ptr0, len0, ptr1, len1);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            if (r3) {
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            var v2 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            return v2;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Render and commit the next boundary in declaration order.
-     *
-     * `mode` is `"final"` (default) or `"updatable"`. Only updatable
-     * boundaries accept later `update()` calls.
-     * @param {number} boundary
+     * Render until the first runtime boundary occurrence or terminal.
      * @param {string} state_json
-     * @param {string | null} [mode]
-     * @returns {Uint8Array}
+     * @returns {object}
      */
-    writeBoundary(boundary, state_json, mode) {
+    start(state_json) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(state_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.streamingsession_writeBoundary(retptr, this.__wbg_ptr, boundary, ptr0, len0, ptr1, len1);
+            wasm.streamingsession_start(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            if (r3) {
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            var v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            return v3;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Render everything before the first boundary.
-     * @param {string} state_json
+     * Push a projected state patch to a committed updatable boundary.
+     * @param {number} instance_id
+     * @param {string} patch_json
      * @returns {Uint8Array}
      */
-    writeShell(state_json) {
+    update(instance_id, patch_json) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(state_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(patch_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.streamingsession_writeShell(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.streamingsession_update(retptr, this.__wbg_ptr, instance_id, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -533,6 +491,14 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_new_da52cf8fe3429cb2: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_next_6dbf2c0ac8cde20f: function(arg0) {
             const ret = getObject(arg0).next;
             return addHeapObject(ret);
@@ -544,6 +510,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
         __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
             getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
         },
@@ -551,7 +521,12 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).value;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);

package/wasm/handler/webui_wasm_handler_bg.wasm.d.ts

@@ -10,13 +10,10 @@ export const protocol_renderPartial: (a: number, b: number, c: number, d: number
 export const protocol_renderStream: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const protocol_streamResponse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const protocol_tokens: (a: number, b: number) => void;
-export const streamingsession_boundary: (a: number, b: number, c: number, d: number) => void;
-export const streamingsession_boundaryCount: (a: number) => number;
-export const streamingsession_finish: (a: number, b: number, c: number, d: number) => void;
-export const streamingsession_finished: (a: number) => number;
+export const streamingsession_advance: (a: number, b: number) => void;
+export const streamingsession_resume: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const streamingsession_start: (a: number, b: number, c: number, d: number) => void;
 export const streamingsession_update: (a: number, b: number, c: number, d: number, e: number) => void;
-export const streamingsession_writeBoundary: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const streamingsession_writeShell: (a: number, b: number, c: number, d: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/wasm/parser/README.md

@@ -15,10 +15,46 @@ WebAssembly bindings for the [WebUI](https://github.com/microsoft/webui) framewo
 The default feature is `all`, which powers the online playground. Consumers that only need to render prebuilt protobuf protocol bytes should use the handler bundle to avoid shipping parser code.
 
 Construct `Protocol` once from protocol bytes. It exposes `render`,
-`renderStream`, `renderPartial`, `renderComponentTemplates`, and `tokens`.
+`renderStream`, `renderPartial`, `renderComponentTemplates`, `tokens`, and
+`streamResponse`.
 Streaming callbacks are coalesced around a 16 KiB target before crossing into
 JavaScript.
 
+`Protocol.streamResponse(entry, requestPath, options)` returns a host-driven
+`StreamingSession`. State and patch arguments are JSON strings. `start`,
+`resume`, and `advance` return:
+
+```js
+{
+  bytes: Uint8Array,
+  done: boolean,
+  boundary?: { instanceId, declarationId, owner, name, key }
+}
+```
+
+| Method | Result |
+|---|---|
+| `start(stateJson)` | Shell bytes through the first descriptor or terminal |
+| `resume(instanceId, stateJson, mode)` | Only the pending occurrence's bytes through its checkpoint |
+| `advance()` | Following parent bytes through the next descriptor or terminal |
+| `update(instanceId, patchJson)` | Projected state bytes for an updatable occurrence |
+
+A descriptor means call `resume`; no descriptor with `done: false` means call
+`advance`; `done: true` means complete. Boundary-only `resume` lets the host
+enqueue the checkpoint immediately. `advance` renders following parent or tail
+bytes, so no sibling boundary workaround is needed.
+
+`mode` is `"final"` (the default) or `"updatable"`. A committed updatable
+occurrence accepts `update(instanceId, patch)`, including between its `resume`
+and `advance`, and returns a `Uint8Array`. Optional boundary keys preserve JSON
+identity: string keys are JavaScript strings and finite numeric keys are
+JavaScript numbers. A key is required when one component-owned declaration is
+reached from multiple static callsites in one entry traversal. Boundaries are
+discovered through entries, reusable components, runtime branches, and selected
+routes. A boundary-bearing subtree under `<for>` fails with
+`boundary-in-repeat`; one boundary may wrap the whole `<for>`. The step with
+`done: true` already contains terminal and document-tail bytes.
+
 ## Building
 
 ```bash

package/wasm/parser/package.json

@@ -5,7 +5,7 @@
     "Microsoft Edge"
   ],
   "description": "WebAssembly bindings for WebUI framework — powers the online playground",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "license": "MIT",
   "repository": {
     "type": "git",

package/wasm/parser/webui_wasm_parser.d.ts

@@ -4,15 +4,18 @@
 /**
  * Build protocol protobuf bytes from virtual files without rendering.
  *
+ * `dom` accepts `"shadow"` (default) or `"light"` for unwrapped components;
+ * authored open Shadow roots remain Shadow in either mode.
+ *
  * Returns the serialized `WebUIProtocol` as protobuf bytes.
  */
-export function build_protocol(files: any, entry: string, projection_manifests?: any | null): Uint8Array;
+export function build_protocol(files: any, entry: string, projection_manifests?: any | null, dom?: string | null): Uint8Array;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly build_protocol: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly build_protocol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/wasm/parser/webui_wasm_parser.js

@@ -3,18 +3,24 @@
 /**
  * Build protocol protobuf bytes from virtual files without rendering.
  *
+ * `dom` accepts `"shadow"` (default) or `"light"` for unwrapped components;
+ * authored open Shadow roots remain Shadow in either mode.
+ *
  * Returns the serialized `WebUIProtocol` as protobuf bytes.
  * @param {any} files
  * @param {string} entry
  * @param {any | null} [projection_manifests]
+ * @param {string | null} [dom]
  * @returns {Uint8Array}
  */
-export function build_protocol(files, entry, projection_manifests) {
+export function build_protocol(files, entry, projection_manifests, dom) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(entry, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        wasm.build_protocol(retptr, addHeapObject(files), ptr0, len0, isLikeNone(projection_manifests) ? 0 : addHeapObject(projection_manifests));
+        var ptr1 = isLikeNone(dom) ? 0 : passStringToWasm0(dom, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.build_protocol(retptr, addHeapObject(files), ptr0, len0, isLikeNone(projection_manifests) ? 0 : addHeapObject(projection_manifests), ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -22,9 +28,9 @@ export function build_protocol(files, entry, projection_manifests) {
         if (r3) {
             throw takeObject(r2);
         }
-        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
         wasm.__wbindgen_export4(r0, r1 * 1, 1);
-        return v2;
+        return v3;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }

package/wasm/parser/webui_wasm_parser_bg.wasm.d.ts

@@ -1,7 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const build_protocol: (a: number, b: number, c: number, d: number, e: number) => void;
+export const build_protocol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;