@jgengine/core 0.6.0 → 0.8.0

package/dist/behaviour/behaviour.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Unity-style behaviour lifecycle over a headless id-keyed node tree, ported from
+ * vladkrutenyuk/three-start (MIT) and adapted to run without three.js: nodes are plain
+ * string ids (use entity instance ids to pair with `entityStore`), and the shell binds
+ * render-side hooks separately.
+ *
+ * Lifecycle per behaviour: `onAwake` (once, first activation) → `onEnable` (every
+ * inactive→active transition) → `onStart` (once, after the first `onEnable`) →
+ * `onUpdate` (per `world.update` while active) → `onDisable` (every active→inactive
+ * transition) → `onDestroy` (once, always — even if never activated).
+ *
+ * `world.start()` bootstraps in passes: modules awake → modules start → modules join
+ * update dispatch → ALL behaviours on effectively-active nodes awake (even disabled
+ * ones) → enable/start/subscribe. Behaviours attached during the module pass are
+ * deferred to the behaviour passes, so module `onUpdate` always dispatches before any
+ * behaviour `onUpdate`.
+ */
+/**
+ * Declaration-merging registry games and adapters augment for typed access to
+ * world modules:
+ *
+ * ```ts
+ * declare module "@jgengine/core/behaviour/behaviour" {
+ *   interface JGEngineRegister {
+ *     modules: { physics: PhysicsModule; director: DirectorModule };
+ *   }
+ * }
+ * ```
+ */
+export interface JGEngineRegister {
+}
+export type RegisterField<TKey extends string, TFallback = unknown> = TKey extends keyof JGEngineRegister ? JGEngineRegister[TKey] : TFallback;
+/** Resolves to the augmented module map when `JGEngineRegister` declares one. */
+export type BehaviourModules = RegisterField<"modules", Record<string, BehaviourModule>>;
+interface UpdateSubscriber {
+    onUpdate(dt: number): void;
+}
+interface BehaviourWorldInternal extends BehaviourWorld {
+    _subscribeUpdate(subscriber: UpdateSubscriber): void;
+    _unsubscribeUpdate(subscriber: UpdateSubscriber): void;
+    _isEffectivelyActive(nodeId: string): boolean;
+    _detachBehaviour(behaviour: Behaviour): void;
+}
+/**
+ * Subclass and override the lifecycle hooks. A behaviour only joins the per-frame
+ * update dispatch if it actually overrides `onUpdate` (prototype-identity check at
+ * each activation), so hook-only behaviours cost nothing per frame.
+ */
+export declare class Behaviour {
+    /** @internal */ _world: BehaviourWorldInternal | null;
+    /** @internal */ _nodeId: string | null;
+    /** @internal */ _awoken: boolean;
+    /** @internal */ _startedOnce: boolean;
+    /** @internal */ _isActive: boolean;
+    private _enabled;
+    private _destroyed;
+    /** The node this behaviour is attached to; available from `onAwake` onward, never in the constructor. */
+    get nodeId(): string;
+    get world(): BehaviourWorld;
+    get modules(): BehaviourModules;
+    /** Own enabled flag; effective activity also requires the node's hierarchy to be active. */
+    get enabled(): boolean;
+    /** Whether the lifecycle is currently in the active span (`onEnable` fired, `onDisable` not yet). */
+    get isActive(): boolean;
+    onAwake(): void;
+    onEnable(): void;
+    onStart(): void;
+    onUpdate(_dt: number): void;
+    onDisable(): void;
+    onDestroy(): void;
+    enable(): void;
+    disable(): void;
+    /** Flips the flag only when the node is hierarchy-inactive or the world hasn't started; lifecycle catches up on the next activation. */
+    setEnabled(enabled: boolean): void;
+    /** Detaches from the node and fires `onDisable` (if active) then `onDestroy`. */
+    destroy(): void;
+    /** @internal */
+    _activate(): void;
+    /** @internal */
+    _deactivate(): void;
+    /** @internal */
+    _destroy(): void;
+}
+/**
+ * A world-lifetime service with typed sibling access via `this.modules`. Modules awake
+ * and start before any behaviour during `world.start()`, subscribe to update dispatch
+ * first (their `onUpdate` fires before every behaviour's), and have no disable/destroy —
+ * they live as long as the world.
+ */
+export declare class BehaviourModule {
+    /** @internal */ _world: BehaviourWorldInternal | null;
+    get world(): BehaviourWorld;
+    get modules(): BehaviourModules;
+    onAwake(): void;
+    onStart(): void;
+    onUpdate(_dt: number): void;
+    /** @internal */
+    _subscribe(): void;
+}
+export interface BehaviourWorld {
+    /** Creates the node if missing (parented under `parentId` when given, else a root); reparents an existing node when `parentId` differs. */
+    add(id: string, parentId?: string): void;
+    has(id: string): boolean;
+    parentOf(id: string): string | null;
+    childrenOf(id: string): readonly string[];
+    /** Moves `id` (and subtree) under `parentId` (`null` = root), firing enable/disable cascades when effective activity changes. Throws on cycles. */
+    setParent(id: string, parentId: string | null): void;
+    /** Attaches and immediately activates when the world has started, the node is effectively active, and the behaviour is enabled (deferred during bootstrap). */
+    attach<T extends Behaviour>(nodeId: string, behaviour: T): T;
+    behavioursOf(nodeId: string): readonly Behaviour[];
+    /**
+     * Sets the node's own flag and cascades activation/deactivation through the subtree,
+     * pruning at descendants whose own flag is false — so reactivating a parent restores
+     * exactly the per-child stored flags. A flip under an inactive ancestor changes only
+     * the flag.
+     */
+    setActive(id: string, active: boolean): void;
+    /** The node's own flag; unknown ids count active. */
+    isActiveSelf(id: string): boolean;
+    /** Own flag AND every ancestor's; unknown ids count active. */
+    isActive(id: string): boolean;
+    /** Registers modules by key. Throws on duplicate keys or after `start()`. */
+    addModules(modules: Partial<BehaviourModules>): void;
+    readonly modules: BehaviourModules;
+    /** Bootstraps: modules awake/start/subscribe, then all behaviours on effectively-active nodes awake, then enable+start+subscribe. Idempotent. */
+    start(): void;
+    started(): boolean;
+    /** Dispatches `onUpdate(dt)` to modules then behaviours, over a snapshot — subscribers added mid-dispatch first fire next update. */
+    update(dt: number): void;
+    /** Destroys every behaviour in the subtree (parent-first) and removes the nodes. */
+    destroyNode(id: string): boolean;
+    /** Destroys all nodes and behaviours and clears update dispatch. */
+    destroy(): void;
+}
+export declare function createBehaviourWorld(): BehaviourWorld;
+export {};

