@amalgm/shell 0.1.142 → 0.1.144

package/dist/entity-apply-host.js

@@ -1,8 +1,8 @@
 /** Node filesystem, immutable-cache, Git, and Verify effects for Live Apply. */
 import { createHash } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, linkSync, lstatSync, openSync, readFileSync, readlinkSync, renameSync, rmSync, symlinkSync, } from "node:fs";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
-import { applyRepositoryIdentity, buildEntityApplyEffects, createUserGroundEnrollmentPolicy, indexRepositoryTerritory, repositoryIdentityHash, } from "@amalgm/live";
+import { chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, linkSync, lstatSync, openSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, symlinkSync, } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+import { applyRepositoryIdentity, buildEntityApplyEffects, createUserGroundEnrollmentPolicy, indexRepositoryTerritory, materializedSlotNames, portableFileMode, repositoryIdentityHash, } from "@amalgm/live";
 import Database from "better-sqlite3";
 import { ensurePrivateDir, ensureUserDir } from "./filesystem.js";
 import { applyRepositoryFiles, hasGitMarker, inspectRepositoryTransportFile, markRepositoryReveal, nestedRepositoryPaths, observeRepository, repositoryObservationMatches, repositoryRevealInProgress, } from "./git-repository-host.js";
@@ -31,6 +31,7 @@ const portable = (row) => ({
     version: row.version,
     payloadVersion: row.payloadVersion,
     transportVersion: row.transportVersion,
+    fileMode: portableFileMode(row.type, row.filesystemMode),
 });
 function fsyncFile(path) {
     const fd = openSync(path, "r");
@@ -101,6 +102,14 @@ export class EntityApplyHost {
     #rowAtPath;
     #entityAtPath;
     #rowsUnderRoot;
+    #notebookUnderRoot;
+    #rowsByParent;
+    #entitiesByParent;
+    #relocateNotebookRow;
+    #relocateEntityRow;
+    #refreshNotebookCtime;
+    #refreshEntityCtime;
+    #onLawRelocationStage;
     #prepared = new Map();
     #groundReleases = new Map();
     /** Repository moments one intent has already read, keyed by intent then by
@@ -127,6 +136,14 @@ export class EntityApplyHost {
         this.#rowAtPath = this.#database.prepare(`${groundSelect("detection_notebook")} WHERE absolute_path = ? AND status = 'active' LIMIT 1`);
         this.#entityAtPath = this.#database.prepare(`${groundSelect("entities")} WHERE absolute_path = ? AND status = 'active' LIMIT 1`);
         this.#rowsUnderRoot = this.#database.prepare(`${groundSelect("entities")} WHERE root_uuid = ? ORDER BY relative_path`);
+        this.#notebookUnderRoot = this.#database.prepare(`${groundSelect("detection_notebook")} WHERE root_uuid = ? ORDER BY relative_path`);
+        this.#rowsByParent = this.#database.prepare(`${groundSelect("detection_notebook")} WHERE parent_uuid = ?`);
+        this.#entitiesByParent = this.#database.prepare(`${groundSelect("entities")} WHERE parent_uuid = ?`);
+        this.#relocateNotebookRow = this.#database.prepare("UPDATE detection_notebook SET relative_path = ?, absolute_path = ? WHERE uuid = ?");
+        this.#relocateEntityRow = this.#database.prepare("UPDATE entities SET relative_path = ?, absolute_path = ? WHERE uuid = ?");
+        this.#refreshNotebookCtime = this.#database.prepare("UPDATE detection_notebook SET changed_time_ms = ? WHERE uuid = ?");
+        this.#refreshEntityCtime = this.#database.prepare("UPDATE entities SET changed_time_ms = ? WHERE uuid = ?");
+        this.#onLawRelocationStage = options.onLawRelocationStage;
         const adapters = [
             "workspace", "folder", "repo.git", "file.text", "file.binary", "link", "reference",
         ].map((type) => this.#adapter(type));
@@ -337,6 +354,8 @@ export class EntityApplyHost {
             }
             if (current
                 && exactRecord(portable(current), plan.target)
+                && context.beforeRelocations.length === 0
+                && context.afterRelocations.length === 0
                 && (repositoryTargetMatches
                     || await this.#matches(intent, plan.target, context.targetPath, plan, current))) {
                 return { kind: "already-target" };
@@ -348,6 +367,8 @@ export class EntityApplyHost {
             // can advance the row directly. Equal bytes at a different address are
             // deliberately not identity evidence.
             if (current?.absolutePath === context.targetPath
+                && context.beforeRelocations.length === 0
+                && context.afterRelocations.length === 0
                 && await this.#matches(intent, plan.target, context.targetPath, plan)) {
                 return { kind: "already-target" };
             }
@@ -360,12 +381,24 @@ export class EntityApplyHost {
                 if (await this.#matches(intent, plan.target, context.targetPath, plan)) {
                     return { kind: "already-target" };
                 }
+                if (context.collisionEligible
+                    && await this.#lawRelocationsReady(intent, plan, context.beforeRelocations)) {
+                    if (intent.phase === "declared")
+                        this.#releaseGround(intent);
+                    return { kind: "safe" };
+                }
                 this.#releaseGround(intent);
                 return this.#heldDestination(intent, context.targetPath);
             }
             // A move/rename may never erase a different thing already occupying the
             // accepted destination.
             if (current.absolutePath !== context.targetPath && tryLstat(context.targetPath)) {
+                if (context.collisionEligible
+                    && await this.#lawRelocationsReady(intent, plan, context.beforeRelocations)) {
+                    if (intent.phase === "declared")
+                        this.#releaseGround(intent);
+                    return { kind: "safe" };
+                }
                 this.#releaseGround(intent);
                 return this.#heldDestination(intent, context.targetPath);
             }
@@ -419,8 +452,10 @@ export class EntityApplyHost {
         try {
             const context = this.#context(plan.target);
             const prepared = await this.#ensurePrepared(intent, plan);
+            this.#relocateLawSiblings(context, context.beforeRelocations);
             if (plan.kind === "lifecycle") {
                 this.#removeWithRecovery(intent, context);
+                this.#relocateAfterTarget(plan.target, context);
                 return;
             }
             if (plan.kind === "repo.git") {
@@ -434,6 +469,7 @@ export class EntityApplyHost {
                     markRepositoryReveal(context.current.absolutePath);
                 }
                 if (context.current && context.current.absolutePath !== context.targetPath
+                    && !context.currentShared
                     && tryLstat(context.current.absolutePath)) {
                     this.#moveWithRecovery(intent, context.current.absolutePath, context.targetPath, context);
                 }
@@ -443,10 +479,12 @@ export class EntityApplyHost {
                 // ground, the same moment, no second capture.
                 this.#observe(intent, context.targetPath, applied.identity, { stateId: applied.stateId, card: applied.card });
                 this.#moveRepositoryRelocations(intent, context, repository.identity);
+                this.#relocateAfterTarget(plan.target, context);
                 return;
             }
             if (plan.kind === "structure") {
-                if (context.current && context.current.absolutePath !== context.targetPath) {
+                if (context.current && context.current.absolutePath !== context.targetPath
+                    && !context.currentShared) {
                     this.#moveWithRecovery(intent, context.current.absolutePath, context.targetPath, context);
                 }
                 else if (!tryLstat(context.targetPath)) {
@@ -464,6 +502,14 @@ export class EntityApplyHost {
                     && hasGitMarker(context.targetPath)) {
                     rmSync(join(context.targetPath, ".git"), { recursive: true, force: true });
                 }
+                if (plan.target.type === "file.text" || plan.target.type === "file.binary") {
+                    if (plan.target.fileMode === null) {
+                        throw new Error(`ordinary file ${plan.target.uuid} has no portable mode`);
+                    }
+                    chmodSync(context.targetPath, plan.target.fileMode);
+                    fsyncFile(context.targetPath);
+                }
+                this.#relocateAfterTarget(plan.target, context);
                 return;
             }
             // Identity owns the address transition. A content or link result may
@@ -472,21 +518,25 @@ export class EntityApplyHost {
             // installing at the new address would leave the old address behind for
             // Detect to misidentify as a new local entity and echo back to cloud.
             if (context.current && context.current.absolutePath !== context.targetPath
+                && !context.currentShared
                 && tryLstat(context.current.absolutePath)) {
                 this.#moveWithRecovery(intent, context.current.absolutePath, context.targetPath, context);
             }
             if (plan.kind === "reference") {
                 this.#installLink(intent, context, relative(dirname(context.targetPath), join(this.#bindingDir, plan.targetEntityId)));
+                this.#relocateAfterTarget(plan.target, context);
                 return;
             }
             if (plan.kind === "link") {
                 this.#installLink(intent, context, plan.targetText);
+                this.#relocateAfterTarget(plan.target, context);
                 return;
             }
             const artifact = prepared.artifact;
             if (!artifact)
                 throw new Error(`${plan.kind} Apply has no prepared immutable artifact`);
             this.#installArtifact(intent, context, plan.target, artifact);
+            this.#relocateAfterTarget(plan.target, context);
         }
         catch (error) {
             this.#releaseGround(intent);
@@ -558,6 +608,10 @@ export class EntityApplyHost {
         const addresses = new Set([context.targetPath]);
         if (context.current)
             addresses.add(context.current.absolutePath);
+        for (const relocation of [...context.beforeRelocations, ...context.afterRelocations]) {
+            addresses.add(relocation.source);
+            addresses.add(relocation.destination);
+        }
         if (plan.kind === "repo.git") {
             const repository = this.#prepared.get(this.#key(intent))?.repository;
             if (repository) {
@@ -577,6 +631,99 @@ export class EntityApplyHost {
         this.#groundReleases.delete(key);
         release();
     }
+    /** A collision relocation is safe only when every source still proves its
+     * own portable identity and every destination is either free or another
+     * relocation source. The final reveal then performs the whole finite chain
+     * while holding all source and destination cones. */
+    async #lawRelocationsReady(intent, plan, relocations) {
+        if (relocations.length === 0)
+            return false;
+        const sources = new Set(relocations.map(({ source }) => source));
+        for (const { row, source, destination } of relocations) {
+            if (tryLstat(destination) && !sources.has(destination))
+                return false;
+            if (!await this.#matches(intent, portable(row), source, plan, row))
+                return false;
+        }
+        return true;
+    }
+    /** Relocate a derived-name chain without ever overwriting ground. Each move
+     * whose destination is free commits row addresses first, then renames disk.
+     * A crash between those facts is repaired by Detect from the same portable
+     * identity; the derived suffix can never become a rename mutation. */
+    #relocateLawSiblings(_context, relocations) {
+        const pending = [...relocations];
+        while (pending.length > 0) {
+            const sources = new Set(pending.map(({ source }) => source));
+            const index = pending.findIndex(({ destination }) => !sources.has(destination) && !tryLstat(destination));
+            if (index < 0) {
+                throw new Error("derived address relocations have no free destination");
+            }
+            const relocation = pending.splice(index, 1)[0];
+            if (!relocation)
+                throw new Error("derived address relocation vanished");
+            const { row, source, destination } = relocation;
+            if (!tryLstat(source))
+                continue;
+            const destinationRelative = relative(this.#root(row).absolutePath, destination)
+                .split(sep).join("/");
+            const descendants = (rows) => rows.filter((candidate) => pathInside(source, candidate.absolutePath));
+            const entityRows = descendants(this.#rowsUnderRoot.all(row.rootUUID));
+            const notebookRows = descendants(this.#notebookUnderRoot.all(row.rootUUID));
+            this.#database.transaction(() => {
+                for (const candidate of entityRows) {
+                    this.#relocateEntityRow.run(destinationRelative + candidate.relativePath.slice(row.relativePath.length), destination + candidate.absolutePath.slice(source.length), candidate.uuid);
+                }
+                for (const candidate of notebookRows) {
+                    this.#relocateNotebookRow.run(destinationRelative + candidate.relativePath.slice(row.relativePath.length), destination + candidate.absolutePath.slice(source.length), candidate.uuid);
+                }
+            })();
+            this.#onLawRelocationStage?.("rows-committed", row.uuid, destination);
+            renameSync(source, destination);
+            this.#onLawRelocationStage?.("ground-moved", row.uuid, destination);
+            const moved = lstatSync(destination);
+            this.#refreshEntityCtime.run(moved.ctimeMs, row.uuid);
+            this.#refreshNotebookCtime.run(moved.ctimeMs, row.uuid);
+        }
+    }
+    /** Reveal has already moved or removed the target ground. Release its old
+     * SQLite address before a sibling takes that slot; final Verify will write
+     * the complete accepted row. The durable Apply intent owns any crash in
+     * this short interval. */
+    #relocateAfterTarget(target, context) {
+        if (context.afterRelocations.length === 0)
+            return;
+        const current = context.current;
+        if (current) {
+            const entityRows = this.#rowsUnderRoot.all(current.rootUUID)
+                .filter((row) => pathInside(current.absolutePath, row.absolutePath));
+            const notebookRows = this.#notebookUnderRoot.all(current.rootUUID)
+                .filter((row) => pathInside(current.absolutePath, row.absolutePath));
+            if (target.status === "active") {
+                const destinationRelative = relative(this.#root(current).absolutePath, context.targetPath)
+                    .split(sep).join("/");
+                this.#database.transaction(() => {
+                    for (const row of entityRows) {
+                        this.#relocateEntityRow.run(destinationRelative + row.relativePath.slice(current.relativePath.length), context.targetPath + row.absolutePath.slice(current.absolutePath.length), row.uuid);
+                    }
+                    for (const row of notebookRows) {
+                        this.#relocateNotebookRow.run(destinationRelative + row.relativePath.slice(current.relativePath.length), context.targetPath + row.absolutePath.slice(current.absolutePath.length), row.uuid);
+                    }
+                })();
+            }
+            else {
+                const removeEntity = this.#database.prepare("DELETE FROM entities WHERE uuid = ?");
+                const removeNotebook = this.#database.prepare("DELETE FROM detection_notebook WHERE uuid = ?");
+                this.#database.transaction(() => {
+                    for (const row of entityRows)
+                        removeEntity.run(row.uuid);
+                    for (const row of notebookRows)
+                        removeNotebook.run(row.uuid);
+                })();
+            }
+        }
+        this.#relocateLawSiblings(context, context.afterRelocations);
+    }
     #emit(intent, plan, stage) {
         this.#onStage?.({
             entityId: intent.entityId,
