@driftengine/core 3.61.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Drift Technologies
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+DriftEngine
+Copyright 2026 Drift Technologies
+
+This product includes software developed at Drift Technologies
+(https://github.com/drftrun/driftengine).
+
+Licensed under the Apache License, Version 2.0. Section 4(d) of that licence
+requires this NOTICE to be reproduced in any derivative work you distribute,
+in the source, the documentation, or a display generated by the work.

package/README.md

@@ -0,0 +1,9 @@
+# @driftengine/core
+
+The runtime everything needs: renderer, loop, camera, input, geometry. Collision and dynamics live in [`@driftengine/physics`](../physics/README.md), which this package depends on and re-exports whole, so reaching for them through this barrel works as it always did.
+
+**Cost: 670.0 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+3% — the number is a fact about the build rather than a claim in a document.
+
+Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)
+for how the packages divide, and why some features are compiled into core on demand instead.

package/dist/behavior/behaviorTree.d.ts

@@ -0,0 +1,140 @@
+/**
+ * A behaviour tree that is data, so it can be looked at, paused and stepped.
+ *
+ * **The complaint this answers is not "a routine cannot be written".** It can, and a consumer
+ * reported theirs: a table of places and a loop that decides where to send everybody once an
+ * in-game hour. It works. What they also reported is what it is — a hand-written behaviour tree
+ * that cannot be inspected, paused or stepped — and where it gets expensive, which is the moment a
+ * routine needs **interrupting**: an agent dropping what it is doing because it started raining,
+ * and picking it up again afterwards.
+ *
+ * So the two things here are the two things a hand-rolled loop does not give you.
+ *
+ * **The tree is data.** Nodes are arrays of integers and names resolved once at build time; the
+ * consumer's own functions live in a table beside it. A running tree can therefore say which node
+ * it is in, by name, without anything having been instrumented — `activePath` walks it — and a
+ * `paused` character can be advanced one node at a time.
+ *
+ * **A preempted branch is suspended, not reset**, which is the whole of "picking it up again". A
+ * selector that switches to a higher-priority child leaves the lower one's cursors exactly where
+ * they were, so when the interruption ends the agent resumes at the step it had reached rather than
+ * at the start of its errand. State is reset only when a branch *finishes* — succeeds or fails —
+ * because that is when starting again is what starting again means. Every behaviour-tree
+ * implementation has to choose here, most reset on abort, and the difference is a villager who
+ * walks back to the shop after a shower against one who walks home and starts the day over.
+ *
+ * **Nothing allocates during a tick and nothing reads a clock.** A tick is a function of the tree,
+ * the character's own cursors, and whatever the consumer's context object holds.
+ */
+export declare const FAILURE = 0;
+export declare const SUCCESS = 1;
+export declare const RUNNING = 2;
+export type BehaviorStatus = 0 | 1 | 2;
+/**
+ * A node, as a consumer writes one.
+ *
+ * Names are the point of the whole shape: they are what an inspector shows and what a log line
+ * says, and a tree whose nodes are anonymous is one you can watch running and still not read.
+ */
+export type BehaviorSpec = {
+    readonly name: string;
+    readonly sequence: readonly BehaviorSpec[];
+} | {
+    readonly name: string;
+    readonly selector: readonly BehaviorSpec[];
+} | {
+    readonly name: string;
+    readonly action: string;
+} | {
+    readonly name: string;
+    readonly condition: string;
+}
+/**
+ * Run the child only while the condition holds.
+ *
+ * **The interruption primitive.** A selector of guards is a list of priorities: the first guard
+ * whose condition is true runs its branch, and a branch that was running under a lower-priority
+ * guard is suspended rather than abandoned. That is how "stop what you are doing because it
+ * started raining" is expressed, and how the errand survives it.
+ */
+ | {
+    readonly name: string;
+    readonly whileTrue: string;
+    readonly does: BehaviorSpec;
+};
+/** What a running tree calls: the consumer's own verbs, by the names the tree uses. */
+export interface BehaviorTasks {
+    /** Something that takes time. Returns `RUNNING` until it is done. */
+    readonly actions: Readonly<Record<string, (context: never) => BehaviorStatus>>;
+    /** Something with an answer now. */
+    readonly conditions: Readonly<Record<string, (context: never) => boolean>>;
+}
+/** The tree, flattened. Built once; a character per agent shares it. */
+export interface BehaviorTree {
+    readonly kind: Uint8Array;
+    /** For a composite: where its children start in `child`. Length `nodeCount + 1`. */
+    readonly childStart: Uint32Array;
+    readonly child: Uint32Array;
+    /** For an action, condition or guard: which function in the table. */
+    readonly slot: Int32Array;
+    readonly names: readonly string[];
+    readonly nodeCount: number;
+    /** The functions, in the order `slot` indexes them. */
+    readonly actions: readonly ((context: never) => BehaviorStatus)[];
+    readonly conditions: readonly ((context: never) => boolean)[];
+}
+/**
+ * Flatten a spec, resolving every name against the tables.
+ *
+ * **A name with no function is refused here rather than at the moment the agent needs it.** A tree
+ * is authored once and run for hours; a typo that surfaces the first time a villager reaches the
+ * market is a typo that surfaces in front of somebody playing.
+ */
+export declare function buildBehaviorTree(root: BehaviorSpec, tasks: BehaviorTasks): BehaviorTree;
+/**
+ * One agent running one tree.
+ *
+ * A character per agent and one tree between them: the tree is read-only after building, and
+ * everything that differs between two villagers following the same routine is here.
+ */
+export declare class BehaviorRunner<Context> {
+    readonly tree: BehaviorTree;
+    /** How far through each composite this agent is. The state a suspension preserves. */
+    private readonly cursor;
+    /** Which node each composite last handed control to, so a switch can be noticed. */
+    private readonly running;
+    /** The chain of nodes entered on the last tick, root first. */
+    private readonly path;
+    private pathLength;
+    private lastStatus;
+    /**
+     * When true, `tick` does nothing and reports the last status.
+     *
+     * Paused rather than not-called, so a debugger can hold one agent while the world runs — and so
+     * `stepOnce` has something to mean.
+     */
+    paused: boolean;
+    constructor(tree: BehaviorTree);
+    get status(): BehaviorStatus;
+    /** Advance one tick, unless paused. */
+    tick(context: Context): BehaviorStatus;
+    /** Advance one tick even while paused. What a step button is wired to. */
+    stepOnce(context: Context): BehaviorStatus;
+    /** Forget everything: the next tick starts the routine from the beginning. */
+    reset(): void;
+    /**
+     * The chain of nodes the last tick was inside, root first, filled into `out`.
+     *
+     * **This is the inspection the report asked for**, and it costs nothing to keep: the chain is
+     * recorded as the tick descends, so asking for it later is a copy rather than a second walk.
+     * `nameOf` turns the indices into the names the tree was written with.
+     */
+    activePath(out: Uint32Array): number;
+    nameOf(node: number): string;
+    private run;
+    private visit;
+    private sequence;
+    private selector;
+    /** Forget a subtree's progress, so it is entered fresh. Called when a branch finishes. */
+    private clear;
+}

