@younndai/lyt 0.13.5 → 0.20.0

package/dist/install/reconcile-engine.js

@@ -0,0 +1,771 @@
+/*
+ * Copyright 2026 MARLINK TRADING SRL (YounndAI)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, renameSync, symlinkSync, writeFileSync, } from "node:fs";
+import { homedir, platform } from "node:os";
+import { basename, dirname, join, parse, relative, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { composeManagedManualMarker, newUuidv7Bytes, openReceiptAttempt, parseReceiptV1ForEmission, reopenReceiptAttempt, uuid7BytesToDashedString, } from "@younndai/lyt-vault";
+import { canonicalJson, digestCanonical, UPDATE_PLAN_PACKAGES } from "./update-plan.js";
+export function defaultReconcileJournalRoot(homeDir = homedir()) {
+    return join(homeDir, "lyt", ".install-reconcile");
+}
+export function buildInstallReconcileFailureEnvelopeV1(error, options = {}) {
+    const journalRoot = resolve(options.journalRoot ?? defaultReconcileJournalRoot());
+    const payload = {
+        schema_id: "lyt.install-reconcile-plan",
+        schema_version: { major: 1, minor: 0 },
+        journal_root: journalRoot,
+        objects: Object.freeze([]),
+    };
+    const planDigest = digestCanonical(payload);
+    const plan = Object.freeze({
+        ...payload,
+        operation_id: digestToUuidV7(planDigest),
+        plan_digest: planDigest,
+    });
+    const now = options.now?.() ?? new Date();
+    return envelopeFromState({
+        plan,
+        attemptId: options.newAttemptId?.() ?? uuid7BytesToDashedString(newUuidv7Bytes()),
+        startedAt: now.toISOString(),
+        finishedAt: now.toISOString(),
+        disposition: "new",
+        completed: [],
+        pending: [],
+        refused: [],
+        mutations: 0,
+        dryRun: false,
+        failure: error instanceof Error ? error.message : "install-reconcile-failed",
+        nextActionOverride: "lyt doctor --json",
+    });
+}
+export function readPackageVersion(packageName) {
+    const require = createRequire(import.meta.url);
+    const packageJsonPath = (require.resolve.paths(packageName) ?? [])
+        .map((base) => join(base, ...packageName.split("/"), "package.json"))
+        .find((candidate) => existsSync(candidate));
+    if (packageJsonPath === undefined)
+        throw new Error("install-provider-package-root-not-found");
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (typeof parsed.version !== "string")
+        throw new Error("install-provider-invalid-version");
+    return parsed.version;
+}
+export function prepareInstallReconcilePlanV1(providers, options = {}) {
+    assertProviderSet(providers);
+    const journalRoot = resolve(options.journalRoot ?? defaultReconcileJournalRoot());
+    assertPathChainHasNoLinks(journalRoot, true);
+    const objects = providers
+        .flatMap((provider) => provider.objects)
+        .map((object) => inspectProviderObject(object))
+        .sort((a, b) => a.object_id.localeCompare(b.object_id));
+    const ids = objects.map((object) => object.object_id);
+    if (new Set(ids).size !== ids.length)
+        throw new Error("install-provider-duplicate-object");
+    const payload = {
+        schema_id: "lyt.install-reconcile-plan",
+        schema_version: { major: 1, minor: 0 },
+        journal_root: journalRoot,
+        objects,
+    };
+    const planDigest = digestCanonical(payload);
+    const operationId = digestToUuidV7(planDigest);
+    return Object.freeze({ ...payload, operation_id: operationId, plan_digest: planDigest });
+}
+export async function reconcileInstallProvidersV1(providers, input = { apply: false }, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const newAttemptId = options.newAttemptId ?? (() => uuid7BytesToDashedString(newUuidv7Bytes()));
+    const journalRoot = resolve(options.journalRoot ?? defaultReconcileJournalRoot());
+    const freshPlan = prepareInstallReconcilePlanV1(providers, { journalRoot });
+    let journal;
+    let plan;
+    if (input.resumeOperationId !== undefined) {
+        if (!input.apply)
+            throw new Error("install-reconcile-resume-requires-apply");
+        journal = readJournal(journalRoot, input.resumeOperationId);
+        plan = journal.plan;
+        journal = recoverAppliedObjects(plan, freshPlan, journal);
+        assertResumeEnvironment(plan, freshPlan, journal);
+    }
+    else {
+        plan = freshPlan;
+        journal = newJournal(plan);
+    }
+    const attemptId = journal.active_attempt_id ?? newAttemptId();
+    const startedAt = journal.active_started_at ?? now().toISOString();
+    if (!input.apply) {
+        return envelopeFromState({
+            plan,
+            attemptId,
+            startedAt,
+            finishedAt: now().toISOString(),
+            disposition: "new",
+            completed: plan.objects
+                .filter((object) => object.disposition === "already-current")
+                .map((object) => object.object_id),
+            pending: plan.objects
+                .filter((object) => object.disposition === "planned")
+                .map((object) => object.object_id),
+            refused: plan.objects
+                .filter((object) => object.disposition === "refused")
+                .map((object) => object.object_id),
+            mutations: 0,
+            dryRun: true,
+        });
+    }
+    const resumePendingAttempt = input.resumeOperationId !== undefined && journal.active_attempt_id !== null;
+    const pendingReceipt = baseReceipt({
+        plan,
+        attemptId,
+        startedAt,
+        finishedAt: startedAt,
+        disposition: input.resumeOperationId === undefined ? "new" : "resumed",
+        status: "failed",
+        mutations: 0,
+        errorCode: "install-reconcile-interrupted",
+        nextAction: "resume-install-reconcile",
+    });
+    const receiptResult = resumePendingAttempt
+        ? await (options.receiptReopen ?? reopenReceiptAttempt)(pendingReceipt)
+        : await (options.receiptOpen ?? openReceiptAttempt)(pendingReceipt);
+    const receiptSession = receiptResult.kind === "ready" ? receiptResult.session : null;
+    if (receiptSession === null) {
+        return envelopeFromState({
+            plan,
+            attemptId,
+            startedAt,
+            finishedAt: now().toISOString(),
+            disposition: input.resumeOperationId === undefined ? "new" : "resumed",
+            completed: journal.completed,
+            pending: journal.pending,
+            refused: journal.refused,
+            mutations: 0,
+            dryRun: false,
+            failure: "receipt-store-unavailable",
+            nextActionOverride: "lyt doctor --json",
+        });
+    }
+    journal = Object.freeze({
+        ...journal,
+        active_attempt_id: attemptId,
+        active_started_at: startedAt,
+        status: "interrupted",
+    });
+    writeJournal(journalRoot, journal);
+    const sourceObjects = new Map(providers.flatMap((provider) => provider.objects).map((object) => [object.object_id, object]));
+    const completed = new Set(journal.completed);
+    const refused = new Set(journal.refused);
+    let mutations = 0;
+    let failure = null;
+    for (const objectPlan of plan.objects) {
+        if (completed.has(objectPlan.object_id) || refused.has(objectPlan.object_id))
+            continue;
+        if (objectPlan.disposition === "already-current") {
+            completed.add(objectPlan.object_id);
+            continue;
+        }
+        if (objectPlan.disposition === "refused") {
+            refused.add(objectPlan.object_id);
+            continue;
+        }
+        const source = sourceObjects.get(objectPlan.object_id);
+        if (source === undefined) {
+            failure = "install-provider-object-missing";
+            break;
+        }
+        try {
+            revalidateObject(source, objectPlan);
+            const staged = stageObject(journalRoot, source);
+            applyOneObject(source, staged);
+            verifyAppliedObject(source, staged);
+            completed.add(objectPlan.object_id);
+            mutations += 1;
+            if (options.failBeforeJournalAfterObject === objectPlan.object_id) {
+                throw new Error("install-reconcile-injected-prejournal-interruption");
+            }
+            const currentPending = plan.objects
+                .map((entry) => entry.object_id)
+                .filter((id) => !completed.has(id) && !refused.has(id));
+            journal = Object.freeze({
+                ...journal,
+                completed: Object.freeze([...completed].sort()),
+                pending: Object.freeze(currentPending),
+                refused: Object.freeze([...refused].sort()),
+                status: "interrupted",
+            });
+            writeJournal(journalRoot, journal);
+            if (options.failAfterObject === objectPlan.object_id) {
+                throw new Error("install-reconcile-injected-interruption");
+            }
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message === "install-reconcile-injected-prejournal-interruption") {
+                throw error;
+            }
+            failure = error instanceof Error ? error.message : "install-reconcile-apply-failed";
+            break;
+        }
+    }
+    const pending = plan.objects
+        .map((entry) => entry.object_id)
+        .filter((id) => !completed.has(id) && !refused.has(id));
+    journal = Object.freeze({
+        ...journal,
+        completed: Object.freeze([...completed].sort()),
+        pending: Object.freeze(pending),
+        refused: Object.freeze([...refused].sort()),
+        active_attempt_id: failure === null ? null : attemptId,
+        active_started_at: failure === null ? null : startedAt,
+        status: failure === null ? terminalJournalStatus(pending, [...refused]) : "interrupted",
+    });
+    writeJournal(journalRoot, journal);
+    let envelope = envelopeFromState({
+        plan,
+        attemptId,
+        startedAt,
+        finishedAt: now().toISOString(),
+        disposition: input.resumeOperationId === undefined ? "new" : "resumed",
+        completed: [...completed].sort(),
+        pending,
+        refused: [...refused].sort(),
+        mutations,
+        dryRun: false,
+        failure,
+    });
+    if (receiptSession !== null) {
+        try {
+            const warnings = await receiptSession.finalize(envelope.receipt);
+            if (warnings.length > 0)
+                throw new Error("receipt-finalization-warning");
+        }
+        catch {
+            envelope = envelopeFromState({
+                plan,
+                attemptId,
+                startedAt,
+                finishedAt: now().toISOString(),
+                disposition: input.resumeOperationId === undefined ? "new" : "resumed",
+                completed: [...completed].sort(),
+                pending,
+                refused: [...refused].sort(),
+                mutations,
+                dryRun: false,
+                failure: "receipt-finalization-failed",
+            });
+            journal = Object.freeze({
+                ...journal,
+                active_attempt_id: attemptId,
+                active_started_at: startedAt,
+                status: "interrupted",
+            });
+            writeJournal(journalRoot, journal);
+            return envelope;
+        }
+        journal = Object.freeze({
+            ...journal,
+            active_attempt_id: null,
+            active_started_at: null,
+            status: terminalJournalStatus(pending, [...refused]),
+        });
+        writeJournal(journalRoot, journal);
+    }
+    return envelope;
+}
+function recoverAppliedObjects(sealed, observed, journal) {
+    const currentById = new Map(observed.objects.map((object) => [object.object_id, object]));
+    const completed = new Set(journal.completed);
+    for (const object of sealed.objects) {
+        const current = currentById.get(object.object_id);
+        if (journal.pending.includes(object.object_id) &&
+            current?.disposition === "already-current" &&
+            current.observed_digest === object.expected_applied_digest) {
+            completed.add(object.object_id);
+        }
+    }
+    if (completed.size === journal.completed.length)
+        return journal;
+    return Object.freeze({
+        ...journal,
+        completed: Object.freeze([...completed].sort()),
+        pending: Object.freeze(journal.pending.filter((id) => !completed.has(id))),
+    });
+}
+function assertResumeEnvironment(sealed, observed, journal) {
+    const observedById = new Map(observed.objects.map((object) => [object.object_id, object]));
+    if (observedById.size !== sealed.objects.length) {
+        throw new Error("install-reconcile-destination-drift");
+    }
+    const completed = new Set(journal.completed);
+    for (const expected of sealed.objects) {
+        const current = observedById.get(expected.object_id);
+        if (current === undefined ||
+            current.provider_package !== expected.provider_package ||
+            current.provider_version !== expected.provider_version ||
+            current.kind !== expected.kind ||
+            current.target_path !== expected.target_path ||
+            current.expected_digest !== expected.expected_digest ||
+            canonicalJson(current.trusted_legacy_digests) !==
+                canonicalJson(expected.trusted_legacy_digests) ||
+            current.expected_applied_digest !== expected.expected_applied_digest ||
+            (completed.has(expected.object_id) && current.disposition !== "already-current") ||
+            (completed.has(expected.object_id) &&
+                current.observed_digest !== expected.expected_applied_digest) ||
+            (!completed.has(expected.object_id) &&
+                (current.disposition !== expected.disposition ||
+                    current.observed_digest !== expected.observed_digest))) {
+            throw new Error("install-reconcile-destination-drift");
+        }
+    }
+}
+function inspectProviderObject(object) {
+    assertPathChainHasNoLinks(dirname(object.target_path), true);
+    let disposition = "planned";
+    let refusalCode = null;
+    let observedDigest = null;
+    let expectedAppliedDigest = object.expected_digest;
+    try {
+        const stat = lstatSync(object.target_path);
+        if (stat.isSymbolicLink()) {
+            if (object.kind === "directory-link") {
+                const linked = resolve(dirname(object.target_path), readlinkSync(object.target_path));
+                observedDigest = digestPathTree(linked);
+                if (observedDigest === object.expected_digest)
+                    disposition = "already-current";
+                else {
+                    disposition = "refused";
+                    refusalCode = "divergent-link";
+                }
+            }
+            else {
+                disposition = "refused";
+                refusalCode = "symlink-leaf";
+            }
+        }
+        else if (object.kind === "directory-link" && stat.isDirectory()) {
+            observedDigest = digestPathTree(object.target_path);
+            if (observedDigest === object.expected_digest) {
+                disposition = "already-current";
+            }
+            else {
+                disposition = "refused";
+                refusalCode = "handler-owned-skill-leaf";
+            }
+        }
+        else if (object.kind === "marker-file" && stat.isFile()) {
+            const current = readFileSync(object.target_path, "utf8");
+            const next = replaceOwnedMarker(current, object);
+            observedDigest = digestBytes(Buffer.from(current));
+            expectedAppliedDigest = digestBytes(Buffer.from(next));
+            disposition = next === current ? "already-current" : "planned";
+        }
+        else {
+            disposition = "refused";
+            refusalCode = "unsupported-leaf-type";
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return Object.freeze({
+        object_id: object.object_id,
+        provider_package: object.provider_package,
+        provider_version: object.provider_version,
+        kind: object.kind,
+        target_path: resolve(object.target_path),
+        expected_digest: object.expected_digest,
+        observed_digest: observedDigest,
+        expected_applied_digest: expectedAppliedDigest,
+        trusted_legacy_digests: Object.freeze([...object.trusted_legacy_digests].sort()),
+        disposition,
+        refusal_code: refusalCode,
+    });
+}
+function revalidateObject(source, sealed) {
+    const current = inspectProviderObject(source);
+    if (canonicalJson(current) !== canonicalJson(sealed)) {
+        throw new Error("install-reconcile-destination-drift");
+    }
+    if (source.kind === "directory-link" &&
+        digestPathTree(source.source_path) !== source.expected_digest) {
+        throw new Error("install-reconcile-provider-drift");
+    }
+    if (source.kind === "marker-file" &&
+        digestBytes(Buffer.from(source.content)) !== source.expected_digest) {
+        throw new Error("install-reconcile-provider-drift");
+    }
+}
+function stageObject(root, object) {
+    assertPathChainHasNoLinks(root, true);
+    const expectedAppliedDigest = inspectProviderObject(object).expected_applied_digest;
+    const objectRoot = join(root, "objects", expectedAppliedDigest);
+    assertPathChainHasNoLinks(objectRoot, true);
+    const primary = join(objectRoot, object.kind === "directory-link" ? "content" : "content.md");
+    mkdirSync(objectRoot, { recursive: true });
+    const candidates = [primary, `${primary}.recovery-${expectedAppliedDigest.slice(0, 16)}`];
+    for (const staged of candidates) {
+        assertPathChainHasNoLinks(staged, true);
+        if (!existsSync(staged)) {
+            if (object.kind === "directory-link")
+                cpSync(object.source_path, staged, { recursive: true });
+            else {
+                const existing = existsSync(object.target_path)
+                    ? readFileSync(object.target_path, "utf8")
+                    : "";
+                writeFileSync(staged, replaceOwnedMarker(existing, object), {
+                    encoding: "utf8",
+                    flag: "wx",
+                });
+            }
+        }
+        const actual = object.kind === "directory-link" ? digestPathTree(staged) : digestBytes(readFileSync(staged));
+        if (actual === expectedAppliedDigest)
+            return staged;
+    }
+    throw new Error("install-reconcile-staging-mismatch");
+}
+function applyOneObject(object, staged) {
+    assertPathChainHasNoLinks(dirname(object.target_path), true);
+    mkdirSync(dirname(object.target_path), { recursive: true });
+    if (object.kind === "directory-link") {
+        if (existsSync(object.target_path)) {
+            if (digestPathTree(object.target_path) === object.expected_digest)
+                return;
+            throw new Error("install-reconcile-refuses-existing-skill-leaf");
+        }
+        symlinkSync(staged, object.target_path, platform() === "win32" ? "junction" : "dir");
+        return;
+    }
+    atomicWriteFile(object.target_path, readFileSync(staged, "utf8"));
+}
+function verifyAppliedObject(object, staged) {
+    if (object.kind === "directory-link") {
+        const linked = resolve(dirname(object.target_path), readlinkSync(object.target_path));
+        if (resolve(linked) !== resolve(staged) || digestPathTree(linked) !== object.expected_digest) {
+            throw new Error("install-reconcile-verification-failed");
+        }
+        return;
+    }
+    if (digestBytes(readFileSync(object.target_path)) !== digestBytes(readFileSync(staged))) {
+        throw new Error("install-reconcile-verification-failed");
+    }
+}
+function assertProviderSet(providers) {
+    const names = providers.map((provider) => provider.package).sort();
+    const expected = [...UPDATE_PLAN_PACKAGES].sort();
+    if (canonicalJson(names) !== canonicalJson(expected)) {
+        throw new Error("install-provider-exact-seven-required");
+    }
+    if (new Set(providers.map((provider) => provider.version)).size !== 1) {
+        throw new Error("install-provider-version-skew");
+    }
+    for (const provider of providers) {
+        if (provider.schema_id !== "lyt.install-provider" ||
+            provider.schema_version.major !== 1 ||
+            provider.schema_version.minor !== 0 ||
+            provider.objects.some((object) => object.provider_package !== provider.package ||
+                object.provider_version !== provider.version) ||
+            provider.objects.some((object) => new Set(object.trusted_legacy_digests).size !== object.trusted_legacy_digests.length ||
+                object.trusted_legacy_digests.some((digest) => !/^[a-f0-9]{64}$/.test(digest) || digest === object.expected_digest))) {
+            throw new Error("install-provider-invalid-manifest");
+        }
+    }
+}
+function replaceOwnedMarker(existing, object) {
+    const composed = composeManagedManualMarker(existing, object.content);
+    if (composed.status === "malformed") {
+        throw new Error("install-reconcile-malformed-managed-marker");
+    }
+    return composed.result;
+}
+function newJournal(plan) {
+    const pending = plan.objects
+        .filter((object) => object.disposition === "planned")
+        .map((object) => object.object_id);
+    const refused = plan.objects
+        .filter((object) => object.disposition === "refused")
+        .map((object) => object.object_id);
+    return Object.freeze({
+        schema_id: "lyt.install-reconcile-journal",
+        schema_version: Object.freeze({ major: 1, minor: 0 }),
+        plan,
+        completed: Object.freeze(plan.objects
+            .filter((object) => object.disposition === "already-current")
+            .map((object) => object.object_id)),
+        pending: Object.freeze(pending),
+        refused: Object.freeze(refused),
+        active_attempt_id: null,
+        active_started_at: null,
+        status: terminalJournalStatus(pending, refused),
+    });
+}
+function terminalJournalStatus(pending, refused) {
+    if (pending.length > 0)
+        return "pending";
+    return refused.length > 0 ? "refused" : "complete";
+}
+function journalPath(root, operationId) {
+    return join(root, "operations", operationId, "journal.json");
+}
+function writeJournal(root, journal) {
+    const path = journalPath(root, journal.plan.operation_id);
+    assertPathChainHasNoLinks(root, true);
+    assertPathChainHasNoLinks(dirname(path), true);
+    assertPathChainHasNoLinks(path, true);
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWriteFile(path, `${JSON.stringify(journal, null, 2)}\n`);
+}
+function readJournal(root, operationId) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(operationId))
+        throw new Error("install-reconcile-invalid-operation-id");
+    const path = journalPath(root, operationId);
+    assertPathChainHasNoLinks(root, true);
+    assertPathChainHasNoLinks(dirname(path), true);
+    assertPathChainHasNoLinks(path, true);
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(parsed.plan?.objects) ||
+        !Array.isArray(parsed.completed) ||
+        !Array.isArray(parsed.pending) ||
+        !Array.isArray(parsed.refused)) {
+        throw new Error("install-reconcile-journal-tampered");
+    }
+    const planIds = new Set(parsed.plan?.objects?.map((object) => object.object_id) ?? []);
+    const completed = new Set(parsed.completed ?? []);
+    const pending = new Set(parsed.pending ?? []);
+    const refused = new Set(parsed.refused ?? []);
+    const partition = new Set([...completed, ...pending, ...refused]);
+    const dispositions = new Map((parsed.plan?.objects ?? []).map((object) => [object.object_id, object.disposition]));
+    if (parsed.schema_id !== "lyt.install-reconcile-journal" ||
+        parsed.schema_version?.major !== 1 ||
+        parsed.schema_version?.minor !== 0 ||
+        !["pending", "complete", "refused", "interrupted"].includes(parsed.status) ||
+        parsed.plan?.schema_id !== "lyt.install-reconcile-plan" ||
+        parsed.plan?.schema_version?.major !== 1 ||
+        parsed.plan?.schema_version?.minor !== 0 ||
+        parsed.plan.operation_id !== operationId ||
+        !Array.isArray(parsed.plan.objects) ||
+        !Array.isArray(parsed.completed) ||
+        !Array.isArray(parsed.pending) ||
+        !Array.isArray(parsed.refused) ||
+        !parsed.completed.every((value) => typeof value === "string") ||
+        !parsed.pending.every((value) => typeof value === "string") ||
+        !parsed.refused.every((value) => typeof value === "string") ||
+        completed.size !== parsed.completed.length ||
+        pending.size !== parsed.pending.length ||
+        refused.size !== parsed.refused.length ||
+        partition.size !== planIds.size ||
+        [...partition].some((id) => !planIds.has(id)) ||
+        [...completed].some((id) => refused.has(id) || pending.has(id) || dispositions.get(id) === "refused") ||
+        [...pending].some((id) => refused.has(id) || dispositions.get(id) !== "planned") ||
+        [...refused].some((id) => dispositions.get(id) !== "refused") ||
+        (parsed.active_attempt_id !== null && typeof parsed.active_attempt_id !== "string") ||
+        (parsed.active_started_at !== null && typeof parsed.active_started_at !== "string") ||
+        (parsed.active_attempt_id === null) !== (parsed.active_started_at === null) ||
+        (parsed.status === "interrupted") !== (parsed.active_attempt_id !== null) ||
+        (parsed.status === "pending" && (parsed.active_attempt_id !== null || pending.size === 0)) ||
+        (parsed.status === "complete" &&
+            (parsed.active_attempt_id !== null || pending.size > 0 || refused.size > 0)) ||
+        (parsed.status === "refused" &&
+            (parsed.active_attempt_id !== null || pending.size > 0 || refused.size === 0)) ||
+        parsed.plan.plan_digest !==
+            digestCanonical({
+                schema_id: parsed.plan.schema_id,
+                schema_version: parsed.plan.schema_version,
+                journal_root: parsed.plan.journal_root,
+                objects: parsed.plan.objects,
+            })) {
+        throw new Error("install-reconcile-journal-tampered");
+    }
+    return parsed;
+}
+export function inspectReconcileJournalV1(root, operationId) {
+    try {
+        return Object.freeze({
+            valid: true,
+            journal: readJournal(resolve(root), operationId),
+            error_code: null,
+        });
+    }
+    catch (error) {
+        return Object.freeze({
+            valid: false,
+            journal: null,
+            error_code: safeErrorCode(error instanceof Error ? error.message : "install-reconcile-journal-invalid"),
+        });
+    }
+}
+function atomicWriteFile(path, content) {
+    const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+    assertPathChainHasNoLinks(dirname(path), true);
+    assertPathChainHasNoLinks(path, true);
+    assertPathChainHasNoLinks(temporary, true);
+    writeFileSync(temporary, content, { encoding: "utf8", flag: "w" });
+    renameSync(temporary, path);
+}
+function envelopeFromState(args) {
+    const failure = args.failure ?? null;
+    const incomplete = args.pending.length > 0 || args.refused.length > 0 || failure !== null;
+    const status = args.dryRun
+        ? "planned"
+        : incomplete
+            ? args.mutations > 0
+                ? "partial"
+                : args.refused.length > 0
+                    ? "refused"
+                    : "failed"
+            : args.mutations > 0
+                ? "success"
+                : "no-op";
+    const nextAction = args.nextActionOverride ??
+        (args.dryRun && (args.pending.length > 0 || args.refused.length > 0)
+            ? args.refused.length > 0
+                ? "lyt doctor --json"
+                : "lyt install reconcile --apply --json"
+            : incomplete
+                ? args.refused.length > 0 && args.pending.length === 0 && failure === null
+                    ? "lyt doctor --json"
+                    : `lyt install reconcile --resume ${args.plan.operation_id} --apply --json`
+                : null);
+    const receiptStatus = args.dryRun ? "no-op" : status === "planned" ? "no-op" : status;
+    const receipt = baseReceipt({
+        plan: args.plan,
+        attemptId: args.attemptId,
+        startedAt: args.startedAt,
+        finishedAt: args.finishedAt,
+        disposition: status === "refused" ? "rejected" : args.disposition,
+        status: receiptStatus,
+        mutations: args.mutations,
+        errorCode: args.dryRun || !incomplete ? null : (failure ?? "install-reconcile-refused-object"),
+        nextAction: args.dryRun || !incomplete
+            ? null
+            : args.refused.length > 0 && args.pending.length === 0 && failure === null
+                ? "inspect-install-reconcile"
+                : "resume-install-reconcile",
+    });
+    return Object.freeze({
+        schema_id: "lyt.install-reconcile-result",
+        schema_version: Object.freeze({ major: 1, minor: 0 }),
+        success: !incomplete,
+        status,
+        operation_id: args.plan.operation_id,
+        attempt_id: args.attemptId,
+        plan_digest: args.plan.plan_digest,
+        plan: args.plan,
+        mutations: args.mutations,
+        completed: Object.freeze([...args.completed]),
+        pending: Object.freeze([...args.pending]),
+        refused: Object.freeze([...args.refused]),
+        next_action: nextAction,
+        receipt,
+    });
+}
+function baseReceipt(args) {
+    return parseReceiptV1ForEmission({
+        schema_id: "lyt.receipt",
+        schema_version: { major: 1, minor: 0 },
+        operation_id: args.plan.operation_id,
+        attempt_id: args.attemptId,
+        operation: "install-reconcile",
+        scope: { kind: "system" },
+        timestamps: { started_at: args.startedAt, finished_at: args.finishedAt },
+        replay: { disposition: args.disposition, key_digest: args.plan.plan_digest },
+        status: args.status,
+        exit_code: args.status === "success" || args.status === "no-op" ? 0 : 1,
+        mutations: { local: args.mutations, remote: 0 },
+        evidence: {
+            before: [
+                {
+                    kind: "reconcile-plan",
+                    subject: "sealed install reconciliation plan",
+                    digest: args.plan.plan_digest,
+                },
+            ],
+            after: [
+                {
+                    kind: "managed-objects",
+                    subject: "verified managed destination objects",
+                    count: args.mutations,
+                },
+            ],
+        },
+        next_action: args.nextAction === null
+            ? null
+            : { code: args.nextAction, summary: "Resume the exact install reconciliation operation." },
+        error: args.errorCode === null
+            ? null
+            : {
+                code: safeErrorCode(args.errorCode),
+                summary: "Install reconciliation is incomplete.",
+                retryable: true,
+            },
+    });
+}
+function safeErrorCode(value) {
+    const safe = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return safe.length > 0 ? safe.slice(0, 96) : "install-reconcile-failed";
+}
+export function assertPathChainHasNoLinks(path, includeLeaf) {
+    const absolute = resolve(path);
+    const parsed = parse(absolute);
+    const parts = relative(parsed.root, absolute).split(/[\\/]/).filter(Boolean);
+    let current = parsed.root;
+    const last = includeLeaf ? parts.length : Math.max(0, parts.length - 1);
+    for (let index = 0; index < last; index += 1) {
+        current = join(current, parts[index]);
+        try {
+            if (lstatSync(current).isSymbolicLink())
+                throw new Error("install-reconcile-symlink-path");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+export function digestBytes(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function digestPathTree(path) {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink())
+        throw new Error("install-provider-source-symlink");
+    if (stat.isFile())
+        return digestBytes(readFileSync(path));
+    if (!stat.isDirectory())
+        throw new Error("install-provider-source-type");
+    const hash = createHash("sha256");
+    for (const name of readdirSync(path).sort()) {
+        const child = join(path, name);
+        hash.update(name, "utf8");
+        hash.update("\0");
+        hash.update(digestPathTree(child), "hex");
+    }
+    return hash.digest("hex");
+}
+function digestToUuidV7(digest) {
+    const chars = digest.slice(0, 32).split("");
+    chars[12] = "7";
+    chars[16] = ["8", "9", "a", "b"][Number.parseInt(chars[16], 16) % 4];
+    const raw = chars.join("");
+    return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`;
+}
+//# sourceMappingURL=reconcile-engine.js.map