@amalgm/shell 0.1.55 → 0.1.57

package/dist/user-ground-host.js

@@ -3,11 +3,12 @@ import { existsSync, lstatSync, realpathSync, readFileSync, readdirSync, readlin
 import { open } 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, ENTITY_CLOUD_CONTRACT, ENTITY_CLOUD_SCHEMA_VERSION, artifactForRecord, canonicalVersion, checkContentManifest, classifyDirectory, classifyFile, classifyRegisteredRoot, createLocalEntityRecord, createEntityRecordAuthorityPort, convergeUserGround, createUserGroundEnrollmentPolicy, isRepositoryMetadataEntry, download as downloadArtifact, encodeEntityRecord, EntityApplyRail, EntityRecordRail, membershipHash, parseSnapshot, pathIsSuspect, privateEntityResourceId, sameRecords, snapshotFromRecords, stableJson, travelingRecords, upload as uploadArtifact, userGroundRecords, } from "@amalgm/live";
+import { CHUNK_BYTES, CONTENT_CONTRACT, ENTITY_CLOUD_CONTRACT, ENTITY_CLOUD_SCHEMA_VERSION, artifactForRecord, canonicalVersion, checkContentManifest, classifyDirectory, classifyFile, classifyRegisteredRoot, createLocalEntityRecord, createEntityRecordAuthorityPort, convergeUserGround, createUserGroundEnrollmentPolicy, isRepositoryMetadataEntry, indexRepositoryTerritory, download as downloadArtifact, encodeEntityRecord, EntityApplyRail, EntityRecordRail, membershipHash, parseSnapshot, pathIsSuspect, privateEntityResourceId, sameRecords, snapshotFromRecords, stableJson, travelingRecords, upload as uploadArtifact, userGroundRecords, } from "@amalgm/live";
 import Database from "better-sqlite3";
 import { atomicCopy, atomicWrite, ensurePrivateDir } from "./filesystem.js";
 import { EntityApplyHost } from "./entity-apply-host.js";
 import { EntityRecordSqliteStore } from "./entity-record-store.js";
+import { indexRowsByOutermostRoot } from "./ground-root-index.js";
 import { ContentCacheDownload, captureContentFile, hashContentFile, sealCapturedArtifact, } from "./content-cache-host.js";
 import { decodeContentWireBytes, encodeContentWireBytes } from "./content-wire-codec.js";
 import { exactTextReplay, planGroundDetection, reconcileGroundUUIDs, } from "./detection/portable.js";
