@nklisch/pi-enhanced 0.1.0

package/node_modules/@nklisch/pi-plugins/dist/application/installed-revision-descriptor.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { ContentDigestSchema, hashContent } from "../domain/content-manifest.js";
+import { InstalledRevisionRecordSchema } from "../domain/state/installed-state.js";
+import { LoadedInstalledPluginSchema, } from "./ports/installed-plugin-loader.js";
+export const InstalledRevisionDescriptorSchemaV1 = z.object({
+    schemaVersion: z.literal(1),
+    loaded: LoadedInstalledPluginSchema,
+    digest: ContentDigestSchema,
+}).strict().readonly();
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalize(record[key])]));
+    }
+    return value;
+}
+function descriptorDigest(loaded, sha256) {
+    return hashContent(new TextEncoder().encode(`installed-revision-descriptor-v1\0${JSON.stringify(canonicalize(loaded))}`), sha256);
+}
+function verifyRevisionBinding(loaded, revision) {
+    if (loaded.binding !== revision.revision || loaded.content.rootDigest !== revision.contentDigest ||
+        loaded.plugin.identity.key !== revision.evidence.plugin.key ||
+        loaded.compatibility.plugin.key !== revision.evidence.plugin.key ||
+        loaded.plugin.source.hash !== revision.evidence.source.sourceHash ||
+        loaded.compatibility.activatable !== revision.evidence.compatibility.activatable) {
+        throw new Error("installed reconstruction descriptor does not match installed revision evidence");
+    }
+}
+export function createInstalledRevisionDescriptor(input) {
+    if (typeof input.sha256 !== "function")
+        throw new TypeError("installed descriptor requires SHA-256");
+    const loaded = LoadedInstalledPluginSchema.parse(input.loaded);
+    const revision = InstalledRevisionRecordSchema.parse(input.revision);
+    verifyRevisionBinding(loaded, revision);
+    return InstalledRevisionDescriptorSchemaV1.parse({
+        schemaVersion: 1,
+        loaded,
+        digest: descriptorDigest(loaded, input.sha256),
+    });
+}
+export function verifyInstalledRevisionDescriptor(input, revision, sha256) {
+    const descriptor = InstalledRevisionDescriptorSchemaV1.parse(input);
+    verifyRevisionBinding(descriptor.loaded, InstalledRevisionRecordSchema.parse(revision));
+    if (descriptor.digest !== descriptorDigest(descriptor.loaded, sha256)) {
+        throw new Error("installed reconstruction descriptor digest does not match its evidence");
+    }
+    return descriptor;
+}
+//# sourceMappingURL=installed-revision-descriptor.js.map

package/node_modules/@nklisch/pi-plugins/dist/application/installed-revision-descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-revision-descriptor.js","sourceRoot":"","sources":["../../src/application/installed-revision-descriptor.ts"],"names":[],"mappings":"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"}

package/node_modules/@nklisch/pi-plugins/dist/application/keyed-mutation-scheduler.d.ts

@@ -0,0 +1,19 @@
+import { type KeyedMutationScheduler, type MutationSubject } from "./mutation-coordination.js";
+import "../domain/state/scope.js";
+import type { MutationExecutionContext } from "./ports/mutation-execution-context.js";
+/**
+ * A callback can retain the scheduler and request another key while it is
+ * already holding one. Waiting for an overlapping key would deadlock forever,
+ * so this error is raised at the recursive call site before a waiter exists.
+ */
+export declare class RecursiveMutationAcquisitionError extends Error {
+    readonly code: "RECURSIVE_MUTATION_ACQUISITION";
+    constructor();
+}
+/**
+ * This encoding is deliberately length-prefixed. Delimiter concatenation would
+ * make a future scope/plugin grammar change capable of aliasing two lock keys.
+ */
+declare function canonicalSubjectKey(subject: MutationSubject): string;
+export declare function createKeyedMutationScheduler(execution?: MutationExecutionContext): KeyedMutationScheduler;
+export { canonicalSubjectKey };

package/node_modules/@nklisch/pi-plugins/dist/application/keyed-mutation-scheduler.js

