@zhin.js/agent 1.1.13 → 1.1.14

package/lib/portfolio/portfolio-journal.js

@@ -0,0 +1,844 @@
+import { compareCanonicalWorkroomText, digestCanonicalWorkroomValue as digest } from '../workroom/canonical-value.js';
+export class PortfolioSequenceConflictError extends Error {
+    portfolioId;
+    expectedSequence;
+    actualSequence;
+    constructor(portfolioId, expectedSequence, actualSequence) {
+        super(`Portfolio ${portfolioId} sequence conflict: expected ${expectedSequence}, actual ${actualSequence}`);
+        this.portfolioId = portfolioId;
+        this.expectedSequence = expectedSequence;
+        this.actualSequence = actualSequence;
+    }
+}
+export class PortfolioEventIdentityConflictError extends Error {
+    portfolioId;
+    eventId;
+    constructor(portfolioId, eventId) {
+        super(`Portfolio ${portfolioId} eventId conflict: ${eventId}`);
+        this.portfolioId = portfolioId;
+        this.eventId = eventId;
+    }
+}
+export class PortfolioRequestIdentityConflictError extends Error {
+    portfolioId;
+    identity;
+    constructor(portfolioId, identity) {
+        super(`Portfolio ${portfolioId} Capacity Request identity conflict: ${identity}`);
+        this.portfolioId = portfolioId;
+        this.identity = identity;
+    }
+}
+/** In-memory adapter for the Portfolio Journal port; authoritative ordering is CAS-only. */
+export class InMemoryPortfolioJournalRepository {
+    #journals = new Map();
+    async listPortfolioIds() {
+        return Object.freeze([...this.#journals.keys()].sort());
+    }
+    async read(portfolioId) {
+        identifier(portfolioId, 'portfolioId');
+        return this.#journals.get(portfolioId) ?? Object.freeze([]);
+    }
+    async append(portfolioId, expectedSequence, drafts) {
+        identifier(portfolioId, 'portfolioId');
+        if (!Number.isSafeInteger(expectedSequence) || expectedSequence < -1) {
+            throw new Error('Invalid Portfolio append position');
+        }
+        const current = this.#journals.get(portfolioId) ?? Object.freeze([]);
+        const actualSequence = current.at(-1)?.sequence ?? -1;
+        if (drafts.length === 0) {
+            if (actualSequence !== expectedSequence) {
+                throw new PortfolioSequenceConflictError(portfolioId, expectedSequence, actualSequence);
+            }
+            return Object.freeze([]);
+        }
+        const normalized = deduplicateDrafts(portfolioId, drafts.map((draft) => parsePortfolioFactDraft(draft)));
+        const eventsById = new Map(current.map((event) => [event.eventId, event]));
+        const requestEvents = current.filter((event) => event.type === 'capacity.requested');
+        const requestsById = new Map(requestEvents.map((event) => [event.payload.request.requestId, event]));
+        const requestsByHead = new Map(requestEvents.map((event) => [headKey(event.payload.request), event]));
+        const idempotent = new Set();
+        for (const draft of normalized) {
+            const existingEvent = eventsById.get(draft.eventId);
+            if (existingEvent) {
+                if (existingEvent.type !== draft.type
+                    || stableJson(existingEvent.payload) !== stableJson(draft.payload)) {
+                    throw new PortfolioEventIdentityConflictError(portfolioId, draft.eventId);
+                }
+                idempotent.add(existingEvent);
+                continue;
+            }
+            if (draft.type === 'capacity.requested') {
+                for (const [identity, existingRequest] of [
+                    [`requestId:${draft.payload.request.requestId}`, requestsById.get(draft.payload.request.requestId)],
+                    [`opaqueHeadId:${headKey(draft.payload.request)}`, requestsByHead.get(headKey(draft.payload.request))],
+                ]) {
+                    if (!existingRequest)
+                        continue;
+                    throw new PortfolioRequestIdentityConflictError(portfolioId, identity);
+                }
+            }
+        }
+        if (idempotent.size > 0) {
+            if (idempotent.size !== normalized.length) {
+                throw new Error('Portfolio append cannot mix replayed and new facts');
+            }
+            return Object.freeze([...idempotent].sort((left, right) => left.sequence - right.sequence));
+        }
+        if (actualSequence !== expectedSequence) {
+            throw new PortfolioSequenceConflictError(portfolioId, expectedSequence, actualSequence);
+        }
+        const appended = normalized.map((draft, index) => deepFreeze({
+            version: 1,
+            portfolioId,
+            sequence: expectedSequence + index + 1,
+            eventId: draft.eventId,
+            occurredAt: draft.occurredAt,
+            type: draft.type,
+            payload: draft.payload,
+        }));
+        this.#journals.set(portfolioId, Object.freeze([...current, ...appended]));
+        return Object.freeze(appended);
+    }
+}
+const REQUEST_KEYS = new Set([
+    'requestId',
+    'projectId',
+    'workRef',
+    'schedulerRevision',
+    'schedulerSequence',
+    'localOrder',
+    'projectPolicyRevision',
+    'opaqueHeadId',
+    'payloadDigest',
+    'resourceBundle',
+    'preemptibility',
+    'deadlineAt',
+    'starvationAt',
+]);
+const WORK_REF_KEYS = new Set(['runId', 'profileRevisionId', 'profileDigest']);
+const RESOURCE_BUNDLE_KEYS = new Set(['demands']);
+const RESOURCE_DEMAND_KEYS = new Set(['poolId', 'capacityUnits', 'rateUnits', 'budgetUnits']);
+export function parsePortfolioCapacityRequest(value) {
+    const request = exactRecord(value, REQUEST_KEYS, 'Capacity Request');
+    const workRef = exactRecord(request.workRef, WORK_REF_KEYS, 'Capacity Request workRef');
+    const resourceBundle = exactRecord(request.resourceBundle, RESOURCE_BUNDLE_KEYS, 'Capacity Request resourceBundle');
+    const bundle = parsePortfolioResourceBundle(resourceBundle);
+    const preemptibility = request.preemptibility;
+    if (preemptibility !== 'checkpointable' && preemptibility !== 'atomic') {
+        throw new Error('Invalid Capacity Request preemptibility');
+    }
+    const deadlineAt = request.deadlineAt === undefined
+        ? undefined
+        : positiveSafeInteger(request.deadlineAt, 'deadlineAt');
+    const starvationAt = positiveSafeInteger(request.starvationAt, 'starvationAt');
+    if (deadlineAt !== undefined && starvationAt > deadlineAt) {
+        throw new Error('Capacity Request starvationAt cannot exceed deadlineAt');
+    }
+    return deepFreeze({
+        requestId: identifier(request.requestId, 'requestId'),
+        projectId: identifier(request.projectId, 'projectId'),
+        workRef: {
+            runId: identifier(workRef.runId, 'workRef.runId'),
+            profileRevisionId: identifier(workRef.profileRevisionId, 'workRef.profileRevisionId'),
+            profileDigest: contentDigest(workRef.profileDigest, 'workRef.profileDigest'),
+        },
+        schedulerRevision: identifier(request.schedulerRevision, 'schedulerRevision'),
+        schedulerSequence: nonNegativeSafeInteger(request.schedulerSequence, 'schedulerSequence'),
+        localOrder: nonNegativeSafeInteger(request.localOrder, 'localOrder'),
+        projectPolicyRevision: positiveSafeInteger(request.projectPolicyRevision, 'projectPolicyRevision'),
+        opaqueHeadId: identifier(request.opaqueHeadId, 'opaqueHeadId'),
+        payloadDigest: contentDigest(request.payloadDigest, 'payloadDigest'),
+        resourceBundle: bundle,
+        preemptibility,
+        ...(deadlineAt === undefined ? {} : { deadlineAt }),
+        starvationAt,
+    });
+}
+export function parsePortfolioResourceBundle(value) {
+    const resourceBundle = exactRecord(value, RESOURCE_BUNDLE_KEYS, 'Portfolio Resource Bundle');
+    if (!Array.isArray(resourceBundle.demands) || resourceBundle.demands.length === 0) {
+        throw new Error('Capacity Request requires a non-empty atomic Resource Bundle');
+    }
+    const seenPools = new Set();
+    const demands = resourceBundle.demands.map((raw, index) => {
+        const demand = exactRecord(raw, RESOURCE_DEMAND_KEYS, `Capacity Request demand ${index}`);
+        const poolId = identifier(demand.poolId, `resourceBundle.demands[${index}].poolId`);
+        if (seenPools.has(poolId))
+            throw new Error(`Duplicate Resource Pool demand: ${poolId}`);
+        seenPools.add(poolId);
+        return {
+            poolId,
+            capacityUnits: positiveSafeInteger(demand.capacityUnits, `${poolId}.capacityUnits`),
+            rateUnits: positiveSafeInteger(demand.rateUnits, `${poolId}.rateUnits`),
+            budgetUnits: nonNegativeSafeInteger(demand.budgetUnits, `${poolId}.budgetUnits`),
+        };
+    }).sort((left, right) => compareCanonicalWorkroomText(left.poolId, right.poolId));
+    return deepFreeze({ demands });
+}
+const PORTFOLIO_FACT_TYPES = new Set([
+    'portfolio.policy_pinned', 'project.policy_updated', 'priority.override_set',
+    'capacity.requested', 'capacity.grant_offered', 'capacity.grant_consumed',
+    'capacity.grant_assignment_failed',
+    'capacity.grant_lease_renewed',
+    'capacity.grant_expired', 'capacity.grant_lease_lost', 'capacity.usage_settled',
+    'capacity.reclaim_requested', 'capacity.reclaim_acknowledged',
+    'capacity.reclaim_timed_out', 'clock.advanced', 'service.normalized',
+]);
+export function parsePortfolioFactPayload(type, value) {
+    let payload;
+    switch (type) {
+        case 'portfolio.policy_pinned': {
+            const record = exactRecord(value, new Set(['policy', 'governance']), type);
+            payload = {
+                policy: parsePortfolioPolicySnapshot(record.policy),
+                governance: parseGovernanceProof(record.governance),
+            };
+            break;
+        }
+        case 'project.policy_updated': {
+            const record = exactRecord(value, new Set(['policy', 'governance']), type);
+            payload = {
+                policy: parsePortfolioProjectPolicy(record.policy),
+                governance: parseGovernanceProof(record.governance),
+            };
+            break;
+        }
+        case 'priority.override_set': {
+            const record = exactRecord(value, new Set(['override', 'governance']), type);
+            payload = {
+                override: parsePriorityOverride(record.override),
+                governance: parseGovernanceProof(record.governance),
+            };
+            break;
+        }
+        case 'capacity.requested': {
+            const record = exactRecord(value, new Set(['request', 'bundleAuthority']), type);
+            payload = {
+                request: parsePortfolioCapacityRequest(record.request),
+                ...(record.bundleAuthority === undefined
+                    ? {}
+                    : { bundleAuthority: parseValidatedBundleAuthority(record.bundleAuthority) }),
+            };
+            break;
+        }
+        case 'capacity.grant_offered': {
+            const record = exactRecord(value, new Set(['grant']), type);
+            payload = { grant: parseCapacityGrant(record.grant) };
+            break;
+        }
+        case 'capacity.grant_consumed': {
+            const record = exactRecord(value, new Set([
+                'grantId', 'projectId', 'fence', 'assignmentRef', 'consumedAt', 'leaseExpiresAt',
+                'maxLeaseExpiresAt', 'authority',
+            ]), type);
+            payload = {
+                grantId: identifier(record.grantId, 'grantId'),
+                projectId: identifier(record.projectId, 'projectId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                assignmentRef: identifier(record.assignmentRef, 'assignmentRef'),
+                consumedAt: nonNegativeSafeInteger(record.consumedAt, 'consumedAt'),
+                leaseExpiresAt: positiveSafeInteger(record.leaseExpiresAt, 'leaseExpiresAt'),
+                maxLeaseExpiresAt: positiveSafeInteger(record.maxLeaseExpiresAt, 'maxLeaseExpiresAt'),
+                authority: parseKernelCommandAuthority(record.authority),
+            };
+            if (payload.leaseExpiresAt <= payload.consumedAt
+                || payload.maxLeaseExpiresAt < payload.leaseExpiresAt) {
+                throw new Error('Capacity Grant lease/max quantum must expire after consume');
+            }
+            break;
+        }
+        case 'capacity.grant_assignment_failed': {
+            const record = exactRecord(value, new Set([
+                'grantId', 'projectId', 'fence', 'assignmentRef', 'reason', 'kernelSequence',
+                'kernelFactDigest', 'failedAt', 'authority',
+            ]), type);
+            if (record.reason !== 'task_stale' && record.reason !== 'task_terminal'
+                && record.reason !== 'run_terminal') {
+                throw new Error('Invalid Capacity Grant Assignment failure reason');
+            }
+            payload = {
+                grantId: identifier(record.grantId, 'grantId'),
+                projectId: identifier(record.projectId, 'projectId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                assignmentRef: identifier(record.assignmentRef, 'assignmentRef'),
+                reason: record.reason,
+                kernelSequence: nonNegativeSafeInteger(record.kernelSequence, 'kernelSequence'),
+                kernelFactDigest: contentDigest(record.kernelFactDigest, 'kernelFactDigest'),
+                failedAt: nonNegativeSafeInteger(record.failedAt, 'failedAt'),
+                authority: parseKernelCommandAuthority(record.authority),
+            };
+            break;
+        }
+        case 'capacity.grant_lease_renewed': {
+            const record = exactRecord(value, new Set([
+                'grantId', 'projectId', 'fence', 'assignmentRef', 'heartbeatSequence', 'renewedAt',
+                'previousLeaseExpiresAt', 'leaseExpiresAt', 'maxLeaseExpiresAt', 'policyDigest',
+                'clockSequence', 'clockDigest', 'usageSettlementCursor', 'authority',
+            ]), type);
+            payload = {
+                grantId: identifier(record.grantId, 'grantId'),
+                projectId: identifier(record.projectId, 'projectId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                assignmentRef: identifier(record.assignmentRef, 'assignmentRef'),
+                heartbeatSequence: positiveSafeInteger(record.heartbeatSequence, 'heartbeatSequence'),
+                renewedAt: nonNegativeSafeInteger(record.renewedAt, 'renewedAt'),
+                previousLeaseExpiresAt: positiveSafeInteger(record.previousLeaseExpiresAt, 'previousLeaseExpiresAt'),
+                leaseExpiresAt: positiveSafeInteger(record.leaseExpiresAt, 'leaseExpiresAt'),
+                maxLeaseExpiresAt: positiveSafeInteger(record.maxLeaseExpiresAt, 'maxLeaseExpiresAt'),
+                policyDigest: contentDigest(record.policyDigest, 'policyDigest'),
+                clockSequence: nonNegativeSafeInteger(record.clockSequence, 'clockSequence'),
+                clockDigest: contentDigest(record.clockDigest, 'clockDigest'),
+                usageSettlementCursor: cursor(record.usageSettlementCursor, 'usageSettlementCursor'),
+                authority: parseKernelCommandAuthority(record.authority),
+            };
+            if (payload.leaseExpiresAt <= payload.previousLeaseExpiresAt
+                || payload.leaseExpiresAt > payload.maxLeaseExpiresAt) {
+                throw new Error('Capacity Grant Lease renewal escaped max quantum');
+            }
+            break;
+        }
+        case 'capacity.grant_expired':
+        case 'capacity.reclaim_timed_out': {
+            const allowed = type === 'capacity.grant_expired'
+                ? new Set(['grantId', 'fence'])
+                : new Set(['reclaimId', 'grantId', 'fence']);
+            const record = exactRecord(value, allowed, type);
+            payload = type === 'capacity.grant_expired'
+                ? { grantId: identifier(record.grantId, 'grantId'), fence: positiveSafeInteger(record.fence, 'fence') }
+                : {
+                    reclaimId: identifier(record.reclaimId, 'reclaimId'),
+                    grantId: identifier(record.grantId, 'grantId'),
+                    fence: positiveSafeInteger(record.fence, 'fence'),
+                };
+            break;
+        }
+        case 'capacity.grant_lease_lost': {
+            const record = exactRecord(value, new Set(['grantId', 'fence', 'usage']), type);
+            if (record.usage !== 'unknown')
+                throw new Error('Lost Capacity Grant usage must remain unknown');
+            payload = {
+                grantId: identifier(record.grantId, 'grantId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                usage: 'unknown',
+            };
+            break;
+        }
+        case 'capacity.usage_settled': {
+            const record = exactRecord(value, new Set([
+                'receiptId', 'grantId', 'fence', 'actualCostMicros', 'settlementRef', 'authenticatedBy', 'authority',
+            ]), type);
+            payload = {
+                receiptId: identifier(record.receiptId, 'receiptId'),
+                grantId: identifier(record.grantId, 'grantId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                actualCostMicros: nonNegativeSafeInteger(record.actualCostMicros, 'actualCostMicros'),
+                settlementRef: identifier(record.settlementRef, 'settlementRef'),
+                authenticatedBy: identifier(record.authenticatedBy, 'authenticatedBy'),
+                authority: parseUsageGatewayAuthority(record.authority),
+            };
+            break;
+        }
+        case 'capacity.reclaim_requested': {
+            const record = exactRecord(value, new Set(['reclaim']), type);
+            payload = { reclaim: parseCapacityReclaim(record.reclaim) };
+            break;
+        }
+        case 'capacity.reclaim_acknowledged': {
+            const record = exactRecord(value, new Set([
+                'reclaimId', 'grantId', 'projectId', 'fence', 'outcome', 'checkpointRef', 'checkpointDigest', 'authority',
+            ]), type);
+            if (record.outcome !== 'checkpointed' && record.outcome !== 'declined') {
+                throw new Error('Invalid Capacity Reclaim outcome');
+            }
+            payload = {
+                reclaimId: identifier(record.reclaimId, 'reclaimId'),
+                grantId: identifier(record.grantId, 'grantId'),
+                projectId: identifier(record.projectId, 'projectId'),
+                fence: positiveSafeInteger(record.fence, 'fence'),
+                outcome: record.outcome,
+                ...(record.checkpointRef === undefined
+                    ? {}
+                    : { checkpointRef: identifier(record.checkpointRef, 'checkpointRef') }),
+                ...(record.checkpointDigest === undefined
+                    ? {}
+                    : { checkpointDigest: contentDigest(record.checkpointDigest, 'checkpointDigest') }),
+                authority: parseKernelCommandAuthority(record.authority),
+            };
+            if (payload.outcome === 'checkpointed' && (!payload.checkpointRef || !payload.checkpointDigest)) {
+                throw new Error('Checkpointed Capacity Reclaim requires checkpoint ref/digest');
+            }
+            if (payload.outcome === 'declined' && (payload.checkpointRef || payload.checkpointDigest)) {
+                throw new Error('Declined Capacity Reclaim cannot claim a checkpoint');
+            }
+            break;
+        }
+        case 'clock.advanced': {
+            const record = exactRecord(value, new Set(['now', 'authority']), type);
+            payload = {
+                now: nonNegativeSafeInteger(record.now, 'Portfolio clock'),
+                authority: parseClockAuthority(record.authority),
+            };
+            break;
+        }
+        case 'service.normalized': {
+            const record = exactRecord(value, new Set(['normalization']), type);
+            payload = { normalization: parseServiceNormalization(record.normalization) };
+            break;
+        }
+    }
+    return deepFreeze(payload);
+}
+export function parsePortfolioPolicySnapshot(value) {
+    const record = exactRecord(value, new Set([
+        'revision', 'digest', 'globalBudgetMicros', 'offerTtlTicks', 'leaseTtlTicks',
+        'leaseHeartbeatTicks', 'maxLeaseQuantumTicks', 'maxLeaseRenewals',
+        'reclaimTtlTicks', 'pools', 'projects',
+    ]), 'Portfolio Policy');
+    const poolsRecord = dictionary(record.pools, 'Portfolio Policy pools');
+    const pools = {};
+    for (const poolId of Object.keys(poolsRecord).sort()) {
+        const pool = exactRecord(poolsRecord[poolId], new Set([
+            'poolId', 'capacityUnits', 'rateUnitsPerWindow', 'rateWindowTicks',
+            'priceMicrosPerBudgetUnit',
+        ]), `Portfolio Pool ${poolId}`);
+        if (pool.poolId !== poolId)
+            throw new Error('Portfolio Pool dictionary identity drift');
+        pools[poolId] = deepFreeze({
+            poolId: identifier(pool.poolId, 'poolId'),
+            capacityUnits: positiveSafeInteger(pool.capacityUnits, 'pool.capacityUnits'),
+            rateUnitsPerWindow: positiveSafeInteger(pool.rateUnitsPerWindow, 'pool.rateUnitsPerWindow'),
+            rateWindowTicks: positiveSafeInteger(pool.rateWindowTicks, 'pool.rateWindowTicks'),
+            priceMicrosPerBudgetUnit: nonNegativeSafeInteger(pool.priceMicrosPerBudgetUnit, 'pool.priceMicrosPerBudgetUnit'),
+        });
+    }
+    if (Object.keys(pools).length === 0)
+        throw new Error('Portfolio Policy requires Resource Pools');
+    const projectsRecord = dictionary(record.projects, 'Portfolio Policy projects');
+    const projects = {};
+    for (const projectId of Object.keys(projectsRecord).sort()) {
+        const project = parsePortfolioProjectPolicy(projectsRecord[projectId]);
+        if (project.projectId !== projectId)
+            throw new Error('Portfolio Project Policy dictionary identity drift');
+        for (const poolId of project.allowedPools) {
+            if (!pools[poolId])
+                throw new Error(`Portfolio Project Policy references unknown Pool ${poolId}`);
+        }
+        projects[projectId] = project;
+    }
+    const leaseTtlTicks = positiveSafeInteger(record.leaseTtlTicks, 'leaseTtlTicks');
+    const leaseHeartbeatTicks = positiveSafeInteger(record.leaseHeartbeatTicks, 'leaseHeartbeatTicks');
+    const maxLeaseQuantumTicks = positiveSafeInteger(record.maxLeaseQuantumTicks, 'maxLeaseQuantumTicks');
+    const maxLeaseRenewals = nonNegativeSafeInteger(record.maxLeaseRenewals, 'maxLeaseRenewals');
+    if (leaseHeartbeatTicks >= leaseTtlTicks) {
+        throw new Error('Portfolio lease heartbeat must be shorter than its lease TTL');
+    }
+    if (maxLeaseQuantumTicks < leaseTtlTicks) {
+        throw new Error('Portfolio max lease quantum cannot be shorter than its lease TTL');
+    }
+    const projection = deepFreeze({
+        revision: positiveSafeInteger(record.revision, 'Portfolio Policy revision'),
+        globalBudgetMicros: nonNegativeSafeInteger(record.globalBudgetMicros, 'globalBudgetMicros'),
+        offerTtlTicks: positiveSafeInteger(record.offerTtlTicks, 'offerTtlTicks'),
+        leaseTtlTicks,
+        leaseHeartbeatTicks,
+        maxLeaseQuantumTicks,
+        maxLeaseRenewals,
+        reclaimTtlTicks: positiveSafeInteger(record.reclaimTtlTicks, 'reclaimTtlTicks'),
+        pools,
+        projects,
+    });
+    const actualDigest = contentDigest(record.digest, 'Portfolio Policy digest');
+    if (actualDigest !== digest(projection))
+        throw new Error('Portfolio Policy digest drift');
+    return deepFreeze({ ...projection, digest: actualDigest });
+}
+export function createPortfolioPolicySnapshot(input) {
+    const projection = deepFreeze(structuredClone(input));
+    return parsePortfolioPolicySnapshot({ ...projection, digest: digest(projection) });
+}
+export function parsePortfolioProjectPolicy(value) {
+    const record = exactRecord(value, new Set([
+        'projectId', 'revision', 'lane', 'weight', 'hardBudgetMicros', 'allowedPools',
+        'maxOutstandingRequests', 'maxConcurrentGrants', 'burstLimit', 'starvationTicks', 'status',
+    ]), 'Portfolio Project Policy');
+    const lane = portfolioLane(record.lane);
+    const status = record.status;
+    if (status !== 'active' && status !== 'paused' && status !== 'reclaim_checkpointable') {
+        throw new Error('Invalid Portfolio Project status');
+    }
+    const allowedPools = stringList(record.allowedPools, 'allowedPools');
+    if (allowedPools.length === 0)
+        throw new Error('Portfolio Project Policy requires allowed Pools');
+    const maxOutstandingRequests = positiveSafeInteger(record.maxOutstandingRequests, 'maxOutstandingRequests');
+    const maxConcurrentGrants = positiveSafeInteger(record.maxConcurrentGrants, 'maxConcurrentGrants');
+    const burstLimit = positiveSafeInteger(record.burstLimit, 'burstLimit');
+    if (maxConcurrentGrants > maxOutstandingRequests || burstLimit > maxOutstandingRequests) {
+        throw new Error('Portfolio Project caps are inconsistent');
+    }
+    return deepFreeze({
+        projectId: identifier(record.projectId, 'projectId'),
+        revision: positiveSafeInteger(record.revision, 'Project Policy revision'),
+        lane,
+        weight: positiveSafeInteger(record.weight, 'Project Policy weight'),
+        hardBudgetMicros: nonNegativeSafeInteger(record.hardBudgetMicros, 'hardBudgetMicros'),
+        allowedPools,
+        maxOutstandingRequests,
+        maxConcurrentGrants,
+        burstLimit,
+        starvationTicks: positiveSafeInteger(record.starvationTicks, 'starvationTicks'),
+        status,
+    });
+}
+function parsePriorityOverride(value) {
+    const record = exactRecord(value, new Set([
+        'overrideId', 'requestId', 'projectId', 'lane', 'policyRevision',
+        'requestPayloadDigest', 'expiresAt',
+    ]), 'Portfolio Priority Override');
+    return deepFreeze({
+        overrideId: identifier(record.overrideId, 'overrideId'),
+        requestId: identifier(record.requestId, 'requestId'),
+        projectId: identifier(record.projectId, 'projectId'),
+        lane: portfolioLane(record.lane),
+        policyRevision: positiveSafeInteger(record.policyRevision, 'policyRevision'),
+        requestPayloadDigest: contentDigest(record.requestPayloadDigest, 'requestPayloadDigest'),
+        expiresAt: positiveSafeInteger(record.expiresAt, 'expiresAt'),
+    });
+}
+function parseGovernanceProof(value) {
+    const record = exactRecord(value, new Set([
+        'principalId', 'authorizedBy', 'reasonDigest', 'targetDigest', 'expectedRevision',
+    ]), 'Portfolio Governance proof');
+    return deepFreeze({
+        principalId: identifier(record.principalId, 'principalId'),
+        authorizedBy: identifier(record.authorizedBy, 'authorizedBy'),
+        reasonDigest: contentDigest(record.reasonDigest, 'reasonDigest'),
+        targetDigest: contentDigest(record.targetDigest, 'targetDigest'),
+        expectedRevision: nonNegativeSafeInteger(record.expectedRevision, 'expectedRevision'),
+    });
+}
+function parseValidatedBundleAuthority(value) {
+    const record = exactRecord(value, new Set([
+        'requestDigest', 'resourceBundleDigest',
+        'catalogGenerationId', 'catalogRevision', 'catalogDigest', 'profileRevisionId',
+        'profileDigest', 'profileCeilingDigest', 'validatedBundleDigest', 'reservedCostMicros',
+    ]), 'Validated Atomic Resource Bundle authority');
+    return deepFreeze({
+        requestDigest: contentDigest(record.requestDigest, 'requestDigest'),
+        resourceBundleDigest: contentDigest(record.resourceBundleDigest, 'resourceBundleDigest'),
+        catalogGenerationId: identifier(record.catalogGenerationId, 'catalogGenerationId'),
+        catalogRevision: positiveSafeInteger(record.catalogRevision, 'catalogRevision'),
+        catalogDigest: contentDigest(record.catalogDigest, 'catalogDigest'),
+        profileRevisionId: identifier(record.profileRevisionId, 'profileRevisionId'),
+        profileDigest: contentDigest(record.profileDigest, 'profileDigest'),
+        profileCeilingDigest: contentDigest(record.profileCeilingDigest, 'profileCeilingDigest'),
+        validatedBundleDigest: contentDigest(record.validatedBundleDigest, 'validatedBundleDigest'),
+        reservedCostMicros: nonNegativeSafeInteger(record.reservedCostMicros, 'reservedCostMicros'),
+    });
+}
+function parseKernelCommandAuthority(value) {
+    const record = exactRecord(value, new Set([
+        'portfolioId', 'action', 'projectId', 'requestId', 'grantId', 'fence',
+        'assignmentRef', 'reclaimId', 'outcome', 'checkpointRef', 'checkpointDigest',
+        'heartbeatSequence', 'clockSequence', 'clockDigest', 'policyDigest', 'usageSettlementCursor',
+        'failureReason', 'kernelSequence', 'kernelFactDigest',
+        'commandDigest', 'authorizedBy',
+    ]), 'Portfolio Kernel command authority');
+    if (record.action !== 'consume' && record.action !== 'assignment_failed'
+        && record.action !== 'reclaim_acknowledge' && record.action !== 'renew') {
+        throw new Error('Invalid Portfolio Kernel command authority action');
+    }
+    if (record.outcome !== undefined && record.outcome !== 'checkpointed' && record.outcome !== 'declined') {
+        throw new Error('Invalid Portfolio Kernel command authority outcome');
+    }
+    return deepFreeze({
+        portfolioId: identifier(record.portfolioId, 'portfolioId'),
+        action: record.action,
+        projectId: identifier(record.projectId, 'projectId'),
+        requestId: identifier(record.requestId, 'requestId'),
+        grantId: identifier(record.grantId, 'grantId'),
+        fence: positiveSafeInteger(record.fence, 'fence'),
+        assignmentRef: identifier(record.assignmentRef, 'assignmentRef'),
+        ...(record.reclaimId === undefined ? {} : { reclaimId: identifier(record.reclaimId, 'reclaimId') }),
+        ...(record.outcome === undefined ? {} : { outcome: record.outcome }),
+        ...(record.checkpointRef === undefined
+            ? {}
+            : { checkpointRef: identifier(record.checkpointRef, 'checkpointRef') }),
+        ...(record.checkpointDigest === undefined
+            ? {}
+            : { checkpointDigest: contentDigest(record.checkpointDigest, 'checkpointDigest') }),
+        ...(record.heartbeatSequence === undefined
+            ? {}
+            : { heartbeatSequence: positiveSafeInteger(record.heartbeatSequence, 'heartbeatSequence') }),
+        ...(record.clockSequence === undefined
+            ? {}
+            : { clockSequence: nonNegativeSafeInteger(record.clockSequence, 'clockSequence') }),
+        ...(record.clockDigest === undefined
+            ? {}
+            : { clockDigest: contentDigest(record.clockDigest, 'clockDigest') }),
+        ...(record.policyDigest === undefined
+            ? {}
+            : { policyDigest: contentDigest(record.policyDigest, 'policyDigest') }),
+        ...(record.usageSettlementCursor === undefined
+            ? {}
+            : { usageSettlementCursor: cursor(record.usageSettlementCursor, 'usageSettlementCursor') }),
+        ...(record.failureReason === undefined ? {} : {
+            failureReason: failureReason(record.failureReason),
+        }),
+        ...(record.kernelSequence === undefined ? {} : {
+            kernelSequence: nonNegativeSafeInteger(record.kernelSequence, 'kernelSequence'),
+        }),
+        ...(record.kernelFactDigest === undefined ? {} : {
+            kernelFactDigest: contentDigest(record.kernelFactDigest, 'kernelFactDigest'),
+        }),
+        commandDigest: contentDigest(record.commandDigest, 'commandDigest'),
+        authorizedBy: identifier(record.authorizedBy, 'authorizedBy'),
+    });
+}
+function failureReason(value) {
+    if (value !== 'task_stale' && value !== 'task_terminal' && value !== 'run_terminal') {
+        throw new Error('Invalid Portfolio Kernel command failure reason');
+    }
+    return value;
+}
+function parseUsageGatewayAuthority(value) {
+    const record = exactRecord(value, new Set([
+        'portfolioId', 'receiptId', 'requestId', 'grantId', 'fence', 'actualCostMicros',
+        'settlementRef', 'receiptDigest', 'authenticatedBy',
+    ]), 'Portfolio Usage Gateway authority');
+    return deepFreeze({
+        portfolioId: identifier(record.portfolioId, 'portfolioId'),
+        receiptId: identifier(record.receiptId, 'receiptId'),
+        requestId: identifier(record.requestId, 'requestId'),
+        grantId: identifier(record.grantId, 'grantId'),
+        fence: positiveSafeInteger(record.fence, 'fence'),
+        actualCostMicros: nonNegativeSafeInteger(record.actualCostMicros, 'actualCostMicros'),
+        settlementRef: identifier(record.settlementRef, 'settlementRef'),
+        receiptDigest: contentDigest(record.receiptDigest, 'receiptDigest'),
+        authenticatedBy: identifier(record.authenticatedBy, 'authenticatedBy'),
+    });
+}
+function parseClockAuthority(value) {
+    const record = exactRecord(value, new Set([
+        'portfolioId', 'now', 'clockDigest', 'authorizedBy',
+    ]), 'Portfolio clock authority');
+    return deepFreeze({
+        portfolioId: identifier(record.portfolioId, 'portfolioId'),
+        now: nonNegativeSafeInteger(record.now, 'Portfolio clock'),
+        clockDigest: contentDigest(record.clockDigest, 'clockDigest'),
+        authorizedBy: identifier(record.authorizedBy, 'authorizedBy'),
+    });
+}
+function parseCapacityGrant(value) {
+    const record = exactRecord(value, new Set([
+        'grantId', 'requestId', 'projectId', 'fence', 'resourceBundle',
+        'requestDigest', 'resourceBundleDigest',
+        'catalogGenerationId', 'catalogRevision', 'catalogDigest', 'profileRevisionId',
+        'profileDigest', 'profileCeilingDigest', 'validatedBundleDigest', 'reservedCostMicros',
+        'portfolioPolicyRevision', 'portfolioPolicyDigest', 'projectPolicyRevision', 'lane',
+        'issuedAt', 'issuedSequence', 'offerExpiresAt', 'status',
+    ]), 'Portfolio Capacity Grant');
+    const status = record.status;
+    if (status !== 'offered')
+        throw new Error('Capacity Grant offer fact cannot forge a terminal status');
+    const issuedAt = nonNegativeSafeInteger(record.issuedAt, 'issuedAt');
+    const offerExpiresAt = positiveSafeInteger(record.offerExpiresAt, 'offerExpiresAt');
+    if (offerExpiresAt <= issuedAt)
+        throw new Error('Capacity Grant offer expiry is stale');
+    return deepFreeze({
+        grantId: identifier(record.grantId, 'grantId'),
+        requestId: identifier(record.requestId, 'requestId'),
+        projectId: identifier(record.projectId, 'projectId'),
+        fence: positiveSafeInteger(record.fence, 'fence'),
+        resourceBundle: parsePortfolioResourceBundle(record.resourceBundle),
+        requestDigest: contentDigest(record.requestDigest, 'requestDigest'),
+        resourceBundleDigest: contentDigest(record.resourceBundleDigest, 'resourceBundleDigest'),
+        catalogGenerationId: identifier(record.catalogGenerationId, 'catalogGenerationId'),
+        catalogRevision: positiveSafeInteger(record.catalogRevision, 'catalogRevision'),
+        catalogDigest: contentDigest(record.catalogDigest, 'catalogDigest'),
+        profileRevisionId: identifier(record.profileRevisionId, 'profileRevisionId'),
+        profileDigest: contentDigest(record.profileDigest, 'profileDigest'),
+        profileCeilingDigest: contentDigest(record.profileCeilingDigest, 'profileCeilingDigest'),
+        validatedBundleDigest: contentDigest(record.validatedBundleDigest, 'validatedBundleDigest'),
+        reservedCostMicros: nonNegativeSafeInteger(record.reservedCostMicros, 'reservedCostMicros'),
+        portfolioPolicyRevision: positiveSafeInteger(record.portfolioPolicyRevision, 'portfolioPolicyRevision'),
+        portfolioPolicyDigest: contentDigest(record.portfolioPolicyDigest, 'portfolioPolicyDigest'),
+        projectPolicyRevision: positiveSafeInteger(record.projectPolicyRevision, 'projectPolicyRevision'),
+        lane: portfolioLane(record.lane),
+        issuedAt,
+        issuedSequence: nonNegativeSafeInteger(record.issuedSequence, 'issuedSequence'),
+        offerExpiresAt,
+        status: 'offered',
+    });
+}
+function parseCapacityReclaim(value) {
+    const record = exactRecord(value, new Set([
+        'reclaimId', 'grantId', 'projectId', 'reservedForRequestId', 'requestedAt',
+        'deadline', 'reason', 'status',
+    ]), 'Portfolio Capacity Reclaim');
+    const reason = record.reason;
+    if (!['higher_portfolio_priority', 'starvation_bound', 'project_pause'].includes(String(reason))) {
+        throw new Error('Invalid Capacity Reclaim reason');
+    }
+    const status = record.status;
+    if (status !== 'pending')
+        throw new Error('Capacity Reclaim request fact cannot forge a terminal status');
+    const requestedAt = nonNegativeSafeInteger(record.requestedAt, 'requestedAt');
+    const deadline = positiveSafeInteger(record.deadline, 'deadline');
+    if (deadline <= requestedAt)
+        throw new Error('Capacity Reclaim deadline is stale');
+    return deepFreeze({
+        reclaimId: identifier(record.reclaimId, 'reclaimId'),
+        grantId: identifier(record.grantId, 'grantId'),
+        projectId: identifier(record.projectId, 'projectId'),
+        ...(record.reservedForRequestId === undefined
+            ? {}
+            : { reservedForRequestId: identifier(record.reservedForRequestId, 'reservedForRequestId') }),
+        requestedAt,
+        deadline,
+        reason: reason,
+        status: 'pending',
+    });
+}
+function parseServiceNormalization(value) {
+    const record = exactRecord(value, new Set([
+        'normalizationId', 'divisor', 'projectService',
+    ]), 'Portfolio Service Normalization');
+    const service = dictionary(record.projectService, 'projectService');
+    const projectService = {};
+    for (const projectId of Object.keys(service).sort()) {
+        projectService[identifier(projectId, 'projectService projectId')] =
+            nonNegativeSafeInteger(service[projectId], `projectService.${projectId}`);
+    }
+    return deepFreeze({
+        normalizationId: identifier(record.normalizationId, 'normalizationId'),
+        divisor: positiveSafeInteger(record.divisor, 'normalization divisor'),
+        projectService,
+    });
+}
+export function parsePortfolioFactDraft(draft) {
+    if (!draft || typeof draft !== 'object' || Array.isArray(draft)) {
+        throw new Error('Invalid Portfolio fact draft');
+    }
+    if (!PORTFOLIO_FACT_TYPES.has(draft.type))
+        throw new Error('Invalid Portfolio fact type');
+    if (!Number.isFinite(draft.occurredAt) || draft.occurredAt < 0) {
+        throw new Error('Invalid Portfolio fact occurredAt');
+    }
+    return deepFreeze({
+        eventId: identifier(draft.eventId, 'eventId'),
+        occurredAt: draft.occurredAt,
+        type: draft.type,
+        payload: parsePortfolioFactPayload(draft.type, draft.payload),
+    });
+}
+function deduplicateDrafts(portfolioId, drafts) {
+    const result = [];
+    const byEventId = new Map();
+    const byRequestId = new Map();
+    const byHead = new Map();
+    for (const draft of drafts) {
+        const eventMatch = byEventId.get(draft.eventId);
+        if (eventMatch) {
+            if (eventMatch.type !== draft.type || stableJson(eventMatch.payload) !== stableJson(draft.payload)) {
+                throw new PortfolioEventIdentityConflictError(portfolioId, draft.eventId);
+            }
+            continue;
+        }
+        byEventId.set(draft.eventId, draft);
+        if (draft.type === 'capacity.requested') {
+            const requestMatch = byRequestId.get(draft.payload.request.requestId);
+            const headMatch = byHead.get(headKey(draft.payload.request));
+            for (const [identity, match] of [
+                [`requestId:${draft.payload.request.requestId}`, requestMatch],
+                [`opaqueHeadId:${headKey(draft.payload.request)}`, headMatch],
+            ]) {
+                if (match)
+                    throw new PortfolioRequestIdentityConflictError(portfolioId, identity);
+            }
+            byRequestId.set(draft.payload.request.requestId, draft);
+            byHead.set(headKey(draft.payload.request), draft);
+        }
+        result.push(draft);
+    }
+    return Object.freeze(result);
+}
+function headKey(request) {
+    return `${request.projectId}:${request.opaqueHeadId}`;
+}
+function exactRecord(value, allowed, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    const record = value;
+    const unknown = Object.keys(record).filter((key) => !allowed.has(key)).sort();
+    if (unknown.length > 0) {
+        throw new Error(`${label} cannot carry Workroom content or unknown fields: ${unknown.join(', ')}`);
+    }
+    return record;
+}
+function dictionary(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a dictionary`);
+    }
+    return value;
+}
+function stringList(value, label) {
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array`);
+    const result = value.map((item, index) => identifier(item, `${label}.${index}`));
+    if (new Set(result).size !== result.length)
+        throw new Error(`${label} contains duplicates`);
+    return Object.freeze([...result].sort());
+}
+function portfolioLane(value) {
+    if (value !== 'urgent' && value !== 'high' && value !== 'normal' && value !== 'low') {
+        throw new Error('Invalid Portfolio lane');
+    }
+    return value;
+}
+function identifier(value, path) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 256) {
+        throw new Error(`Invalid opaque ${path}`);
+    }
+    return value;
+}
+function contentDigest(value, path) {
+    const result = identifier(value, path);
+    if (!result.startsWith('sha256:'))
+        throw new Error(`Invalid ${path}`);
+    return result;
+}
+function positiveSafeInteger(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) <= 0)
+        throw new Error(`${path} must be a positive safe integer`);
+    return Number(value);
+}
+function nonNegativeSafeInteger(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new Error(`${path} must be a non-negative safe integer`);
+    return Number(value);
+}
+function cursor(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) < -1)
+        throw new Error(`${path} must be a safe cursor`);
+    return Number(value);
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => compareCanonicalWorkroomText(left, right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const item of Object.values(value))
+        deepFreeze(item);
+    return Object.freeze(value);
+}
+//# sourceMappingURL=portfolio-journal.js.map