agl 1.0.17 → 21.0.2

package/dist_ts/classes.flexstore.js

@@ -0,0 +1,3400 @@
+import * as plugins from './plugins.js';
+import { FlexDomainHeadModel, FlexHeadModel, FlexMigrationModel, FlexPrivateCandidateModel, FlexPrivateChunkModel, FlexWriterLeaseModel, assertFlexDomainHeadDocument, assertFlexHeadDocument, assertFlexMigrationDocument, assertFlexPrivateCandidateDocument, assertFlexPrivateChunkDocument, assertFlexWriterLeaseDocument, flexDomainHeadId, flexMigrationId, flexPrivateChunkBytes, flexWriterLeaseId, initFlexPrivateModels, registerFlexPrivateModels, } from './classes.flexmodels.private.js';
+import { FlexPublicCandidateModel, FlexPublicHeadModel, FlexPublicMessageRecordModel, FlexPublicSessionRecordModel, FlexProjectionMessageRecordModel, FlexProjectionSourceModel, assertFlexPublicCandidateDocument, assertFlexPublicHeadDocument, assertFlexPublicMessageRecordDocument, assertFlexPublicSessionRecordDocument, assertFlexProjectionMessageRecordDocument, assertFlexProjectionSourceDocument, flexHeadId, flexPublicHeadId, flexPublicMessageBytesLimit, flexPublicMessageLimit, flexPublicSessionLimit, flexPublicSingleMessageBytesLimit, initFlexPublicModels, registerFlexPublicModels, } from './classes.flexmodels.public.js';
+export const flexOrphanGraceMs = 60 * 60 * 1000;
+const flexMaintenancePageLimit = 128;
+const flexOrphanMaintenanceIntervalMs = 15 * 60 * 1000;
+const flexLeaseDurationMs = 30_000;
+const flexLeaseHeartbeatMs = 10_000;
+const flexLeaseHeartbeatOperationTimeoutMs = 5_000;
+const flexLeaseTransitionTimeoutMs = 20_000;
+const flexMaintenanceOperationTimeoutMs = 10_000;
+const sha256 = (valueArg) => plugins.crypto.createHash('sha256').update(valueArg).digest('hex');
+const serializedBytes = (valueArg) => Buffer.from(JSON.stringify(valueArg), 'utf8');
+const canonicalJson = (valueArg) => JSON.stringify(valueArg, (_key, value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, value[key]]));
+});
+const randomCandidateId = () => plugins.crypto.randomBytes(16).toString('base64url');
+const randomOwnerToken = () => plugins.crypto.randomBytes(32).toString('base64url');
+const privateCandidateDocumentId = (candidateIdArg) => `flex-private-candidate:${candidateIdArg}`;
+const privateChunkDocumentId = (candidateIdArg, indexArg) => `flex-private-chunk:${candidateIdArg}:${indexArg}`;
+const publicCandidateDocumentId = (candidateIdArg) => `flex-public-candidate:${candidateIdArg}`;
+const publicSessionDocumentId = (candidateIdArg, sessionIdArg) => `flex-public-session:${candidateIdArg}:${sha256(sessionIdArg).slice(0, 32)}`;
+const publicMessageDocumentId = (candidateIdArg, sessionIdArg, messageIdArg) => `flex-public-message:${candidateIdArg}:${sha256(`${sessionIdArg}\0${messageIdArg}`).slice(0, 32)}`;
+const projectionSourceDocumentId = (candidateIdArg) => `flex-projection-source:${candidateIdArg}`;
+const projectionMessageDocumentId = (candidateIdArg, indexArg) => `flex-projection-message:${candidateIdArg}:${String(indexArg).padStart(16, '0')}`;
+const providerKey = (storageKeyArg, sessionIdArg) => JSON.stringify([storageKeyArg, sessionIdArg]);
+const compareNewestSession = (leftArg, rightArg) => rightArg.updatedAt.localeCompare(leftArg.updatedAt)
+    || rightArg.createdAt.localeCompare(leftArg.createdAt)
+    || leftArg.sessionId.localeCompare(rightArg.sessionId);
+const compareNewestOrderedMessage = (leftArg, rightArg) => {
+    if (leftArg.message.sessionId === rightArg.message.sessionId) {
+        return rightArg.messageIndex - leftArg.messageIndex;
+    }
+    return rightArg.message.createdAt.localeCompare(leftArg.message.createdAt)
+        || leftArg.message.sessionId.localeCompare(rightArg.message.sessionId)
+        || leftArg.message.messageId.localeCompare(rightArg.message.messageId)
+        || rightArg.messageIndex - leftArg.messageIndex;
+};
+const compareNewestProjectionDescriptor = (leftArg, rightArg) => leftArg.sessionId === rightArg.sessionId
+    ? (rightArg.messageIndex ?? rightArg.index) - (leftArg.messageIndex ?? leftArg.index)
+    : rightArg.messageCreatedAt.localeCompare(leftArg.messageCreatedAt)
+        || leftArg.sessionId.localeCompare(rightArg.sessionId)
+        || leftArg.messageId.localeCompare(rightArg.messageId)
+        || (rightArg.messageIndex ?? rightArg.index) - (leftArg.messageIndex ?? leftArg.index);
+const retainNewest = (valuesArg, limitArg, compareArg) => {
+    const retained = [];
+    for (const value of valuesArg) {
+        let low = 0;
+        let high = retained.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (compareArg(value, retained[middle]) < 0)
+                high = middle;
+            else
+                low = middle + 1;
+        }
+        if (low >= limitArg)
+            continue;
+        retained.splice(low, 0, value);
+        if (retained.length > limitArg)
+            retained.pop();
+    }
+    return retained;
+};
+const retainPublicSessions = (sessionsArg) => {
+    const roots = retainNewest(sessionsArg.filter((session) => session.parentSessionId === undefined), flexPublicSessionLimit, compareNewestSession);
+    const children = retainNewest(sessionsArg.filter((session) => session.parentSessionId !== undefined), flexPublicSessionLimit - roots.length, compareNewestSession);
+    return [...roots, ...children].sort(compareNewestSession);
+};
+const flexTaskPlaceholderBytesLimit = 384 * 1024;
+const taskOutputOmittedNotice = '[Task output omitted because its public projection exceeded 480 KiB.]';
+const placeholderMessage = (messageArg) => {
+    const linkedTaskParts = messageArg.parts.flatMap((part) => (part.type === 'tool' && part.childSessionId !== undefined
+        ? [{
+                partId: part.partId,
+                type: 'tool',
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                status: part.status,
+                input: {},
+                output: taskOutputOmittedNotice,
+                childSessionId: part.childSessionId,
+                ...(part.model === undefined ? {} : { model: part.model }),
+            }]
+        : []));
+    if (linkedTaskParts.length === 0) {
+        return {
+            ...messageArg,
+            parts: [{
+                    partId: messageArg.parts[0]?.partId ?? messageArg.messageId,
+                    type: 'text',
+                    text: '[Message content omitted because its public projection exceeded 480 KiB.]',
+                }],
+        };
+    }
+    const retainedTaskParts = [];
+    for (const part of linkedTaskParts) {
+        const candidate = { ...messageArg, parts: [...retainedTaskParts, part] };
+        if (serializedBytes(candidate).byteLength > flexTaskPlaceholderBytesLimit)
+            break;
+        retainedTaskParts.push(part);
+    }
+    if (retainedTaskParts.length < linkedTaskParts.length) {
+        retainedTaskParts.at(-1).output = `${taskOutputOmittedNotice} ${linkedTaskParts.length - retainedTaskParts.length} additional task link(s) omitted.`;
+    }
+    return { ...messageArg, parts: retainedTaskParts };
+};
+const recordManifest = (documentArg) => {
+    const bytes = serializedBytes(documentArg);
+    return { id: documentArg.id, sha256: sha256(bytes), bytes: bytes.byteLength };
+};
+const publicCandidateManifestBytes = (manifestArg) => serializedBytes(manifestArg);
+const projectionSourceManifestBytes = (manifestArg) => Buffer.from(canonicalJson(manifestArg), 'utf8');
+const projectionMessagePayload = (messageArg, previousArg) => ({
+    message: messageArg,
+    ...(previousArg === undefined ? {} : { previous: previousArg }),
+});
+const projectionMessagePayloadBytes = (messageArg, previousArg) => Buffer.from(canonicalJson(projectionMessagePayload(messageArg, previousArg)), 'utf8');
+const projectionMessageBodyBytes = (messageArg) => Buffer.byteLength(canonicalJson(messageArg), 'utf8');
+const cloneJson = (valueArg, pathArg = '$') => {
+    const seen = new WeakSet();
+    const visit = (value, path) => {
+        if (value === null || typeof value === 'string' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value)) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path} contains a non-finite number.`);
+            }
+            return value;
+        }
+        if (typeof value === 'undefined')
+            return undefined;
+        if (typeof value !== 'object') {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path} contains ${typeof value}, which is not JSON-safe.`);
+        }
+        if (seen.has(value)) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path} contains a cycle.`);
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path} is not a plain object.`);
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path} contains a symbol-keyed property.`);
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+            const result = value.map((entry, index) => {
+                if (!(index in value) || entry === undefined) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path}[${index}] is not JSON-safe.`);
+                }
+                return visit(entry, `${path}[${index}]`);
+            });
+            seen.delete(value);
+            return result;
+        }
+        const result = {};
+        for (const key of Object.getOwnPropertyNames(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor.enumerable || !('value' in descriptor)) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError(`${path}.${key} is not a plain JSON property.`);
+            }
+            const entry = visit(descriptor.value, `${path}.${key}`);
+            if (entry !== undefined)
+                result[key] = entry;
+        }
+        seen.delete(value);
+        return result;
+    };
+    return visit(valueArg, pathArg);
+};
+const assertIdentifier = (valueArg, nameArg) => {
+    if (typeof valueArg !== 'string'
+        || valueArg.trim().length === 0
+        || Buffer.byteLength(valueArg, 'utf8') > 512) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError(`${nameArg} must be a non-empty string of at most 512 bytes.`);
+    }
+};
+const assertExpectedNextRevision = (snapshotRevisionArg, expectedRevisionArg) => {
+    if (!Number.isSafeInteger(expectedRevisionArg) || expectedRevisionArg < 0) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('expectedRevision must be a non-negative integer.');
+    }
+    if (snapshotRevisionArg !== expectedRevisionArg + 1) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError(`Snapshot revision ${snapshotRevisionArg} must equal expected revision ${expectedRevisionArg} plus one.`);
+    }
+};
+const smartRevisionSelector = (valueArg) => valueArg._smartdataRevision === undefined ? { $exists: false } : valueArg._smartdataRevision;
+const privateChunkManifestsEqual = (leftArg, rightArg) => leftArg.length === rightArg.length && leftArg.every((left, index) => {
+    const right = rightArg[index];
+    return right !== undefined
+        && left.id === right.id
+        && left.index === right.index
+        && left.sha256 === right.sha256
+        && left.bytes === right.bytes;
+});
+const publicManifestsEqual = (leftArg, rightArg) => canonicalJson(leftArg) === canonicalJson(rightArg);
+const domainHeadBody = (valueArg) => ({
+    id: valueArg.id,
+    controllerId: valueArg.controllerId,
+    storageKey: valueArg.storageKey,
+    domain: valueArg.domain,
+    incarnationId: valueArg.incarnationId,
+    revision: valueArg.revision,
+    currentPrivateCandidateId: valueArg.currentPrivateCandidateId,
+    privateCandidate: valueArg.privateCandidate,
+    ...(valueArg.projectionSource !== undefined
+        ? { projectionSource: valueArg.projectionSource }
+        : {}),
+    ...(valueArg.sessionId !== undefined ? { sessionId: valueArg.sessionId } : {}),
+    ...(valueArg.archiveId !== undefined ? { archiveId: valueArg.archiveId } : {}),
+});
+const publicHeadBody = (valueArg) => ({
+    id: valueArg.id,
+    controllerId: valueArg.controllerId,
+    storageKey: valueArg.storageKey,
+    revision: valueArg.revision,
+    currentPublicCandidateId: valueArg.currentPublicCandidateId,
+    publicCandidates: valueArg.publicCandidates,
+});
+const leaseBody = (valueArg) => ({
+    id: valueArg.id,
+    controllerId: valueArg.controllerId,
+    storageKey: valueArg.storageKey,
+    ownerToken: valueArg.ownerToken,
+    epoch: valueArg.epoch,
+    state: valueArg.state,
+    expiresAt: valueArg.expiresAt,
+    updatedAt: valueArg.updatedAt,
+});
+const leaseTransitionImage = (valueArg) => ({
+    _id: valueArg._id,
+    ...leaseBody(valueArg),
+    ...(valueArg._smartdataRevision !== undefined
+        ? { _smartdataRevision: valueArg._smartdataRevision }
+        : {}),
+});
+const leaseTransitionImagesEqual = (leftArg, rightArg) => String(leftArg._id) === String(rightArg._id)
+    && canonicalJson(leaseBody(leftArg)) === canonicalJson(leaseBody(rightArg))
+    && leftArg._smartdataRevision === rightArg._smartdataRevision;
+const migrationBody = (valueArg) => ({
+    id: valueArg.id,
+    controllerId: valueArg.controllerId,
+    storageKey: valueArg.storageKey,
+    migration: valueArg.migration,
+    legacyRevision: valueArg.legacyRevision,
+    legacyCandidateId: valueArg.legacyCandidateId,
+    completedAt: valueArg.completedAt,
+});
+const projectPrivateChunk = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    index: modelArg.index,
+    sha256: modelArg.sha256,
+    bytes: modelArg.bytes,
+    data: modelArg.data,
+    createdAt: modelArg.createdAt,
+    ...(modelArg.domain !== undefined ? { domain: modelArg.domain } : {}),
+    ...(modelArg.incarnationId !== undefined ? { incarnationId: modelArg.incarnationId } : {}),
+    ...(modelArg.sessionId !== undefined ? { sessionId: modelArg.sessionId } : {}),
+    ...(modelArg.archiveId !== undefined ? { archiveId: modelArg.archiveId } : {}),
+});
+const projectPrivateCandidate = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    sha256: modelArg.sha256,
+    bytes: modelArg.bytes,
+    chunks: modelArg.chunks,
+    createdAt: modelArg.createdAt,
+    ...(modelArg.domain !== undefined ? { domain: modelArg.domain } : {}),
+    ...(modelArg.incarnationId !== undefined ? { incarnationId: modelArg.incarnationId } : {}),
+    ...(modelArg.sessionId !== undefined ? { sessionId: modelArg.sessionId } : {}),
+    ...(modelArg.archiveId !== undefined ? { archiveId: modelArg.archiveId } : {}),
+});
+const projectPublicCandidate = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    sha256: modelArg.sha256,
+    bytes: modelArg.bytes,
+    sessionRecords: modelArg.sessionRecords,
+    messageRecords: modelArg.messageRecords,
+    sessionsTruncated: modelArg.sessionsTruncated,
+    messagesTruncated: modelArg.messagesTruncated,
+    messageBytesTruncated: modelArg.messageBytesTruncated,
+    visibleDigest: modelArg.visibleDigest,
+    scopeSource: modelArg.scopeSource,
+    projectionSources: modelArg.projectionSources,
+    createdAt: modelArg.createdAt,
+});
+const projectPublicSession = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    session: modelArg.session,
+    createdAt: modelArg.createdAt,
+});
+const projectPublicMessage = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    messageIndex: modelArg.messageIndex,
+    message: modelArg.message,
+    createdAt: modelArg.createdAt,
+});
+const projectProjectionSource = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    sessionId: modelArg.sessionId,
+    candidateId: modelArg.candidateId,
+    incarnationId: modelArg.incarnationId,
+    revision: modelArg.revision,
+    ...(modelArg.orderVersion === undefined ? {} : { orderVersion: modelArg.orderVersion }),
+    sha256: modelArg.sha256,
+    bytes: modelArg.bytes,
+    messageCount: modelArg.messageCount,
+    messagesTruncated: modelArg.messagesTruncated,
+    visibleDigest: modelArg.visibleDigest,
+    ...(modelArg.latestMessage === undefined ? {} : { latestMessage: modelArg.latestMessage }),
+    createdAt: modelArg.createdAt,
+});
+const projectProjectionMessage = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    sessionId: modelArg.sessionId,
+    incarnationId: modelArg.incarnationId,
+    revision: modelArg.revision,
+    index: modelArg.index,
+    ...(modelArg.messageIndex === undefined ? {} : { messageIndex: modelArg.messageIndex }),
+    sha256: modelArg.sha256,
+    bytes: modelArg.bytes,
+    messageCreatedAt: modelArg.messageCreatedAt,
+    messageId: modelArg.messageId,
+    message: modelArg.message,
+    ...(modelArg.previous === undefined ? {} : { previous: modelArg.previous }),
+    createdAt: modelArg.createdAt,
+});
+const insertOrdinary = async (modelConstructorArg, documentArg) => {
+    const model = Object.assign(new modelConstructorArg(), documentArg);
+    await modelConstructorArg.insert(model);
+};
+const inBatches = async (valuesArg, operationArg) => {
+    for (let index = 0; index < valuesArg.length; index += 32) {
+        await Promise.all(valuesArg.slice(index, index + 32).map(operationArg));
+    }
+};
+const createPrivateProjection = (controllerIdArg, storageKeyArg, candidateIdArg, revisionArg, snapshotArg, createdAtArg, sourceArg) => {
+    const complete = serializedBytes(snapshotArg);
+    const chunks = [];
+    for (let offset = 0, index = 0; offset < complete.byteLength || index === 0; index++) {
+        const chunk = complete.subarray(offset, Math.min(offset + flexPrivateChunkBytes, complete.byteLength));
+        const id = privateChunkDocumentId(candidateIdArg, index);
+        chunks.push({
+            id,
+            controllerId: controllerIdArg,
+            scopeId: storageKeyArg,
+            candidateId: candidateIdArg,
+            revision: revisionArg,
+            index,
+            sha256: sha256(chunk),
+            bytes: chunk.byteLength,
+            data: chunk.toString('base64'),
+            createdAt: createdAtArg,
+            ...(sourceArg ? {
+                domain: sourceArg.identity.domain,
+                incarnationId: sourceArg.incarnationId,
+                ...(sourceArg.identity.sessionId !== undefined
+                    ? { sessionId: sourceArg.identity.sessionId }
+                    : {}),
+                ...(sourceArg.identity.archiveId !== undefined
+                    ? { archiveId: sourceArg.identity.archiveId }
+                    : {}),
+            } : {}),
+        });
+        offset += chunk.byteLength;
+        if (complete.byteLength === 0)
+            break;
+    }
+    const candidate = {
+        id: privateCandidateDocumentId(candidateIdArg),
+        controllerId: controllerIdArg,
+        scopeId: storageKeyArg,
+        candidateId: candidateIdArg,
+        revision: revisionArg,
+        sha256: sha256(complete),
+        bytes: complete.byteLength,
+        chunks: chunks.map(({ id, index, sha256: digest, bytes }) => ({
+            id, index, sha256: digest, bytes,
+        })),
+        createdAt: createdAtArg,
+        ...(sourceArg ? {
+            domain: sourceArg.identity.domain,
+            incarnationId: sourceArg.incarnationId,
+            ...(sourceArg.identity.sessionId !== undefined
+                ? { sessionId: sourceArg.identity.sessionId }
+                : {}),
+            ...(sourceArg.identity.archiveId !== undefined
+                ? { archiveId: sourceArg.identity.archiveId }
+                : {}),
+        } : {}),
+    };
+    assertFlexPrivateCandidateDocument(candidate);
+    for (const chunk of chunks)
+        assertFlexPrivateChunkDocument(chunk);
+    return { candidate, chunks };
+};
+export const createProjectionSource = (controllerIdArg, storageKeyArg, sessionIdArg, snapshotArg, preparationArg, limitsArg = {
+    messageLimit: flexPublicMessageLimit,
+    messageBytesLimit: flexPublicMessageBytesLimit,
+    singleMessageBytesLimit: flexPublicSingleMessageBytesLimit,
+}) => {
+    const retainedMessages = snapshotArg.messages.slice(-limitsArg.messageLimit);
+    const buildChain = (orderedMessagesArg, normalizeOversizedArg, messageIndexOffsetArg) => {
+        const messages = [];
+        let previous;
+        let replaced = false;
+        for (const [index, sourceMessage] of orderedMessagesArg.entries()) {
+            let message = sourceMessage;
+            let payload = projectionMessagePayloadBytes(message, previous);
+            if (payload.byteLength > limitsArg.singleMessageBytesLimit) {
+                if (!normalizeOversizedArg) {
+                    throw new Error('Flex projection source normalization invariant failed.');
+                }
+                const placeholder = placeholderMessage(sourceMessage);
+                const placeholderPayload = projectionMessagePayloadBytes(placeholder, previous);
+                if (projectionMessageBodyBytes(placeholder) >= projectionMessageBodyBytes(sourceMessage)
+                    || placeholderPayload.byteLength > limitsArg.singleMessageBytesLimit) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source message metadata exceeds its projection limit.');
+                }
+                message = placeholder;
+                payload = placeholderPayload;
+                replaced = true;
+            }
+            const descriptor = {
+                id: projectionMessageDocumentId(preparationArg.candidateId, index),
+                index,
+                messageIndex: messageIndexOffsetArg + index,
+                sha256: sha256(payload),
+                bytes: payload.byteLength,
+                messageCreatedAt: message.createdAt,
+                sessionId: sessionIdArg,
+                messageId: message.messageId,
+            };
+            const record = {
+                ...descriptor,
+                controllerId: controllerIdArg,
+                scopeId: storageKeyArg,
+                candidateId: preparationArg.candidateId,
+                incarnationId: preparationArg.incarnationId,
+                revision: preparationArg.revision,
+                message,
+                ...(previous === undefined ? {} : { previous }),
+                createdAt: preparationArg.createdAt,
+            };
+            assertFlexProjectionMessageRecordDocument(record);
+            messages.push(record);
+            previous = descriptor;
+        }
+        return { messages, replaced };
+    };
+    const normalized = buildChain(retainedMessages, true, snapshotArg.messages.length - retainedMessages.length);
+    const selectedNewest = [];
+    let selectedMessageBytes = 0;
+    for (let index = normalized.messages.length - 1; index >= 0; index--) {
+        const message = normalized.messages[index].message;
+        const bodyBytes = projectionMessageBodyBytes(message);
+        if (selectedMessageBytes + bodyBytes > limitsArg.messageBytesLimit)
+            break;
+        selectedMessageBytes += bodyBytes;
+        selectedNewest.push(message);
+    }
+    const finalChain = buildChain(selectedNewest.reverse(), false, snapshotArg.messages.length - selectedNewest.length);
+    const messages = finalChain.messages;
+    const previous = messages.at(-1);
+    const latestMessage = previous
+        ? {
+            id: previous.id,
+            index: previous.index,
+            messageIndex: previous.messageIndex,
+            sha256: previous.sha256,
+            bytes: previous.bytes,
+            messageCreatedAt: previous.messageCreatedAt,
+            sessionId: previous.sessionId,
+            messageId: previous.messageId,
+        }
+        : undefined;
+    const messagesTruncated = retainedMessages.length < snapshotArg.messages.length
+        || messages.length < retainedMessages.length
+        || normalized.replaced;
+    const visibleHash = plugins.crypto.createHash('sha256');
+    visibleHash.update('order:1', 'utf8');
+    visibleHash.update(messagesTruncated ? '1' : '0', 'utf8');
+    for (const message of messages) {
+        visibleHash.update('\0', 'utf8');
+        visibleHash.update(String(message.messageIndex), 'utf8');
+        visibleHash.update('\0', 'utf8');
+        visibleHash.update(sha256(Buffer.from(canonicalJson(message.message), 'utf8')), 'utf8');
+    }
+    const unhashedManifest = {
+        candidateId: preparationArg.candidateId,
+        orderVersion: 1,
+        messageCount: messages.length,
+        messagesTruncated,
+        visibleDigest: visibleHash.digest('hex'),
+        ...(latestMessage === undefined ? {} : { latestMessage }),
+    };
+    const manifestBytes = projectionSourceManifestBytes(unhashedManifest);
+    const manifest = {
+        ...unhashedManifest,
+        sha256: sha256(manifestBytes),
+        bytes: manifestBytes.byteLength,
+    };
+    const source = {
+        id: projectionSourceDocumentId(preparationArg.candidateId),
+        controllerId: controllerIdArg,
+        scopeId: storageKeyArg,
+        sessionId: sessionIdArg,
+        incarnationId: preparationArg.incarnationId,
+        revision: preparationArg.revision,
+        ...manifest,
+        createdAt: preparationArg.createdAt,
+    };
+    assertFlexProjectionSourceDocument(source);
+    return { manifest, source, messages };
+};
+export const createFlexPublicProjection = (controllerIdArg, storageKeyArg, candidateIdArg, publicationRevisionArg, scopeSourceArg, projectionSourcesArg, createdAtArg = new Date().toISOString()) => {
+    const retainedSessions = retainPublicSessions(scopeSourceArg.snapshot.sessions);
+    const retainedSessionIds = new Set(retainedSessions.map((session) => session.sessionId));
+    const projectionBySession = new Map(projectionSourcesArg.map((source) => [
+        source.head.sessionId,
+        source,
+    ]));
+    const sessions = retainedSessions.map((session) => ({
+        id: publicSessionDocumentId(candidateIdArg, session.sessionId),
+        controllerId: controllerIdArg,
+        scopeId: storageKeyArg,
+        candidateId: candidateIdArg,
+        revision: publicationRevisionArg,
+        session: cloneJson(session),
+        createdAt: createdAtArg,
+    }));
+    const scopeSessionIds = new Set(scopeSourceArg.snapshot.sessions.map((session) => session.sessionId));
+    const originalMessageCount = projectionSourcesArg.reduce((total, source) => (source.head.sessionId && scopeSessionIds.has(source.head.sessionId)
+        ? total + source.snapshot.messages.length
+        : total), 0);
+    const sourceEntries = projectionSourcesArg.flatMap((source) => {
+        if (!source.head.sessionId || !retainedSessionIds.has(source.head.sessionId))
+            return [];
+        const sourceTail = source.snapshot.messages.slice(-flexPublicMessageLimit);
+        return sourceTail.length === 0 ? [] : [{
+                messages: sourceTail,
+                sourceIndex: sourceTail.length - 1,
+                messageIndex: source.snapshot.messages.length - 1,
+            }];
+    });
+    const allMessages = [];
+    while (sourceEntries.length > 0 && allMessages.length < flexPublicMessageLimit) {
+        let newestIndex = 0;
+        for (let index = 1; index < sourceEntries.length; index++) {
+            const candidate = sourceEntries[index];
+            const newest = sourceEntries[newestIndex];
+            if (compareNewestOrderedMessage({ messageIndex: candidate.messageIndex, message: candidate.messages[candidate.sourceIndex] }, { messageIndex: newest.messageIndex, message: newest.messages[newest.sourceIndex] }) < 0)
+                newestIndex = index;
+        }
+        const newest = sourceEntries[newestIndex];
+        allMessages.push({
+            messageIndex: newest.messageIndex,
+            message: newest.messages[newest.sourceIndex],
+        });
+        newest.sourceIndex -= 1;
+        newest.messageIndex -= 1;
+        if (newest.sourceIndex < 0)
+            sourceEntries.splice(newestIndex, 1);
+    }
+    const messages = [];
+    let messageBytes = 0;
+    let messageBytesTruncated = false;
+    let oversizedMessagesReplaced = false;
+    for (const sourceEntry of allMessages) {
+        if (messages.length >= flexPublicMessageLimit)
+            break;
+        const createRecord = (messageArg) => ({
+            id: publicMessageDocumentId(candidateIdArg, messageArg.sessionId, messageArg.messageId),
+            controllerId: controllerIdArg,
+            scopeId: storageKeyArg,
+            candidateId: candidateIdArg,
+            revision: publicationRevisionArg,
+            messageIndex: sourceEntry.messageIndex,
+            message: cloneJson(messageArg),
+            createdAt: createdAtArg,
+        });
+        let record = createRecord(sourceEntry.message);
+        let recordBytes = serializedBytes(record).byteLength;
+        if (recordBytes > flexPublicSingleMessageBytesLimit) {
+            record = createRecord(placeholderMessage(sourceEntry.message));
+            recordBytes = serializedBytes(record).byteLength;
+            oversizedMessagesReplaced = true;
+            if (recordBytes > flexPublicSingleMessageBytesLimit) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex public message metadata exceeds its projection limit.');
+            }
+        }
+        if (messageBytes + recordBytes > flexPublicMessageBytesLimit) {
+            messageBytesTruncated = true;
+            break;
+        }
+        messageBytes += recordBytes;
+        messages.push(record);
+    }
+    const sessionsTruncated = retainedSessions.length < scopeSourceArg.snapshot.sessions.length;
+    const messagesTruncated = sessionsTruncated
+        || messages.length < originalMessageCount
+        || oversizedMessagesReplaced;
+    const sessionRecords = sessions.map(recordManifest);
+    if (new Set(messages.map((record) => (`${record.message.sessionId}\0${record.messageIndex}`))).size !== messages.length) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex public projection contains duplicate message indexes.');
+    }
+    const messageRecords = messages.map(recordManifest);
+    const visibleDigest = sha256(serializedBytes({
+        sessions: sessions.map((record) => record.session),
+        messages: messages.map((record) => ({
+            messageIndex: record.messageIndex,
+            message: record.message,
+        })),
+        sessionsTruncated,
+        messagesTruncated,
+        messageBytesTruncated,
+    }));
+    const projectionSources = retainedSessions.flatMap((session) => {
+        const source = projectionBySession.get(session.sessionId);
+        return source ? [{
+                sessionId: session.sessionId,
+                incarnationId: source.head.incarnationId,
+                revision: source.head.revision,
+            }] : [];
+    });
+    const unhashedManifest = {
+        candidateId: candidateIdArg,
+        revision: publicationRevisionArg,
+        sessionRecords,
+        messageRecords,
+        sessionsTruncated,
+        messagesTruncated,
+        messageBytesTruncated,
+        visibleDigest,
+        scopeSource: {
+            incarnationId: scopeSourceArg.head.incarnationId,
+            revision: scopeSourceArg.head.revision,
+        },
+        projectionSources,
+    };
+    const candidateBytes = publicCandidateManifestBytes(unhashedManifest);
+    const candidate = {
+        id: publicCandidateDocumentId(candidateIdArg),
+        controllerId: controllerIdArg,
+        scopeId: storageKeyArg,
+        ...unhashedManifest,
+        sha256: sha256(candidateBytes),
+        bytes: candidateBytes.byteLength,
+        createdAt: createdAtArg,
+    };
+    assertFlexPublicCandidateDocument(candidate);
+    for (const session of sessions)
+        assertFlexPublicSessionRecordDocument(session);
+    for (const message of messages)
+        assertFlexPublicMessageRecordDocument(message);
+    return { candidate, sessions, messages };
+};
+class FlexLeaseLostError extends Error {
+    constructor(storageKeyArg) {
+        super(`Flex writer lease for storage key "${storageKeyArg}" is not owned or has expired.`);
+        this.name = 'FlexLeaseLostError';
+    }
+}
+class FlexHeadCasError extends Error {
+    actualRevision;
+    constructor(actualRevision) {
+        super('Flex head compare-and-swap did not match.');
+        this.actualRevision = actualRevision;
+        this.name = 'FlexHeadCasError';
+    }
+}
+const waitForFlexStoreDeadline = async (promiseArg, timeoutMsArg, messageArg) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(messageArg)), timeoutMsArg);
+    timer.unref?.();
+    void promiseArg.then(resolve, reject).finally(() => clearTimeout(timer));
+});
+const waitForFlexStoreRetry = async (timeoutMsArg, abortSignalArg) => new Promise((resolve, reject) => {
+    const timer = setTimeout(finish, timeoutMsArg);
+    timer.unref?.();
+    const abort = () => finish(abortSignalArg.reason, true);
+    function finish(errorArg, rejectedArg = false) {
+        clearTimeout(timer);
+        abortSignalArg?.removeEventListener('abort', abort);
+        if (rejectedArg)
+            reject(errorArg);
+        else
+            resolve();
+    }
+    if (abortSignalArg?.aborted)
+        abort();
+    else
+        abortSignalArg?.addEventListener('abort', abort, { once: true });
+});
+export class FlexStore {
+    scopes;
+    projections;
+    permissions;
+    projectManagement;
+    agentEvents;
+    jobs;
+    database;
+    controllerId;
+    onFatalError;
+    manager;
+    initialized = false;
+    initPromise;
+    closed = false;
+    closeComplete = false;
+    closePromise;
+    closeDrainTimeoutMs = flexMaintenanceOperationTimeoutMs;
+    maintenanceOpen = true;
+    maintenanceAbortController = new AbortController();
+    orphanMaintenanceTask;
+    orphanMaintenanceTimer;
+    heartbeatsOpen = true;
+    leaseHeartbeatTimer;
+    leaseTransitionTimeoutMs = flexLeaseTransitionTimeoutMs;
+    fatalError;
+    leaseTransitionAbortControllers = new Set();
+    heldLeases = new Map();
+    storageQueues = new Map();
+    activeCandidateIds = new Set();
+    agentEventStores = new Map();
+    jobStores = new Map();
+    constructor(optionsArg) {
+        assertIdentifier(optionsArg.controllerId, 'controllerId');
+        if (!optionsArg.projectManagementHost
+            || typeof optionsArg.projectManagementHost.load !== 'function'
+            || typeof optionsArg.projectManagementHost.save !== 'function'
+            || typeof optionsArg.projectManagementHost.tombstoneSession !== 'function'
+            || typeof optionsArg.projectManagementHost.purgeNamespace !== 'function')
+            throw new Error('FlexStore requires a durable project-management host.');
+        this.database = optionsArg.database;
+        this.controllerId = optionsArg.controllerId;
+        this.onFatalError = optionsArg.onFatalError;
+        this.manager = { db: this.database };
+        registerFlexPrivateModels(this.manager);
+        registerFlexPublicModels(this.manager);
+        this.scopes = {
+            load: (storageKey) => this.loadScope(storageKey),
+            save: (storageKey, snapshot, expectedRevision) => this.saveScope(storageKey, snapshot, expectedRevision),
+        };
+        this.projections = {
+            load: (storageKey, sessionId) => this.loadProjection(storageKey, sessionId),
+            save: (storageKey, sessionId, snapshot, expectedRevision) => this.saveProjection(storageKey, sessionId, snapshot, expectedRevision),
+            deleteSession: (storageKey, sessionId) => this.deleteProjection(storageKey, sessionId),
+        };
+        this.permissions = {
+            load: (storageKey, sessionId) => this.loadPermission(storageKey, sessionId),
+            save: (storageKey, sessionId, snapshot, expectedRevision) => this.savePermission(storageKey, sessionId, snapshot, expectedRevision),
+            deleteSession: (storageKey, sessionId) => this.deletePermission(storageKey, sessionId),
+        };
+        this.projectManagement = {
+            load: (storageKey, sessionId, sessionGeneration) => {
+                if (!sessionGeneration
+                    || typeof sessionGeneration.sessionGenerationId !== 'string'
+                    || sessionGeneration.sessionGenerationId.trim().length === 0
+                    || Buffer.byteLength(sessionGeneration.sessionGenerationId, 'utf8')
+                        > plugins.flexharness.FLEX_SESSION_GENERATION_ID_MAX_BYTES
+                    || !Number.isSafeInteger(sessionGeneration.sessionGenerationSequence)
+                    || sessionGeneration.sessionGenerationSequence < 1) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex project-management load requires an authoritative session generation.');
+                }
+                return optionsArg.projectManagementHost.load(storageKey, sessionId, sessionGeneration);
+            },
+            save: (storageKey, sessionId, snapshot, expectedRevision, writeContext) => optionsArg.projectManagementHost.save(storageKey, sessionId, snapshot, expectedRevision, writeContext),
+            tombstoneSession: (storageKey, sessionId, tombstone, expectedRevision) => optionsArg.projectManagementHost.tombstoneSession(storageKey, sessionId, tombstone, expectedRevision),
+            purgeNamespace: (storageKey) => optionsArg.projectManagementHost.purgeNamespace(storageKey),
+        };
+        this.agentEvents = {
+            getStore: (storageKey, sessionId) => this.getAgentEventStore(storageKey, sessionId),
+            releaseSession: (storageKey, sessionId) => {
+                this.agentEventStores.delete(providerKey(storageKey, sessionId));
+            },
+            deleteSession: (storageKey, sessionId) => this.deleteAgentEventSession(storageKey, sessionId),
+        };
+        this.jobs = {
+            getStore: (storageKey, sessionId) => this.getJobStore(storageKey, sessionId),
+            releaseSession: (storageKey, sessionId) => {
+                this.jobStores.delete(providerKey(storageKey, sessionId));
+            },
+            deleteSession: (storageKey, sessionId) => this.deleteJobSession(storageKey, sessionId),
+        };
+    }
+    async init() {
+        this.throwIfFatal();
+        if (this.closed)
+            throw new Error('The Flex store is closed.');
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        const initPromise = (async () => {
+            await initFlexPrivateModels();
+            await initFlexPublicModels();
+            this.initialized = true;
+            this.queueOrphanMaintenance();
+        })();
+        this.initPromise = initPromise;
+        try {
+            await initPromise;
+        }
+        finally {
+            if (this.initPromise === initPromise)
+                this.initPromise = undefined;
+        }
+    }
+    getLegacyMigrationStores() {
+        return {
+            scopes: {
+                ...this.scopes,
+                save: (storageKey, snapshot, expectedRevision) => this.saveScope(storageKey, snapshot, expectedRevision, false),
+            },
+            projections: {
+                ...this.projections,
+                save: (storageKey, sessionId, snapshot, expectedRevision) => this.saveProjection(storageKey, sessionId, snapshot, expectedRevision, false),
+            },
+            permissions: this.permissions,
+            projectManagement: this.projectManagement,
+            agentEvents: this.agentEvents,
+            jobs: this.jobs,
+        };
+    }
+    async loadLegacy(storageKeyArg) {
+        return this.runStorage(storageKeyArg, async () => {
+            const head = await this.readLegacyHead(storageKeyArg);
+            if (!head)
+                return undefined;
+            const manifest = head.privateCandidates.find((candidate) => candidate.candidateId === head.currentPrivateCandidateId);
+            if (!manifest || manifest.revision !== head.revision) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex legacy private head manifest is invalid.');
+            }
+            return this.loadPrivateCandidate(storageKeyArg, manifest, async (value) => value);
+        });
+    }
+    async hasCompletedLegacyMigration(storageKeyArg) {
+        return this.runStorage(storageKeyArg, async () => {
+            const marker = await this.readMigration(storageKeyArg);
+            if (!marker)
+                return false;
+            const legacyHead = await this.readLegacyHead(storageKeyArg);
+            if (!legacyHead
+                || marker.legacyRevision !== legacyHead.revision
+                || marker.legacyCandidateId !== legacyHead.currentPrivateCandidateId) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Completed Flex migration does not match its retained legacy source.');
+            }
+            return true;
+        });
+    }
+    async completeLegacyMigration(storageKeyArg) {
+        await this.runStorage(storageKeyArg, async (lease) => {
+            const legacyHead = await this.readLegacyHead(storageKeyArg);
+            if (!legacyHead) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Cannot complete Flex migration without its retained legacy source.');
+            }
+            const current = await this.readMigration(storageKeyArg);
+            if (current) {
+                if (current.legacyRevision !== legacyHead.revision
+                    || current.legacyCandidateId !== legacyHead.currentPrivateCandidateId) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Completed Flex migration does not match its retained legacy source.');
+                }
+                return;
+            }
+            const next = {
+                id: flexMigrationId(this.controllerId, storageKeyArg),
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                migration: 'flexharness-v3',
+                legacyRevision: legacyHead.revision,
+                legacyCandidateId: legacyHead.currentPrivateCandidateId,
+                completedAt: new Date().toISOString(),
+            };
+            assertFlexMigrationDocument(next);
+            await this.commitHeadMutation({
+                lease,
+                collection: FlexMigrationModel.collection.mongoDbCollection,
+                current: null,
+                next,
+                selector: { id: next.id },
+                readCurrent: (options) => this.readMigration(storageKeyArg, options),
+                project: migrationBody,
+                targetName: `migration:${next.id}`,
+            });
+        });
+    }
+    async ensurePublicProjection(storageKeyArg) {
+        await this.runStorage(storageKeyArg, async (lease) => this.publishPublicProjection(storageKeyArg, lease));
+    }
+    async listProjectionOrderMigrationPage(storageKeyArg, cursorArg) {
+        return this.runStorage(storageKeyArg, async () => {
+            const heads = await this.readDomainHeadPage({
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                domain: 'projection',
+            }, cursorArg);
+            const sessionIds = [];
+            for (const head of heads) {
+                if (!head.sessionId) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection head is missing its session identity.');
+                }
+                this.assertDomainHeadIdentity(head, {
+                    storageKey: storageKeyArg,
+                    domain: 'projection',
+                    sessionId: head.sessionId,
+                });
+                if (head.projectionSource?.orderVersion !== 1)
+                    sessionIds.push(head.sessionId);
+            }
+            const last = heads.at(-1);
+            return {
+                sessionIds,
+                ...(last && heads.length === flexMaintenancePageLimit ? { nextCursor: last._id } : {}),
+            };
+        });
+    }
+    async rewriteProjectionSourceOrder(storageKeyArg, sessionIdArg) {
+        return this.runStorage(storageKeyArg, async (lease) => {
+            const identity = {
+                storageKey: storageKeyArg,
+                domain: 'projection',
+                sessionId: sessionIdArg,
+            };
+            const current = await this.readDomainHead(identity);
+            if (!current || current.projectionSource?.orderVersion === 1)
+                return false;
+            const snapshot = await this.loadPrivateCandidate(storageKeyArg, current.privateCandidate, (value) => this.validateProjectionSnapshot(value, sessionIdArg), undefined, { identity, incarnationId: current.incarnationId });
+            const candidateId = randomCandidateId();
+            const build = createProjectionSource(this.controllerId, storageKeyArg, sessionIdArg, snapshot, {
+                candidateId,
+                incarnationId: current.incarnationId,
+                revision: current.revision,
+                createdAt: new Date().toISOString(),
+            });
+            const next = {
+                ...domainHeadBody(current),
+                projectionSource: build.manifest,
+            };
+            assertFlexDomainHeadDocument(next);
+            this.activeCandidateIds.add(candidateId);
+            let committed = false;
+            try {
+                await this.writeAndVerifyProjectionSource(build);
+                await this.commitDomainHead(lease, current, next, identity);
+                committed = true;
+                if (current.projectionSource) {
+                    await this.cleanupProjectionSourceByCandidate(current.projectionSource.candidateId).catch(() => undefined);
+                }
+            }
+            finally {
+                this.activeCandidateIds.delete(candidateId);
+                if (!committed)
+                    this.queueOrphanMaintenance();
+            }
+            return true;
+        });
+    }
+    async purgeScope(storageKeyArg) {
+        await this.runStorage(storageKeyArg, async (lease) => {
+            this.evictProviderScope(storageKeyArg);
+            let lastDomainHeadId;
+            while (true) {
+                const domainHeads = await this.readDomainHeadPage({
+                    controllerId: this.controllerId,
+                    storageKey: storageKeyArg,
+                }, lastDomainHeadId);
+                for (const head of domainHeads) {
+                    const identity = {
+                        storageKey: storageKeyArg,
+                        domain: head.domain,
+                        ...(head.sessionId !== undefined ? { sessionId: head.sessionId } : {}),
+                        ...(head.archiveId !== undefined ? { archiveId: head.archiveId } : {}),
+                    };
+                    this.assertDomainHeadIdentity(head, identity);
+                    await this.deleteDomainHead(lease, head, identity);
+                }
+                const last = domainHeads.at(-1);
+                if (!last || domainHeads.length < flexMaintenancePageLimit)
+                    break;
+                lastDomainHeadId = last._id;
+            }
+            const publicHead = await this.readPublicHead(storageKeyArg);
+            if (publicHead)
+                await this.deletePublicHead(lease, publicHead, storageKeyArg);
+            const migration = await this.readMigration(storageKeyArg);
+            if (migration) {
+                await this.commitHeadMutation({
+                    lease,
+                    collection: FlexMigrationModel.collection.mongoDbCollection,
+                    current: migration,
+                    next: null,
+                    selector: {
+                        _id: migration._id,
+                        id: migration.id,
+                        controllerId: this.controllerId,
+                        storageKey: storageKeyArg,
+                        _smartdataRevision: smartRevisionSelector(migration),
+                    },
+                    readCurrent: (options) => this.readMigration(storageKeyArg, options),
+                    project: migrationBody,
+                    targetName: `migration:${migration.id}`,
+                });
+            }
+            const legacyRaw = await FlexHeadModel.collection.mongoDbCollection.findOne({
+                id: flexHeadId(this.controllerId, storageKeyArg),
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+            });
+            if (legacyRaw) {
+                await this.commitHeadMutation({
+                    lease,
+                    collection: FlexHeadModel.collection.mongoDbCollection,
+                    current: legacyRaw,
+                    next: null,
+                    selector: {
+                        _id: legacyRaw._id,
+                        id: flexHeadId(this.controllerId, storageKeyArg),
+                        controllerId: this.controllerId,
+                        storageKey: storageKeyArg,
+                        _smartdataRevision: smartRevisionSelector(legacyRaw),
+                    },
+                    readCurrent: async (options) => await FlexHeadModel.collection.mongoDbCollection.findOne({
+                        id: flexHeadId(this.controllerId, storageKeyArg),
+                    }, options),
+                    project: (value) => value,
+                    targetName: `legacy:${storageKeyArg}`,
+                });
+            }
+            await this.deleteScopeRecords(lease, storageKeyArg);
+            const remaining = await Promise.all([
+                FlexDomainHeadModel.exact.count({ controllerId: this.controllerId, storageKey: storageKeyArg }),
+                FlexPublicHeadModel.exact.count({ controllerId: this.controllerId, storageKey: storageKeyArg }),
+                FlexMigrationModel.exact.count({ controllerId: this.controllerId, storageKey: storageKeyArg }),
+                FlexHeadModel.collection.mongoDbCollection.countDocuments({
+                    controllerId: this.controllerId,
+                    storageKey: storageKeyArg,
+                }),
+            ]);
+            if (remaining.some((count) => count !== 0)) {
+                throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', 'Flex scope purge could not confirm all head deletions.');
+            }
+            await this.releaseHeldLease(lease);
+        });
+    }
+    async reconcileOrphans(nowArg = Date.now(), abortSignalArg) {
+        await this.init();
+        abortSignalArg?.throwIfAborted();
+        const cutoff = new Date(nowArg - flexOrphanGraceMs).toISOString();
+        await this.reconcileCandidateOrphans('private', cutoff, abortSignalArg);
+        await this.reconcileCandidateOrphans('public', cutoff, abortSignalArg);
+        await this.reconcileCandidateOrphans('projectionSource', cutoff, abortSignalArg);
+    }
+    async close() {
+        if (this.closeComplete)
+            return;
+        if (this.closePromise)
+            return this.closePromise;
+        const closePromise = (async () => {
+            const errors = [];
+            this.closed = true;
+            for (const controller of this.leaseTransitionAbortControllers) {
+                controller.abort(new Error('The Flex store is closing.'));
+            }
+            this.maintenanceOpen = false;
+            this.maintenanceAbortController.abort(new Error('The Flex store is closing.'));
+            if (this.orphanMaintenanceTimer) {
+                clearTimeout(this.orphanMaintenanceTimer);
+                this.orphanMaintenanceTimer = undefined;
+            }
+            if (this.orphanMaintenanceTask) {
+                try {
+                    await waitForFlexStoreDeadline(this.orphanMaintenanceTask, this.closeDrainTimeoutMs, 'Flex orphan maintenance did not stop before the close deadline.');
+                }
+                catch (errorArg) {
+                    errors.push(errorArg);
+                }
+            }
+            try {
+                await waitForFlexStoreDeadline(Promise.allSettled([...this.storageQueues.values()]), this.closeDrainTimeoutMs, 'Flex storage operations did not drain before the close deadline.');
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+                for (const controller of this.leaseTransitionAbortControllers) {
+                    controller.abort(errorArg);
+                }
+            }
+            this.heartbeatsOpen = false;
+            if (this.leaseHeartbeatTimer) {
+                clearInterval(this.leaseHeartbeatTimer);
+                this.leaseHeartbeatTimer = undefined;
+            }
+            this.agentEventStores.clear();
+            this.jobStores.clear();
+            const releaseResults = await Promise.allSettled([...this.heldLeases.values()].map((lease) => this.releaseHeldLease(lease, this.closeDrainTimeoutMs)));
+            errors.push(...releaseResults
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason));
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'Flex store close failed.');
+            this.closeComplete = true;
+        })();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+        }
+        finally {
+            if (!this.closeComplete && this.closePromise === closePromise)
+                this.closePromise = undefined;
+        }
+    }
+    async loadScope(storageKeyArg) {
+        return this.runStorage(storageKeyArg, async () => (await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'scope' }, (value) => this.validateScopeSnapshot(value)))?.snapshot);
+    }
+    async saveScope(storageKeyArg, snapshotArg, expectedRevisionArg, publishPublicProjectionArg = true) {
+        assertExpectedNextRevision(snapshotArg.revision, expectedRevisionArg);
+        const snapshot = await this.validateScopeSnapshot(snapshotArg);
+        await this.runStorage(storageKeyArg, async (lease) => {
+            await this.saveDomain(lease, { storageKey: storageKeyArg, domain: 'scope' }, snapshot, expectedRevisionArg, (actual) => new plugins.flexharness.FlexHarnessStoreConflictError(storageKeyArg, expectedRevisionArg, actual));
+            if (!publishPublicProjectionArg)
+                return;
+            try {
+                await this.publishPublicProjection(storageKeyArg, lease);
+            }
+            catch (errorArg) {
+                throw new plugins.flexharness.FlexHarnessStoreCommitUncertainError(flexPublicHeadId(this.controllerId, storageKeyArg), 'write', { cause: errorArg });
+            }
+        });
+    }
+    async loadProjection(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        return this.runStorage(storageKeyArg, async () => (await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'projection', sessionId: sessionIdArg }, (value) => this.validateProjectionSnapshot(value, sessionIdArg)))?.snapshot);
+    }
+    async saveProjection(storageKeyArg, sessionIdArg, snapshotArg, expectedRevisionArg, publishPublicProjectionArg = true) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        assertExpectedNextRevision(snapshotArg.revision, expectedRevisionArg);
+        const snapshot = await this.validateProjectionSnapshot(snapshotArg, sessionIdArg);
+        await this.runStorage(storageKeyArg, async (lease) => {
+            let visibleSourceChanged = true;
+            await this.saveDomain(lease, { storageKey: storageKeyArg, domain: 'projection', sessionId: sessionIdArg }, snapshot, expectedRevisionArg, (actual) => new plugins.flexharness.FlexHarnessStoreConflictError(providerKey(storageKeyArg, sessionIdArg), expectedRevisionArg, actual), undefined, undefined, async (preparation, current) => {
+                const source = createProjectionSource(this.controllerId, storageKeyArg, sessionIdArg, snapshot, preparation);
+                if (current?.projectionSource?.orderVersion === 1
+                    && current.projectionSource.visibleDigest === source.manifest.visibleDigest) {
+                    await this.loadProjectionSource(current);
+                    visibleSourceChanged = false;
+                    return current.projectionSource;
+                }
+                await this.writeAndVerifyProjectionSource(source);
+                return source.manifest;
+            });
+            if (!visibleSourceChanged || !publishPublicProjectionArg)
+                return;
+            try {
+                await this.publishPublicProjection(storageKeyArg, lease);
+            }
+            catch (errorArg) {
+                throw new plugins.flexharness.FlexHarnessStoreCommitUncertainError(flexPublicHeadId(this.controllerId, storageKeyArg), 'write', { cause: errorArg });
+            }
+        });
+    }
+    async deleteProjection(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        await this.runStorage(storageKeyArg, async (lease) => {
+            const identity = {
+                storageKey: storageKeyArg,
+                domain: 'projection',
+                sessionId: sessionIdArg,
+            };
+            const head = await this.readDomainHead(identity);
+            if (head)
+                await this.deleteDomainHead(lease, head, identity);
+            try {
+                await this.publishPublicProjection(storageKeyArg, lease);
+            }
+            catch (errorArg) {
+                throw new plugins.flexharness.FlexHarnessStoreCommitUncertainError(flexPublicHeadId(this.controllerId, storageKeyArg), 'write', { cause: errorArg });
+            }
+        });
+    }
+    async loadPermission(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        return this.runStorage(storageKeyArg, async () => (await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'permission', sessionId: sessionIdArg }, (value) => this.validatePermissionSnapshot(value)))?.snapshot);
+    }
+    async savePermission(storageKeyArg, sessionIdArg, snapshotArg, expectedRevisionArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        assertExpectedNextRevision(snapshotArg.revision, expectedRevisionArg);
+        const snapshot = await this.validatePermissionSnapshot(snapshotArg);
+        await this.runStorage(storageKeyArg, async (lease) => {
+            await this.saveDomain(lease, { storageKey: storageKeyArg, domain: 'permission', sessionId: sessionIdArg }, snapshot, expectedRevisionArg, (actual) => new plugins.flexharness.FlexHarnessStoreConflictError(providerKey(storageKeyArg, sessionIdArg), expectedRevisionArg, actual));
+        });
+    }
+    async deletePermission(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        await this.runStorage(storageKeyArg, async (lease) => {
+            const identity = {
+                storageKey: storageKeyArg,
+                domain: 'permission',
+                sessionId: sessionIdArg,
+            };
+            const head = await this.readDomainHead(identity);
+            if (head)
+                await this.deleteDomainHead(lease, head, identity);
+        });
+    }
+    async getAgentEventStore(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        return this.runStorage(storageKeyArg, async () => {
+            const key = providerKey(storageKeyArg, sessionIdArg);
+            const existing = this.agentEventStores.get(key);
+            if (existing)
+                return existing;
+            const wrapper = {
+                eventSchemaVersion: 2,
+                load: (sessionId) => this.loadAgentEventSnapshot(storageKeyArg, sessionIdArg, sessionId),
+                save: (sessionId, events, expectedRevision) => this.saveAgentEventSnapshot(storageKeyArg, sessionIdArg, sessionId, events, expectedRevision),
+                archive: (archive) => this.saveAgentEventArchive(storageKeyArg, sessionIdArg, archive),
+                loadArchive: (sessionId, archiveId) => this.loadAgentEventArchive(storageKeyArg, sessionIdArg, sessionId, archiveId),
+            };
+            this.agentEventStores.set(key, wrapper);
+            return wrapper;
+        });
+    }
+    assertBoundSession(boundSessionIdArg, requestedSessionIdArg) {
+        if (boundSessionIdArg !== requestedSessionIdArg) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError(`Store is bound to session "${boundSessionIdArg}", not "${requestedSessionIdArg}".`);
+        }
+    }
+    async loadAgentEventSnapshot(storageKeyArg, boundSessionIdArg, sessionIdArg) {
+        this.assertBoundSession(boundSessionIdArg, sessionIdArg);
+        return this.runStorage(storageKeyArg, async () => (await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'agentEvents', sessionId: sessionIdArg }, (value) => this.validateAgentEventSnapshot(value, sessionIdArg)))?.snapshot);
+    }
+    async saveAgentEventSnapshot(storageKeyArg, boundSessionIdArg, sessionIdArg, eventsArg, expectedRevisionArg) {
+        this.assertBoundSession(boundSessionIdArg, sessionIdArg);
+        assertExpectedNextRevision(expectedRevisionArg + 1, expectedRevisionArg);
+        const snapshot = this.validateAgentEventSnapshot({
+            schemaVersion: 2,
+            sessionId: sessionIdArg,
+            revision: expectedRevisionArg + 1,
+            updatedAt: eventsArg.reduce((latest, event) => Math.max(latest, event.timestamp), 0),
+            events: cloneJson([...eventsArg], '$events'),
+        }, sessionIdArg);
+        await this.runStorage(storageKeyArg, async (lease) => {
+            await this.saveDomain(lease, { storageKey: storageKeyArg, domain: 'agentEvents', sessionId: sessionIdArg }, snapshot, expectedRevisionArg, (actual) => new plugins.smartagent.AgentEventStoreConflictError(sessionIdArg, expectedRevisionArg, actual));
+        });
+        return snapshot.revision;
+    }
+    async saveAgentEventArchive(storageKeyArg, boundSessionIdArg, archiveArg) {
+        this.assertBoundSession(boundSessionIdArg, archiveArg.sessionId);
+        assertIdentifier(archiveArg.archiveId, 'archiveId');
+        const archive = this.validateAgentEventArchive(cloneJson(archiveArg, '$archive'), boundSessionIdArg, archiveArg.archiveId);
+        await this.runStorage(storageKeyArg, async (lease) => {
+            const identity = {
+                storageKey: storageKeyArg,
+                domain: 'agentArchive',
+                sessionId: boundSessionIdArg,
+                archiveId: archive.archiveId,
+            };
+            const current = await this.loadDomainDirect(identity, (value) => this.validateAgentEventArchive(value, boundSessionIdArg, archive.archiveId));
+            if (current) {
+                if (canonicalJson(current.snapshot) !== canonicalJson(archive)) {
+                    throw new Error(`Archive "${archive.archiveId}" already exists with different content.`);
+                }
+                return;
+            }
+            try {
+                await this.saveDomain(lease, identity, archive, 0, () => new Error(`Archive "${archive.archiveId}" already exists.`), 1);
+            }
+            catch (errorArg) {
+                const reconciled = await this.loadDomainDirect(identity, (value) => this.validateAgentEventArchive(value, boundSessionIdArg, archive.archiveId));
+                if (reconciled && canonicalJson(reconciled.snapshot) === canonicalJson(archive))
+                    return;
+                throw errorArg;
+            }
+        });
+    }
+    async loadAgentEventArchive(storageKeyArg, boundSessionIdArg, sessionIdArg, archiveIdArg) {
+        this.assertBoundSession(boundSessionIdArg, sessionIdArg);
+        assertIdentifier(archiveIdArg, 'archiveId');
+        return this.runStorage(storageKeyArg, async () => (await this.loadDomainDirect({
+            storageKey: storageKeyArg,
+            domain: 'agentArchive',
+            sessionId: sessionIdArg,
+            archiveId: archiveIdArg,
+        }, (value) => this.validateAgentEventArchive(value, sessionIdArg, archiveIdArg)))?.snapshot);
+    }
+    async deleteAgentEventSession(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        await this.runStorage(storageKeyArg, async (lease) => {
+            let lastId;
+            while (true) {
+                const heads = await this.readDomainHeadPage({
+                    controllerId: this.controllerId,
+                    storageKey: storageKeyArg,
+                    sessionId: sessionIdArg,
+                    domain: { $in: ['agentEvents', 'agentArchive'] },
+                }, lastId);
+                for (const head of heads) {
+                    const identity = {
+                        storageKey: storageKeyArg,
+                        domain: head.domain,
+                        sessionId: sessionIdArg,
+                        ...(head.archiveId !== undefined ? { archiveId: head.archiveId } : {}),
+                    };
+                    this.assertDomainHeadIdentity(head, identity);
+                    await this.deleteDomainHead(lease, head, identity);
+                }
+                const last = heads.at(-1);
+                if (!last || heads.length < flexMaintenancePageLimit)
+                    break;
+                lastId = last._id;
+            }
+            this.agentEventStores.delete(providerKey(storageKeyArg, sessionIdArg));
+        });
+    }
+    async getJobStore(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        return this.runStorage(storageKeyArg, async () => {
+            const key = providerKey(storageKeyArg, sessionIdArg);
+            const existing = this.jobStores.get(key);
+            if (existing)
+                return existing;
+            const wrapper = {
+                load: (abortSignal) => this.loadJobSnapshot(storageKeyArg, sessionIdArg, abortSignal),
+                save: (jobs, expectedRevision, abortSignal) => this.saveJobSnapshot(storageKeyArg, sessionIdArg, jobs, expectedRevision, abortSignal),
+            };
+            this.jobStores.set(key, wrapper);
+            return wrapper;
+        });
+    }
+    async loadJobSnapshot(storageKeyArg, sessionIdArg, abortSignalArg) {
+        abortSignalArg?.throwIfAborted();
+        const result = await this.runStorage(storageKeyArg, async () => {
+            abortSignalArg?.throwIfAborted();
+            const loaded = await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'jobs', sessionId: sessionIdArg }, (value) => this.validateToolJobSnapshot(value), abortSignalArg);
+            abortSignalArg?.throwIfAborted();
+            return loaded?.snapshot;
+        });
+        abortSignalArg?.throwIfAborted();
+        return result;
+    }
+    async saveJobSnapshot(storageKeyArg, sessionIdArg, jobsArg, expectedRevisionArg, abortSignalArg) {
+        abortSignalArg?.throwIfAborted();
+        assertExpectedNextRevision(expectedRevisionArg + 1, expectedRevisionArg);
+        const snapshot = this.validateToolJobSnapshot({
+            schemaVersion: 1,
+            revision: expectedRevisionArg + 1,
+            updatedAt: Date.now(),
+            jobs: cloneJson([...jobsArg], '$jobs'),
+        });
+        await this.runStorage(storageKeyArg, async (lease) => {
+            abortSignalArg?.throwIfAborted();
+            await this.saveDomain(lease, { storageKey: storageKeyArg, domain: 'jobs', sessionId: sessionIdArg }, snapshot, expectedRevisionArg, (actual) => new plugins.smartagentTools.ToolJobStoreConflictError(expectedRevisionArg, actual), snapshot.revision, abortSignalArg);
+        });
+        return snapshot.revision;
+    }
+    async deleteJobSession(storageKeyArg, sessionIdArg) {
+        assertIdentifier(sessionIdArg, 'sessionId');
+        await this.runStorage(storageKeyArg, async (lease) => {
+            const identity = {
+                storageKey: storageKeyArg,
+                domain: 'jobs',
+                sessionId: sessionIdArg,
+            };
+            const head = await this.readDomainHead(identity);
+            if (head)
+                await this.deleteDomainHead(lease, head, identity);
+            this.jobStores.delete(providerKey(storageKeyArg, sessionIdArg));
+        });
+    }
+    async validateScopeSnapshot(valueArg) {
+        const value = valueArg;
+        if (!Number.isSafeInteger(value?.revision) || value.revision < 0) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid scope snapshot revision.');
+        }
+        const stores = new plugins.flexharness.InMemoryFlexHarnessStores();
+        await stores.scopes.save('__validation__', { ...value, revision: 1 }, 0);
+        return cloneJson(value);
+    }
+    async validateProjectionSnapshot(valueArg, sessionIdArg) {
+        const value = valueArg;
+        if (!Number.isSafeInteger(value?.revision) || value.revision < 0) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid projection snapshot revision.');
+        }
+        const stores = new plugins.flexharness.InMemoryFlexHarnessStores();
+        await stores.projections.save('__validation__', sessionIdArg, { ...value, revision: 1 }, 0);
+        return cloneJson(value);
+    }
+    async validatePermissionSnapshot(valueArg) {
+        const value = valueArg;
+        if (!Number.isSafeInteger(value?.revision) || value.revision < 0) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid permission snapshot revision.');
+        }
+        const stores = new plugins.flexharness.InMemoryFlexHarnessStores();
+        await stores.permissions.save('__validation__', '__validation__', { ...value, revision: 1 }, 0);
+        return cloneJson(value);
+    }
+    validateAgentEventSnapshot(valueArg, sessionIdArg) {
+        try {
+            return cloneJson(plugins.smartagent.validateAgentEventSnapshotV2(valueArg, sessionIdArg));
+        }
+        catch (errorArg) {
+            if (errorArg instanceof plugins.flexharness.FlexHarnessStoreFormatError)
+                throw errorArg;
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid schema-2 Agent event snapshot.', { cause: errorArg });
+        }
+    }
+    validateAgentEventArchive(valueArg, sessionIdArg, archiveIdArg) {
+        try {
+            return cloneJson(plugins.smartagent.validateAgentEventArchiveV2(valueArg, sessionIdArg, archiveIdArg));
+        }
+        catch (errorArg) {
+            if (errorArg instanceof plugins.flexharness.FlexHarnessStoreFormatError)
+                throw errorArg;
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid schema-2 Agent event archive.', { cause: errorArg });
+        }
+    }
+    validateToolJobSnapshot(valueArg) {
+        const value = cloneJson(valueArg);
+        if (!value
+            || value.schemaVersion !== 1
+            || !Number.isSafeInteger(value.revision)
+            || (value.revision ?? -1) < 1
+            || !Number.isSafeInteger(value.updatedAt)
+            || (value.updatedAt ?? -1) < 0
+            || !Array.isArray(value.jobs)
+            || Object.keys(value).some((key) => !['schemaVersion', 'revision', 'updatedAt', 'jobs'].includes(key))) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job snapshot.');
+        }
+        const executionIds = new Set();
+        for (const job of value.jobs) {
+            if (!job
+                || typeof job !== 'object'
+                || Array.isArray(job)
+                || typeof job.executionId !== 'string'
+                || job.executionId.length === 0
+                || executionIds.has(job.executionId)
+                || typeof job.type !== 'string'
+                || job.type.length === 0
+                || !['running', 'finished', 'failed', 'aborted'].includes(job.state)
+                || Object.keys(job).some((key) => ![
+                    'executionId', 'type', 'state', 'request', 'exitCode', 'stdout', 'stderr', 'signal',
+                    'startedAt', 'updatedAt', 'finishedAt',
+                ].includes(key))) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job state.');
+            }
+            executionIds.add(job.executionId);
+            if ((job.exitCode !== undefined && job.exitCode !== null && !Number.isSafeInteger(job.exitCode))
+                || (job.stdout !== undefined && typeof job.stdout !== 'string')
+                || (job.stderr !== undefined && typeof job.stderr !== 'string')
+                || (job.signal !== undefined && typeof job.signal !== 'string')
+                || [job.startedAt, job.updatedAt, job.finishedAt].some((time) => (time !== undefined && (!Number.isSafeInteger(time) || time < 0)))) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job state values.');
+            }
+            if (job.request !== undefined) {
+                const request = job.request;
+                if (!request
+                    || typeof request !== 'object'
+                    || Array.isArray(request)
+                    || typeof request.type !== 'string'
+                    || request.type.length === 0
+                    || Object.keys(request).some((key) => ![
+                        'type', 'command', 'cwd', 'timeoutMs', 'metadata',
+                    ].includes(key))
+                    || (request.cwd !== undefined && typeof request.cwd !== 'string')
+                    || (request.timeoutMs !== undefined && (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs < 0))) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job request.');
+                }
+                if (request.command !== undefined && (!request.command
+                    || typeof request.command !== 'object'
+                    || Array.isArray(request.command)
+                    || typeof request.command.executable !== 'string'
+                    || request.command.executable.length === 0
+                    || !Array.isArray(request.command.args)
+                    || !request.command.args.every((argument) => typeof argument === 'string')
+                    || Object.keys(request.command).some((key) => !['executable', 'args'].includes(key)))) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job command.');
+                }
+                if (request.metadata !== undefined && (!request.metadata
+                    || typeof request.metadata !== 'object'
+                    || Array.isArray(request.metadata))) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid tool job metadata.');
+                }
+            }
+        }
+        return value;
+    }
+    async saveDomain(leaseArg, identityArg, snapshotArg, expectedRevisionArg, conflictArg, revisionArg = snapshotArg.revision, abortSignalArg, prepareCandidateArg) {
+        if (!Number.isSafeInteger(revisionArg) || Number(revisionArg) < 1) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Invalid domain revision.');
+        }
+        const revision = Number(revisionArg);
+        const current = await this.readDomainHead(identityArg);
+        const actualRevision = current?.revision ?? 0;
+        if (actualRevision !== expectedRevisionArg)
+            throw conflictArg(actualRevision);
+        abortSignalArg?.throwIfAborted();
+        const candidateId = randomCandidateId();
+        const createdAt = new Date().toISOString();
+        const incarnationId = current?.incarnationId ?? randomCandidateId();
+        const projection = createPrivateProjection(this.controllerId, identityArg.storageKey, candidateId, revision, snapshotArg, createdAt, { identity: identityArg, incarnationId });
+        const manifest = {
+            candidateId,
+            revision,
+            sha256: projection.candidate.sha256,
+            bytes: projection.candidate.bytes,
+            chunks: projection.candidate.chunks,
+        };
+        this.activeCandidateIds.add(candidateId);
+        let committed = false;
+        try {
+            await this.writeAndVerifyPrivate(projection.candidate, projection.chunks, abortSignalArg);
+            abortSignalArg?.throwIfAborted();
+            const projectionSource = await prepareCandidateArg?.({
+                candidateId,
+                incarnationId,
+                revision,
+                createdAt,
+            }, current);
+            abortSignalArg?.throwIfAborted();
+            const next = {
+                id: flexDomainHeadId(this.controllerId, identityArg.storageKey, identityArg.domain, identityArg.sessionId, identityArg.archiveId),
+                controllerId: this.controllerId,
+                storageKey: identityArg.storageKey,
+                domain: identityArg.domain,
+                incarnationId,
+                revision,
+                currentPrivateCandidateId: candidateId,
+                privateCandidate: manifest,
+                ...(projectionSource === undefined ? {} : { projectionSource }),
+                ...(identityArg.sessionId !== undefined ? { sessionId: identityArg.sessionId } : {}),
+                ...(identityArg.archiveId !== undefined ? { archiveId: identityArg.archiveId } : {}),
+            };
+            assertFlexDomainHeadDocument(next);
+            this.assertDomainHeadIdentity(next, identityArg);
+            try {
+                await this.commitDomainHead(leaseArg, current, next, identityArg);
+            }
+            catch (errorArg) {
+                if (errorArg instanceof FlexHeadCasError)
+                    throw conflictArg(errorArg.actualRevision);
+                throw errorArg;
+            }
+            committed = true;
+            if (current) {
+                await this.cleanupPrivateByCandidate(current.privateCandidate).catch(() => undefined);
+                if (current.domain === 'projection'
+                    && current.projectionSource?.candidateId !== projectionSource?.candidateId) {
+                    await this.cleanupProjectionSourceByCandidate(current.projectionSource.candidateId).catch(() => undefined);
+                }
+            }
+            return await this.readDomainHead(identityArg) ?? (() => {
+                throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', 'Committed Flex domain head is missing on readback.');
+            })();
+        }
+        finally {
+            if (!committed)
+                this.queueOrphanMaintenance();
+            this.activeCandidateIds.delete(candidateId);
+        }
+    }
+    async loadDomainDirect(identityArg, validateArg, abortSignalArg) {
+        abortSignalArg?.throwIfAborted();
+        const head = await this.readDomainHead(identityArg);
+        if (!head)
+            return undefined;
+        const snapshot = await this.loadPrivateCandidate(identityArg.storageKey, head.privateCandidate, validateArg, abortSignalArg, { identity: identityArg, incarnationId: head.incarnationId });
+        abortSignalArg?.throwIfAborted();
+        const snapshotRevision = snapshot.revision;
+        if (identityArg.domain !== 'agentArchive'
+            && snapshotRevision !== head.revision) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex domain snapshot revision does not match its head.');
+        }
+        return { head, snapshot };
+    }
+    async readLegacyHead(storageKeyArg, optionsArg) {
+        const expectedId = flexHeadId(this.controllerId, storageKeyArg);
+        const raw = await FlexHeadModel.collection.mongoDbCollection.findOne({ id: expectedId }, optionsArg);
+        const head = raw;
+        if (!head)
+            return null;
+        const body = {
+            id: head.id,
+            controllerId: head.controllerId,
+            storageKey: head.storageKey,
+            revision: head.revision,
+            currentPrivateCandidateId: head.currentPrivateCandidateId,
+            currentPublicCandidateId: head.currentPublicCandidateId,
+            privateCandidates: head.privateCandidates,
+            publicCandidates: head.publicCandidates,
+        };
+        try {
+            assertFlexHeadDocument(body);
+        }
+        catch (errorArg) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex legacy head is invalid.', { cause: errorArg });
+        }
+        if (body.id !== expectedId
+            || body.controllerId !== this.controllerId
+            || body.storageKey !== storageKeyArg) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex legacy head identity mismatch.');
+        }
+        return head;
+    }
+    async readMigration(storageKeyArg, optionsArg) {
+        const expectedId = flexMigrationId(this.controllerId, storageKeyArg);
+        const marker = await FlexMigrationModel.collection.mongoDbCollection.findOne({ id: expectedId }, optionsArg);
+        if (!marker)
+            return null;
+        const body = migrationBody(marker);
+        try {
+            assertFlexMigrationDocument(body);
+        }
+        catch (errorArg) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex migration marker is invalid.', { cause: errorArg });
+        }
+        if (body.id !== expectedId
+            || body.controllerId !== this.controllerId
+            || body.storageKey !== storageKeyArg) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex migration marker identity mismatch.');
+        }
+        return marker;
+    }
+    async readDomainHead(identityArg, optionsArg) {
+        const id = flexDomainHeadId(this.controllerId, identityArg.storageKey, identityArg.domain, identityArg.sessionId, identityArg.archiveId);
+        const head = await FlexDomainHeadModel.collection.mongoDbCollection.findOne({ id }, optionsArg);
+        if (head)
+            this.assertDomainHeadIdentity(head, identityArg);
+        return head;
+    }
+    async readDomainHeadPage(filterArg, lastIdArg) {
+        const cursor = FlexDomainHeadModel.collection.mongoDbCollection.find({
+            ...filterArg,
+            ...(lastIdArg ? { _id: { $gt: lastIdArg } } : {}),
+        }).sort({ _id: 1 }).limit(flexMaintenancePageLimit);
+        try {
+            return await cursor.toArray();
+        }
+        finally {
+            await cursor.close();
+        }
+    }
+    assertDomainHeadIdentity(headArg, identityArg) {
+        const body = domainHeadBody(headArg);
+        assertFlexDomainHeadDocument(body);
+        if (body.id !== flexDomainHeadId(this.controllerId, identityArg.storageKey, identityArg.domain, identityArg.sessionId, identityArg.archiveId)
+            || body.controllerId !== this.controllerId
+            || body.storageKey !== identityArg.storageKey
+            || body.domain !== identityArg.domain
+            || body.sessionId !== identityArg.sessionId
+            || body.archiveId !== identityArg.archiveId) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex domain head identity mismatch.');
+        }
+    }
+    async commitDomainHead(leaseArg, currentArg, nextArg, identityArg) {
+        await this.commitHeadMutation({
+            lease: leaseArg,
+            collection: FlexDomainHeadModel.collection.mongoDbCollection,
+            current: currentArg,
+            next: nextArg,
+            selector: currentArg ? {
+                _id: currentArg._id,
+                id: currentArg.id,
+                controllerId: this.controllerId,
+                storageKey: identityArg.storageKey,
+                domain: identityArg.domain,
+                revision: currentArg.revision,
+                _smartdataRevision: smartRevisionSelector(currentArg),
+            } : { id: nextArg.id },
+            readCurrent: (options) => this.readDomainHead(identityArg, options),
+            project: domainHeadBody,
+            targetName: `domain:${nextArg.id}`,
+        });
+    }
+    async deleteDomainHead(leaseArg, headArg, identityArg) {
+        await this.commitHeadMutation({
+            lease: leaseArg,
+            collection: FlexDomainHeadModel.collection.mongoDbCollection,
+            current: headArg,
+            next: null,
+            selector: {
+                _id: headArg._id,
+                id: headArg.id,
+                controllerId: this.controllerId,
+                storageKey: identityArg.storageKey,
+                domain: identityArg.domain,
+                revision: headArg.revision,
+                _smartdataRevision: smartRevisionSelector(headArg),
+            },
+            readCurrent: (options) => this.readDomainHead(identityArg, options),
+            project: domainHeadBody,
+            targetName: `domain:${headArg.id}`,
+        });
+        await this.cleanupPrivateByCandidate(headArg.privateCandidate).catch(() => undefined);
+        if (headArg.domain === 'projection') {
+            await this.cleanupProjectionSourceByCandidate(headArg.projectionSource.candidateId).catch(() => undefined);
+        }
+    }
+    async loadPrivateCandidate(storageKeyArg, manifestArg, validateArg, abortSignalArg, sourceArg) {
+        abortSignalArg?.throwIfAborted();
+        const candidateModel = await FlexPrivateCandidateModel.getInstance({
+            id: privateCandidateDocumentId(manifestArg.candidateId),
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            candidateId: manifestArg.candidateId,
+        });
+        if (!candidateModel) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private candidate is missing.');
+        }
+        const candidate = projectPrivateCandidate(candidateModel);
+        assertFlexPrivateCandidateDocument(candidate);
+        if (candidate.id !== privateCandidateDocumentId(manifestArg.candidateId)
+            || candidate.controllerId !== this.controllerId
+            || candidate.scopeId !== storageKeyArg
+            || candidate.candidateId !== manifestArg.candidateId
+            || !privateChunkManifestsEqual(candidate.chunks, manifestArg.chunks)
+            || candidate.sha256 !== manifestArg.sha256
+            || candidate.bytes !== manifestArg.bytes
+            || candidate.revision !== manifestArg.revision
+            || (sourceArg && (candidate.domain !== sourceArg.identity.domain
+                || candidate.incarnationId !== sourceArg.incarnationId
+                || candidate.sessionId !== sourceArg.identity.sessionId
+                || candidate.archiveId !== sourceArg.identity.archiveId))) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private candidate mismatch.');
+        }
+        const chunkModels = await FlexPrivateChunkModel.getInstances({
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            candidateId: manifestArg.candidateId,
+        });
+        if (chunkModels.length !== manifestArg.chunks.length) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private candidate has an unexpected chunk set.');
+        }
+        const chunksById = new Map(chunkModels.map((model) => [model.id, model]));
+        const chunks = [];
+        for (const chunkManifest of manifestArg.chunks) {
+            abortSignalArg?.throwIfAborted();
+            const model = chunksById.get(chunkManifest.id);
+            if (!model) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private chunk is missing.');
+            }
+            const document = projectPrivateChunk(model);
+            assertFlexPrivateChunkDocument(document);
+            const bytes = Buffer.from(document.data, 'base64');
+            if (document.id !== privateChunkDocumentId(manifestArg.candidateId, chunkManifest.index)
+                || bytes.toString('base64') !== document.data
+                || document.controllerId !== this.controllerId
+                || document.scopeId !== storageKeyArg
+                || document.candidateId !== manifestArg.candidateId
+                || document.revision !== manifestArg.revision
+                || document.createdAt !== candidate.createdAt
+                || (sourceArg && (document.domain !== sourceArg.identity.domain
+                    || document.incarnationId !== sourceArg.incarnationId
+                    || document.sessionId !== sourceArg.identity.sessionId
+                    || document.archiveId !== sourceArg.identity.archiveId))
+                || document.index !== chunkManifest.index
+                || document.sha256 !== chunkManifest.sha256
+                || document.bytes !== chunkManifest.bytes
+                || bytes.byteLength !== chunkManifest.bytes
+                || sha256(bytes) !== chunkManifest.sha256) {
+                bytes.fill(0);
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private chunk mismatch.');
+            }
+            chunks.push(bytes);
+        }
+        const complete = Buffer.concat(chunks, manifestArg.bytes);
+        for (const chunk of chunks)
+            chunk.fill(0);
+        try {
+            if (complete.byteLength !== manifestArg.bytes || sha256(complete) !== manifestArg.sha256) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private snapshot hash mismatch.');
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(complete.toString('utf8'));
+            }
+            catch (errorArg) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private snapshot is not JSON.', { cause: errorArg });
+            }
+            abortSignalArg?.throwIfAborted();
+            try {
+                return await validateArg(parsed);
+            }
+            catch (errorArg) {
+                if (errorArg instanceof plugins.flexharness.FlexHarnessStoreFormatError)
+                    throw errorArg;
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex private snapshot has an invalid schema.', { cause: errorArg });
+            }
+        }
+        finally {
+            complete.fill(0);
+        }
+    }
+    async writeAndVerifyPrivate(candidateArg, chunksArg, abortSignalArg) {
+        await insertOrdinary(FlexPrivateCandidateModel, candidateArg);
+        abortSignalArg?.throwIfAborted();
+        await inBatches(chunksArg, async (chunk) => {
+            abortSignalArg?.throwIfAborted();
+            await insertOrdinary(FlexPrivateChunkModel, chunk);
+            abortSignalArg?.throwIfAborted();
+        });
+        abortSignalArg?.throwIfAborted();
+        const storedCandidate = await FlexPrivateCandidateModel.getInstance({ id: candidateArg.id });
+        if (!storedCandidate)
+            throw new Error('Flex private candidate verification failed.');
+        const projectedCandidate = projectPrivateCandidate(storedCandidate);
+        assertFlexPrivateCandidateDocument(projectedCandidate);
+        if (canonicalJson(projectedCandidate) !== canonicalJson(candidateArg)) {
+            throw new Error('Flex private candidate verification failed.');
+        }
+        const storedChunks = await FlexPrivateChunkModel.getInstances({
+            controllerId: candidateArg.controllerId,
+            scopeId: candidateArg.scopeId,
+            candidateId: candidateArg.candidateId,
+        });
+        if (storedChunks.length !== chunksArg.length) {
+            throw new Error('Flex private chunk verification failed.');
+        }
+        const expectedById = new Map(chunksArg.map((chunk) => [chunk.id, chunk]));
+        for (const stored of storedChunks) {
+            abortSignalArg?.throwIfAborted();
+            const projected = projectPrivateChunk(stored);
+            assertFlexPrivateChunkDocument(projected);
+            const expected = expectedById.get(projected.id);
+            if (!expected || canonicalJson(projected) !== canonicalJson(expected)) {
+                throw new Error('Flex private chunk verification failed.');
+            }
+        }
+    }
+    async writeAndVerifyProjectionSource(buildArg) {
+        await insertOrdinary(FlexProjectionSourceModel, buildArg.source);
+        await inBatches(buildArg.messages, (message) => insertOrdinary(FlexProjectionMessageRecordModel, message));
+        const storedSource = await FlexProjectionSourceModel.getInstance({ id: buildArg.source.id });
+        if (!storedSource)
+            throw new Error('Flex projection source verification failed.');
+        const source = projectProjectionSource(storedSource);
+        assertFlexProjectionSourceDocument(source);
+        if (canonicalJson(source) !== canonicalJson(buildArg.source)) {
+            throw new Error('Flex projection source verification failed.');
+        }
+        await inBatches(buildArg.messages, async (expected) => {
+            const stored = await FlexProjectionMessageRecordModel.getInstance({ id: expected.id });
+            if (!stored)
+                throw new Error('Flex projection message verification failed.');
+            const message = projectProjectionMessage(stored);
+            assertFlexProjectionMessageRecordDocument(message);
+            if (canonicalJson(message) !== canonicalJson(expected)) {
+                throw new Error('Flex projection message verification failed.');
+            }
+        });
+    }
+    async loadProjectionSource(headArg) {
+        if (headArg.domain !== 'projection' || !headArg.sessionId || !headArg.projectionSource) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection head does not contain a projection source.');
+        }
+        const model = await FlexProjectionSourceModel.getInstance({
+            id: projectionSourceDocumentId(headArg.projectionSource.candidateId),
+        });
+        if (!model) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source is missing.');
+        }
+        const source = projectProjectionSource(model);
+        assertFlexProjectionSourceDocument(source);
+        const unhashedManifest = {
+            candidateId: source.candidateId,
+            ...(source.orderVersion === undefined ? {} : { orderVersion: source.orderVersion }),
+            messageCount: source.messageCount,
+            messagesTruncated: source.messagesTruncated,
+            visibleDigest: source.visibleDigest,
+            ...(source.latestMessage === undefined ? {} : { latestMessage: source.latestMessage }),
+        };
+        const bytes = projectionSourceManifestBytes(unhashedManifest);
+        const manifest = {
+            ...unhashedManifest,
+            sha256: sha256(bytes),
+            bytes: bytes.byteLength,
+        };
+        if (source.id !== projectionSourceDocumentId(headArg.projectionSource.candidateId)
+            || source.controllerId !== this.controllerId
+            || source.scopeId !== headArg.storageKey
+            || source.sessionId !== headArg.sessionId
+            || source.candidateId !== headArg.projectionSource.candidateId
+            || source.incarnationId !== headArg.incarnationId
+            || source.revision > headArg.revision
+            || canonicalJson(manifest) !== canonicalJson(headArg.projectionSource)) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source does not match its domain head.');
+        }
+        return source;
+    }
+    async loadProjectionMessageRecord(sourceArg, descriptorArg) {
+        const model = await FlexProjectionMessageRecordModel.getInstance({ id: descriptorArg.id });
+        if (!model) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection message record is missing.');
+        }
+        const record = projectProjectionMessage(model);
+        assertFlexProjectionMessageRecordDocument(record);
+        const descriptor = {
+            id: record.id,
+            index: record.index,
+            ...(record.messageIndex === undefined ? {} : { messageIndex: record.messageIndex }),
+            sha256: record.sha256,
+            bytes: record.bytes,
+            messageCreatedAt: record.messageCreatedAt,
+            sessionId: record.sessionId,
+            messageId: record.messageId,
+        };
+        const payload = projectionMessagePayloadBytes(record.message, record.previous);
+        if (record.id !== projectionMessageDocumentId(sourceArg.candidateId, record.index)
+            || record.controllerId !== this.controllerId
+            || record.scopeId !== sourceArg.scopeId
+            || record.candidateId !== sourceArg.candidateId
+            || record.sessionId !== sourceArg.sessionId
+            || record.incarnationId !== sourceArg.incarnationId
+            || record.revision !== sourceArg.revision
+            || canonicalJson(descriptor) !== canonicalJson(descriptorArg)
+            || payload.byteLength !== record.bytes
+            || sha256(payload) !== record.sha256
+            || (record.index === 0
+                ? record.previous !== undefined
+                : !record.previous
+                    || record.previous.index !== record.index - 1
+                    || record.previous.id !== projectionMessageDocumentId(sourceArg.candidateId, record.index - 1))) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection message chain is invalid.');
+        }
+        return record;
+    }
+    async buildPublicProjectionFromSources(storageKeyArg, candidateIdArg, publicationRevisionArg, scopeArg, sourcesArg, createdAtArg = new Date().toISOString()) {
+        const retainedSessions = retainPublicSessions(scopeArg.snapshot.sessions);
+        const retainedSessionIds = new Set(retainedSessions.map((session) => session.sessionId));
+        const sessions = retainedSessions.map((session) => ({
+            id: publicSessionDocumentId(candidateIdArg, session.sessionId),
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            candidateId: candidateIdArg,
+            revision: publicationRevisionArg,
+            session: cloneJson(session),
+            createdAt: createdAtArg,
+        }));
+        const sourceBySession = new Map(sourcesArg.map((source) => [source.sessionId, source]));
+        if (sourceBySession.size !== sourcesArg.length) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source set contains duplicate sessions.');
+        }
+        const sources = retainedSessions.flatMap((session) => {
+            const source = sourceBySession.get(session.sessionId);
+            return source && retainedSessionIds.has(source.sessionId) ? [source] : [];
+        });
+        const entries = sources.flatMap((source) => source.latestMessage
+            ? [{ source, descriptor: source.latestMessage }]
+            : []);
+        const messages = [];
+        let messageBytes = 0;
+        let messageBytesTruncated = false;
+        let oversizedMessagesReplaced = false;
+        while (entries.length > 0 && messages.length < flexPublicMessageLimit) {
+            let newestIndex = 0;
+            for (let index = 1; index < entries.length; index++) {
+                if (compareNewestProjectionDescriptor(entries[index].descriptor, entries[newestIndex].descriptor) < 0)
+                    newestIndex = index;
+            }
+            const entry = entries[newestIndex];
+            const sourceRecord = await this.loadProjectionMessageRecord(entry.source, entry.descriptor);
+            if (sourceRecord.messageIndex === undefined) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source message order is unavailable.');
+            }
+            const messageIndex = sourceRecord.messageIndex;
+            const createRecord = (messageArg) => ({
+                id: publicMessageDocumentId(candidateIdArg, messageArg.sessionId, messageArg.messageId),
+                controllerId: this.controllerId,
+                scopeId: storageKeyArg,
+                candidateId: candidateIdArg,
+                revision: publicationRevisionArg,
+                messageIndex,
+                message: cloneJson(messageArg),
+                createdAt: createdAtArg,
+            });
+            let publicRecord = createRecord(sourceRecord.message);
+            let publicRecordBytes = serializedBytes(publicRecord).byteLength;
+            if (publicRecordBytes > flexPublicSingleMessageBytesLimit) {
+                publicRecord = createRecord(placeholderMessage(sourceRecord.message));
+                publicRecordBytes = serializedBytes(publicRecord).byteLength;
+                oversizedMessagesReplaced = true;
+                if (publicRecordBytes > flexPublicSingleMessageBytesLimit) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex public message metadata exceeds its projection limit.');
+                }
+            }
+            if (messageBytes + publicRecordBytes > flexPublicMessageBytesLimit) {
+                messageBytesTruncated = true;
+                break;
+            }
+            messageBytes += publicRecordBytes;
+            messages.push(publicRecord);
+            if (sourceRecord.previous) {
+                entries[newestIndex] = { source: entry.source, descriptor: sourceRecord.previous };
+            }
+            else {
+                entries.splice(newestIndex, 1);
+            }
+        }
+        const sessionsTruncated = retainedSessions.length < scopeArg.snapshot.sessions.length;
+        let availableMessageCount = 0;
+        for (const source of sources) {
+            availableMessageCount = Math.min(flexPublicMessageLimit + 1, availableMessageCount + source.messageCount);
+        }
+        const messagesTruncated = sessionsTruncated
+            || sources.some((source) => source.messagesTruncated)
+            || messages.length < availableMessageCount
+            || oversizedMessagesReplaced;
+        const sessionRecords = sessions.map(recordManifest);
+        if (new Set(messages.map((record) => (`${record.message.sessionId}\0${record.messageIndex}`))).size !== messages.length) {
+            throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex public projection contains duplicate message indexes.');
+        }
+        const messageRecords = messages.map(recordManifest);
+        const visibleDigest = sha256(serializedBytes({
+            sessions: sessions.map((record) => record.session),
+            messages: messages.map((record) => ({
+                messageIndex: record.messageIndex,
+                message: record.message,
+            })),
+            sessionsTruncated,
+            messagesTruncated,
+            messageBytesTruncated,
+        }));
+        const projectionSources = sources.map((source) => ({
+            sessionId: source.sessionId,
+            incarnationId: source.incarnationId,
+            revision: source.revision,
+        }));
+        const unhashedManifest = {
+            candidateId: candidateIdArg,
+            revision: publicationRevisionArg,
+            sessionRecords,
+            messageRecords,
+            sessionsTruncated,
+            messagesTruncated,
+            messageBytesTruncated,
+            visibleDigest,
+            scopeSource: {
+                incarnationId: scopeArg.head.incarnationId,
+                revision: scopeArg.head.revision,
+            },
+            projectionSources,
+        };
+        const candidateBytes = publicCandidateManifestBytes(unhashedManifest);
+        const candidate = {
+            id: publicCandidateDocumentId(candidateIdArg),
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            ...unhashedManifest,
+            sha256: sha256(candidateBytes),
+            bytes: candidateBytes.byteLength,
+            createdAt: createdAtArg,
+        };
+        assertFlexPublicCandidateDocument(candidate);
+        for (const session of sessions)
+            assertFlexPublicSessionRecordDocument(session);
+        for (const message of messages)
+            assertFlexPublicMessageRecordDocument(message);
+        return { candidate, sessions, messages };
+    }
+    async publishPublicProjection(storageKeyArg, leaseArg) {
+        const scope = await this.loadDomainDirect({ storageKey: storageKeyArg, domain: 'scope' }, (value) => this.validateScopeSnapshot(value));
+        if (!scope)
+            return;
+        const retainedSessionIds = retainNewest(scope.snapshot.sessions, flexPublicSessionLimit, compareNewestSession)
+            .map((session) => session.sessionId);
+        const projectionHeads = [];
+        if (retainedSessionIds.length > 0) {
+            const cursor = FlexDomainHeadModel.collection.mongoDbCollection.find({
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                domain: 'projection',
+                sessionId: { $in: retainedSessionIds },
+            }).limit(retainedSessionIds.length + 1);
+            try {
+                projectionHeads.push(...await cursor.toArray());
+            }
+            finally {
+                await cursor.close();
+            }
+            if (projectionHeads.length > retainedSessionIds.length) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection head set exceeds the retained session set.');
+            }
+        }
+        const sources = [];
+        for (let index = 0; index < projectionHeads.length; index += 32) {
+            const batch = projectionHeads.slice(index, index + 32);
+            sources.push(...await Promise.all(batch.map(async (head) => {
+                if (!head.sessionId) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection head is missing its session identity.');
+                }
+                const identity = {
+                    storageKey: storageKeyArg,
+                    domain: 'projection',
+                    sessionId: head.sessionId,
+                };
+                this.assertDomainHeadIdentity(head, identity);
+                const source = await this.loadProjectionSource(head);
+                if (source.orderVersion !== 1) {
+                    throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex projection source ordering migration is required before publication.');
+                }
+                return source;
+            })));
+        }
+        const currentHead = await this.readPublicHead(storageKeyArg);
+        const publicationRevision = (currentHead?.revision ?? 0) + 1;
+        const candidateId = randomCandidateId();
+        const build = await this.buildPublicProjectionFromSources(storageKeyArg, candidateId, publicationRevision, scope, sources);
+        const currentManifest = currentHead?.publicCandidates[0];
+        if (currentManifest?.visibleDigest === build.candidate.visibleDigest
+            && await this.verifyPublicCandidate(storageKeyArg, currentManifest).catch(() => false))
+            return;
+        const manifest = {
+            candidateId: build.candidate.candidateId,
+            revision: build.candidate.revision,
+            sha256: build.candidate.sha256,
+            bytes: build.candidate.bytes,
+            sessionRecords: build.candidate.sessionRecords,
+            messageRecords: build.candidate.messageRecords,
+            sessionsTruncated: build.candidate.sessionsTruncated,
+            messagesTruncated: build.candidate.messagesTruncated,
+            messageBytesTruncated: build.candidate.messageBytesTruncated,
+            visibleDigest: build.candidate.visibleDigest,
+            scopeSource: build.candidate.scopeSource,
+            projectionSources: build.candidate.projectionSources,
+        };
+        const nextHead = {
+            id: flexPublicHeadId(this.controllerId, storageKeyArg),
+            controllerId: this.controllerId,
+            storageKey: storageKeyArg,
+            revision: publicationRevision,
+            currentPublicCandidateId: candidateId,
+            publicCandidates: [
+                manifest,
+                ...(currentHead?.publicCandidates ?? []).slice(0, 3),
+            ],
+        };
+        assertFlexPublicHeadDocument(nextHead);
+        this.activeCandidateIds.add(candidateId);
+        let committed = false;
+        try {
+            await this.writeAndVerifyPublic(build);
+            await this.commitPublicHead(leaseArg, currentHead, nextHead, storageKeyArg);
+            committed = true;
+            if (currentHead) {
+                const retained = new Set(nextHead.publicCandidates.map((entry) => entry.candidateId));
+                for (const evicted of currentHead.publicCandidates) {
+                    if (!retained.has(evicted.candidateId)) {
+                        await this.cleanupPublicByCandidate(evicted, storageKeyArg).catch(() => undefined);
+                    }
+                }
+            }
+        }
+        finally {
+            this.activeCandidateIds.delete(candidateId);
+            if (!committed)
+                this.queueOrphanMaintenance();
+        }
+    }
+    async readPublicHead(storageKeyArg, optionsArg) {
+        const id = flexPublicHeadId(this.controllerId, storageKeyArg);
+        const rawHead = await this.database.mongoDb.collection('flex_public_heads').findOne({ id }, optionsArg);
+        const head = rawHead;
+        if (head) {
+            const body = publicHeadBody(head);
+            assertFlexPublicHeadDocument(body);
+            if (body.id !== id
+                || body.controllerId !== this.controllerId
+                || body.storageKey !== storageKeyArg) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex public head identity mismatch.');
+            }
+        }
+        return head;
+    }
+    async commitPublicHead(leaseArg, currentArg, nextArg, storageKeyArg) {
+        await this.commitHeadMutation({
+            lease: leaseArg,
+            collection: this.database.mongoDb.collection('flex_public_heads'),
+            current: currentArg,
+            next: nextArg,
+            selector: currentArg ? {
+                _id: currentArg._id,
+                id: currentArg.id,
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                revision: currentArg.revision,
+                _smartdataRevision: smartRevisionSelector(currentArg),
+            } : { id: nextArg.id },
+            readCurrent: (options) => this.readPublicHead(storageKeyArg, options),
+            project: publicHeadBody,
+            targetName: `public:${nextArg.id}`,
+        });
+    }
+    async deletePublicHead(leaseArg, headArg, storageKeyArg) {
+        await this.commitHeadMutation({
+            lease: leaseArg,
+            collection: this.database.mongoDb.collection('flex_public_heads'),
+            current: headArg,
+            next: null,
+            selector: {
+                _id: headArg._id,
+                id: headArg.id,
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                revision: headArg.revision,
+                _smartdataRevision: smartRevisionSelector(headArg),
+            },
+            readCurrent: (options) => this.readPublicHead(storageKeyArg, options),
+            project: publicHeadBody,
+            targetName: `public:${headArg.id}`,
+        });
+    }
+    async writeAndVerifyPublic(buildArg) {
+        await insertOrdinary(FlexPublicCandidateModel, buildArg.candidate);
+        await inBatches(buildArg.sessions, (session) => insertOrdinary(FlexPublicSessionRecordModel, session));
+        await inBatches(buildArg.messages, (message) => insertOrdinary(FlexPublicMessageRecordModel, message));
+        const manifest = {
+            candidateId: buildArg.candidate.candidateId,
+            revision: buildArg.candidate.revision,
+            sha256: buildArg.candidate.sha256,
+            bytes: buildArg.candidate.bytes,
+            sessionRecords: buildArg.candidate.sessionRecords,
+            messageRecords: buildArg.candidate.messageRecords,
+            sessionsTruncated: buildArg.candidate.sessionsTruncated,
+            messagesTruncated: buildArg.candidate.messagesTruncated,
+            messageBytesTruncated: buildArg.candidate.messageBytesTruncated,
+            visibleDigest: buildArg.candidate.visibleDigest,
+            scopeSource: buildArg.candidate.scopeSource,
+            projectionSources: buildArg.candidate.projectionSources,
+        };
+        if (!await this.verifyPublicCandidate(buildArg.candidate.scopeId, manifest)) {
+            throw new Error('Flex public candidate verification failed.');
+        }
+    }
+    async verifyPublicCandidate(storageKeyArg, manifestArg) {
+        const model = await FlexPublicCandidateModel.getInstance({
+            id: publicCandidateDocumentId(manifestArg.candidateId),
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            candidateId: manifestArg.candidateId,
+        });
+        if (!model)
+            return false;
+        const candidate = projectPublicCandidate(model);
+        assertFlexPublicCandidateDocument(candidate);
+        const projectedManifest = {
+            candidateId: candidate.candidateId,
+            revision: candidate.revision,
+            sha256: candidate.sha256,
+            bytes: candidate.bytes,
+            sessionRecords: candidate.sessionRecords,
+            messageRecords: candidate.messageRecords,
+            sessionsTruncated: candidate.sessionsTruncated,
+            messagesTruncated: candidate.messagesTruncated,
+            messageBytesTruncated: candidate.messageBytesTruncated,
+            visibleDigest: candidate.visibleDigest,
+            scopeSource: candidate.scopeSource,
+            projectionSources: candidate.projectionSources,
+        };
+        const unhashed = {
+            candidateId: candidate.candidateId,
+            revision: candidate.revision,
+            sessionRecords: candidate.sessionRecords,
+            messageRecords: candidate.messageRecords,
+            sessionsTruncated: candidate.sessionsTruncated,
+            messagesTruncated: candidate.messagesTruncated,
+            messageBytesTruncated: candidate.messageBytesTruncated,
+            visibleDigest: candidate.visibleDigest,
+            scopeSource: candidate.scopeSource,
+            projectionSources: candidate.projectionSources,
+        };
+        const bytes = publicCandidateManifestBytes(unhashed);
+        if (candidate.id !== publicCandidateDocumentId(manifestArg.candidateId)
+            || candidate.controllerId !== this.controllerId
+            || candidate.scopeId !== storageKeyArg
+            || !publicManifestsEqual(projectedManifest, manifestArg)
+            || candidate.bytes !== bytes.byteLength
+            || candidate.sha256 !== sha256(bytes))
+            return false;
+        const [sessionModels, messageModels] = await Promise.all([
+            FlexPublicSessionRecordModel.getInstances({
+                controllerId: this.controllerId,
+                scopeId: storageKeyArg,
+                candidateId: manifestArg.candidateId,
+            }),
+            FlexPublicMessageRecordModel.getInstances({
+                controllerId: this.controllerId,
+                scopeId: storageKeyArg,
+                candidateId: manifestArg.candidateId,
+            }),
+        ]);
+        if (sessionModels.length !== manifestArg.sessionRecords.length
+            || messageModels.length !== manifestArg.messageRecords.length)
+            return false;
+        const manifests = new Map([
+            ...manifestArg.sessionRecords,
+            ...manifestArg.messageRecords,
+        ].map((manifest) => [manifest.id, manifest]));
+        for (const sessionModel of sessionModels) {
+            const document = projectPublicSession(sessionModel);
+            assertFlexPublicSessionRecordDocument(document);
+            if (document.controllerId !== this.controllerId
+                || document.scopeId !== storageKeyArg
+                || document.candidateId !== manifestArg.candidateId
+                || document.revision !== manifestArg.revision
+                || canonicalJson(recordManifest(document)) !== canonicalJson(manifests.get(document.id)))
+                return false;
+        }
+        for (const messageModel of messageModels) {
+            const document = projectPublicMessage(messageModel);
+            assertFlexPublicMessageRecordDocument(document);
+            if (document.controllerId !== this.controllerId
+                || document.scopeId !== storageKeyArg
+                || document.candidateId !== manifestArg.candidateId
+                || document.revision !== manifestArg.revision
+                || canonicalJson(recordManifest(document)) !== canonicalJson(manifests.get(document.id)))
+                return false;
+        }
+        return true;
+    }
+    async commitHeadMutation(optionsArg) {
+        return this.runLeaseTransition(optionsArg.lease, (abortSignal, timeoutMs) => this.commitHeadMutationWithLease(optionsArg, abortSignal, timeoutMs));
+    }
+    async commitHeadMutationWithLease(optionsArg, abortSignalArg, timeoutMsArg) {
+        const deadline = Date.now() + timeoutMsArg;
+        const session = this.database.startSession();
+        let callbackError;
+        try {
+            await session.withTransaction(async () => {
+                abortSignalArg.throwIfAborted();
+                const now = Date.now();
+                const leasePostimage = await FlexWriterLeaseModel.collection.mongoDbCollection.findOneAndUpdate({
+                    id: flexWriterLeaseId(this.controllerId, optionsArg.lease.storageKey),
+                    controllerId: this.controllerId,
+                    storageKey: optionsArg.lease.storageKey,
+                    ownerToken: optionsArg.lease.ownerToken,
+                    epoch: optionsArg.lease.epoch,
+                    state: 'active',
+                    expiresAt: { $gt: now },
+                }, {
+                    $set: {
+                        expiresAt: now + flexLeaseDurationMs,
+                        updatedAt: new Date(now).toISOString(),
+                        _smartdataRevision: plugins.crypto.randomUUID(),
+                    },
+                }, {
+                    session,
+                    returnDocument: 'after',
+                    includeResultMetadata: false,
+                });
+                abortSignalArg.throwIfAborted();
+                if (!leasePostimage)
+                    throw new FlexLeaseLostError(optionsArg.lease.storageKey);
+                if (!optionsArg.current && optionsArg.next) {
+                    try {
+                        await optionsArg.collection.insertOne({
+                            ...optionsArg.next,
+                            _smartdataRevision: plugins.crypto.randomUUID(),
+                        }, { session });
+                        abortSignalArg.throwIfAborted();
+                    }
+                    catch (errorArg) {
+                        callbackError = errorArg;
+                        throw errorArg;
+                    }
+                    return;
+                }
+                if (optionsArg.current && optionsArg.next) {
+                    const postimage = await optionsArg.collection.findOneAndReplace(optionsArg.selector, { ...optionsArg.next, _smartdataRevision: plugins.crypto.randomUUID() }, {
+                        session,
+                        upsert: false,
+                        returnDocument: 'after',
+                        includeResultMetadata: false,
+                    });
+                    abortSignalArg.throwIfAborted();
+                    if (!postimage) {
+                        throw new FlexHeadCasError(optionsArg.current.revision ?? 0);
+                    }
+                    return;
+                }
+                if (optionsArg.current && !optionsArg.next) {
+                    const deletion = await optionsArg.collection.deleteOne(optionsArg.selector, {
+                        session,
+                    });
+                    abortSignalArg.throwIfAborted();
+                    if (deletion.deletedCount !== 1) {
+                        throw new FlexHeadCasError(optionsArg.current.revision ?? 0);
+                    }
+                }
+            }, {
+                timeoutMS: Math.max(1, deadline - Date.now()),
+                maxCommitTimeMS: Math.max(1, deadline - Date.now()),
+            });
+            this.throwIfFatal();
+            await this.verifyHeldLease(optionsArg.lease, false, abortSignalArg, false, Math.max(1, deadline - Date.now()));
+            return;
+        }
+        catch (errorArg) {
+            this.throwIfFatal();
+            const operationError = callbackError ?? errorArg;
+            const reconciliationOptions = {
+                signal: abortSignalArg,
+                timeoutMS: Math.max(1, deadline - Date.now()),
+            };
+            let leaseCurrent;
+            let targetCurrent;
+            try {
+                [leaseCurrent, targetCurrent] = await Promise.all([
+                    FlexWriterLeaseModel.collection.mongoDbCollection.findOne({
+                        id: flexWriterLeaseId(this.controllerId, optionsArg.lease.storageKey),
+                    }, reconciliationOptions),
+                    optionsArg.readCurrent(reconciliationOptions),
+                ]);
+            }
+            catch (readbackError) {
+                throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', `Flex ${optionsArg.targetName} mutation failed and readback was unavailable.`, { cause: new AggregateError([operationError, readbackError]) });
+            }
+            const uncertainTransition = optionsArg.lease.uncertainTransition;
+            if (leaseCurrent
+                && uncertainTransition
+                && leaseTransitionImagesEqual(leaseCurrent, uncertainTransition.postimage)) {
+                optionsArg.lease.ownerToken = leaseCurrent.ownerToken;
+                optionsArg.lease.epoch = leaseCurrent.epoch;
+                optionsArg.lease.expiresAt = leaseCurrent.expiresAt;
+                optionsArg.lease.uncertainTransition = undefined;
+            }
+            const sameLease = !!leaseCurrent
+                && leaseCurrent.controllerId === this.controllerId
+                && leaseCurrent.storageKey === optionsArg.lease.storageKey
+                && leaseCurrent.ownerToken === optionsArg.lease.ownerToken
+                && leaseCurrent.epoch === optionsArg.lease.epoch
+                && leaseCurrent.state === 'active'
+                && leaseCurrent.expiresAt > Date.now();
+            const requestedCommitted = optionsArg.next
+                ? !!targetCurrent
+                    && canonicalJson(optionsArg.project(targetCurrent))
+                        === canonicalJson(optionsArg.project(optionsArg.next))
+                : targetCurrent === null;
+            if (sameLease && requestedCommitted) {
+                optionsArg.lease.expiresAt = leaseCurrent.expiresAt;
+                return;
+            }
+            if (!sameLease) {
+                if (uncertainTransition
+                    && leaseCurrent
+                    && leaseTransitionImagesEqual(leaseCurrent, uncertainTransition.preimage))
+                    throw operationError;
+                throw this.markLeaseLost(optionsArg.lease);
+            }
+            if (errorArg instanceof FlexHeadCasError) {
+                throw new FlexHeadCasError(targetCurrent?.revision ?? 0);
+            }
+            if (targetCurrent && optionsArg.current) {
+                const stillCurrent = canonicalJson(optionsArg.project(targetCurrent))
+                    === canonicalJson(optionsArg.project(optionsArg.current));
+                if (stillCurrent)
+                    throw operationError;
+            }
+            if (!targetCurrent && !optionsArg.current)
+                throw operationError;
+            throw new FlexHeadCasError(targetCurrent?.revision ?? 0);
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    async deleteScopeRecords(leaseArg, storageKeyArg) {
+        const collections = [
+            FlexPrivateChunkModel.collection.mongoDbCollection,
+            FlexPrivateCandidateModel.collection.mongoDbCollection,
+            FlexPublicSessionRecordModel.collection.mongoDbCollection,
+            FlexPublicMessageRecordModel.collection.mongoDbCollection,
+            FlexPublicCandidateModel.collection.mongoDbCollection,
+            FlexProjectionMessageRecordModel.collection.mongoDbCollection,
+            FlexProjectionSourceModel.collection.mongoDbCollection,
+        ];
+        for (const collection of collections) {
+            let lastId;
+            while (true) {
+                const cursor = collection.find({
+                    controllerId: this.controllerId,
+                    scopeId: storageKeyArg,
+                    ...(lastId ? { _id: { $gt: lastId } } : {}),
+                }, { projection: { _id: 1 } }).sort({ _id: 1 }).limit(flexMaintenancePageLimit);
+                let documents;
+                try {
+                    documents = await cursor.toArray();
+                }
+                finally {
+                    await cursor.close();
+                }
+                if (documents.length === 0)
+                    break;
+                const documentIds = documents.map((document) => document._id);
+                await this.deleteScopeRecordBatch(leaseArg, storageKeyArg, collection, documentIds);
+                const last = documents.at(-1);
+                if (!last || documents.length < flexMaintenancePageLimit)
+                    break;
+                lastId = last._id;
+            }
+        }
+    }
+    async deleteScopeRecordBatch(leaseArg, storageKeyArg, collectionArg, documentIdsArg) {
+        return this.runLeaseTransition(leaseArg, (abortSignal, timeoutMs) => this.deleteScopeRecordBatchWithLease(leaseArg, storageKeyArg, collectionArg, documentIdsArg, abortSignal, timeoutMs));
+    }
+    async deleteScopeRecordBatchWithLease(leaseArg, storageKeyArg, collectionArg, documentIdsArg, abortSignalArg, timeoutMsArg) {
+        const deadline = Date.now() + timeoutMsArg;
+        const session = this.database.startSession();
+        try {
+            await session.withTransaction(async () => {
+                abortSignalArg.throwIfAborted();
+                const now = Date.now();
+                const leasePostimage = await FlexWriterLeaseModel.collection.mongoDbCollection.findOneAndUpdate({
+                    id: flexWriterLeaseId(this.controllerId, storageKeyArg),
+                    controllerId: this.controllerId,
+                    storageKey: storageKeyArg,
+                    ownerToken: leaseArg.ownerToken,
+                    epoch: leaseArg.epoch,
+                    state: 'active',
+                    expiresAt: { $gt: now },
+                }, {
+                    $set: {
+                        expiresAt: now + flexLeaseDurationMs,
+                        updatedAt: new Date(now).toISOString(),
+                        _smartdataRevision: plugins.crypto.randomUUID(),
+                    },
+                }, {
+                    session,
+                    returnDocument: 'after',
+                    includeResultMetadata: false,
+                });
+                abortSignalArg.throwIfAborted();
+                if (!leasePostimage)
+                    throw new FlexLeaseLostError(storageKeyArg);
+                await collectionArg.deleteMany({
+                    controllerId: this.controllerId,
+                    scopeId: storageKeyArg,
+                    _id: { $in: documentIdsArg },
+                }, { session });
+                abortSignalArg.throwIfAborted();
+            }, {
+                timeoutMS: Math.max(1, deadline - Date.now()),
+                maxCommitTimeMS: Math.max(1, deadline - Date.now()),
+            });
+            this.throwIfFatal();
+            await this.verifyHeldLease(leaseArg, false, abortSignalArg, false, Math.max(1, deadline - Date.now()));
+        }
+        catch (errorArg) {
+            this.throwIfFatal();
+            const [currentLease, remaining] = await Promise.all([
+                FlexWriterLeaseModel.collection.mongoDbCollection.findOne({
+                    id: flexWriterLeaseId(this.controllerId, storageKeyArg),
+                }, {
+                    signal: abortSignalArg,
+                    timeoutMS: Math.max(1, deadline - Date.now()),
+                }),
+                collectionArg.countDocuments({ _id: { $in: documentIdsArg } }, {
+                    signal: abortSignalArg,
+                    timeoutMS: Math.max(1, deadline - Date.now()),
+                }),
+            ]);
+            const uncertainTransition = leaseArg.uncertainTransition;
+            if (currentLease
+                && uncertainTransition
+                && leaseTransitionImagesEqual(currentLease, uncertainTransition.postimage)) {
+                leaseArg.ownerToken = currentLease.ownerToken;
+                leaseArg.epoch = currentLease.epoch;
+                leaseArg.expiresAt = currentLease.expiresAt;
+                leaseArg.uncertainTransition = undefined;
+            }
+            const sameLease = !!currentLease
+                && currentLease.controllerId === this.controllerId
+                && currentLease.storageKey === storageKeyArg
+                && currentLease.ownerToken === leaseArg.ownerToken
+                && currentLease.epoch === leaseArg.epoch
+                && currentLease.state === 'active'
+                && currentLease.expiresAt > Date.now();
+            if (sameLease && remaining === 0) {
+                leaseArg.expiresAt = currentLease.expiresAt;
+                return;
+            }
+            if (!sameLease) {
+                if (uncertainTransition
+                    && currentLease
+                    && leaseTransitionImagesEqual(currentLease, uncertainTransition.preimage))
+                    throw errorArg;
+                throw this.markLeaseLost(leaseArg);
+            }
+            throw errorArg;
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    async runStorage(storageKeyArg, operationArg) {
+        assertIdentifier(storageKeyArg, 'storageKey');
+        this.throwIfFatal();
+        await this.init();
+        if (this.closed)
+            throw new Error('The Flex store is closed.');
+        const prior = this.storageQueues.get(storageKeyArg) ?? Promise.resolve();
+        const operation = prior.catch(() => undefined).then(async () => {
+            this.throwIfFatal();
+            if (this.closed)
+                throw new Error('The Flex store is closed.');
+            const lease = await this.ensureLease(storageKeyArg);
+            if (this.closed) {
+                await this.releaseHeldLease(lease, this.closeDrainTimeoutMs);
+                throw new Error('The Flex store is closed.');
+            }
+            return operationArg(lease);
+        });
+        const settled = operation.then(() => undefined, () => undefined);
+        this.storageQueues.set(storageKeyArg, settled);
+        void settled.then(() => {
+            if (this.storageQueues.get(storageKeyArg) === settled) {
+                this.storageQueues.delete(storageKeyArg);
+            }
+        });
+        return operation;
+    }
+    async ensureLease(storageKeyArg) {
+        this.throwIfFatal();
+        if (this.closed)
+            throw new Error('The Flex store is closed.');
+        const held = this.heldLeases.get(storageKeyArg);
+        if (held) {
+            if (held.lost || held.releasing)
+                throw new FlexLeaseLostError(storageKeyArg);
+            await this.runLeaseTransition(held, (abortSignal, timeoutMs) => this.verifyHeldLease(held, true, abortSignal, false, timeoutMs));
+            return held;
+        }
+        const id = flexWriterLeaseId(this.controllerId, storageKeyArg);
+        const ownerToken = randomOwnerToken();
+        while (true) {
+            if (this.closed)
+                throw new Error('The Flex store is closed.');
+            const now = Date.now();
+            const current = await FlexWriterLeaseModel.exact.findStoredOne({ id });
+            if (!current) {
+                const document = {
+                    id,
+                    controllerId: this.controllerId,
+                    storageKey: storageKeyArg,
+                    ownerToken,
+                    epoch: 1,
+                    state: 'active',
+                    expiresAt: now + flexLeaseDurationMs,
+                    updatedAt: new Date(now).toISOString(),
+                };
+                assertFlexWriterLeaseDocument(document);
+                const insertion = await FlexWriterLeaseModel.exact.insert(document);
+                if (insertion.status === 'conflict')
+                    continue;
+                const lease = {
+                    storageKey: storageKeyArg,
+                    ownerToken,
+                    epoch: 1,
+                    expiresAt: document.expiresAt,
+                    lost: false,
+                    releasing: false,
+                };
+                this.heldLeases.set(storageKeyArg, lease);
+                if (this.closed) {
+                    await this.releaseHeldLease(lease, this.closeDrainTimeoutMs);
+                    throw new Error('The Flex store is closed.');
+                }
+                this.startLeaseHeartbeat();
+                return lease;
+            }
+            const body = leaseBody(current);
+            assertFlexWriterLeaseDocument(body);
+            if (body.id !== id
+                || body.controllerId !== this.controllerId
+                || body.storageKey !== storageKeyArg) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex writer lease identity mismatch.');
+            }
+            if (body.state === 'active' && body.expiresAt > now) {
+                throw new Error(`Storage key "${storageKeyArg}" has an active foreign Flex writer lease.`);
+            }
+            const transition = await FlexWriterLeaseModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.ownerToken = ownerToken;
+                    model.epoch = current.epoch + 1;
+                    model.state = 'active';
+                    model.expiresAt = now + flexLeaseDurationMs;
+                    model.updatedAt = new Date(now).toISOString();
+                },
+            });
+            if (transition.status === 'concurrent_change')
+                continue;
+            const lease = {
+                storageKey: storageKeyArg,
+                ownerToken,
+                epoch: current.epoch + 1,
+                expiresAt: now + flexLeaseDurationMs,
+                lost: false,
+                releasing: false,
+            };
+            this.heldLeases.set(storageKeyArg, lease);
+            if (this.closed) {
+                await this.releaseHeldLease(lease, this.closeDrainTimeoutMs);
+                throw new Error('The Flex store is closed.');
+            }
+            this.startLeaseHeartbeat();
+            return lease;
+        }
+    }
+    async verifyHeldLease(leaseArg, renewIfNeededArg, abortSignalArg, forceRenewalArg = false, timeoutMsArg = flexMaintenanceOperationTimeoutMs) {
+        if (leaseArg.lost)
+            throw new FlexLeaseLostError(leaseArg.storageKey);
+        this.throwIfFatal();
+        const id = flexWriterLeaseId(this.controllerId, leaseArg.storageKey);
+        const collection = FlexWriterLeaseModel.collection.mongoDbCollection;
+        const deadline = Date.now() + timeoutMsArg;
+        const operationOptions = () => ({
+            timeoutMS: Math.max(1, deadline - Date.now()),
+            ...(abortSignalArg ? { signal: abortSignalArg } : {}),
+        });
+        while (true) {
+            abortSignalArg?.throwIfAborted();
+            this.throwIfFatal();
+            if (Date.now() >= deadline) {
+                throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', `Flex writer lease transition for "${leaseArg.storageKey}" exceeded its deadline.`);
+            }
+            const uncertain = leaseArg.uncertainTransition;
+            if (uncertain) {
+                let current;
+                try {
+                    current = await collection.findOne({ id }, operationOptions());
+                }
+                catch (readbackError) {
+                    if (uncertain.postimage.expiresAt <= Date.now()) {
+                        throw this.markLeaseLost(leaseArg);
+                    }
+                    throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', `Flex writer lease transition for "${leaseArg.storageKey}" remains uncertain.`, { cause: readbackError });
+                }
+                this.throwIfFatal();
+                if (uncertain.postimage.expiresAt <= Date.now()) {
+                    throw this.markLeaseLost(leaseArg);
+                }
+                if (current && leaseTransitionImagesEqual(current, uncertain.postimage)) {
+                    leaseArg.ownerToken = current.ownerToken;
+                    leaseArg.epoch = current.epoch;
+                    leaseArg.expiresAt = current.expiresAt;
+                    leaseArg.uncertainTransition = undefined;
+                    continue;
+                }
+                if (!current || !leaseTransitionImagesEqual(current, uncertain.preimage)) {
+                    throw this.markLeaseLost(leaseArg);
+                }
+                let transition;
+                try {
+                    transition = await collection.findOneAndReplace({
+                        _id: uncertain.preimage._id,
+                        ...leaseBody(uncertain.preimage),
+                        _smartdataRevision: smartRevisionSelector(uncertain.preimage),
+                    }, {
+                        ...leaseBody(uncertain.postimage),
+                        _smartdataRevision: uncertain.postimage._smartdataRevision,
+                    }, {
+                        returnDocument: 'after',
+                        includeResultMetadata: false,
+                        ...operationOptions(),
+                    });
+                }
+                catch {
+                    await waitForFlexStoreRetry(10, abortSignalArg);
+                    continue;
+                }
+                this.throwIfFatal();
+                if (transition && leaseTransitionImagesEqual(transition, uncertain.postimage)) {
+                    leaseArg.ownerToken = transition.ownerToken;
+                    leaseArg.epoch = transition.epoch;
+                    leaseArg.expiresAt = transition.expiresAt;
+                    leaseArg.uncertainTransition = undefined;
+                    continue;
+                }
+                if (transition && !leaseTransitionImagesEqual(transition, uncertain.preimage)) {
+                    throw this.markLeaseLost(leaseArg);
+                }
+                await waitForFlexStoreRetry(10, abortSignalArg);
+                continue;
+            }
+            let current;
+            try {
+                current = await collection.findOne({ id }, operationOptions());
+            }
+            catch (readError) {
+                if (leaseArg.expiresAt <= Date.now())
+                    throw this.markLeaseLost(leaseArg);
+                throw readError;
+            }
+            this.throwIfFatal();
+            if (!current
+                || current.controllerId !== this.controllerId
+                || current.storageKey !== leaseArg.storageKey
+                || current.ownerToken !== leaseArg.ownerToken
+                || current.epoch !== leaseArg.epoch
+                || current.state !== 'active') {
+                throw this.markLeaseLost(leaseArg);
+            }
+            leaseArg.expiresAt = current.expiresAt;
+            const now = Date.now();
+            const expired = current.expiresAt <= now;
+            if (!expired
+                && (!renewIfNeededArg
+                    || (!forceRenewalArg && current.expiresAt - now > flexLeaseHeartbeatMs)))
+                return;
+            const previousOwnerToken = leaseArg.ownerToken;
+            const previousEpoch = leaseArg.epoch;
+            const nextOwnerToken = expired ? randomOwnerToken() : previousOwnerToken;
+            const nextEpoch = expired ? previousEpoch + 1 : previousEpoch;
+            const nextRevision = plugins.crypto.randomUUID();
+            const next = {
+                ...leaseBody(current),
+                ownerToken: nextOwnerToken,
+                epoch: nextEpoch,
+                expiresAt: now + flexLeaseDurationMs,
+                updatedAt: new Date(now).toISOString(),
+            };
+            assertFlexWriterLeaseDocument(next);
+            const uncertainTransition = {
+                preimage: leaseTransitionImage(current),
+                postimage: leaseTransitionImage({
+                    _id: current._id,
+                    ...next,
+                    _smartdataRevision: nextRevision,
+                }),
+            };
+            leaseArg.uncertainTransition = uncertainTransition;
+            let transition;
+            try {
+                transition = await collection.findOneAndReplace({
+                    _id: uncertainTransition.preimage._id,
+                    ...leaseBody(uncertainTransition.preimage),
+                    _smartdataRevision: smartRevisionSelector(uncertainTransition.preimage),
+                }, {
+                    ...leaseBody(uncertainTransition.postimage),
+                    _smartdataRevision: uncertainTransition.postimage._smartdataRevision,
+                }, {
+                    returnDocument: 'after',
+                    includeResultMetadata: false,
+                    ...operationOptions(),
+                });
+            }
+            catch {
+                continue;
+            }
+            this.throwIfFatal();
+            if (transition && leaseTransitionImagesEqual(transition, uncertainTransition.postimage)) {
+                leaseArg.ownerToken = nextOwnerToken;
+                leaseArg.epoch = nextEpoch;
+                leaseArg.expiresAt = transition.expiresAt;
+                leaseArg.uncertainTransition = undefined;
+                if (transition.expiresAt > Date.now())
+                    return;
+                await waitForFlexStoreRetry(10, abortSignalArg);
+                continue;
+            }
+            if (transition && !leaseTransitionImagesEqual(transition, uncertainTransition.preimage)) {
+                throw this.markLeaseLost(leaseArg);
+            }
+            await waitForFlexStoreRetry(10, abortSignalArg);
+        }
+    }
+    async runLeaseTransition(leaseArg, operationArg) {
+        this.throwIfFatal();
+        const deadline = Date.now() + this.leaseTransitionTimeoutMs;
+        const abortController = new AbortController();
+        this.leaseTransitionAbortControllers.add(abortController);
+        const prior = leaseArg.transitionTask ?? Promise.resolve();
+        const operation = prior.catch(() => undefined).then(async () => {
+            this.throwIfFatal();
+            if (leaseArg.lost)
+                throw new FlexLeaseLostError(leaseArg.storageKey);
+            abortController.signal.throwIfAborted();
+            if (leaseArg.uncertainTransition) {
+                await this.verifyHeldLease(leaseArg, false, abortController.signal, false, Math.max(1, deadline - Date.now()));
+            }
+            abortController.signal.throwIfAborted();
+            return operationArg(abortController.signal, Math.max(1, deadline - Date.now()));
+        });
+        let operationSettled = false;
+        const settled = operation.then(() => { operationSettled = true; }, () => { operationSettled = true; });
+        leaseArg.transitionTask = settled;
+        void settled.then(() => {
+            this.leaseTransitionAbortControllers.delete(abortController);
+            if (leaseArg.transitionTask === settled)
+                leaseArg.transitionTask = undefined;
+        });
+        try {
+            await waitForFlexStoreDeadline(prior, Math.max(1, deadline - Date.now()), `Flex writer lease transition queue for "${leaseArg.storageKey}" stalled.`);
+        }
+        catch (errorArg) {
+            abortController.abort(errorArg);
+            throw this.failStore(errorArg, leaseArg);
+        }
+        try {
+            return await waitForFlexStoreDeadline(operation, Math.max(1, deadline - Date.now()), `Flex writer lease transition for "${leaseArg.storageKey}" stalled.`);
+        }
+        catch (errorArg) {
+            if (!operationSettled) {
+                abortController.abort(errorArg);
+                throw this.failStore(errorArg, leaseArg);
+            }
+            throw errorArg;
+        }
+    }
+    throwIfFatal() {
+        if (this.fatalError)
+            throw this.fatalError;
+    }
+    markLeaseLost(leaseArg) {
+        return this.failStore(new FlexLeaseLostError(leaseArg.storageKey), leaseArg);
+    }
+    failStore(errorArg, leaseArg) {
+        const error = errorArg instanceof Error ? errorArg : new Error(String(errorArg));
+        if (leaseArg)
+            leaseArg.lost = true;
+        if (this.fatalError)
+            return this.fatalError;
+        this.fatalError = error;
+        this.heartbeatsOpen = false;
+        this.maintenanceOpen = false;
+        this.maintenanceAbortController.abort(error);
+        if (this.orphanMaintenanceTimer) {
+            clearTimeout(this.orphanMaintenanceTimer);
+            this.orphanMaintenanceTimer = undefined;
+        }
+        if (this.leaseHeartbeatTimer) {
+            clearInterval(this.leaseHeartbeatTimer);
+            this.leaseHeartbeatTimer = undefined;
+        }
+        for (const controller of this.leaseTransitionAbortControllers)
+            controller.abort(error);
+        for (const lease of this.heldLeases.values()) {
+            lease.lost = true;
+            lease.heartbeatAbortController?.abort(error);
+        }
+        try {
+            this.onFatalError?.(error);
+        }
+        catch {
+            // Store fencing is independent from health-listener behavior.
+        }
+        return error;
+    }
+    startLeaseHeartbeat() {
+        if (this.leaseHeartbeatTimer || !this.heartbeatsOpen)
+            return;
+        this.leaseHeartbeatTimer = setInterval(() => this.heartbeatHeldLeases(), flexLeaseHeartbeatMs);
+        this.leaseHeartbeatTimer.unref?.();
+    }
+    heartbeatHeldLeases() {
+        for (const lease of this.heldLeases.values()) {
+            if (lease.lost || lease.releasing || lease.heartbeatTask)
+                continue;
+            const abortController = new AbortController();
+            const task = this.runLeaseTransition(lease, (transitionSignal, timeoutMs) => (this.verifyHeldLease(lease, true, AbortSignal.any([abortController.signal, transitionSignal]), true, Math.min(timeoutMs, flexLeaseHeartbeatOperationTimeoutMs)))).catch((errorArg) => {
+                if (errorArg instanceof FlexLeaseLostError) {
+                    if (!lease.releasing)
+                        lease.lost = true;
+                    return;
+                }
+                if (!lease.releasing && this.heartbeatsOpen && !abortController.signal.aborted) {
+                    console.error(`Flex writer lease heartbeat for "${lease.storageKey}" failed; retrying on the next interval.`, errorArg);
+                }
+            }).finally(() => {
+                if (lease.heartbeatTask === task)
+                    lease.heartbeatTask = undefined;
+                if (lease.heartbeatAbortController === abortController) {
+                    lease.heartbeatAbortController = undefined;
+                }
+            });
+            lease.heartbeatAbortController = abortController;
+            lease.heartbeatTask = task;
+        }
+    }
+    async releaseHeldLease(leaseArg, timeoutMsArg = flexMaintenanceOperationTimeoutMs) {
+        const deadline = Date.now() + timeoutMsArg;
+        leaseArg.releasing = true;
+        try {
+            const heartbeatTask = leaseArg.heartbeatTask;
+            const heartbeatAbortController = leaseArg.heartbeatAbortController;
+            heartbeatAbortController?.abort(new Error('The Flex writer lease is being released.'));
+            if (heartbeatTask) {
+                await waitForFlexStoreDeadline(heartbeatTask, Math.max(1, deadline - Date.now()), `Flex writer lease heartbeat for "${leaseArg.storageKey}" did not stop before the release deadline.`);
+                if (leaseArg.heartbeatTask === heartbeatTask)
+                    leaseArg.heartbeatTask = undefined;
+                if (leaseArg.heartbeatAbortController === heartbeatAbortController) {
+                    leaseArg.heartbeatAbortController = undefined;
+                }
+            }
+            const transitionTask = leaseArg.transitionTask;
+            if (transitionTask) {
+                try {
+                    await waitForFlexStoreDeadline(transitionTask, Math.max(1, deadline - Date.now()), `Flex writer lease transition for "${leaseArg.storageKey}" did not stop before the release deadline.`);
+                }
+                catch {
+                    leaseArg.lost = true;
+                }
+            }
+            if (leaseArg.lost || this.fatalError) {
+                this.forgetHeldLease(leaseArg);
+                if (this.closed)
+                    this.leaseTransitionAbortControllers.clear();
+                return;
+            }
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0) {
+                throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', `Flex writer lease release for "${leaseArg.storageKey}" exceeded its deadline.`);
+            }
+            await this.releaseLease(leaseArg, remainingMs);
+            this.forgetHeldLease(leaseArg);
+        }
+        catch (errorArg) {
+            leaseArg.releasing = false;
+            if (!this.heldLeases.has(leaseArg.storageKey)) {
+                this.heldLeases.set(leaseArg.storageKey, leaseArg);
+            }
+            throw errorArg;
+        }
+    }
+    forgetHeldLease(leaseArg) {
+        if (this.heldLeases.get(leaseArg.storageKey) === leaseArg) {
+            this.heldLeases.delete(leaseArg.storageKey);
+        }
+        if (this.heldLeases.size === 0 && this.leaseHeartbeatTimer) {
+            clearInterval(this.leaseHeartbeatTimer);
+            this.leaseHeartbeatTimer = undefined;
+        }
+    }
+    async releaseLease(leaseArg, timeoutMsArg = flexMaintenanceOperationTimeoutMs) {
+        const id = flexWriterLeaseId(this.controllerId, leaseArg.storageKey);
+        const collection = FlexWriterLeaseModel.collection.mongoDbCollection;
+        const deadline = Date.now() + timeoutMsArg;
+        while (Date.now() < deadline) {
+            const remainingMs = Math.max(1, deadline - Date.now());
+            const current = await collection.findOne({ id }, { timeoutMS: remainingMs });
+            if (!current
+                || current.ownerToken !== leaseArg.ownerToken
+                || current.epoch !== leaseArg.epoch
+                || current.state === 'released')
+                return;
+            const now = Date.now();
+            const next = {
+                ...leaseBody(current),
+                state: 'released',
+                expiresAt: now,
+                updatedAt: new Date(now).toISOString(),
+            };
+            assertFlexWriterLeaseDocument(next);
+            const transition = await collection.findOneAndReplace({
+                _id: current._id,
+                id,
+                ownerToken: leaseArg.ownerToken,
+                epoch: leaseArg.epoch,
+                state: current.state,
+                _smartdataRevision: smartRevisionSelector(current),
+            }, {
+                ...next,
+                _smartdataRevision: plugins.crypto.randomUUID(),
+            }, {
+                returnDocument: 'after',
+                includeResultMetadata: false,
+                timeoutMS: Math.max(1, deadline - Date.now()),
+            });
+            if (transition)
+                return;
+        }
+        throw new plugins.smartdata.SmartdataExactPersistenceError('ambiguous_write', `Flex writer lease release for "${leaseArg.storageKey}" exceeded its deadline.`);
+    }
+    async cleanupPrivateByCandidate(manifestArg, timeoutMsArg) {
+        const options = timeoutMsArg === undefined ? {} : { timeoutMS: timeoutMsArg };
+        await FlexPrivateChunkModel.collection.mongoDbCollection.deleteMany({
+            controllerId: this.controllerId,
+            candidateId: manifestArg.candidateId,
+        }, options);
+        await FlexPrivateCandidateModel.collection.mongoDbCollection.deleteMany({
+            controllerId: this.controllerId,
+            candidateId: manifestArg.candidateId,
+        }, options);
+    }
+    async cleanupProjectionSourceByCandidate(candidateIdArg, timeoutMsArg) {
+        const filter = { controllerId: this.controllerId, candidateId: candidateIdArg };
+        const options = timeoutMsArg === undefined ? {} : { timeoutMS: timeoutMsArg };
+        await FlexProjectionMessageRecordModel.collection.mongoDbCollection.deleteMany(filter, options);
+        await FlexProjectionSourceModel.collection.mongoDbCollection.deleteMany(filter, options);
+    }
+    async cleanupPublicByCandidate(manifestArg, storageKeyArg, timeoutMsArg) {
+        await Promise.all([
+            FlexPublicSessionRecordModel.collection.mongoDbCollection.deleteMany({
+                controllerId: this.controllerId,
+                scopeId: storageKeyArg,
+                candidateId: manifestArg.candidateId,
+            }, timeoutMsArg === undefined ? {} : { timeoutMS: timeoutMsArg }),
+            FlexPublicMessageRecordModel.collection.mongoDbCollection.deleteMany({
+                controllerId: this.controllerId,
+                scopeId: storageKeyArg,
+                candidateId: manifestArg.candidateId,
+            }, timeoutMsArg === undefined ? {} : { timeoutMS: timeoutMsArg }),
+        ]);
+        await FlexPublicCandidateModel.collection.mongoDbCollection.deleteMany({
+            controllerId: this.controllerId,
+            scopeId: storageKeyArg,
+            candidateId: manifestArg.candidateId,
+        }, timeoutMsArg === undefined ? {} : { timeoutMS: timeoutMsArg });
+    }
+    async ensureMaintenanceLease(storageKeyArg, abortSignalArg) {
+        abortSignalArg.throwIfAborted();
+        const id = flexWriterLeaseId(this.controllerId, storageKeyArg);
+        const collection = FlexWriterLeaseModel.collection.mongoDbCollection;
+        const readLease = async (withAbortSignalArg = true) => {
+            const raw = await collection.findOne({ id }, {
+                ...(withAbortSignalArg ? { signal: abortSignalArg } : {}),
+                timeoutMS: flexMaintenanceOperationTimeoutMs,
+            });
+            if (!raw)
+                return null;
+            const body = leaseBody(raw);
+            assertFlexWriterLeaseDocument(body);
+            if (body.id !== id
+                || body.controllerId !== this.controllerId
+                || body.storageKey !== storageKeyArg) {
+                throw new plugins.flexharness.FlexHarnessStoreFormatError('Flex writer lease identity mismatch.');
+            }
+            return raw;
+        };
+        const held = this.heldLeases.get(storageKeyArg);
+        if (held) {
+            if (held.lost || held.releasing)
+                return undefined;
+            try {
+                await this.runLeaseTransition(held, (transitionSignal, timeoutMs) => this.verifyHeldLease(held, false, AbortSignal.any([abortSignalArg, transitionSignal]), false, Math.min(timeoutMs, flexMaintenanceOperationTimeoutMs)));
+            }
+            catch (errorArg) {
+                if (abortSignalArg.aborted)
+                    throw abortSignalArg.reason;
+                return undefined;
+            }
+            return { lease: held, acquired: false };
+        }
+        const ownerToken = randomOwnerToken();
+        const now = Date.now();
+        let current = await readLease();
+        if (!current) {
+            const document = {
+                id,
+                controllerId: this.controllerId,
+                storageKey: storageKeyArg,
+                ownerToken,
+                epoch: 1,
+                state: 'active',
+                expiresAt: now + flexLeaseDurationMs,
+                updatedAt: new Date(now).toISOString(),
+            };
+            assertFlexWriterLeaseDocument(document);
+            try {
+                await collection.insertOne({
+                    ...document,
+                    _smartdataRevision: plugins.crypto.randomUUID(),
+                }, { timeoutMS: flexMaintenanceOperationTimeoutMs });
+                current = await readLease(false);
+            }
+            catch (errorArg) {
+                current = await readLease(false);
+                if (!current)
+                    throw errorArg;
+            }
+            if (!current
+                || current.ownerToken !== ownerToken
+                || current.epoch !== 1
+                || current.state !== 'active')
+                return undefined;
+        }
+        else {
+            if (current.state === 'active' && current.expiresAt > now)
+                return undefined;
+            const next = {
+                ...leaseBody(current),
+                ownerToken,
+                epoch: current.epoch + 1,
+                state: 'active',
+                expiresAt: now + flexLeaseDurationMs,
+                updatedAt: new Date(now).toISOString(),
+            };
+            assertFlexWriterLeaseDocument(next);
+            const postimage = await collection.findOneAndReplace({
+                _id: current._id,
+                id,
+                ownerToken: current.ownerToken,
+                epoch: current.epoch,
+                state: current.state,
+                _smartdataRevision: smartRevisionSelector(current),
+            }, {
+                ...next,
+                _smartdataRevision: plugins.crypto.randomUUID(),
+            }, {
+                returnDocument: 'after',
+                includeResultMetadata: false,
+                timeoutMS: flexMaintenanceOperationTimeoutMs,
+            });
+            if (!postimage)
+                return undefined;
+            current = postimage;
+        }
+        const lease = {
+            storageKey: storageKeyArg,
+            ownerToken,
+            epoch: current.epoch,
+            expiresAt: current.expiresAt,
+            lost: false,
+            releasing: false,
+        };
+        this.heldLeases.set(storageKeyArg, lease);
+        this.startLeaseHeartbeat();
+        return { lease, acquired: true };
+    }
+    async runIdleMaintenanceStorage(storageKeyArg, abortSignalArg, operationArg) {
+        abortSignalArg.throwIfAborted();
+        if (this.storageQueues.has(storageKeyArg))
+            return false;
+        const operation = (async () => {
+            const leaseResult = await this.ensureMaintenanceLease(storageKeyArg, abortSignalArg);
+            if (!leaseResult)
+                return false;
+            try {
+                abortSignalArg.throwIfAborted();
+                await operationArg();
+                return true;
+            }
+            finally {
+                if (leaseResult.acquired) {
+                    await this.releaseHeldLease(leaseResult.lease, flexMaintenanceOperationTimeoutMs);
+                }
+            }
+        })();
+        const settled = operation.then(() => undefined, () => undefined);
+        this.storageQueues.set(storageKeyArg, settled);
+        void settled.then(() => {
+            if (this.storageQueues.get(storageKeyArg) === settled) {
+                this.storageQueues.delete(storageKeyArg);
+            }
+        });
+        return operation;
+    }
+    async reconcileCandidateOrphans(kindArg, cutoffArg, abortSignalArg) {
+        const model = kindArg === 'private'
+            ? FlexPrivateCandidateModel
+            : kindArg === 'public'
+                ? FlexPublicCandidateModel
+                : FlexProjectionSourceModel;
+        let lastPosition;
+        while (true) {
+            abortSignalArg?.throwIfAborted();
+            const cursor = model.collection.mongoDbCollection.find({
+                controllerId: this.controllerId,
+                ...(lastPosition ? {
+                    $or: [{
+                            createdAt: { $gt: lastPosition.createdAt, $lte: cutoffArg },
+                        }, {
+                            createdAt: lastPosition.createdAt,
+                            _id: { $gt: lastPosition.id },
+                        }],
+                } : { createdAt: { $lte: cutoffArg } }),
+            }, abortSignalArg ? { signal: abortSignalArg } : {})
+                .sort({ createdAt: 1, _id: 1 })
+                .limit(flexMaintenancePageLimit);
+            let documents;
+            try {
+                documents = await cursor.toArray();
+            }
+            finally {
+                await cursor.close();
+            }
+            for (const document of documents) {
+                abortSignalArg?.throwIfAborted();
+                if (this.activeCandidateIds.has(document.candidateId))
+                    continue;
+                try {
+                    await this.runIdleMaintenanceStorage(document.scopeId, abortSignalArg ?? this.maintenanceAbortController.signal, async () => {
+                        if (await this.hasCandidateHeadReference(kindArg, document.candidateId, abortSignalArg))
+                            return;
+                        abortSignalArg?.throwIfAborted();
+                        if (kindArg === 'private') {
+                            await this.cleanupPrivateByCandidate({ candidateId: document.candidateId }, flexMaintenanceOperationTimeoutMs);
+                        }
+                        else if (kindArg === 'public') {
+                            await this.cleanupPublicByCandidate(document, document.scopeId, flexMaintenanceOperationTimeoutMs);
+                        }
+                        else {
+                            await this.cleanupProjectionSourceByCandidate(document.candidateId, flexMaintenanceOperationTimeoutMs);
+                        }
+                    });
+                }
+                catch (errorArg) {
+                    if (abortSignalArg?.aborted)
+                        throw abortSignalArg.reason;
+                }
+            }
+            const last = documents.at(-1);
+            if (!last || documents.length < flexMaintenancePageLimit)
+                break;
+            lastPosition = { createdAt: last.createdAt, id: last._id };
+        }
+    }
+    async hasCandidateHeadReference(kindArg, candidateIdArg, abortSignalArg) {
+        if (kindArg === 'private') {
+            const [legacy, domain] = await Promise.all([
+                FlexHeadModel.collection.mongoDbCollection.findOne({
+                    controllerId: this.controllerId,
+                    currentPrivateCandidateId: candidateIdArg,
+                }, { projection: { _id: 1 }, ...(abortSignalArg ? { signal: abortSignalArg } : {}) }),
+                FlexDomainHeadModel.collection.mongoDbCollection.findOne({
+                    controllerId: this.controllerId,
+                    currentPrivateCandidateId: candidateIdArg,
+                }, { projection: { _id: 1 }, ...(abortSignalArg ? { signal: abortSignalArg } : {}) }),
+            ]);
+            return !!legacy || !!domain;
+        }
+        if (kindArg === 'projectionSource') {
+            return !!await FlexDomainHeadModel.collection.mongoDbCollection.findOne({
+                controllerId: this.controllerId,
+                domain: 'projection',
+                'projectionSource.candidateId': candidateIdArg,
+            }, { projection: { _id: 1 }, ...(abortSignalArg ? { signal: abortSignalArg } : {}) });
+        }
+        const [legacy, current] = await Promise.all([
+            FlexHeadModel.collection.mongoDbCollection.findOne({
+                controllerId: this.controllerId,
+                'publicCandidates.candidateId': candidateIdArg,
+            }, { projection: { _id: 1 }, ...(abortSignalArg ? { signal: abortSignalArg } : {}) }),
+            FlexPublicHeadModel.collection.mongoDbCollection.findOne({
+                controllerId: this.controllerId,
+                'publicCandidates.candidateId': candidateIdArg,
+            }, { projection: { _id: 1 }, ...(abortSignalArg ? { signal: abortSignalArg } : {}) }),
+        ]);
+        return !!legacy || !!current;
+    }
+    evictProviderScope(storageKeyArg) {
+        for (const key of this.agentEventStores.keys()) {
+            if (JSON.parse(key)[0] === storageKeyArg)
+                this.agentEventStores.delete(key);
+        }
+        for (const key of this.jobStores.keys()) {
+            if (JSON.parse(key)[0] === storageKeyArg)
+                this.jobStores.delete(key);
+        }
+    }
+    queueOrphanMaintenance() {
+        if (!this.maintenanceOpen)
+            return;
+        if (this.orphanMaintenanceTask)
+            return;
+        const task = Promise.resolve().then(async () => {
+            await this.reconcileOrphans(Date.now(), this.maintenanceAbortController.signal).catch(() => undefined);
+        }).finally(() => {
+            if (this.orphanMaintenanceTask === task)
+                this.orphanMaintenanceTask = undefined;
+            this.scheduleOrphanMaintenance();
+        });
+        this.orphanMaintenanceTask = task;
+    }
+    scheduleOrphanMaintenance() {
+        if (!this.maintenanceOpen || this.orphanMaintenanceTimer)
+            return;
+        this.orphanMaintenanceTimer = setTimeout(() => {
+            this.orphanMaintenanceTimer = undefined;
+            if (!this.maintenanceOpen)
+                return;
+            this.queueOrphanMaintenance();
+        }, flexOrphanMaintenanceIntervalMs);
+        this.orphanMaintenanceTimer.unref?.();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexstore.js","sourceRoot":"","sources":["../../ts/classes.flexstore.ts"],"names":[],"mappings":"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"}