@symbiote-native/test-utils 0.3.0 → 0.4.0

package/build/recording-host.js

@@ -0,0 +1,409 @@
+/**
+ * A tree host that RECORDS and derives nothing — for the 141 test files that never read a tree.
+ *
+ * Those files call `installFabric()` only because that is how a test gets a host at all: they
+ * assert on state machines, prop resolution, listeners, styles. Attaching them to a second
+ * implementation of Fabric's tree rules buys them nothing and costs the project a mirror.
+ *
+ * **Why this is not one.** It keeps the AUTHORED tree — who was appended to whom, what props were
+ * set — because that is what the ops literally say and what an adapter's own seam asks back
+ * (Solid's `getParentNode`, Vue's `nextSibling`, Svelte's `firstChild`). It does not decide what
+ * COMMITS: no flattening, no stacking contexts, no virtual nodes, no clone protocol, no view-name
+ * rewriting. There is no derived answer here to be wrong, which is the whole difference between
+ * recording a statement and re-deriving a conclusion.
+ *
+ * A test that needs the committed tree belongs in `core/engine/cpp/tests/js`, where React Native
+ * answers. Asking one of those questions here gets `undefined` rather than a plausible lie.
+ */
+import { NO_VALUE, OP_APPEND_CHILD, OP_COMMIT, OP_CREATE_ANCHOR, OP_CREATE_ELEMENT, OP_CREATE_RAW_TEXT, OP_INSERT_BEFORE, OP_REMOVE_CHILD, OP_SET_COMPONENT, OP_SET_OWNED_LISTENER, OP_SET_TAG, OP_SET_UNDERLAY_SHOWN, OP_SET_PROP, OP_SET_TEXT, OP_STRIDE, } from '@symbiote-native/engine/mutation-buffer';
+import { fabricProps, isSymbioteNode, propsOf, setTreeHost, } from '@symbiote-native/engine';
+/**
+ * Install the recording host, with the minimum slot the engine insists on.
+ *
+ * `createSurface` calls `installEventHandler`, which reaches `globalThis.nativeFabricUIManager` and
+ * throws if it is absent — so a host alone is not enough to get a surface open. The slot below
+ * exists to be PRESENT: every method answers nothing except `registerEventHandler`, which hands the
+ * engine's handler to the host so `fireEvent` can play it back.
+ *
+ * What that does NOT buy is a real gesture. Deciding which node a touch lands on is hit-testing,
+ * and that is the renderer's answer; a test that needs it belongs in `core/engine/cpp/tests/js`.
+ */
+export function installRecordingFabric() {
+    const host = createRecordingHost();
+    Object.assign(globalThis, {
+        nativeFabricUIManager: {
+            registerEventHandler(handler) {
+                host.registerEventHandler(handler);
+            },
+            dispatchCommand() { },
+            setIsJSResponder() { },
+            sendAccessibilityEvent() { },
+            measure() { },
+            measureInWindow() { },
+            measureLayout() { },
+        },
+    });
+    setTreeHost(host);
+    return host;
+}
+/**
+ * The Fabric payload for a node — what the engine WOULD hand the renderer for it, built by the
+ * engine's own builder rather than read off anything.
+ *
+ * This exists because the two are easy to confuse and the difference bites: a node's PROPS are the
+ * author's bag (`style` is still an object), while the PAYLOAD is what `fabricProps` makes of it —
+ * style flattened into top-level keys, the aria fold run, the ten RN processors applied. A test
+ * asking about `padding` or `accessibilityRole` or a parsed `backgroundSize` means the payload, and
+ * reading the bag instead comes back `undefined` with nothing to explain why.
+ */
+export function payloadOf(node) {
+    return fabricProps(node, propsOf(node));
+}
+/**
+ * Where a tag would be. Not a Fabric tag and not pretending to be one — this host never speaks to
+ * Fabric, so any number here would be an invention.
+ */
+const NO_TAG = -1;
+export function createRecordingHost() {
+    let recorded = new WeakMap();
+    let eventHandler;
+    // The WeakMap above cannot be enumerated, and `find` has to start somewhere. Strong references,
+    // so `forget()` is what a long file calls to stop this growing — the same deal `installFabric`'s
+    // `created` array made.
+    let created = [];
+    const nodeOf = (handle, what) => {
+        const node = recorded.get(handle);
+        if (node === undefined) {
+            throw new Error(`${what}: handle names no node in this tree`);
+        }
+        return node;
+    };
+    const detach = (node) => {
+        const { parent } = node;
+        if (parent === undefined)
+            return;
+        const at = parent.children.indexOf(node);
+        if (at >= 0)
+            parent.children.splice(at, 1);
+        node.parent = undefined;
+    };
+    // Lands a rootTag onto a whole subtree at OP_COMMIT, the same moment the real engine hands every
+    // node in the walk its own `ShadowNode`. `committedRootTag` never gets cleared afterwards, so a
+    // node removed after this still answers `committedRecordOf` — see that field's own comment.
+    const markCommitted = (node, rootTag) => {
+        node.committedRootTag = rootTag;
+        for (const child of node.children)
+            markCommitted(child, rootTag);
+    };
+    const host = {
+        commits: 0,
+        commands: [],
+        responderHandovers: [],
+        accessibilityEvents: [],
+        applyOps(batch) {
+            const { ops, strings, values, handles, instanceHandles } = batch;
+            const handleAt = (slot) => {
+                const handle = handles[slot];
+                if (handle === undefined) {
+                    throw new Error(`applyOps: slot ${slot} is outside this batch's handles`);
+                }
+                return handle;
+            };
+            const at = (slot) => nodeOf(handleAt(slot), 'applyOps');
+            const create = (slot, viewName, props, instanceHandle) => {
+                const handle = handleAt(slot);
+                // Checked rather than assumed: the batch types handles as `object`, and the whole value of
+                // holding the node is being able to hand it back to the engine's own API.
+                if (!isSymbioteNode(handle)) {
+                    throw new Error('applyOps: a handle in this batch is not an engine node');
+                }
+                const node = {
+                    handle,
+                    instanceHandle,
+                    viewName,
+                    tagName: '',
+                    ownedListeners: {},
+                    underlayShown: false,
+                    props,
+                    parent: undefined,
+                    children: [],
+                    committedRootTag: undefined,
+                };
+                recorded.set(handle, node);
+                created.push(node);
+            };
+            for (let cursor = 0; cursor + OP_STRIDE <= ops.length; cursor += OP_STRIDE) {
+                const code = ops[cursor];
+                const a = ops[cursor + 1];
+                const b = ops[cursor + 2];
+                const c = ops[cursor + 3];
+                const d = ops[cursor + 4];
+                switch (code) {
+                    case OP_CREATE_ELEMENT:
+                        // Slot 4 is the index into `instanceHandles` — the object Fabric would hand back with
+                        // an event. Recorded because it is what the op SAYS, and because a test firing an
+                        // event has to name the same object the engine registered.
+                        create(a, strings[b], {}, instanceHandles[d]);
+                        break;
+                    case OP_CREATE_RAW_TEXT:
+                        create(a, 'RCTRawText', { text: strings[b] });
+                        break;
+                    case OP_CREATE_ANCHOR:
+                        create(a, '', {});
+                        break;
+                    case OP_APPEND_CHILD: {
+                        const child = at(b);
+                        detach(child);
+                        child.parent = at(a);
+                        at(a).children.push(child);
+                        break;
+                    }
+                    case OP_INSERT_BEFORE: {
+                        const parent = at(a);
+                        const child = at(b);
+                        const before = at(c);
+                        detach(child);
+                        child.parent = parent;
+                        const index = parent.children.indexOf(before);
+                        parent.children.splice(index < 0 ? parent.children.length : index, 0, child);
+                        break;
+                    }
+                    case OP_REMOVE_CHILD:
+                        detach(at(b));
+                        break;
+                    case OP_SET_PROP: {
+                        const node = at(a);
+                        if (c === NO_VALUE)
+                            delete node.props[strings[b]];
+                        else
+                            node.props[strings[b]] = values[c];
+                        break;
+                    }
+                    case OP_SET_TEXT:
+                        at(a).props.text = strings[b];
+                        break;
+                    case OP_SET_COMPONENT:
+                        at(a).viewName = strings[b];
+                        break;
+                    // RECORDED AND NOT ACTED ON, deliberately. The real host resolves a tag's platform props
+                    // off this (`foldPressableProps`); this host builds its payload through the TypeScript
+                    // `fabricProps`, which carries no copy of those rules and must not grow one — a second
+                    // implementation is how a test goes green over a rule that no longer runs. A test that
+                    // needs to read what a tag actually sends belongs in `core/engine/cpp/tests/js`.
+                    case OP_SET_TAG:
+                        at(a).tagName = strings[b];
+                        break;
+                    // RECORDED, NOT APPLIED, exactly like the tag above. The real host resolves `focusable`'s
+                    // three-leg touchable form off this bit; this host builds its payload through the
+                    // TypeScript `fabricProps`, which carries no copy of the tag rules and must not grow one.
+                    // So a test that wants the resolved key reads the committed payload in an itest, and what
+                    // this records is the fact a test can ASK about.
+                    case OP_SET_OWNED_LISTENER:
+                        at(a).ownedListeners[strings[b]] = c !== 0;
+                        break;
+                    // Same treatment, and for the same reason: the real host paints TouchableHighlight's
+                    // underlay from this bit (`foldTouchableHighlightUnderlay`), and this one must not grow a
+                    // copy of that rule. Recorded so a test can ask whether the MACHINE flipped it — which is
+                    // the half that is still JS — while what the flip LOOKS like is asserted on a committed
+                    // payload in `core/engine/cpp/tests/js/touchable-highlight-underlay.itest.ts`.
+                    case OP_SET_UNDERLAY_SHOWN:
+                        at(a).underlayShown = b !== 0;
+                        break;
+                    case OP_COMMIT: {
+                        host.commits += 1;
+                        markCommitted(at(b), a);
+                        break;
+                    }
+                    default:
+                        throw new Error(`applyOps: unknown opcode ${String(code)}`);
+                }
+            }
+        },
+        propOf(handle, key) {
+            return nodeOf(handle, 'propOf').props[key];
+        },
+        propsOf(handle) {
+            return nodeOf(handle, 'propsOf').props;
+        },
+        // Nothing is memoized here, so there is nothing to invalidate.
+        markPropsDirty() { },
+        /**
+         * A record for a node standing under a surface the ops COMMITTED, and nothing more.
+         *
+         * The engine gates every imperative call on this, so answering `undefined` always would make
+         * `dispatchCommand` unreachable and quietly turn four command tests green-by-absence. What is
+         * answered here is read straight off the op stream — there WAS a commit, and this node is under
+         * that surface — with no claim about what the renderer did with it: no tag Fabric minted, no
+         * view that survived flattening, no guarantee it is mounted. A test that needs any of those
+         * belongs in `core/engine/cpp/tests/js`.
+         *
+         * `handle` is the authored node and `tag` is `NO_TAG`, so a test reading either gets something
+         * obviously not-from-Fabric rather than a plausible number. `rootTag` is real, not invented —
+         * see `IRecorded.committedRootTag`'s own comment for why the JS-level surface identifier is a
+         * different unknown from the native Fabric tag.
+         *
+         * Read off `committedRootTag` (set once per node at the commit that landed it, never cleared),
+         * not a live walk to a committed root — `removeChild` cuts the parent link before a behavior's
+         * teardown sweep runs in the SAME commit, so a walk answers `undefined` for exactly the node a
+         * parting write (`TextInput`'s unmount blur) needs to still reach. `node->committed` in the real
+         * engine works the same way, and for the same reason.
+         */
+        committedRecordOf(handle) {
+            const node = recorded.get(handle);
+            if (node === undefined || node.committedRootTag === undefined) {
+                return undefined;
+            }
+            return {
+                handle,
+                tag: NO_TAG,
+                rootTag: node.committedRootTag,
+            };
+        },
+        /**
+         * REFUSED, loudly, and that is the whole point of implementing it here.
+         *
+         * This host records the OPS it was handed; it never builds a Fabric payload, because building
+         * one is `SymbioteFabricProps.cpp`'s job and that code does not exist in a vitest process. An
+         * answer synthesised from the JS twin would be a test asserting against the wrong
+         * implementation — the exact drift `ITreeHost.committedPayloadOf` was added to close.
+         *
+         * So a test asking this question belongs in `core/engine/cpp/tests/js/` (`pnpm run test:itest`),
+         * where the real builder runs. `.props` on this host stays the read for "what did the adapter
+         * SAY", which is a different and still-useful question.
+         */
+        committedPayloadOf() {
+            throw new Error('recording host: committedPayloadOf needs the real payload builder — move this to an itest');
+        },
+        parentOf(handle) {
+            return nodeOf(handle, 'parentOf').parent?.handle;
+        },
+        childrenOf(handle) {
+            return nodeOf(handle, 'childrenOf').children.map(child => child.handle);
+        },
+        firstChildOf(handle) {
+            return nodeOf(handle, 'firstChildOf').children[0]?.handle;
+        },
+        nextSiblingOf(handle) {
+            const node = nodeOf(handle, 'nextSiblingOf');
+            const siblings = node.parent?.children;
+            if (siblings === undefined)
+                return undefined;
+            return siblings[siblings.indexOf(node) + 1]?.handle;
+        },
+        parentsOf(handles) {
+            return handles.map(handle => nodeOf(handle, 'parentsOf').parent?.handle);
+        },
+        subtreesOf(roots) {
+            const out = [];
+            const walk = (node) => {
+                out.push(node.handle);
+                for (const child of node.children)
+                    walk(child);
+            };
+            for (const root of roots)
+                walk(nodeOf(root, 'subtreesOf'));
+            return out;
+        },
+        // The twin of the engine's narrowed walk, and it MUST narrow here too: the vitest suite is where
+        // the sweep's behaviour is asserted, so a recording host that handed back everything would make
+        // every one of those cases pass whatever the engine does.
+        teardownSubtreesOf(roots) {
+            const out = [];
+            const walk = (node, isRoot) => {
+                const reserved = out.length;
+                out.push(node.handle);
+                let isWanted = isRoot || node.tagName !== '';
+                for (const child of node.children) {
+                    if (walk(child, false))
+                        isWanted = true;
+                }
+                if (!isWanted)
+                    out.length = reserved;
+                return isWanted;
+            };
+            for (const root of roots)
+                walk(nodeOf(root, 'teardownSubtreesOf'), true);
+            return out;
+        },
+        ancestorsOf(handle) {
+            const chain = [];
+            for (let node = nodeOf(handle, 'ancestorsOf'); node !== undefined; node = node.parent) {
+                chain.push(node.handle);
+            }
+            return chain;
+        },
+        census(roots) {
+            let nodes = 0;
+            const walk = (node) => {
+                nodes += 1;
+                for (const child of node.children)
+                    walk(child);
+            };
+            for (const root of roots)
+                walk(nodeOf(root, 'census'));
+            // The skip counts belong to the commit rules, which this host does not have. Zero is the
+            // honest answer: nothing here was skipped, because nothing here was decided.
+            return {
+                nodes,
+                anchors: 0,
+                emptyRawTexts: 0,
+                renderable: nodes,
+                flattenWidths: [],
+            };
+        },
+        // The imperative six ask the PLATFORM — a frame, a gesture, an announcement. Three of them
+        // carry a request the engine MADE, so they are recorded; the measuring three want an answer
+        // only a platform has, and there is none here.
+        dispatchCommand(handle, commandName, args) {
+            host.commands.push({
+                handle,
+                viewName: nodeOf(handle, 'dispatchCommand').viewName,
+                commandName,
+                args,
+            });
+        },
+        sendAccessibilityEvent(handle, eventType) {
+            host.accessibilityEvents.push({ handle, eventType });
+        },
+        measure(_handle, _callback) { },
+        measureInWindow(_handle, _callback) { },
+        measureLayout(_handle, _relativeTo, onFail, _onSuccess) {
+            onFail();
+        },
+        setIsJSResponder(handle, isResponder, blockNativeResponder) {
+            host.responderHandovers.push({
+                handle,
+                isResponder,
+                blockNativeResponder,
+            });
+        },
+        registerEventHandler(handler) {
+            eventHandler = handler;
+        },
+        find(predicate) {
+            return created.find(predicate);
+        },
+        findAll(predicate) {
+            return created.filter(predicate);
+        },
+        fireEvent(handle, topLevelType, nativeEvent = {}) {
+            if (eventHandler === undefined) {
+                throw new Error('no event handler registered by the renderer');
+            }
+            eventHandler(handle, topLevelType, nativeEvent);
+        },
+        reset() {
+            created = [];
+            host.commits = 0;
+            host.commands.length = 0;
+            host.responderHandovers.length = 0;
+            host.accessibilityEvents.length = 0;
+        },
+        forget() {
+            recorded = new WeakMap();
+            created = [];
+            host.reset();
+        },
+    };
+    return host;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/test-utils",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Shared, framework-agnostic fake-Fabric test harness for SymbioteNative — the fake nativeFabricUIManager recorder used by the co-located test suites across the engine, every adapter, and the example apps.",
   "license": "MIT",
   "repository": {
@@ -39,6 +39,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@symbiote-native/engine": "1.1.0"
+  },
   "scripts": {
     "typecheck": "tsc --build",
     "format": "prettier --write \"src/**/*.{ts,tsx}\""

package/build/fake-fabric.d.ts

@@ -1,51 +0,0 @@
-export interface IFakeNode {
-    tag: number;
-    viewName: string;
-    props: Record<string, unknown>;
-    children: IFakeNode[];
-    instanceHandle: unknown;
-    /** Fabric family parent. Clones keep the same tag/family, so reparenting a family is illegal. */
-    parentFamilyTag?: number;
-}
-export type IEventHandler = (instanceHandle: unknown, topLevelType: string, nativeEvent: Record<string, unknown>) => void;
-export interface IFabricRecorder {
-    /** The child set handed to the most recent `completeRoot`. */
-    committed: IFakeNode[];
-    /** Every node ever `createNode`'d this run (clones excluded). */
-    created: IFakeNode[];
-    /** Every imperative command dispatched at a committed Fabric node. */
-    commands: Array<{
-        node: IFakeNode;
-        commandName: string;
-        args: readonly unknown[];
-    }>;
-    /**
-     * Call counters, for tests that assert "exactly N native nodes were created" — and for pricing
-     * a commit's PROTOCOL half against its walk half. `appendChild` and `clone` are the two Fabric
-     * makes unavoidable: a parent whose child set changed is cloned empty and re-appends every child
-     * handle, so those counts are what a real JSI boundary would charge no matter how cheap the JS
-     * walk above them gets. Counting them here is the only way a headless run can say which half a
-     * proposed optimisation is even aimed at.
-     */
-    counts: {
-        createNode: number;
-        completeRoot: number;
-        appendChild: number;
-        clone: number;
-    };
-    /**
-     * RN wraps every commit in a synthetic `box-none` AppContainer root.
-     * Returns it, asserting it is the single expected root, so each test unwraps the
-     * AppContainer the same way instead of re-checking the invariant by hand.
-     */
-    appRoot(): IFakeNode;
-    /** Find the first `createNode`'d node matching a predicate (e.g. the app's own View). */
-    find(predicate: (node: IFakeNode) => boolean): IFakeNode | undefined;
-    /** Deliver a native event to the renderer's registered handler. */
-    fireEvent(handle: unknown, topLevelType: string, nativeEvent?: Record<string, unknown>): void;
-    /** Serialize a node list to `RCTView(RCTText(RCTRawText "text"))` shorthand. */
-    serialize(nodes: IFakeNode[]): string;
-    /** Zero the counters and clear `committed` / `created` (the event handler survives). */
-    reset(): void;
-}
-export declare function installFabric(): IFabricRecorder;

package/build/fake-fabric.js

@@ -1,151 +0,0 @@
-// One shared fake `nativeFabricUIManager` for the unit suite. `installFabric()` puts a
-// fresh recording slot on `globalThis` and returns a handle to inspect what was committed.
-//
-// Mirrors real Fabric's clone-on-write semantics: every clone gets a NEW identity;
-// `*NewProps` MERGES the diff onto previous props (the engine always sends a minimal diff —
-// see `diffProps` in commit.ts). A removed key arrives as literal `null` and stays `null`,
-// not deleted, so a test can tell "explicitly reset" apart from "never set". `*Children`
-// variants reset children (the engine re-appends).
-// See the header comment above for the merge/null-removal semantics this mirrors.
-function mergeFabricProps(previous, diff) {
-    return { ...previous, ...diff };
-}
-// Fabric clones keep the node's FAMILY, so a handle that already belongs to one parent can never
-// be appended under another. Enforced on both routes into a parent's child list — the append loop
-// and the batched clone — so switching between them cannot quietly drop the check.
-function assertSameFamily(parent, child) {
-    if (child.parentFamilyTag !== undefined &&
-        child.parentFamilyTag !== parent.tag) {
-        throw new Error(`Fabric family reparent: child ${child.viewName}#${child.tag} already belongs to parent #${child.parentFamilyTag}, cannot append to ${parent.viewName}#${parent.tag}`);
-    }
-}
-// `Array.isArray` narrows to `any[]`, which leaves the OTHER branch of the union un-narrowed;
-// an explicit predicate keeps both sides typed without a cast.
-function isFakeNodeList(value) {
-    return Array.isArray(value);
-}
-// A clone with no child list comes back EMPTY, exactly as the real binding does.
-function adoptChildren(parent, children) {
-    if (children === undefined)
-        return [];
-    for (const child of children) {
-        assertSameFamily(parent, child);
-        child.parentFamilyTag = parent.tag;
-    }
-    return [...children];
-}
-export function installFabric() {
-    let committed = [];
-    const created = [];
-    const commands = [];
-    const counts = { createNode: 0, completeRoot: 0, appendChild: 0, clone: 0 };
-    let eventHandler;
-    const slot = {
-        createNode(tag, viewName, _rootTag, props, instanceHandle) {
-            counts.createNode += 1;
-            const node = {
-                tag,
-                viewName,
-                props,
-                children: [],
-                instanceHandle,
-            };
-            created.push(node);
-            return node;
-        },
-        cloneNodeWithNewProps: (node, newProps) => {
-            counts.clone += 1;
-            return { ...node, props: mergeFabricProps(node.props, newProps) };
-        },
-        // Both clone-with-children forms take the child list as an OPTIONAL trailing/second argument,
-        // mirroring UIManagerBinding.cpp: `cloneNodeWithNewChildren(node, children?)` and the 3-arg
-        // `cloneNodeWithNewChildrenAndProps(node, children, props)`. The engine probes support by
-        // ARITY, so these must keep 2 and 3 declared parameters — a default value on any of them
-        // would drop `.length` below the threshold and silently send every test down the append loop.
-        cloneNodeWithNewChildren: (node, children) => {
-            counts.clone += 1;
-            return { ...node, children: adoptChildren(node, children) };
-        },
-        cloneNodeWithNewChildrenAndProps: (node, childrenOrProps, maybeProps) => {
-            counts.clone += 1;
-            const children = isFakeNodeList(childrenOrProps)
-                ? childrenOrProps
-                : undefined;
-            const newProps = isFakeNodeList(childrenOrProps)
-                ? (maybeProps ?? {})
-                : childrenOrProps;
-            return {
-                ...node,
-                props: mergeFabricProps(node.props, newProps),
-                children: adoptChildren(node, children),
-            };
-        },
-        createChildSet: () => [],
-        appendChild(parent, child) {
-            counts.appendChild += 1;
-            assertSameFamily(parent, child);
-            child.parentFamilyTag = parent.tag;
-            parent.children.push(child);
-            return parent;
-        },
-        appendChildToSet(childSet, child) {
-            childSet.push(child);
-        },
-        completeRoot(_rootTag, childSet) {
-            counts.completeRoot += 1;
-            committed = childSet;
-        },
-        registerEventHandler(handler) {
-            eventHandler = handler;
-        },
-        dispatchCommand(node, commandName, args) {
-            commands.push({ node, commandName, args });
-        },
-    };
-    Object.assign(globalThis, { nativeFabricUIManager: slot });
-    const serializeNode = (node) => {
-        const text = node.viewName === 'RCTRawText' ? ` "${String(node.props.text)}"` : '';
-        const kids = node.children.length
-            ? `(${node.children.map(serializeNode).join('')})`
-            : '';
-        return `${node.viewName}${text}${kids}`;
-    };
-    return {
-        get committed() {
-            return committed;
-        },
-        created,
-        commands,
-        counts,
-        appRoot() {
-            const root = committed[0];
-            if (committed.length !== 1 || root?.props.pointerEvents !== 'box-none') {
-                throw new Error(`expected a single box-none AppContainer root, got ${committed.length} node(s)`);
-            }
-            return root;
-        },
-        find(predicate) {
-            return created.find(predicate);
-        },
-        fireEvent(handle, topLevelType, nativeEvent = {}) {
-            if (!eventHandler)
-                throw new Error('no event handler registered by the renderer');
-            eventHandler(handle, topLevelType, nativeEvent);
-        },
-        serialize(nodes) {
-            return nodes.map(serializeNode).join('');
-        },
-        reset() {
-            committed = [];
-            created.length = 0;
-            commands.length = 0;
-            // Every counter, not a subset: `appendChild` and `clone` were left out, so any assertion
-            // on them across a reset read the PREVIOUS phase's total and could not fail. Both are now
-            // the metric that prices the clone protocol, so a stale one is a silent wrong answer.
-            counts.createNode = 0;
-            counts.completeRoot = 0;
-            counts.appendChild = 0;
-            counts.clone = 0;
-        },
-    };
-}