@gtkx/react 0.14.0 → 0.16.0

package/dist/nodes/widget.js

@@ -1,79 +1,81 @@
-import { batch, isObjectEqual, NativeObject } from "@gtkx/ffi";
-import * as Gdk from "@gtkx/ffi/gdk";
+import { getNativeObject, isObjectEqual } from "@gtkx/ffi";
+import { ObjectClass, ParamSpecString, Type, TypeInstance, typeClassRef, typeFromName, typeFundamental, typeNameFromInstance, } from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { Node } from "../node.js";
 import { registerNodeClass } from "../registry.js";
-import { EVENT_CONTROLLER_PROPS } from "./internal/constants.js";
-import { hasSingleContent, isAddable, isAppendable, isEditable, isInsertable, isRemovable, isReorderable, isSingleChild, } from "./internal/predicates.js";
-import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType, resolvePropMeta, resolveSignal } from "./internal/utils.js";
-import { SlotNode } from "./slot.js";
-const PROPS = ["children", "widthRequest", "heightRequest"];
+import { getAttachmentStrategy, attachChild as performAttachment, detachChild as performDetachment, } from "./internal/child-attachment.js";
+import { isAttachable, isEditable, isInsertable, isRemovable, isReorderable, } from "./internal/predicates.js";
+import { filterProps, matchesAnyClass, propNameToSignalName, resolvePropMeta, resolveSignal, } from "./internal/utils.js";
+const EXCLUDED_PROPS = ["children", "widthRequest", "heightRequest", "grabFocus"];
+function findProperty(obj, key) {
+    if (!obj.handle)
+        return null;
+    const propertyName = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const typeInstance = getNativeObject(obj.handle, TypeInstance);
+    const typeName = typeNameFromInstance(typeInstance);
+    const gtype = typeFromName(typeName);
+    const typeClass = typeClassRef(gtype);
+    const objectClass = getNativeObject(typeClass.handle, ObjectClass);
+    return objectClass.findProperty(propertyName) ?? null;
+}
 export class WidgetNode extends Node {
     static priority = 3;
-    motionController;
-    clickController;
-    keyController;
-    scrollController;
-    dragSourceController;
-    dropTargetController;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Widget, containerOrClass);
+        return matchesAnyClass([Gtk.Widget], containerOrClass);
     }
