@amalgm/shell 0.1.54 → 0.1.56

package/dist/entity-apply-host.js

@@ -0,0 +1,661 @@
+/** Node filesystem, immutable-cache, Git, and Verify effects for Live Apply. */
+import { createHash } from "node:crypto";
+import { chmodSync, copyFileSync, existsSync, lstatSync, readFileSync, readlinkSync, renameSync, rmSync, symlinkSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { applyRepositoryIdentity, buildEntityApplyEffects, createUserGroundEnrollmentPolicy, indexRepositoryTerritory, repositoryIdentityHash, } from "@amalgm/live";
+import Database from "better-sqlite3";
+import { ensurePrivateDir } from "./filesystem.js";
+import { applyRepositoryFiles, captureRepository, hasGitMarker, inspectRepositoryTransportFile, } from "./git-repository-host.js";
+import { hashContentFile } from "./content-cache-host.js";
+import { projectMaterializedGraph } from "./materialized-graph.js";
+import { EntityApplySqliteStore } from "./entity-apply-store.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 sha256Hex = (input) => createHash("sha256").update(input).digest("hex");
+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 tryLstat = (path) => {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        throw error;
+    }
+};
+const exactRecord = (left, right) => left.uuid === right.uuid
+    && left.type === right.type
+    && left.parentUUID === right.parentUUID
+    && left.name === right.name
+    && left.status === right.status
+    && left.version === right.version
+    && left.payloadVersion === right.payloadVersion
+    && left.transportVersion === right.transportVersion;
+/** One persistent machine-effect owner for the Apply rail lifetime. */
+export class EntityApplyHost {
+    store;
+    effects;
+    #database;
+    #userRoot;
+    #cacheDir;
+    #bindingDir;
+    #readContent;
+    #acquireGround;
+    #rowByUuid;
+    #entityByUuid;
+    #rowsUnderRoot;
+    #prepared = new Map();
+    #groundReleases = new Map();
+    constructor(options) {
+        this.#database = new Database(options.databaseFile);
+        this.#userRoot = options.userRoot;
+        this.store = new EntityApplySqliteStore(this.#database, {
+            now: options.now,
+            onIntentFinished: (intent) => this.#releaseGround(intent),
+            isLocallyEligible: (target) => this.#isLocallyEligible(target),
+        });
+        this.#cacheDir = options.cacheDir;
+        this.#bindingDir = options.bindingDir;
+        this.#readContent = options.readContent;
+        this.#acquireGround = options.acquireGround;
+        this.#rowByUuid = this.#database.prepare(`${ROW_SELECT} WHERE uuid = ? LIMIT 1`);
+        this.#entityByUuid = this.#database.prepare(`
+      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 entities WHERE uuid = ? LIMIT 1
+    `);
+        this.#rowsUnderRoot = this.#database.prepare(`
+      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 entities WHERE root_uuid = ? ORDER BY relative_path
+    `);
+        const adapters = [
+            "workspace", "folder", "repo.git", "file.text", "file.binary", "link", "reference",
+        ].map((type) => this.#adapter(type));
+        this.effects = buildEntityApplyEffects(adapters, options.captureLocal);
+    }
+    close() {
+        for (const release of this.#groundReleases.values())
+            release();
+        this.#groundReleases.clear();
+        this.store.close();
+    }
+    #adapter(type) {
+        const apply = Object.freeze({
+            prepare: (intent, plan) => this.#prepare(intent, plan),
+            guard: (intent, plan) => this.#guard(intent, plan),
+            reveal: (intent, plan) => this.#reveal(intent, plan),
+            discard: (intent, plan) => this.#discard(intent, plan),
+        });
+        const verify = Object.freeze({
+            verify: (intent, plan) => this.#verify(intent, plan),
+        });
+        return Object.freeze({
+            name: `${type}-apply`,
+            types: Object.freeze({ [type]: `${type} truth is reread from its native filesystem representation` }),
+            rails: Object.freeze({ apply, verify }),
+        });
+    }
+    /** The portable Inbox contains cloud truth for every entity. Shell alone
+     * decides whether that accepted entity belongs on this machine. External
+     * selected roots are fully materialized; core-ground descendants obey the
+     * portable `.amalgmignore` policy before any Apply intent or disk write. */
+    #isLocallyEligible(target) {
+        const context = this.#context(target);
+        const boundary = context.current ?? context.parent;
+        if (!boundary)
+            return false;
+        const root = this.#current(boundary.rootUUID);
+        if (!root || root.absolutePath !== this.#userRoot)
+            return true;
+        const relativePath = relative(this.#userRoot, context.targetPath).split("\\").join("/");
+        if (!relativePath)
+            return true;
+        const ignore = join(this.#userRoot, ".amalgmignore");
+        const policy = createUserGroundEnrollmentPolicy(existsSync(ignore) ? readFileSync(ignore, "utf8") : "");
+        return policy(relativePath);
+    }
+    async #prepare(intent, plan) {
+        await this.#ensurePrepared(intent, plan);
+    }
+    async #ensurePrepared(intent, plan) {
+        const key = this.#key(intent);
+        const existing = this.#prepared.get(key);
+        if (existing)
+            return existing;
+        let prepared = {};
+        if (plan.kind === "file.text" || plan.kind === "file.binary" || plan.kind === "link") {
+            prepared = { artifact: await this.#readContent(plan.artifact) };
+        }
+        else if (plan.kind === "structure" && plan.repairArtifact) {
+            prepared = { artifact: await this.#readContent(plan.repairArtifact) };
+        }
+        else if (plan.kind === "repo.git") {
+            prepared = { repository: await this.#repositoryChain(plan.artifact) };
+        }
+        this.#prepared.set(key, prepared);
+        return prepared;
+    }
+    async #guard(intent, plan) {
+        await this.#holdGround(intent);
+        try {
+            const context = this.#context(plan.target);
+            const current = context.current;
+            if (current
+                && exactRecord(portable(current), plan.target)
+                && await this.#matches(plan.target, context.targetPath, plan, current)) {
+                return { kind: "already-target" };
+            }
+            // A rail transition can change an entity's registered payload witness
+            // without changing its bytes: clean repo leaves use Git object ids,
+            // while the ordinary file rail uses SHA-256. At the same durable UUID
+            // and address, exact target bytes prove that no write is required; Verify
+            // can advance the row directly. Equal bytes at a different address are
+            // deliberately not identity evidence.
+            if (current?.absolutePath === context.targetPath
+                && await this.#matches(plan.target, context.targetPath, plan)) {
+                return { kind: "already-target" };
+            }
+            if (!current) {
+                if (!tryLstat(context.targetPath)) {
+                    if (intent.phase === "declared")
+                        this.#releaseGround(intent);
+                    return { kind: "safe" };
+                }
+                const result = await this.#matches(plan.target, context.targetPath, plan)
+                    ? { kind: "already-target" }
+                    : { kind: "local-change" };
+                if (result.kind === "local-change")
+                    this.#releaseGround(intent);
+                return result;
+            }
+            // A move/rename may never erase a different thing already occupying the
+            // accepted destination. Detect must first give that ground identity.
+            if (current.absolutePath !== context.targetPath && tryLstat(context.targetPath)) {
+                this.#releaseGround(intent);
+                return { kind: "local-change" };
+            }
+            if (await this.#matches(portable(current), current.absolutePath, plan, current)) {
+                if (intent.phase === "declared")
+                    this.#releaseGround(intent);
+                return { kind: "safe" };
+            }
+            const displaced = this.#displacedPath(intent, context);
+            if (!tryLstat(current.absolutePath)
+                && tryLstat(displaced)
+                && await this.#matches(portable(current), displaced, plan, current)) {
+                if (intent.phase === "declared")
+                    this.#releaseGround(intent);
+                return { kind: "safe" };
+            }
+            this.#releaseGround(intent);
+            return { kind: "local-change" };
+        }
+        catch (error) {
+            this.#releaseGround(intent);
+            return { kind: "retry", reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async #reveal(intent, plan) {
+        try {
+            const context = this.#context(plan.target);
+            const prepared = await this.#ensurePrepared(intent, plan);
+            if (plan.kind === "lifecycle") {
+                this.#removeWithRecovery(intent, context);
+                return;
+            }
+            if (plan.kind === "repo.git") {
+                if (context.current && context.current.absolutePath !== context.targetPath) {
+                    this.#moveWithRecovery(intent, context.current.absolutePath, context.targetPath, context);
+                }
+                ensurePrivateDir(context.targetPath);
+                const repository = prepared.repository;
+                if (!repository)
+                    throw new Error("repository Apply has no prepared transport chain");
+                await applyRepositoryFiles(context.targetPath, repository.chain);
+                return;
+            }
+            if (plan.kind === "structure") {
+                if (context.current && context.current.absolutePath !== context.targetPath) {
+                    this.#moveWithRecovery(intent, context.current.absolutePath, context.targetPath, context);
+                }
+                else if (!tryLstat(context.targetPath)) {
+                    if (plan.target.type === "workspace" || plan.target.type === "folder") {
+                        ensurePrivateDir(context.targetPath);
+                    }
+                    else if (prepared.artifact) {
+                        this.#installArtifact(intent, context, plan.target, prepared.artifact);
+                    }
+                    else {
+                        throw new Error("structural leaf repair has no immutable artifact");
+                    }
+                }
+                if ((plan.target.type === "workspace" || plan.target.type === "folder")
+                    && hasGitMarker(context.targetPath)) {
+                    rmSync(join(context.targetPath, ".git"), { recursive: true, force: true });
+                }
+                return;
+            }
+            if (plan.kind === "reference") {
+                this.#installLink(intent, context, relative(dirname(context.targetPath), join(this.#bindingDir, plan.targetEntityId)));
+                return;
+            }
+            if (plan.kind === "link") {
+                this.#installLink(intent, context, plan.targetText);
+                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);
+        }
+        catch (error) {
+            this.#releaseGround(intent);
+            throw error;
+        }
+    }
+    async #verify(intent, plan) {
+        try {
+            const context = this.#context(plan.target);
+            if (await this.#restoreRacedLocal(intent, plan, context)) {
+                this.#releaseGround(intent);
+                return { kind: "local-change" };
+            }
+            if (!await this.#matches(plan.target, context.targetPath, plan)) {
+                this.#releaseGround(intent);
+                return { kind: "local-change" };
+            }
+            if (plan.target.type === "repo.git" && plan.target.status === "active") {
+                const repository = await this.#repositoryRows(intent, plan, context);
+                this.store.stageVerification(intent, repository.rows, repository.removals);
+            }
+            else {
+                this.store.stageVerification(intent, [this.#verifiedRow(plan.target, context)]);
+            }
+            return { kind: "match" };
+        }
+        catch (error) {
+            this.#releaseGround(intent);
+            return { kind: "retry", reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async #discard(intent, _plan) {
+        try {
+            this.#prepared.delete(this.#key(intent));
+            const current = this.#current(intent.entityId);
+            if (!current)
+                return;
+            rmSync(this.#controlDirectory(intent, {
+                current,
+                parent: current.parentUUID ? this.#current(current.parentUUID) : null,
+            }), { recursive: true, force: true });
+        }
+        catch (error) {
+            this.#releaseGround(intent);
+            throw error;
+        }
+    }
+    async #holdGround(intent) {
+        const key = this.#key(intent);
+        if (this.#groundReleases.has(key))
+            return;
+        this.#groundReleases.set(key, await this.#acquireGround());
+    }
+    #releaseGround(intent) {
+        const key = this.#key(intent);
+        const release = this.#groundReleases.get(key);
+        if (!release)
+            return;
+        this.#groundReleases.delete(key);
+        release();
+    }
+    /**
+     * A save can land after the final read guard but before the replacement
+     * syscall. Replacement keeps the displaced bytes private; Verify compares
+     * those bytes with the last notebook observation. A difference is restored
+     * so Live's ordinary Detect + Record capture path can make it durable.
+     */
+    async #restoreRacedLocal(intent, plan, context) {
+        const current = context.current;
+        if (!current)
+            return false;
+        const displaced = this.#displacedPath(intent, context);
+        if (!tryLstat(displaced))
+            return false;
+        if (await this.#matches(portable(current), displaced, plan, current))
+            return false;
+        const applied = join(this.#controlDirectory(intent, context), "applied");
+        rmSync(applied, { recursive: true, force: true });
+        if (tryLstat(context.targetPath))
+            renameSync(context.targetPath, applied);
+        ensurePrivateDir(dirname(current.absolutePath));
+        if (tryLstat(current.absolutePath))
+            rmSync(current.absolutePath, { recursive: true, force: true });
+        renameSync(displaced, current.absolutePath);
+        return true;
+    }
+    #installArtifact(intent, context, target, artifact) {
+        const control = this.#controlDirectory(intent, context);
+        ensurePrivateDir(control);
+        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);
+        this.#replacePrepared(intent, context, staged);
+    }
+    #installLink(intent, context, targetText) {
+        const control = this.#controlDirectory(intent, context);
+        ensurePrivateDir(control);
+        const staged = join(control, "prepared");
+        rmSync(staged, { recursive: true, force: true });
+        symlinkSync(targetText, staged);
+        this.#replacePrepared(intent, context, staged);
+    }
+    #replacePrepared(intent, context, staged) {
+        ensurePrivateDir(dirname(context.targetPath));
+        const displaced = this.#displacedPath(intent, context);
+        if (tryLstat(context.targetPath)) {
+            rmSync(displaced, { recursive: true, force: true });
+            renameSync(context.targetPath, displaced);
+        }
+        try {
+            renameSync(staged, context.targetPath);
+        }
+        catch (error) {
+            if (!tryLstat(context.targetPath) && tryLstat(displaced)) {
+                renameSync(displaced, context.targetPath);
+            }
+            throw error;
+        }
+    }
+    #moveWithRecovery(intent, source, destination, context) {
+        ensurePrivateDir(dirname(destination));
+        if (tryLstat(destination)) {
+            const displaced = this.#displacedPath(intent, context);
+            rmSync(displaced, { recursive: true, force: true });
+            renameSync(destination, displaced);
+        }
+        renameSync(source, destination);
+    }
+    #removeWithRecovery(intent, context) {
+        const source = context.current?.absolutePath ?? context.targetPath;
+        if (!tryLstat(source))
+            return;
+        const displaced = this.#displacedPath(intent, context);
+        rmSync(displaced, { recursive: true, force: true });
+        ensurePrivateDir(dirname(displaced));
+        renameSync(source, displaced);
+    }
+    async #matches(record, path, plan, stored) {
+        const stats = tryLstat(path);
+        if (record.status !== "active")
+            return stats === null;
+        if (!stats)
+            return false;
+        if (record.type === "file.text" || record.type === "file.binary") {
+            return stats.isFile() && !stats.isSymbolicLink()
+                && record.payloadVersion !== null
+                && await this.#hashFile(path) === record.payloadVersion;
+        }
+        if (record.type === "link") {
+            return stats.isSymbolicLink()
+                && record.payloadVersion !== null
+                && sha256Hex(Buffer.from(readlinkSync(path), "utf8")) === record.payloadVersion;
+        }
+        if (record.type === "reference") {
+            if (!stats.isSymbolicLink() || !record.payloadVersion)
+                return false;
+            return readlinkSync(path) === relative(dirname(path), join(this.#bindingDir, record.payloadVersion));
+        }
+        if (record.type === "repo.git") {
+            if (!stats.isDirectory() || !hasGitMarker(path)
+                || !record.payloadVersion || !record.transportVersion) {
+                return false;
+            }
+            const identity = plan.kind === "repo.git"
+                && (!stored || stored.transportVersion !== record.transportVersion)
+                ? (await this.#repositoryChain(plan.artifact)).identity
+                : this.#repositoryIdentity(stored ?? this.#current(record.uuid));
+            const file = join(this.#cacheDir, `${record.transportVersion}.bin`);
+            if (!existsSync(file))
+                return false;
+            const layout = inspectRepositoryTransportFile(file);
+            const prior = {
+                stateId: record.payloadVersion,
+                transportVersion: record.transportVersion,
+                card: layout.card,
+                identityHash: layout.identityHash,
+            };
+            const captured = captureRepository(path, identity, prior, identity);
+            return captured.bytes === null
+                && captured.stateId === record.payloadVersion
+                && captured.transportVersion === record.transportVersion;
+        }
+        if (!stats.isDirectory() || stats.isSymbolicLink())
+            return false;
+        if (hasGitMarker(path))
+            return false;
+        // Containers do not ship or overwrite a child list. Their physical Apply
+        // proof is only the accepted address/type/lifecycle result; independently
+        // ordered child UUIDs establish membership as they materialize.
+        return true;
+    }
+    #verifiedRow(target, context) {
+        const prior = context.current ?? context.parent;
+        if (!prior)
+            throw new Error(`entity ${target.uuid} has no local materialization boundary`);
+        const stats = tryLstat(context.targetPath);
+        if (target.status === "active" && !stats)
+            throw new Error(`entity ${target.uuid} vanished before Verify`);
+        const evidence = stats ?? prior;
+        return {
+            resourceId: prior.resourceId,
+            rootUUID: prior.rootUUID,
+            record: target,
+            relativePath: target.parentUUID === null
+                ? prior.relativePath
+                : [context.parent?.relativePath, target.name].filter(Boolean).join("/"),
+            absolutePath: context.targetPath,
+            deviceNumber: "dev" in evidence ? evidence.dev : evidence.deviceNumber,
+            inode: "ino" in evidence ? evidence.ino : evidence.inode,
+            byteSize: "size" in evidence ? evidence.size : evidence.byteSize,
+            modifiedTimeMs: "mtimeMs" in evidence ? evidence.mtimeMs : evidence.modifiedTimeMs,
+            changedTimeMs: "ctimeMs" in evidence ? evidence.ctimeMs : evidence.changedTimeMs,
+            filesystemMode: "mode" in evidence ? evidence.mode : evidence.filesystemMode,
+            contentVerifiedAtMs: ["file.text", "file.binary", "link", "reference"]
+                .includes(target.type) ? Date.now() : null,
+        };
+    }
+    async #repositoryRows(intent, plan, context) {
+        if (plan.kind !== "repo.git")
+            throw new Error("repository Verify received a non-repository plan");
+        const prepared = await this.#ensurePrepared(intent, plan);
+        const repository = prepared.repository;
+        if (!repository)
+            throw new Error("repository Verify has no transport identity");
+        const root = this.#verifiedRow(plan.target, context);
+        const existing = this.#rowsUnderRoot.all(root.rootUUID);
+        const repositoryPrefix = root.relativePath;
+        const identityByPath = new Map(repository.identity.map((entry) => [entry.path, entry]));
+        const nestedRepositoryPaths = repository.identity
+            .filter((entry) => entry.type === "repo.git")
+            .map((entry) => entry.path);
+        const localRepositoryPath = (row) => {
+            if (row.uuid === plan.target.uuid)
+                return "";
+            if (!repositoryPrefix)
+                return row.relativePath;
+            return row.relativePath.startsWith(`${repositoryPrefix}/`)
+                ? row.relativePath.slice(repositoryPrefix.length + 1)
+                : null;
+        };
+        const removals = existing.filter((row) => {
+            const path = localRepositoryPath(row);
+            if (path === null || path === "")
+                return false;
+            if (nestedRepositoryPaths.some((nested) => path.startsWith(`${nested}/`)))
+                return false;
+            return identityByPath.get(path)?.uuid !== row.uuid;
+        }).map((row) => row.uuid);
+        const removed = new Set(removals);
+        const base = existing.filter((row) => !removed.has(row.uuid)).map((row) => ({
+            record: row.uuid === plan.target.uuid ? plan.target : portable(row),
+            relativePath: row.uuid === plan.target.uuid ? root.relativePath : row.relativePath,
+            absolutePath: row.uuid === plan.target.uuid ? root.absolutePath : row.absolutePath,
+            deviceNumber: row.uuid === plan.target.uuid ? root.deviceNumber : row.deviceNumber,
+            inode: row.uuid === plan.target.uuid ? root.inode : row.inode,
+            byteSize: row.uuid === plan.target.uuid ? root.byteSize ?? 0 : row.byteSize ?? 0,
+            modifiedTimeMs: row.uuid === plan.target.uuid ? root.modifiedTimeMs ?? 0 : row.modifiedTimeMs ?? 0,
+            changedTimeMs: row.uuid === plan.target.uuid ? root.changedTimeMs ?? 0 : row.changedTimeMs ?? 0,
+            filesystemMode: row.uuid === plan.target.uuid ? root.filesystemMode ?? 0 : row.filesystemMode ?? 0,
+            contentVerifiedAtMs: row.uuid === plan.target.uuid
+                ? root.contentVerifiedAtMs : row.contentVerifiedAtMs,
+        }));
+        if (!base.some((row) => row.record.uuid === plan.target.uuid))
+            base.push({
+                record: root.record,
+                relativePath: root.relativePath,
+                absolutePath: root.absolutePath,
+                deviceNumber: root.deviceNumber,
+                inode: root.inode,
+                byteSize: root.byteSize ?? 0,
+                modifiedTimeMs: root.modifiedTimeMs ?? 0,
+                changedTimeMs: root.changedTimeMs ?? 0,
+                filesystemMode: root.filesystemMode ?? 0,
+                contentVerifiedAtMs: root.contentVerifiedAtMs,
+            });
+        const rows = projectMaterializedGraph(base, [{
+                record: plan.target,
+                identity: repository.identity,
+            }], sha256Hex).map((row) => ({
+            resourceId: root.resourceId,
+            rootUUID: root.rootUUID,
+            ...row,
+        }));
+        const projectedIdentity = indexRepositoryTerritory(rows.map((row) => ({
+            ...row,
+            uuid: row.record.uuid,
+            type: row.record.type,
+            parentUUID: row.record.parentUUID,
+        }))).ownedBy(plan.target.uuid)
+            .map((row) => ({
+            path: root.relativePath
+                ? row.relativePath.slice(root.relativePath.length + 1)
+                : row.relativePath,
+            uuid: row.record.uuid,
+            type: row.record.type,
+            payloadVersion: row.record.payloadVersion,
+        }))
+            .sort((left, right) => left.path.localeCompare(right.path));
+        if (repositoryIdentityHash(projectedIdentity, sha256Hex)
+            !== repositoryIdentityHash(repository.identity, sha256Hex)) {
+            throw new Error("repository Apply projection does not reproduce its transport identity map");
+        }
+        return { rows, removals };
+    }
+    async #repositoryChain(artifact) {
+        const reversed = [];
+        const versions = new Set();
+        let version = artifact.contentHash;
+        while (version) {
+            if (versions.has(version))
+                throw new Error("repository Apply transport chain has a cycle");
+            versions.add(version);
+            const local = await this.#readContent({ ...artifact, contentHash: version });
+            if (local.contentHash !== version)
+                throw new Error("repository Apply cache returned wrong transport");
+            reversed.push({ file: local.file, transportVersion: version });
+            version = inspectRepositoryTransportFile(local.file).parentTransportVersion;
+        }
+        const chain = reversed.reverse();
+        let identity = null;
+        for (const sealed of chain) {
+            identity = applyRepositoryIdentity(identity, inspectRepositoryTransportFile(sealed.file), sha256Hex);
+        }
+        return { chain, identity: identity ?? [] };
+    }
+    #repositoryIdentity(repository) {
+        if (!repository)
+            return [];
+        const rows = this.#rowsUnderRoot.all(repository.rootUUID);
+        return indexRepositoryTerritory(rows).ownedBy(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));
+    }
+    #context(target) {
+        const current = this.#current(target.uuid);
+        const parent = target.parentUUID ? this.#current(target.parentUUID) : null;
+        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 };
+    }
+    #current(entityId) {
+        return this.#rowByUuid.get(entityId)
+            ?? this.#entityByUuid.get(entityId)
+            ?? null;
+    }
+    #root(current) {
+        const root = this.#current(current.rootUUID);
+        if (!root)
+            throw new Error(`entity ${current.uuid} has no materialized root ${current.rootUUID}`);
+        return root;
+    }
+    #controlDirectory(intent, context) {
+        const anchor = context.current ?? context.parent;
+        if (!anchor)
+            throw new Error(`entity ${intent.entityId} has no Apply control root`);
+        return join(this.#root(anchor).absolutePath, ".amalgm", "apply", `${intent.entityId}-${intent.throughSequence}`);
+    }
+    #displacedPath(intent, context) {
+        return join(this.#controlDirectory(intent, context), "displaced");
+    }
+    #key(intent) {
+        return `${intent.entityId}:${intent.throughSequence}`;
+    }
+    async #hashFile(file) {
+        return hashContentFile(file);
+    }
+}
+//# sourceMappingURL=entity-apply-host.js.map