@@ -0,0 +1,235 @@
+import { MutationSubjectSchema, } from "./mutation-coordination.js";
+import "../domain/state/scope.js";
+const encoder = new TextEncoder();
+/**
+ * A callback can retain the scheduler and request another key while it is
+ * already holding one. Waiting for an overlapping key would deadlock forever,
+ * so this error is raised at the recursive call site before a waiter exists.
+ */
+export class RecursiveMutationAcquisitionError extends Error {
+    code = "RECURSIVE_MUTATION_ACQUISITION";
+    constructor() {
+        super("mutation scheduler does not permit overlapping recursive acquisition");
+        this.name = "RecursiveMutationAcquisitionError";
+    }
+}
+function assertSignal(signal) {
+    if (signal === null ||
+        typeof signal !== "object" ||
+        typeof signal.addEventListener !== "function" ||
+        typeof signal.removeEventListener !== "function" ||
+        typeof signal.aborted !== "boolean") {
+        throw new TypeError("mutation scheduling requires an AbortSignal");
+    }
+}
+function throwIfAborted(signal) {
+    if (signal.aborted)
+        throw signal.reason;
+}
+function field(value) {
+    return `${encoder.encode(value).byteLength}:${value}`;
+}
+/**
+ * This encoding is deliberately length-prefixed. Delimiter concatenation would
+ * make a future scope/plugin grammar change capable of aliasing two lock keys.
+ */
+function canonicalSubjectKey(subject) {
+    const scope = subject.scope;
+    return scope.kind === "user"
+        ? `scope:${field("user")}|plugin:${field(subject.plugin)}`
+        : `scope:${field("project")}${field(scope.projectKey)}|plugin:${field(subject.plugin)}`;
+}
+function canonicalScopeKey(subject) {
+    return subject.scope.kind === "user"
+        ? `scope:${field("user")}`
+        : `scope:${field("project")}${field(subject.scope.projectKey)}`;
+}
+function compareKeys(left, right) {
+    const leftBytes = encoder.encode(left);
+    const rightBytes = encoder.encode(right);
+    const length = Math.min(leftBytes.byteLength, rightBytes.byteLength);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.byteLength - rightBytes.byteLength;
+}
+function validateSubjects(input) {
+    if (!Array.isArray(input))
+        throw new TypeError("mutation subjects must be an array");
+    const subjects = input.map((subject) => MutationSubjectSchema.parse(subject));
+    const scope = subjects[0] === undefined ? undefined : canonicalScopeKey(subjects[0]);
+    const keys = new Set();
+    for (const subject of subjects) {
+        if (scope !== undefined && canonicalScopeKey(subject) !== scope) {
+            throw new TypeError("a mutation request must contain one scope");
+        }
+        const key = canonicalSubjectKey(subject);
+        if (keys.has(key))
+            throw new TypeError("a mutation request cannot contain duplicate subjects");
+        keys.add(key);
+    }
+    return [...subjects].sort((left, right) => compareKeys(canonicalSubjectKey(left), canonicalSubjectKey(right)));
+}
+function removeWaiter(state, waiter) {
+    const index = state.queue.indexOf(waiter);
+    if (index !== -1)
+        state.queue.splice(index, 1);
+}
+function createSynchronousExecutionContext() {
+    let currentKeys;
+    return {
+        current: () => currentKeys,
+        run(keys, work) {
+            const previous = currentKeys;
+            currentKeys = keys;
+            try {
+                return work();
+            }
+            finally {
+                currentKeys = previous;
+            }
+        },
+    };
+}
+class Scheduler {
+    execution;
+    states = new Map();
+    constructor(execution) {
+        this.execution = execution;
+    }
+    run(subjects, work, signal) {
+        if (typeof work !== "function")
+            throw new TypeError("mutation work must be a function");
+        const validated = validateSubjects(subjects);
+        const heldKeys = this.execution.current();
+        if (heldKeys !== undefined && validated.some((subject) => heldKeys.has(canonicalSubjectKey(subject)))) {
+            throw new RecursiveMutationAcquisitionError();
+        }
+        return this.runInternal(validated, work, signal);
+    }
+    runInternal(subjects, work, signal) {
+        assertSignal(signal);
+        if (typeof work !== "function")
+            throw new TypeError("mutation work must be a function");
+        throwIfAborted(signal);
+        const keys = subjects.map(canonicalSubjectKey);
+        if (keys.length === 0) {
+            return Promise.resolve().then(async () => {
+                throwIfAborted(signal);
+                return this.execution.run(new Set(this.execution.current() ?? []), work);
+            });
+        }
+        return this.acquire(keys, signal).then(async (waiter) => {
+            try {
+                throwIfAborted(signal);
+                const heldKeys = new Set(this.execution.current() ?? []);
+                for (const key of keys)
+                    heldKeys.add(key);
+                return await this.execution.run(heldKeys, work);
+            }
+            finally {
+                this.release(waiter);
+            }
+        });
+    }
+    acquire(keys, signal) {
+        let waiter;
+        const promise = new Promise((resolve, reject) => {
+            waiter = {
+                token: Symbol("mutation-owner"),
+                keys,
+                resolve: () => resolve(waiter),
+                reject,
+                signal,
+                settled: false,
+                abortListener: undefined,
+            };
+        });
+        for (const key of keys) {
+            const state = this.states.get(key) ?? { queue: [], owner: undefined };
+            this.states.set(key, state);
+            state.queue.push(waiter);
+        }
+        waiter.abortListener = () => this.cancel(waiter);
+        signal.addEventListener("abort", waiter.abortListener, { once: true });
+        if (signal.aborted) {
+            this.cancel(waiter);
+        }
+        else {
+            this.pump(keys);
+        }
+        return promise;
+    }
+    cancel(waiter) {
+        if (waiter.settled)
+            return;
+        waiter.settled = true;
+        if (waiter.abortListener !== undefined) {
+            waiter.signal.removeEventListener("abort", waiter.abortListener);
+            waiter.abortListener = undefined;
+        }
+        for (const key of waiter.keys) {
+            const state = this.states.get(key);
+            if (state !== undefined)
+                removeWaiter(state, waiter);
+        }
+        waiter.reject(waiter.signal.reason);
+        this.pump(waiter.keys);
+    }
+    pump(keys) {
+        for (const key of keys)
+            this.pumpOne(key);
+        for (const key of keys)
+            this.cleanup(key);
+    }
+    pumpOne(key) {
+        const state = this.states.get(key);
+        const candidate = state?.queue[0];
+        if (state === undefined || candidate === undefined || state.owner !== undefined)
+            return;
+        const ready = candidate.keys.every((candidateKey) => {
+            const candidateState = this.states.get(candidateKey);
+            return candidateState !== undefined && candidateState.owner === undefined && candidateState.queue[0] === candidate;
+        });
+        if (!ready)
+            return;
+        candidate.settled = true;
+        if (candidate.abortListener !== undefined) {
+            candidate.signal.removeEventListener("abort", candidate.abortListener);
+            candidate.abortListener = undefined;
+        }
+        for (const candidateKey of candidate.keys) {
+            const candidateState = this.states.get(candidateKey);
+            if (candidateState === undefined)
+                throw new Error("scheduler key state disappeared");
+            candidateState.queue.shift();
+            candidateState.owner = candidate;
+        }
+        candidate.resolve();
+    }
+    release(waiter) {
+        for (const key of [...waiter.keys].reverse()) {
+            const state = this.states.get(key);
+            if (state?.owner === waiter)
+                state.owner = undefined;
+        }
+        this.pump(waiter.keys);
+    }
+    cleanup(key) {
+        const state = this.states.get(key);
+        if (state !== undefined && state.owner === undefined && state.queue.length === 0) {
+            this.states.delete(key);
+        }
+    }
+}
+export function createKeyedMutationScheduler(execution) {
+    const context = execution ?? createSynchronousExecutionContext();
+    if (context === null || typeof context !== "object" || typeof context.current !== "function" || typeof context.run !== "function") {
+        throw new TypeError("mutation scheduler execution context is required");
+    }
+    return new Scheduler(context);
+}
+export { canonicalSubjectKey };
+//# sourceMappingURL=keyed-mutation-scheduler.js.map

