@amalgm/shell 0.1.141 → 0.1.143

package/dist/user-ground-host.js

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, realpathSync, readFileSync, readdirSync, readlin
 import { open, readFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { buildUserHomeManifest, buildUserManifest, liveMachineStateDir, scopedAmalgmDir, shippedUserHomeDeclaration, } from "@amalgm/core/identity";
-import { CHUNK_BYTES, CONTENT_CONTRACT, INLINE_CARGO_MAX_BYTES, ENTITY_CLOUD_CONTRACT, ENTITY_CLOUD_SCHEMA_VERSION, artifactForRecord, canonicalVersion, checkContentManifest, classifyDirectory, classifyFile, classifyRegisteredRoot, containedRecords, createLocalEntityRecord, createEntityRecordAuthorityPort, convergeUserGround, decodeAcceptedEntityRecord, deriveUploadManifest, createUserGroundEnrollmentPolicy, isRepositoryMetadataEntry, indexRepositoryTerritory, downloadAll as downloadAllArtifacts, encodeEntityRecord, EntityApplyRail, EntityRecordRail, membershipHash, pathIsSuspect, CONTENT_REFS_BATCH_OBJECTS, privateEntityResourceId, repositoryIdentityHash, sameRecords, snapshotFromRecords, stableJson, streamCargo, travelingRecords, upload as uploadArtifact, userGroundRecords, GRAPH_HEAD_OPERATION_KIND, } from "@amalgm/live";
+import { CHUNK_BYTES, CONTENT_CONTRACT, INLINE_CARGO_MAX_BYTES, ENTITY_CLOUD_CONTRACT, ENTITY_CLOUD_SCHEMA_VERSION, artifactForRecord, canonicalVersion, checkContentManifest, classifyDirectory, classifyFile, classifyRegisteredRoot, containedRecords, createLocalEntityRecord, createEntityRecordAuthorityPort, convergeUserGround, decodeAcceptedEntityRecord, deriveUploadManifest, createUserGroundEnrollmentPolicy, isRepositoryMetadataEntry, indexRepositoryTerritory, downloadAll as downloadAllArtifacts, encodeEntityRecord, EntityApplyRail, EntityRecordRail, membershipHash, materializedSlotNames, pathIsSuspect, CONTENT_REFS_BATCH_OBJECTS, privateEntityResourceId, repositoryIdentityHash, sameRecords, snapshotFromRecords, stableJson, streamCargo, travelingRecords, upload as uploadArtifact, userGroundRecords, GRAPH_HEAD_OPERATION_KIND, } from "@amalgm/live";
 import Database from "better-sqlite3";
 import { atomicCopy, atomicWrite, ensurePrivateDir, ensureUserDir } from "./filesystem.js";
 import { emitFilesStage, } from "./files-observability.js";
@@ -1095,6 +1095,7 @@ export class UserGroundHost {
                         measurements: { type: evidence.type, phase: evidence.phase },
                     });
                 },
+                onLawRelocationStage: this.options.onLawRelocationStage,
                 now: () => this.options.now?.().getTime() ?? Date.now(),
             });
             const settledMaterialization = host.adoptVerifiedMaterialization();
