botmux 2.111.0 → 2.112.0

package/dist/services/vc-meeting-delivery-hub-store.js

@@ -0,0 +1,1230 @@
+/**
+ * Durable hub-side metadata for VC meeting delivery fan-out.
+ *
+ * The receiver ledger is authoritative for execution. This store records only
+ * the sender's membership projection, independently assigned deliverySeq,
+ * frozen envelope identity, and the receiver cursor the hub has observed.
+ * Meeting/chat/transcript text is deliberately absent. A frozen entry retains
+ * source identity plus hashes (including the rendered text hash), so recovery
+ * can re-render content and prove that it rebuilt the exact envelope.
+ *
+ * One JSON file is used per (listenerAppId, meetingId). Every RMW is protected
+ * by the repository file lock and written with tmp+rename at mode 0600.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { VC_MEETING_DELIVERY_GAP_REASONS, VC_MEETING_DELIVERY_KINDS, VC_MEETING_MEMBER_STATUSES, VC_MEETING_RESPONSE_MODES, } from './vc-meeting-delivery-protocol.js';
+import { atomicWriteFileSync } from '../utils/atomic-write.js';
+import { withFileLockSync } from '../utils/file-lock.js';
+import { logger } from '../utils/logger.js';
+import { isExactVcMeetingLegacyMemberIdentity, normalizeVcMeetingMemberPolicy, vcMeetingCanonicalStringListsEqual, vcMeetingMemberFilterEquals, } from './vc-meeting-member-policy.js';
+import { normalizeVcMeetingProfileInstructions } from './vc-meeting-profile-instructions.js';
+const DIR_NAME = 'vc-meeting-delivery-hub';
+const SCHEMA_VERSION = 1;
+const HASH_RE = /^sha256:[0-9a-f]{64}$/;
+const DELIVERY_KEY_RE = /^vc_[0-9a-f]{1,47}$/;
+function safeFileToken(raw) {
+    return raw.replace(/[^A-Za-z0-9._-]/g, (ch) => `%${ch.charCodeAt(0).toString(16)}`);
+}
+function meetingFilePath(dataDir, listenerAppId, meetingId) {
+    return join(dataDir, DIR_NAME, `${safeFileToken(listenerAppId)}__${safeFileToken(meetingId)}.json`);
+}
+function stateDirectory(dataDir) {
+    return join(dataDir, DIR_NAME);
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+    const allowedSet = new Set(allowed);
+    return Object.keys(value).every((key) => allowedSet.has(key));
+}
+function isNonEmpty(value) {
+    return typeof value === 'string' && value.length > 0 && value.trim() === value;
+}
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isFiniteNonNegative(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function isHash(value) {
+    return typeof value === 'string' && HASH_RE.test(value);
+}
+function isDeliveryKey(value) {
+    return typeof value === 'string' && DELIVERY_KEY_RE.test(value);
+}
+function validGap(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, [
+            'occurredFromMs',
+            'occurredToMs',
+            'missingItemVersionKey',
+            'originalContentHash',
+            'reason',
+        ])
+        || typeof value.reason !== 'string'
+        || !VC_MEETING_DELIVERY_GAP_REASONS.includes(value.reason))
+        return false;
+    if (value.occurredFromMs !== undefined && !isFiniteNonNegative(value.occurredFromMs))
+        return false;
+    if (value.occurredToMs !== undefined && !isFiniteNonNegative(value.occurredToMs))
+        return false;
+    if (typeof value.occurredFromMs === 'number' && typeof value.occurredToMs === 'number'
+        && value.occurredFromMs > value.occurredToMs)
+        return false;
+    if (value.missingItemVersionKey !== undefined && !isNonEmpty(value.missingItemVersionKey))
+        return false;
+    if (value.originalContentHash !== undefined && !isHash(value.originalContentHash))
+        return false;
+    return true;
+}
+function validEntryRef(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, [
+            'deliverySeq',
+            'ingestSeq',
+            'itemVersionKey',
+            'contentHash',
+            'kind',
+            'controlKey',
+            'gap',
+            'renderedTextHash',
+        ])
+        || !isPositiveInteger(value.deliverySeq)
+        || typeof value.kind !== 'string'
+        || !VC_MEETING_DELIVERY_KINDS.includes(value.kind)
+        || !isHash(value.renderedTextHash))
+        return false;
+    if (value.ingestSeq !== undefined && !isPositiveInteger(value.ingestSeq))
+        return false;
+    for (const field of ['itemVersionKey', 'controlKey']) {
+        if (value[field] !== undefined && !isNonEmpty(value[field]))
+            return false;
+    }
+    if (value.contentHash !== undefined && !isHash(value.contentHash))
+        return false;
+    if (value.kind === 'item'
+        && (!isPositiveInteger(value.ingestSeq)
+            || !isNonEmpty(value.itemVersionKey)
+            || !isHash(value.contentHash)))
+        return false;
+    if (value.kind === 'gap') {
+        if (!validGap(value.gap))
+            return false;
+    }
+    else if (value.gap !== undefined)
+        return false;
+    if (value.kind === 'control' || value.kind === 'effect_result') {
+        if (!isNonEmpty(value.controlKey))
+            return false;
+    }
+    else if (value.controlKey !== undefined)
+        return false;
+    return true;
+}
+function validObservation(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['status', 'receiverCommittedThrough', 'observedAt'])
+        && typeof value.status === 'string'
+        && ['accepted', 'dispatched', 'completed', 'duplicate', 'failed_retryable', 'failed_terminal', 'ambiguous']
+            .includes(value.status)
+        && isNonNegativeInteger(value.receiverCommittedThrough)
+        && isFiniteNonNegative(value.observedAt);
+}
+function validRenderContext(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, ['timeZone', 'authorizedActorIds'])
+        || !isNonEmpty(value.timeZone)
+        || !Array.isArray(value.authorizedActorIds)
+        || !value.authorizedActorIds.every(isNonEmpty))
+        return false;
+    const authorizedActorIds = value.authorizedActorIds;
+    const sorted = [...authorizedActorIds].sort();
+    return new Set(authorizedActorIds).size === authorizedActorIds.length
+        && sorted.every((item, index) => item === authorizedActorIds[index]);
+}
+function validAssignment(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, [
+            'deliveryKey',
+            'inputHash',
+            'ownerBootId',
+            'ownerEpoch',
+            'membershipGeneration',
+            'fromSeq',
+            'toSeq',
+            'batchId',
+            'final',
+            'entries',
+            'renderContext',
+            'instructionVersion',
+            'target',
+            'createdAt',
+            'updatedAt',
+            'lastObservation',
+        ])
+        || !isDeliveryKey(value.deliveryKey)
+        || !isHash(value.inputHash)
+        || !isNonEmpty(value.ownerBootId)
+        || !isPositiveInteger(value.ownerEpoch)
+        || !isPositiveInteger(value.membershipGeneration)
+        || !isPositiveInteger(value.fromSeq)
+        || !isPositiveInteger(value.toSeq)
+        || value.fromSeq > value.toSeq
+        || !isNonEmpty(value.batchId)
+        || typeof value.final !== 'boolean'
+        || !Array.isArray(value.entries)
+        || !validRenderContext(value.renderContext)
+        || !isNonEmpty(value.instructionVersion)
+        || !isRecord(value.target)
+        || !hasOnlyKeys(value.target, ['sessionId', 'chatId'])
+        || !isNonEmpty(value.target.sessionId)
+        || !isNonEmpty(value.target.chatId)
+        || !isFiniteNonNegative(value.createdAt)
+        || !isFiniteNonNegative(value.updatedAt)
+        || (value.lastObservation !== undefined && !validObservation(value.lastObservation)))
+        return false;
+    if (value.entries.length !== value.toSeq - value.fromSeq + 1)
+        return false;
+    let finalCount = 0;
+    const itemVersionKeys = new Set();
+    const ingestSeqs = new Set();
+    for (let index = 0; index < value.entries.length; index += 1) {
+        const entry = value.entries[index];
+        if (!validEntryRef(entry) || entry.deliverySeq !== value.fromSeq + index)
+            return false;
+        if (entry.kind === 'final')
+            finalCount += 1;
+        if (entry.kind === 'item') {
+            if (itemVersionKeys.has(entry.itemVersionKey) || ingestSeqs.has(entry.ingestSeq))
+                return false;
+            itemVersionKeys.add(entry.itemVersionKey);
+            ingestSeqs.add(entry.ingestSeq);
+        }
+    }
+    return value.final
+        ? finalCount === 1 && value.entries[value.entries.length - 1]?.kind === 'final'
+        : finalCount === 0;
+}
+function validAck(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, [
+            'deliveryKey',
+            'inputHash',
+            'fromSeq',
+            'toSeq',
+            'final',
+            'receiverCommittedThrough',
+            'ackedAt',
+        ])
+        && isDeliveryKey(value.deliveryKey)
+        && isHash(value.inputHash)
+        && isPositiveInteger(value.fromSeq)
+        && isPositiveInteger(value.toSeq)
+        && value.fromSeq <= value.toSeq
+        && typeof value.final === 'boolean'
+        && isNonNegativeInteger(value.receiverCommittedThrough)
+        && value.receiverCommittedThrough >= value.toSeq
+        && isFiniteNonNegative(value.ackedAt);
+}
+function validAckedItemVersion(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['ingestSeq', 'itemVersionKey', 'contentHash', 'deliverySeq', 'ackedAt'])
+        && isPositiveInteger(value.ingestSeq)
+        && isNonEmpty(value.itemVersionKey)
+        && isHash(value.contentHash)
+        && isPositiveInteger(value.deliverySeq)
+        && isFiniteNonNegative(value.ackedAt);
+}
+function validMemberRecord(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, [
+            'listenerAppId',
+            'meetingId',
+            'memberId',
+            'memberEpoch',
+            'ownerBootId',
+            'ownerEpoch',
+            'agentAppId',
+            'role',
+            'instructions',
+            'deliveryProfileHash',
+            'membershipGeneration',
+            'status',
+            'responseMode',
+            'filter',
+            'capabilities',
+            'ownedSinks',
+            'sinkOwnerGeneration',
+            'joinedAtIngestSeq',
+            'receiverSessionId',
+            'outputChatId',
+            'senderAckedThrough',
+            'nextDeliverySeq',
+            'inFlight',
+            'lastAckedAssignment',
+            'ackedItemVersions',
+            'finalAssignedSeq',
+            'finalAckedAt',
+            'createdAt',
+            'updatedAt',
+        ])
+        || !isNonEmpty(value.listenerAppId)
+        || !isNonEmpty(value.meetingId)
+        || !isNonEmpty(value.memberId)
+        || !isPositiveInteger(value.memberEpoch)
+        || !isNonEmpty(value.ownerBootId)
+        || !isPositiveInteger(value.ownerEpoch)
+        || !isNonEmpty(value.agentAppId)
+        || !isNonEmpty(value.role)
+        || !isHash(value.deliveryProfileHash)
+        || !isPositiveInteger(value.membershipGeneration)
+        || typeof value.status !== 'string'
+        || !VC_MEETING_MEMBER_STATUSES.includes(value.status)
+        || typeof value.responseMode !== 'string'
+        || !VC_MEETING_RESPONSE_MODES.includes(value.responseMode)
+        || !isNonNegativeInteger(value.joinedAtIngestSeq)
+        || !isNonEmpty(value.receiverSessionId)
+        || !isNonEmpty(value.outputChatId)
+        || !isNonNegativeInteger(value.senderAckedThrough)
+        || !isPositiveInteger(value.nextDeliverySeq)
+        || value.nextDeliverySeq < value.senderAckedThrough + 1
+        || (value.inFlight !== undefined && !validAssignment(value.inFlight))
+        || (value.lastAckedAssignment !== undefined && !validAck(value.lastAckedAssignment))
+        || !Array.isArray(value.ackedItemVersions)
+        || !value.ackedItemVersions.every(validAckedItemVersion)
+        || (value.finalAssignedSeq !== undefined && !isPositiveInteger(value.finalAssignedSeq))
+        || (value.finalAckedAt !== undefined && !isFiniteNonNegative(value.finalAckedAt))
+        || !isFiniteNonNegative(value.createdAt)
+        || !isFiniteNonNegative(value.updatedAt))
+        return false;
+    const normalizedInstructions = normalizeVcMeetingProfileInstructions(value.instructions);
+    if (!normalizedInstructions.ok
+        || normalizedInstructions.instructions !== value.instructions)
+        return false;
+    const policy = normalizeVcMeetingMemberPolicy({
+        memberId: value.memberId,
+        role: value.role,
+        membershipGeneration: value.membershipGeneration,
+        responseMode: value.responseMode,
+        filter: value.filter,
+        capabilities: value.capabilities,
+        ownedSinks: value.ownedSinks,
+        sinkOwnerGeneration: value.sinkOwnerGeneration,
+    });
+    if (!policy
+        || !vcMeetingMemberFilterEquals(value.filter, policy.filter)
+        || !vcMeetingCanonicalStringListsEqual(value.capabilities, policy.capabilities)
+        || !vcMeetingCanonicalStringListsEqual(value.ownedSinks, policy.ownedSinks)
+        || value.sinkOwnerGeneration !== policy.sinkOwnerGeneration)
+        return false;
+    const ackedKeys = new Set();
+    for (const item of value.ackedItemVersions) {
+        if (ackedKeys.has(item.itemVersionKey))
+            return false;
+        ackedKeys.add(item.itemVersionKey);
+        if (item.deliverySeq > value.senderAckedThrough)
+            return false;
+    }
+    if (value.inFlight) {
+        if (value.inFlight.fromSeq !== value.senderAckedThrough + 1
+            || value.nextDeliverySeq !== value.inFlight.toSeq + 1)
+            return false;
+    }
+    else if (value.nextDeliverySeq !== value.senderAckedThrough + 1)
+        return false;
+    if (value.finalAckedAt !== undefined
+        && (value.finalAssignedSeq === undefined || value.senderAckedThrough < value.finalAssignedSeq))
+        return false;
+    return true;
+}
+function validClose(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['phase', 'finalizationDeadlineAt', 'closedAt', 'reason', 'updatedAt'])
+        && typeof value.phase === 'string'
+        && ['active', 'data_closing', 'finalizing', 'closed'].includes(value.phase)
+        && (value.finalizationDeadlineAt === undefined || isFiniteNonNegative(value.finalizationDeadlineAt))
+        && (value.closedAt === undefined || isFiniteNonNegative(value.closedAt))
+        && (value.reason === undefined || isNonEmpty(value.reason))
+        && isFiniteNonNegative(value.updatedAt)
+        && (value.phase === 'closed' ? value.closedAt !== undefined : value.closedAt === undefined);
+}
+function validState(value) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, [
+            'schemaVersion',
+            'listenerAppId',
+            'meetingId',
+            'owner',
+            'close',
+            'members',
+            'createdAt',
+            'updatedAt',
+        ])
+        || value.schemaVersion !== SCHEMA_VERSION
+        || !isNonEmpty(value.listenerAppId)
+        || !isNonEmpty(value.meetingId)
+        || !isRecord(value.owner)
+        || !hasOnlyKeys(value.owner, ['ownerBootId', 'ownerEpoch', 'retiredBootIds'])
+        || !isNonEmpty(value.owner.ownerBootId)
+        || !isPositiveInteger(value.owner.ownerEpoch)
+        || !Array.isArray(value.owner.retiredBootIds)
+        || !value.owner.retiredBootIds.every(isNonEmpty)
+        || new Set(value.owner.retiredBootIds).size !== value.owner.retiredBootIds.length
+        || !validClose(value.close)
+        || !isRecord(value.members)
+        || !isFiniteNonNegative(value.createdAt)
+        || !isFiniteNonNegative(value.updatedAt))
+        return false;
+    for (const [memberId, rawMember] of Object.entries(value.members)) {
+        if (!isNonEmpty(memberId) || !isRecord(rawMember)
+            || !hasOnlyKeys(rawMember, ['maxKnownEpoch', 'generationHighWater', 'epochs'])
+            || !isPositiveInteger(rawMember.maxKnownEpoch)
+            || !isPositiveInteger(rawMember.generationHighWater)
+            || !isRecord(rawMember.epochs))
+            return false;
+        let maxEpoch = 0;
+        let maxGeneration = 0;
+        for (const [epochKey, record] of Object.entries(rawMember.epochs)) {
+            if (!validMemberRecord(record)
+                || record.listenerAppId !== value.listenerAppId
+                || record.meetingId !== value.meetingId
+                || record.memberId !== memberId
+                || String(record.memberEpoch) !== epochKey)
+                return false;
+            maxEpoch = Math.max(maxEpoch, record.memberEpoch);
+            maxGeneration = Math.max(maxGeneration, record.membershipGeneration);
+        }
+        if (maxEpoch !== rawMember.maxKnownEpoch || maxGeneration !== rawMember.generationHighWater)
+            return false;
+    }
+    return true;
+}
+function normalizePersistedMemberPolicies(value) {
+    if (!isRecord(value) || !isRecord(value.members))
+        return;
+    for (const rawMember of Object.values(value.members)) {
+        if (!isRecord(rawMember) || !isRecord(rawMember.epochs))
+            continue;
+        for (const rawRecord of Object.values(rawMember.epochs)) {
+            if (!isRecord(rawRecord)
+                || typeof rawRecord.memberId !== 'string'
+                || typeof rawRecord.role !== 'string'
+                || typeof rawRecord.membershipGeneration !== 'number'
+                || (rawRecord.responseMode !== 'silent' && rawRecord.responseMode !== 'listener_thread'))
+                continue;
+            const policy = normalizeVcMeetingMemberPolicy({
+                memberId: rawRecord.memberId,
+                role: rawRecord.role,
+                membershipGeneration: rawRecord.membershipGeneration,
+                responseMode: rawRecord.responseMode,
+                filter: rawRecord.filter,
+                capabilities: rawRecord.capabilities,
+                ownedSinks: rawRecord.ownedSinks,
+                sinkOwnerGeneration: rawRecord.sinkOwnerGeneration,
+            });
+            if (policy)
+                Object.assign(rawRecord, policy);
+            const normalizedInstructions = normalizeVcMeetingProfileInstructions(rawRecord.instructions);
+            if (normalizedInstructions.ok) {
+                if (normalizedInstructions.instructions === undefined)
+                    delete rawRecord.instructions;
+                else
+                    rawRecord.instructions = normalizedInstructions.instructions;
+            }
+        }
+    }
+}
+function readStateForAccess(filePath) {
+    if (!existsSync(filePath)) {
+        const prefix = `${basename(filePath)}.corrupt.`;
+        let quarantined = false;
+        try {
+            quarantined = readdirSync(dirname(filePath)).some(name => name.startsWith(prefix));
+        }
+        catch { /* a genuinely absent directory/state is initializable */ }
+        if (quarantined)
+            throw new Error(`vc meeting hub state has quarantined evidence for ${filePath}`);
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        normalizePersistedMemberPolicies(parsed);
+        if (!validState(parsed))
+            throw new Error('state failed schema/invariant validation');
+        return parsed;
+    }
+    catch (err) {
+        const aside = `${filePath}.corrupt.${Date.now()}.${process.pid}`;
+        try {
+            renameSync(filePath, aside);
+        }
+        catch { /* another process may already quarantine it */ }
+        logger.warn(`[vc-meeting-delivery-hub-store] corrupt state at ${filePath}, moved aside to ${aside}: `
+            + `${err instanceof Error ? err.message : String(err)}`);
+        // Missing state may be initialized by an authoritative projection;
+        // corrupt state must not be mistaken for missing or cursor zero. The
+        // caller pauses this meeting until an operator reconciles the quarantined
+        // evidence.
+        throw new Error(`vc meeting hub state is corrupt: ${aside}`);
+    }
+}
+function writeState(filePath, state, now) {
+    state.updatedAt = now;
+    if (!validState(state)) {
+        throw new Error('refusing to write invalid vc meeting hub state');
+    }
+    const actualDir = join(filePath, '..');
+    if (!existsSync(actualDir))
+        mkdirSync(actualDir, { recursive: true, mode: 0o700 });
+    atomicWriteFileSync(filePath, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+}
+function mutateState(dataDir, listenerAppId, meetingId, now, fn) {
+    const dir = stateDirectory(dataDir);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const filePath = meetingFilePath(dataDir, listenerAppId, meetingId);
+    return withFileLockSync(filePath, () => {
+        const state = readStateForAccess(filePath);
+        const mutation = fn(state);
+        if (mutation.write)
+            writeState(filePath, mutation.write, now);
+        return mutation.result;
+    });
+}
+function readState(dataDir, listenerAppId, meetingId) {
+    const filePath = meetingFilePath(dataDir, listenerAppId, meetingId);
+    if (!existsSync(filePath))
+        return undefined;
+    return withFileLockSync(filePath, () => readStateForAccess(filePath));
+}
+function newState(input, now) {
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        listenerAppId: input.listenerAppId,
+        meetingId: input.meetingId,
+        owner: { ownerBootId: input.ownerBootId, ownerEpoch: input.ownerEpoch, retiredBootIds: [] },
+        close: { phase: 'active', updatedAt: now },
+        members: {},
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function projectionInputValid(input) {
+    return isRecord(input)
+        && hasOnlyKeys(input, [
+            'listenerAppId',
+            'meetingId',
+            'memberId',
+            'memberEpoch',
+            'ownerBootId',
+            'ownerEpoch',
+            'agentAppId',
+            'role',
+            'instructions',
+            'deliveryProfileHash',
+            'membershipGeneration',
+            'status',
+            'responseMode',
+            'filter',
+            'capabilities',
+            'ownedSinks',
+            'sinkOwnerGeneration',
+            'joinedAtIngestSeq',
+            'receiverSessionId',
+            'outputChatId',
+        ])
+        && isNonEmpty(input.listenerAppId)
+        && isNonEmpty(input.meetingId)
+        && isNonEmpty(input.memberId)
+        && isPositiveInteger(input.memberEpoch)
+        && isNonEmpty(input.ownerBootId)
+        && isPositiveInteger(input.ownerEpoch)
+        && isNonEmpty(input.agentAppId)
+        && isNonEmpty(input.role)
+        && isHash(input.deliveryProfileHash)
+        && isPositiveInteger(input.membershipGeneration)
+        && VC_MEETING_MEMBER_STATUSES.includes(input.status)
+        && VC_MEETING_RESPONSE_MODES.includes(input.responseMode)
+        && normalizeVcMeetingMemberPolicy({
+            memberId: input.memberId,
+            role: input.role,
+            membershipGeneration: input.membershipGeneration,
+            responseMode: input.responseMode,
+            filter: input.filter,
+            capabilities: input.capabilities,
+            ownedSinks: input.ownedSinks,
+            sinkOwnerGeneration: input.sinkOwnerGeneration,
+        }) !== undefined
+        && isNonNegativeInteger(input.joinedAtIngestSeq)
+        && isNonEmpty(input.receiverSessionId)
+        && isNonEmpty(input.outputChatId)
+        && (() => {
+            const normalized = normalizeVcMeetingProfileInstructions(input.instructions);
+            return normalized.ok && normalized.instructions === input.instructions;
+        })();
+}
+function streamIdentityEquals(a, b) {
+    return a.agentAppId === b.agentAppId
+        && a.role === b.role
+        && a.instructions === b.instructions
+        && a.deliveryProfileHash === b.deliveryProfileHash
+        && vcMeetingMemberFilterEquals(a.filter, b.filter)
+        && a.joinedAtIngestSeq === b.joinedAtIngestSeq
+        && a.receiverSessionId === b.receiverSessionId
+        && a.outputChatId === b.outputChatId;
+}
+function projectionContentEquals(a, b) {
+    return streamIdentityEquals(a, b)
+        && a.status === b.status
+        && a.responseMode === b.responseMode
+        && vcMeetingCanonicalStringListsEqual(a.capabilities ?? [], b.capabilities ?? [])
+        && vcMeetingCanonicalStringListsEqual(a.ownedSinks ?? [], b.ownedSinks ?? [])
+        && a.sinkOwnerGeneration === b.sinkOwnerGeneration;
+}
+function updateOwner(state, ownerEpoch, ownerBootId) {
+    if (ownerEpoch > state.owner.ownerEpoch) {
+        state.owner = { ownerEpoch, ownerBootId, retiredBootIds: [] };
+        return;
+    }
+    if (ownerBootId === state.owner.ownerBootId)
+        return;
+    const retired = state.owner.retiredBootIds.slice();
+    if (state.owner.ownerBootId && !retired.includes(state.owner.ownerBootId)) {
+        retired.push(state.owner.ownerBootId);
+    }
+    state.owner = { ownerEpoch, ownerBootId, retiredBootIds: retired };
+}
+export function applyVcMeetingHubMemberProjection(dataDir, input, now = Date.now()) {
+    const normalizedInstructions = normalizeVcMeetingProfileInstructions(input.instructions);
+    if (!normalizedInstructions.ok)
+        return { ok: false, reason: 'invalid' };
+    const policy = normalizeVcMeetingMemberPolicy({
+        memberId: input.memberId,
+        role: input.role,
+        membershipGeneration: input.membershipGeneration,
+        responseMode: input.responseMode,
+        filter: input.filter,
+        capabilities: input.capabilities,
+        ownedSinks: input.ownedSinks,
+        sinkOwnerGeneration: input.sinkOwnerGeneration,
+    });
+    if (policy)
+        input = { ...input, ...policy };
+    else
+        input = { ...input };
+    if (normalizedInstructions.instructions === undefined)
+        delete input.instructions;
+    else
+        input.instructions = normalizedInstructions.instructions;
+    if (!projectionInputValid(input) || !isFiniteNonNegative(now)) {
+        return { ok: false, reason: 'invalid' };
+    }
+    return mutateState(dataDir, input.listenerAppId, input.meetingId, now, (existing) => {
+        const state = existing ?? newState(input, now);
+        if (state.close.phase === 'closed') {
+            return { result: { ok: false, reason: 'meeting_closed' } };
+        }
+        if (input.ownerEpoch < state.owner.ownerEpoch) {
+            return { result: { ok: false, reason: 'stale_owner_epoch' } };
+        }
+        if (input.ownerEpoch === state.owner.ownerEpoch
+            && state.owner.retiredBootIds.includes(input.ownerBootId)) {
+            return { result: { ok: false, reason: 'stale_owner_boot' } };
+        }
+        const member = state.members[input.memberId] ?? {
+            maxKnownEpoch: input.memberEpoch,
+            generationHighWater: input.membershipGeneration,
+            epochs: {},
+        };
+        if (input.memberEpoch < member.maxKnownEpoch) {
+            return { result: { ok: false, reason: 'stale_member_epoch' } };
+        }
+        if (input.membershipGeneration < member.generationHighWater) {
+            return { result: { ok: false, reason: 'stale_membership_generation' } };
+        }
+        const prior = member.epochs[String(input.memberEpoch)];
+        if (prior?.status === 'removed' && input.status !== 'removed') {
+            return { result: { ok: false, reason: 'epoch_removed' } };
+        }
+        if (prior && input.membershipGeneration === prior.membershipGeneration
+            && !projectionContentEquals(input, prior)) {
+            return { result: { ok: false, reason: 'projection_conflict' } };
+        }
+        if (prior
+            && (input.sinkOwnerGeneration ?? 0) < (prior.sinkOwnerGeneration ?? 0)) {
+            return { result: { ok: false, reason: 'stale_sink_owner_generation' } };
+        }
+        const sinkOwnershipChanged = !vcMeetingCanonicalStringListsEqual(input.ownedSinks ?? [], prior?.ownedSinks ?? []);
+        if (prior && sinkOwnershipChanged
+            && (input.sinkOwnerGeneration ?? 0) <= (prior.sinkOwnerGeneration ?? 0)) {
+            return { result: { ok: false, reason: 'stale_sink_owner_generation' } };
+        }
+        if (prior && !streamIdentityEquals(input, prior)) {
+            return { result: { ok: false, reason: 'epoch_required' } };
+        }
+        // Profile-mode ownership is a durable invariant, not merely config-time
+        // validation. Exact MA-P0 legacy epochs are exempt until the daemon's
+        // single-agent switch path is migrated to explicit remove-then-claim.
+        if (input.status !== 'removed'
+            && !isExactVcMeetingLegacyMemberIdentity(input)
+            && (input.ownedSinks?.length ?? 0) > 0) {
+            for (const [otherMemberId, otherState] of Object.entries(state.members)) {
+                // A higher epoch atomically supersedes this same logical member's old
+                // epoch. Requiring a separate remove first creates a crash window where
+                // restore cannot publish the successor at all. Other logical members
+                // still compete against the latest epoch and remain conflict-fenced.
+                if (otherMemberId === input.memberId)
+                    continue;
+                const other = otherState.epochs[String(otherState.maxKnownEpoch)];
+                if (!other || other.status === 'removed')
+                    continue;
+                const overlap = (input.ownedSinks ?? []).find(sink => other.ownedSinks?.includes(sink));
+                if (overlap) {
+                    return {
+                        result: {
+                            ok: false,
+                            reason: 'sink_owner_conflict',
+                            detail: `${overlap} is already owned by ${other.memberId}@${other.memberEpoch}`,
+                        },
+                    };
+                }
+            }
+        }
+        updateOwner(state, input.ownerEpoch, input.ownerBootId);
+        const record = {
+            ...input,
+            senderAckedThrough: prior?.senderAckedThrough ?? 0,
+            nextDeliverySeq: prior?.nextDeliverySeq ?? 1,
+            ...(prior?.inFlight ? { inFlight: prior.inFlight } : {}),
+            ...(prior?.lastAckedAssignment ? { lastAckedAssignment: prior.lastAckedAssignment } : {}),
+            ackedItemVersions: prior?.ackedItemVersions.map(item => ({ ...item })) ?? [],
+            ...(prior?.finalAssignedSeq !== undefined ? { finalAssignedSeq: prior.finalAssignedSeq } : {}),
+            ...(prior?.finalAckedAt !== undefined ? { finalAckedAt: prior.finalAckedAt } : {}),
+            createdAt: prior?.createdAt ?? now,
+            updatedAt: now,
+        };
+        member.epochs[String(input.memberEpoch)] = record;
+        member.maxKnownEpoch = Math.max(member.maxKnownEpoch, input.memberEpoch);
+        member.generationHighWater = Math.max(member.generationHighWater, input.membershipGeneration);
+        state.members[input.memberId] = member;
+        return { result: { ok: true, record }, write: state };
+    });
+}
+function freezeInputValid(input) {
+    if (!isRecord(input)
+        || !hasOnlyKeys(input, [
+            'listenerAppId',
+            'meetingId',
+            'memberId',
+            'memberEpoch',
+            'ownerBootId',
+            'ownerEpoch',
+            'membershipGeneration',
+            'deliveryKey',
+            'inputHash',
+            'fromSeq',
+            'toSeq',
+            'batchId',
+            'final',
+            'entries',
+            'renderContext',
+            'instructionVersion',
+            'target',
+        ])
+        || !isNonEmpty(input.listenerAppId)
+        || !isNonEmpty(input.meetingId)
+        || !isNonEmpty(input.memberId)
+        || !isPositiveInteger(input.memberEpoch)
+        || !isNonEmpty(input.ownerBootId)
+        || !isPositiveInteger(input.ownerEpoch)
+        || !isPositiveInteger(input.membershipGeneration)
+        || !isDeliveryKey(input.deliveryKey)
+        || !isHash(input.inputHash)
+        || !isPositiveInteger(input.fromSeq)
+        || !isPositiveInteger(input.toSeq)
+        || input.fromSeq > input.toSeq
+        || !isNonEmpty(input.batchId)
+        || typeof input.final !== 'boolean'
+        || !Array.isArray(input.entries)
+        || !validRenderContext(input.renderContext)
+        || !isNonEmpty(input.instructionVersion)
+        || !isRecord(input.target)
+        || !hasOnlyKeys(input.target, ['sessionId', 'chatId'])
+        || !isNonEmpty(input.target.sessionId)
+        || !isNonEmpty(input.target.chatId))
+        return false;
+    if (input.entries.length !== input.toSeq - input.fromSeq + 1)
+        return false;
+    let finalCount = 0;
+    const itemVersionKeys = new Set();
+    const ingestSeqs = new Set();
+    for (let index = 0; index < input.entries.length; index += 1) {
+        const entry = input.entries[index];
+        if (!validEntryRef(entry) || entry.deliverySeq !== input.fromSeq + index)
+            return false;
+        if (entry.kind === 'final')
+            finalCount += 1;
+        if (entry.kind === 'item') {
+            if (itemVersionKeys.has(entry.itemVersionKey) || ingestSeqs.has(entry.ingestSeq))
+                return false;
+            itemVersionKeys.add(entry.itemVersionKey);
+            ingestSeqs.add(entry.ingestSeq);
+        }
+    }
+    return input.final
+        ? finalCount === 1 && input.entries[input.entries.length - 1]?.kind === 'final'
+        : finalCount === 0;
+}
+function assignmentMetadataEquals(a, b) {
+    return a.deliveryKey === b.deliveryKey
+        && a.inputHash === b.inputHash
+        && a.ownerBootId === b.ownerBootId
+        && a.ownerEpoch === b.ownerEpoch
+        && a.membershipGeneration === b.membershipGeneration
+        && a.fromSeq === b.fromSeq
+        && a.toSeq === b.toSeq
+        && a.batchId === b.batchId
+        && a.final === b.final
+        && a.renderContext.timeZone === b.renderContext.timeZone
+        && a.renderContext.authorizedActorIds.length === b.renderContext.authorizedActorIds.length
+        && a.renderContext.authorizedActorIds.every((id, index) => id === b.renderContext.authorizedActorIds[index])
+        && a.instructionVersion === b.instructionVersion
+        && a.target.sessionId === b.target.sessionId
+        && a.target.chatId === b.target.chatId
+        && a.entries.length === b.entries.length
+        && a.entries.every((entry, index) => entryRefEquals(entry, b.entries[index]));
+}
+function entryRefEquals(a, b) {
+    return a.deliverySeq === b.deliverySeq
+        && a.ingestSeq === b.ingestSeq
+        && a.itemVersionKey === b.itemVersionKey
+        && a.contentHash === b.contentHash
+        && a.kind === b.kind
+        && a.controlKey === b.controlKey
+        && a.renderedTextHash === b.renderedTextHash
+        && a.gap?.occurredFromMs === b.gap?.occurredFromMs
+        && a.gap?.occurredToMs === b.gap?.occurredToMs
+        && a.gap?.missingItemVersionKey === b.gap?.missingItemVersionKey
+        && a.gap?.originalContentHash === b.gap?.originalContentHash
+        && a.gap?.reason === b.gap?.reason;
+}
+function ackIdentityEquals(a, b) {
+    return a.deliveryKey === b.deliveryKey
+        && a.inputHash === b.inputHash
+        && a.fromSeq === b.fromSeq
+        && a.toSeq === b.toSeq
+        && a.final === b.final;
+}
+export function freezeVcMeetingHubDeliveryAssignment(dataDir, input, now = Date.now()) {
+    if (!freezeInputValid(input) || !isFiniteNonNegative(now)) {
+        return { kind: 'conflict', reason: 'invalid' };
+    }
+    return mutateState(dataDir, input.listenerAppId, input.meetingId, now, (state) => {
+        if (!state)
+            return { result: { kind: 'conflict', reason: 'unknown_meeting' } };
+        if (state.close.phase === 'closed') {
+            return { result: { kind: 'conflict', reason: 'meeting_closed' } };
+        }
+        if (input.ownerEpoch < state.owner.ownerEpoch) {
+            return { result: { kind: 'conflict', reason: 'stale_owner_epoch' } };
+        }
+        if (input.ownerEpoch > state.owner.ownerEpoch) {
+            return { result: { kind: 'conflict', reason: 'owner_epoch_not_registered' } };
+        }
+        if (input.ownerBootId !== state.owner.ownerBootId) {
+            return { result: { kind: 'conflict', reason: 'stale_owner_boot' } };
+        }
+        const memberState = state.members[input.memberId];
+        if (!memberState)
+            return { result: { kind: 'conflict', reason: 'unknown_member' } };
+        if (input.memberEpoch !== memberState.maxKnownEpoch) {
+            return { result: { kind: 'conflict', reason: 'stale_member_epoch' } };
+        }
+        const member = memberState.epochs[String(input.memberEpoch)];
+        if (!member)
+            return { result: { kind: 'conflict', reason: 'unknown_member' } };
+        if (input.membershipGeneration < memberState.generationHighWater) {
+            return { result: { kind: 'conflict', reason: 'stale_membership_generation' } };
+        }
+        if (input.membershipGeneration > memberState.generationHighWater) {
+            return { result: { kind: 'conflict', reason: 'membership_generation_not_registered' } };
+        }
+        if (member.status === 'paused') {
+            return { result: { kind: 'conflict', reason: 'membership_paused' } };
+        }
+        if (member.status === 'removed') {
+            return { result: { kind: 'conflict', reason: 'membership_removed' } };
+        }
+        if (input.target.sessionId !== member.receiverSessionId || input.target.chatId !== member.outputChatId) {
+            return { result: { kind: 'conflict', reason: 'target_mismatch' } };
+        }
+        if (member.inFlight) {
+            if (assignmentMetadataEquals(member.inFlight, input)) {
+                return {
+                    result: {
+                        kind: 'existing',
+                        assignment: member.inFlight,
+                        senderAckedThrough: member.senderAckedThrough,
+                    },
+                };
+            }
+            return {
+                result: {
+                    kind: 'conflict',
+                    reason: member.inFlight.deliveryKey === input.deliveryKey
+                        ? 'assignment_conflict'
+                        : 'delivery_in_flight',
+                    activeDeliveryKey: member.inFlight.deliveryKey,
+                },
+            };
+        }
+        if (member.lastAckedAssignment && ackIdentityEquals(member.lastAckedAssignment, input)) {
+            return {
+                result: {
+                    kind: 'already_acked',
+                    ack: member.lastAckedAssignment,
+                    senderAckedThrough: member.senderAckedThrough,
+                },
+            };
+        }
+        if (member.finalAssignedSeq !== undefined
+            && input.entries.some(entry => entry.kind === 'item' || entry.kind === 'gap')) {
+            return { result: { kind: 'conflict', reason: 'stream_finalized' } };
+        }
+        for (const entry of input.entries) {
+            if (entry.kind !== 'item')
+                continue;
+            const priorAck = member.ackedItemVersions.find(item => item.itemVersionKey === entry.itemVersionKey);
+            if (!priorAck)
+                continue;
+            const sameIdentity = priorAck.ingestSeq === entry.ingestSeq
+                && priorAck.contentHash === entry.contentHash;
+            return {
+                result: {
+                    kind: 'conflict',
+                    reason: sameIdentity ? 'item_already_acked' : 'acked_item_conflict',
+                },
+            };
+        }
+        const expected = member.senderAckedThrough + 1;
+        if (input.fromSeq <= member.senderAckedThrough) {
+            return {
+                result: {
+                    kind: 'conflict',
+                    reason: 'delivery_partial_overlap',
+                    expectedFromSeq: expected,
+                },
+            };
+        }
+        if (input.fromSeq > expected) {
+            return {
+                result: { kind: 'conflict', reason: 'delivery_gap', expectedFromSeq: expected },
+            };
+        }
+        if (input.final && member.finalAssignedSeq !== undefined) {
+            return { result: { kind: 'conflict', reason: 'final_already_assigned' } };
+        }
+        const assignment = {
+            deliveryKey: input.deliveryKey,
+            inputHash: input.inputHash,
+            ownerBootId: input.ownerBootId,
+            ownerEpoch: input.ownerEpoch,
+            membershipGeneration: input.membershipGeneration,
+            fromSeq: input.fromSeq,
+            toSeq: input.toSeq,
+            batchId: input.batchId,
+            final: input.final,
+            entries: input.entries.map((entry) => ({
+                deliverySeq: entry.deliverySeq,
+                ...(entry.ingestSeq !== undefined ? { ingestSeq: entry.ingestSeq } : {}),
+                ...(entry.itemVersionKey !== undefined ? { itemVersionKey: entry.itemVersionKey } : {}),
+                ...(entry.contentHash !== undefined ? { contentHash: entry.contentHash } : {}),
+                kind: entry.kind,
+                ...(entry.controlKey !== undefined ? { controlKey: entry.controlKey } : {}),
+                ...(entry.gap !== undefined ? { gap: { ...entry.gap } } : {}),
+                renderedTextHash: entry.renderedTextHash,
+            })),
+            renderContext: {
+                timeZone: input.renderContext.timeZone,
+                authorizedActorIds: [...input.renderContext.authorizedActorIds],
+            },
+            instructionVersion: input.instructionVersion,
+            target: { sessionId: input.target.sessionId, chatId: input.target.chatId },
+            createdAt: now,
+            updatedAt: now,
+        };
+        member.inFlight = assignment;
+        member.nextDeliverySeq = input.toSeq + 1;
+        if (input.final)
+            member.finalAssignedSeq = input.toSeq;
+        member.updatedAt = now;
+        return {
+            result: { kind: 'frozen', assignment, senderAckedThrough: member.senderAckedThrough },
+            write: state,
+        };
+    });
+}
+function observationInputValid(input) {
+    return isRecord(input)
+        && hasOnlyKeys(input, [
+            'listenerAppId',
+            'meetingId',
+            'memberId',
+            'memberEpoch',
+            'ownerBootId',
+            'ownerEpoch',
+            'deliveryKey',
+            'inputHash',
+            'fromSeq',
+            'toSeq',
+            'status',
+            'receiverCommittedThrough',
+        ])
+        && isNonEmpty(input.listenerAppId)
+        && isNonEmpty(input.meetingId)
+        && isNonEmpty(input.memberId)
+        && isPositiveInteger(input.memberEpoch)
+        && isNonEmpty(input.ownerBootId)
+        && isPositiveInteger(input.ownerEpoch)
+        && isDeliveryKey(input.deliveryKey)
+        && isHash(input.inputHash)
+        && isPositiveInteger(input.fromSeq)
+        && isPositiveInteger(input.toSeq)
+        && input.fromSeq <= input.toSeq
+        && ['accepted', 'dispatched', 'completed', 'duplicate', 'failed_retryable', 'failed_terminal', 'ambiguous']
+            .includes(input.status)
+        && isNonNegativeInteger(input.receiverCommittedThrough);
+}
+function observationMatchesAck(input, ack) {
+    return input.deliveryKey === ack.deliveryKey
+        && input.inputHash === ack.inputHash
+        && input.fromSeq === ack.fromSeq
+        && input.toSeq === ack.toSeq;
+}
+export function observeVcMeetingHubReceiverReceipt(dataDir, input, now = Date.now()) {
+    if (!observationInputValid(input) || !isFiniteNonNegative(now)) {
+        return { ok: false, reason: 'invalid' };
+    }
+    return mutateState(dataDir, input.listenerAppId, input.meetingId, now, (state) => {
+        if (!state)
+            return { result: { ok: false, reason: 'unknown_meeting' } };
+        if (input.ownerEpoch < state.owner.ownerEpoch) {
+            return { result: { ok: false, reason: 'stale_owner_epoch' } };
+        }
+        if (input.ownerEpoch > state.owner.ownerEpoch) {
+            return { result: { ok: false, reason: 'owner_epoch_not_registered' } };
+        }
+        if (input.ownerBootId !== state.owner.ownerBootId) {
+            return { result: { ok: false, reason: 'stale_owner_boot' } };
+        }
+        const memberState = state.members[input.memberId];
+        if (!memberState)
+            return { result: { ok: false, reason: 'unknown_member' } };
+        if (input.memberEpoch !== memberState.maxKnownEpoch) {
+            return { result: { ok: false, reason: 'stale_member_epoch' } };
+        }
+        const member = memberState.epochs[String(input.memberEpoch)];
+        if (!member)
+            return { result: { ok: false, reason: 'unknown_member' } };
+        if (!member.inFlight) {
+            if (member.lastAckedAssignment
+                && observationMatchesAck(input, member.lastAckedAssignment)
+                && (input.status === 'completed' || input.status === 'duplicate')
+                && input.receiverCommittedThrough >= input.toSeq) {
+                return {
+                    result: {
+                        ok: true,
+                        kind: 'already_acked',
+                        senderAckedThrough: member.senderAckedThrough,
+                        ack: member.lastAckedAssignment,
+                    },
+                };
+            }
+            return { result: { ok: false, reason: 'no_in_flight' } };
+        }
+        const assignment = member.inFlight;
+        if (input.deliveryKey !== assignment.deliveryKey) {
+            return { result: { ok: false, reason: 'delivery_key_mismatch' } };
+        }
+        if (input.inputHash !== assignment.inputHash) {
+            return { result: { ok: false, reason: 'input_hash_mismatch' } };
+        }
+        if (input.fromSeq !== assignment.fromSeq || input.toSeq !== assignment.toSeq) {
+            return { result: { ok: false, reason: 'range_mismatch' } };
+        }
+        if (input.receiverCommittedThrough < member.senderAckedThrough) {
+            return { result: { ok: false, reason: 'receiver_cursor_regression' } };
+        }
+        const terminal = input.status === 'completed' || input.status === 'duplicate';
+        if (terminal && input.receiverCommittedThrough < assignment.toSeq) {
+            return { result: { ok: false, reason: 'receiver_cursor_short' } };
+        }
+        if (!terminal) {
+            assignment.lastObservation = {
+                status: input.status,
+                receiverCommittedThrough: input.receiverCommittedThrough,
+                observedAt: now,
+            };
+            assignment.updatedAt = now;
+            member.updatedAt = now;
+            return {
+                result: {
+                    ok: true,
+                    kind: 'observed',
+                    senderAckedThrough: member.senderAckedThrough,
+                    assignment,
+                },
+                write: state,
+            };
+        }
+        const ack = {
+            deliveryKey: assignment.deliveryKey,
+            inputHash: assignment.inputHash,
+            fromSeq: assignment.fromSeq,
+            toSeq: assignment.toSeq,
+            final: assignment.final,
+            receiverCommittedThrough: input.receiverCommittedThrough,
+            ackedAt: now,
+        };
+        const newlyAckedItems = [];
+        for (const entry of assignment.entries) {
+            if (entry.kind !== 'item')
+                continue;
+            // validAssignment guarantees these fields for item entries. Keep the
+            // runtime guard so a future schema change cannot silently weaken the
+            // durable per-member dedup index.
+            if (entry.ingestSeq === undefined || entry.itemVersionKey === undefined || entry.contentHash === undefined) {
+                return { result: { ok: false, reason: 'acked_item_conflict' } };
+            }
+            const existing = member.ackedItemVersions.find(item => item.itemVersionKey === entry.itemVersionKey);
+            if (existing) {
+                if (existing.ingestSeq !== entry.ingestSeq || existing.contentHash !== entry.contentHash) {
+                    return { result: { ok: false, reason: 'acked_item_conflict' } };
+                }
+                continue;
+            }
+            const pendingDuplicate = newlyAckedItems.find(item => item.itemVersionKey === entry.itemVersionKey);
+            if (pendingDuplicate) {
+                return { result: { ok: false, reason: 'acked_item_conflict' } };
+            }
+            newlyAckedItems.push({
+                ingestSeq: entry.ingestSeq,
+                itemVersionKey: entry.itemVersionKey,
+                contentHash: entry.contentHash,
+                deliverySeq: entry.deliverySeq,
+                ackedAt: now,
+            });
+        }
+        member.senderAckedThrough = assignment.toSeq;
+        member.nextDeliverySeq = assignment.toSeq + 1;
+        member.lastAckedAssignment = ack;
+        member.ackedItemVersions.push(...newlyAckedItems);
+        delete member.inFlight;
+        if (assignment.final)
+            member.finalAckedAt = now;
+        member.updatedAt = now;
+        return {
+            result: { ok: true, kind: 'acked', senderAckedThrough: member.senderAckedThrough, ack },
+            write: state,
+        };
+    });
+}
+export function getVcMeetingHubMember(dataDir, key) {
+    return readState(dataDir, key.listenerAppId, key.meetingId)
+        ?.members[key.memberId]?.epochs[String(key.memberEpoch)];
+}
+export function getVcMeetingHubDeliveryAssignment(dataDir, key) {
+    return getVcMeetingHubMember(dataDir, key)?.inFlight;
+}
+export function listVcMeetingHubMembers(dataDir, scope) {
+    const state = readState(dataDir, scope.listenerAppId, scope.meetingId);
+    if (!state)
+        return [];
+    const records = Object.values(state.members).flatMap((member) => Object.values(member.epochs));
+    return records.sort((a, b) => a.memberId.localeCompare(b.memberId) || a.memberEpoch - b.memberEpoch);
+}
+export function getVcMeetingHubCloseState(dataDir, scope) {
+    return readState(dataDir, scope.listenerAppId, scope.meetingId)?.close;
+}
+const CLOSE_PHASE_ORDER = {
+    active: 0,
+    data_closing: 1,
+    finalizing: 2,
+    closed: 3,
+};
+export function updateVcMeetingHubCloseState(dataDir, input, now = Date.now()) {
+    if (!isRecord(input)
+        || !hasOnlyKeys(input, [
+            'listenerAppId',
+            'meetingId',
+            'ownerBootId',
+            'ownerEpoch',
+            'phase',
+            'finalizationDeadlineAt',
+            'reason',
+        ])
+        || !isNonEmpty(input.listenerAppId)
+        || !isNonEmpty(input.meetingId)
+        || !isNonEmpty(input.ownerBootId)
+        || !isPositiveInteger(input.ownerEpoch)
+        || !Object.keys(CLOSE_PHASE_ORDER).includes(input.phase)
+        || (input.finalizationDeadlineAt !== undefined && !isFiniteNonNegative(input.finalizationDeadlineAt))
+        || (input.reason !== undefined && !isNonEmpty(input.reason))
+        || !isFiniteNonNegative(now))
+        return { ok: false, reason: 'invalid' };
+    return mutateState(dataDir, input.listenerAppId, input.meetingId, now, (state) => {
+        if (!state)
+            return { result: { ok: false, reason: 'unknown_meeting' } };
+        if (input.ownerEpoch < state.owner.ownerEpoch) {
+            return { result: { ok: false, reason: 'stale_owner_epoch' } };
+        }
+        if (input.ownerEpoch > state.owner.ownerEpoch) {
+            return { result: { ok: false, reason: 'owner_epoch_not_registered' } };
+        }
+        if (input.ownerBootId !== state.owner.ownerBootId) {
+            return { result: { ok: false, reason: 'stale_owner_boot' } };
+        }
+        if (CLOSE_PHASE_ORDER[input.phase] < CLOSE_PHASE_ORDER[state.close.phase]) {
+            return { result: { ok: false, reason: 'close_phase_regression' } };
+        }
+        if (CLOSE_PHASE_ORDER[input.phase] > CLOSE_PHASE_ORDER[state.close.phase] + 1) {
+            return { result: { ok: false, reason: 'close_phase_jump' } };
+        }
+        if (input.phase === 'closed') {
+            for (const memberState of Object.values(state.members)) {
+                const member = memberState.epochs[String(memberState.maxKnownEpoch)];
+                if (!member || member.status === 'removed')
+                    continue;
+                if (member.inFlight) {
+                    return { result: { ok: false, reason: 'in_flight_not_settled' } };
+                }
+                if (member.finalAckedAt === undefined) {
+                    return { result: { ok: false, reason: 'final_not_acked' } };
+                }
+            }
+        }
+        const close = {
+            phase: input.phase,
+            ...(input.finalizationDeadlineAt !== undefined
+                ? { finalizationDeadlineAt: input.finalizationDeadlineAt }
+                : state.close.finalizationDeadlineAt !== undefined
+                    ? { finalizationDeadlineAt: state.close.finalizationDeadlineAt }
+                    : {}),
+            ...(input.phase === 'closed' ? { closedAt: state.close.closedAt ?? now } : {}),
+            ...(input.reason !== undefined
+                ? { reason: input.reason }
+                : state.close.reason !== undefined
+                    ? { reason: state.close.reason }
+                    : {}),
+            updatedAt: now,
+        };
+        state.close = close;
+        return { result: { ok: true, close }, write: state };
+    });
+}
+//# sourceMappingURL=vc-meeting-delivery-hub-store.js.map