botmux 3.10.0 → 3.23.1

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

@@ -1,1241 +0,0 @@
-/**
- * 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',
-            'outputPlacement',
-            '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)
-        || (value.outputPlacement !== 'auto'
-            && value.outputPlacement !== 'chat'
-            && value.outputPlacement !== 'topic')
-        || !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);
-            rawRecord.outputPlacement ??= 'auto';
-            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',
-            'outputPlacement',
-        ])
-        && 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)
-        && (input.outputPlacement === 'auto'
-            || input.outputPlacement === 'chat'
-            || input.outputPlacement === 'topic')
-        && (() => {
-            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
-        && (a.outputPlacement ?? 'auto') === (b.outputPlacement ?? 'auto')
-        && 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()) {
-    input = { ...input, outputPlacement: input.outputPlacement ?? 'auto' };
-    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