@gtkx/react 1.0.0-rc.3 → 1.0.0

package/src/reconciler/metadata.ts

@@ -1,6 +1,6 @@
 import { TYPE_INVALID, typeFromName, typeInterfaces, typeName, typeParent } from "@gtkx/runtime";
 import { getOrInsert } from "@gtkx/utils";
-import { CONSTRUCT_ONLY_PROPS, CONSTRUCT_PROPS, DEFAULT_PROPS, SIGNALS, userEventSignals } from "virtual:gtkx-config";
+import { constructOnlyProps, constructProps, defaultProps, signals, userEventSignals } from "virtual:gtkx-config";
 import { deferredProps, type ElementBehavior, ELEMENTS } from "./registry.js";
 
 type TypeInfo = {
@@ -9,9 +9,9 @@ type TypeInfo = {
     userEventSignals: Set<string>;
     behaviors: ElementBehavior[];
     deferred: Set<string>;
-    lazy: boolean;
+    declaredConstructOnly: Set<string>;
+    isLazy: boolean;
     hasFlush: boolean;
-    hasMount: boolean;
     constructOnly: Set<string>;
     construct: Set<string>;
     defaults: Record<string, unknown>;
@@ -58,10 +58,10 @@ const addAll = <T>(target: Set<T>, source: Iterable<T> | undefined): void => {
 };
 
 const accumulateAncestor = (info: TypeInfo, ancestor: string): void => {
-    Object.assign(info.signals, SIGNALS[ancestor] ?? {});
+    Object.assign(info.signals, signals[ancestor] ?? {});
     addAll(info.userEventSignals, userEventSignals[ancestor]);
-    addAll(info.constructOnly, CONSTRUCT_ONLY_PROPS[ancestor]);
-    addAll(info.construct, CONSTRUCT_PROPS[ancestor]);
+    addAll(info.constructOnly, constructOnlyProps[ancestor]);
+    addAll(info.construct, constructProps[ancestor]);
     info.behaviors.push(...(ELEMENTS[ancestor]?.behaviors ?? []));
 };
 
@@ -70,11 +70,8 @@ const applyBehaviorFlags = (info: TypeInfo, behavior: ElementBehavior): void =>
         info.hasFlush = true;
     }
 
-    if (behavior.mount !== undefined) {
-        info.hasMount = true;
-    }
-
     addAll(info.deferred, deferredProps(behavior));
+    addAll(info.declaredConstructOnly, behavior.constructOnly);
 };
 
 const resolveBehaviorFlags = (info: TypeInfo): void => {
@@ -92,9 +89,9 @@ const buildTypeInfo = (name: string): TypeInfo => {
         userEventSignals: new Set(),
         behaviors: [],
         deferred: new Set(),
-        lazy: false,
+        declaredConstructOnly: new Set(),
+        isLazy: false,
         hasFlush: false,
-        hasMount: false,
         constructOnly: new Set(),
         construct: new Set(),
         defaults: {},
@@ -105,10 +102,10 @@ const buildTypeInfo = (name: string): TypeInfo => {
     }
 
     resolveBehaviorFlags(info);
-    info.lazy = chain.some((ancestor) => ELEMENTS[ancestor]?.lazy === true);
+    info.isLazy = chain.some((ancestor) => ELEMENTS[ancestor]?.isLazy === true);
 
     for (const ancestor of chain.toReversed()) {
-        Object.assign(info.defaults, DEFAULT_PROPS[ancestor] ?? {});
+        Object.assign(info.defaults, defaultProps[ancestor] ?? {});
     }
 
     return info;

package/src/reconciler/node.ts

@@ -5,7 +5,7 @@ import { getOrInsert } from "@gtkx/utils";
 import type { ElementBehavior, Props } from "./registry.js";
 
 type ContentKind = "label" | "buffer" | "tag" | "anchor";
-type HandlerRecord = { signal: string; handler: SignalHandler; wrapped: SignalHandler; blockable: boolean };
+type HandlerRecord = { signal: string; handler: SignalHandler; wrapped: SignalHandler; isBlockable: boolean };
 type Dispatch = (fn: () => unknown) => unknown;
 
 type SignalTarget = {
@@ -18,10 +18,10 @@ type SignalTarget = {
 type PlacedChild = {
     node: PlaceableNode;
     object: GObject.Object;
+    typeName: string;
     adopted: GObject.Object | null;
     slot: string;
     behavior: ElementBehavior | null;
-    attached: boolean;
 };
 
 type ElementNode = SignalTarget & {
@@ -111,16 +111,18 @@ const createElementNode = (
 
 const createTextNode = (text: string): TextNode => ({ kind: TEXT_KIND, text, parent: null });
 
-const nodeObject = (node: PlaceableNode): GObject.Object | null => {
-    if (node.kind === LAZY_KIND) {
-        const [child] = node.children;
-
-        return child === undefined ? null : nodeObject(child);
+const leafElement = (node: PlaceableNode): ElementNode | null => {
+    if (node.kind !== LAZY_KIND) {
+        return node;
     }
 
-    return node.object;
+    const [child] = node.children;
+
+    return child === undefined ? null : leafElement(child);
 };
 
+const nodeObject = (node: PlaceableNode): GObject.Object | null => leafElement(node)?.object ?? null;
+
 const lazyTarget = (node: LazyNode, adopted: GObject.Object): SignalTarget => ({
     object: adopted,
     handlers: node.handlers,
@@ -129,7 +131,7 @@ const lazyTarget = (node: LazyNode, adopted: GObject.Object): SignalTarget => ({
 });
 
 const getOrCreateContext = (node: ElementNode, behavior: ElementBehavior): unknown =>
-    getOrInsert(node.contexts, behavior, () => behavior.createContext?.(node.object));
+    getOrInsert(node.contexts, behavior, () => behavior.initialize?.(node.object));
 
 export {
     ELEMENT_KIND,
@@ -141,6 +143,7 @@ export {
     createLazyNode,
     createElementNode,
     createTextNode,
+    leafElement,
     nodeObject,
     lazyTarget,
     getOrCreateContext,

package/src/reconciler/placement.ts

@@ -1,6 +1,6 @@
 import * as GObject from "@gtkx/gi/gobject";
 import * as Gtk from "@gtkx/gi/gtk";
-import { getOrInsert, indexBeforeOrEnd, remove } from "@gtkx/utils";
+import { getOrInsert, indexBeforeOrEnd } from "@gtkx/utils";
 import type { DetachInfo, ElementBehavior, PlaceInfo } from "./registry.js";
 import { applyAdoptedProps, markFlush } from "./apply-props.js";
 import { typeInfoFor } from "./metadata.js";
@@ -11,7 +11,7 @@ import {
     getOrCreateContext,
     LAZY_KIND,
     lazyTarget,
-    nodeObject,
+    leafElement,
     type PlaceableNode,
     type PlacedChild,
 } from "./node.js";
@@ -21,13 +21,20 @@ import { markTextDirty } from "./text.js";
 type AttachContext = { parent: ElementNode; entry: PlacedChild; index: number; sibling: GObject.Object | null };
 
 const createEntry = (slot: string, node: PlaceableNode): PlacedChild | null => {
-    const object = nodeObject(node);
+    const leaf = leafElement(node);
 
-    if (object === null) {
+    if (leaf === null) {
         return null;
     }
 
-    return { node, object, adopted: null, slot, behavior: null, attached: false };
+    return {
+        node,
+        object: leaf.object,
+        typeName: leaf.typeName,
+        adopted: null,
+        slot,
+        behavior: null,
+    };
 };
 
 const siblingAt = (entries: PlacedChild[], index: number): GObject.Object | null =>
@@ -80,7 +87,6 @@ const setObjectSlot = (parent: ElementNode, entry: PlacedChild): void => {
     writeSlot(parent, entry, entry.object);
     wireBufferView(entry.node, parent);
     entry.behavior = null;
-    entry.attached = true;
 };
 
 const didAttach = (ctx: AttachContext, behavior: ElementBehavior): boolean => {
@@ -99,12 +105,19 @@ const didAttach = (ctx: AttachContext, behavior: ElementBehavior): boolean => {
 
     ctx.entry.behavior = behavior;
     adoptedFrom(ctx.parent, ctx.entry, behavior, claim);
-    ctx.entry.attached = true;
     applyLazyProps(ctx.entry);
 
     return true;
 };
 
+const unclaimedChildError = (parentTypeName: string, childTypeName: string): Error =>
+    new Error(
+        `<${childTypeName}> cannot be a child of <${parentTypeName}>. Pass it to the ` +
+        `<${parentTypeName}> prop that takes it, if there is one, portal it to rootElement with createPortal ` +
+        `if it does not belong inside <${parentTypeName}>, or register an attach behavior for ` +
+        `<${parentTypeName}> with defineElements from "@gtkx/react/config" if it belongs among its children.`,
+    );
+
 const runAttach = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
     const ctx: AttachContext = { parent, entry, index, sibling };
 
@@ -114,9 +127,11 @@ const runAttach = (parent: ElementNode, entry: PlacedChild, index: number, sibli
         }
     }
 
-    if (entry.slot !== DEFAULT_SLOT) {
-        setObjectSlot(parent, entry);
+    if (entry.slot === DEFAULT_SLOT) {
+        throw unclaimedChildError(parent.typeName, entry.typeName);
     }
+
+    setObjectSlot(parent, entry);
 };
 
 const attachEntry = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
@@ -136,9 +151,7 @@ const runDetach = (parent: ElementNode, entry: PlacedChild): void => {
     const behavior = entry.behavior;
 
     if (behavior === null) {
-        if (entry.slot !== DEFAULT_SLOT) {
-            writeSlot(parent, entry, null);
-        }
+        writeSlot(parent, entry, null);
 
         return;
     }
@@ -147,12 +160,6 @@ const runDetach = (parent: ElementNode, entry: PlacedChild): void => {
 };
 
 const detachEntry = (parent: ElementNode, entry: PlacedChild): void => {
-    if (!entry.attached) {
-        return;
-    }
-
-    entry.attached = false;
-
     applyWrite(() => {
         runDetach(parent, entry);
     });
@@ -174,13 +181,6 @@ const getPosition = (entries: PlacedChild[], before: PlaceableNode | null): numb
 
 const placeNew = (parent: ElementNode, entry: PlacedChild, entries: PlacedChild[], index: number): void => {
     attachEntry(parent, entry, index, siblingAt(entries, index));
-
-    if (!entry.attached) {
-        remove(entries, entry);
-
-        return;
-    }
-
     const isInsertedBeforeEnd = index < entries.length - 1;
     const isCannotReorderInPlace = entry.behavior !== null && entry.behavior.reorder === undefined;
 

package/src/reconciler/registry.ts

@@ -5,62 +5,88 @@ type Props = Record<string, unknown>;
 
 /** Per-child values a slot hook receives while placing or moving one child. */
 type PlaceInfo = {
+    /** Name of the slot being filled: `children`, or the prop the child was nested under. */
     slot: string;
+    /** Position of the child among the slot's children. */
     index: number;
+    /** Object of the preceding child in the slot, or null when the child comes first. */
     sibling: GObject.Object | null;
+    /** Object adopted for this child by an earlier attach, or null before it has one. */
     adopted: GObject.Object | null;
+    /** Props of the child element. */
     props: Props;
+    /** Value `initialize` returned for this behavior on the parent. */
     context: unknown;
 };
 
 /** Per-child values a slot hook receives while removing one child. */
 type DetachInfo = {
+    /** Name of the slot the child is leaving. */
     slot: string;
+    /** Object the container adopted for this child, or null when it adopted none. */
     adopted: GObject.Object | null;
+    /** Props of the child element. */
     props: Props;
+    /** Value `initialize` returned for this behavior on the parent. */
     context: unknown;
 };
 
 /**
- * Customizes how one element type places children and applies props. Every hook receives the
- * GObject instance and a private per-node `context` built once by `createContext`. A slot hook
- * claims a child by returning a non-`undefined` value; that value, or `resolve`, is the object
- * the container adopts for the child. `update` returns the prop names it consumed so those props
- * are not also set as plain GObject properties. `create` builds the GObject for types whose
- * constructor does more than set properties, and is consulted for its own type only, never
- * inherited by subtypes.
+ * Customizes how one element type places children and applies props. Hooks other than `create` receive the
+ * GObject instance; `update` and `flush` also take the private per-node context `initialize` built, and
+ * `attach`, `reorder` and `detach` read it off their info object. Subtypes inherit a type's behaviors,
+ * except for `create`, which is consulted only for the type it is registered on.
  */
 type ElementBehavior<T extends GObject.Object = GObject.Object> = {
+    /** Builds the GObject from its construct props, for types whose constructor does more than set properties. */
     create?: (props: Props) => GObject.Object;
-    createContext?: (object: T) => unknown;
+    /** Builds the private per-node context the other hooks receive, once per node. */
+    initialize?: (object: T) => unknown;
+    /** Places a child, claiming it by returning anything other than `undefined`. */
     attach?: (object: T, child: GObject.Object, info: PlaceInfo) => unknown;
+    /** Moves an already-attached child; without it, the whole slot is detached and re-attached in order. */
     reorder?: (object: T, child: GObject.Object, info: PlaceInfo) => unknown;
+    /** Removes a child this behavior attached. */
     detach?: (object: T, child: GObject.Object, info: DetachInfo) => void;
+    /** Returns the object the container adopts for a child, overriding whatever `attach` returned. */
     resolve?: (object: T, child: GObject.Object) => GObject.Object | null;
+    /** Applies changed props and returns the names it consumed, which are then not set as GObject properties. */
     update?: (object: T, prev: Props, next: Props, context: unknown) => Iterable<string> | undefined;
+    /** Runs after the commit that touched the node, once every child has been placed. */
     flush?: (object: T, context: unknown) => void;
-    mount?: (object: T, context: unknown) => void;
-    unmount?: (object: T, context: unknown) => void;
+    /** Props to withhold from the constructor, leaving them for a later hook to apply. */
     deferred?: string[];
+    /**
+     * Props the behavior can only apply while the element is being built, because the library exposes no
+     * counterpart to whatever applied them. Changing one after it has been applied throws instead of
+     * silently applying the new value on top of the old.
+     */
+    constructOnly?: string[];
 };
 
 /** A named export in a module, referenced as plain data (the module is never imported at runtime). */
-type ModuleExport = { module: string; export: string };
+type ModuleExport = {
+    /** Specifier the export is imported from. */
+    module: string;
+    /** Identifier the module exports it under. */
+    export: string;
+};
 
 /**
- * Per-element configuration keyed by GLib type name: whether the element is lazy (its GObject is
- * created by its parent container, as pages and layout children are), the custom behaviors bound to
- * its type, an optional component that wraps the generated element, the base props interface its
- * generated props extend, and the GObject properties to leave out of the generated props (those a
- * behavior already writes from children, such as the `child` and `content` properties). `component`,
- * `props` and `omitProps` are inert at runtime; they are read only by codegen.
+ * How one GLib type is rendered. `component`, `props` and `omittedProps` are inert at runtime; they are
+ * read only by codegen.
  */
 type ElementConfig<T extends GObject.Object = GObject.Object> = {
-    lazy?: boolean;
+    /** The element has no GObject of its own; its parent container creates one, as it does for pages. */
+    isLazy?: boolean;
+    /** Behaviors bound to the type, consulted in registration order and inherited by its subtypes. */
     behaviors?: ElementBehavior<T>[];
+    /** Component that wraps the generated element. */
     component?: ModuleExport;
+    /** Base props interface the generated props extend. */
     props?: ModuleExport;
-    omitProps?: string[];
+    /** GObject properties to leave out of the generated props, such as those a behavior writes from children. */
+    omittedProps?: string[];
 };
 
 /**
@@ -69,7 +95,6 @@ type ElementConfig<T extends GObject.Object = GObject.Object> = {
  */
 const ELEMENTS: Record<string, ElementConfig> = {};
 
-/** Props a behavior applies after construction; the constructor is never given them. */
 const deferredProps = (behavior: ElementBehavior): string[] => behavior.deferred ?? [];
 
 const mergeBehaviors = (base: ElementConfig, added: ElementBehavior[], isPrepended: boolean): ElementBehavior[] => {
@@ -79,19 +104,19 @@ const mergeBehaviors = (base: ElementConfig, added: ElementBehavior[], isPrepend
 };
 
 const mergeConfigEntry = (base: ElementConfig, added: ElementConfig<never>, isPrepended = false): ElementConfig => {
-    const { behaviors, lazy, omitProps, ...rest } = added;
+    const { behaviors, isLazy, omittedProps, ...rest } = added;
     const entry: ElementConfig = { ...base, ...rest };
 
     if (behaviors !== undefined) {
         entry.behaviors = mergeBehaviors(base, behaviors as ElementBehavior[], isPrepended);
     }
 
-    if (omitProps !== undefined) {
-        entry.omitProps = [...(base.omitProps ?? []), ...omitProps];
+    if (omittedProps !== undefined) {
+        entry.omittedProps = [...(base.omittedProps ?? []), ...omittedProps];
     }
 
-    if (lazy === true) {
-        entry.lazy = true;
+    if (isLazy === true) {
+        entry.isLazy = true;
     }
 
     return entry;
@@ -99,9 +124,9 @@ const mergeConfigEntry = (base: ElementConfig, added: ElementConfig<never>, isPr
 
 /**
  * Merges maps of {@link ElementConfig} keyed by GLib type name into one, concatenating each type's
- * behaviors and omitted props in the order the maps are given (an earlier map's behaviors come first)
- * and taking the last lazy flag, component, and props seen. Use it to combine an app's element config
- * with its behaviors.
+ * behaviors and omitted props in the order the maps are given (an earlier map's behaviors come first),
+ * taking the last component and props seen, and marking a type lazy if any map does. Use it to combine
+ * an app's element config with its behaviors.
  */
 const mergeElementConfigs = (...maps: Record<string, ElementConfig<never>>[]): Record<string, ElementConfig> => {
     const merged: Record<string, ElementConfig> = {};
@@ -115,23 +140,17 @@ const mergeElementConfigs = (...maps: Record<string, ElementConfig<never>>[]): R
     return merged;
 };
 
-/**
- * Registers a map of {@link ElementConfig} keyed by GLib type name, merging each entry into the
- * registry. Behaviors are appended by default (the framework's built-ins register this way); pass
- * `{ prepend: true }` for an app's own configuration so its behaviors are consulted before the
- * built-ins for the same slot, letting it override them regardless of registration order.
- */
 const registerElements = (
     map: Record<string, ElementConfig<never>>,
-    options: { prepend?: boolean } = {},
+    options: { isPrepended?: boolean } = {},
 ): void => {
     for (const [type, config] of Object.entries(map)) {
-        ELEMENTS[type] = mergeConfigEntry(ELEMENTS[type] ?? {}, config, options.prepend === true);
+        ELEMENTS[type] = mergeConfigEntry(ELEMENTS[type] ?? {}, config, options.isPrepended === true);
     }
 };
 
 /**
- * Identity helper that types the module named by the `elements` entry of `gtkx.config.ts`, enabling
+ * Identity helper that types the module named by `elements.behaviors` in `gtkx.config.ts`, enabling
  * editor autocompletion and type checking. Key each entry by GLib type name and write each behavior
  * with {@link defineBehavior} so its hooks receive the concrete GObject class.
  */
@@ -150,11 +169,9 @@ const defineElements = (elements: Record<string, ElementConfig<never>>): Record<
  */
 const defineBehavior = <T extends GObject.Object>(hooks: ElementBehavior<T>): ElementBehavior<never> => hooks;
 
-/** Spreads one config across many GLib type names. */
 const forTypes = (types: string[], config: ElementConfig<never>): Record<string, ElementConfig<never>> =>
     Object.fromEntries(types.map((type) => [type, config]));
 
-/** References a base props interface exported from `@gtkx/react/internal`. */
 const internal = (name: string): ModuleExport => ({ module: "@gtkx/react/internal", export: name });
 
 export {

package/src/reconciler/root-element.ts

@@ -1,11 +1,13 @@
 /** The type of the shared {@link rootElement} marker used as a default top-level container. */
-type RootElement = { [ROOT_ELEMENT_BRAND]: true };
+type RootElement = {
+    /** Marks a container as the top level rather than a GObject; `isRootElement` tests for it. */
+    [ROOT_ELEMENT_BRAND]: true;
+};
 
 const ROOT_ELEMENT_BRAND: unique symbol = Symbol.for("gtkx:root-element");
 /** A shared marker value used as the default top-level container for rendering and portals. */
 const rootElement: RootElement = { [ROOT_ELEMENT_BRAND]: true };
 
-/** Reports whether an arbitrary value is a {@link rootElement} marker. */
 const isRootElement = (value: unknown): value is RootElement =>
     typeof value === "object" && value !== null && Object.hasOwn(value, ROOT_ELEMENT_BRAND);
 

package/src/reconciler/root.ts

@@ -2,6 +2,7 @@ import type { ErrorInfo, ReactNode, ReactPortal } from "react";
 import * as Gdk from "@gtkx/gi/gdk";
 import { createLogger, type Logger } from "@gtkx/utils";
 import { ConcurrentRoot } from "react-reconciler/constants.js";
+import { injectIntoDevTools } from "./devtools.js";
 import { type Container, reconciler } from "./host-config.js";
 import { rootElement } from "./root-element.js";
 
@@ -15,15 +16,19 @@ type RootErrorCallbacks = {
 
 type ReconcilerRootOptions = RootErrorCallbacks & { containerInfo: Container };
 
-/** A root that mounts an element tree into an explicit container and reports render errors. */
+/** A render root whose updates and teardown the caller drives, with error handling left to it. */
 type ReconcilerRoot = {
+    /** Mounts an element tree into the container, or updates the tree already mounted there. */
     update: (element: ReactNode) => void;
+    /** Hands the root to `teardown`, then stops {@link quit} from unmounting the container. */
     unmount: (teardown: (root: ReconcilerRoot) => Promise<void>) => Promise<void>;
 };
 
 /** The object {@link createRoot} returns: it renders an element tree into a container and can tear it down. */
 type Root = {
+    /** Mounts an element tree into the container, or updates the tree already mounted there. */
     render: (element: ReactNode) => void;
+    /** Unmounts the rendered tree and runs its effect cleanups. */
     unmount: () => void;
 };
 
@@ -49,12 +54,6 @@ function createErrorHandlerSlot(): ErrorHandlerSlot {
     };
 }
 
-/**
- * Installs a process-wide handler for errors thrown while rendering or applying an update.
- *
- * @param handler The handler to install.
- * @returns The previously installed handler, or null.
- */
 const setReconcilerErrorHandler = (handler: ErrorHandler): ErrorHandler | null => errorHandlerSlot.set(handler);
 
 const rethrowUncaughtRenderError = (error: unknown): never => {
@@ -66,6 +65,8 @@ const logCaughtRenderError = (error: unknown): void => {
 };
 
 const openContainer = (containerInfo: Container, callbacks: RootErrorCallbacks): OpaqueRoot => {
+    injectIntoDevTools(reconciler);
+
     const container = reconciler.createContainer(
         containerInfo,
         ConcurrentRoot,
@@ -97,12 +98,6 @@ const unmountContainer = (container: OpaqueRoot): void => {
     activeRoots.delete(container);
 };
 
-/**
- * Creates a root that mounts an element tree into a container, routing render errors to the supplied callbacks.
- *
- * @param options The container to render into and the error callbacks to route failures to.
- * @returns A {@link ReconcilerRoot}.
- */
 const createReconcilerRoot = (options: ReconcilerRootOptions): ReconcilerRoot => {
     const container = openContainer(options.containerInfo, options);
 
@@ -120,10 +115,10 @@ const createReconcilerRoot = (options: ReconcilerRootOptions): ReconcilerRoot =>
 };
 
 /**
- * Creates a render root for a GTKX application.
+ * Creates a render root for a GTKX application. Uncaught render errors are rethrown and errors caught by an
+ * error boundary are logged.
  *
- * @param container The top-level container to render into; defaults to the shared {@link rootElement}.
- * @returns A {@link Root} exposing render and unmount.
+ * @param container The GObject to render into; defaults to the shared {@link rootElement}, which holds no object.
  */
 const createRoot = (container: Container = rootElement): Root => {
     const opaque = openContainer(container, {
@@ -153,10 +148,7 @@ const quit = (): typeof Gdk.EVENT_STOP => {
 /**
  * Renders children into a container other than the surrounding tree.
  *
- * @param children The element tree to render.
- * @param container The GObject, application, or {@link rootElement} to render into.
- * @param key An optional stable key.
- * @returns A React portal.
+ * @param container The GObject to render into, or {@link rootElement} to render at the top level.
  */
 const createPortal = (children: ReactNode, container: Container, key?: string): ReactPortal =>
     reconciler.createPortal(children, container, null, key ?? null) as unknown as ReactPortal;

package/src/reconciler/signals.ts

@@ -36,7 +36,7 @@ const invokeHandler = (
 
 const wrapHandler = (target: SignalTarget, record: HandlerRecord, notifyProperty: string | null): SignalHandler =>
     (...args: unknown[]): unknown => {
-        if (record.blockable && isApplyingWrite()) {
+        if (record.isBlockable && isApplyingWrite()) {
             return undefined;
         }
 
@@ -58,7 +58,7 @@ const connectHandler = (target: SignalTarget, prop: string, signal: string, hand
 
     const isBlockable = isBlockableSignal(typeInfoFor(target.typeName), signal);
     const notifyProperty = getNotifyProperty(signal);
-    const record: HandlerRecord = { signal, handler, wrapped: (): undefined => undefined, blockable: isBlockable };
+    const record: HandlerRecord = { signal, handler, wrapped: (): undefined => undefined, isBlockable };
     record.wrapped = wrapHandler(target, record, notifyProperty);
     target.object.on(signal, record.wrapped);
     target.handlers.set(prop, record);
@@ -85,7 +85,6 @@ const disconnectAllHandlers = (target: SignalTarget): void => {
 
 export {
     applyWrite,
-    isApplyingWrite,
     connectHandler,
     disconnectHandler,
     disconnectAllHandlers,

package/src/reconciler/text.ts

@@ -7,7 +7,7 @@ import type { Props } from "./registry.js";
 import { ELEMENT_KIND, TEXT_KIND } from "./node.js";
 import { applyWrite } from "./signals.js";
 
-type OffsetResult = { found: boolean; offset: number };
+type OffsetResult = { wasFound: boolean; offset: number };
 
 type BufferBuild = {
     buffer: Gtk.TextBuffer;
@@ -76,14 +76,14 @@ const isTagElement = (node: ContentChild): node is ElementNode =>
 
 const stepOffset = (node: ContentChild, target: TextNode, offset: number): OffsetResult => {
     if (node === target) {
-        return { found: true, offset };
+        return { wasFound: true, offset };
     }
 
     if (isTagElement(node)) {
         return getOffset(node.content, target, offset);
     }
 
-    return { found: false, offset: offset + contentTextLength(node) };
+    return { wasFound: false, offset: offset + contentTextLength(node) };
 };
 
 const getOffset = (nodes: ContentChild[], target: TextNode, start: number): OffsetResult => {
@@ -92,14 +92,14 @@ const getOffset = (nodes: ContentChild[], target: TextNode, start: number): Offs
     for (const node of nodes) {
         const step = stepOffset(node, target, offset);
 
-        if (step.found) {
+        if (step.wasFound) {
             return step;
         }
 
         offset = step.offset;
     }
 
-    return { found: false, offset };
+    return { wasFound: false, offset };
 };
 
 const enclosingTagNodes = (node: TextNode): ElementNode[] => {
@@ -379,7 +379,7 @@ const didUpdateTextSurgically = (host: ElementNode, node: TextNode, oldText: str
 
     const located = getOffset(host.content, node, 0);
 
-    if (!located.found) {
+    if (!located.wasFound) {
         return false;
     }