@amalgm/shell 0.1.142 → 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);