dialog-ide 0.5.0

package/dist/dialoged/skein/tree.js

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkeinTree = exports.ALL_MARKERS = exports.KnotLockedError = exports.LabelConflictError = void 0;
+exports.isEffectivelyLocked = isEffectivelyLocked;
+exports.isValidMarker = isValidMarker;
+const immutable_1 = require("immutable");
+class LabelConflictError extends Error {
+    constructor(label) {
+        super(`Label "${label}" is already used by another knot.`);
+        this.name = 'LabelConflictError';
+    }
+}
+exports.LabelConflictError = LabelConflictError;
+class KnotLockedError extends Error {
+    constructor() {
+        super('Cannot delete: this knot or one of its descendants is locked or labeled.');
+        this.name = 'KnotLockedError';
+    }
+}
+exports.KnotLockedError = KnotLockedError;
+function isEffectivelyLocked(knot) {
+    return knot.locked || knot.label !== null;
+}
+function responsesMatch(blessed, fresh) {
+    return blessed !== null && blessed.text === fresh.text && blessed.inputType === fresh.inputType;
+}
+function responseAfterUpdate(existing, fresh) {
+    return responsesMatch(existing.response, fresh) ? null : fresh;
+}
+exports.ALL_MARKERS = [1, 2, 3, 4];
+function isValidMarker(value) {
+    return value === 1 || value === 2 || value === 3 || value === 4;
+}
+class SkeinTree {
+    constructor(engine, seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates) {
+        this.engine = engine;
+        this.seed = seed;
+        this.knots = knots;
+        this.knotStates = knotStates;
+        this.activeKnotId = activeKnotId;
+        this.collapsedKnotIds = collapsedKnotIds;
+        this.dynamicStates = dynamicStates;
+    }
+    static newTree(engine, seed) {
+        const initialKnot = {
+            id: 0,
+            command: 'START',
+            response: {
+                text: 'Welcome to the game. > ',
+                inputType: 'line'
+            },
+            unblessedResponse: null,
+            parentId: null,
+            label: 'START',
+            locked: false,
+            marker: null
+        };
+        const initialState = {
+            state: 'valid',
+            treeState: 'valid',
+            selectedChild: null,
+            children: []
+        };
+        return new SkeinTree(engine, seed, (0, immutable_1.Map)().set(0, initialKnot), (0, immutable_1.Map)().set(0, initialState), 0, (0, immutable_1.Set)(), (0, immutable_1.Map)());
+    }
+    addChild(parentId, command, response) {
+        const newId = this.generateNextId();
+        const parentKnot = this.knots.get(parentId);
+        if (!parentKnot) {
+            throw new Error(`Parent knot ${parentId} not found`);
+        }
+        const newKnot = {
+            id: newId,
+            command,
+            response: null,
+            unblessedResponse: response,
+            parentId,
+            label: null,
+            locked: false,
+            marker: null
+        };
+        const newState = {
+            state: 'new',
+            treeState: 'new',
+            selectedChild: null,
+            children: []
+        };
+        const parentState = this.knotStates.get(parentId);
+        const updatedParentState = {
+            ...parentState,
+            children: [...parentState.children, newId],
+            selectedChild: newId
+        };
+        const knots = this.knots.set(newId, newKnot);
+        let knotStates = this.knotStates
+            .set(newId, newState)
+            .set(parentId, updatedParentState);
+        knotStates = SkeinTree.propagateTreeState(knots, knotStates, parentId);
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    updateKnotCommandAndResponse(id, command, response) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const updatedKnot = {
+            ...knot,
+            command,
+            unblessedResponse: responseAfterUpdate(knot, response)
+        };
+        const knots = this.knots.set(id, updatedKnot);
+        const knotStates = SkeinTree.propagateOwnStateChange(knots, this.knotStates, id, updatedKnot);
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    updateKnotResponse(id, response) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const updatedKnot = {
+            ...knot,
+            unblessedResponse: responseAfterUpdate(knot, response)
+        };
+        const knots = this.knots.set(id, updatedKnot);
+        const knotStates = SkeinTree.propagateOwnStateChange(knots, this.knotStates, id, updatedKnot);
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    blessKnot(id) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        if (!knot.unblessedResponse) {
+            return this;
+        }
+        const updatedKnot = {
+            ...knot,
+            response: knot.unblessedResponse,
+            unblessedResponse: null
+        };
+        const knots = this.knots.set(id, updatedKnot);
+        const knotStates = SkeinTree.propagateOwnStateChange(knots, this.knotStates, id, updatedKnot);
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    blessTranscript(id) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        let tree = this;
+        for (const pathId of this.pathFromRoot(id)) {
+            const knot = tree.knots.get(pathId);
+            if (SkeinTree.computeKnotState(knot) !== 'valid') {
+                tree = tree.blessKnot(pathId);
+            }
+        }
+        return tree;
+    }
+    deleteKnot(id) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const subtreeIds = this.collectSubtreeIds(id);
+        if (subtreeIds.some((subtreeId) => isEffectivelyLocked(this.knots.get(subtreeId)))) {
+            throw new KnotLockedError();
+        }
+        let knots = this.knots;
+        let knotStates = this.knotStates;
+        let collapsedKnotIds = this.collapsedKnotIds;
+        let dynamicStates = this.dynamicStates;
+        for (const descendantId of subtreeIds) {
+            knots = knots.delete(descendantId);
+            knotStates = knotStates.delete(descendantId);
+            collapsedKnotIds = collapsedKnotIds.remove(descendantId);
+            dynamicStates = dynamicStates.delete(descendantId);
+        }
+        if (knot.parentId !== null) {
+            knotStates = SkeinTree.removeChildFromParent(knotStates, knot.parentId, id);
+            knotStates = SkeinTree.propagateTreeState(knots, knotStates, knot.parentId);
+        }
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, collapsedKnotIds, dynamicStates);
+    }
+    spliceKnot(id) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const knotState = this.knotStates.get(id);
+        const childIds = knotState.children;
+        let knots = this.knots.delete(id);
+        let knotStates = this.knotStates.delete(id);
+        for (const childId of childIds) {
+            const child = knots.get(childId);
+            knots = knots.set(childId, { ...child, parentId: knot.parentId });
+        }
+        if (knot.parentId !== null) {
+            const parentState = knotStates.get(knot.parentId);
+            const index = parentState.children.indexOf(id);
+            const children = index === -1
+                ? [...parentState.children, ...childIds]
+                : [...parentState.children.slice(0, index), ...childIds, ...parentState.children.slice(index + 1)];
+            knotStates = knotStates.set(knot.parentId, {
+                ...parentState,
+                children,
+                selectedChild: parentState.selectedChild === id
+                    ? (childIds.length > 0 ? childIds[0] : null)
+                    : parentState.selectedChild
+            });
+            knotStates = SkeinTree.propagateTreeState(knots, knotStates, knot.parentId);
+        }
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, this.activeKnotId, this.collapsedKnotIds.remove(id), this.dynamicStates.delete(id));
+    }
+    nextId() {
+        return this.generateNextId();
+    }
+    insertParent(id, command, response) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const newId = this.generateNextId();
+        const oldParentId = knot.parentId;
+        const newParentKnot = {
+            id: newId,
+            command,
+            response: null,
+            unblessedResponse: response,
+            parentId: oldParentId,
+            label: null,
+            locked: false,
+            marker: null
+        };
+        const newParentState = {
+            state: 'new',
+            treeState: 'new',
+            selectedChild: id,
+            children: [id]
+        };
+        const updatedKnot = { ...knot, parentId: newId };
+        let knots = this.knots.set(newId, newParentKnot).set(id, updatedKnot);
+        let knotStates = this.knotStates.set(newId, newParentState);
+        let collapsedKnotIds = this.collapsedKnotIds;
+        let dynamicStates = this.dynamicStates;
+        let activeKnotId = this.activeKnotId;
+        if (oldParentId !== null) {
+            const grandparentState = knotStates.get(oldParentId);
+            const index = grandparentState.children.indexOf(id);
+            const children = index === -1
+                ? grandparentState.children
+                : [...grandparentState.children.slice(0, index), newId, ...grandparentState.children.slice(index + 1)];
+            knotStates = knotStates.set(oldParentId, {
+                ...grandparentState,
+                children,
+                selectedChild: grandparentState.selectedChild === id ? newId : grandparentState.selectedChild
+            });
+            const otherId = children.find((cid) => cid !== newId && knots.get(cid).command === command) ?? null;
+            if (otherId !== null) {
+                const merged = new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates)
+                    .mergeSiblingInto(newId, otherId);
+                knots = merged.knots;
+                knotStates = merged.knotStates;
+                collapsedKnotIds = merged.collapsedKnotIds;
+                dynamicStates = merged.dynamicStates;
+                activeKnotId = merged.activeKnotId;
+                knotStates = SkeinTree.absorbSiblingInParent(knotStates, oldParentId, newId, otherId);
+            }
+        }
+        knotStates = SkeinTree.propagateTreeState(knots, knotStates, newId);
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates);
+    }
+    setLabel(id, label) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        if (label !== null) {
+            const existing = this.findByLabel(label);
+            if (existing && existing.id !== id) {
+                throw new LabelConflictError(label);
+            }
+        }
+        const updatedKnot = {
+            ...knot,
+            label
+        };
+        return new SkeinTree(this.engine, this.seed, this.knots.set(id, updatedKnot), this.knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    findByLabel(label) {
+        for (const knot of this.knots.valueSeq()) {
+            if (knot.label === label) {
+                return knot;
+            }
+        }
+        return null;
+    }
+    setMarker(id, marker) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        return new SkeinTree(this.engine, this.seed, this.knots.set(id, { ...knot, marker }), this.knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    renameCommand(id, command) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        if (command === knot.command) {
+            return this;
+        }
+        let knots = this.knots.set(id, { ...knot, command });
+        let knotStates = this.knotStates;
+        let collapsedKnotIds = this.collapsedKnotIds;
+        let dynamicStates = this.dynamicStates;
+        let activeKnotId = this.activeKnotId;
+        if (knot.parentId !== null) {
+            const parentState = knotStates.get(knot.parentId);
+            const otherId = parentState.children.find((cid) => cid !== id && knots.get(cid).command === command) ?? null;
+            if (otherId !== null) {
+                const merged = new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates)
+                    .mergeSiblingInto(id, otherId);
+                knots = merged.knots;
+                knotStates = merged.knotStates;
+                collapsedKnotIds = merged.collapsedKnotIds;
+                dynamicStates = merged.dynamicStates;
+                activeKnotId = merged.activeKnotId;
+                knotStates = SkeinTree.absorbSiblingInParent(knotStates, knot.parentId, id, otherId);
+                knotStates = SkeinTree.propagateTreeState(knots, knotStates, knot.parentId);
+            }
+        }
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates);
+    }
+    mergeSiblingInto(keepId, otherId) {
+        const keepKnot = this.knots.get(keepId);
+        const otherKnot = this.knots.get(otherId);
+        const otherState = this.knotStates.get(otherId);
+        let knots = this.knots.set(keepId, {
+            ...keepKnot,
+            label: keepKnot.label ?? otherKnot.label,
+            locked: keepKnot.locked || otherKnot.locked,
+            marker: keepKnot.marker ?? otherKnot.marker
+        });
+        let knotStates = this.knotStates;
+        let collapsedKnotIds = this.collapsedKnotIds;
+        let dynamicStates = this.dynamicStates;
+        let activeKnotId = this.activeKnotId;
+        for (const otherChildId of otherState.children) {
+            const otherChildCommand = knots.get(otherChildId).command;
+            const keepState = knotStates.get(keepId);
+            const matchedKeepChildId = keepState.children.find((cid) => knots.get(cid).command === otherChildCommand) ?? null;
+            if (matchedKeepChildId !== null) {
+                const merged = new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates)
+                    .mergeSiblingInto(matchedKeepChildId, otherChildId);
+                knots = merged.knots;
+                knotStates = merged.knotStates;
+                collapsedKnotIds = merged.collapsedKnotIds;
+                dynamicStates = merged.dynamicStates;
+                activeKnotId = merged.activeKnotId;
+            }
+            else {
+                knots = knots.set(otherChildId, { ...knots.get(otherChildId), parentId: keepId });
+                const ks = knotStates.get(keepId);
+                knotStates = knotStates.set(keepId, {
+                    ...ks,
+                    children: [...ks.children, otherChildId],
+                    selectedChild: ks.selectedChild ?? otherChildId
+                });
+            }
+        }
+        knots = knots.delete(otherId);
+        knotStates = knotStates.delete(otherId);
+        collapsedKnotIds = collapsedKnotIds.remove(otherId);
+        dynamicStates = dynamicStates.delete(otherId);
+        if (activeKnotId === otherId) {
+            activeKnotId = keepId;
+        }
+        const keepState = knotStates.get(keepId);
+        const treeState = keepState.children.reduce((acc, cid) => SkeinTree.maxStatus(acc, knotStates.get(cid).treeState), keepState.state);
+        knotStates = knotStates.set(keepId, { ...keepState, treeState });
+        return new SkeinTree(this.engine, this.seed, knots, knotStates, activeKnotId, collapsedKnotIds, dynamicStates);
+    }
+    static absorbSiblingInParent(knotStates, parentId, keepId, otherId) {
+        const parentState = knotStates.get(parentId);
+        const children = parentState.children.filter((cid) => cid !== otherId);
+        return knotStates.set(parentId, {
+            ...parentState,
+            children,
+            selectedChild: parentState.selectedChild === otherId ? keepId : parentState.selectedChild
+        });
+    }
+    setLockStatus(id, locked) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const updatedKnot = {
+            ...knot,
+            locked
+        };
+        return new SkeinTree(this.engine, this.seed, this.knots.set(id, updatedKnot), this.knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    getKnot(id) {
+        return this.knots.get(id) || null;
+    }
+    promptTypeAt(id) {
+        if (id === null) {
+            return 'line';
+        }
+        const knot = this.knots.get(id);
+        const response = knot?.response ?? knot?.unblessedResponse;
+        return response?.inputType ?? 'line';
+    }
+    updateDynamicState(id, state) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        return new SkeinTree(this.engine, this.seed, this.knots, this.knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates.set(id, state));
+    }
+    getDynamicState(id) {
+        return this.dynamicStates.get(id) ?? null;
+    }
+    findChildId(parentId, command) {
+        const parentState = this.knotStates.get(parentId);
+        if (!parentState) {
+            return null;
+        }
+        for (const childId of parentState.children) {
+            if (this.knots.get(childId)?.command === command) {
+                return childId;
+            }
+        }
+        return null;
+    }
+    sortedChildren(parentId) {
+        const state = this.knotStates.get(parentId);
+        if (!state) {
+            return [];
+        }
+        return state.children.map((id) => this.getDerivedKnot(id)).sort((a, b) => a.command.localeCompare(b.command));
+    }
+    commandPath(id) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        return this.pathFromRoot(id)
+            .filter((pathId) => pathId !== 0)
+            .map((pathId) => ({ id: pathId, command: this.knots.get(pathId).command }));
+    }
+    getAllKnots() {
+        return this.knots.valueSeq().toArray();
+    }
+    getDerivedKnot(id) {
+        const knot = this.knots.get(id);
+        if (!knot) {
+            return null;
+        }
+        const state = this.knotStates.get(id);
+        return {
+            id: knot.id,
+            command: knot.command,
+            response: knot.response ? knot.response.text : '',
+            unblessedResponse: knot.unblessedResponse ? knot.unblessedResponse.text : null,
+            state: state ? state.state : SkeinTree.computeKnotState(knot),
+            treeState: state ? state.treeState : SkeinTree.computeKnotState(knot),
+            parentId: knot.parentId,
+            children: state ? state.children : [],
+            selectedChild: state ? state.selectedChild : null,
+            inputType: knot.response ? knot.response.inputType : 'line',
+            label: knot.label,
+            locked: knot.locked,
+            marker: knot.marker,
+            collapsed: this.collapsedKnotIds.has(id)
+        };
+    }
+    visibleKnotIdsForMarkerFilter(marker) {
+        const visible = new globalThis.Set();
+        const visit = (id) => {
+            const knot = this.knots.get(id);
+            const state = this.knotStates.get(id);
+            const anyChildMatches = state.children.map(visit).some(Boolean);
+            const selfMatches = knot.marker === marker;
+            if (anyChildMatches || selfMatches) {
+                visible.add(id);
+                return true;
+            }
+            return false;
+        };
+        visit(0);
+        return visible;
+    }
+    static computeKnotState(knot) {
+        if (knot.response) {
+            if (knot.unblessedResponse && knot.response.text !== knot.unblessedResponse.text) {
+                return 'error';
+            }
+            return 'valid';
+        }
+        return 'new';
+    }
+    static maxStatus(a, b) {
+        if (a === 'error' || b === 'error') {
+            return 'error';
+        }
+        if (a === 'new' || b === 'new') {
+            return 'new';
+        }
+        return 'valid';
+    }
+    static propagateOwnStateChange(knots, knotStates, id, updatedKnot) {
+        const state = knotStates.get(id);
+        const withUpdatedState = knotStates.set(id, { ...state, state: SkeinTree.computeKnotState(updatedKnot) });
+        return SkeinTree.propagateTreeState(knots, withUpdatedState, id);
+    }
+    static propagateTreeState(knots, knotStates, startId) {
+        let states = knotStates;
+        let currentId = startId;
+        while (currentId !== null) {
+            const current = states.get(currentId);
+            const computed = current.children.reduce((acc, childId) => SkeinTree.maxStatus(acc, states.get(childId).treeState), current.state);
+            states = states.set(currentId, { ...current, treeState: computed });
+            currentId = knots.get(currentId).parentId;
+        }
+        return states;
+    }
+    collectSubtreeIds(id) {
+        const ids = [id];
+        const state = this.knotStates.get(id);
+        if (state) {
+            for (const childId of state.children) {
+                ids.push(...this.collectSubtreeIds(childId));
+            }
+        }
+        return ids;
+    }
+    pathFromRoot(id) {
+        const path = [];
+        let current = this.knots.get(id);
+        while (current) {
+            path.unshift(current.id);
+            current = current.parentId !== null ? this.knots.get(current.parentId) : undefined;
+        }
+        return path;
+    }
+    static removeChildFromParent(knotStates, parentId, childId) {
+        const parentState = knotStates.get(parentId);
+        if (!parentState) {
+            return knotStates;
+        }
+        const children = parentState.children.filter((existingId) => existingId !== childId);
+        return knotStates.set(parentId, {
+            ...parentState,
+            children,
+            selectedChild: parentState.selectedChild === childId
+                ? (children.length > 0 ? children[0] : null)
+                : parentState.selectedChild
+        });
+    }
+    static fromKnots(engine, seed, wireKnots) {
+        const sorted = [...wireKnots].sort((a, b) => a.id - b.id);
+        const childrenByParent = new globalThis.Map();
+        for (const knot of sorted) {
+            if (knot.parentId !== null) {
+                const children = childrenByParent.get(knot.parentId) ?? [];
+                children.push(knot.id);
+                childrenByParent.set(knot.parentId, children);
+            }
+        }
+        let knots = (0, immutable_1.Map)();
+        let knotStates = (0, immutable_1.Map)();
+        for (const knot of sorted) {
+            const children = childrenByParent.get(knot.id) ?? [];
+            const knotState = SkeinTree.computeKnotState(knot);
+            knots = knots.set(knot.id, knot);
+            knotStates = knotStates.set(knot.id, {
+                state: knotState,
+                treeState: knotState,
+                selectedChild: children.length > 0 ? children[0] : null,
+                children
+            });
+        }
+        const leafIds = sorted.filter((knot) => !childrenByParent.has(knot.id)).map((knot) => knot.id);
+        for (const leafId of leafIds) {
+            knotStates = SkeinTree.propagateTreeState(knots, knotStates, leafId);
+        }
+        let activeKnotId = 0;
+        let cursor = 0;
+        while (cursor !== null) {
+            activeKnotId = cursor;
+            cursor = knotStates.get(cursor)?.selectedChild ?? null;
+        }
+        return new SkeinTree(engine, seed, knots, knotStates, activeKnotId, (0, immutable_1.Set)(), (0, immutable_1.Map)());
+    }
+    generateNextId() {
+        let maxId = -1;
+        this.knots.forEach((knot) => {
+            if (knot.id > maxId) {
+                maxId = knot.id;
+            }
+        });
+        return maxId + 1;
+    }
+    getEngine() {
+        return this.engine;
+    }
+    getSeed() {
+        return this.seed;
+    }
+    getActiveKnotId() {
+        return this.activeKnotId;
+    }
+    getSelectedLeafId() {
+        let currentId = 0;
+        for (;;) {
+            const state = this.knotStates.get(currentId);
+            if (!state || state.selectedChild === null) {
+                return currentId;
+            }
+            currentId = state.selectedChild;
+        }
+    }
+    knotIdsWithStatus(status) {
+        return this.knotStates
+            .filter((state) => state.state === status)
+            .keySeq()
+            .toArray()
+            .sort((a, b) => a - b);
+    }
+    getLeafIds() {
+        return this.knotStates
+            .filter((state) => state.children.length === 0)
+            .keySeq()
+            .toArray()
+            .sort((a, b) => a - b);
+    }
+    setActiveKnotId(id) {
+        return new SkeinTree(this.engine, this.seed, this.knots, this.knotStates, id, this.collapsedKnotIds, this.dynamicStates);
+    }
+    selectKnot(id) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        return this.selectPath(id).extendSelection(id).setActiveKnotId(id);
+    }
+    selectPath(id) {
+        const path = this.pathFromRoot(id);
+        let knotStates = this.knotStates;
+        for (let i = 0; i < path.length - 1; i++) {
+            const parentId = path[i];
+            const childId = path[i + 1];
+            const parentState = knotStates.get(parentId);
+            if (parentState.selectedChild !== childId) {
+                knotStates = knotStates.set(parentId, { ...parentState, selectedChild: childId });
+            }
+        }
+        return new SkeinTree(this.engine, this.seed, this.knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    extendSelection(id) {
+        let knotStates = this.knotStates;
+        let currentId = id;
+        for (;;) {
+            const state = knotStates.get(currentId);
+            if (!state || state.children.length !== 1) {
+                break;
+            }
+            const childId = state.children[0];
+            knotStates = knotStates.set(currentId, { ...state, selectedChild: childId });
+            currentId = childId;
+        }
+        return new SkeinTree(this.engine, this.seed, this.knots, knotStates, this.activeKnotId, this.collapsedKnotIds, this.dynamicStates);
+    }
+    selectForNewChild(id) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const afterPath = this.selectPath(id);
+        const state = afterPath.knotStates.get(id);
+        const knotStates = state.selectedChild === null ? afterPath.knotStates : afterPath.knotStates.set(id, { ...state, selectedChild: null });
+        return new SkeinTree(this.engine, this.seed, this.knots, knotStates, id, this.collapsedKnotIds, this.dynamicStates);
+    }
+    toggleCollapsed(id) {
+        if (!this.knots.get(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        const collapsing = !this.collapsedKnotIds.has(id);
+        const collapsedKnotIds = collapsing ? this.collapsedKnotIds.add(id) : this.collapsedKnotIds.remove(id);
+        const activeKnotId = collapsing && this.activeKnotId !== null && this.isDescendantOf(this.activeKnotId, id) ? id : this.activeKnotId;
+        return new SkeinTree(this.engine, this.seed, this.knots, this.knotStates, activeKnotId, collapsedKnotIds, this.dynamicStates);
+    }
+    isDescendantOf(id, ancestorId) {
+        let current = this.knots.get(id)?.parentId ?? null;
+        while (current !== null) {
+            if (current === ancestorId) {
+                return true;
+            }
+            current = this.knots.get(current)?.parentId ?? null;
+        }
+        return false;
+    }
+}
+exports.SkeinTree = SkeinTree;
+//# sourceMappingURL=tree.js.map