package/dist/behavior/behaviorTree.js

@@ -0,0 +1,289 @@
+/**
+ * A behaviour tree that is data, so it can be looked at, paused and stepped.
+ *
+ * **The complaint this answers is not "a routine cannot be written".** It can, and a consumer
+ * reported theirs: a table of places and a loop that decides where to send everybody once an
+ * in-game hour. It works. What they also reported is what it is — a hand-written behaviour tree
+ * that cannot be inspected, paused or stepped — and where it gets expensive, which is the moment a
+ * routine needs **interrupting**: an agent dropping what it is doing because it started raining,
+ * and picking it up again afterwards.
+ *
+ * So the two things here are the two things a hand-rolled loop does not give you.
+ *
+ * **The tree is data.** Nodes are arrays of integers and names resolved once at build time; the
+ * consumer's own functions live in a table beside it. A running tree can therefore say which node
+ * it is in, by name, without anything having been instrumented — `activePath` walks it — and a
+ * `paused` character can be advanced one node at a time.
+ *
+ * **A preempted branch is suspended, not reset**, which is the whole of "picking it up again". A
+ * selector that switches to a higher-priority child leaves the lower one's cursors exactly where
+ * they were, so when the interruption ends the agent resumes at the step it had reached rather than
+ * at the start of its errand. State is reset only when a branch *finishes* — succeeds or fails —
+ * because that is when starting again is what starting again means. Every behaviour-tree
+ * implementation has to choose here, most reset on abort, and the difference is a villager who
+ * walks back to the shop after a shower against one who walks home and starts the day over.
+ *
+ * **Nothing allocates during a tick and nothing reads a clock.** A tick is a function of the tree,
+ * the character's own cursors, and whatever the consumer's context object holds.
+ */
+export const FAILURE = 0;
+export const SUCCESS = 1;
+export const RUNNING = 2;
+const SEQUENCE = 0;
+const SELECTOR = 1;
+const ACTION = 2;
+const CONDITION = 3;
+const GUARD = 4;
+/**
+ * Flatten a spec, resolving every name against the tables.
+ *
+ * **A name with no function is refused here rather than at the moment the agent needs it.** A tree
+ * is authored once and run for hours; a typo that surfaces the first time a villager reaches the
+ * market is a typo that surfaces in front of somebody playing.
+ */
+export function buildBehaviorTree(root, tasks) {
+    const kind = [];
+    const names = [];
+    const slot = [];
+    const childLists = [];
+    const actions = [];
+    const conditions = [];
+    const actionSlot = new Map();
+    const conditionSlot = new Map();
+    const resolveAction = (name, node) => {
+        const found = actionSlot.get(name);
+        if (found !== undefined)
+            return found;
+        const fn = tasks.actions[name];
+        if (fn === undefined) {
+            throw new Error(`buildBehaviorTree: node "${node}" does an action "${name}" nothing provides`);
+        }
+        actions.push(fn);
+        actionSlot.set(name, actions.length - 1);
+        return actions.length - 1;
+    };
+    const resolveCondition = (name, node) => {
+        const found = conditionSlot.get(name);
+        if (found !== undefined)
+            return found;
+        const fn = tasks.conditions[name];
+        if (fn === undefined) {
+            throw new Error(`buildBehaviorTree: node "${node}" asks "${name}", which nothing answers`);
+        }
+        conditions.push(fn);
+        conditionSlot.set(name, conditions.length - 1);
+        return conditions.length - 1;
+    };
+    const visit = (spec) => {
+        const at = kind.length;
+        names.push(spec.name);
+        kind.push(0);
+        slot.push(-1);
+        childLists.push([]);
+        if ('sequence' in spec || 'selector' in spec) {
+            const children = 'sequence' in spec ? spec.sequence : spec.selector;
+            if (children.length === 0) {
+                throw new Error(`buildBehaviorTree: "${spec.name}" is a composite with no children`);
+            }
+            kind[at] = 'sequence' in spec ? SEQUENCE : SELECTOR;
+            const list = childLists[at];
+            for (const each of children)
+                list.push(visit(each));
+        }
+        else if ('action' in spec) {
+            kind[at] = ACTION;
+            slot[at] = resolveAction(spec.action, spec.name);
+        }
+        else if ('condition' in spec) {
+            kind[at] = CONDITION;
+            slot[at] = resolveCondition(spec.condition, spec.name);
+        }
+        else {
+            kind[at] = GUARD;
+            slot[at] = resolveCondition(spec.whileTrue, spec.name);
+            childLists[at].push(visit(spec.does));
+        }
+        return at;
+    };
+    visit(root);
+    const nodeCount = kind.length;
+    const childStart = new Uint32Array(nodeCount + 1);
+    for (let i = 0; i < nodeCount; i++) {
+        childStart[i + 1] = (childStart[i] ?? 0) + (childLists[i]?.length ?? 0);
+    }
+    const child = new Uint32Array(childStart[nodeCount] ?? 0);
+    for (let i = 0; i < nodeCount; i++) {
+        const list = childLists[i] ?? [];
+        for (let k = 0; k < list.length; k++)
+            child[(childStart[i] ?? 0) + k] = list[k] ?? 0;
+    }
+    return {
+        kind: Uint8Array.from(kind),
+        childStart,
+        child,
+        slot: Int32Array.from(slot),
+        names,
+        nodeCount,
+        actions,
+        conditions,
+    };
+}
+/**
+ * One agent running one tree.
+ *
+ * A character per agent and one tree between them: the tree is read-only after building, and
+ * everything that differs between two villagers following the same routine is here.
+ */
+export class BehaviorRunner {
+    tree;
+    /** How far through each composite this agent is. The state a suspension preserves. */
+    cursor;
+    /** Which node each composite last handed control to, so a switch can be noticed. */
+    running;
+    /** The chain of nodes entered on the last tick, root first. */
+    path;
+    pathLength = 0;
+    lastStatus = RUNNING;
+    /**
+     * When true, `tick` does nothing and reports the last status.
+     *
+     * Paused rather than not-called, so a debugger can hold one agent while the world runs — and so
+     * `stepOnce` has something to mean.
+     */
+    paused = false;
+    constructor(tree) {
+        this.tree = tree;
+        this.cursor = new Uint32Array(tree.nodeCount);
+        this.running = new Int32Array(tree.nodeCount).fill(-1);
+        this.path = new Uint32Array(tree.nodeCount);
+    }
+    get status() {
+        return this.lastStatus;
+    }
+    /** Advance one tick, unless paused. */
+    tick(context) {
+        if (this.paused)
+            return this.lastStatus;
+        return this.run(context);
+    }
+    /** Advance one tick even while paused. What a step button is wired to. */
+    stepOnce(context) {
+        return this.run(context);
+    }
+    /** Forget everything: the next tick starts the routine from the beginning. */
+    reset() {
+        this.cursor.fill(0);
+        this.running.fill(-1);
+        this.pathLength = 0;
+        this.lastStatus = RUNNING;
+    }
+    /**
+     * The chain of nodes the last tick was inside, root first, filled into `out`.
+     *
+     * **This is the inspection the report asked for**, and it costs nothing to keep: the chain is
+     * recorded as the tick descends, so asking for it later is a copy rather than a second walk.
+     * `nameOf` turns the indices into the names the tree was written with.
+     */
+    activePath(out) {
+        const count = Math.min(this.pathLength, out.length);
+        for (let i = 0; i < count; i++)
+            out[i] = this.path[i] ?? 0;
+        return count;
+    }
+    nameOf(node) {
+        return this.tree.names[node] ?? '?';
+    }
+    run(context) {
+        this.pathLength = 0;
+        this.lastStatus = this.visit(0, context);
+        return this.lastStatus;
+    }
+    visit(node, context) {
+        if (this.pathLength < this.path.length)
+            this.path[this.pathLength++] = node;
+        const tree = this.tree;
+        switch (tree.kind[node]) {
+            case ACTION: {
+                const fn = tree.actions[tree.slot[node] ?? 0];
+                return fn === undefined ? FAILURE : fn(context);
+            }
+            case CONDITION: {
+                const fn = tree.conditions[tree.slot[node] ?? 0];
+                return fn !== undefined && fn(context) ? SUCCESS : FAILURE;
+            }
+            case GUARD: {
+                const fn = tree.conditions[tree.slot[node] ?? 0];
+                /*
+                 * The condition has stopped holding. The child keeps every cursor it had: this is the node
+                 * that makes an interruption resumable, and clearing here is the single change that would
+                 * turn a villager who returns to their errand into one who starts the day again.
+                 */
+                if (fn === undefined || !fn(context))
+                    return FAILURE;
+                return this.visit(tree.child[tree.childStart[node] ?? 0] ?? 0, context);
+            }
+            case SEQUENCE:
+                return this.sequence(node, context);
+            default:
+                return this.selector(node, context);
+        }
+    }
+    sequence(node, context) {
+        const tree = this.tree;
+        const start = tree.childStart[node] ?? 0;
+        const end = tree.childStart[node + 1] ?? 0;
+        const count = end - start;
+        /* Resumed from the cursor, which is what makes a sequence a routine rather than a list of
+           things attempted from the top every tick. */
+        for (let i = this.cursor[node] ?? 0; i < count; i++) {
+            const status = this.visit(tree.child[start + i] ?? 0, context);
+            if (status === RUNNING) {
+                this.cursor[node] = i;
+                return RUNNING;
+            }
+            if (status === FAILURE) {
+                this.clear(node);
+                return FAILURE;
+            }
+            /* Succeeded: on to the next, and the child starts clean the next time it is entered. */
+            this.clear(tree.child[start + i] ?? 0);
+        }
+        this.clear(node);
+        return SUCCESS;
+    }
+    selector(node, context) {
+        const tree = this.tree;
+        const start = tree.childStart[node] ?? 0;
+        const end = tree.childStart[node + 1] ?? 0;
+        for (let i = start; i < end; i++) {
+            const branch = tree.child[i] ?? 0;
+            const status = this.visit(branch, context);
+            if (status === FAILURE)
+                continue;
+            /*
+             * **A different branch has taken over, and the one it displaced is left exactly as it was.**
+             * Nothing is cleared here, which is the whole feature: the displaced branch's cursors say
+             * which step of the errand it had reached, and it resumes there when this one stops being
+             * eligible. Resetting instead is the version of this that most implementations ship, and it
+             * is why interrupting an agent usually costs the thing it was doing.
+             */
+            this.running[node] = branch;
+            if (status === SUCCESS) {
+                this.clear(branch);
+                this.running[node] = -1;
+            }
+            return status;
+        }
+        this.clear(node);
+        return FAILURE;
+    }
+    /** Forget a subtree's progress, so it is entered fresh. Called when a branch finishes. */
+    clear(node) {
+        this.cursor[node] = 0;
+        this.running[node] = -1;
+        const start = this.tree.childStart[node] ?? 0;
+        const end = this.tree.childStart[node + 1] ?? 0;
+        for (let i = start; i < end; i++)
+            this.clear(this.tree.child[i] ?? 0);
+    }
+}