@@ -2345,6 +2346,11 @@ export class UserGroundHost {
         if (!committed) {
             throw pipelineStageError("detection", new DetectionBasisAdvancedError());
         }
+        settleMaterializedSlotAddresses(this.databasePath(identity), new Set([
+            ...notebookBasis.flatMap(({ row }) => row?.parentUUID ? [row.parentUUID] : []),
+            ...acceptedMaterializedRows.flatMap((row) => row.parentUUID ? [row.parentUUID] : []),
+            ...acceptedNotebookRows.flatMap((row) => row.parentUUID ? [row.parentUUID] : []),
+        ]));
         const recordCommitDuration = performance.now() - recordCommitStarted;
         if (detectedRecords.length === 0) {
             this.stage({
@@ -3783,6 +3789,80 @@ function commitDetectedState(file, input) {
         database.close();
     }
 }
+/** A local sibling-set change can alter collision-derived disk addresses
+ * without changing any portable record. Detect commits its portable truth
+ * first, then settles only the affected sibling groups while it still owns
+ * their ground cone. Rows move before bytes, matching Apply's recovery law;
+ * Watch observes the resulting renames as the same UUIDs at their newly
+ * derived addresses and therefore emits no Record. */
+function settleMaterializedSlotAddresses(file, parentUUIDs) {
+    if (parentUUIDs.size === 0)
+        return;
+    const entityRows = readGroundRows(file, "entities");
+    const notebookRows = readGroundRows(file, "detection_notebook");
+    const current = new Map(entityRows.map((row) => [row.uuid, row]));
+    for (const row of notebookRows)
+        current.set(row.uuid, row);
+    const relocations = [];
+    for (const parentUUID of parentUUIDs) {
+        const parent = current.get(parentUUID);
+        if (!parent)
+            continue;
+        const siblings = [...current.values()].filter((row) => row.parentUUID === parentUUID && row.status === "active");
+        const derived = materializedSlotNames(siblings);
+        for (const row of siblings) {
+            const name = derived.get(row.uuid) ?? row.name;
+            const destination = join(parent.absolutePath, name);
+            if (destination === row.absolutePath)
+                continue;
+            relocations.push({
+                row,
+                destination,
+                relativePath: [parent.relativePath, name].filter(Boolean).join("/"),
+            });
+        }
+    }
+    if (relocations.length === 0)
+        return;
+    const database = initializeDatabase(file);
+    try {
+        const update = (table) => database.prepare(`UPDATE ${table} SET relative_path = ?, absolute_path = ? WHERE uuid = ?`);
+        const updateEntity = update("entities");
+        const updateNotebook = update("detection_notebook");
+        const refreshEntity = database.prepare("UPDATE entities SET changed_time_ms = ? WHERE uuid = ?");
+        const refreshNotebook = database.prepare("UPDATE detection_notebook SET changed_time_ms = ? WHERE uuid = ?");
+        const pending = [...relocations];
+        while (pending.length > 0) {
+            const sources = new Set(pending.map(({ row }) => row.absolutePath));
+            const index = pending.findIndex(({ destination }) => !sources.has(destination) && !existsSync(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, destination, relativePath: destinationRelative } = relocation;
+            if (!existsSync(row.absolutePath))
+                continue;
+            const entityDescendants = entityRows.filter((candidate) => pathWithin(row.absolutePath, candidate.absolutePath));
+            const notebookDescendants = notebookRows.filter((candidate) => pathWithin(row.absolutePath, candidate.absolutePath));
+            database.transaction(() => {
+                for (const candidate of entityDescendants) {
+                    updateEntity.run(destinationRelative + candidate.relativePath.slice(row.relativePath.length), destination + candidate.absolutePath.slice(row.absolutePath.length), candidate.uuid);
+                }
+                for (const candidate of notebookDescendants) {
+                    updateNotebook.run(destinationRelative + candidate.relativePath.slice(row.relativePath.length), destination + candidate.absolutePath.slice(row.absolutePath.length), candidate.uuid);
+                }
+            })();
+            renameSync(row.absolutePath, destination);
+            const moved = lstatSync(destination);
+            refreshEntity.run(moved.ctimeMs, row.uuid);
+            refreshNotebook.run(moved.ctimeMs, row.uuid);
+        }
+    }
+    finally {
+        database.close();
+    }
+}
 /** Journal the newest snapshot publication for its resource. A journal row
  * has exactly three meanings: `pending` and never submitted — a local intent
  * the authority has never seen, superseded freely (last write wins);
@@ -4877,7 +4957,11 @@ async function reconcileRoot(input) {
                 ...(registeredBoundaryId ? { fixedUUID: registeredBoundaryId } : {}),
                 type,
                 parentUUID,
-                name: child.name,
+                // The row at this exact address owns its portable name. Collision
+                // suffixes are materialization only, so a complete walk freezes the
+                // pre-pass address-to-identity map instead of letting an earlier
+                // sibling deletion turn a later suffixed child into a fake rename.
+                name: existing?.name ?? child.name,
                 relativePath,
                 absolutePath,
                 payloadVersion,
@@ -5465,6 +5549,23 @@ async function reconcileRoot(input) {
 }
 function portablePaths(records, boundaryUUIDs = new Set()) {
     const byUuid = new Map(records.map((record) => [record.uuid, record]));
+    const siblingsByParent = new Map();
+    for (const record of records) {
+        if (record.status !== "active" || record.parentUUID === null)
+            continue;
+        const siblings = siblingsByParent.get(record.parentUUID) ?? [];
+        siblings.push(record);
+        siblingsByParent.set(record.parentUUID, siblings);
+    }
+    const derivedNames = new Map();
+    for (const siblings of siblingsByParent.values()) {
+        for (const [uuid, name] of materializedSlotNames(siblings.map((record) => ({
+            uuid: record.uuid,
+            name: record.name,
+            type: record.type,
+        }))))
+            derivedNames.set(uuid, name);
+    }
     const memo = new Map();
     const resolving = new Set();
     const resolve = (record) => {
@@ -5479,7 +5580,8 @@ function portablePaths(records, boundaryUUIDs = new Set()) {
             const parent = byUuid.get(record.parentUUID);
             if (!parent)
                 throw new Error(`cloud entity ${record.uuid} has no parent`);
-            path = [resolve(parent), record.name].filter(Boolean).join("/");
+            path = [resolve(parent), derivedNames.get(record.uuid) ?? record.name]
+                .filter(Boolean).join("/");
         }
         resolving.delete(record.uuid);
         memo.set(record.uuid, path);
@@ -5513,6 +5615,40 @@ function recordRootResolver(records) {
     };
     return rootOf;
 }
+/** Resolve the final root of every accepted tail result. A snapshot-membership
+ * lookup answers where an entity used to live; it cannot place a child whose
+ * parent was itself created or moved after the snapshot watermark. The
+ * complete accepted prefix is therefore the first ancestry source, with the
+ * snapshot used only when that prefix leaves an ancestor unchanged. */
+function acceptedResultRootResolver(accepted, snapshotMembership) {
+    const results = new Map(accepted.map((record) => [record.uuid, record]));
+    const memo = new Map();
+    const resolving = new Set();
+    const rootOf = (record) => {
+        const known = memo.get(record.uuid);
+        if (known !== undefined)
+            return known;
+        if (record.parentUUID === null) {
+            memo.set(record.uuid, record.uuid);
+            return record.uuid;
+        }
+        if (resolving.has(record.uuid)) {
+            throw new Error("accepted entity tail has a parent cycle");
+        }
+        resolving.add(record.uuid);
+        const changedParent = results.get(record.parentUUID);
+        const rootId = changedParent
+            ? rootOf(changedParent)
+            : snapshotMembership.get(record.parentUUID);
+        resolving.delete(record.uuid);
+        if (rootId === undefined) {
+            throw new Error(`accepted entity ${record.uuid} descends from no committed root`);
+        }
+        memo.set(record.uuid, rootId);
+        return rootId;
+    };
+    return rootOf;
+}
 /** The roots one publication rebuilds, each with its complete new records.
  *
  * A walked root is rebuilt from its ground alone: materialized ground is the
@@ -5542,13 +5678,17 @@ async function publicationRoots(graph, localRecords, accepted) {
     // asks: which root holds each accepted result, and which root still files
     // each record the walk re-rooted.
     const located = await graph.membership(new Set([
-        ...accepted.map((result) => result.uuid),
+        ...accepted.flatMap((result) => [
+            result.uuid,
+            ...(result.parentUUID === null ? [] : [result.parentUUID]),
+        ]),
         ...localRecords.map((record) => record.uuid),
     ]));
+    const acceptedRootOf = acceptedResultRootResolver(accepted, located);
     const overlays = new Map();
     for (const result of accepted) {
-        const rootId = located.get(result.uuid) ?? null;
-        if (rootId === null || walked.has(rootId))
+        const rootId = acceptedRootOf(result);
+        if (walked.has(rootId))
             continue;
         const overlay = overlays.get(rootId);
         if (overlay)
@@ -5556,15 +5696,6 @@ async function publicationRoots(graph, localRecords, accepted) {
         else
             overlays.set(rootId, [result]);
     }
-    for (const [rootId, results] of overlays) {
-        const byUuid = new Map((await graph.recordsFor(rootId))
-            .map((record) => [record.uuid, record]));
-        for (const result of results)
-            byUuid.set(result.uuid, result);
-        // Entity channels are independently ordered, so container membership is
-        // derived once from the final prefix rather than by arrival order.
-        rebuilt.set(rootId, recordsRetainingMissingEvidence([...byUuid.values()], []));
-    }
     // A records-shaped authority base carries no page identities, so it can
     // prove nothing about a root the commit leaves alone: the first head pages
     // the whole account at once, and never again.
@@ -5579,6 +5710,17 @@ async function publicationRoots(graph, localRecords, accepted) {
     // such root is rebuilt without them, and a root that keeps nothing is left
     // with no records at all — the rebuild then drops it from the graph.
     const vacated = new Map();
+    for (const result of accepted) {
+        const oldRoot = located.get(result.uuid) ?? null;
+        const newRoot = acceptedRootOf(result);
+        if (oldRoot === null || oldRoot === newRoot || walked.has(oldRoot))
+            continue;
+        const gone = vacated.get(oldRoot);
+        if (gone)
+            gone.add(result.uuid);
+        else
+            vacated.set(oldRoot, new Set([result.uuid]));
+    }
     for (const record of localRecords) {
         const rootId = located.get(record.uuid) ?? null;
         if (rootId === null || walked.has(rootId))
@@ -5589,9 +5731,18 @@ async function publicationRoots(graph, localRecords, accepted) {
         else
             vacated.set(rootId, new Set([record.uuid]));
     }
-    for (const [rootId, gone] of vacated) {
-        const held = rebuilt.get(rootId) ?? await graph.recordsFor(rootId);
-        rebuilt.set(rootId, held.filter((record) => !gone.has(record.uuid)));
+    const affectedRoots = new Set([...overlays.keys(), ...vacated.keys()]);
+    for (const rootId of affectedRoots) {
+        const byUuid = new Map((rebuilt.get(rootId) ?? await graph.recordsFor(rootId))
+            .map((record) => [record.uuid, record]));
+        for (const uuid of vacated.get(rootId) ?? [])
+            byUuid.delete(uuid);
+        for (const result of overlays.get(rootId) ?? [])
+            byUuid.set(result.uuid, result);
+        // Entity channels are independently ordered. Derive ancestry and
+        // container membership once from the complete final prefix, never from
+        // the order in which independent entity records arrived.
+        rebuilt.set(rootId, recordsRetainingMissingEvidence([...byUuid.values()], []));
     }
     return rebuilt;
 }