@zhin.js/agent 1.1.31 → 1.1.32

package/lib/portfolio/portfolio-admission.js

@@ -1,1080 +0,0 @@
-import { PortfolioSequenceConflictError, parsePortfolioCapacityRequest, parsePortfolioPolicySnapshot, parsePortfolioProjectPolicy, parsePortfolioResourceBundle, } from './portfolio-journal.js';
-import { compareCanonicalWorkroomText, canonicalWorkroomJson, deepFreezeWorkroomValue as deepFreeze, digestCanonicalWorkroomValue as digest, } from '../workroom/canonical-value.js';
-const CAPACITY_HOLDING = new Set([
-    'offered', 'consumed', 'reclaim_requested',
-]);
-const BUDGET_HOLDING = new Set([
-    'offered', 'consumed', 'reclaim_requested', 'usage_pending', 'usage_unknown',
-]);
-const LANE_ORDER = {
-    urgent: 0, high: 1, normal: 2, low: 3,
-};
-/** Journal-backed Portfolio resource authority. It never writes Workroom facts. */
-export class PortfolioAdmissionApplication {
-    options;
-    #maxCasAttempts;
-    constructor(options) {
-        this.options = options;
-        this.#maxCasAttempts = options.maxCasAttempts ?? 3;
-    }
-    async read() {
-        return replayPortfolioAdmission(this.options.portfolioId, await this.options.repository.read(this.options.portfolioId));
-    }
-    async pinPolicy(policy, governance) {
-        const canonical = parsePortfolioPolicySnapshot(policy);
-        assertGovernance(governance, canonical.digest, 0);
-        await this.#commit(state => {
-            if (state.policy) {
-                if (state.policy.digest === canonical.digest)
-                    return [];
-                throw new Error('Portfolio Policy is already pinned');
-            }
-            return [this.#draft('portfolio.policy_pinned', canonical.digest, state.now, {
-                    policy: canonical,
-                    governance,
-                })];
-        });
-    }
-    async updateProjectPolicy(policy, governance) {
-        await this.updateProjectPolicies([policy], { [policy.projectId]: governance });
-    }
-    async updateProjectPolicies(policies, governance) {
-        const canonical = policies.map(parsePortfolioProjectPolicy)
-            .sort((left, right) => compareCanonicalWorkroomText(left.projectId, right.projectId));
-        if (canonical.length === 0 || new Set(canonical.map(policy => policy.projectId)).size !== canonical.length) {
-            throw new Error('Portfolio Project Policy atomic batch is empty or duplicated');
-        }
-        await this.#commit(state => {
-            const portfolio = requirePolicy(state);
-            let previousBudget = 0;
-            let candidateBudget = 0;
-            for (const candidate of canonical) {
-                const previous = portfolio.projects[candidate.projectId];
-                if (!previous || candidate.revision !== previous.revision + 1) {
-                    throw new Error('Portfolio Project Policy revision is stale');
-                }
-                previousBudget += previous.hardBudgetMicros;
-                candidateBudget += candidate.hardBudgetMicros;
-                assertGovernance(governance[candidate.projectId], digest(candidate), previous.revision);
-            }
-            if (previousBudget !== candidateBudget) {
-                throw new Error('Portfolio Project Policy budget transfer must conserve its exact batch total');
-            }
-            return canonical.map(candidate => this.#draft('project.policy_updated', `${candidate.projectId}:${candidate.revision}`, state.now, { policy: candidate, governance: governance[candidate.projectId] }));
-        });
-    }
-    async setPriorityOverride(override, governance) {
-        await this.#commit(state => {
-            const policy = requirePolicy(state);
-            const request = requireRequest(state, override.requestId).request;
-            const project = policy.projects[override.projectId];
-            if (!project || request.projectId !== override.projectId
-                || request.payloadDigest !== override.requestPayloadDigest
-                || override.policyRevision !== project.revision
-                || override.expiresAt <= state.now) {
-                throw new Error('Portfolio Priority Override exact request/policy scope is stale');
-            }
-            assertGovernance(governance, digest(override), project.revision);
-            const existing = state.overrides[override.overrideId];
-            if (existing) {
-                if (canonicalWorkroomJson(existing) !== canonicalWorkroomJson(override)) {
-                    throw new Error('Portfolio Priority Override identity conflict');
-                }
-                return [];
-            }
-            return [this.#draft('priority.override_set', override.overrideId, state.now, {
-                    override,
-                    governance,
-                })];
-        });
-    }
-    async submit(request, bundleAuthority) {
-        const canonical = parsePortfolioCapacityRequest(request);
-        await this.#commit(state => {
-            const policy = requirePolicy(state);
-            const project = policy.projects[canonical.projectId];
-            if (!project || project.revision !== canonical.projectPolicyRevision) {
-                throw new Error('Capacity Request Project Policy revision is stale');
-            }
-            assertBundleAuthority(canonical, bundleAuthority, policy);
-            const existing = state.requests[canonical.requestId];
-            if (existing) {
-                if (canonicalWorkroomJson(existing.request) !== canonicalWorkroomJson(canonical)
-                    || canonicalWorkroomJson(existing.bundleAuthority) !== canonicalWorkroomJson(bundleAuthority)) {
-                    throw new Error('Capacity Request identity conflict');
-                }
-                return [];
-            }
-            const outstanding = Object.values(state.requests).filter(item => item.request.projectId === canonical.projectId
-                && portfolioRequestStatus(state, item.request.requestId) !== 'settled').length;
-            if (outstanding >= project.maxOutstandingRequests) {
-                throw new Error('Capacity Request exceeds Project outstanding cap');
-            }
-            return [this.#draft('capacity.requested', canonical.requestId, state.now, {
-                    request: canonical,
-                    bundleAuthority,
-                })];
-        });
-    }
-    async decideAdmission() {
-        let offered = null;
-        await this.#commit(state => {
-            offered = null;
-            const decision = decideAdmission(state);
-            if (!decision)
-                return [];
-            if ('reclaimId' in decision) {
-                return [this.#draft('capacity.reclaim_requested', decision.reclaimId, state.now, {
-                        reclaim: decision,
-                    })];
-            }
-            offered = decision;
-            return [this.#draft('capacity.grant_offered', decision.grantId, state.now, {
-                    grant: decision,
-                })];
-        });
-        return offered;
-    }
-    async consume(input, authority) {
-        await this.#commit(state => {
-            const policy = requirePolicy(state);
-            const grant = requireGrant(state, input.grantId);
-            if (grant.status === 'consumed' && grant.projectId === input.projectId
-                && grant.fence === input.fence && grant.assignmentRef === input.assignmentRef) {
-                assertKernelAuthority(this.options.portfolioId, grant, authority, {
-                    action: 'consume', assignmentRef: input.assignmentRef,
-                });
-                return [];
-            }
-            if (grant.projectId !== input.projectId || grant.fence !== input.fence
-                || grant.status !== 'offered' || grant.offerExpiresAt <= state.now) {
-                throw new Error('Capacity Grant consume scope/fence/offer is stale');
-            }
-            assertKernelAuthority(this.options.portfolioId, grant, authority, {
-                action: 'consume', assignmentRef: input.assignmentRef,
-            });
-            return [this.#draft('capacity.grant_consumed', `${grant.grantId}:${grant.fence}`, state.now, {
-                    grantId: grant.grantId,
-                    projectId: grant.projectId,
-                    fence: grant.fence,
-                    assignmentRef: input.assignmentRef,
-                    consumedAt: state.now,
-                    leaseExpiresAt: state.now + policy.leaseTtlTicks,
-                    maxLeaseExpiresAt: state.now + policy.maxLeaseQuantumTicks,
-                    authority,
-                })];
-        });
-    }
-    async failAssignment(input, authority) {
-        await this.#commit(state => {
-            const grant = requireGrant(state, input.grantId);
-            const action = {
-                action: 'assignment_failed',
-                assignmentRef: input.assignmentRef,
-                failureReason: input.reason,
-                kernelSequence: input.kernelSequence,
-                kernelFactDigest: input.kernelFactDigest,
-            };
-            if (grant.status === 'assignment_failed' && grant.projectId === input.projectId
-                && grant.fence === input.fence && grant.assignmentRef === input.assignmentRef) {
-                assertKernelAuthority(this.options.portfolioId, grant, authority, action);
-                return [];
-            }
-            if (grant.status !== 'consumed' || grant.projectId !== input.projectId
-                || grant.fence !== input.fence || grant.assignmentRef !== input.assignmentRef) {
-                throw new Error('Capacity Grant Assignment failure scope/fence/status is stale');
-            }
-            assertKernelAuthority(this.options.portfolioId, grant, authority, action);
-            return [this.#draft('capacity.grant_assignment_failed', `${grant.grantId}:${grant.fence}:${input.assignmentRef}`, state.now, {
-                    ...input, failedAt: state.now, authority,
-                })];
-        });
-    }
-    async renewLease(input, authority) {
-        await this.#commit(state => {
-            const policy = requirePolicy(state);
-            const grant = requireGrant(state, input.grantId);
-            const action = renewalAuthorityAction(state, policy, input.assignmentRef, input.heartbeatSequence);
-            if (grant.status === 'consumed' && grant.projectId === input.projectId
-                && grant.fence === input.fence && grant.assignmentRef === input.assignmentRef
-                && grant.lastHeartbeatSequence === input.heartbeatSequence) {
-                assertKernelAuthority(this.options.portfolioId, grant, authority, action);
-                return [];
-            }
-            if (grant.status !== 'consumed' || grant.projectId !== input.projectId
-                || grant.fence !== input.fence || grant.assignmentRef !== input.assignmentRef
-                || grant.leaseExpiresAt === undefined || grant.leaseExpiresAt <= state.now
-                || grant.maxLeaseExpiresAt === undefined) {
-                throw new Error('Capacity Grant Lease renewal scope/fence/status is stale');
-            }
-            if (state.clockSequence < 0 || !state.clockDigest) {
-                throw new Error('Capacity Grant Lease renewal requires a current Portfolio clock fact');
-            }
-            const previousHeartbeatSequence = grant.lastHeartbeatSequence ?? 0;
-            const previousHeartbeatAt = grant.lastHeartbeatAt ?? grant.consumedAt;
-            const renewalCount = grant.renewalCount ?? 0;
-            if (input.heartbeatSequence !== previousHeartbeatSequence + 1
-                || state.now < previousHeartbeatAt + policy.leaseHeartbeatTicks) {
-                throw new Error('Capacity Grant Lease heartbeat sequence/time is stale');
-            }
-            if (renewalCount >= policy.maxLeaseRenewals) {
-                throw new Error('Capacity Grant Lease renewal limit is exhausted');
-            }
-            const pendingReclaim = Object.values(state.reclaims).some(reclaim => reclaim.status === 'pending');
-            const starvedReservation = Object.values(state.requests).some(item => portfolioRequestStatus(state, item.request.requestId) === 'pending'
-                && state.now >= item.request.starvationAt);
-            if (pendingReclaim || starvedReservation) {
-                throw new Error('Capacity Grant Lease renewal is reserved for reclaim/starvation');
-            }
-            const leaseExpiresAt = Math.min(state.now + policy.leaseTtlTicks, grant.maxLeaseExpiresAt);
-            if (leaseExpiresAt <= grant.leaseExpiresAt) {
-                throw new Error('Capacity Grant Lease max quantum is exhausted');
-            }
-            assertKernelAuthority(this.options.portfolioId, grant, authority, action);
-            return [this.#draft('capacity.grant_lease_renewed', `${grant.grantId}:${grant.fence}:${input.heartbeatSequence}`, state.now, {
-                    grantId: grant.grantId,
-                    projectId: grant.projectId,
-                    fence: grant.fence,
-                    assignmentRef: input.assignmentRef,
-                    heartbeatSequence: input.heartbeatSequence,
-                    renewedAt: state.now,
-                    previousLeaseExpiresAt: grant.leaseExpiresAt,
-                    leaseExpiresAt,
-                    maxLeaseExpiresAt: grant.maxLeaseExpiresAt,
-                    policyDigest: policy.digest,
-                    clockSequence: state.clockSequence,
-                    clockDigest: state.clockDigest,
-                    usageSettlementCursor: state.usageSettlementCursor,
-                    authority,
-                })];
-        });
-    }
-    async acknowledgeReclaim(input, authority) {
-        await this.#commit(state => {
-            const reclaim = requireReclaim(state, input.reclaimId);
-            const grant = requireGrant(state, reclaim.grantId);
-            if (reclaim.status === input.outcome && reclaim.projectId === input.projectId
-                && grant.fence === input.fence) {
-                if (reclaim.checkpointRef !== input.checkpointRef
-                    || reclaim.checkpointDigest !== input.checkpointDigest) {
-                    throw new Error('Capacity Reclaim checkpoint idempotency drift');
-                }
-                assertKernelAuthority(this.options.portfolioId, grant, authority, {
-                    action: 'reclaim_acknowledge', assignmentRef: grant.assignmentRef,
-                    reclaimId: reclaim.reclaimId, outcome: input.outcome,
-                    ...(input.checkpointRef === undefined ? {} : { checkpointRef: input.checkpointRef }),
-                    ...(input.checkpointDigest === undefined ? {} : { checkpointDigest: input.checkpointDigest }),
-                });
-                return [];
-            }
-            if (reclaim.status !== 'pending' || reclaim.projectId !== input.projectId
-                || grant.fence !== input.fence || grant.status !== 'reclaim_requested') {
-                throw new Error('Capacity Reclaim acknowledgement scope/fence is stale');
-            }
-            if (input.outcome === 'checkpointed' && (!input.checkpointRef || !input.checkpointDigest)) {
-                throw new Error('Checkpointed Capacity Reclaim requires checkpoint ref/digest');
-            }
-            if (input.outcome === 'declined' && (input.checkpointRef || input.checkpointDigest)) {
-                throw new Error('Declined Capacity Reclaim cannot claim a checkpoint');
-            }
-            assertKernelAuthority(this.options.portfolioId, grant, authority, {
-                action: 'reclaim_acknowledge', assignmentRef: grant.assignmentRef,
-                reclaimId: reclaim.reclaimId, outcome: input.outcome,
-                ...(input.checkpointRef === undefined ? {} : { checkpointRef: input.checkpointRef }),
-                ...(input.checkpointDigest === undefined ? {} : { checkpointDigest: input.checkpointDigest }),
-            });
-            return [this.#draft('capacity.reclaim_acknowledged', reclaim.reclaimId, state.now, {
-                    reclaimId: reclaim.reclaimId,
-                    grantId: grant.grantId,
-                    projectId: grant.projectId,
-                    fence: grant.fence,
-                    outcome: input.outcome,
-                    ...(input.checkpointRef === undefined ? {} : { checkpointRef: input.checkpointRef }),
-                    ...(input.checkpointDigest === undefined ? {} : { checkpointDigest: input.checkpointDigest }),
-                    authority,
-                })];
-        });
-    }
-    async settleUsage(authority) {
-        await this.#commit(state => {
-            const grant = requireGrant(state, authority.grantId);
-            assertUsageAuthority(this.options.portfolioId, grant, authority);
-            if (grant.fence !== authority.fence
-                || !['consumed', 'reclaim_requested', 'usage_pending', 'usage_unknown'].includes(grant.status)) {
-                if (grant.status === 'settled'
-                    && grant.actualCostMicros === authority.actualCostMicros
-                    && grant.settlementRef === authority.settlementRef
-                    && grant.receiptId === authority.receiptId
-                    && grant.receiptDigest === authority.receiptDigest
-                    && grant.authenticatedBy === authority.authenticatedBy)
-                    return [];
-                throw new Error('Capacity Usage Receipt scope/fence/status is stale');
-            }
-            if (!Number.isSafeInteger(authority.actualCostMicros) || authority.actualCostMicros < 0) {
-                throw new Error('Capacity Usage actual cost is invalid');
-            }
-            return [this.#draft('capacity.usage_settled', authority.receiptId, state.now, {
-                    receiptId: authority.receiptId,
-                    grantId: authority.grantId,
-                    fence: authority.fence,
-                    actualCostMicros: authority.actualCostMicros,
-                    settlementRef: authority.settlementRef,
-                    authenticatedBy: authority.authenticatedBy,
-                    authority,
-                })];
-        });
-    }
-    async advanceClock(authority) {
-        await this.#commit(state => {
-            assertClockAuthority(this.options.portfolioId, authority);
-            const { now } = authority;
-            if (!Number.isSafeInteger(now) || now <= state.now)
-                throw new Error('Portfolio clock must advance');
-            const drafts = [this.#draft('clock.advanced', String(now), now, { now, authority })];
-            for (const grant of Object.values(state.grants)) {
-                if (grant.status === 'offered' && grant.offerExpiresAt <= now) {
-                    drafts.push(this.#draft('capacity.grant_expired', `${grant.grantId}:${grant.fence}`, now, {
-                        grantId: grant.grantId, fence: grant.fence,
-                    }));
-                }
-                else if ((grant.status === 'consumed' || grant.status === 'reclaim_requested')
-                    && grant.leaseExpiresAt !== undefined && grant.leaseExpiresAt <= now) {
-                    drafts.push(this.#draft('capacity.grant_lease_lost', `${grant.grantId}:${grant.fence}`, now, {
-                        grantId: grant.grantId, fence: grant.fence, usage: 'unknown',
-                    }));
-                }
-            }
-            for (const reclaim of Object.values(state.reclaims)) {
-                if (reclaim.status === 'pending' && reclaim.deadline <= now) {
-                    const grant = requireGrant(state, reclaim.grantId);
-                    drafts.push(this.#draft('capacity.reclaim_timed_out', reclaim.reclaimId, now, {
-                        reclaimId: reclaim.reclaimId, grantId: grant.grantId, fence: grant.fence,
-                    }));
-                }
-            }
-            return drafts;
-        });
-    }
-    async normalizeService(divisor) {
-        await this.#commit(state => {
-            if (!Number.isSafeInteger(divisor) || divisor < 2) {
-                throw new Error('Portfolio service normalization divisor must be at least two');
-            }
-            const projectService = {};
-            for (const projectId of Object.keys(requirePolicy(state).projects).sort()) {
-                projectService[projectId] = Math.floor(dominantService(state, projectId) / divisor);
-            }
-            const normalizationId = `normalization:${state.sequence + 1}`;
-            return [this.#draft('service.normalized', normalizationId, state.now, {
-                    normalization: { normalizationId, divisor, projectService },
-                })];
-        });
-    }
-    async #commit(decide) {
-        for (let attempt = 1; attempt <= this.#maxCasAttempts; attempt += 1) {
-            const state = await this.read();
-            const drafts = decide(state);
-            if (drafts.length === 0)
-                return;
-            try {
-                await this.options.repository.append(this.options.portfolioId, state.sequence, drafts);
-                return;
-            }
-            catch (error) {
-                if (!(error instanceof PortfolioSequenceConflictError) || attempt === this.#maxCasAttempts)
-                    throw error;
-            }
-        }
-        throw new Error('Portfolio admission CAS retry loop exhausted');
-    }
-    #draft(type, identity, occurredAt, payload) {
-        return {
-            eventId: this.options.ids.eventId(type, identity),
-            occurredAt,
-            type,
-            payload,
-        };
-    }
-}
-export function replayPortfolioAdmission(portfolioId, facts) {
-    let state = deepFreeze({
-        portfolioId, sequence: -1, now: 0,
-        clockSequence: -1, usageSettlementCursor: -1,
-        requests: {}, grants: {}, reclaims: {}, overrides: {},
-        normalizedService: {}, normalizedAtSequence: -1,
-    });
-    for (const [index, fact] of facts.entries()) {
-        if (fact.portfolioId !== portfolioId || fact.sequence !== index) {
-            throw new Error('Portfolio Journal replay sequence/scope drift');
-        }
-        state = evolve(state, fact);
-    }
-    return deepFreeze(state);
-}
-export function portfolioRequestStatus(state, requestId) {
-    requireRequest(state, requestId);
-    const highestFenceGrant = Object.values(state.grants)
-        .filter(grant => grant.requestId === requestId)
-        .sort((left, right) => right.fence - left.fence)[0];
-    if (!highestFenceGrant || highestFenceGrant.status === 'expired'
-        || highestFenceGrant.status === 'assignment_failed')
-        return 'pending';
-    if (highestFenceGrant.status === 'settled')
-        return 'settled';
-    if (highestFenceGrant.status === 'usage_pending' || highestFenceGrant.status === 'usage_unknown') {
-        return 'usage_blocked';
-    }
-    return 'granted';
-}
-export function portfolioProjectBudget(state, projectId) {
-    const project = requirePolicy(state).projects[projectId];
-    if (!project)
-        throw new Error(`Unknown Portfolio Project ${projectId}`);
-    const grants = Object.values(state.grants).filter(grant => grant.projectId === projectId);
-    const spentMicros = grants.filter(grant => grant.status === 'settled')
-        .reduce((sum, grant) => sum + (grant.actualCostMicros ?? 0), 0);
-    const reservedMicros = grants.filter(grant => BUDGET_HOLDING.has(grant.status))
-        .reduce((sum, grant) => sum + grant.reservedCostMicros, 0);
-    return deepFreeze({
-        limitMicros: project.hardBudgetMicros,
-        spentMicros,
-        reservedMicros,
-        availableMicros: project.hardBudgetMicros - spentMicros - reservedMicros,
-    });
-}
-export function portfolioRequestBlockers(state, requestId) {
-    return Object.freeze(blockers(state, requireRequest(state, requestId)));
-}
-function evolve(state, fact) {
-    let next = { ...state, sequence: fact.sequence };
-    switch (fact.type) {
-        case 'portfolio.policy_pinned':
-            if (state.policy)
-                throw new Error('Portfolio Policy fact is duplicated');
-            assertGovernance(fact.payload.governance, fact.payload.policy.digest, 0);
-            return { ...next, policy: fact.payload.policy };
-        case 'project.policy_updated': {
-            const current = requirePolicy(state);
-            const previous = current.projects[fact.payload.policy.projectId];
-            if (!previous || fact.payload.policy.revision !== previous.revision + 1) {
-                throw new Error('Persisted Portfolio Project Policy revision drift');
-            }
-            assertGovernance(fact.payload.governance, digest(fact.payload.policy), previous.revision);
-            return {
-                ...next,
-                policy: {
-                    ...current,
-                    projects: { ...current.projects, [fact.payload.policy.projectId]: fact.payload.policy },
-                },
-            };
-        }
-        case 'priority.override_set': {
-            const request = requireRequest(state, fact.payload.override.requestId).request;
-            const project = requirePolicy(state).projects[fact.payload.override.projectId];
-            if (!project || request.payloadDigest !== fact.payload.override.requestPayloadDigest
-                || fact.payload.override.policyRevision !== project.revision) {
-                throw new Error('Persisted Portfolio Priority Override scope drift');
-            }
-            assertGovernance(fact.payload.governance, digest(fact.payload.override), project.revision);
-            return { ...next, overrides: { ...state.overrides, [fact.payload.override.overrideId]: fact.payload.override } };
-        }
-        case 'capacity.requested': {
-            if (!fact.payload.bundleAuthority)
-                throw new Error('Production Capacity Request lacks validated Bundle authority');
-            assertBundleAuthority(fact.payload.request, fact.payload.bundleAuthority, requirePolicy(state));
-            return {
-                ...next,
-                requests: {
-                    ...state.requests,
-                    [fact.payload.request.requestId]: {
-                        request: fact.payload.request,
-                        bundleAuthority: fact.payload.bundleAuthority,
-                        requestedAt: fact.occurredAt,
-                        requestedSequence: fact.sequence,
-                    },
-                },
-            };
-        }
-        case 'capacity.grant_offered': {
-            const item = requireRequest(state, fact.payload.grant.requestId);
-            assertGrantMatchesRequest(fact.payload.grant, item, state);
-            if (fact.payload.grant.issuedSequence !== fact.sequence) {
-                throw new Error('Capacity Grant offered sequence drift');
-            }
-            return { ...next, grants: { ...state.grants, [fact.payload.grant.grantId]: fact.payload.grant } };
-        }
-        case 'capacity.grant_consumed': {
-            const grant = requireGrant(state, fact.payload.grantId);
-            const policy = requirePolicy(state);
-            if (grant.status !== 'offered' || grant.projectId !== fact.payload.projectId
-                || grant.fence !== fact.payload.fence || grant.offerExpiresAt <= fact.payload.consumedAt
-                || fact.payload.leaseExpiresAt !== fact.payload.consumedAt + policy.leaseTtlTicks
-                || fact.payload.maxLeaseExpiresAt !== fact.payload.consumedAt + policy.maxLeaseQuantumTicks) {
-                throw new Error('Persisted Capacity Grant consume drift');
-            }
-            assertKernelAuthority(state.portfolioId, grant, fact.payload.authority, {
-                action: 'consume', assignmentRef: fact.payload.assignmentRef,
-            });
-            return updateGrant(next, grant.grantId, {
-                status: 'consumed', assignmentRef: fact.payload.assignmentRef,
-                consumedAt: fact.payload.consumedAt, leaseExpiresAt: fact.payload.leaseExpiresAt,
-                maxLeaseExpiresAt: fact.payload.maxLeaseExpiresAt,
-                renewalCount: 0, lastHeartbeatSequence: 0, lastHeartbeatAt: fact.payload.consumedAt,
-            });
-        }
-        case 'capacity.grant_assignment_failed': {
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            const action = {
-                action: 'assignment_failed',
-                assignmentRef: fact.payload.assignmentRef,
-                failureReason: fact.payload.reason,
-                kernelSequence: fact.payload.kernelSequence,
-                kernelFactDigest: fact.payload.kernelFactDigest,
-            };
-            if (grant.status !== 'consumed' || grant.projectId !== fact.payload.projectId
-                || grant.assignmentRef !== fact.payload.assignmentRef) {
-                throw new Error('Persisted Capacity Grant Assignment failure drift');
-            }
-            assertKernelAuthority(state.portfolioId, grant, fact.payload.authority, action);
-            return updateGrant(next, grant.grantId, { status: 'assignment_failed' });
-        }
-        case 'capacity.grant_lease_renewed': {
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            const policy = requirePolicy(state);
-            const action = renewalAuthorityAction(state, policy, fact.payload.assignmentRef, fact.payload.heartbeatSequence);
-            const pendingReclaim = Object.values(state.reclaims).some(reclaim => reclaim.status === 'pending');
-            const starvedReservation = Object.values(state.requests).some(item => portfolioRequestStatus(state, item.request.requestId) === 'pending'
-                && state.now >= item.request.starvationAt);
-            if (grant.status !== 'consumed' || grant.projectId !== fact.payload.projectId
-                || grant.assignmentRef !== fact.payload.assignmentRef
-                || grant.leaseExpiresAt !== fact.payload.previousLeaseExpiresAt
-                || grant.maxLeaseExpiresAt !== fact.payload.maxLeaseExpiresAt
-                || fact.payload.heartbeatSequence !== (grant.lastHeartbeatSequence ?? 0) + 1
-                || fact.payload.renewedAt !== state.now
-                || fact.payload.renewedAt < (grant.lastHeartbeatAt ?? grant.consumedAt) + policy.leaseHeartbeatTicks
-                || fact.payload.policyDigest !== policy.digest
-                || fact.payload.clockSequence !== state.clockSequence
-                || fact.payload.clockDigest !== state.clockDigest
-                || fact.payload.usageSettlementCursor !== state.usageSettlementCursor
-                || fact.payload.leaseExpiresAt !== Math.min(state.now + policy.leaseTtlTicks, fact.payload.maxLeaseExpiresAt)
-                || (grant.renewalCount ?? 0) >= policy.maxLeaseRenewals
-                || pendingReclaim || starvedReservation) {
-                throw new Error('Persisted Capacity Grant Lease renewal drift');
-            }
-            assertKernelAuthority(state.portfolioId, grant, fact.payload.authority, action);
-            return updateGrant(next, grant.grantId, {
-                leaseExpiresAt: fact.payload.leaseExpiresAt,
-                renewalCount: (grant.renewalCount ?? 0) + 1,
-                lastHeartbeatSequence: fact.payload.heartbeatSequence,
-                lastHeartbeatAt: fact.payload.renewedAt,
-            });
-        }
-        case 'capacity.grant_expired': {
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            if (grant.status !== 'offered')
-                throw new Error('Only an offered Capacity Grant can expire');
-            return updateGrant(next, grant.grantId, { status: 'expired' });
-        }
-        case 'capacity.grant_lease_lost': {
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            if (grant.status !== 'consumed' && grant.status !== 'reclaim_requested') {
-                throw new Error('Only a consumed Capacity Grant can lose its lease');
-            }
-            return updateGrant(next, grant.grantId, { status: 'usage_unknown' });
-        }
-        case 'capacity.usage_settled': {
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            assertUsageAuthority(state.portfolioId, grant, fact.payload.authority);
-            if (fact.payload.authenticatedBy !== fact.payload.authority.authenticatedBy) {
-                throw new Error('Persisted Usage Gateway authenticator drift');
-            }
-            if (!['consumed', 'reclaim_requested', 'usage_pending', 'usage_unknown'].includes(grant.status)) {
-                throw new Error('Persisted Capacity Usage settlement status drift');
-            }
-            return updateGrant({ ...next, usageSettlementCursor: fact.sequence }, grant.grantId, {
-                status: 'settled', actualCostMicros: fact.payload.actualCostMicros,
-                settlementRef: fact.payload.settlementRef,
-                receiptId: fact.payload.receiptId,
-                receiptDigest: fact.payload.authority.receiptDigest,
-                authenticatedBy: fact.payload.authenticatedBy,
-            });
-        }
-        case 'capacity.reclaim_requested': {
-            const grant = requireGrant(state, fact.payload.reclaim.grantId);
-            const request = requireRequest(state, grant.requestId).request;
-            const candidate = fact.payload.reclaim.reservedForRequestId === undefined
-                ? undefined
-                : requireRequest(state, fact.payload.reclaim.reservedForRequestId);
-            if (grant.status !== 'consumed' || request.preemptibility !== 'checkpointable'
-                || !candidate
-                || canonicalWorkroomJson(createReclaim(state, grant, candidate))
-                    !== canonicalWorkroomJson(fact.payload.reclaim)) {
-                throw new Error('Persisted Capacity Reclaim attempts to preempt atomic/stale work');
-            }
-            next = { ...next, reclaims: { ...state.reclaims, [fact.payload.reclaim.reclaimId]: fact.payload.reclaim } };
-            return updateGrant(next, grant.grantId, { status: 'reclaim_requested' });
-        }
-        case 'capacity.reclaim_acknowledged': {
-            const reclaim = requireReclaim(state, fact.payload.reclaimId);
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            if (reclaim.status !== 'pending' || reclaim.projectId !== fact.payload.projectId) {
-                throw new Error('Persisted Capacity Reclaim acknowledgement drift');
-            }
-            assertKernelAuthority(state.portfolioId, grant, fact.payload.authority, {
-                action: 'reclaim_acknowledge', assignmentRef: grant.assignmentRef,
-                reclaimId: reclaim.reclaimId, outcome: fact.payload.outcome,
-                ...(fact.payload.checkpointRef === undefined ? {} : { checkpointRef: fact.payload.checkpointRef }),
-                ...(fact.payload.checkpointDigest === undefined ? {} : { checkpointDigest: fact.payload.checkpointDigest }),
-            });
-            next = {
-                ...next,
-                reclaims: {
-                    ...state.reclaims,
-                    [reclaim.reclaimId]: {
-                        ...reclaim,
-                        status: fact.payload.outcome,
-                        ...(fact.payload.checkpointRef === undefined ? {} : { checkpointRef: fact.payload.checkpointRef }),
-                        ...(fact.payload.checkpointDigest === undefined ? {} : { checkpointDigest: fact.payload.checkpointDigest }),
-                    },
-                },
-            };
-            return updateGrant(next, grant.grantId, {
-                status: fact.payload.outcome === 'checkpointed' ? 'usage_pending' : 'consumed',
-            });
-        }
-        case 'capacity.reclaim_timed_out': {
-            const reclaim = requireReclaim(state, fact.payload.reclaimId);
-            const grant = requireFence(state, fact.payload.grantId, fact.payload.fence);
-            next = {
-                ...next,
-                reclaims: { ...state.reclaims, [reclaim.reclaimId]: { ...reclaim, status: 'timed_out' } },
-            };
-            return grant.status === 'reclaim_requested'
-                ? updateGrant(next, grant.grantId, { status: 'consumed' })
-                : next;
-        }
-        case 'clock.advanced':
-            assertClockAuthority(state.portfolioId, fact.payload.authority);
-            if (fact.payload.authority.now !== fact.payload.now) {
-                throw new Error('Persisted Portfolio clock authority time drift');
-            }
-            if (fact.payload.now <= state.now)
-                throw new Error('Persisted Portfolio clock did not advance');
-            return {
-                ...next,
-                now: fact.payload.now,
-                clockSequence: fact.sequence,
-                clockDigest: fact.payload.authority.clockDigest,
-            };
-        case 'service.normalized':
-            return {
-                ...next,
-                normalizedService: fact.payload.normalization.projectService,
-                normalizedAtSequence: fact.sequence,
-            };
-    }
-}
-function decideAdmission(state) {
-    const heads = projectHeads(state).sort((left, right) => compareRequests(state, left, right));
-    for (const head of heads) {
-        if (blockers(state, head).length === 0)
-            return createGrant(state, head);
-    }
-    for (const head of heads) {
-        const blocked = blockers(state, head);
-        if (blocked.length > 0 && blocked.every(item => item.startsWith('capacity:'))) {
-            const victim = reclaimVictim(state, head);
-            if (victim)
-                return createReclaim(state, victim, head);
-        }
-    }
-    return null;
-}
-function projectHeads(state) {
-    const byProject = new Map();
-    for (const request of Object.values(state.requests)) {
-        if (portfolioRequestStatus(state, request.request.requestId) !== 'pending')
-            continue;
-        if (requirePolicy(state).projects[request.request.projectId]?.status !== 'active')
-            continue;
-        const entries = byProject.get(request.request.projectId) ?? [];
-        entries.push(request);
-        byProject.set(request.request.projectId, entries);
-    }
-    return [...byProject.values()].map(entries => entries.sort((left, right) => left.request.localOrder - right.request.localOrder
-        || left.request.schedulerSequence - right.request.schedulerSequence
-        || compareCanonicalWorkroomText(left.request.requestId, right.request.requestId))[0]);
-}
-function compareRequests(state, left, right) {
-    const leftStarved = state.now >= left.request.starvationAt;
-    const rightStarved = state.now >= right.request.starvationAt;
-    if (leftStarved !== rightStarved)
-        return leftStarved ? -1 : 1;
-    if (leftStarved && left.request.starvationAt !== right.request.starvationAt) {
-        return left.request.starvationAt - right.request.starvationAt;
-    }
-    const lane = LANE_ORDER[effectiveLane(state, left.request)] - LANE_ORDER[effectiveLane(state, right.request)];
-    if (lane !== 0)
-        return lane;
-    const service = projectedDominantService(state, left) - projectedDominantService(state, right);
-    if (service !== 0)
-        return service;
-    const deadline = (left.request.deadlineAt ?? Number.POSITIVE_INFINITY)
-        - (right.request.deadlineAt ?? Number.POSITIVE_INFINITY);
-    if (deadline !== 0)
-        return deadline;
-    return left.request.schedulerSequence - right.request.schedulerSequence
-        || compareCanonicalWorkroomText(left.request.requestId, right.request.requestId);
-}
-function blockers(state, request) {
-    const policy = requirePolicy(state);
-    const project = policy.projects[request.request.projectId];
-    const result = [];
-    if (project.status !== 'active')
-        result.push(`project:${project.status}`);
-    const active = Object.values(state.grants).filter(grant => grant.projectId === project.projectId
-        && CAPACITY_HOLDING.has(grant.status));
-    if (active.length >= project.maxConcurrentGrants)
-        result.push('project:concurrency');
-    const burst = Object.values(state.grants).filter(grant => grant.projectId === project.projectId
-        && grant.issuedAt === state.now).length;
-    if (burst >= project.burstLimit)
-        result.push('project:burst');
-    const reserved = request.bundleAuthority.reservedCostMicros;
-    if (portfolioProjectBudget(state, project.projectId).availableMicros < reserved)
-        result.push('project:budget');
-    if (portfolioGlobalBudget(state).availableMicros < reserved)
-        result.push('global:budget');
-    for (const demand of request.request.resourceBundle.demands) {
-        const pool = policy.pools[demand.poolId];
-        const used = Object.values(state.grants).filter(grant => CAPACITY_HOLDING.has(grant.status))
-            .reduce((sum, grant) => sum
-            + (grant.resourceBundle.demands.find(item => item.poolId === demand.poolId)?.capacityUnits ?? 0), 0);
-        if (used + demand.capacityUnits > pool.capacityUnits)
-            result.push(`capacity:${demand.poolId}`);
-        if (rateUsed(state, demand.poolId) + demand.rateUnits > pool.rateUnitsPerWindow) {
-            result.push(`rate:${demand.poolId}`);
-        }
-    }
-    return result;
-}
-function createGrant(state, request) {
-    const policy = requirePolicy(state);
-    const authority = request.bundleAuthority;
-    const fence = Object.values(state.grants).filter(grant => grant.requestId === request.request.requestId)
-        .reduce((highest, grant) => Math.max(highest, grant.fence), 0) + 1;
-    return deepFreeze({
-        grantId: `capacity-grant:${encodeURIComponent(request.request.requestId)}:${fence}`,
-        requestId: request.request.requestId,
-        projectId: request.request.projectId,
-        fence,
-        resourceBundle: request.request.resourceBundle,
-        requestDigest: authority.requestDigest,
-        resourceBundleDigest: authority.resourceBundleDigest,
-        catalogGenerationId: authority.catalogGenerationId,
-        catalogRevision: authority.catalogRevision,
-        catalogDigest: authority.catalogDigest,
-        profileRevisionId: authority.profileRevisionId,
-        profileDigest: authority.profileDigest,
-        profileCeilingDigest: authority.profileCeilingDigest,
-        validatedBundleDigest: authority.validatedBundleDigest,
-        reservedCostMicros: authority.reservedCostMicros,
-        portfolioPolicyRevision: policy.revision,
-        portfolioPolicyDigest: policy.digest,
-        projectPolicyRevision: policy.projects[request.request.projectId].revision,
-        lane: effectiveLane(state, request.request),
-        issuedAt: state.now,
-        issuedSequence: state.sequence + 1,
-        offerExpiresAt: state.now + policy.offerTtlTicks,
-        status: 'offered',
-    });
-}
-function reclaimVictim(state, candidate) {
-    const candidateLane = LANE_ORDER[effectiveLane(state, candidate.request)];
-    const pools = new Set(candidate.request.resourceBundle.demands.map(item => item.poolId));
-    return Object.values(state.grants).filter(grant => {
-        const request = state.requests[grant.requestId]?.request;
-        return grant.status === 'consumed'
-            && request?.preemptibility === 'checkpointable'
-            && grant.projectId !== candidate.request.projectId
-            && grant.resourceBundle.demands.some(item => pools.has(item.poolId))
-            && (state.now >= candidate.request.starvationAt || candidateLane < LANE_ORDER[grant.lane]);
-    }).sort((left, right) => LANE_ORDER[right.lane] - LANE_ORDER[left.lane]
-        || right.issuedAt - left.issuedAt || compareCanonicalWorkroomText(right.grantId, left.grantId))[0];
-}
-function createReclaim(state, grant, candidate) {
-    return deepFreeze({
-        reclaimId: `capacity-reclaim:${encodeURIComponent(grant.grantId)}:${grant.fence}`,
-        grantId: grant.grantId,
-        projectId: grant.projectId,
-        reservedForRequestId: candidate.request.requestId,
-        requestedAt: state.now,
-        deadline: state.now + requirePolicy(state).reclaimTtlTicks,
-        reason: state.now >= candidate.request.starvationAt ? 'starvation_bound' : 'higher_portfolio_priority',
-        status: 'pending',
-    });
-}
-function projectedDominantService(state, request) {
-    const project = requirePolicy(state).projects[request.request.projectId];
-    let dominant = (state.normalizedService[project.projectId] ?? 0) / 1_000_000;
-    for (const pool of Object.values(requirePolicy(state).pools)) {
-        const historical = Object.values(state.grants)
-            .filter(grant => grant.projectId === project.projectId
-            && grant.status !== 'expired'
-            && grant.issuedSequence > state.normalizedAtSequence)
-            .reduce((sum, grant) => sum
-            + (grant.resourceBundle.demands.find(item => item.poolId === pool.poolId)?.capacityUnits ?? 0), 0);
-        const requested = request.request.resourceBundle.demands
-            .find(item => item.poolId === pool.poolId)?.capacityUnits ?? 0;
-        dominant = Math.max(dominant, (historical + requested) / pool.capacityUnits / project.weight);
-    }
-    return dominant;
-}
-function dominantService(state, projectId) {
-    const project = requirePolicy(state).projects[projectId];
-    if (!project)
-        throw new Error(`Unknown Portfolio Project ${projectId}`);
-    let dominant = (state.normalizedService[projectId] ?? 0) / 1_000_000;
-    for (const pool of Object.values(requirePolicy(state).pools)) {
-        const historical = Object.values(state.grants)
-            .filter(grant => grant.projectId === projectId && grant.status !== 'expired'
-            && grant.issuedSequence > state.normalizedAtSequence)
-            .reduce((sum, grant) => sum
-            + (grant.resourceBundle.demands.find(item => item.poolId === pool.poolId)?.capacityUnits ?? 0), 0);
-        dominant = Math.max(dominant, historical / pool.capacityUnits / project.weight);
-    }
-    return Math.floor(dominant * 1_000_000);
-}
-function effectiveLane(state, request) {
-    const override = Object.values(state.overrides).find(item => item.requestId === request.requestId && item.projectId === request.projectId
-        && item.requestPayloadDigest === request.payloadDigest && item.expiresAt > state.now);
-    return override?.lane ?? requirePolicy(state).projects[request.projectId].lane;
-}
-function rateUsed(state, poolId) {
-    const pool = requirePolicy(state).pools[poolId];
-    const start = Math.floor(state.now / pool.rateWindowTicks) * pool.rateWindowTicks;
-    return Object.values(state.grants).reduce((sum, grant) => {
-        const units = grant.resourceBundle.demands.find(item => item.poolId === poolId)?.rateUnits ?? 0;
-        if (grant.status === 'offered')
-            return sum + units;
-        if (grant.consumedAt !== undefined && grant.consumedAt >= start)
-            return sum + units;
-        return sum;
-    }, 0);
-}
-function portfolioGlobalBudget(state) {
-    const grants = Object.values(state.grants);
-    const spentMicros = grants.filter(grant => grant.status === 'settled')
-        .reduce((sum, grant) => sum + (grant.actualCostMicros ?? 0), 0);
-    const reservedMicros = grants.filter(grant => BUDGET_HOLDING.has(grant.status))
-        .reduce((sum, grant) => sum + grant.reservedCostMicros, 0);
-    return {
-        spentMicros, reservedMicros,
-        availableMicros: requirePolicy(state).globalBudgetMicros - spentMicros - reservedMicros,
-    };
-}
-function assertBundleAuthority(request, authority, policy) {
-    if (authority.requestDigest !== portfolioCapacityRequestDigest(request)
-        || authority.resourceBundleDigest !== digest(parsePortfolioResourceBundle(request.resourceBundle))
-        || authority.profileRevisionId !== request.workRef.profileRevisionId
-        || authority.profileDigest !== request.workRef.profileDigest
-        || authority.reservedCostMicros !== reservedCost(policy, request)
-        || authority.validatedBundleDigest !== portfolioValidatedBundleDigest(authority)) {
-        throw new Error('Validated Atomic Resource Bundle authority/request drift');
-    }
-    const project = policy.projects[request.projectId];
-    if (!project || request.resourceBundle.demands.some(demand => !project.allowedPools.includes(demand.poolId))) {
-        throw new Error('Validated Atomic Resource Bundle is outside Portfolio Project Policy');
-    }
-}
-function assertGrantMatchesRequest(grant, request, state) {
-    const authority = request.bundleAuthority;
-    const policy = requirePolicy(state);
-    const fence = Object.values(state.grants).filter(item => item.requestId === request.request.requestId)
-        .reduce((highest, item) => Math.max(highest, item.fence), 0) + 1;
-    if (grant.status !== 'offered'
-        || grant.grantId !== `capacity-grant:${encodeURIComponent(request.request.requestId)}:${fence}`
-        || grant.fence !== fence
-        || grant.requestId !== request.request.requestId
-        || grant.projectId !== request.request.projectId
-        || grant.requestDigest !== authority.requestDigest
-        || grant.resourceBundleDigest !== authority.resourceBundleDigest
-        || grant.validatedBundleDigest !== authority.validatedBundleDigest
-        || grant.catalogGenerationId !== authority.catalogGenerationId
-        || grant.catalogRevision !== authority.catalogRevision
-        || grant.catalogDigest !== authority.catalogDigest
-        || grant.profileRevisionId !== authority.profileRevisionId
-        || grant.profileDigest !== authority.profileDigest
-        || grant.profileCeilingDigest !== authority.profileCeilingDigest
-        || grant.reservedCostMicros !== authority.reservedCostMicros
-        || grant.portfolioPolicyRevision !== policy.revision
-        || grant.portfolioPolicyDigest !== policy.digest
-        || grant.projectPolicyRevision !== policy.projects[grant.projectId]?.revision
-        || grant.lane !== effectiveLane(state, request.request)
-        || grant.issuedAt !== state.now
-        || grant.offerExpiresAt !== state.now + policy.offerTtlTicks
-        || canonicalWorkroomJson(grant.resourceBundle) !== canonicalWorkroomJson(request.request.resourceBundle)) {
-        throw new Error('Capacity Grant drifted from validated Atomic Resource Bundle');
-    }
-}
-export function portfolioCapacityRequestDigest(request) {
-    return digest(parsePortfolioCapacityRequest(request));
-}
-export function portfolioValidatedBundleDigest(authority) {
-    const { validatedBundleDigest: _ignored, ...claims } = authority;
-    return digest(claims);
-}
-function reservedCost(policy, request) {
-    return request.resourceBundle.demands.reduce((sum, demand) => {
-        const price = policy.pools[demand.poolId]?.priceMicrosPerBudgetUnit;
-        if (price === undefined)
-            throw new Error(`Unknown Portfolio Resource Pool ${demand.poolId}`);
-        const cost = demand.budgetUnits * price;
-        if (!Number.isSafeInteger(cost) || !Number.isSafeInteger(sum + cost)) {
-            throw new Error('Portfolio budget reservation overflows');
-        }
-        return sum + cost;
-    }, 0);
-}
-function assertGovernance(proof, targetDigest, expectedRevision) {
-    if (!proof || proof.targetDigest !== targetDigest || proof.expectedRevision !== expectedRevision
-        || !proof.principalId || !proof.authorizedBy
-        || !/^sha256:[a-f0-9]{64}$/u.test(proof.reasonDigest)) {
-        throw new Error('Portfolio Governance proof scope/revision is stale');
-    }
-}
-export function portfolioKernelCommandDigest(claims) {
-    return digest(claims);
-}
-export function portfolioUsageReceiptDigest(claims) {
-    return digest(claims);
-}
-export function portfolioClockDigest(claims) {
-    return digest(claims);
-}
-function assertKernelAuthority(portfolioId, grant, authority, action) {
-    const claims = {
-        portfolioId: authority.portfolioId,
-        action: authority.action,
-        projectId: authority.projectId,
-        requestId: authority.requestId,
-        grantId: authority.grantId,
-        fence: authority.fence,
-        assignmentRef: authority.assignmentRef,
-        ...(authority.reclaimId === undefined ? {} : { reclaimId: authority.reclaimId }),
-        ...(authority.outcome === undefined ? {} : { outcome: authority.outcome }),
-        ...(authority.checkpointRef === undefined ? {} : { checkpointRef: authority.checkpointRef }),
-        ...(authority.checkpointDigest === undefined ? {} : { checkpointDigest: authority.checkpointDigest }),
-        ...(authority.heartbeatSequence === undefined ? {} : { heartbeatSequence: authority.heartbeatSequence }),
-        ...(authority.clockSequence === undefined ? {} : { clockSequence: authority.clockSequence }),
-        ...(authority.clockDigest === undefined ? {} : { clockDigest: authority.clockDigest }),
-        ...(authority.policyDigest === undefined ? {} : { policyDigest: authority.policyDigest }),
-        ...(authority.usageSettlementCursor === undefined
-            ? {}
-            : { usageSettlementCursor: authority.usageSettlementCursor }),
-        ...(authority.failureReason === undefined ? {} : { failureReason: authority.failureReason }),
-        ...(authority.kernelSequence === undefined ? {} : { kernelSequence: authority.kernelSequence }),
-        ...(authority.kernelFactDigest === undefined ? {} : { kernelFactDigest: authority.kernelFactDigest }),
-    };
-    const expected = {
-        portfolioId,
-        action: action.action,
-        projectId: grant.projectId,
-        requestId: grant.requestId,
-        grantId: grant.grantId,
-        fence: grant.fence,
-        assignmentRef: action.assignmentRef,
-        ...(action.reclaimId === undefined ? {} : { reclaimId: action.reclaimId }),
-        ...(action.outcome === undefined ? {} : { outcome: action.outcome }),
-        ...(action.checkpointRef === undefined ? {} : { checkpointRef: action.checkpointRef }),
-        ...(action.checkpointDigest === undefined ? {} : { checkpointDigest: action.checkpointDigest }),
-        ...(action.heartbeatSequence === undefined ? {} : { heartbeatSequence: action.heartbeatSequence }),
-        ...(action.clockSequence === undefined ? {} : { clockSequence: action.clockSequence }),
-        ...(action.clockDigest === undefined ? {} : { clockDigest: action.clockDigest }),
-        ...(action.policyDigest === undefined ? {} : { policyDigest: action.policyDigest }),
-        ...(action.usageSettlementCursor === undefined
-            ? {}
-            : { usageSettlementCursor: action.usageSettlementCursor }),
-        ...(action.failureReason === undefined ? {} : { failureReason: action.failureReason }),
-        ...(action.kernelSequence === undefined ? {} : { kernelSequence: action.kernelSequence }),
-        ...(action.kernelFactDigest === undefined ? {} : { kernelFactDigest: action.kernelFactDigest }),
-    };
-    if (!authority.authorizedBy || canonicalWorkroomJson(claims) !== canonicalWorkroomJson(expected)
-        || authority.commandDigest !== portfolioKernelCommandDigest(claims)) {
-        throw new Error('Owning Workroom Kernel command authority scope is stale');
-    }
-}
-function renewalAuthorityAction(state, policy, assignmentRef, heartbeatSequence) {
-    if (state.clockSequence < 0 || !state.clockDigest) {
-        throw new Error('Capacity Grant Lease renewal requires a current Portfolio clock fact');
-    }
-    return {
-        action: 'renew',
-        assignmentRef,
-        heartbeatSequence,
-        clockSequence: state.clockSequence,
-        clockDigest: state.clockDigest,
-        policyDigest: policy.digest,
-        usageSettlementCursor: state.usageSettlementCursor,
-    };
-}
-function assertUsageAuthority(portfolioId, grant, authority) {
-    const claims = {
-        portfolioId: authority.portfolioId,
-        receiptId: authority.receiptId,
-        requestId: authority.requestId,
-        grantId: authority.grantId,
-        fence: authority.fence,
-        actualCostMicros: authority.actualCostMicros,
-        settlementRef: authority.settlementRef,
-    };
-    if (!authority.authenticatedBy || authority.portfolioId !== portfolioId
-        || authority.requestId !== grant.requestId || authority.grantId !== grant.grantId
-        || authority.fence !== grant.fence
-        || authority.receiptDigest !== portfolioUsageReceiptDigest(claims)) {
-        throw new Error('Usage Gateway receipt authority scope is stale');
-    }
-}
-function assertClockAuthority(portfolioId, authority) {
-    const claims = { portfolioId: authority.portfolioId, now: authority.now };
-    if (!authority.authorizedBy || authority.portfolioId !== portfolioId
-        || authority.clockDigest !== portfolioClockDigest(claims)) {
-        throw new Error('Portfolio Kernel clock authority scope is stale');
-    }
-}
-function requirePolicy(state) {
-    if (!state.policy)
-        throw new Error('Portfolio Policy authority is unavailable');
-    return state.policy;
-}
-function requireRequest(state, requestId) {
-    const request = state.requests[requestId];
-    if (!request)
-        throw new Error(`Unknown Capacity Request ${requestId}`);
-    return request;
-}
-function requireGrant(state, grantId) {
-    const grant = state.grants[grantId];
-    if (!grant)
-        throw new Error(`Unknown Capacity Grant ${grantId}`);
-    return grant;
-}
-function requireFence(state, grantId, fence) {
-    const grant = requireGrant(state, grantId);
-    if (grant.fence !== fence)
-        throw new Error('Capacity Grant fence is stale');
-    return grant;
-}
-function requireReclaim(state, reclaimId) {
-    const reclaim = state.reclaims[reclaimId];
-    if (!reclaim)
-        throw new Error(`Unknown Capacity Reclaim ${reclaimId}`);
-    return reclaim;
-}
-function updateGrant(state, grantId, patch) {
-    return {
-        ...state,
-        grants: { ...state.grants, [grantId]: { ...requireGrant(state, grantId), ...patch } },
-    };
-}
-//# sourceMappingURL=portfolio-admission.js.map