-    static createContainer(props, containerClass) {
+    static createContainer(props, containerClass, _rootContainer) {
         const WidgetClass = containerClass;
         const typeName = WidgetClass.glibTypeName;
         const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
         return new WidgetClass(...args);
     }
     appendChild(child) {
-        if (child instanceof SlotNode) {
-            child.setParent(this.container);
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.attachTo(this);
             return;
         }
         if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'Widget': expected WidgetNode child`);
+            throw new Error(`Cannot append '${child.typeName}' to 'Widget': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot append 'Window' to '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => this.attachChild(child));
+        this.attachChild(child);
     }
     removeChild(child) {
-        if (child instanceof SlotNode) {
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.detachFrom(this);
             return;
         }
         if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'Widget': expected WidgetNode child`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'Widget': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot remove 'Window' from '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => this.detachChild(child));
+        this.detachChild(child);
     }
     insertBefore(child, before) {
-        if (child instanceof SlotNode) {
-            child.setParent(this.container);
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.attachTo(this);
             return;
         }
         if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' before '${before.typeName}': expected WidgetNode children`);
+            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot insert 'Window' into '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => {
-            if (isReorderable(this.container)) {
-                this.insertBeforeReorderable(this.container, child, before);
-            }
-            else if (isInsertable(this.container)) {
-                this.insertBeforeInsertable(this.container, child, before);
-            }
-            else {
-                this.appendChild(child);
-            }
-        });
+        if (isReorderable(this.container)) {
+            this.insertBeforeReorderable(this.container, child, before);
+        }
+        else if (isInsertable(this.container)) {
+            this.insertBeforeInsertable(this.container, child, before);
+        }
+        else {
+            this.appendChild(child);
+        }
     }
     insertBeforeReorderable(container, child, before) {
         const previousSibling = this.findPreviousSibling(before);
@@ -93,52 +95,48 @@ export class WidgetNode extends Node {
         container.insert(child.container, position);
     }
     updateProps(oldProps, newProps) {
+        if (!this.container) {
+            throw new Error(`WidgetNode.updateProps: container is undefined for ${this.typeName}`);
+        }
         this.updateSizeRequest(oldProps, newProps);
+        this.updateGrabFocus(oldProps, newProps);
         const propNames = new Set([
-            ...Object.keys(filterProps(oldProps ?? {}, PROPS)),
-            ...Object.keys(filterProps(newProps ?? {}, PROPS)),
+            ...Object.keys(filterProps(oldProps ?? {}, EXCLUDED_PROPS)),
+            ...Object.keys(filterProps(newProps ?? {}, EXCLUDED_PROPS)),
         ]);
         const pendingSignals = [];
+        const pendingProperties = [];
         for (const name of propNames) {
             const oldValue = oldProps?.[name];
             const newValue = newProps[name];
             if (oldValue === newValue)
                 continue;
-            if (EVENT_CONTROLLER_PROPS.has(name)) {
-                pendingSignals.push({ name, newValue });
-                continue;
-            }
-            if (name === "onNotify") {
-                pendingSignals.push({ name, newValue });
-                continue;
-            }
-            const signalName = this.propNameToSignalName(name);
+            const signalName = propNameToSignalName(name);
             if (resolveSignal(this.container, signalName)) {
                 pendingSignals.push({ name, newValue });
             }
             else if (newValue !== undefined) {
-                const isEditableText = name === "text" && isEditable(this.container);
-                if (isEditableText && oldValue !== undefined) {
-                    const currentValue = this.getProperty(name);
-                    if (oldValue !== currentValue) {
-                        continue;
-                    }
+                pendingProperties.push({ name, oldValue, newValue });
+            }
+            else if (oldValue !== undefined) {
+                const defaultValue = this.getPropertyDefaultValue(name);
+                if (defaultValue !== undefined) {
+                    pendingProperties.push({ name, oldValue, newValue: defaultValue });
                 }
-                this.setProperty(name, newValue);
             }
         }
         for (const { name, newValue } of pendingSignals) {
-            if (EVENT_CONTROLLER_PROPS.has(name)) {
-                this.updateEventControllerProp(name, newValue ?? null);
-            }
-            else if (name === "onNotify") {
-                this.updateNotifyHandler(newValue ?? null);
-            }
-            else {
-                const signalName = this.propNameToSignalName(name);
-                const handler = typeof newValue === "function" ? newValue : undefined;
-                signalStore.set(this, this.container, signalName, handler);
+            const signalName = propNameToSignalName(name);
+            const handler = typeof newValue === "function" ? newValue : undefined;
+            this.signalStore.set(this, this.container, signalName, handler);
+        }
+        for (const { name, oldValue, newValue } of pendingProperties) {
+            if (name === "text" && oldValue !== undefined && isEditable(this.container)) {
+                if (oldValue !== this.container.getText()) {
+                    continue;
+                }
             }
+            this.setProperty(name, newValue);
         }
     }
     updateSizeRequest(oldProps, newProps) {
@@ -150,138 +148,46 @@ export class WidgetNode extends Node {
             this.container.setSizeRequest(newWidth ?? -1, newHeight ?? -1);
         }
     }
-    updateEventControllerProp(propName, handlerOrValue) {
-        const wrappedHandler = typeof handlerOrValue === "function"
-            ? (_self, ...args) => handlerOrValue(...args)
-            : undefined;
-        switch (propName) {
-            case "onEnter":
-            case "onLeave":
-            case "onMotion": {
-                if (!this.motionController) {
-                    this.motionController = new Gtk.EventControllerMotion();
-                    this.container.addController(this.motionController);
-                }
-                const signalName = propName === "onEnter" ? "enter" : propName === "onLeave" ? "leave" : "motion";
-                signalStore.set(this, this.motionController, signalName, wrappedHandler);
-                break;
-            }
-            case "onPressed":
-            case "onReleased": {
-                if (!this.clickController) {
-                    this.clickController = new Gtk.GestureClick();
-                    this.container.addController(this.clickController);
-                }
-                const signalName = propName === "onPressed" ? "pressed" : "released";
-                signalStore.set(this, this.clickController, signalName, wrappedHandler);
-                break;
-            }
-            case "onKeyPressed":
-            case "onKeyReleased": {
-                if (!this.keyController) {
-                    this.keyController = new Gtk.EventControllerKey();
-                    this.container.addController(this.keyController);
-                }
-                const signalName = propName === "onKeyPressed" ? "key-pressed" : "key-released";
-                signalStore.set(this, this.keyController, signalName, wrappedHandler);
-                break;
-            }
-            case "onScroll": {
-                if (!this.scrollController) {
-                    this.scrollController = new Gtk.EventControllerScroll(Gtk.EventControllerScrollFlags.BOTH_AXES);
-                    this.container.addController(this.scrollController);
-                }
-                signalStore.set(this, this.scrollController, "scroll", wrappedHandler);
-                break;
-            }
-            case "onDragPrepare":
-            case "onDragBegin":
-            case "onDragEnd":
-            case "onDragCancel":
-            case "dragActions": {
-                const dragSource = this.ensureDragSource();
-                if (propName === "dragActions") {
-                    dragSource.setActions(handlerOrValue ?? Gdk.DragAction.COPY);
-                }
-                else {
-                    const signalName = propName === "onDragPrepare"
-                        ? "prepare"
-                        : propName === "onDragBegin"
-                            ? "drag-begin"
-                            : propName === "onDragEnd"
-                                ? "drag-end"
-                                : "drag-cancel";
-                    signalStore.set(this, dragSource, signalName, wrappedHandler);
-                }
-                break;
-            }
-            case "onDrop":
-            case "onDropEnter":
-            case "onDropLeave":
-            case "onDropMotion":
-            case "dropActions":
-            case "dropTypes": {
-                const dropTarget = this.ensureDropTarget();
-                if (propName === "dropActions") {
-                    dropTarget.setActions(handlerOrValue ?? Gdk.DragAction.COPY);
-                }
-                else if (propName === "dropTypes") {
-                    const types = handlerOrValue ?? [];
-                    dropTarget.setGtypes(types.length, types);
-                }
-                else {
-                    const signalName = propName === "onDrop"
-                        ? "drop"
-                        : propName === "onDropEnter"
-                            ? "enter"
-                            : propName === "onDropLeave"
-                                ? "leave"
-                                : "motion";
-                    signalStore.set(this, dropTarget, signalName, wrappedHandler);
-                }
-                break;
-            }
-        }
-    }
-    ensureDragSource() {
-        if (!this.dragSourceController) {
-            this.dragSourceController = new Gtk.DragSource();
-            this.dragSourceController.setActions(Gdk.DragAction.COPY);
-            this.container.addController(this.dragSourceController);
-        }
-        return this.dragSourceController;
-    }
-    ensureDropTarget() {
-        if (!this.dropTargetController) {
-            this.dropTargetController = new Gtk.DropTarget(0, Gdk.DragAction.COPY);
-            this.container.addController(this.dropTargetController);
+    updateGrabFocus(oldProps, newProps) {
+        const oldGrabFocus = oldProps?.grabFocus;
+        const newGrabFocus = newProps.grabFocus;
+        if (!oldGrabFocus && newGrabFocus) {
+            this.container.grabFocus();
         }
-        return this.dropTargetController;
     }
-    updateNotifyHandler(handler) {
-        const wrappedHandler = handler
-            ? (obj, pspec) => {
-                handler(obj, pspec.getName());
-            }
-            : undefined;
-        signalStore.set(this, this.container, "notify", wrappedHandler);
-    }
-    propNameToSignalName(name) {
-        return name
-            .slice(2)
-            .replace(/([A-Z])/g, "-$1")
-            .toLowerCase()
-            .replace(/^-/, "");
-    }
-    getProperty(key) {
-        const propMeta = resolvePropMeta(this.container, key);
-        if (!propMeta)
+    getPropertyDefaultValue(key) {
+        if (!resolvePropMeta(this.container, key))
             return undefined;
-        const [getterName] = propMeta;
-        const getter = getterName ? this.container[getterName] : undefined;
-        if (getter && typeof getter === "function") {
-            return getter.call(this.container);
-        }
+        const pspec = findProperty(this.container, key);
+        if (!pspec)
+            return undefined;
+        const value = pspec.getDefaultValue();
+        const gtype = value.getType();
+        const fundamental = typeFundamental(gtype);
+        if (fundamental === Type.BOOLEAN)
+            return value.getBoolean();
+        if (fundamental === Type.INT)
+            return value.getInt();
+        if (fundamental === Type.UINT)
+            return value.getUint();
+        if (fundamental === Type.LONG)
+            return value.getLong();
+        if (fundamental === Type.ULONG)
+            return value.getUlong();
+        if (fundamental === Type.INT64)
+            return value.getInt64();
+        if (fundamental === Type.UINT64)
+            return value.getUint64();
+        if (fundamental === Type.FLOAT)
+            return value.getFloat();
+        if (fundamental === Type.DOUBLE)
+            return value.getDouble();
+        if (fundamental === Type.STRING)
+            return value.getString();
+        if (fundamental === Type.ENUM)
+            return value.getEnum();
+        if (fundamental === Type.FLAGS)
+            return value.getFlags();
         return undefined;
     }
     setProperty(key, value) {
@@ -290,21 +196,17 @@ export class WidgetNode extends Node {
             return;
         const [getterName, setterName] = propMeta;
         const setter = this.container[setterName];
-        const getter = getterName ? this.container[getterName] : undefined;
-        if (getter && typeof getter === "function") {
-            const currentValue = getter.call(this.container);
-            if (currentValue === value) {
-                return;
-            }
-            if (currentValue instanceof NativeObject &&
-                value instanceof NativeObject &&
-                isObjectEqual(currentValue, value)) {
-                return;
+        if (!setter || typeof setter !== "function")
+            return;
+        if (getterName && findProperty(this.container, key) instanceof ParamSpecString) {
+            const getter = this.container[getterName];
+            if (getter && typeof getter === "function") {
+                const currentValue = getter.call(this.container);
+                if (currentValue === value)
+                    return;
             }
         }
-        if (setter && typeof setter === "function") {
-            setter.call(this.container, value);
-        }
+        setter.call(this.container, value);
     }
     detachChildFromParent(child) {
         const currentParent = child.container.getParent();
@@ -313,37 +215,21 @@ export class WidgetNode extends Node {
         }
     }
     attachChild(child) {
-        if (isAppendable(this.container)) {
-            this.detachChildFromParent(child);
-            this.container.append(child.container);
+        const strategy = getAttachmentStrategy(this.container);
+        if (!strategy) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.container.constructor.name}': container does not support children`);
         }
-        else if (isAddable(this.container)) {
+        if (strategy.type === "appendable" || strategy.type === "addable") {
             this.detachChildFromParent(child);
-            this.container.add(child.container);
-        }
-        else if (hasSingleContent(this.container)) {
-            this.container.setContent(child.container);
-        }
-        else if (isSingleChild(this.container)) {
-            this.container.setChild(child.container);
-        }
-        else {
-            throw new Error(`Cannot append '${child.typeName}' to '${this.container.constructor.name}': container does not support children`);
         }
+        performAttachment(child.container, strategy);
     }
     detachChild(child) {
-        if (isRemovable(this.container)) {
-            this.container.remove(child.container);
-        }
-        else if (hasSingleContent(this.container)) {
-            this.container.setContent(null);
-        }
-        else if (isSingleChild(this.container)) {
-            this.container.setChild(null);
-        }
-        else {
+        const strategy = getAttachmentStrategy(this.container);
+        if (!strategy) {
             throw new Error(`Cannot remove '${child.typeName}' from '${this.container.constructor.name}': container does not support child removal`);
         }
+        performDetachment(child.container, strategy);
     }
     findPreviousSibling(before) {
         let beforeChild = this.container.getFirstChild();

package/dist/nodes/window.d.ts

@@ -2,22 +2,28 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import type { Node } from "../node.js";
 import type { Container, ContainerClass, Props } from "../types.js";
 import { WidgetNode } from "./widget.js";
-type WindowProps = Props & {
+type CreditSection = {
+    name: string;
+    people: string[];
+};
+export type WindowProps = Props & {
     defaultWidth?: number;
     defaultHeight?: number;
     onClose?: () => void;
+    creditSections?: CreditSection[];
 };
 export declare class WindowNode extends WidgetNode<Gtk.Window, WindowProps> {
     static priority: number;
     private menu;
     static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
-    static createContainer(props: Props, containerClass: typeof Gtk.Window, rootContainer?: Container): Gtk.Window;
-    constructor(typeName: string, props: WindowProps, container: Gtk.Window, rootContainer?: Container);
+    static createContainer(props: Props, containerClass: typeof Gtk.Window, rootContainer: Container | undefined): Gtk.Window;
+    constructor(typeName: string, props: WindowProps, container: Gtk.Window, rootContainer: Container);
     appendChild(child: Node): void;
     removeChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;
     mount(): void;
     unmount(): void;
     updateProps(oldProps: WindowProps | null, newProps: WindowProps): void;
+    protected applyOwnProps(oldProps: WindowProps | null, newProps: WindowProps): void;
 }
 export {};

package/dist/nodes/window.js

@@ -1,25 +1,25 @@
 import * as Adw from "@gtkx/ffi/adw";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
-import { Menu } from "./models/menu.js";
+import { DialogNode } from "./dialog.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { MenuModel } from "./models/menu.js";
 import { WidgetNode } from "./widget.js";
-const PROPS = ["defaultWidth", "defaultHeight", "onClose"];
+const OWN_PROPS = ["defaultWidth", "defaultHeight", "onClose"];
 export class WindowNode extends WidgetNode {
     static priority = 1;
     menu;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Window, containerOrClass);
+        return matchesAnyClass([Gtk.Window], containerOrClass);
     }
     static createContainer(props, containerClass, rootContainer) {
         const WindowClass = containerClass;
-        if (isContainerType(Gtk.ApplicationWindow, WindowClass) ||
-            isContainerType(Adw.ApplicationWindow, WindowClass)) {
+        if (matchesAnyClass([Gtk.ApplicationWindow], WindowClass) ||
+            matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
             if (!(rootContainer instanceof Gtk.Application)) {
                 throw new Error("Expected ApplicationWindow to be created within Application");
             }
-            if (isContainerType(Adw.ApplicationWindow, WindowClass)) {
+            if (matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
                 return new Adw.ApplicationWindow(rootContainer);
             }
             return new Gtk.ApplicationWindow(rootContainer);
@@ -30,13 +30,22 @@ export class WindowNode extends WidgetNode {
         super(typeName, props, container, rootContainer);
         const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
         const actionMap = container instanceof Gtk.ApplicationWindow ? container : undefined;
-        this.menu = new Menu("root", {}, actionMap, application);
+        this.menu = new MenuModel("root", {}, rootContainer, actionMap, application);
+        if (container instanceof Gtk.AboutDialog && props.creditSections) {
+            for (const section of props.creditSections) {
+                container.addCreditSection(section.name, section.people);
+            }
+        }
     }
     appendChild(child) {
         if (child.container instanceof Gtk.Window) {
             child.container.setTransientFor(this.container);
             return;
         }
+        if (child instanceof DialogNode) {
+            child.parent = this.container;
+            return;
+        }
         this.menu.appendChild(child);
         super.appendChild(child);
     }
@@ -45,6 +54,10 @@ export class WindowNode extends WidgetNode {
             child.container.setTransientFor(null);
             return;
         }
+        if (child instanceof DialogNode) {
+            child.parent = null;
+            return;
+        }
         this.menu.removeChild(child);
         super.removeChild(child);
     }
@@ -61,22 +74,25 @@ export class WindowNode extends WidgetNode {
         super.unmount();
     }
     updateProps(oldProps, newProps) {
-        if (!oldProps ||
-            oldProps.defaultWidth !== newProps.defaultWidth ||
-            oldProps.defaultHeight !== newProps.defaultHeight) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "defaultWidth") || hasChanged(oldProps, newProps, "defaultHeight")) {
             const width = newProps.defaultWidth ?? -1;
             const height = newProps.defaultHeight ?? -1;
             this.container.setDefaultSize(width, height);
         }
-        if (oldProps?.onClose !== newProps.onClose) {
+        if (hasChanged(oldProps, newProps, "onClose")) {
             const userHandler = newProps.onClose;
-            const wrappedHandler = () => {
-                userHandler?.();
-                return true;
-            };
-            signalStore.set(this, this.container, "close-request", wrappedHandler);
+            const wrappedHandler = userHandler
+                ? () => {
+                    userHandler();
+                    return true;
+                }
+                : undefined;
+            this.signalStore.set(this, this.container, "close-request", wrappedHandler);
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
     }
 }
 registerNodeClass(WindowNode);

package/dist/registry.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from "./node.js";
 import type { Container, Props } from "./types.js";
 type NodeClass<T = unknown, P = Props> = {
-    new (typeName: string, props: P, container: T, rootContainer?: Container): Node<T, P>;
+    new (typeName: string, props: P, container: T, rootContainer: Container): Node<T, P>;
 } & Omit<typeof Node, "prototype">;
 export declare const NODE_CLASSES: NodeClass[];
 export declare const registerNodeClass: <T, P>(nodeClass: NodeClass<T, P>) => void;

package/dist/render.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { discardAllBatches, start, stop } from "@gtkx/ffi";
+import { start, stop } from "@gtkx/ffi";
 import { createContext, useContext } from "react";
 import { formatBoundaryError, formatRenderError } from "./errors.js";
+import { getSignalStore } from "./nodes/internal/signal-store.js";
 import { reconciler } from "./reconciler.js";
 /**
  * React Context providing access to the GTK Application instance.
@@ -96,17 +97,18 @@ export const setHotReloading = (value) => {
  * @see {@link update} for hot-reloading the rendered tree
  */
 export const render = (element, appId, flags) => {
-    app = start(appId, flags);
+    const application = start(appId, flags);
+    app = application;
     const instance = reconciler.getInstance();
-    container = instance.createContainer(app, 1, null, false, null, "", (error) => {
-        discardAllBatches();
+    container = instance.createContainer(application, 1, null, false, null, "", (error) => {
+        getSignalStore(application).forceUnblockAll();
         throw formatRenderError(error);
     }, (error) => {
-        discardAllBatches();
+        getSignalStore(application).forceUnblockAll();
         const formattedError = formatBoundaryError(error);
         console.error(formattedError.toString());
     }, () => { }, () => { }, null);
-    instance.updateContainer(_jsx(ApplicationContext.Provider, { value: app, children: element }), container, null, () => { });
+    instance.updateContainer(_jsx(ApplicationContext.Provider, { value: application, children: element }), container, null, () => { });
 };
 /**
  * Updates the rendered React element tree.

package/dist/scheduler.d.ts

@@ -1,10 +1,20 @@
 type Callback = () => void;
+/**
+ * Priority levels for scheduling operations after React commit.
+ *
+ * Priority guidelines:
+ * - HIGH: Removals and detachments (must run before additions to avoid conflicts)
+ * - NORMAL: Additions and attachments (standard widget operations)
+ * - LOW: Sync operations that depend on all additions being complete (e.g., model updates)
+ *
+ * Within the same priority level, callbacks execute in FIFO order.
+ */
 export declare enum CommitPriority {
     /** Runs first. Used for widget removals to unparent before reparenting. */
     HIGH = 0,
     /** Runs after HIGH priority. Used for widget additions. */
     NORMAL = 1,
-    /** Runs last. Used for model sync operations that need all data to be added first. */
+    /** Runs after NORMAL. Used for model sync operations that need all data to be added first. */
     LOW = 2
 }
 /**