@amalgm/shell 0.1.44 → 0.1.46

package/dist/detection/runtime.js

@@ -0,0 +1,919 @@
+/**
+ * The named Detect lane.
+ *
+ * A watcher path that still names enrolled, non-repository ground does not
+ * justify a workspace walk. This runtime holds one SQLite connection,
+ * resolves indexed paths, widens only to a named new folder's subtree, and
+ * commits exact Live proposals plus local truth in one transaction. Evidence
+ * it cannot prove is declined before mutation and goes to reconciliation in
+ * the owning host.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
+import { join, posix, resolve, sep } from "node:path";
+import { canonicalVersion, checkContentManifest, classifyFile, createUserGroundEnrollmentPolicy, detectedChangeProposal, membershipHash, } from "@amalgm/live";
+import Database from "better-sqlite3";
+import { captureContentFile, sealCapturedArtifact } from "../content-cache-host.js";
+import { captureRepository, hasGitMarker, inspectRepositoryTransportFile, } from "../git-repository-host.js";
+import { exactTextReplay } from "./portable.js";
+import { encodeMutationOperation } from "./journal-codec.js";
+const ROW_SELECT = `
+  SELECT resource_id AS resourceId, root_uuid AS rootUUID,
+         uuid, type, parent_uuid AS parentUUID, name, status, version,
+         payload_version AS payloadVersion, transport_version AS transportVersion,
+         relative_path AS relativePath, absolute_path AS absolutePath,
+         device_number AS deviceNumber, inode,
+         byte_size AS byteSize, modified_time_ms AS modifiedTimeMs,
+         changed_time_ms AS changedTimeMs, filesystem_mode AS filesystemMode,
+         content_verified_at_ms AS contentVerifiedAtMs
+    FROM detection_notebook`;
+const ROW_COLUMNS = [
+    "uuid", "resource_id", "root_uuid", "type", "parent_uuid", "name", "status", "version",
+    "payload_version", "transport_version", "relative_path", "absolute_path", "device_number",
+    "inode", "byte_size", "modified_time_ms", "changed_time_ms", "filesystem_mode",
+    "content_verified_at_ms",
+].join(", ");
+const rowValues = (row) => [
+    row.uuid, row.resourceId, row.rootUUID, row.type, row.parentUUID, row.name, row.status,
+    row.version, row.payloadVersion, row.transportVersion, row.relativePath, row.absolutePath,
+    row.deviceNumber, row.inode, row.byteSize, row.modifiedTimeMs, row.changedTimeMs,
+    row.filesystemMode, row.contentVerifiedAtMs,
+];
+const upsert = (database, table) => database.prepare(`
+    INSERT INTO ${table}(${ROW_COLUMNS})
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(uuid) DO UPDATE SET
+      resource_id = excluded.resource_id,
+      root_uuid = excluded.root_uuid,
+      type = excluded.type,
+      parent_uuid = excluded.parent_uuid,
+      name = excluded.name,
+      status = excluded.status,
+      version = excluded.version,
+      payload_version = excluded.payload_version,
+      transport_version = excluded.transport_version,
+      relative_path = excluded.relative_path,
+      absolute_path = excluded.absolute_path,
+      device_number = excluded.device_number,
+      inode = excluded.inode,
+      byte_size = excluded.byte_size,
+      modified_time_ms = excluded.modified_time_ms,
+      changed_time_ms = excluded.changed_time_ms,
+      filesystem_mode = excluded.filesystem_mode,
+      content_verified_at_ms = excluded.content_verified_at_ms
+  `);
+const portable = (row) => ({
+    uuid: row.uuid,
+    type: row.type,
+    parentUUID: row.parentUUID,
+    name: row.name,
+    status: row.status,
+    version: row.version,
+    payloadVersion: row.payloadVersion,
+    transportVersion: row.transportVersion,
+});
+const sha256Hex = (input) => createHash("sha256").update(input).digest("hex");
+const sameFingerprint = (row, stats) => row.deviceNumber === stats.dev
+    && row.inode === stats.ino
+    && row.byteSize === stats.size
+    && row.modifiedTimeMs === stats.mtimeMs
+    && row.changedTimeMs === stats.ctimeMs
+    && row.filesystemMode === stats.mode;
+const journalJson = encodeMutationOperation;
+/** One persistent, prepared Detect store. It owns no Watch or Send behavior. */
+export class NamedDetectRuntime {
+    database;
+    cacheDir;
+    userRoot;
+    rootAtDirectory;
+    rowAtPath;
+    rowAtUuid;
+    rowsUnderPath;
+    rowsAtPhysicalIdentity;
+    notebookChildren;
+    materializedByUuid;
+    materializedUnderPath;
+    writeEntity;
+    writeNotebook;
+    appendMutation;
+    removeEntity;
+    userPolicy;
+    constructor(databaseFile, cacheDir, userRoot) {
+        this.database = new Database(databaseFile);
+        this.database.pragma("journal_mode = WAL");
+        this.database.pragma("synchronous = FULL");
+        this.cacheDir = cacheDir;
+        this.userRoot = resolve(userRoot);
+        this.userPolicy = this.readUserPolicy();
+        this.rootAtDirectory = this.database.prepare(`${ROW_SELECT} WHERE absolute_path = ? AND relative_path = '' AND status = 'active' LIMIT 1`);
+        this.rowAtPath = this.database.prepare(`${ROW_SELECT} WHERE root_uuid = ? AND relative_path = ? AND status = 'active' LIMIT 1`);
+        this.rowAtUuid = this.database.prepare(`${ROW_SELECT} WHERE uuid = ? LIMIT 1`);
+        this.rowsUnderPath = this.database.prepare(`${ROW_SELECT}
+      WHERE root_uuid = ? AND status = 'active'
+        AND (? = '' OR relative_path = ?
+          OR substr(relative_path, 1, length(?) + 1) = ? || '/')
+      ORDER BY relative_path`);
+        this.rowsAtPhysicalIdentity = this.database.prepare(`${ROW_SELECT} WHERE device_number = ? AND inode = ? AND status = 'active' ORDER BY uuid`);
+        this.notebookChildren = this.database.prepare(`
+      SELECT uuid, name FROM detection_notebook
+       WHERE parent_uuid = ? AND status = 'active' ORDER BY name, uuid
+    `);
+        this.materializedByUuid = this.database.prepare("SELECT 1 AS present FROM entities WHERE uuid = ?");
+        this.materializedUnderPath = this.database.prepare(`
+      SELECT uuid FROM entities
+       WHERE root_uuid = ?
+         AND (relative_path = ? OR substr(relative_path, 1, length(?) + 1) = ? || '/')
+    `);
+        this.writeEntity = upsert(this.database, "entities");
+        this.writeNotebook = upsert(this.database, "detection_notebook");
+        this.appendMutation = this.database.prepare(`
+      INSERT INTO mutation_journal(
+        mutation_id, resource_id, operation_kind, operation_json, created_at
+      ) VALUES (?, ?, 'detected.change', ?, ?)
+    `);
+        this.removeEntity = this.database.prepare("DELETE FROM entities WHERE uuid = ?");
+    }
+    close() {
+        this.database.close();
+    }
+    refreshEnrollmentPolicy() {
+        this.userPolicy = this.readUserPolicy();
+    }
+    async detect(observations) {
+        if (observations.some(({ suspicion }) => suspicion.paths === null)) {
+            return { handled: false, evidence: [] };
+        }
+        const repository = await this.detectRepository(observations);
+        if (repository)
+            return repository;
+        const captured = [];
+        const materializedRemovals = new Set();
+        const membershipParents = new Set();
+        const evidence = [];
+        const prepared = [];
+        const moveSources = [];
+        let repositoryBoundary = false;
+        for (const observation of observations) {
+            const paths = observation.suspicion.paths;
+            if (paths.length === 0)
+                continue;
+            if (paths.some((path) => path === ".amalgmignore"
+                || path === ".git" || path.startsWith(".git/") || path.includes("/.git/")
+                || path.endsWith("/.git"))) {
+                return { handled: false, evidence: [] };
+            }
+            const root = this.rootAtDirectory.get(observation.directory);
+            if (!root)
+                return { handled: false, evidence: [] };
+            const started = performance.now();
+            const scopedPaths = paths.filter((path) => !paths.some((candidate) => candidate !== path && path.startsWith(`${candidate}/`)));
+            const policy = resolve(observation.directory) === this.userRoot
+                ? this.userPolicy
+                : () => true;
+            const entries = scopedPaths.filter(policy).map((path) => {
+                const exact = this.rowAtPath.get(root.rootUUID, path);
+                const absolutePath = join(observation.directory, ...path.split("/"));
+                const stats = tryLstat(absolutePath);
+                if (!stats && exact) {
+                    if (this.enclosedByRepository(exact)) {
+                        repositoryBoundary = true;
+                    }
+                    moveSources.push(absolutePath);
+                }
+                return { path, absolutePath, exact, stats };
+            });
+            if (repositoryBoundary)
+                return { handled: false, evidence: [] };
+            prepared.push({ observation, root, paths, policy, started, entries });
+        }
+        for (const item of prepared) {
+            const { observation, root, paths, policy, started, entries } = item;
+            let metadataReads = entries.length;
+            let contentReads = 0;
+            let journalBytes = 0;
+            const beforeCount = captured.length;
+            for (const { path, absolutePath, exact, stats } of entries) {
+                if (!stats) {
+                    if (!exact)
+                        continue;
+                    const removals = ["workspace", "folder"].includes(exact.type)
+                        ? this.materializedUnderPath.all(root.rootUUID, path, path, path)
+                        : [{ uuid: exact.uuid }];
+                    for (const row of removals)
+                        materializedRemovals.add(row.uuid);
+                    continue;
+                }
+                const portableParent = posix.dirname(path);
+                const parentPath = portableParent === "." ? "" : portableParent;
+                const parent = this.rowAtPath.get(root.rootUUID, parentPath);
+                if (!parent || !["workspace", "folder"].includes(parent.type)
+                    || this.enclosedByRepository(parent)) {
+                    return { handled: false, evidence: [] };
+                }
+                let scope;
+                if (stats.isFile()) {
+                    if (exact && !["file.text", "file.binary"].includes(exact.type)) {
+                        return { handled: false, evidence: [] };
+                    }
+                    const file = await this.captureFile({
+                        root, path, absolutePath, stats, parent, exact, moveSources,
+                    });
+                    scope = {
+                        items: file.item ? [file.item] : [],
+                        metadataReads: 1,
+                        contentReads: file.contentReads,
+                    };
+                }
+                else if (stats.isSymbolicLink()) {
+                    if (exact?.type === "reference"
+                        || (resolve(observation.directory) === this.userRoot
+                            && (path === "workspaces" || path.startsWith("workspaces/")))) {
+                        return { handled: false, evidence: [] };
+                    }
+                    const link = this.captureLink({
+                        root, path, absolutePath, stats, parent, exact, moveSources,
+                    });
+                    if (!link)
+                        return { handled: false, evidence: [] };
+                    scope = {
+                        items: link.item ? [link.item] : [],
+                        metadataReads: 1,
+                        contentReads: link.contentReads,
+                    };
+                }
+                else if (stats.isDirectory() && !stats.isSymbolicLink()) {
+                    const directory = await this.captureDirectory({
+                        root,
+                        path,
+                        absolutePath,
+                        stats,
+                        parent,
+                        policy,
+                        moveSources,
+                    });
+                    if (!directory)
+                        return { handled: false, evidence: [] };
+                    scope = directory;
+                }
+                else {
+                    return { handled: false, evidence: [] };
+                }
+                metadataReads += scope.metadataReads - 1;
+                contentReads += scope.contentReads;
+                for (const item of scope.items) {
+                    if (item.proposal)
+                        journalBytes += Buffer.byteLength(journalJson({ proposal: item.proposal }));
+                    captured.push(item);
+                    if (item.base === null
+                        || item.base.parentUUID !== item.result.parentUUID
+                        || item.base.name !== item.result.name) {
+                        if (item.base?.parentUUID)
+                            membershipParents.add(item.base.parentUUID);
+                        if (item.result.parentUUID)
+                            membershipParents.add(item.result.parentUUID);
+                    }
+                }
+            }
+            evidence.push({
+                directory: observation.directory,
+                paths: paths.length,
+                metadataReads,
+                contentReads,
+                gitInspections: 0,
+                repositoryCaptures: 0,
+                plannedRows: captured.length - beforeCount,
+                records: captured.slice(beforeCount).filter(({ proposal }) => proposal !== null).length,
+                journalBytes,
+                durationMs: performance.now() - started,
+            });
+        }
+        this.database.transaction(() => {
+            for (const uuid of materializedRemovals)
+                this.removeEntity.run(uuid);
+            for (const item of captured) {
+                this.writeEntity.run(...rowValues(item.result));
+                this.writeNotebook.run(...rowValues(item.result));
+                if (!item.proposal)
+                    continue;
+                const mutationId = randomUUID();
+                this.appendMutation.run(mutationId, item.proposal.resourceId, journalJson({ proposal: item.proposal }), new Date().toISOString());
+            }
+            for (const parentUUID of membershipParents) {
+                const base = this.rowAtUuid.get(parentUUID);
+                if (!base || !["workspace", "folder"].includes(base.type))
+                    continue;
+                const children = this.notebookChildren.all(parentUUID);
+                const payloadVersion = membershipHash(children, sha256Hex);
+                const version = canonicalVersion({
+                    type: base.type,
+                    parentUUID: base.parentUUID,
+                    name: base.name,
+                    status: base.status,
+                    payloadVersion,
+                }, sha256Hex);
+                if (version === base.version)
+                    continue;
+                const result = { ...base, payloadVersion, version };
+                this.writeEntity.run(...rowValues(result));
+                this.writeNotebook.run(...rowValues(result));
+                const proposal = detectedChangeProposal({
+                    base: portable(base),
+                    result: portable(result),
+                    replay: { kind: "structure" },
+                });
+                if (!proposal)
+                    continue;
+                this.appendMutation.run(randomUUID(), proposal.resourceId, journalJson({ proposal }), new Date().toISOString());
+            }
+        })();
+        return { handled: true, evidence };
+    }
+    /** A known leaf edit inside one repository is still named evidence. It
+     * updates that leaf's local identity proof, then records one nearest-repo
+     * Card + Checkpoint transition. Ambiguous structure and rail changes widen
+     * to reconciliation before this method mutates SQLite. */
+    async detectRepository(observations) {
+        const active = observations.filter(({ suspicion }) => suspicion.paths.length > 0);
+        if (active.length === 0)
+            return null;
+        let repository = null;
+        let directory = "";
+        const leafRows = new Map();
+        let metadataReads = 0;
+        let contentReads = 0;
+        const started = performance.now();
+        for (const observation of active) {
+            const root = this.rootAtDirectory.get(observation.directory);
+            if (!root)
+                return null;
+            const paths = observation.suspicion.paths
+                .filter((path) => !observation.suspicion.paths?.some((candidate) => candidate !== path && path.startsWith(`${candidate}/`)));
+            for (const path of paths) {
+                const owner = this.repositoryAtPath(root.rootUUID, path);
+                if (!owner || (repository && owner.uuid !== repository.uuid))
+                    return null;
+                repository = owner;
+                directory = observation.directory;
+                const marker = path.split("/").indexOf(".git");
+                if (marker >= 0) {
+                    // An established repository may report Card metadata. Index changes
+                    // can also imply worktree identity changes, so they widen.
+                    const insideMarker = path.split("/").slice(marker + 1).join("/");
+                    if (!hasGitMarker(owner.absolutePath)
+                        || insideMarker === "index" || insideMarker.startsWith("index/"))
+                        return null;
+                    metadataReads += 1;
+                    continue;
+                }
+                const exact = this.rowAtPath.get(root.rootUUID, path);
+                const stats = tryLstat(join(observation.directory, ...path.split("/")));
+                if (!exact || !stats || exact.uuid === owner.uuid
+                    || this.repositoryAtPath(root.rootUUID, exact.relativePath)?.uuid !== owner.uuid)
+                    return null;
+                metadataReads += 1;
+                if (stats.isFile() && ["file.text", "file.binary"].includes(exact.type)) {
+                    const captured = await captureContentFile(exact.absolutePath, stats, null);
+                    const type = classifyFile({ binary: captured.binary });
+                    const result = {
+                        ...exact,
+                        type,
+                        version: canonicalVersion({
+                            type,
+                            parentUUID: exact.parentUUID,
+                            name: exact.name,
+                            status: exact.status,
+                            payloadVersion: captured.contentHash,
+                        }, sha256Hex),
+                        payloadVersion: captured.contentHash,
+                        transportVersion: null,
+                        deviceNumber: stats.dev,
+                        inode: stats.ino,
+                        byteSize: stats.size,
+                        modifiedTimeMs: stats.mtimeMs,
+                        changedTimeMs: stats.ctimeMs,
+                        filesystemMode: stats.mode,
+                        contentVerifiedAtMs: Date.now(),
+                    };
+                    leafRows.set(result.uuid, result);
+                    contentReads += 1;
+                    continue;
+                }
+                if (stats.isSymbolicLink() && exact.type === "link") {
+                    const target = readlinkSync(exact.absolutePath);
+                    const payloadVersion = sha256Hex(Buffer.from(target, "utf8"));
+                    const result = {
+                        ...exact,
+                        version: canonicalVersion({
+                            type: "link",
+                            parentUUID: exact.parentUUID,
+                            name: exact.name,
+                            status: exact.status,
+                            payloadVersion,
+                        }, sha256Hex),
+                        payloadVersion,
+                        deviceNumber: stats.dev,
+                        inode: stats.ino,
+                        byteSize: stats.size,
+                        modifiedTimeMs: stats.mtimeMs,
+                        changedTimeMs: stats.ctimeMs,
+                        filesystemMode: stats.mode,
+                        contentVerifiedAtMs: Date.now(),
+                    };
+                    leafRows.set(result.uuid, result);
+                    contentReads += 1;
+                    continue;
+                }
+                return null;
+            }
+        }
+        if (!repository || !directory)
+            return null;
+        const priorRows = this.rowsUnderPath.all(repository.rootUUID, repository.relativePath, repository.relativePath, repository.relativePath, repository.relativePath);
+        const currentRows = priorRows.map((row) => leafRows.get(row.uuid) ?? row);
+        const previousIdentity = repositoryIdentity(repository, priorRows);
+        const identity = repositoryIdentity(repository, currentRows);
+        let prior = null;
+        let priorLayout = null;
+        if (repository.payloadVersion && repository.transportVersion) {
+            const priorFile = join(this.cacheDir, `${repository.transportVersion}.bin`);
+            if (existsSync(priorFile)) {
+                try {
+                    const layout = inspectRepositoryTransportFile(priorFile);
+                    if (layout.stateId === repository.payloadVersion) {
+                        priorLayout = layout;
+                        prior = {
+                            stateId: repository.payloadVersion,
+                            transportVersion: repository.transportVersion,
+                            card: layout.card,
+                            identityHash: layout.identityHash,
+                        };
+                    }
+                }
+                catch {
+                    prior = null;
+                    priorLayout = null;
+                }
+            }
+        }
+        const captured = captureRepository(repository.absolutePath, identity, prior, prior ? previousIdentity : null);
+        if (captured.bytes) {
+            sealCapturedArtifact(this.cacheDir, {
+                entityId: repository.uuid,
+                entityType: "repo.git",
+                kind: "git",
+                contentHash: captured.transportVersion,
+            }, captured.bytes);
+        }
+        const layout = inspectRepositoryTransportFile(join(this.cacheDir, `${captured.transportVersion}.bin`));
+        const stats = lstatSync(repository.absolutePath);
+        const result = {
+            ...repository,
+            version: canonicalVersion({
+                type: "repo.git",
+                parentUUID: repository.parentUUID,
+                name: repository.name,
+                status: repository.status,
+                payloadVersion: captured.stateId,
+            }, sha256Hex),
+            payloadVersion: captured.stateId,
+            transportVersion: captured.transportVersion,
+            deviceNumber: stats.dev,
+            inode: stats.ino,
+            byteSize: stats.size,
+            modifiedTimeMs: stats.mtimeMs,
+            changedTimeMs: stats.ctimeMs,
+            filesystemMode: stats.mode,
+        };
+        const proposal = detectedChangeProposal({
+            base: portable(repository),
+            result: portable(result),
+            replay: {
+                kind: "repo.git",
+                stateId: layout.stateId,
+                cardId: layout.cardId,
+                checkpointId: layout.checkpointId,
+                cardChanged: priorLayout?.cardId !== layout.cardId,
+                checkpointChanged: priorLayout?.checkpointId !== layout.checkpointId,
+                parentTransportVersion: layout.parentTransportVersion,
+                transportVersion: captured.transportVersion,
+            },
+        });
+        const journalBytes = proposal
+            ? Buffer.byteLength(journalJson({ proposal }))
+            : 0;
+        this.database.transaction(() => {
+            for (const row of leafRows.values()) {
+                this.writeEntity.run(...rowValues(row));
+                this.writeNotebook.run(...rowValues(row));
+            }
+            this.writeEntity.run(...rowValues(result));
+            this.writeNotebook.run(...rowValues(result));
+            if (proposal) {
+                this.appendMutation.run(randomUUID(), proposal.resourceId, journalJson({ proposal }), new Date().toISOString());
+            }
+        })();
+        return {
+            handled: true,
+            evidence: [{
+                    directory,
+                    paths: active.reduce((count, item) => count + item.suspicion.paths.length, 0),
+                    metadataReads,
+                    contentReads,
+                    gitInspections: 1,
+                    repositoryCaptures: 1,
+                    plannedRows: 1,
+                    records: proposal ? 1 : 0,
+                    journalBytes,
+                    durationMs: performance.now() - started,
+                }],
+        };
+    }
+    repositoryAtPath(rootUUID, path) {
+        const segments = path.split("/");
+        const marker = segments.indexOf(".git");
+        if (marker >= 0) {
+            const candidate = segments.slice(0, marker).join("/");
+            const row = this.rowAtPath.get(rootUUID, candidate);
+            return row?.type === "repo.git" ? row : null;
+        }
+        let candidate = path;
+        while (true) {
+            const row = this.rowAtPath.get(rootUUID, candidate);
+            if (row?.type === "repo.git")
+                return row;
+            if (candidate === "")
+                return null;
+            const parent = posix.dirname(candidate);
+            candidate = parent === "." ? "" : parent;
+        }
+    }
+    async captureFile(input) {
+        const { root, path, absolutePath, stats, parent, exact, moveSources } = input;
+        const base = exact ?? this.uniqueMovedBase(stats.dev, stats.ino, absolutePath, moveSources);
+        const fingerprintTrusted = base !== null
+            && base.relativePath === path
+            && this.materializedByUuid.get(base.uuid) !== undefined
+            && sameFingerprint(base, stats)
+            && base.contentVerifiedAtMs !== null
+            && stats.mtimeMs < base.contentVerifiedAtMs;
+        if (fingerprintTrusted)
+            return { item: null, contentReads: 0 };
+        const canReuseMovedContent = base !== null
+            && base.relativePath !== path
+            && base.deviceNumber === stats.dev
+            && base.inode === stats.ino
+            && base.byteSize === stats.size
+            && base.modifiedTimeMs === stats.mtimeMs
+            && base.filesystemMode === stats.mode
+            && base.payloadVersion !== null;
+        const content = canReuseMovedContent ? null : await captureContentFile(absolutePath, stats, this.cacheDir);
+        const type = content ? classifyFile({ binary: content.binary }) : base?.type;
+        const payloadVersion = content?.contentHash ?? base?.payloadVersion ?? null;
+        if (!type || !["file.text", "file.binary"].includes(type) || !payloadVersion) {
+            throw new Error(`named Detect could not capture ${path}`);
+        }
+        const result = {
+            resourceId: root.resourceId,
+            rootUUID: root.rootUUID,
+            uuid: base?.uuid ?? randomUUID(),
+            type,
+            parentUUID: parent.uuid,
+            name: posix.basename(path),
+            status: "active",
+            version: canonicalVersion({
+                type,
+                parentUUID: parent.uuid,
+                name: posix.basename(path),
+                status: "active",
+                payloadVersion,
+            }, sha256Hex),
+            payloadVersion,
+            transportVersion: null,
+            relativePath: path,
+            absolutePath,
+            deviceNumber: stats.dev,
+            inode: stats.ino,
+            byteSize: stats.size,
+            modifiedTimeMs: stats.mtimeMs,
+            changedTimeMs: stats.ctimeMs,
+            filesystemMode: stats.mode,
+            contentVerifiedAtMs: content ? Date.now() : base?.contentVerifiedAtMs ?? null,
+        };
+        const replay = base !== null
+            && base.type === result.type
+            && base.payloadVersion === result.payloadVersion
+            && base.transportVersion === result.transportVersion
+            ? { kind: "structure" }
+            : this.replayFor(base, result);
+        return {
+            item: {
+                base,
+                result,
+                proposal: detectedChangeProposal({
+                    base: base ? portable(base) : null,
+                    result: portable(result),
+                    replay,
+                }),
+            },
+            contentReads: content ? 1 : 0,
+        };
+    }
+    async captureDirectory(input) {
+        if (existsSync(join(input.absolutePath, ".git")))
+            return null;
+        const exact = this.rowAtPath.get(input.root.rootUUID, input.path);
+        if (exact && !["workspace", "folder"].includes(exact.type))
+            return null;
+        const base = exact ?? this.uniqueMovedBase(input.stats.dev, input.stats.ino, input.absolutePath, input.moveSources);
+        if (base && !["workspace", "folder"].includes(base.type))
+            return null;
+        const uuid = base?.uuid ?? randomUUID();
+        const childItems = [];
+        let metadataReads = 1;
+        let contentReads = 0;
+        const children = [];
+        for (const child of readdirSync(input.absolutePath, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            const path = `${input.path}/${child.name}`;
+            if (!input.policy(path))
+                continue;
+            const absolutePath = join(input.absolutePath, child.name);
+            const stats = lstatSync(absolutePath);
+            metadataReads += 1;
+            const parentRow = {
+                resourceId: input.root.resourceId,
+                rootUUID: input.root.rootUUID,
+                uuid,
+                type: "folder",
+                parentUUID: input.parent.uuid,
+                name: posix.basename(input.path),
+                status: "active",
+                version: "0".repeat(64),
+                payloadVersion: null,
+                transportVersion: null,
+                relativePath: input.path,
+                absolutePath: input.absolutePath,
+                deviceNumber: input.stats.dev,
+                inode: input.stats.ino,
+                byteSize: input.stats.size,
+                modifiedTimeMs: input.stats.mtimeMs,
+                changedTimeMs: input.stats.ctimeMs,
+                filesystemMode: input.stats.mode,
+                contentVerifiedAtMs: null,
+            };
+            if (stats.isSymbolicLink()) {
+                const link = this.captureLink({
+                    root: input.root,
+                    path,
+                    absolutePath,
+                    stats,
+                    parent: parentRow,
+                    exact: this.rowAtPath.get(input.root.rootUUID, path),
+                    moveSources: input.moveSources,
+                });
+                if (!link)
+                    return null;
+                const identity = link.item?.result
+                    ?? this.rowAtPath.get(input.root.rootUUID, path);
+                if (!identity)
+                    throw new Error(`captured link ${path} has no identity`);
+                children.push({ uuid: identity.uuid, name: child.name });
+                if (link.item)
+                    childItems.push(link.item);
+                contentReads += link.contentReads;
+            }
+            else if (stats.isDirectory()) {
+                const nested = await this.captureDirectory({
+                    root: input.root,
+                    path,
+                    absolutePath,
+                    stats,
+                    parent: parentRow,
+                    policy: input.policy,
+                    moveSources: input.moveSources,
+                });
+                if (!nested)
+                    return null;
+                const nestedRoot = nested.items[0];
+                if (!nestedRoot)
+                    throw new Error(`captured directory ${path} has no root`);
+                children.push({ uuid: nestedRoot.result.uuid, name: child.name });
+                childItems.push(...nested.items);
+                metadataReads += nested.metadataReads - 1;
+                contentReads += nested.contentReads;
+            }
+            else if (stats.isFile()) {
+                const file = await this.captureFile({
+                    root: input.root,
+                    path,
+                    absolutePath,
+                    stats,
+                    parent: parentRow,
+                    exact: this.rowAtPath.get(input.root.rootUUID, path),
+                    moveSources: input.moveSources,
+                });
+                const identity = file.item?.result
+                    ?? this.rowAtPath.get(input.root.rootUUID, path);
+                if (!identity)
+                    throw new Error(`captured file ${path} has no identity`);
+                children.push({ uuid: identity.uuid, name: child.name });
+                if (file.item)
+                    childItems.push(file.item);
+                contentReads += file.contentReads;
+            }
+        }
+        const result = {
+            resourceId: input.root.resourceId,
+            rootUUID: input.root.rootUUID,
+            uuid,
+            type: "folder",
+            parentUUID: input.parent.uuid,
+            name: posix.basename(input.path),
+            status: "active",
+            version: canonicalVersion({
+                type: "folder",
+                parentUUID: input.parent.uuid,
+                name: posix.basename(input.path),
+                status: "active",
+                payloadVersion: membershipHash(children, sha256Hex),
+            }, sha256Hex),
+            payloadVersion: null,
+            transportVersion: null,
+            relativePath: input.path,
+            absolutePath: input.absolutePath,
+            deviceNumber: input.stats.dev,
+            inode: input.stats.ino,
+            byteSize: input.stats.size,
+            modifiedTimeMs: input.stats.mtimeMs,
+            changedTimeMs: input.stats.ctimeMs,
+            filesystemMode: input.stats.mode,
+            contentVerifiedAtMs: null,
+        };
+        const proposal = detectedChangeProposal({
+            base: base ? portable(base) : null,
+            result: portable(result),
+            replay: { kind: "structure" },
+        });
+        return {
+            items: [{ base, result, proposal }, ...childItems],
+            metadataReads,
+            contentReads,
+        };
+    }
+    captureLink(input) {
+        const { root, path, absolutePath, stats, parent, exact, moveSources } = input;
+        const base = exact ?? this.uniqueMovedBase(stats.dev, stats.ino, absolutePath, moveSources);
+        if (base && base.type !== "link")
+            return null;
+        const fingerprintTrusted = base !== null
+            && base.relativePath === path
+            && this.materializedByUuid.get(base.uuid) !== undefined
+            && sameFingerprint(base, stats)
+            && base.contentVerifiedAtMs !== null
+            && stats.mtimeMs < base.contentVerifiedAtMs;
+        if (fingerprintTrusted)
+            return { item: null, contentReads: 0 };
+        const canReuseMovedTarget = base !== null
+            && base.relativePath !== path
+            && base.deviceNumber === stats.dev
+            && base.inode === stats.ino
+            && base.byteSize === stats.size
+            && base.modifiedTimeMs === stats.mtimeMs
+            && base.filesystemMode === stats.mode
+            && base.payloadVersion !== null;
+        const target = canReuseMovedTarget ? null : readlinkSync(absolutePath);
+        const payloadVersion = target === null
+            ? base?.payloadVersion ?? null
+            : sha256Hex(Buffer.from(target, "utf8"));
+        if (!payloadVersion)
+            return null;
+        const result = {
+            resourceId: root.resourceId,
+            rootUUID: root.rootUUID,
+            uuid: base?.uuid ?? randomUUID(),
+            type: "link",
+            parentUUID: parent.uuid,
+            name: posix.basename(path),
+            status: "active",
+            version: canonicalVersion({
+                type: "link",
+                parentUUID: parent.uuid,
+                name: posix.basename(path),
+                status: "active",
+                payloadVersion,
+            }, sha256Hex),
+            payloadVersion,
+            transportVersion: null,
+            relativePath: path,
+            absolutePath,
+            deviceNumber: stats.dev,
+            inode: stats.ino,
+            byteSize: stats.size,
+            modifiedTimeMs: stats.mtimeMs,
+            changedTimeMs: stats.ctimeMs,
+            filesystemMode: stats.mode,
+            contentVerifiedAtMs: target === null ? base?.contentVerifiedAtMs ?? null : Date.now(),
+        };
+        const replay = base !== null && base.payloadVersion === result.payloadVersion
+            ? { kind: "structure" }
+            : target === null ? { kind: "structure" } : {
+                kind: "link",
+                resultPayloadVersion: payloadVersion,
+                target,
+            };
+        return {
+            item: {
+                base,
+                result,
+                proposal: detectedChangeProposal({
+                    base: base ? portable(base) : null,
+                    result: portable(result),
+                    replay,
+                }),
+            },
+            contentReads: target === null ? 0 : 1,
+        };
+    }
+    enclosedByRepository(row) {
+        let cursor = row;
+        const seen = new Set();
+        while (cursor.parentUUID !== null) {
+            if (seen.has(cursor.uuid))
+                throw new Error("Detect notebook has a parent cycle");
+            seen.add(cursor.uuid);
+            const parent = this.rowAtUuid.get(cursor.parentUUID);
+            if (!parent)
+                throw new Error(`Detect notebook has no parent ${cursor.parentUUID}`);
+            if (parent.type === "repo.git")
+                return true;
+            cursor = parent;
+        }
+        return false;
+    }
+    readUserPolicy() {
+        const ignore = join(this.userRoot, ".amalgmignore");
+        return createUserGroundEnrollmentPolicy(existsSync(ignore) ? readFileSync(ignore, "utf8") : "");
+    }
+    uniqueMovedBase(deviceNumber, inode, absolutePath, moveSources) {
+        const candidates = this.rowsAtPhysicalIdentity.all(deviceNumber, inode)
+            .filter((row) => row.absolutePath !== absolutePath
+            && moveSources.some((source) => row.absolutePath === source || row.absolutePath.startsWith(`${source}${sep}`))
+            && !existsSync(row.absolutePath));
+        return candidates.length === 1 ? candidates[0] : null;
+    }
+    replayFor(base, result) {
+        if (result.type === "file.text") {
+            const resultBytes = readFileSync(join(this.cacheDir, `${result.payloadVersion}.bin`));
+            const baseFile = base?.payloadVersion ? join(this.cacheDir, `${base.payloadVersion}.bin`) : null;
+            const baseBytes = baseFile && existsSync(baseFile) ? readFileSync(baseFile) : null;
+            return exactTextReplay({
+                entityId: result.uuid,
+                basePayloadVersion: base?.payloadVersion ?? null,
+                baseBytes,
+                resultPayloadVersion: result.payloadVersion,
+                resultBytes,
+                sha256Hex,
+            });
+        }
+        const manifestFile = join(this.cacheDir, "manifests", `${result.payloadVersion}.json`);
+        const checked = checkContentManifest(JSON.parse(readFileSync(manifestFile, "utf8")), result.payloadVersion);
+        if (!checked.ok)
+            throw new Error(checked.error);
+        return {
+            kind: "file.binary",
+            resultPayloadVersion: result.payloadVersion,
+            manifest: checked.value,
+        };
+    }
+}
+function tryLstat(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        throw error;
+    }
+}
+function repositoryIdentity(repository, rows) {
+    const repositories = rows.filter((row) => row.type === "repo.git");
+    const ownerOf = (row) => repositories
+        .filter((candidate) => candidate.uuid !== row.uuid
+        && (candidate.relativePath === ""
+            || row.relativePath.startsWith(`${candidate.relativePath}/`)))
+        .sort((left, right) => right.relativePath.length - left.relativePath.length)[0] ?? null;
+    return rows
+        .filter((row) => row.uuid !== repository.uuid && ownerOf(row)?.uuid === repository.uuid)
+        .map((row) => ({
+        path: repository.relativePath
+            ? row.relativePath.slice(repository.relativePath.length + 1)
+            : row.relativePath,
+        uuid: row.uuid,
+        type: row.type,
+        payloadVersion: row.payloadVersion,
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+//# sourceMappingURL=runtime.js.map