package/node_modules/@nklisch/pi-plugins/dist/application/keyed-mutation-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-mutation-scheduler.js","sourceRoot":"","sources":["../../src/application/keyed-mutation-scheduler.ts"],"names":[],"mappings":"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"}

package/node_modules/@nklisch/pi-plugins/dist/application/lifecycle-transition-reconciler.d.ts

@@ -0,0 +1,76 @@
+import "zod";
+import type { Sha256 } from "../domain/source.js";
+import { type PluginKey } from "../domain/identity.js";
+import { type ScopeContext } from "../domain/state/scope.js";
+import { type Generation } from "../domain/state/config-state.js";
+import { type InstalledPluginRecord } from "../domain/state/installed-state.js";
+import { type GenerationSnapshot } from "./state-contract.js";
+import type { GenerationMutationCoordinator } from "./generation-mutation-coordinator.js";
+import { type ActivationObservation, type LifecycleReloadPort } from "./ports/lifecycle-reload.js";
+import { type LifecycleTransitionRecord, type LifecycleTransitionStore } from "./ports/lifecycle-transition-store.js";
+import { type ProjectionExpectation } from "./ports/runtime-projection.js";
+import type { LifecycleOperation } from "./plugin-lifecycle-contract.js";
+export type LifecycleActivationFailure = Readonly<{
+    kind: "reload-rejected";
+    code: "RELOAD_REJECTED";
+}> | Readonly<{
+    kind: "observation-mismatch";
+    code: "OBSERVATION_MISMATCH";
+}> | Readonly<{
+    kind: "adapter-error";
+    code: "ADAPTER_FAILED" | "ABORTED";
+}>;
+export type TransitionReconciliationResult = Readonly<{
+    kind: "completed";
+    snapshot: GenerationSnapshot;
+    observation: ActivationObservation;
+}> | Readonly<{
+    kind: "rolled-back";
+    snapshot: GenerationSnapshot;
+    observation: ActivationObservation;
+    failure: LifecycleActivationFailure;
+}> | Readonly<{
+    kind: "recovery-required";
+    committed?: Generation;
+}>;
+export type LifecycleTransitionReconcilerDependencies = Readonly<{
+    mutations: GenerationMutationCoordinator;
+    state: {
+        read(scope: ScopeContext, signal: AbortSignal): Promise<import("./state-contract.js").StateLoadResult>;
+    };
+    reload: LifecycleReloadPort;
+    transitions: LifecycleTransitionStore;
+    sha256: Sha256;
+}>;
+export type CompleteCommittedTransitionRequest = Readonly<{
+    operation: LifecycleOperation;
+    scope: ScopeContext;
+    plugin: PluginKey;
+    previous: InstalledPluginRecord | undefined;
+    candidate: InstalledPluginRecord;
+    final: InstalledPluginRecord | null;
+    reference: import("../domain/state/references.js").PendingTransitionRef;
+    committed: GenerationSnapshot;
+    candidateProjection: ProjectionExpectation;
+    previousProjection: ProjectionExpectation;
+    activation: Readonly<{
+        ok: true;
+        observation: ActivationObservation;
+    } | {
+        ok: false;
+        failure: LifecycleActivationFailure;
+    }>;
+}>;
+export type RecoverInterruptedTransitionRequest = Readonly<{
+    scope: ScopeContext;
+    plugin: PluginKey;
+    record: LifecycleTransitionRecord;
+    current: InstalledPluginRecord | null;
+    observation?: ActivationObservation;
+}>;
+export declare function createLifecycleTransitionReconciler(dependencies: LifecycleTransitionReconcilerDependencies): LifecycleTransitionReconciler;
+export interface LifecycleTransitionReconciler {
+    completeCommittedTransition(request: CompleteCommittedTransitionRequest, signal: AbortSignal): Promise<TransitionReconciliationResult>;
+    recoverInterruptedTransition(request: RecoverInterruptedTransitionRequest, signal: AbortSignal): Promise<TransitionReconciliationResult>;
+}
+export type { ActivationObservation, Generation, InstalledPluginRecord, LifecycleTransitionRecord, PluginKey, ProjectionExpectation };