package/dist/behaviour/behaviour.js

@@ -0,0 +1,388 @@
+/**
+ * Unity-style behaviour lifecycle over a headless id-keyed node tree, ported from
+ * vladkrutenyuk/three-start (MIT) and adapted to run without three.js: nodes are plain
+ * string ids (use entity instance ids to pair with `entityStore`), and the shell binds
+ * render-side hooks separately.
+ *
+ * Lifecycle per behaviour: `onAwake` (once, first activation) → `onEnable` (every
+ * inactive→active transition) → `onStart` (once, after the first `onEnable`) →
+ * `onUpdate` (per `world.update` while active) → `onDisable` (every active→inactive
+ * transition) → `onDestroy` (once, always — even if never activated).
+ *
+ * `world.start()` bootstraps in passes: modules awake → modules start → modules join
+ * update dispatch → ALL behaviours on effectively-active nodes awake (even disabled
+ * ones) → enable/start/subscribe. Behaviours attached during the module pass are
+ * deferred to the behaviour passes, so module `onUpdate` always dispatches before any
+ * behaviour `onUpdate`.
+ */
+/**
+ * Subclass and override the lifecycle hooks. A behaviour only joins the per-frame
+ * update dispatch if it actually overrides `onUpdate` (prototype-identity check at
+ * each activation), so hook-only behaviours cost nothing per frame.
+ */
+export class Behaviour {
+    /** @internal */ _world = null;
+    /** @internal */ _nodeId = null;
+    /** @internal */ _awoken = false;
+    /** @internal */ _startedOnce = false;
+    /** @internal */ _isActive = false;
+    _enabled = true;
+    _destroyed = false;
+    /** The node this behaviour is attached to; available from `onAwake` onward, never in the constructor. */
+    get nodeId() {
+        if (this._nodeId === null)
+            throw new Error("behaviour is not attached to a node");
+        return this._nodeId;
+    }
+    get world() {
+        if (this._world === null)
+            throw new Error("behaviour is not attached to a world");
+        return this._world;
+    }
+    get modules() {
+        return this.world.modules;
+    }
+    /** Own enabled flag; effective activity also requires the node's hierarchy to be active. */
+    get enabled() {
+        return this._enabled;
+    }
+    /** Whether the lifecycle is currently in the active span (`onEnable` fired, `onDisable` not yet). */
+    get isActive() {
+        return this._isActive;
+    }
+    onAwake() { }
+    onEnable() { }
+    onStart() { }
+    onUpdate(_dt) { }
+    onDisable() { }
+    onDestroy() { }
+    enable() {
+        this.setEnabled(true);
+    }
+    disable() {
+        this.setEnabled(false);
+    }
+    /** Flips the flag only when the node is hierarchy-inactive or the world hasn't started; lifecycle catches up on the next activation. */
+    setEnabled(enabled) {
+        if (this._enabled === enabled)
+            return;
+        this._enabled = enabled;
+        const world = this._world;
+        const nodeId = this._nodeId;
+        if (world === null || nodeId === null)
+            return;
+        if (!world.started() || !world._isEffectivelyActive(nodeId))
+            return;
+        if (enabled)
+            this._activate();
+        else
+            this._deactivate();
+    }
+    /** Detaches from the node and fires `onDisable` (if active) then `onDestroy`. */
+    destroy() {
+        if (this._world !== null)
+            this._world._detachBehaviour(this);
+        this._destroy();
+    }
+    /** @internal */
+    _activate() {
+        if (this._isActive)
+            return;
+        if (this._world === null)
+            return;
+        this._isActive = true;
+        if (!this._awoken) {
+            this._awoken = true;
+            this.onAwake();
+        }
+        this.onEnable();
+        if (!this._startedOnce) {
+            this._startedOnce = true;
+            this.onStart();
+        }
+        if (this.onUpdate !== Behaviour.prototype.onUpdate) {
+            this._world._subscribeUpdate(this);
+        }
+    }
+    /** @internal */
+    _deactivate() {
+        if (!this._isActive)
+            return;
+        this._isActive = false;
+        this._world?._unsubscribeUpdate(this);
+        this.onDisable();
+    }
+    /** @internal */
+    _destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._deactivate();
+        this.onDestroy();
+        this._world = null;
+        this._nodeId = null;
+    }
+}
+/**
+ * A world-lifetime service with typed sibling access via `this.modules`. Modules awake
+ * and start before any behaviour during `world.start()`, subscribe to update dispatch
+ * first (their `onUpdate` fires before every behaviour's), and have no disable/destroy —
+ * they live as long as the world.
+ */
+export class BehaviourModule {
+    /** @internal */ _world = null;
+    get world() {
+        if (this._world === null)
+            throw new Error("module is not registered with a world");
+        return this._world;
+    }
+    get modules() {
+        return this.world.modules;
+    }
+    onAwake() { }
+    onStart() { }
+    onUpdate(_dt) { }
+    /** @internal */
+    _subscribe() {
+        if (this._world === null)
+            return;
+        if (this.onUpdate !== BehaviourModule.prototype.onUpdate) {
+            this._world._subscribeUpdate(this);
+        }
+    }
+}
+export function createBehaviourWorld() {
+    const nodes = new Map();
+    const roots = [];
+    const updateSubscribers = [];
+    const moduleRecord = {};
+    let started = false;
+    let bootstrapping = false;
+    function mustGet(id) {
+        const node = nodes.get(id);
+        if (node === undefined)
+            throw new Error(`unknown behaviour node "${id}"`);
+        return node;
+    }
+    function ensureNode(id, parentId) {
+        const existing = nodes.get(id);
+        if (existing !== undefined) {
+            if (parentId !== undefined && existing.parent?.id !== parentId)
+                world.setParent(id, parentId);
+            return existing;
+        }
+        const parent = parentId === undefined ? null : ensureNode(parentId);
+        const node = { id, parent, children: [], activeSelf: true, behaviours: [] };
+        nodes.set(id, node);
+        if (parent === null)
+            roots.push(node);
+        else
+            parent.children.push(node);
+        return node;
+    }
+    function parentChainActive(node) {
+        let ancestor = node.parent;
+        while (ancestor !== null) {
+            if (!ancestor.activeSelf)
+                return false;
+            ancestor = ancestor.parent;
+        }
+        return true;
+    }
+    function isEffectivelyActive(node) {
+        return node.activeSelf && parentChainActive(node);
+    }
+    function traverseActiveSelf(node, visit) {
+        if (!node.activeSelf)
+            return;
+        visit(node);
+        for (const child of [...node.children])
+            traverseActiveSelf(child, visit);
+    }
+    function activateNode(node) {
+        if (!started)
+            return;
+        if (!isEffectivelyActive(node))
+            return;
+        for (const behaviour of [...node.behaviours]) {
+            if (behaviour.enabled)
+                behaviour._activate();
+        }
+    }
+    function deactivateNode(node) {
+        for (const behaviour of [...node.behaviours]) {
+            if (behaviour._isActive)
+                behaviour._deactivate();
+        }
+    }
+    function deactivateSubtree(node) {
+        deactivateNode(node);
+        for (const child of [...node.children])
+            traverseActiveSelf(child, deactivateNode);
+    }
+    function unlink(node) {
+        const siblings = node.parent === null ? roots : node.parent.children;
+        const index = siblings.indexOf(node);
+        if (index !== -1)
+            siblings.splice(index, 1);
+    }
+    function collectSubtree(node, into) {
+        into.push(node);
+        for (const child of node.children)
+            collectSubtree(child, into);
+    }
+    const world = {
+        add(id, parentId) {
+            ensureNode(id, parentId);
+        },
+        has: (id) => nodes.has(id),
+        parentOf: (id) => mustGet(id).parent?.id ?? null,
+        childrenOf: (id) => mustGet(id).children.map((child) => child.id),
+        setParent(id, parentId) {
+            const node = mustGet(id);
+            const nextParent = parentId === null ? null : mustGet(parentId);
+            if (node.parent === nextParent)
+                return;
+            for (let ancestor = nextParent; ancestor !== null; ancestor = ancestor.parent) {
+                if (ancestor === node)
+                    throw new Error(`cannot parent "${parentId}" under its own descendant "${id}"`);
+            }
+            const wasEffective = isEffectivelyActive(node);
+            unlink(node);
+            node.parent = nextParent;
+            if (nextParent === null)
+                roots.push(node);
+            else
+                nextParent.children.push(node);
+            const nowEffective = isEffectivelyActive(node);
+            if (!started || wasEffective === nowEffective)
+                return;
+            if (nowEffective)
+                traverseActiveSelf(node, activateNode);
+            else
+                deactivateSubtree(node);
+        },
+        attach(nodeId, behaviour) {
+            if (behaviour._world !== null)
+                throw new Error("behaviour is already attached");
+            const node = ensureNode(nodeId);
+            behaviour._world = world;
+            behaviour._nodeId = nodeId;
+            node.behaviours.push(behaviour);
+            if (started && !bootstrapping && behaviour.enabled && isEffectivelyActive(node)) {
+                behaviour._activate();
+            }
+            return behaviour;
+        },
+        behavioursOf: (nodeId) => [...(nodes.get(nodeId)?.behaviours ?? [])],
+        setActive(id, active) {
+            const node = ensureNode(id);
+            if (node.activeSelf === active)
+                return;
+            node.activeSelf = active;
+            if (!parentChainActive(node))
+                return;
+            if (active)
+                traverseActiveSelf(node, activateNode);
+            else
+                deactivateSubtree(node);
+        },
+        isActiveSelf: (id) => nodes.get(id)?.activeSelf ?? true,
+        isActive(id) {
+            const node = nodes.get(id);
+            return node === undefined ? true : isEffectivelyActive(node);
+        },
+        addModules(modules) {
+            if (started)
+                throw new Error("cannot add modules after start()");
+            for (const [key, module] of Object.entries(modules)) {
+                if (module === undefined)
+                    continue;
+                if (moduleRecord[key] !== undefined)
+                    throw new Error(`module "${key}" is already registered`);
+                const instance = module;
+                instance._world = world;
+                moduleRecord[key] = instance;
+            }
+        },
+        modules: moduleRecord,
+        start() {
+            if (started)
+                return;
+            started = true;
+            bootstrapping = true;
+            const modules = Object.values(moduleRecord);
+            for (const module of modules)
+                module.onAwake();
+            for (const module of modules)
+                module.onStart();
+            for (const module of modules)
+                module._subscribe();
+            bootstrapping = false;
+            for (const root of [...roots]) {
+                traverseActiveSelf(root, (node) => {
+                    for (const behaviour of [...node.behaviours]) {
+                        if (!behaviour._awoken) {
+                            behaviour._awoken = true;
+                            behaviour.onAwake();
+                        }
+                    }
+                });
+            }
+            for (const root of [...roots]) {
+                traverseActiveSelf(root, activateNode);
+            }
+        },
+        started: () => started,
+        update(dt) {
+            for (const subscriber of [...updateSubscribers])
+                subscriber.onUpdate(dt);
+        },
+        destroyNode(id) {
+            const node = nodes.get(id);
+            if (node === undefined)
+                return false;
+            const subtree = [];
+            collectSubtree(node, subtree);
+            for (const member of subtree) {
+                for (const behaviour of [...member.behaviours])
+                    behaviour._destroy();
+                member.behaviours.length = 0;
+            }
+            unlink(node);
+            for (const member of subtree)
+                nodes.delete(member.id);
+            return true;
+        },
+        destroy() {
+            for (const root of [...roots])
+                world.destroyNode(root.id);
+            updateSubscribers.length = 0;
+        },
+        _subscribeUpdate(subscriber) {
+            if (!updateSubscribers.includes(subscriber))
+                updateSubscribers.push(subscriber);
+        },
+        _unsubscribeUpdate(subscriber) {
+            const index = updateSubscribers.indexOf(subscriber);
+            if (index !== -1)
+                updateSubscribers.splice(index, 1);
+        },
+        _isEffectivelyActive: (nodeId) => {
+            const node = nodes.get(nodeId);
+            return node === undefined ? true : isEffectivelyActive(node);
+        },
+        _detachBehaviour(behaviour) {
+            const nodeId = behaviour._nodeId;
+            if (nodeId === null)
+                return;
+            const node = nodes.get(nodeId);
+            if (node === undefined)
+                return;
+            const index = node.behaviours.indexOf(behaviour);
+            if (index !== -1)
+                node.behaviours.splice(index, 1);
+        },
+    };
+    return world;
+}