@@ -661,8 +808,10 @@ export class EntityApplyHost {
         const staged = join(control, "prepared");
         rmSync(staged, { recursive: true, force: true });
         copyFileSync(artifact.file, staged);
-        const currentMode = context.current && tryLstat(context.current.absolutePath)?.mode;
-        chmodSync(staged, currentMode ? currentMode & 0o777 : 0o644);
+        if (target.fileMode === null) {
+            throw new Error(`ordinary file ${target.uuid} has no portable mode`);
+        }
+        chmodSync(staged, target.fileMode);
         // The completion transaction is durable; the revealed bytes must be too,
         // or a power loss leaves the notebook naming a target whose file is
         // truncated on disk, and Detect would publish that truncation as head.
@@ -729,6 +878,7 @@ export class EntityApplyHost {
         if (record.type === "file.text" || record.type === "file.binary") {
             return stats.isFile() && !stats.isSymbolicLink()
                 && record.payloadVersion !== null
+                && record.fileMode === portableFileMode(record.type, stats.mode)
                 && await this.#hashFile(path) === record.payloadVersion;
         }
         if (record.type === "link") {
@@ -790,7 +940,7 @@ export class EntityApplyHost {
             record: target,
             relativePath: target.parentUUID === null
                 ? prior.relativePath
-                : [context.parent?.relativePath, target.name].filter(Boolean).join("/"),
+                : [context.parent?.relativePath, context.targetName].filter(Boolean).join("/"),
             absolutePath: context.targetPath,
             deviceNumber: "dev" in evidence ? evidence.dev : evidence.deviceNumber,
             inode: "ino" in evidence ? evidence.ino : evidence.inode,
@@ -931,10 +1081,124 @@ export class EntityApplyHost {
         if (target.parentUUID !== null && !parent) {
             throw new Error(`entity ${target.uuid} waits for materialized parent ${target.parentUUID}`);
         }
-        const targetPath = parent ? join(parent.absolutePath, target.name) : current?.absolutePath;
-        if (!targetPath)
-            throw new Error(`root entity ${target.uuid} has no machine binding`);
-        return { current, parent, targetPath };
+        if (!parent) {
+            const targetPath = current?.absolutePath;
+            if (!targetPath)
+                throw new Error(`root entity ${target.uuid} has no machine binding`);
+            return {
+                current,
+                parent,
+                targetPath,
+                targetName: target.name,
+                beforeRelocations: [],
+                afterRelocations: [],
+                currentShared: false,
+                collisionEligible: false,
+            };
+        }
+        const finalByParent = new Map();
+        const affectedParents = new Map();
+        affectedParents.set(parent.uuid, parent);
+        if (current?.parentUUID && current.parentUUID !== parent.uuid) {
+            const oldParent = this.#current(current.parentUUID);
+            if (!oldParent)
+                throw new Error(`entity ${target.uuid} lost materialized parent ${current.parentUUID}`);
+            affectedParents.set(oldParent.uuid, oldParent);
+        }
+        for (const parentRow of affectedParents.values()) {
+            finalByParent.set(parentRow.uuid, [...this.#activeSiblings(parentRow.uuid)].filter((row) => row.uuid !== target.uuid));
+        }
+        if (target.status === "active") {
+            finalByParent.get(parent.uuid)?.push({
+                ...(current ?? parent),
+                uuid: target.uuid,
+                type: target.type,
+                parentUUID: target.parentUUID,
+                name: target.name,
+                status: target.status,
+            });
+        }
+        const derivedByUuid = new Map();
+        for (const siblings of finalByParent.values()) {
+            for (const [uuid, name] of materializedSlotNames(siblings))
+                derivedByUuid.set(uuid, name);
+        }
+        const collisionEligible = current === null
+            || (current.parentUUID === target.parentUUID && current.name === target.name);
+        const targetName = target.status === "active"
+            ? collisionEligible ? derivedByUuid.get(target.uuid) ?? target.name : target.name
+            : current ? basename(current.absolutePath) : target.name;
+        const targetPath = target.status === "active"
+            ? join(parent.absolutePath, targetName)
+            : current?.absolutePath ?? join(parent.absolutePath, targetName);
+        const beforeRelocations = [];
+        const afterRelocations = [];
+        for (const [parentUUID, siblings] of finalByParent) {
+            const parentRow = affectedParents.get(parentUUID);
+            if (!parentRow)
+                continue;
+            for (const row of siblings) {
+                if (row.uuid === target.uuid)
+                    continue;
+                if (!collisionEligible
+                    && row.parentUUID === target.parentUUID
+                    && row.name === target.name)
+                    continue;
+                const destination = join(parentRow.absolutePath, derivedByUuid.get(row.uuid) ?? row.name);
+                const source = destination === row.absolutePath && !tryLstat(destination)
+                    ? this.#physicalSiblingPath(parentRow.absolutePath, row)
+                    : row.absolutePath;
+                if (source === null || source === destination)
+                    continue;
+                const relocation = { row, source, destination };
+                const leavesOldSlot = current !== null
+                    && row.parentUUID === current.parentUUID
+                    && row.name === current.name
+                    && (target.status !== "active"
+                        || target.parentUUID !== current.parentUUID
+                        || target.name !== current.name);
+                (leavesOldSlot ? afterRelocations : beforeRelocations).push(relocation);
+            }
+        }
+        return {
+            current,
+            parent,
+            targetPath,
+            targetName,
+            beforeRelocations,
+            afterRelocations,
+            currentShared: current !== null
+                && [...finalByParent.values()].flat()
+                    .some((row) => row.uuid !== current.uuid && row.absolutePath === current.absolutePath),
+            // A new identity can arrive concurrently in an already-held portable
+            // slot. An existing identity renaming or moving into another identity's
+            // slot is not concurrency; mutation-time law forbids it and Apply keeps
+            // treating that accepted anomaly as a conflict.
+            collisionEligible,
+        };
+    }
+    /** Active children across accepted and Detect truth; the notebook row wins
+     * for a UUID exactly as #current does. */
+    #activeSiblings(parentUUID) {
+        const rows = new Map();
+        for (const row of this.#entitiesByParent.all(parentUUID)) {
+            rows.set(row.uuid, row);
+        }
+        for (const row of this.#rowsByParent.all(parentUUID)) {
+            rows.set(row.uuid, row);
+        }
+        return [...rows.values()].filter((row) => row.status === "active");
+    }
+    /** Rows are committed before a derived-address rename. After a crash, the
+     * row therefore names the destination while the same inode can still stand
+     * at the old sibling address. Recover that source without guessing by name. */
+    #physicalSiblingPath(parent, row) {
+        const matches = readdirSync(parent, { withFileTypes: true }).flatMap((entry) => {
+            const path = join(parent, entry.name);
+            const stats = tryLstat(path);
+            return stats && stats.dev === row.deviceNumber && stats.ino === row.inode ? [path] : [];
+        });
+        return matches.length === 1 ? matches[0] : null;
     }
     #current(entityId) {
         return this.#rowByUuid.get(entityId)