@gtkx/react 1.0.0-rc.2 → 1.0.0-rc.4

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,7 +9,7 @@ type TypeInfo = {
     userEventSignals: Set<string>;
     behaviors: ElementBehavior[];
     deferred: Set<string>;
-    lazy: boolean;
+    isLazy: boolean;
     hasFlush: boolean;
     hasMount: boolean;
     constructOnly: Set<string>;
@@ -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 ?? []));
 };
 
@@ -92,7 +92,7 @@ const buildTypeInfo = (name: string): TypeInfo => {
         userEventSignals: new Set(),
         behaviors: [],
         deferred: new Set(),
-        lazy: false,
+        isLazy: false,
         hasFlush: false,
         hasMount: false,
         constructOnly: new Set(),
@@ -105,10 +105,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 = {
@@ -21,7 +21,7 @@ type PlacedChild = {
     adopted: GObject.Object | null;
     slot: string;
     behavior: ElementBehavior | null;
-    attached: boolean;
+    isAttached: boolean;
 };
 
 type ElementNode = SignalTarget & {
@@ -129,7 +129,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,

package/src/reconciler/placement.ts

@@ -15,6 +15,7 @@ import {
     type PlaceableNode,
     type PlacedChild,
 } from "./node.js";
+import { applyWrite } from "./signals.js";
 import { markTextDirty } from "./text.js";
 
 type AttachContext = { parent: ElementNode; entry: PlacedChild; index: number; sibling: GObject.Object | null };
@@ -26,7 +27,7 @@ const createEntry = (slot: string, node: PlaceableNode): PlacedChild | null => {
         return null;
     }
 
-    return { node, object, adopted: null, slot, behavior: null, attached: false };
+    return { node, object, adopted: null, slot, behavior: null, isAttached: false };
 };
 
 const siblingAt = (entries: PlacedChild[], index: number): GObject.Object | null =>
@@ -69,11 +70,17 @@ const wireBufferView = (node: PlaceableNode, parent: ElementNode): void => {
     markTextDirty(node);
 };
 
+const writeSlot = (parent: ElementNode, entry: PlacedChild, value: GObject.Object | null): void => {
+    applyWrite(() => {
+        Reflect.set(parent.object, entry.slot, value);
+    });
+};
+
 const setObjectSlot = (parent: ElementNode, entry: PlacedChild): void => {
-    Reflect.set(parent.object, entry.slot, entry.object);
+    writeSlot(parent, entry, entry.object);
     wireBufferView(entry.node, parent);
     entry.behavior = null;
-    entry.attached = true;
+    entry.isAttached = true;
 };
 
 const didAttach = (ctx: AttachContext, behavior: ElementBehavior): boolean => {
@@ -92,13 +99,13 @@ const didAttach = (ctx: AttachContext, behavior: ElementBehavior): boolean => {
 
     ctx.entry.behavior = behavior;
     adoptedFrom(ctx.parent, ctx.entry, behavior, claim);
-    ctx.entry.attached = true;
+    ctx.entry.isAttached = true;
     applyLazyProps(ctx.entry);
 
     return true;
 };
 
-const attachEntry = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
+const runAttach = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
     const ctx: AttachContext = { parent, entry, index, sibling };
 
     for (const behavior of typeInfoFor(parent.typeName).behaviors) {
@@ -112,6 +119,12 @@ const attachEntry = (parent: ElementNode, entry: PlacedChild, index: number, sib
     }
 };
 
+const attachEntry = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
+    applyWrite(() => {
+        runAttach(parent, entry, index, sibling);
+    });
+};
+
 const detachInfo = (entry: PlacedChild, context: unknown): DetachInfo => ({
     slot: entry.slot,
     adopted: entry.adopted,
@@ -119,17 +132,12 @@ const detachInfo = (entry: PlacedChild, context: unknown): DetachInfo => ({
     context,
 });
 
-const detachEntry = (parent: ElementNode, entry: PlacedChild): void => {
-    if (!entry.attached) {
-        return;
-    }
-
-    entry.attached = false;
+const runDetach = (parent: ElementNode, entry: PlacedChild): void => {
     const behavior = entry.behavior;
 
     if (behavior === null) {
         if (entry.slot !== DEFAULT_SLOT) {
-            Reflect.set(parent.object, entry.slot, null);
+            writeSlot(parent, entry, null);
         }
 
         return;
@@ -138,6 +146,18 @@ const detachEntry = (parent: ElementNode, entry: PlacedChild): void => {
     behavior.detach?.(parent.object, entry.object, detachInfo(entry, getOrCreateContext(parent, behavior)));
 };
 
+const detachEntry = (parent: ElementNode, entry: PlacedChild): void => {
+    if (!entry.isAttached) {
+        return;
+    }
+
+    entry.isAttached = false;
+
+    applyWrite(() => {
+        runDetach(parent, entry);
+    });
+};
+
 const rebuild = (parent: ElementNode, entries: PlacedChild[]): void => {
     for (const entry of entries) {
         detachEntry(parent, entry);
@@ -155,7 +175,7 @@ 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) {
+    if (!entry.isAttached) {
         remove(entries, entry);
 
         return;

package/src/reconciler/registry.ts

@@ -5,59 +5,86 @@ 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`, `flush`, `mount` and `unmount` 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;
+    /** Runs once the node and its initial children are attached. */
     mount?: (object: T, context: unknown) => void;
+    /** Runs when React deletes the node. */
     unmount?: (object: T, context: unknown) => void;
+    /** Props to withhold from the constructor, leaving them for a later hook to apply. */
     deferred?: 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, and the base props interface its
- * generated props extend. `component` and `props` 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;
+    /** GObject properties to leave out of the generated props, such as those a behavior writes from children. */
+    omittedProps?: string[];
 };
 
 /**
@@ -66,7 +93,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[] => {
@@ -76,22 +102,19 @@ const mergeBehaviors = (base: ElementConfig, added: ElementBehavior[], isPrepend
 };
 
 const mergeConfigEntry = (base: ElementConfig, added: ElementConfig<never>, isPrepended = false): ElementConfig => {
-    const entry: ElementConfig = { ...base };
-
-    if (added.behaviors !== undefined) {
-        entry.behaviors = mergeBehaviors(entry, added.behaviors as ElementBehavior[], isPrepended);
-    }
+    const { behaviors, isLazy, omittedProps, ...rest } = added;
+    const entry: ElementConfig = { ...base, ...rest };
 
-    if (added.lazy === true) {
-        entry.lazy = true;
+    if (behaviors !== undefined) {
+        entry.behaviors = mergeBehaviors(base, behaviors as ElementBehavior[], isPrepended);
     }
 
-    if (added.component !== undefined) {
-        entry.component = added.component;
+    if (omittedProps !== undefined) {
+        entry.omittedProps = [...(base.omittedProps ?? []), ...omittedProps];
     }
 
-    if (added.props !== undefined) {
-        entry.props = added.props;
+    if (isLazy === true) {
+        entry.isLazy = true;
     }
 
     return entry;
@@ -99,8 +122,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 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> = {};
@@ -114,34 +138,38 @@ 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
- * editor autocompletion and type checking. Key each entry by GLib type name and annotate each hook's
- * object parameter with the concrete GObject class the behavior applies to.
+ * 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.
  */
 const defineElements = (elements: Record<string, ElementConfig<never>>): Record<string, ElementConfig<never>> =>
     elements;
 
-/** Spreads one config across many GLib type names. */
+/**
+ * Types one behavior against the GObject class it applies to, so every hook's object parameter is
+ * inferred rather than annotated by hand. Pass the class as the type argument.
+ *
+ * ```ts
+ * defineElements({
+ *     GtkFrame: { behaviors: [defineBehavior<Gtk.Frame>({ attach: (frame, child) => frame.setChild(child) })] },
+ * });
+ * ```
+ */
+const defineBehavior = <T extends GObject.Object>(hooks: ElementBehavior<T>): ElementBehavior<never> => hooks;
+
 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 {
@@ -150,6 +178,7 @@ export {
     mergeElementConfigs,
     registerElements,
     defineElements,
+    defineBehavior,
     forTypes,
     internal,
     type Props,

package/src/reconciler/root-element.ts

@@ -5,7 +5,6 @@ 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

@@ -1,10 +1,9 @@
-import type { ErrorInfo, ReactNode } from "react";
+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 { type Container, reconciler } from "./host-config.js";
 import { rootElement } from "./root-element.js";
-import { endSuppressionNow } from "./signals.js";
 
 type OpaqueRoot = { [opaqueRoot]: true };
 
@@ -16,7 +15,6 @@ type RootErrorCallbacks = {
 
 type ReconcilerRootOptions = RootErrorCallbacks & { containerInfo: Container };
 
-/** A root that mounts an element tree into an explicit container and reports render errors. */
 type ReconcilerRoot = {
     update: (element: ReactNode) => void;
     unmount: (teardown: (root: ReconcilerRoot) => Promise<void>) => Promise<void>;
@@ -24,7 +22,9 @@ type ReconcilerRoot = {
 
 /** 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;
 };
 
@@ -50,21 +50,13 @@ 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 => {
-    endSuppressionNow();
     throw error;
 };
 
 const logCaughtRenderError = (error: unknown): void => {
-    endSuppressionNow();
     log.error("caught render error", error);
 };
 
@@ -100,12 +92,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);
 
@@ -123,10 +109,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, {
@@ -156,13 +142,10 @@ 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): ReactNode =>
-    Object.assign(reconciler.createPortal(children, container, null, key ?? null), { type: "gtkx-portal", props: {} });
+const createPortal = (children: ReactNode, container: Container, key?: string): ReactPortal =>
+    reconciler.createPortal(children, container, null, key ?? null) as unknown as ReactPortal;
 
 export {
     setReconcilerErrorHandler,

package/src/reconciler/signals.ts

@@ -3,40 +3,20 @@ import { camelCase } from "@gtkx/utils";
 import type { HandlerRecord, SignalTarget } from "./node.js";
 import { type TypeInfo, typeInfoFor } from "./metadata.js";
 
-type SuppressionCounter = {
-    beginSuppression: () => void;
-    endSuppression: () => void;
-    endSuppressionNow: () => void;
-    isSuppressed: () => boolean;
-};
-
 const NOTIFY_DETAIL_PREFIX = "notify::";
-const suppressionCounter: SuppressionCounter = createSuppressionCounter();
-const beginSuppression: () => void = suppressionCounter.beginSuppression;
-const endSuppression: () => void = suppressionCounter.endSuppression;
-const endSuppressionNow: () => void = suppressionCounter.endSuppressionNow;
-const isSuppressed: () => boolean = suppressionCounter.isSuppressed;
-
-function createSuppressionCounter(): SuppressionCounter {
-    let depth = 0;
-
-    const release = (): void => {
-        if (depth > 0) {
-            depth -= 1;
-        }
-    };
+const writeState: { depth: number } = { depth: 0 };
 
-    return {
-        beginSuppression: () => {
-            depth += 1;
-        },
-        endSuppression: () => {
-            queueMicrotask(release);
-        },
-        endSuppressionNow: release,
-        isSuppressed: () => depth > 0,
-    };
-}
+const isApplyingWrite = (): boolean => writeState.depth > 0;
+
+const applyWrite = <T>(write: () => T): T => {
+    writeState.depth += 1;
+
+    try {
+        return write();
+    } finally {
+        writeState.depth = Math.max(0, writeState.depth - 1);
+    }
+};
 
 const getNotifyProperty = (signal: string): string | null =>
     signal.startsWith(NOTIFY_DETAIL_PREFIX) ? camelCase(signal.slice(NOTIFY_DETAIL_PREFIX.length)) : null;
@@ -56,7 +36,7 @@ const invokeHandler = (
 
 const wrapHandler = (target: SignalTarget, record: HandlerRecord, notifyProperty: string | null): SignalHandler =>
     (...args: unknown[]): unknown => {
-        if (record.blockable && isSuppressed()) {
+        if (record.isBlockable && isApplyingWrite()) {
             return undefined;
         }
 
@@ -78,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);
@@ -104,9 +84,8 @@ const disconnectAllHandlers = (target: SignalTarget): void => {
 };
 
 export {
-    beginSuppression,
-    endSuppression,
-    endSuppressionNow,
+    applyWrite,
+    isApplyingWrite,
     connectHandler,
     disconnectHandler,
     disconnectAllHandlers,