package/node_modules/@nklisch/pi-plugins/dist/application/lifecycle-transition-reconciler.js

@@ -0,0 +1,236 @@
+import "zod";
+import { PluginKeySchema } from "../domain/identity.js";
+import { ScopeContextSchema, toScopeReference } from "../domain/state/scope.js";
+import {} from "../domain/state/config-state.js";
+import { InstalledPluginRecordSchema } from "../domain/state/installed-state.js";
+import { createInstalledUserStateDocument } from "../domain/state/installed-state.js";
+import { createProjectLocalStateDocument } from "../domain/state/project-state.js";
+import { parseStateMutation } from "./state-contract.js";
+import { ActivationObservationSchema, LifecycleReloadResultSchema, } from "./ports/lifecycle-reload.js";
+import { LifecycleTransitionRecordSchemaV1, } from "./ports/lifecycle-transition-store.js";
+import { ProjectionExpectationSchema, } from "./ports/runtime-projection.js";
+import { classifyInterruptedTransition, projectionMatchesObservation, stateWithoutPending } from "./recovery-contract.js";
+// A lifecycle handoff spans foreground reload plus detached scheduler/notice
+// maintenance. Those unrelated writers may advance the shared scope several
+// times; each retry is still fenced by the exact pending target and reference.
+const MAX_REBASE_ATTEMPTS = 8;
+function sameJson(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    if (Array.isArray(left) || Array.isArray(right))
+        return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameJson(value, right[index]));
+    const a = left;
+    const b = right;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && sameJson(a[key], b[key]));
+}
+function target(snapshot, plugin) {
+    return "installed" in snapshot ? snapshot.installed.plugins.find((entry) => entry.plugin === plugin) : snapshot.project.plugins.find((entry) => entry.plugin === plugin);
+}
+function records(snapshot) {
+    return "installed" in snapshot ? snapshot.installed.plugins : snapshot.project.plugins;
+}
+function replaceTarget(snapshot, plugin, replacement, sha256) {
+    const next = records(snapshot).filter((entry) => entry.plugin !== plugin);
+    if (replacement !== null)
+        next.push(replacement);
+    if ("installed" in snapshot) {
+        const installed = createInstalledUserStateDocument({ ...snapshot.installed, generation: snapshot.generation, plugins: next }, sha256);
+        return parseStateMutation({ scope: snapshot.scope, expectedGeneration: snapshot.generation, replace: { installed } }, sha256);
+    }
+    const project = createProjectLocalStateDocument({ ...snapshot.project, generation: snapshot.generation, plugins: next }, snapshot.scope, sha256);
+    return parseStateMutation({ scope: snapshot.scope, expectedGeneration: snapshot.generation, replace: { project } }, sha256);
+}
+function withPending(record, reference) {
+    return InstalledPluginRecordSchema.parse({ ...stateWithoutPending(record), pendingTransition: reference });
+}
+function matches(snapshot, plugin, candidate, reference, allowAbsent, final) {
+    const current = target(snapshot, plugin);
+    if (current === undefined)
+        return allowAbsent && final === null;
+    return current.pendingTransition === reference && sameJson(stateWithoutPending(current), candidate);
+}
+function safeFailure(error) {
+    if (error !== null && typeof error === "object" && "name" in error && error.name === "AbortError")
+        return { kind: "adapter-error", code: "ABORTED" };
+    return { kind: "adapter-error", code: "ADAPTER_FAILED" };
+}
+function assertSignal(signal) {
+    if (signal.aborted)
+        throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+export function createLifecycleTransitionReconciler(dependencies) {
+    if (dependencies === null || typeof dependencies !== "object")
+        throw new TypeError("transition reconciler dependencies are required");
+    async function load(scope, signal) {
+        const result = await dependencies.state.read(scope, signal);
+        return result.ok ? result.snapshot : undefined;
+    }
+    async function mutatePending(scope, plugin, candidate, final, reference, committed, mutation, signal, allowAbsent = false) {
+        let expected = committed.generation;
+        for (let attempt = 0; attempt < MAX_REBASE_ATTEMPTS; attempt += 1) {
+            assertSignal(signal);
+            const result = await dependencies.mutations.runPreparedMutation({ scope, plugins: [plugin], expectedGeneration: expected }, async (context) => {
+                await context.assertOwned();
+                if (!matches(context.snapshot, plugin, candidate, reference, allowAbsent, final))
+                    throw new Error("transition target changed");
+                return { mutation: mutation(context.snapshot), value: undefined };
+            }, signal);
+            if (result.kind === "committed")
+                return result.snapshot;
+            if (result.kind !== "stale-generation" || attempt + 1 >= MAX_REBASE_ATTEMPTS)
+                return undefined;
+            const fresh = await load(scope, signal);
+            if (fresh === undefined || fresh.generation <= expected || !matches(fresh, plugin, candidate, reference, allowAbsent, final))
+                return undefined;
+            expected = fresh.generation;
+        }
+        return undefined;
+    }
+    async function reloadAndObserve(scope, plugin, reference, expectation, signal) {
+        try {
+            const reload = LifecycleReloadResultSchema.parse(await dependencies.reload.reload({ scope: toScopeReference(scope), transition: reference }, signal));
+            if (reload.kind === "failed")
+                return { ok: false, failure: { kind: "reload-rejected", code: "RELOAD_REJECTED" } };
+            const observation = ActivationObservationSchema.parse(await dependencies.reload.observe({ scope: toScopeReference(scope), plugin }, signal));
+            if (!projectionMatchesObservation(observation, expectation, plugin))
+                return { ok: false, failure: { kind: "observation-mismatch", code: "OBSERVATION_MISMATCH" } };
+            return { ok: true, observation };
+        }
+        catch (error) {
+            return { ok: false, failure: safeFailure(error) };
+        }
+    }
+    async function settle(scope, reference, outcome, generation, signal) {
+        try {
+            await dependencies.transitions.settle({ scope: toScopeReference(scope), reference, outcome, generation }, signal);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async function markRecovery(scope, reference, generation, signal) {
+        try {
+            await dependencies.transitions.settle({ scope: toScopeReference(scope), reference, outcome: "recovery-required", generation }, signal);
+        }
+        catch { /* startup will retain the pending state */ }
+    }
+    async function restoreAndVerify(request, signal) {
+        const restored = await mutatePending(request.scope, request.plugin, request.candidate, request.previous ?? null, request.reference, request.committed, (snapshot) => replaceTarget(snapshot, request.plugin, request.previous === undefined ? null : withPending(request.previous, request.reference), dependencies.sha256), signal, request.previous === undefined).catch(() => undefined);
+        if (restored === undefined) {
+            await markRecovery(request.scope, request.reference, request.committed.generation, signal);
+            return { kind: "recovery-required", committed: request.committed.generation };
+        }
+        const observed = await reloadAndObserve(request.scope, request.plugin, request.reference, request.previousProjection, signal);
+        if (!observed.ok) {
+            await markRecovery(request.scope, request.reference, restored.generation, signal);
+            return { kind: "recovery-required", committed: restored.generation };
+        }
+        const restoredRecord = request.previous === undefined ? request.candidate : request.previous;
+        const final = await mutatePending(request.scope, request.plugin, restoredRecord, request.previous ?? null, request.reference, restored, (snapshot) => replaceTarget(snapshot, request.plugin, request.previous ?? null, dependencies.sha256), signal, request.previous === undefined).catch(() => undefined);
+        if (final === undefined || !(await settle(request.scope, request.reference, "rolled-back", final.generation, signal))) {
+            await markRecovery(request.scope, request.reference, final?.generation ?? restored.generation, signal);
+            return { kind: "recovery-required", committed: final?.generation ?? restored.generation };
+        }
+        return { kind: "rolled-back", snapshot: final, observation: observed.observation, failure: request.failure };
+    }
+    async function completeCommittedTransition(request, signal) {
+        const scope = ScopeContextSchema.parse(request.scope);
+        const plugin = PluginKeySchema.parse(request.plugin);
+        const candidate = InstalledPluginRecordSchema.parse(request.candidate);
+        const final = request.final === null ? null : InstalledPluginRecordSchema.parse(request.final);
+        const candidateProjection = ProjectionExpectationSchema.parse(request.candidateProjection);
+        const previousProjection = ProjectionExpectationSchema.parse(request.previousProjection);
+        if (!request.activation.ok)
+            return restoreAndVerify({ ...request, scope, plugin, candidate, previousProjection, failure: request.activation.failure }, signal);
+        const settled = await mutatePending(scope, plugin, candidate, final, request.reference, request.committed, (snapshot) => replaceTarget(snapshot, plugin, final, dependencies.sha256), signal);
+        const journalSettled = settled === undefined ? false : await settle(scope, request.reference, "completed", settled.generation, signal);
+        if (settled === undefined || !journalSettled) {
+            await markRecovery(scope, request.reference, settled?.generation ?? request.committed.generation, signal);
+            return { kind: "recovery-required", committed: settled?.generation ?? request.committed.generation };
+        }
+        return { kind: "completed", snapshot: settled, observation: request.activation.observation };
+    }
+    async function recoverInterruptedTransition(request, signal) {
+        assertSignal(signal);
+        const record = LifecycleTransitionRecordSchemaV1.parse(request.record);
+        const scope = ScopeContextSchema.parse(request.scope);
+        const plugin = PluginKeySchema.parse(request.plugin);
+        const classification = classifyInterruptedTransition({ record, current: request.current, ...(request.observation === undefined ? {} : { observation: request.observation }) });
+        const currentSnapshot = await load(scope, signal);
+        if (currentSnapshot === undefined)
+            return { kind: "recovery-required" };
+        const current = target(currentSnapshot, plugin);
+        if (classification.kind === "conflict")
+            return { kind: "recovery-required", committed: currentSnapshot.generation };
+        if (classification.kind === "finalize") {
+            const currentWithoutPending = current === undefined ? null : stateWithoutPending(current);
+            const candidate = InstalledPluginRecordSchema.parse(record.candidate);
+            const final = record.final === null ? null : InstalledPluginRecordSchema.parse(record.final);
+            // A terminal final state is already settled; only the journal status is
+            // missing. No state rewrite is needed, and no arbitrary replay is possible.
+            if (current?.pendingTransition === undefined && (final === null ? currentWithoutPending === null : sameJson(currentWithoutPending, final))) {
+                if (request.observation === undefined || !projectionMatchesObservation(request.observation, record.candidateProjection, plugin)) {
+                    await markRecovery(scope, record.reference, currentSnapshot.generation, signal);
+                    return { kind: "recovery-required", committed: currentSnapshot.generation };
+                }
+                if (await settle(scope, record.reference, "completed", currentSnapshot.generation, signal))
+                    return { kind: "completed", snapshot: currentSnapshot, observation: request.observation };
+                await markRecovery(scope, record.reference, currentSnapshot.generation, signal);
+                return { kind: "recovery-required", committed: currentSnapshot.generation };
+            }
+            const settled = await mutatePending(scope, plugin, candidate, final, record.reference, currentSnapshot, (snapshot) => replaceTarget(snapshot, plugin, final, dependencies.sha256), signal, final === null).catch(() => undefined);
+            if (settled === undefined || request.observation === undefined || !projectionMatchesObservation(request.observation, record.candidateProjection, plugin) || !(await settle(scope, record.reference, "completed", settled.generation, signal))) {
+                await markRecovery(scope, record.reference, settled?.generation ?? currentSnapshot.generation, signal);
+                return { kind: "recovery-required", committed: settled?.generation ?? currentSnapshot.generation };
+            }
+            return { kind: "completed", snapshot: settled, observation: request.observation };
+        }
+        const candidate = InstalledPluginRecordSchema.parse(record.candidate);
+        const previous = record.previous === null ? null : InstalledPluginRecordSchema.parse(record.previous);
+        if (dependencies.reload.reconcileLocal === undefined || current === undefined) {
+            await markRecovery(scope, record.reference, currentSnapshot.generation, signal);
+            return { kind: "recovery-required", committed: currentSnapshot.generation };
+        }
+        let observation;
+        try {
+            // A fresh process has no successor evidence. Reconcile the conservative
+            // previous target locally while the pending record remains durable, then
+            // publish authority only after exact participant observation.
+            observation = await dependencies.reload.reconcileLocal({
+                scope,
+                plugin,
+                target: previous,
+                expectation: record.previousProjection,
+            }, signal);
+            if (!projectionMatchesObservation(observation, record.previousProjection, plugin))
+                throw new Error("local recovery observation mismatched");
+        }
+        catch {
+            await markRecovery(scope, record.reference, currentSnapshot.generation, signal);
+            return { kind: "recovery-required", committed: currentSnapshot.generation };
+        }
+        const pendingValue = stateWithoutPending(current);
+        const expectedPending = sameJson(pendingValue, candidate)
+            ? candidate
+            : previous !== null && sameJson(pendingValue, previous)
+                ? previous
+                : undefined;
+        if (expectedPending === undefined) {
+            await markRecovery(scope, record.reference, currentSnapshot.generation, signal);
+            return { kind: "recovery-required", committed: currentSnapshot.generation };
+        }
+        const final = await mutatePending(scope, plugin, expectedPending, previous, record.reference, currentSnapshot, (snapshot) => replaceTarget(snapshot, plugin, previous, dependencies.sha256), signal, previous === null).catch(() => undefined);
+        const settlement = final === undefined ? false : await settle(scope, record.reference, "rolled-back", final.generation, signal);
+        if (final === undefined || !settlement) {
+            await markRecovery(scope, record.reference, final?.generation ?? currentSnapshot.generation, signal);
+            return { kind: "recovery-required", committed: final?.generation ?? currentSnapshot.generation };
+        }
+        return { kind: "rolled-back", snapshot: final, observation, failure: { kind: "observation-mismatch", code: "OBSERVATION_MISMATCH" } };
+    }
+    return Object.freeze({ completeCommittedTransition, recoverInterruptedTransition });
+}
+//# sourceMappingURL=lifecycle-transition-reconciler.js.map