@amalgm/shell 0.1.164-preview.36072132286 → 0.1.164-preview.36809057014

package/dist/ground-basis.js

@@ -0,0 +1,1023 @@
+/** Fixed SQLite facts used to authorize a later ground replacement. Source
+ * witnesses still prove disk; this read set proves the database basis.
+ *
+ * One counter orders every committed ground write. The write that changes a
+ * fact stamps that fact's last-change sequence in the same transaction, so a
+ * basis read at sequence S0 stays valid exactly while none of its facts has a
+ * stamp after S0. Within one epoch stamps are never deleted: a removed row, or
+ * a query answer that became empty, keeps its tombstone and still invalidates.
+ *
+ * Every basis and revision string lives in process memory, so none outlives
+ * its process. A process's first open of the ground file therefore begins a
+ * new epoch: a new incarnation retires every older basis and the stamps start
+ * empty. Which identities ever existed is a separate, permanent fact. */
+import { randomUUID } from "node:crypto";
+import { deserialize, serialize } from "node:v8";
+import { GROUND_ROW_PROJECTION, groundRowProjection, groundRowValues } from "./ground-row.js";
+import { activeRepository, readSubtree, subtreePages, TerritoryHandle, TerritoryView } from "./ground-territory.js";
+import { cachedStatement } from "./sqlite.js";
+import { turnBoundary } from "./turns.js";
+const INVENTORIES = ["entities", "detection_notebook"];
+const key = (dependency) => JSON.stringify([dependency.inventory, dependency.aspect, dependency.id]);
+const reading = new WeakSet();
+export class GroundBasisChangedError extends Error {
+}
+/** The same phase owner applies to both the store and direct snapshot entry. */
+export function assertGroundWriteAllowed(database) {
+    if (reading.has(database))
+        throw new Error("ground writes cannot run inside an observation snapshot");
+}
+function ensureGroundBasisSchema(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS ground_incarnation (
+      singleton INTEGER PRIMARY KEY CHECK(singleton = 1), identity TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS ground_sequence (
+      singleton INTEGER PRIMARY KEY CHECK(singleton = 1), value INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS ground_revisions (
+      inventory TEXT NOT NULL, aspect TEXT NOT NULL, identity TEXT NOT NULL, revision INTEGER NOT NULL,
+      PRIMARY KEY(inventory, aspect, identity)
+    ) WITHOUT ROWID;
+    CREATE INDEX IF NOT EXISTS ground_revisions_by_revision ON ground_revisions(revision);
+  `);
+    database.prepare("INSERT OR IGNORE INTO ground_incarnation(singleton, identity) VALUES (1, ?)").run(randomUUID());
+    database.prepare("INSERT OR IGNORE INTO ground_sequence(singleton, value) VALUES (1, 0)").run();
+    // Unordered random revisions cannot be compared with a sequence. Every fact
+    // they name keeps its history at sequence 0 (identity history and
+    // tombstones survive), and the new incarnation retires every older basis.
+    if (database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'ground_dependency_revisions'").get()) {
+        database.transaction(() => {
+            database.exec(`INSERT OR IGNORE INTO ground_revisions(inventory, aspect, identity, revision)
+        SELECT inventory, aspect, identity, 0 FROM ground_dependency_revisions;
+        DROP TABLE ground_dependency_revisions;`);
+            database.prepare("UPDATE ground_incarnation SET identity = ? WHERE singleton = 1").run(randomUUID());
+        })();
+    }
+    // Every UUID ever removed from an inventory. Entity stamps were that record
+    // before this table: each one names a UUID that existed, so all of them
+    // are carried once, a superset that includes UUIDs still present.
+    if (!database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'ground_identity_history'").get()) {
+        database.transaction(() => {
+            database.exec(`CREATE TABLE ground_identity_history (
+          inventory TEXT NOT NULL, uuid TEXT NOT NULL, PRIMARY KEY(inventory, uuid)
+        ) WITHOUT ROWID;
+        INSERT INTO ground_identity_history(inventory, uuid)
+          SELECT inventory, identity FROM ground_revisions WHERE aspect = 'entity';`);
+        })();
+    }
+}
+/** A process's first open of the ground file. No basis or revision string of
+ * an earlier process can reach this one, so the stamps restart empty under a
+ * new incarnation; a basis read before this commit, by any connection, fails
+ * its incarnation check instead of reading a missing stamp as unchanged. The
+ * counter stays monotonic, so no S0 or sequence string repeats. */
+export function beginGroundEpoch(database) {
+    ensureGroundBasisSchema(database);
+    database.transaction(() => {
+        database.prepare("UPDATE ground_incarnation SET identity = ? WHERE singleton = 1").run(randomUUID());
+        database.exec("DELETE FROM ground_revisions");
+    })();
+}
+/** One row by UUID, outside any basis: a read that proves nothing. */
+export const readGroundRow = (database, inventory, uuid) => cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory} WHERE uuid = ?`).get(uuid);
+/** The database incarnation that retires every basis read before a reset. */
+export const groundIncarnation = (database) => cachedStatement(database, "SELECT identity FROM ground_incarnation WHERE singleton = 1").get().identity;
+/** The last stamp any committed write issued: S0 for a read made with it. */
+export const currentSequence = (database) => cachedStatement(database, "SELECT value FROM ground_sequence WHERE singleton = 1", true).get().value;
+const revisionOf = (database, dependency) => cachedStatement(database, "SELECT revision FROM ground_revisions WHERE inventory = ? AND aspect = ? AND identity = ?", true)
+    .get(dependency.inventory, dependency.aspect, dependency.id)?.revision;
+/** Every fact stamped after a sequence, with its stamp: one indexed range
+ * read, empty while nothing has been written since. */
+const stampsAfter = (database, sequence) => cachedStatement(database, "SELECT inventory, aspect, identity, revision FROM ground_revisions WHERE revision > ?", true)
+    .all(sequence)
+    .map(row => ({ dependency: { inventory: row.inventory, aspect: row.aspect, id: row.identity }, revision: row.revision }));
+/** The facts stamped after an open observation's S0, as of its latest read.
+ * Within an epoch a stamp only rises, so a fact once stamped after S0 stays
+ * so, and each late read adds only what was stamped since the read before.
+ * A late read then costs one range read over the writes since, however many
+ * facts it consumes, instead of a lookup per fact. */
+class LaterStamps {
+    #keys = new Set();
+    #through;
+    constructor(sequence) { this.#through = sequence; }
+    /** Bring the set to the snapshot of the read transaction in progress. */
+    refresh(database) {
+        const current = currentSequence(database);
+        if (current <= this.#through)
+            return;
+        for (const { dependency } of stampsAfter(database, this.#through))
+            this.#keys.add(key(dependency));
+        this.#through = current;
+    }
+    has(id) { return this.#keys.has(id); }
+}
+/** One root's committed O/B state: equal exactly while no row of that root,
+ * in either inventory, has been written. */
+export function rootRevision(database, rootUUID) {
+    return JSON.stringify([groundIncarnation(database), ...["entities", "detection_notebook"]
+            .map(inventory => revisionOf(database, { inventory, aspect: "inventory", id: rootUUID })?.toString() ?? null)]);
+}
+/** A database incarnation, the sequence S0 it was read at, and the facts it
+ * consumed. Only an open observation can accumulate facts; admission receives
+ * a closed basis. */
+export class GroundBasis {
+    #incarnation;
+    #sequence;
+    #dependencies = new Map();
+    /** Rows read by identity, and whole repository subtrees, per inventory. */
+    #entities = { entities: new Set(), detection_notebook: new Set() };
+    #territories = { entities: [], detection_notebook: [] };
+    #inventories = new Set();
+    /** The activation each row read consumed with its answer. */
+    #activations = new Map();
+    constructor(incarnation, sequence) {
+        this.#incarnation = incarnation;
+        this.#sequence = sequence;
+    }
+    /** How many facts admission must check; the cost of this basis. */
+    get size() { return this.#dependencies.size; }
+    /** Plain evidence of this basis. It lists the facts of a basis small
+     * enough to check one by one and counts a larger one. */
+    describe() {
+        const facts = [...this.#dependencies.values()];
+        return Object.freeze({ database: this.#incarnation, sequence: this.#sequence.toString(), facts: facts.length,
+            listed: facts.length > POINT_LOOKUPS ? null
+                : Object.freeze(facts.map(({ inventory, aspect, id }) => Object.freeze([inventory, aspect, id]))) });
+    }
+    /** What a saver thread needs to accept this basis: its facts, and every
+     * row it may protect. */
+    toData() {
+        const protectedRows = (inventory) => [...new Set([...this.#entities[inventory], ...this.#territories[inventory].flatMap(uuids => [...uuids])])];
+        return { incarnation: this.#incarnation, sequence: this.#sequence, facts: [...this.#dependencies.keys()],
+            protected: { entities: protectedRows("entities"), detection_notebook: protectedRows("detection_notebook") },
+            inventories: [...this.#inventories] };
+    }
+    static fromData(data) {
+        const basis = new GroundBasis(data.incarnation, data.sequence);
+        for (const id of data.facts) {
+            const [inventory, aspect, fact] = JSON.parse(id);
+            basis.#dependencies.set(id, { inventory, aspect, id: fact });
+        }
+        for (const inventory of INVENTORIES)
+            for (const uuid of data.protected[inventory])
+                basis.#entities[inventory].add(uuid);
+        for (const inventory of data.inventories)
+            basis.#inventories.add(inventory);
+        return basis;
+    }
+    /** One basis consuming every part's facts and protecting every part's
+     * rows; all parts were read at one incarnation and S0. */
+    static union(parts) {
+        const [first] = parts;
+        if (!first)
+            throw new Error("a ground basis union needs a part");
+        const union = new GroundBasis(first.#incarnation, first.#sequence);
+        for (const part of parts) {
+            if (part.#incarnation !== first.#incarnation || part.#sequence !== first.#sequence) {
+                throw new Error("a ground basis union needs one incarnation and sequence");
+            }
+            for (const [id, dependency] of part.#dependencies)
+                union.#dependencies.set(id, dependency);
+            for (const inventory of INVENTORIES) {
+                for (const uuid of part.#entities[inventory])
+                    union.#entities[inventory].add(uuid);
+                union.#territories[inventory].push(...part.#territories[inventory]);
+            }
+            for (const inventory of part.#inventories)
+                union.#inventories.add(inventory);
+            for (const [id, dependency] of part.#activations)
+                union.#activations.set(id, dependency);
+        }
+        return union;
+    }
+    static observe(database) {
+        let late;
+        let closed = false;
+        let failed = false;
+        let readingNow = false;
+        const assertOpen = () => {
+            if (closed || failed)
+                throw new Error("ground observation is closed or failed");
+            if (readingNow) {
+                failed = true;
+                throw new Error("ground observation cannot read or finish inside its callback");
+            }
+        };
+        return Object.freeze({
+            read(operation) {
+                assertOpen();
+                readingNow = true;
+                try {
+                    const captured = GroundBasis.capture(database, operation, late);
+                    if (failed)
+                        throw new Error("ground observation failed during its callback");
+                    late ??= { basis: captured.basis, stamps: new LaterStamps(captured.basis.#sequence) };
+                    return captured.value;
+                }
+                catch (error) {
+                    failed = true;
+                    throw error;
+                }
+                finally {
+                    readingNow = false;
+                }
+            },
+            finish() {
+                assertOpen();
+                if (!late)
+                    throw new Error("ground observation has no reads");
+                closed = true;
+                return late.basis;
+            },
+        });
+    }
+    static capture(database, operation, late) {
+        if (database.inTransaction)
+            throw new Error("ground observation snapshots require a separate read transaction");
+        drainReceipts(database);
+        const capture = database.transaction(() => {
+            if (late && groundIncarnation(database) !== late.basis.#incarnation) {
+                throw new GroundBasisChangedError("ground incarnation changed during observation");
+            }
+            late?.stamps.refresh(database);
+            const basis = late?.basis ?? new GroundBasis(groundIncarnation(database), currentSequence(database));
+            // Intern within one inventory. O and B have different evidence even
+            // when their common row fields happen to match.
+            const retained = new Map();
+            const retain = (inventory, row) => {
+                const key = `${inventory}:${row.uuid}`, previous = retained.get(key);
+                const values = groundRowValues(row, inventory);
+                if (previous && groundRowValues(previous, inventory).every((value, index) => value === values[index]))
+                    return previous;
+                const frozen = Object.freeze(row);
+                retained.set(key, frozen);
+                return frozen;
+            };
+            let active = true;
+            // A first read is S0 itself. A late read recovers S0's answer only
+            // while each consumed fact is still unchanged since S0.
+            // A repeated late read is checked too: its answer is current, and it
+            // may stand for the original only while the fact is unchanged.
+            const remember = (dependency) => {
+                const id = key(dependency);
+                if (late?.stamps.has(id))
+                    throw new GroundBasisChangedError("ground dependency changed after its observation sequence");
+                basis.#dependencies.set(id, dependency);
+            };
+            const assertActive = () => {
+                if (!active)
+                    throw new Error("ground snapshot reader used outside its transaction");
+            };
+            // Read in the same transaction as the answer it qualifies.
+            const activated = (inventory, uuid, row) => {
+                const dependency = activation(inventory, row?.rootUUID ?? "*");
+                remember(dependency);
+                basis.#activations.set(JSON.stringify([inventory, uuid]), dependency);
+            };
+            const entity = (inventory, uuid) => {
+                assertActive();
+                remember({ inventory, aspect: "entity", id: uuid });
+                basis.#entities[inventory].add(uuid);
+                const row = readGroundRow(database, inventory, uuid);
+                activated(inventory, uuid, row);
+                return row && retain(inventory, row);
+            };
+            // A returned row's fields can change with its root's visible
+            // generation, whatever key found it.
+            const shown = (inventory, found) => {
+                for (const rootUUID of new Set(found.map(row => row.rootUUID)))
+                    remember(activation(inventory, rootUUID));
+            };
+            const rows = (inventory, values) => {
+                shown(inventory, values);
+                return Object.freeze(values.map(row => {
+                    remember({ inventory, aspect: "entity", id: row.uuid });
+                    basis.#entities[inventory].add(row.uuid);
+                    return retain(inventory, row);
+                }));
+            };
+            const reader = {
+                repositoryMembers() {
+                    assertActive();
+                    remember({ inventory: "entities", aspect: "repositories", id: "*" });
+                    return effectiveRepositories(database);
+                },
+                physical: uuid => entity("entities", uuid),
+                sharing: uuid => entity("detection_notebook", uuid),
+                atPath(inventory, rootUUID, relativePath) {
+                    assertActive();
+                    remember({ inventory, aspect: "path", id: pathKey(rootUUID, relativePath) });
+                    remember(activation(inventory, rootUUID));
+                    return rows(inventory, cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+            WHERE root_uuid = ? AND relative_path = ? ORDER BY uuid`).all(rootUUID, relativePath));
+                },
+                physicalCandidates(inventory, rootUUID, physicalKey) {
+                    assertActive();
+                    remember({ inventory, aspect: "physical", id: physicalAnswer(rootUUID, physicalKey) });
+                    remember(activation(inventory, rootUUID));
+                    return rows(inventory, cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+            WHERE physical_key = ? AND root_uuid = ? ORDER BY uuid`).all(physicalKey, rootUUID));
+                },
+                objectRows(inventory, physicalKey) {
+                    assertActive();
+                    remember({ inventory, aspect: "object", id: physicalKey });
+                    remember(activation(inventory, "*"));
+                    return rows(inventory, cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+            WHERE physical_key = ? ORDER BY uuid`).all(physicalKey));
+                },
+                subtree(inventory, uuid) {
+                    assertActive();
+                    const owned = reader.territory(inventory, uuid);
+                    if (owned)
+                        return owned.rows();
+                    // Any other subtree is its members' complete child relations, each
+                    // including an empty one; a new descendant invalidates its nearest
+                    // old parent.
+                    const values = cachedStatement(database, `WITH RECURSIVE descendants(uuid) AS (
+            SELECT uuid FROM ${inventory} WHERE uuid = ?
+            UNION SELECT child.uuid FROM ${inventory} AS child JOIN descendants ON child.parent_uuid = descendants.uuid
+          ) SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+            WHERE uuid IN (SELECT uuid FROM descendants) ORDER BY uuid`).all(uuid);
+                    for (const row of values)
+                        remember({ inventory, aspect: "namespace", id: row.uuid });
+                    return rows(inventory, values);
+                },
+                territory(inventory, uuid) {
+                    assertActive();
+                    if (!activeRepository(entity(inventory, uuid)))
+                        return undefined; // An absent root is itself evidence.
+                    // A repository's subtree is exactly its territory and, for each
+                    // active repository within it, that one's own row and territory.
+                    const view = warmTerritory(database, inventory, uuid);
+                    for (const fact of territoryFacts(view))
+                        remember(fact);
+                    return new TerritoryHandle(view, {
+                        read(row) {
+                            basis.#entities[inventory].add(row.uuid);
+                            basis.#activations.set(JSON.stringify([inventory, row.uuid]), activation(inventory, row.rootUUID));
+                        },
+                        readAll(uuids) { basis.#territories[inventory].push(uuids); },
+                        moved: () => new GroundBasisChangedError("territory view moved after its observation"),
+                    });
+                },
+                rootsAtPath(inventory, absolutePath) {
+                    assertActive();
+                    remember({ inventory, aspect: "roots", id: absolutePath });
+                    const found = cachedStatement(database, `SELECT ${GROUND_ROW_PROJECTION} FROM ${inventory}
+            WHERE absolute_path = ? AND relative_path = '' AND status = 'active' ORDER BY uuid`).all(absolutePath);
+                    for (const row of found)
+                        remember({ inventory, aspect: "structure", id: row.uuid });
+                    shown(inventory, found);
+                    return Object.freeze(found.map(row => Object.freeze(structure(inventory, row))));
+                },
+                structure(inventory, uuid) {
+                    assertActive();
+                    remember({ inventory, aspect: "structure", id: uuid });
+                    const row = cachedStatement(database, `SELECT ${GROUND_ROW_PROJECTION} FROM ${inventory} WHERE uuid = ?`).get(uuid);
+                    activated(inventory, uuid, row);
+                    return row && Object.freeze(structure(inventory, row));
+                },
+                children(inventory, parentUUID) {
+                    assertActive();
+                    reader.structure(inventory, parentUUID);
+                    remember({ inventory, aspect: "namespace", id: parentUUID });
+                    const rows = cachedStatement(database, `SELECT ${NAMESPACE_PROJECTION}
+            FROM ${inventory} WHERE parent_uuid = ? ORDER BY uuid`)
+                        .all(parentUUID);
+                    shown(inventory, rows);
+                    return Object.freeze(rows.map(row => Object.freeze(row)));
+                },
+                slot(inventory, parentUUID, name) {
+                    assertActive();
+                    reader.structure(inventory, parentUUID);
+                    remember({ inventory, aspect: "slot", id: slotKey(parentUUID, name) });
+                    const rows = cachedStatement(database, `SELECT ${NAMESPACE_PROJECTION}
+            FROM ${inventory} WHERE parent_uuid = ? AND name = ? ORDER BY uuid`)
+                        .all(parentUUID, name);
+                    shown(inventory, rows);
+                    return Object.freeze(rows.map(row => Object.freeze(row)));
+                },
+                members(inventory, parentUUID) {
+                    assertActive();
+                    entity(inventory, parentUUID); // An absent container is itself evidence.
+                    remember({ inventory, aspect: "namespace", id: parentUUID });
+                    return rows(inventory, cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+            WHERE parent_uuid = ? ORDER BY uuid`).all(parentUUID));
+                },
+                inventory(inventory, rootUUID) {
+                    assertActive();
+                    remember({ inventory, aspect: "inventory", id: rootUUID ?? "*" });
+                    basis.#inventories.add(JSON.stringify([inventory, rootUUID]));
+                    const sql = `SELECT ${groundRowProjection(inventory)} FROM ${inventory}`;
+                    const cursor = (rootUUID === null ? cachedStatement(database, sql).iterate()
+                        : cachedStatement(database, `${sql} WHERE root_uuid = ?`).iterate(rootUUID));
+                    const rows = [];
+                    for (const row of cursor)
+                        rows.push(retain(inventory, row));
+                    return Object.freeze(rows);
+                },
+            };
+            try {
+                const value = operation(reader);
+                if (value && typeof value.then === "function")
+                    throw new Error("ground snapshots cannot contain asynchronous work");
+                return { value, basis };
+            }
+            finally {
+                active = false;
+            }
+        });
+        reading.add(database);
+        try {
+            return capture();
+        }
+        finally {
+            reading.delete(database);
+        }
+    }
+    /** Same incarnation, and no consumed fact stamped after S0. Never compares
+     * the global counter with S0: unrelated writes do not invalidate. A small
+     * basis looks up each fact; a large one intersects the few facts stamped
+     * since S0, so the check is bounded by the smaller side. */
+    unchanged(database) {
+        if (groundIncarnation(database) !== this.#incarnation)
+            return false;
+        if (this.#dependencies.size <= POINT_LOOKUPS) {
+            for (const dependency of this.#dependencies.values()) {
+                const stamp = revisionOf(database, dependency);
+                if (stamp !== undefined && stamp > this.#sequence)
+                    return false;
+            }
+            return true;
+        }
+        return !stampsAfter(database, this.#sequence).some(({ dependency }) => this.#dependencies.has(key(dependency)));
+    }
+    /** Every fact of this basis is a fact of one of these, read against the
+     * same incarnation and S0, so their unchanged answers are its answer. No
+     * expectation is merged: all of them are S0. */
+    within(parts) {
+        const same = parts.filter(part => part.#incarnation === this.#incarnation && part.#sequence === this.#sequence);
+        for (const id of this.#dependencies.keys())
+            if (!same.some(part => part.#dependencies.has(id)))
+                return false;
+        return true;
+    }
+    /** Entities of one inventory written by anyone after S0, and roots whose
+     * visible generation changed after S0, each with the sequence that last
+     * stamped it. Each such root is a responsibility of its own: its rows can
+     * change without their own stamps. */
+    changedSince(database, inventory) {
+        if (groundIncarnation(database) !== this.#incarnation)
+            throw new GroundBasisChangedError("ground incarnation changed");
+        const stamped = stampsAfter(database, this.#sequence).filter(({ dependency }) => dependency.inventory === inventory);
+        return {
+            entities: stamped.filter(({ dependency }) => dependency.aspect === "entity").map(({ dependency, revision }) => [dependency.id, revision]),
+            roots: stamped.filter(({ dependency: { aspect, id } }) => aspect === "activation" && id !== "*")
+                .map(({ dependency, revision }) => [dependency.id, revision]),
+        };
+    }
+    /** One admission unit's basis: the same incarnation and S0, over only the
+     * facts that unit consumed. Its answers derive from the S0 snapshot, so a
+     * fact unchanged since S0 is exactly the validity condition. An entity is
+     * protected only when the original observation could protect it; a
+     * scoped basis never widens allocation authority. */
+    scope(build) {
+        const scoped = new GroundBasis(this.#incarnation, this.#sequence);
+        const add = (dependency) => { scoped.#dependencies.set(key(dependency), dependency); };
+        let open = true;
+        const guard = (operation) => (...values) => {
+            if (!open)
+                throw new Error("a ground scope cannot grow after it is built");
+            operation(...values);
+        };
+        // A row fact carries the activation its original read consumed; one the
+        // original never read by identity consumes the widest.
+        const consumed = (inventory, uuid) => this.#activations.get(JSON.stringify([inventory, uuid])) ?? activation(inventory, "*");
+        build(Object.freeze({
+            entity: guard((inventory, uuid, before) => {
+                add({ inventory, aspect: "entity", id: uuid });
+                add(activation(inventory, before?.rootUUID ?? "*"));
+                if (this.protects(inventory, uuid, before))
+                    scoped.#entities[inventory].add(uuid);
+            }),
+            structure: guard((inventory, uuid) => {
+                add({ inventory, aspect: "structure", id: uuid });
+                add(consumed(inventory, uuid));
+            }),
+            namespace: guard((inventory, uuid) => {
+                add({ inventory, aspect: "namespace", id: uuid });
+                add(consumed(inventory, uuid));
+            }),
+            path: guard((inventory, rootUUID, relativePath) => {
+                add({ inventory, aspect: "path", id: pathKey(rootUUID, relativePath) });
+                add(activation(inventory, rootUUID));
+            }),
+            physical: guard((inventory, rootUUID, physicalKey) => {
+                add({ inventory, aspect: "physical", id: physicalAnswer(rootUUID, physicalKey) });
+                add(activation(inventory, rootUUID));
+            }),
+            roots: guard((inventory, absolutePath) => add({ inventory, aspect: "roots", id: absolutePath })),
+            repositories: guard(() => add({ inventory: "entities", aspect: "repositories", id: "*" })),
+            territory: guard((inventory, uuid) => {
+                add(territory(inventory, uuid));
+                add(consumed(inventory, uuid));
+            }),
+        }));
+        open = false;
+        return scoped;
+    }
+    /** A scoped inventory protects its existing rows. A proposed destination
+     * cannot prove that a missing UUID was originally absent everywhere. */
+    protects(inventory, uuid, before) {
+        return this.#entities[inventory].has(uuid) || this.#territories[inventory].some(uuids => uuids.has(uuid))
+            || this.#inventories.has(JSON.stringify([inventory, null]))
+            || (before !== undefined && this.includesInventory(inventory, before.rootUUID));
+    }
+    includesInventory(inventory, rootUUID) {
+        return this.#inventories.has(JSON.stringify([inventory, null]))
+            || this.#inventories.has(JSON.stringify([inventory, rootUUID]));
+    }
+    /** May place a row this inventory never held: its root inventory, or its
+     * exact destination slot, was observed free. Identity history remains a
+     * separate proof; revision <= S0 never authorizes resurrection. */
+    allocates(inventory, after) {
+        return this.includesInventory(inventory, after.rootUUID)
+            || this.#dependencies.has(key({ inventory, aspect: "path", id: pathKey(after.rootUUID, after.relativePath) }));
+    }
+}
+const POINT_LOOKUPS = 64;
+const pathKey = (rootUUID, relativePath) => JSON.stringify([rootUUID, relativePath]);
+const physicalAnswer = (rootUUID, physicalKey) => JSON.stringify([rootUUID, physicalKey]);
+const slotKey = (parentUUID, name) => JSON.stringify([parentUUID, name]);
+const NAMESPACE_PROJECTION = `uuid, resource_id AS resourceId, root_uuid AS rootUUID, parent_uuid AS parentUUID,
+  name, type, status, relative_path AS relativePath, absolute_path AS absolutePath`;
+const activation = (inventory, rootUUID) => ({ inventory, aspect: "activation", id: rootUUID });
+const territory = (inventory, uuid) => ({ inventory, aspect: "territory", id: uuid });
+/** The write changed an active repository's own head only; its placement in
+ * its owner's package, and so that territory, is unchanged. */
+export const repositoryHeadOnly = (before, after) => activeRepository(before) && activeRepository(after) && before.filesystemMode === after.filesystemMode
+    && equal(namespace(before), namespace(after));
+/** The nearest active repository strictly above each identity in one graph,
+ * memoized and safe on cycles: the owner whose territory the identity is. */
+export function repositoryOwners(lookup) {
+    // The nearest active repository at or above each walked identity.
+    const memo = new Map();
+    return (uuid) => {
+        const chain = new Set();
+        let owner = null;
+        for (let current = lookup(uuid)?.parentUUID ?? null; current !== null;) {
+            if (memo.has(current)) {
+                owner = memo.get(current);
+                break;
+            }
+            const row = lookup(current);
+            if (!row || chain.has(current))
+                break;
+            if (activeRepository(row)) {
+                owner = current;
+                break;
+            }
+            chain.add(current);
+            current = row.parentUUID;
+        }
+        for (const walked of chain)
+            memo.set(walked, owner);
+        if (owner !== null)
+            memo.set(owner, owner);
+        return owner;
+    };
+}
+const namespace = (row) => row && ({
+    uuid: row.uuid, resourceId: row.resourceId, rootUUID: row.rootUUID, parentUUID: row.parentUUID,
+    name: row.name, type: row.type, status: row.status, relativePath: row.relativePath, absolutePath: row.absolutePath,
+});
+const structure = (inventory, row) => row && ({
+    ...namespace(row),
+    association: inventory === "entities" ? Object.freeze({
+        physicalKey: row.physicalKey, kind: (row.filesystemMode ?? 0) & 0o170000,
+    }) : null,
+});
+const equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+/** Each query answer a row belongs to, keyed exactly by the query arguments
+ * that would return it. A row entering or leaving an answer stamps it. */
+function answers(inventory, row) {
+    if (!row)
+        return [];
+    const found = [{ inventory, aspect: "path", id: pathKey(row.rootUUID, row.relativePath) }];
+    if (row.physicalKey !== null && row.physicalKey !== undefined) {
+        found.push({ inventory, aspect: "physical", id: physicalAnswer(row.rootUUID, row.physicalKey) }, { inventory, aspect: "object", id: row.physicalKey });
+    }
+    if (row.relativePath === "" && row.status === "active")
+        found.push({ inventory, aspect: "roots", id: row.absolutePath });
+    return found;
+}
+/** A row's place in the repository membership answer: an active repository's
+ * identity and address. Its state never enters that answer. */
+const member = (inventory, row) => inventory === "entities" && row?.type === "repo.git" && row.status === "active"
+    ? [row.uuid, row.rootUUID, row.absolutePath] : null;
+/** A row's place in the ancestry that decides effective activity. */
+const container = (inventory, row) => inventory === "entities" && row && ["workspace", "folder", "repo.git"].includes(row.type)
+    ? [row.type, row.status, row.parentUUID] : null;
+/** Active repositories with no inactive ancestor. The answer is a function of
+ * repository identities and container ancestry, so it is derived once per
+ * pair of their stamps and reused while neither has advanced. The climb
+ * carries each ancestor's status, so it reads only repositories and their
+ * ancestors by key, never the whole inventory. */
+const effectiveMembers = new WeakMap();
+function effectiveRepositories(database) {
+    const witness = JSON.stringify([groundIncarnation(database), ...["repositories", "containers"]
+            .map(aspect => revisionOf(database, { inventory: "entities", aspect, id: "*" })?.toString() ?? null)]);
+    const known = effectiveMembers.get(database);
+    if (known?.witness === witness)
+        return known.members;
+    const members = Object.freeze(cachedStatement(database, `WITH RECURSIVE ancestry(repository, ancestor, inactive) AS (
+      SELECT uuid, parent_uuid, 0 FROM entities WHERE type = 'repo.git' AND status = 'active'
+      UNION SELECT ancestry.repository, entities.parent_uuid, entities.status <> 'active'
+        FROM ancestry JOIN entities ON entities.uuid = ancestry.ancestor WHERE NOT ancestry.inactive
+    )
+    SELECT uuid, root_uuid AS rootUUID, absolute_path AS absolutePath FROM entities
+     WHERE type = 'repo.git' AND status = 'active'
+       AND uuid NOT IN (SELECT repository FROM ancestry WHERE inactive)
+     ORDER BY uuid`).all().map(member => Object.freeze(member)));
+    effectiveMembers.set(database, { witness, members });
+    return members;
+}
+/** The facts a repository's subtree consumes: the top's row and territory,
+ * each active repository's row and territory beneath it, and the visible
+ * generation of every root its rows belong to. */
+const territoryFacts = (view) => [
+    { inventory: view.inventory, aspect: "entity", id: view.uuid }, territory(view.inventory, view.uuid),
+    ...[...view.nested].flatMap((uuid) => [{ inventory: view.inventory, aspect: "entity", id: uuid },
+        territory(view.inventory, uuid)]),
+    ...[...view.roots].map(rootUUID => activation(view.inventory, rootUUID)),
+];
+const stampedAfter = (database, dependency, sequence) => {
+    const stamp = revisionOf(database, dependency);
+    return stamp !== undefined && stamp > sequence;
+};
+/** Warm repository subtrees per ground file, most recently read last, each
+ * with the sequence it is exact at. A few cover the repositories a machine
+ * edits at once; any other read reloads, which is always exact. Only the
+ * main thread keeps them; every write it does not make itself reaches them
+ * as a saver receipt, in sequence order. */
+const WARM_TERRITORIES = 16;
+const warmFiles = new Map();
+/** Inside a snapshot: the kept view while none of its facts is stamped after
+ * its sequence, since then its answer is this snapshot's; else a reload. */
+function warmTerritory(database, inventory, uuid) {
+    const id = JSON.stringify([inventory, uuid]);
+    return keptTerritory(database, id) ?? keepTerritory(database, id, { incarnation: groundIncarnation(database),
+        sequence: currentSequence(database), view: TerritoryView.load(database, inventory, uuid) });
+}
+/** Inside a read: the kept view, now the most recently read and exact at this
+ * read's sequence, while none of its facts was stamped since; else none. */
+function keptTerritory(database, id) {
+    if (!database.inTransaction)
+        throw new Error("a kept territory is judged inside one read");
+    const warm = warmFiles.get(database.name), known = warm?.get(id);
+    if (!known)
+        return undefined;
+    warm.delete(id);
+    if (known.incarnation !== groundIncarnation(database)
+        || territoryFacts(known.view).some(fact => stampedAfter(database, fact, known.sequence))) {
+        known.view.retire();
+        return undefined;
+    }
+    warm.set(id, known);
+    known.sequence = currentSequence(database);
+    return known.view;
+}
+function keepTerritory(database, id, kept) {
+    let warm = warmFiles.get(database.name);
+    if (!warm)
+        warmFiles.set(database.name, warm = new Map());
+    warm.get(id)?.view.retire();
+    warm.delete(id);
+    warm.set(id, kept);
+    if (warm.size > WARM_TERRITORIES) {
+        const [oldest, evicted] = warm.entries().next().value;
+        warm.delete(oldest);
+        evicted.view.retire();
+    }
+    return kept.view;
+}
+/** Every warm view of one file stops: its receipts may be missing, or the
+ * file closed. */
+export function retireGroundViews(file) {
+    for (const { view } of warmFiles.get(file)?.values() ?? [])
+        view.retire();
+    warmFiles.delete(file);
+}
+/** On the saver's own connection: every stamping write's receipt. */
+const receiptSinks = new WeakMap();
+export function saveGroundReceipts(database, sink) {
+    receiptSinks.set(database, sink);
+}
+/** On the main thread: each file's receipts already sent, taken now. A read
+ * drains before its snapshot, never inside it, so no view runs ahead of the
+ * snapshot that uses it; a write drains inside its own transaction, which
+ * already sees every committed receipt. */
+const receiptSources = new Map();
+export function registerReceiptSource(file, drain) {
+    if (drain)
+        receiptSources.set(file, drain);
+    else
+        receiptSources.delete(file);
+}
+const drainReceipts = (database) => receiptSources.get(database.name)?.();
+/** Receipts arrive in sequence order, and the main thread's own writes carry
+ * its views synchronously, so a view exact at an earlier sequence is exact
+ * just before this one. A view this write touches is carried from the rows
+ * it stored; one it cannot carry is dropped. */
+export function carryGroundReceipt(file, receipt) {
+    const warm = warmFiles.get(file);
+    if (!warm || receipt.stamped.length === 0)
+        return;
+    const stamped = new Set(receipt.stamped);
+    const decoded = new Map();
+    const writtenIn = (inventory) => {
+        let rows = decoded.get(inventory);
+        if (!rows) {
+            const bytes = receipt.written[inventory];
+            const entries = bytes ? deserialize(bytes) : [];
+            decoded.set(inventory, rows = new Map(entries.map(([uuid, row, children]) => [uuid, { row, children }])));
+        }
+        return rows;
+    };
+    for (const [id, known] of warm) {
+        if (receipt.sequence <= known.sequence)
+            continue;
+        const facts = territoryFacts(known.view);
+        if (!facts.some(fact => stamped.has(key(fact))))
+            continue;
+        const written = writtenIn(known.view.inventory);
+        const plan = known.incarnation === receipt.incarnation
+            && !facts.some(fact => fact.aspect === "activation" && stamped.has(key(fact)))
+            ? known.view.plan(uuid => written.get(uuid)?.row ?? undefined, uuid => written.get(uuid)?.children ?? undefined, written.keys())
+            : null;
+        if (plan) {
+            known.view.apply(plan);
+            known.sequence = receipt.sequence;
+        }
+        else {
+            warm.delete(id);
+            known.view.retire();
+        }
+    }
+}
+/** On a content thread's read-only connection. */
+export function readTerritories(database, uuid, inventories) {
+    const read = database.transaction(() => ({ incarnation: groundIncarnation(database), sequence: currentSequence(database),
+        subtrees: inventories.map(inventory => readSubtree(database, inventory, uuid)) }))();
+    return { ...read, subtrees: read.subtrees.map(rows => rows && subtreePages(rows)) };
+}
+/** Outside every snapshot, before one reads these repositories: the views no
+ * snapshot would find exact are read off this thread (`read`), built a page
+ * per step, and kept once a short read finds them exact now; each pair's
+ * agreement is compared a few rows per step. A view some write moved after
+ * its read is read again, a few times at most; one still moving is left to
+ * the snapshot, which reads it inside itself. */
+export async function prepareTerritories(database, repositories, read) {
+    for (const uuid of repositories) {
+        const views = new Map();
+        for (let attempt = 0; attempt < PREPARE_ATTEMPTS; attempt++) {
+            drainReceipts(database);
+            for (const inventory of INVENTORIES) {
+                const view = views.get(inventory) ?? currentTerritory(database, JSON.stringify([inventory, uuid]));
+                if (view)
+                    views.set(inventory, view);
+            }
+            const missing = INVENTORIES.filter(inventory => !views.has(inventory));
+            if (!missing.length)
+                break;
+            const { incarnation, sequence, subtrees } = await read(uuid, missing);
+            let absent = 0;
+            for (const [at, inventory] of missing.entries()) {
+                // No active repository: the snapshot answers that itself.
+                if (!subtrees[at]) {
+                    absent += 1;
+                    continue;
+                }
+                const building = TerritoryView.building(inventory, uuid, subtrees[at]);
+                let step = building.next();
+                for (; !step.done; step = building.next())
+                    await turnBoundary();
+                const id = JSON.stringify([inventory, uuid]);
+                drainReceipts(database);
+                if (!currentTerritory(database, id))
+                    keepTerritory(database, id, { incarnation, sequence, view: step.value });
+            }
+            if (absent === missing.length)
+                break;
+        }
+        const o = views.get("entities"), b = views.get("detection_notebook");
+        if (!o || !b)
+            continue;
+        const agreeing = TerritoryView.agreeing(o, b);
+        while (!agreeing.next().done)
+            await turnBoundary();
+    }
+}
+const PREPARE_ATTEMPTS = 3;
+/** Outside every snapshot: the kept view when it is exact now, in one short read. */
+const currentTerritory = (database, id) => database.transaction(() => keptTerritory(database, id))();
+/** Inside a write, after its rows and before its stamps. A view whose facts
+ * this write stamps is carried to the write's sequence only by an outermost
+ * commit, only when it was exact before the write, and only from the rows
+ * the write stored; any other such view is dropped. A savepoint cannot
+ * certify its commit, and a changed visible generation is no row change.
+ * The returned step runs after the commit and never before it. */
+function carryTerritories(database, stamped, written, outermost) {
+    drainReceipts(database);
+    const warm = warmFiles.get(database.name);
+    if (!warm)
+        return () => { };
+    const incarnation = groundIncarnation(database);
+    const stored = new Map();
+    const carried = [];
+    for (const [id, known] of warm) {
+        const facts = territoryFacts(known.view);
+        if (!facts.some(fact => stamped.has(key(fact))))
+            continue;
+        const { inventory } = known.view;
+        const plan = outermost && known.incarnation === incarnation
+            && !facts.some(fact => fact.aspect === "activation" && stamped.has(key(fact)))
+            && !facts.some(fact => stampedAfter(database, fact, known.sequence))
+            ? known.view.plan(uuid => {
+                const id = JSON.stringify([inventory, uuid]);
+                if (!stored.has(id))
+                    stored.set(id, readGroundRow(database, inventory, uuid));
+                return stored.get(id);
+            }, uuid => cachedStatement(database, `SELECT uuid FROM ${inventory} WHERE parent_uuid = ?`).pluck().all(uuid), written.filter(change => change.inventory === inventory).map(({ before, after }) => (after ?? before).uuid))
+            : null;
+        if (plan)
+            carried.push({ known, plan });
+        else {
+            warm.delete(id);
+            known.view.retire();
+        }
+    }
+    return sequence => {
+        for (const { known, plan } of carried) {
+            known.view.apply(plan);
+            known.sequence = sequence;
+        }
+    };
+}
+/** Every fact a change of this root's visible generation can change without
+ * a member write, in both inventories, read inside the changing transaction
+ * after the change: the root's own activation and aggregates, the roots
+ * answers its root rows supply, the namespace and slot their portable
+ * parents list them in, and repository membership when it holds a repository. Ancestry
+ * is stamped as a whole. It names the answers the root now supplies; a
+ * change that also hides stored rows must add the answers they supplied. */
+function activationVector(database, rootUUID) {
+    const vector = [{ inventory: "entities", aspect: "containers", id: "*" }];
+    for (const inventory of ["entities", "detection_notebook"]) {
+        vector.push(activation(inventory, rootUUID), activation(inventory, "*"), { inventory, aspect: "inventory", id: rootUUID }, { inventory, aspect: "inventory", id: "*" });
+        for (const { absolutePath, parentUUID, name, status } of cachedStatement(database, `SELECT absolute_path AS absolutePath,
+      parent_uuid AS parentUUID, name, status FROM ${inventory} WHERE root_uuid = ? AND relative_path = ''`)
+            .all(rootUUID)) {
+            if (status === "active")
+                vector.push({ inventory, aspect: "roots", id: absolutePath });
+            if (parentUUID !== null) {
+                vector.push({ inventory, aspect: "namespace", id: parentUUID }, { inventory, aspect: "slot", id: slotKey(parentUUID, name) });
+            }
+        }
+    }
+    if (cachedStatement(database, `SELECT EXISTS(SELECT 1 FROM entities
+    WHERE root_uuid = ? AND type = 'repo.git' AND status = 'active')`).pluck().get(rootUUID)) {
+        vector.push({ inventory: "entities", aspect: "repositories", id: "*" });
+    }
+    return vector;
+}
+/** Stamps every fact these committed transitions change, and the activation
+ * vector of each root whose visible generation this transaction changed,
+ * with one new sequence, inside the caller's write transaction. Returns the
+ * stamp count and the step the caller runs after its outermost commit.
+ *
+ * A row placed where none stood, in a root whose first generation this
+ * transaction installs, beneath a parent placed the same way or none, is
+ * stamped by that vector alone. Every earlier answer it could join was
+ * empty of it and consumed that root's activation or `*`: an answer keyed
+ * inside the root names the root, one keyed by an absent identity or an
+ * object names `*`, and the aggregates and the root rows' namespaces
+ * are the vector's. A child list of a parent that stood consumed its own
+ * root's activation, so a row placed beneath one is stamped as usual. An
+ * installation therefore stamps a few facts however many rows it places,
+ * and no territory can hold its rows unless its activation is stamped. */
+export function advanceGroundBasis(database, transitions, activated, outermost) {
+    const changed = new Map();
+    const add = (dependency) => { changed.set(key(dependency), dependency); };
+    const installed = new Set(activated);
+    for (const rootUUID of installed)
+        for (const dependency of activationVector(database, rootUUID))
+            add(dependency);
+    const written = [...transitions].filter(({ inventory, before, after }) => !equal(before && groundRowValues(before, inventory), after && groundRowValues(after, inventory)));
+    const placed = new Set(written.filter(({ before, after }) => !before && installed.has(after.rootUUID))
+        .map(({ inventory, after }) => JSON.stringify([inventory, after.uuid])));
+    const stamping = placed.size === 0 ? written : written.filter(({ inventory, before, after }) => before || !placed.has(JSON.stringify([inventory, after.uuid]))
+        || (after.parentUUID !== null && !placed.has(JSON.stringify([inventory, after.parentUUID]))));
+    // Owners resolve in the graph before this transaction, from each written
+    // row's original, and in the committed graph after it.
+    const owners = Object.fromEntries(["entities", "detection_notebook"].map(inventory => {
+        const originals = new Map(written.filter(change => change.inventory === inventory)
+            .map(change => [(change.after ?? change.before).uuid, change.before]));
+        const current = (uuid) => cachedStatement(database, `SELECT parent_uuid AS parentUUID, type, status FROM ${inventory} WHERE uuid = ?`).get(uuid);
+        return [inventory, {
+                before: repositoryOwners(uuid => originals.has(uuid) ? originals.get(uuid) : current(uuid)),
+                after: repositoryOwners(current),
+            }];
+    }));
+    // What a territory can hold, for the saver's receipt.
+    const held = { entities: [], detection_notebook: [] };
+    const repositories = new Set();
+    for (const transition of stamping) {
+        const { inventory, before, after } = transition;
+        const uuid = (after ?? before).uuid;
+        const repository = activeRepository(before) || activeRepository(after);
+        let owned = false;
+        if (!repositoryHeadOnly(before, after)) {
+            for (const owner of [before && owners[inventory].before(uuid), after && owners[inventory].after(uuid)]) {
+                if (owner) {
+                    add(territory(inventory, owner));
+                    owned = true;
+                }
+            }
+        }
+        if (repository || owned)
+            held[inventory].push(transition);
+        if (repository)
+            repositories.add(key({ inventory, aspect: "entity", id: uuid }));
+        if (activeRepository(before) !== activeRepository(after))
+            add(territory(inventory, uuid));
+        add({ inventory, aspect: "entity", id: uuid });
+        add({ inventory, aspect: "inventory", id: "*" });
+        for (const row of [before, after])
+            if (row)
+                add({ inventory, aspect: "inventory", id: row.rootUUID });
+        if (!equal(structure(inventory, before), structure(inventory, after)))
+            add({ inventory, aspect: "structure", id: uuid });
+        if (!equal(namespace(before), namespace(after)))
+            for (const row of [before, after]) {
+                if (!row?.parentUUID)
+                    continue;
+                add({ inventory, aspect: "namespace", id: row.parentUUID });
+                add({ inventory, aspect: "slot", id: slotKey(row.parentUUID, row.name) });
+            }
+        // Both the old and the new answer change when membership moves; an
+        // answer that stays with the row changes only through its entity key.
+        const left = answers(inventory, before), right = answers(inventory, after);
+        const kept = new Set(left.map(key).filter(id => right.some(dependency => key(dependency) === id)));
+        for (const dependency of [...left, ...right])
+            if (!kept.has(key(dependency)))
+                add(dependency);
+        if (!equal(member(inventory, before), member(inventory, after)))
+            add({ inventory, aspect: "repositories", id: "*" });
+        if (!equal(container(inventory, before), container(inventory, after)))
+            add({ inventory, aspect: "containers", id: "*" });
+    }
+    if (changed.size === 0)
+        return { writes: 0, committed: () => { } };
+    const carry = carryTerritories(database, changed, written, outermost);
+    const sequence = cachedStatement(database, "UPDATE ground_sequence SET value = value + 1 WHERE singleton = 1 RETURNING value", true).get().value;
+    const write = cachedStatement(database, `INSERT INTO ground_revisions(inventory, aspect, identity, revision)
+    VALUES (?, ?, ?, ?) ON CONFLICT(inventory, aspect, identity) DO UPDATE SET revision = excluded.revision`);
+    for (const dependency of changed.values())
+        write.run(dependency.inventory, dependency.aspect, dependency.id, sequence);
+    receiptSinks.get(database)?.(receipt(database, sequence, changed, held, repositories));
+    return { writes: changed.size, committed: () => carry(sequence) };
+}
+/** On the saver, inside the write: its receipt, with the stamps a warm view
+ * consumes and the rows it held read back as stored. */
+function receipt(database, sequence, changed, held, repositories) {
+    const stamped = [...changed].filter(([id, { aspect }]) => aspect === "territory" || aspect === "activation" || repositories.has(id)).map(([id]) => id);
+    const written = {};
+    for (const inventory of stamped.length ? INVENTORIES : []) {
+        const changes = held[inventory];
+        if (!changes.length)
+            continue;
+        const uuids = [...new Set(changes.map(({ before, after }) => (after ?? before).uuid))];
+        const rows = new Map(cachedStatement(database, `SELECT ${groundRowProjection(inventory)} FROM ${inventory}
+      WHERE uuid IN (SELECT value FROM json_each(?))`).all(JSON.stringify(uuids)).map(row => [row.uuid, row]));
+        const moved = changes.some(({ before, after }) => !before || (after && after.parentUUID !== before.parentUUID));
+        const children = new Map();
+        if (moved) {
+            for (const { parent, uuid } of cachedStatement(database, `SELECT parent_uuid AS parent, uuid FROM ${inventory}
+        WHERE parent_uuid IN (SELECT value FROM json_each(?))`).all(JSON.stringify([...rows.keys()]))) {
+                const listed = children.get(parent);
+                if (listed)
+                    listed.push(uuid);
+                else
+                    children.set(parent, [uuid]);
+            }
+        }
+        written[inventory] = serialize(uuids.map(uuid => {
+            const row = rows.get(uuid) ?? null;
+            return [uuid, row, row && moved ? children.get(uuid) ?? [] : null];
+        }));
+    }
+    return { incarnation: groundIncarnation(database), sequence, stamped, written };
+}
+//# sourceMappingURL=ground-basis.js.map