@@ -1983,6 +1984,14 @@ async function reconcileGround(input) {
         ? notebook.filter((row) => materializedUUIDs.has(row.uuid))
         : materialized;
     const materializedByUuid = new Map(materializedBaseline.map((row) => [row.uuid, row]));
+    const materializedByRoot = new Map();
+    for (const row of materializedBaseline) {
+        if (row.resourceId !== resourceId)
+            continue;
+        const rows = materializedByRoot.get(row.rootUUID) || [];
+        rows.push(row);
+        materializedByRoot.set(row.rootUUID, rows);
+    }
     const ignoreFile = join(userRoot, ".amalgmignore");
     const policy = createUserGroundEnrollmentPolicy(existsSync(ignoreFile) ? readFileSync(ignoreFile, "utf8") : "");
     const bindingDir = workspaceBindingDir(userRoot, identity.deviceId);
@@ -1991,6 +2000,8 @@ async function reconcileGround(input) {
         .map(({ workspaceId, directory }) => [workspaceId, directory]));
     const outerBoundRoots = boundRootEntries.filter((candidate) => !boundRootEntries.some((other) => other.workspaceId !== candidate.workspaceId
         && pathWithin(other.directory, candidate.directory)));
+    const existingByUuid = new Map(existing.map((row) => [row.uuid, row]));
+    const existingByOutermostRoot = indexRowsByOutermostRoot(outerBoundRoots.map(({ workspaceId, directory }) => ({ rootId: workspaceId, directory })), existing.filter((row) => row.resourceId === resourceId));
     const registeredBoundaries = new Map(boundRootEntries
         .map(({ workspaceId, directory }) => [resolve(directory), workspaceId]));
     const suspicionFor = (root) => {
@@ -2029,7 +2040,7 @@ async function reconcileGround(input) {
             notebookByUuid.delete(uuid);
         }
         const currentIds = new Set(result.rows.map((row) => row.record.uuid));
-        for (const prior of materializedBaseline.filter((row) => row.resourceId === parameters.resourceId && row.rootUUID === parameters.rootUUID)) {
+        for (const prior of materializedByRoot.get(parameters.rootUUID) || []) {
             if (!currentIds.has(prior.uuid))
                 materializedRemovals.add(prior.uuid);
         }
@@ -2081,8 +2092,8 @@ async function reconcileGround(input) {
         suspicion: observationFor(userRoot),
     });
     for (const { workspaceId, directory: rootPath } of outerBoundRoots) {
-        const existingRoot = existing.find((row) => row.uuid === workspaceId);
-        const existingWorkspaceRows = existing.filter((row) => row.resourceId === resourceId && pathWithin(rootPath, row.absolutePath));
+        const existingRoot = existingByUuid.get(workspaceId);
+        const existingWorkspaceRows = existingByOutermostRoot.get(workspaceId) || [];
         await scan({
             identity,
             resourceId,
@@ -2446,20 +2457,20 @@ async function reconcileRoot(input) {
     // children first so one capture pass is already the fixed point.
     const repositories = entries.filter((entry) => entry.type === "repo.git")
         .sort((left, right) => right.relativePath.length - left.relativePath.length);
+    const territory = indexRepositoryTerritory(entries);
+    const previousEntries = [...existingByPath.values()];
+    const previousTerritory = indexRepositoryTerritory(previousEntries);
     const replayByUuid = new Map();
-    const properDescendantOf = (candidate, ancestor) => ancestor === "" ? candidate !== "" : candidate.startsWith(`${ancestor}/`);
-    const repositoryOwner = (entry) => repositories
-        .filter((repository) => repository.uuid !== entry.uuid
-        && properDescendantOf(entry.relativePath, repository.relativePath))
-        .sort((left, right) => right.relativePath.length - left.relativePath.length)[0] ?? null;
     try {
         for (const repository of repositories) {
-            let repoIdentity = entries
-                .filter((entry) => repositoryOwner(entry)?.uuid === repository.uuid)
+            const ownedEntries = territory.ownedBy(repository.uuid);
+            const repositoryPath = (entry) => repository.relativePath
+                ? entry.relativePath.slice(repository.relativePath.length + 1)
+                : entry.relativePath;
+            const ownedByPath = new Map(ownedEntries.map((entry) => [repositoryPath(entry), entry]));
+            let repoIdentity = ownedEntries
                 .map((entry) => ({
-                path: repository.relativePath
-                    ? entry.relativePath.slice(repository.relativePath.length + 1)
-                    : entry.relativePath,
+                path: repositoryPath(entry),
                 uuid: entry.uuid,
                 type: entry.type,
                 payloadVersion: entry.payloadVersion,
@@ -2497,15 +2508,8 @@ async function reconcileRoot(input) {
                     }
                 }
             }
-            const previousRepositories = [...existingByPath.values()]
-                .filter((row) => row.type === "repo.git");
-            const previousOwner = (row) => previousRepositories
-                .filter((candidate) => candidate.uuid !== row.uuid
-                && properDescendantOf(row.relativePath, candidate.relativePath))
-                .sort((left, right) => right.relativePath.length - left.relativePath.length)[0] ?? null;
             const previousIdentity = prior && priorRow
-                ? [...existingByPath.values()]
-                    .filter((row) => previousOwner(row)?.uuid === priorRow.uuid)
+                ? previousTerritory.ownedBy(priorRow.uuid)
                     .map((row) => ({
                     path: priorRow.relativePath
                         ? row.relativePath.slice(priorRow.relativePath.length + 1)
@@ -2532,10 +2536,7 @@ async function reconcileRoot(input) {
                 throw new Error(`repository did not settle during capture: ${repository.absolutePath}`);
             }
             for (const identityEntry of repoIdentity) {
-                const entry = entries.find((candidate) => repositoryOwner(candidate)?.uuid === repository.uuid
-                    && (repository.relativePath
-                        ? candidate.relativePath.slice(repository.relativePath.length + 1)
-                        : candidate.relativePath) === identityEntry.path);
+                const entry = ownedByPath.get(identityEntry.path);
                 if (!entry)
                     continue;
                 entry.type = identityEntry.type;
@@ -2625,7 +2626,7 @@ async function reconcileRoot(input) {
     const detected = rows.map((row) => {
         const base = beforeByUuid.get(row.record.uuid) ?? null;
         const entry = entryByUuid.get(row.record.uuid);
-        if (row.record.type !== "repo.git" && entry && repositoryOwner(entry)) {
+        if (row.record.type !== "repo.git" && entry && territory.ownerOf(entry)) {
             return {
                 record: row.record,
                 relativePath: row.relativePath,