package/dist/board/laneBoard.d.ts

@@ -0,0 +1,63 @@
+export type Side = string;
+export interface LaneRuleInput<C> {
+    lane: number;
+    side: Side;
+    cards: readonly C[];
+    subtotal: number;
+}
+export interface LaneRule<C> {
+    id: string;
+    apply: (input: LaneRuleInput<C>) => number;
+}
+export interface LaneBoardConfig<C> {
+    laneCount: number;
+    sides: readonly Side[];
+    power: (card: C) => number;
+    laneRules?: readonly (LaneRule<C> | null | undefined)[];
+}
+export interface LaneCells<C> {
+    readonly [side: Side]: readonly C[];
+}
+export interface LaneBoardState<C> {
+    readonly lanes: readonly LaneCells<C>[];
+}
+export interface LaneAggregate {
+    lane: number;
+    side: Side;
+    subtotal: number;
+    total: number;
+    count: number;
+}
+export interface LaneOutcome {
+    lane: number;
+    totals: Readonly<Record<Side, number>>;
+    winner: Side | null;
+}
+export type LaneRejection = "invalid-lane" | "invalid-side";
+export interface LanePlaceResult<C> {
+    status: "ok";
+    state: LaneBoardState<C>;
+}
+export interface LanePlaceRejected {
+    status: "rejected";
+    reason: LaneRejection;
+}
+export type LaneResult<C> = LanePlaceResult<C> | LanePlaceRejected;
+export declare function createLaneBoardState<C>(config: LaneBoardConfig<C>): LaneBoardState<C>;
+export declare function placeCard<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number, side: Side, card: C): LaneResult<C>;
+export declare function removeCard<C>(state: LaneBoardState<C>, lane: number, side: Side, predicate: (card: C, index: number) => boolean): LaneResult<C>;
+export declare function laneAggregate<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number, side: Side): LaneAggregate;
+export declare function laneOutcome<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number): LaneOutcome;
+export declare function boardTotals<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>): Readonly<Record<Side, number>>;
+export declare function lanesWon<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>): Readonly<Record<Side, number>>;
+export interface LaneBoard<C> {
+    state(): LaneBoardState<C>;
+    place(lane: number, side: Side, card: C): LaneResult<C>;
+    remove(lane: number, side: Side, predicate: (card: C, index: number) => boolean): LaneResult<C>;
+    aggregate(lane: number, side: Side): LaneAggregate;
+    outcome(lane: number): LaneOutcome;
+    totals(): Readonly<Record<Side, number>>;
+    lanesWon(): Readonly<Record<Side, number>>;
+    reset(next?: LaneBoardState<C>): void;
+}
+export declare function createLaneBoard<C>(config: LaneBoardConfig<C>): LaneBoard<C>;

