@agentplat/mesh-postgres 0.3.0-beta.1 → 0.3.0-beta.4

package/dist/planning-recovery.js

@@ -0,0 +1,706 @@
+import { assertSnapshotHighWatersNotLoweredV1, createCollectivePlanningSnapshotV1, restorePlanningReducerSnapshotV1, validatePlanningReducerSnapshotV1, } from "@agentplat/collective-planning";
+import { computeMeshDurableValueDigest } from "@agentplat/mesh/durability";
+import { canonicalizeMeshJsonBytes } from "@agentplat/mesh-protocol";
+import { defaultPostgresSchema, normalizePostgresIdentifier, quotePostgresIdentifier, } from "@agentplat/postgres";
+export const PLANNING_RECOVERY_DURABILITY_SCHEMA_VERSION = 1;
+export const PLANNING_RECOVERY_DURABILITY_GENESIS_DIGEST = "sha256:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+/** Canonical constructor; it validates the real reducer snapshot before persistence. */
+export async function createPlanningRecoveryDurableStateV1(input) {
+    const value = exactObject(input, ["scope", "generation", "planningSnapshot", "recovery"], "state_input");
+    const scope = normalizeScope(value.scope);
+    const generation = positiveInteger(value.generation, "generation");
+    const planningSnapshot = validatePlanningReducerSnapshotV1(value.planningSnapshot);
+    assertSnapshotScope(scope, planningSnapshot);
+    const recovery = await validatePlanningRecoveryStateV1(value.recovery);
+    const highWaters = deriveHighWaters(planningSnapshot, recovery);
+    const stateDigest = await digest({
+        schemaVersion: 1,
+        scope,
+        generation,
+        planningSnapshot,
+        recovery,
+        highWaters,
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        scope,
+        generation,
+        planningSnapshot,
+        recovery,
+        highWaters,
+        stateDigest,
+    });
+}
+export async function createPlanningRecoveryStateV1(input) {
+    const value = exactObject(input, [
+        "schemaVersion",
+        "assignmentEpochHighWater",
+        "replaySequenceHighWater",
+        "revocationHighWater",
+        "budgetReservationHighWater",
+        "fencingToken",
+    ], "recovery_state_input");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("planning_recovery_schema_version_invalid");
+    const result = {
+        schemaVersion: 1,
+        assignmentEpochHighWater: nonNegativeInteger(value.assignmentEpochHighWater, "assignmentEpochHighWater"),
+        replaySequenceHighWater: nonNegativeInteger(value.replaySequenceHighWater, "replaySequenceHighWater"),
+        revocationHighWater: nonNegativeInteger(value.revocationHighWater, "revocationHighWater"),
+        budgetReservationHighWater: nonNegativeInteger(value.budgetReservationHighWater, "budgetReservationHighWater"),
+        fencingToken: identifier(value.fencingToken, "fencingToken"),
+    };
+    return Object.freeze({
+        ...result,
+        recoveryDigest: await digest(result),
+    });
+}
+export async function validatePlanningRecoveryStateV1(input) {
+    const value = exactObject(input, [
+        "schemaVersion",
+        "assignmentEpochHighWater",
+        "replaySequenceHighWater",
+        "revocationHighWater",
+        "budgetReservationHighWater",
+        "fencingToken",
+        "recoveryDigest",
+    ], "recovery_state");
+    const rebuilt = await createPlanningRecoveryStateV1({
+        schemaVersion: value.schemaVersion,
+        assignmentEpochHighWater: value.assignmentEpochHighWater,
+        replaySequenceHighWater: value.replaySequenceHighWater,
+        revocationHighWater: value.revocationHighWater,
+        budgetReservationHighWater: value.budgetReservationHighWater,
+        fencingToken: value.fencingToken,
+    });
+    if (value.recoveryDigest !== rebuilt.recoveryDigest)
+        throw new TypeError("planning_recovery_recovery_digest_invalid");
+    return rebuilt;
+}
+export async function validatePlanningRecoveryDurableStateV1(input) {
+    const value = exactObject(input, [
+        "schemaVersion",
+        "scope",
+        "generation",
+        "planningSnapshot",
+        "recovery",
+        "highWaters",
+        "stateDigest",
+    ], "state");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("planning_recovery_schema_version_invalid");
+    const rebuilt = await createPlanningRecoveryDurableStateV1({
+        scope: value.scope,
+        generation: value.generation,
+        planningSnapshot: value.planningSnapshot,
+        recovery: value.recovery,
+    });
+    if (!sameJson(value.highWaters, rebuilt.highWaters) ||
+        value.stateDigest !== rebuilt.stateDigest)
+        throw new TypeError("planning_recovery_state_digest_invalid");
+    return rebuilt;
+}
+export async function createPlanningRecoveryDurableEventV1(input) {
+    const value = exactObject(input, [
+        "scope",
+        "sequence",
+        "previousDigest",
+        "stateGeneration",
+        "stateDigest",
+        "event",
+        "occurredAt",
+    ], "event_input");
+    const scope = normalizeScope(value.scope);
+    const event = normalizeEvent(value.event);
+    const result = {
+        schemaVersion: 1,
+        scope,
+        sequence: positiveInteger(value.sequence, "sequence"),
+        previousDigest: digestString(value.previousDigest, "previousDigest"),
+        stateGeneration: positiveInteger(value.stateGeneration, "stateGeneration"),
+        stateDigest: digestString(value.stateDigest, "stateDigest"),
+        ...event,
+        occurredAt: timestamp(value.occurredAt),
+    };
+    return Object.freeze({
+        ...result,
+        digest: await digest(result),
+    });
+}
+export async function verifyPlanningRecoveryDurableJournalV1(input) {
+    const value = exactObject(input, [
+        "entries",
+        "anchorSequence",
+        "anchorDigest",
+        "expectedHeadSequence",
+        "expectedHeadDigest",
+    ], "journal_input", [
+        "anchorSequence",
+        "anchorDigest",
+        "expectedHeadSequence",
+        "expectedHeadDigest",
+    ]);
+    if (!Array.isArray(value.entries) ||
+        (value.anchorSequence === undefined) !== (value.anchorDigest === undefined))
+        throw new TypeError("planning_recovery_journal_invalid");
+    let sequence = value.anchorSequence === undefined
+        ? 0
+        : nonNegativeInteger(value.anchorSequence, "anchorSequence");
+    let head = value.anchorDigest === undefined
+        ? PLANNING_RECOVERY_DURABILITY_GENESIS_DIGEST
+        : digestString(value.anchorDigest, "anchorDigest");
+    let scope;
+    let stateGeneration = 0;
+    for (const raw of value.entries) {
+        const entry = exactObject(raw, [
+            "schemaVersion",
+            "scope",
+            "sequence",
+            "previousDigest",
+            "digest",
+            "stateGeneration",
+            "stateDigest",
+            "eventId",
+            "kind",
+            "logicalTimeMs",
+            "payload",
+            "occurredAt",
+        ], "journal_entry");
+        const entryScope = normalizeScope(entry.scope);
+        const entryGeneration = positiveInteger(entry.stateGeneration, "stateGeneration");
+        if (entry.sequence !== sequence + 1 ||
+            entry.previousDigest !== head ||
+            (scope !== undefined && !sameJson(scope, entryScope)) ||
+            entryGeneration <= stateGeneration)
+            return false;
+        const rebuilt = await createPlanningRecoveryDurableEventV1({
+            scope: entry.scope,
+            sequence: entry.sequence,
+            previousDigest: entry.previousDigest,
+            stateGeneration: entry.stateGeneration,
+            stateDigest: entry.stateDigest,
+            event: {
+                eventId: entry.eventId,
+                kind: entry.kind,
+                logicalTimeMs: entry.logicalTimeMs,
+                payload: entry.payload,
+            },
+            occurredAt: entry.occurredAt,
+        });
+        if (entry.schemaVersion !== 1 || entry.digest !== rebuilt.digest)
+            return false;
+        scope = entryScope;
+        stateGeneration = rebuilt.stateGeneration;
+        sequence = rebuilt.sequence;
+        head = rebuilt.digest;
+    }
+    return ((value.expectedHeadSequence === undefined ||
+        value.expectedHeadSequence === sequence) &&
+        (value.expectedHeadDigest === undefined ||
+            value.expectedHeadDigest === head));
+}
+/** In-memory conformance layer. It deliberately shares all validation with PostgreSQL. */
+export class InMemoryPlanningRecoveryDurableRepositoryV1 {
+    #snapshot;
+    #events = [];
+    scope;
+    constructor(scope) {
+        this.scope = normalizeScope(scope);
+    }
+    async initialize(input) {
+        const state = await scopedState(this.scope, input);
+        if (!this.#snapshot) {
+            this.#snapshot = await makeSnapshot(state, 0, PLANNING_RECOVERY_DURABILITY_GENESIS_DIGEST);
+            return "initialized";
+        }
+        if (this.#snapshot.state.stateDigest !== state.stateDigest)
+            throw new Error("planning_recovery_state_conflict");
+        return "existing";
+    }
+    async read() {
+        if (!this.#snapshot)
+            throw new Error("planning_recovery_state_missing");
+        return clone(this.#snapshot);
+    }
+    async commit(input) {
+        const normalized = await normalizeCommitInput(input);
+        const current = await this.read();
+        const next = await scopedState(this.scope, normalized.nextState);
+        if (normalized.expectedGeneration !== current.state.generation ||
+            normalized.expectedStateDigest !== current.state.stateDigest)
+            return Object.freeze({ committed: false, code: "state_conflict" });
+        if (!canAdvance(current.state, next, normalized.event))
+            return Object.freeze({ committed: false, code: "rollback_rejected" });
+        const event = await createPlanningRecoveryDurableEventV1({
+            scope: this.scope,
+            sequence: current.eventHeadSequence + 1,
+            previousDigest: current.eventHeadDigest,
+            stateGeneration: next.generation,
+            stateDigest: next.stateDigest,
+            event: normalized.event,
+            occurredAt: new Date(0).toISOString(),
+        });
+        this.#events.push(event);
+        this.#snapshot = await makeSnapshot(next, event.sequence, event.digest);
+        return Object.freeze({ committed: true, state: next, event });
+    }
+    async restore(input) {
+        const snapshot = await validateSnapshot(input);
+        assertSameScope(this.scope, snapshot.state.scope);
+        if (!this.#snapshot) {
+            this.#snapshot = snapshot;
+            this.#events = [];
+            return Object.freeze({ restored: true, snapshot: clone(snapshot) });
+        }
+        if (this.#snapshot.snapshotDigest === snapshot.snapshotDigest)
+            return Object.freeze({ restored: false, code: "existing" });
+        return Object.freeze({ restored: false, code: "rollback_rejected" });
+    }
+    async inspectEvents(input = {}) {
+        const after = nonNegativeInteger(input.afterSequence ?? 0, "afterSequence");
+        const limit = positiveInteger(input.limit ?? 100, "limit", 1000);
+        return Object.freeze(this.#events
+            .filter((event) => event.sequence > after)
+            .slice(0, limit)
+            .map(clone));
+    }
+}
+export class PostgresPlanningRecoveryDurableRepositoryV1 {
+    pool;
+    #scope;
+    #prefix;
+    constructor(pool, options) {
+        this.pool = pool;
+        if (!pool || typeof pool.connect !== "function")
+            throw new TypeError("A PostgreSQL pool is required");
+        const values = exactObject(options, [
+            "schema",
+            "tenantId",
+            "policyDomainId",
+            "missionId",
+            "intentRevision",
+            "intentDigest",
+            "policyDigest",
+            "peerId",
+            "peerInstanceId",
+        ], "postgres_options", ["schema"]);
+        this.#scope = normalizeScope({
+            tenantId: values.tenantId,
+            policyDomainId: values.policyDomainId,
+            missionId: values.missionId,
+            intentRevision: values.intentRevision,
+            intentDigest: values.intentDigest,
+            policyDigest: values.policyDigest,
+            peerId: values.peerId,
+            peerInstanceId: values.peerInstanceId,
+        });
+        this.#prefix = `${quotePostgresIdentifier(normalizePostgresIdentifier(values.schema ?? defaultPostgresSchema, "schema"))}.`;
+    }
+    async initialize(input) {
+        const state = await scopedState(this.#scope, input);
+        return this.#transaction(async (client) => {
+            const inserted = await client.query(`INSERT INTO ${this.#prefix}mesh_planning_recovery_states (tenant_id,policy_domain_id,mission_id,intent_revision,intent_digest,policy_digest,peer_id,peer_instance_id,generation,high_water_logical_ms,plan_revision_high_water,fragment_revision_high_water,budget_reservation_high_water,replay_sequence_high_water,assignment_epoch_high_water,revocation_high_water,state_digest,planning_snapshot,recovery_state,event_head_sequence,event_head_digest) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18::jsonb,$19::jsonb,$20,$21) ON CONFLICT DO NOTHING`, rowValues(state, 0, PLANNING_RECOVERY_DURABILITY_GENESIS_DIGEST));
+            if ((inserted.rowCount ?? 0) === 1)
+                return "initialized";
+            if ((await this.#readWith(client)).state.stateDigest !== state.stateDigest)
+                throw new Error("planning_recovery_state_conflict");
+            return "existing";
+        });
+    }
+    async read() {
+        return this.#readWith(this.pool);
+    }
+    async commit(input) {
+        const normalized = await normalizeCommitInput(input);
+        const next = await scopedState(this.#scope, normalized.nextState);
+        return this.#transaction(async (client) => {
+            const current = await this.#readWith(client, true);
+            if (normalized.expectedGeneration !== current.state.generation ||
+                normalized.expectedStateDigest !== current.state.stateDigest)
+                return Object.freeze({
+                    committed: false,
+                    code: "state_conflict",
+                });
+            if (!canAdvance(current.state, next, normalized.event))
+                return Object.freeze({
+                    committed: false,
+                    code: "rollback_rejected",
+                });
+            const event = await createPlanningRecoveryDurableEventV1({
+                scope: this.#scope,
+                sequence: current.eventHeadSequence + 1,
+                previousDigest: current.eventHeadDigest,
+                stateGeneration: next.generation,
+                stateDigest: next.stateDigest,
+                event: normalized.event,
+                occurredAt: new Date().toISOString(),
+            });
+            const updated = await client.query(`UPDATE ${this.#prefix}mesh_planning_recovery_states SET generation=$9,high_water_logical_ms=$10,plan_revision_high_water=$11,fragment_revision_high_water=$12,budget_reservation_high_water=$13,replay_sequence_high_water=$14,assignment_epoch_high_water=$15,revocation_high_water=$16,state_digest=$17,planning_snapshot=$18::jsonb,recovery_state=$19::jsonb,event_head_sequence=$20,event_head_digest=$21,updated_at=transaction_timestamp() WHERE tenant_id=$1 AND policy_domain_id=$2 AND mission_id=$3 AND intent_revision=$4 AND intent_digest=$5 AND policy_digest=$6 AND peer_id=$7 AND peer_instance_id=$8 AND generation=$22 AND state_digest=$23 AND high_water_logical_ms <= $10`, [
+                ...scopeValues(this.#scope),
+                ...stateValues(next),
+                event.sequence,
+                event.digest,
+                normalized.expectedGeneration,
+                normalized.expectedStateDigest,
+            ]);
+            if ((updated.rowCount ?? 0) !== 1)
+                return Object.freeze({
+                    committed: false,
+                    code: "state_conflict",
+                });
+            await client.query(`INSERT INTO ${this.#prefix}mesh_planning_recovery_events (tenant_id,policy_domain_id,mission_id,intent_revision,intent_digest,policy_digest,peer_id,peer_instance_id,sequence,event_id,previous_digest,digest,state_generation,state_digest,logical_time_ms,kind,payload,occurred_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17::jsonb,$18)`, [
+                ...scopeValues(this.#scope),
+                event.sequence,
+                event.eventId,
+                event.previousDigest,
+                event.digest,
+                event.stateGeneration,
+                event.stateDigest,
+                event.logicalTimeMs,
+                event.kind,
+                JSON.stringify(event.payload),
+                event.occurredAt,
+            ]);
+            return Object.freeze({ committed: true, state: next, event });
+        });
+    }
+    async restore(input) {
+        const snapshot = await validateSnapshot(input);
+        assertSameScope(this.#scope, snapshot.state.scope);
+        return this.#transaction(async (client) => {
+            const inserted = await client.query(`INSERT INTO ${this.#prefix}mesh_planning_recovery_states (tenant_id,policy_domain_id,mission_id,intent_revision,intent_digest,policy_digest,peer_id,peer_instance_id,generation,high_water_logical_ms,plan_revision_high_water,fragment_revision_high_water,budget_reservation_high_water,replay_sequence_high_water,assignment_epoch_high_water,revocation_high_water,state_digest,planning_snapshot,recovery_state,event_head_sequence,event_head_digest) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18::jsonb,$19::jsonb,$20,$21) ON CONFLICT DO NOTHING`, rowValues(snapshot.state, snapshot.eventHeadSequence, snapshot.eventHeadDigest));
+            if ((inserted.rowCount ?? 0) === 1)
+                return Object.freeze({ restored: true, snapshot });
+            const current = await this.#readWith(client, true);
+            if (current.snapshotDigest === snapshot.snapshotDigest)
+                return Object.freeze({ restored: false, code: "existing" });
+            return Object.freeze({
+                restored: false,
+                code: "rollback_rejected",
+            });
+        });
+    }
+    async inspectEvents(input = {}) {
+        const after = nonNegativeInteger(input.afterSequence ?? 0, "afterSequence");
+        const limit = positiveInteger(input.limit ?? 100, "limit", 1000);
+        const result = await this.pool.query(`SELECT * FROM ${this.#prefix}mesh_planning_recovery_events WHERE tenant_id=$1 AND policy_domain_id=$2 AND mission_id=$3 AND intent_revision=$4 AND intent_digest=$5 AND policy_digest=$6 AND peer_id=$7 AND peer_instance_id=$8 AND sequence > $9 ORDER BY sequence LIMIT $10`, [...scopeValues(this.#scope), after, limit]);
+        return Object.freeze(await Promise.all(result.rows.map((row) => mapEvent(row, this.#scope))));
+    }
+    async #readWith(queryable, locked = false) {
+        const result = await queryable.query(`SELECT * FROM ${this.#prefix}mesh_planning_recovery_states WHERE tenant_id=$1 AND policy_domain_id=$2 AND mission_id=$3 AND intent_revision=$4 AND intent_digest=$5 AND policy_digest=$6 AND peer_id=$7 AND peer_instance_id=$8${locked ? " FOR UPDATE" : ""}`, scopeValues(this.#scope));
+        if (!result.rows[0])
+            throw new Error("planning_recovery_state_missing");
+        return mapSnapshot(result.rows[0], this.#scope);
+    }
+    async #transaction(work) {
+        const client = await this.pool.connect();
+        try {
+            await client.query("BEGIN");
+            const result = await work(client);
+            await client.query("COMMIT");
+            return result;
+        }
+        catch (error) {
+            await client.query("ROLLBACK").catch(() => undefined);
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+async function mapSnapshot(row, scope) {
+    const state = await createPlanningRecoveryDurableStateV1({
+        scope,
+        generation: numberValue(row.generation, "generation"),
+        planningSnapshot: row.planning_snapshot,
+        recovery: row.recovery_state,
+    });
+    if (row.state_digest !== state.stateDigest ||
+        !sameJson(rowHighWaters(row), state.highWaters))
+        throw new Error("planning_recovery_state_corrupt");
+    return makeSnapshot(state, nonNegativeInteger(numberValue(row.event_head_sequence, "eventHeadSequence"), "eventHeadSequence"), digestString(row.event_head_digest, "eventHeadDigest"));
+}
+async function mapEvent(row, scope) {
+    const event = await createPlanningRecoveryDurableEventV1({
+        scope,
+        sequence: numberValue(row.sequence, "sequence"),
+        previousDigest: String(row.previous_digest),
+        stateGeneration: numberValue(row.state_generation, "stateGeneration"),
+        stateDigest: String(row.state_digest),
+        event: {
+            eventId: String(row.event_id),
+            kind: String(row.kind),
+            logicalTimeMs: numberValue(row.logical_time_ms, "logicalTimeMs"),
+            payload: row.payload,
+        },
+        occurredAt: new Date(String(row.occurred_at)).toISOString(),
+    });
+    if (event.digest !== row.digest)
+        throw new Error("planning_recovery_event_corrupt");
+    return event;
+}
+async function makeSnapshot(state, eventHeadSequence, eventHeadDigest) {
+    const snapshot = {
+        schemaVersion: 1,
+        state,
+        eventHeadSequence: nonNegativeInteger(eventHeadSequence, "eventHeadSequence"),
+        eventHeadDigest: digestString(eventHeadDigest, "eventHeadDigest"),
+    };
+    return Object.freeze({
+        ...snapshot,
+        snapshotDigest: await digest(snapshot),
+    });
+}
+async function validateSnapshot(input) {
+    const value = exactObject(input, [
+        "schemaVersion",
+        "state",
+        "eventHeadSequence",
+        "eventHeadDigest",
+        "snapshotDigest",
+    ], "snapshot");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("planning_recovery_snapshot_invalid");
+    const snapshot = await makeSnapshot(await validatePlanningRecoveryDurableStateV1(value.state), value.eventHeadSequence, value.eventHeadDigest);
+    if (value.snapshotDigest !== snapshot.snapshotDigest)
+        throw new TypeError("planning_recovery_snapshot_digest_invalid");
+    return snapshot;
+}
+async function scopedState(scope, input) {
+    const state = await validatePlanningRecoveryDurableStateV1(input);
+    assertSameScope(scope, state.scope);
+    return state;
+}
+async function normalizeCommitInput(input) {
+    const value = exactObject(input, ["expectedGeneration", "expectedStateDigest", "nextState", "event"], "commit_input");
+    return Object.freeze({
+        expectedGeneration: positiveInteger(value.expectedGeneration, "expectedGeneration"),
+        expectedStateDigest: digestString(value.expectedStateDigest, "expectedStateDigest"),
+        nextState: await validatePlanningRecoveryDurableStateV1(value.nextState),
+        event: normalizeEvent(value.event),
+    });
+}
+function canAdvance(previous, next, event) {
+    if (next.generation !== previous.generation + 1 ||
+        event.logicalTimeMs < previous.highWaters.logicalTimeMs)
+        return false;
+    try {
+        restorePlanningReducerSnapshotV1(previous.planningSnapshot.state, next.planningSnapshot);
+        assertSnapshotHighWatersNotLoweredV1(toCollective(previous.planningSnapshot), toCollective(next.planningSnapshot));
+    }
+    catch {
+        return false;
+    }
+    return (highWatersNotLowered(previous.highWaters, next.highWaters) &&
+        recoveryCanAdvance(previous.recovery, next.recovery));
+}
+function toCollective(snapshot) {
+    const state = snapshot.state;
+    return createCollectivePlanningSnapshotV1({
+        format: "agentplat.collective-planning.snapshot",
+        formatVersion: 1,
+        schemaVersion: 1,
+        snapshotId: snapshot.snapshotId,
+        tenantId: state.tenantId,
+        policyDomainId: state.policyDomainId,
+        peerId: state.peerId,
+        peerInstanceId: state.peerInstanceId,
+        missionIntent: state.missionIntent,
+        selectionPolicy: state.selectionPolicy,
+        planView: state.planView,
+        domainHighWaters: state.recordHighWaters,
+    });
+}
+function highWatersNotLowered(a, b) {
+    return Object.keys(a).every((key) => b[key] >= a[key]);
+}
+function recoveryCanAdvance(previous, next) {
+    if (next.assignmentEpochHighWater === previous.assignmentEpochHighWater)
+        return next.fencingToken === previous.fencingToken;
+    return (next.assignmentEpochHighWater === previous.assignmentEpochHighWater + 1 &&
+        next.fencingToken !== previous.fencingToken);
+}
+function deriveHighWaters(snapshot, recovery) {
+    const state = snapshot.state;
+    const fragments = state.planView.fragments;
+    const budget = state.planView.budgetReservations.reduce((sum, item) => sum + item.units, 0);
+    if (recovery.budgetReservationHighWater < budget)
+        throw new TypeError("planning_recovery_budget_high_water_invalid");
+    return Object.freeze({
+        logicalTimeMs: state.planView.logicalTimeHighWaterMs,
+        intentRevision: state.missionIntent.revision,
+        planRevision: state.planView.revision,
+        fragmentRevision: fragments.reduce((max, item) => Math.max(max, item.fragmentRevision), 0),
+        budgetReservationUnits: recovery.budgetReservationHighWater,
+        replaySequence: recovery.replaySequenceHighWater,
+        assignmentEpoch: recovery.assignmentEpochHighWater,
+        revocation: recovery.revocationHighWater,
+    });
+}
+function assertSnapshotScope(scope, snapshot) {
+    const state = snapshot.state;
+    if (scope.tenantId !== state.tenantId ||
+        scope.policyDomainId !== state.policyDomainId ||
+        scope.missionId !== state.missionIntent.missionIntentId ||
+        scope.intentRevision !== state.missionIntent.revision ||
+        scope.intentDigest !== state.missionIntent.intentDigest ||
+        scope.policyDigest !== state.selectionPolicy.policyDigest ||
+        scope.peerId !== state.peerId ||
+        scope.peerInstanceId !== state.peerInstanceId)
+        throw new Error("planning_recovery_scope_mismatch");
+}
+function normalizeScope(input) {
+    const value = exactObject(input, [
+        "tenantId",
+        "policyDomainId",
+        "missionId",
+        "intentRevision",
+        "intentDigest",
+        "policyDigest",
+        "peerId",
+        "peerInstanceId",
+    ], "scope");
+    return Object.freeze({
+        tenantId: identifier(value.tenantId, "tenantId"),
+        policyDomainId: identifier(value.policyDomainId, "policyDomainId"),
+        missionId: identifier(value.missionId, "missionId"),
+        intentRevision: positiveInteger(value.intentRevision, "intentRevision"),
+        intentDigest: planningDigest(value.intentDigest, "intentDigest"),
+        policyDigest: planningDigest(value.policyDigest, "policyDigest"),
+        peerId: identifier(value.peerId, "peerId"),
+        peerInstanceId: identifier(value.peerInstanceId, "peerInstanceId"),
+    });
+}
+function normalizeEvent(input) {
+    const value = exactObject(input, ["eventId", "kind", "logicalTimeMs", "payload"], "event");
+    if (!canonicalizeMeshJsonBytes(value.payload).ok)
+        throw new TypeError("planning_recovery_payload_invalid");
+    return Object.freeze({
+        eventId: identifier(value.eventId, "eventId"),
+        kind: identifier(value.kind, "kind"),
+        logicalTimeMs: nonNegativeInteger(value.logicalTimeMs, "logicalTimeMs"),
+        payload: clone(value.payload),
+    });
+}
+function exactObject(input, keys, name, optional = []) {
+    if (!input ||
+        typeof input !== "object" ||
+        Object.getPrototypeOf(input) !== Object.prototype ||
+        Object.getOwnPropertySymbols(input).length)
+        throw new TypeError(`planning_recovery_${name}_invalid`);
+    const names = Object.getOwnPropertyNames(input);
+    if (names.some((key) => !keys.includes(key)) ||
+        keys.some((key) => !optional.includes(key) && !names.includes(key)))
+        throw new TypeError(`planning_recovery_${name}_keys_invalid`);
+    const result = {};
+    for (const key of names) {
+        const descriptor = Object.getOwnPropertyDescriptor(input, key);
+        if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
+            throw new TypeError(`planning_recovery_${name}_accessor_invalid`);
+        result[key] = descriptor.value;
+    }
+    return result;
+}
+function assertSameScope(a, b) {
+    if (!sameJson(a, b))
+        throw new Error("planning_recovery_scope_mismatch");
+}
+function scopeValues(scope) {
+    return [
+        scope.tenantId,
+        scope.policyDomainId,
+        scope.missionId,
+        scope.intentRevision,
+        scope.intentDigest,
+        scope.policyDigest,
+        scope.peerId,
+        scope.peerInstanceId,
+    ];
+}
+function stateValues(state) {
+    const h = state.highWaters;
+    return [
+        state.generation,
+        h.logicalTimeMs,
+        h.planRevision,
+        h.fragmentRevision,
+        h.budgetReservationUnits,
+        h.replaySequence,
+        h.assignmentEpoch,
+        h.revocation,
+        state.stateDigest,
+        JSON.stringify(state.planningSnapshot),
+        JSON.stringify(state.recovery),
+    ];
+}
+function rowValues(state, sequence, digestValue) {
+    return [
+        ...scopeValues(state.scope),
+        ...stateValues(state),
+        sequence,
+        digestValue,
+    ];
+}
+function rowHighWaters(row) {
+    return {
+        logicalTimeMs: numberValue(row.high_water_logical_ms, "logicalTimeMs"),
+        intentRevision: numberValue(row.intent_revision, "intentRevision"),
+        planRevision: numberValue(row.plan_revision_high_water, "planRevision"),
+        fragmentRevision: numberValue(row.fragment_revision_high_water, "fragmentRevision"),
+        budgetReservationUnits: numberValue(row.budget_reservation_high_water, "budgetReservationUnits"),
+        replaySequence: numberValue(row.replay_sequence_high_water, "replaySequence"),
+        assignmentEpoch: numberValue(row.assignment_epoch_high_water, "assignmentEpoch"),
+        revocation: numberValue(row.revocation_high_water, "revocation"),
+    };
+}
+async function digest(value) {
+    return computeMeshDurableValueDigest(value);
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function sameJson(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function identifier(value, name) {
+    if (typeof value !== "string" ||
+        value.length < 1 ||
+        value.length > 256 ||
+        /[\u0000-\u001f\u007f]/u.test(value))
+        throw new TypeError(`planning_recovery_${name}_invalid`);
+    return value;
+}
+function digestString(value, name) {
+    if (typeof value !== "string" || !/^sha256:[A-Za-z0-9_-]{43}$/u.test(value))
+        throw new TypeError(`planning_recovery_${name}_invalid`);
+    return value;
+}
+function planningDigest(value, name) {
+    if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(value))
+        throw new TypeError(`planning_recovery_${name}_invalid`);
+    return value;
+}
+function positiveInteger(value, name, max = Number.MAX_SAFE_INTEGER) {
+    if (!Number.isSafeInteger(value) ||
+        value < 1 ||
+        value > max)
+        throw new RangeError(`planning_recovery_${name}_invalid`);
+    return value;
+}
+function nonNegativeInteger(value, name, max = Number.MAX_SAFE_INTEGER) {
+    if (!Number.isSafeInteger(value) ||
+        value < 0 ||
+        value > max)
+        throw new RangeError(`planning_recovery_${name}_invalid`);
+    return value;
+}
+function numberValue(value, name) {
+    return nonNegativeInteger(typeof value === "number" ? value : Number(value), name);
+}
+function timestamp(value) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        throw new TypeError("planning_recovery_timestamp_invalid");
+    return new Date(value).toISOString();
+}
+//# sourceMappingURL=planning-recovery.js.map