package/dist/board/laneBoard.js

@@ -0,0 +1,114 @@
+function emptyLane(sides) {
+    const cells = {};
+    for (const side of sides)
+        cells[side] = [];
+    return cells;
+}
+export function createLaneBoardState(config) {
+    if (config.laneCount <= 0)
+        throw new Error("laneBoard needs at least one lane");
+    if (config.sides.length === 0)
+        throw new Error("laneBoard needs at least one side");
+    const lanes = [];
+    for (let i = 0; i < config.laneCount; i++)
+        lanes.push(emptyLane(config.sides));
+    return { lanes };
+}
+function validLane(state, lane) {
+    return Number.isInteger(lane) && lane >= 0 && lane < state.lanes.length;
+}
+export function placeCard(state, config, lane, side, card) {
+    if (!validLane(state, lane))
+        return { status: "rejected", reason: "invalid-lane" };
+    if (!config.sides.includes(side))
+        return { status: "rejected", reason: "invalid-side" };
+    const lanes = state.lanes.slice();
+    const cell = lanes[lane];
+    lanes[lane] = { ...cell, [side]: [...cell[side], card] };
+    return { status: "ok", state: { lanes } };
+}
+export function removeCard(state, lane, side, predicate) {
+    if (!validLane(state, lane))
+        return { status: "rejected", reason: "invalid-lane" };
+    const cell = state.lanes[lane];
+    if (cell[side] === undefined)
+        return { status: "rejected", reason: "invalid-side" };
+    const lanes = state.lanes.slice();
+    lanes[lane] = { ...cell, [side]: cell[side].filter((card, index) => !predicate(card, index)) };
+    return { status: "ok", state: { lanes } };
+}
+export function laneAggregate(state, config, lane, side) {
+    const cards = state.lanes[lane]?.[side] ?? [];
+    let subtotal = 0;
+    for (const card of cards)
+        subtotal += config.power(card);
+    const rule = config.laneRules?.[lane] ?? null;
+    const total = rule ? rule.apply({ lane, side, cards, subtotal }) : subtotal;
+    return { lane, side, subtotal, total, count: cards.length };
+}
+export function laneOutcome(state, config, lane) {
+    const totals = {};
+    let winner = null;
+    let best = -Infinity;
+    let tie = false;
+    for (const side of config.sides) {
+        const total = laneAggregate(state, config, lane, side).total;
+        totals[side] = total;
+        if (total > best) {
+            best = total;
+            winner = side;
+            tie = false;
+        }
+        else if (total === best) {
+            tie = true;
+        }
+    }
+    return { lane, totals, winner: tie ? null : winner };
+}
+export function boardTotals(state, config) {
+    const totals = {};
+    for (const side of config.sides)
+        totals[side] = 0;
+    for (let lane = 0; lane < state.lanes.length; lane++) {
+        for (const side of config.sides) {
+            totals[side] += laneAggregate(state, config, lane, side).total;
+        }
+    }
+    return totals;
+}
+export function lanesWon(state, config) {
+    const won = {};
+    for (const side of config.sides)
+        won[side] = 0;
+    for (let lane = 0; lane < state.lanes.length; lane++) {
+        const outcome = laneOutcome(state, config, lane);
+        if (outcome.winner !== null)
+            won[outcome.winner] += 1;
+    }
+    return won;
+}
+export function createLaneBoard(config) {
+    let state = createLaneBoardState(config);
+    return {
+        state: () => state,
+        place(lane, side, card) {
+            const result = placeCard(state, config, lane, side, card);
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        remove(lane, side, predicate) {
+            const result = removeCard(state, lane, side, predicate);
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        aggregate: (lane, side) => laneAggregate(state, config, lane, side),
+        outcome: (lane) => laneOutcome(state, config, lane),
+        totals: () => boardTotals(state, config),
+        lanesWon: () => lanesWon(state, config),
+        reset(next) {
+            state = next ?? createLaneBoardState(config);
+        },
+    };
+}