agl 1.0.17 → 21.0.2

package/dist_ts/classes.flexprojectionreader.js

@@ -0,0 +1,580 @@
+import * as plugins from './plugins.js';
+import { hasFlexExactKeys, isFlexPlainObject } from './interfaces.flexipc.js';
+import { assertFlexProviderConnectionDocument, } from './classes.flexmodels.private.js';
+import { FlexPublicCandidateModel, FlexPublicMessageRecordModel, FlexPublicSessionRecordModel, assertFlexPublicCandidateDocument, assertFlexPublicMessageRecordDocument, assertFlexPublicSessionRecordDocument, flexPublicHeadId, flexPublicPageBytesLimit, flexPublicPageLimit, initFlexPublicModels, isFlexPublicCandidateManifest, registerFlexPublicModels, } from './classes.flexmodels.public.js';
+const sha256 = (valueArg) => plugins.crypto.createHash('sha256').update(valueArg).digest('hex');
+const serializedBytes = (valueArg) => Buffer.from(JSON.stringify(valueArg), 'utf8');
+const isNonNegativeInteger = (valueArg) => Number.isSafeInteger(valueArg) && valueArg >= 0;
+const isBoundedString = (valueArg, maximumBytesArg) => typeof valueArg === 'string'
+    && valueArg.length > 0
+    && Buffer.byteLength(valueArg, 'utf8') <= maximumBytesArg;
+const isIsoDate = (valueArg) => typeof valueArg === 'string'
+    && Number.isFinite(Date.parse(valueArg))
+    && new Date(valueArg).toISOString() === valueArg;
+function assertPublicHeadView(valueArg) {
+    if (!isFlexPlainObject(valueArg)
+        || !hasFlexExactKeys(valueArg, [
+            'id', 'controllerId', 'storageKey', 'revision',
+            'currentPublicCandidateId', 'publicCandidates',
+        ])
+        || !isBoundedString(valueArg.id, 1024)
+        || !isBoundedString(valueArg.controllerId, 512)
+        || !isBoundedString(valueArg.storageKey, 512)
+        || !isNonNegativeInteger(valueArg.revision)
+        || !isBoundedString(valueArg.currentPublicCandidateId, 64)
+        || !Array.isArray(valueArg.publicCandidates)
+        || valueArg.publicCandidates.length < 1
+        || valueArg.publicCandidates.length > 4
+        || !valueArg.publicCandidates.every(isFlexPublicCandidateManifest)
+        || valueArg.publicCandidates[0]?.candidateId !== valueArg.currentPublicCandidateId
+        || valueArg.publicCandidates[0]?.revision !== valueArg.revision)
+        throw new FlexProjectionFormatError();
+}
+const projectCandidate = (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 projectSessionRecord = (modelArg) => ({
+    id: modelArg.id,
+    controllerId: modelArg.controllerId,
+    scopeId: modelArg.scopeId,
+    candidateId: modelArg.candidateId,
+    revision: modelArg.revision,
+    session: modelArg.session,
+    createdAt: modelArg.createdAt,
+});
+const projectMessageRecord = (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 compareNewestSession = (leftArg, rightArg) => rightArg.session.updatedAt.localeCompare(leftArg.session.updatedAt)
+    || rightArg.session.createdAt.localeCompare(leftArg.session.createdAt)
+    || leftArg.session.sessionId.localeCompare(rightArg.session.sessionId);
+const compareNewestMessage = (leftArg, rightArg) => rightArg.messageIndex - leftArg.messageIndex;
+const validateLimit = (valueArg) => {
+    const selected = valueArg ?? flexPublicPageLimit;
+    if (!Number.isSafeInteger(selected) || selected < 1 || selected > flexPublicPageLimit) {
+        throw new FlexProjectionCursorError();
+    }
+    return selected;
+};
+const manifestBytes = (manifestArg) => serializedBytes({
+    candidateId: manifestArg.candidateId,
+    revision: manifestArg.revision,
+    sessionRecords: manifestArg.sessionRecords.map(({ id, sha256: digest, bytes }) => ({
+        id, sha256: digest, bytes,
+    })),
+    messageRecords: manifestArg.messageRecords.map(({ id, sha256: digest, bytes }) => ({
+        id, sha256: digest, bytes,
+    })),
+    sessionsTruncated: manifestArg.sessionsTruncated,
+    messagesTruncated: manifestArg.messagesTruncated,
+    messageBytesTruncated: manifestArg.messageBytesTruncated,
+    visibleDigest: manifestArg.visibleDigest,
+    scopeSource: manifestArg.scopeSource,
+    projectionSources: manifestArg.projectionSources,
+});
+const verifyRecordManifest = (documentArg, manifestArg) => {
+    const bytes = serializedBytes(documentArg);
+    if (documentArg.id !== manifestArg.id
+        || bytes.byteLength !== manifestArg.bytes
+        || sha256(bytes) !== manifestArg.sha256)
+        throw new FlexProjectionFormatError();
+};
+const recordManifestsEqual = (leftArg, rightArg) => leftArg.length === rightArg.length && leftArg.every((left, index) => {
+    const right = rightArg[index];
+    return right !== undefined
+        && left.id === right.id
+        && left.sha256 === right.sha256
+        && left.bytes === right.bytes;
+});
+export class FlexProjectionCursorError extends Error {
+    code = 'FLEX_PROJECTION_CURSOR_INVALID';
+    constructor() {
+        super('The Flex projection cursor is invalid.');
+    }
+}
+export class FlexProjectionStaleCursorError extends Error {
+    code = 'FLEX_PROJECTION_CURSOR_STALE';
+    constructor() {
+        super('The Flex projection cursor refers to an evicted candidate.');
+    }
+}
+export class FlexProjectionNotFoundError extends Error {
+    code = 'FLEX_PROJECTION_NOT_FOUND';
+    constructor() {
+        super('The requested Flex projection was not found.');
+    }
+}
+export class FlexProjectionFormatError extends Error {
+    code = 'FLEX_PROJECTION_FORMAT_INVALID';
+    constructor() {
+        super('The Flex public projection is invalid.');
+    }
+}
+export class FlexProjectionReader {
+    database;
+    controllerId;
+    manager;
+    initialized = false;
+    databaseOpened = false;
+    initPromise;
+    closePromise;
+    closed = false;
+    constructor(optionsArg) {
+        this.controllerId = optionsArg.controllerId;
+        this.database = new plugins.smartdata.SmartdataDb(optionsArg.database);
+        this.manager = { db: this.database };
+        registerFlexPublicModels(this.manager);
+    }
+    async init() {
+        if (this.closed)
+            throw new Error('The Flex projection reader is closed.');
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        const initPromise = (async () => {
+            try {
+                this.databaseOpened = true;
+                await this.database.init();
+                await initFlexPublicModels();
+                if (this.closed)
+                    throw new Error('The Flex projection reader was closed during startup.');
+                this.initialized = true;
+            }
+            catch (errorArg) {
+                if (this.databaseOpened) {
+                    try {
+                        await this.database.close();
+                        this.databaseOpened = false;
+                    }
+                    catch {
+                        // close() retains retry ownership for a database that did not close.
+                    }
+                }
+                throw errorArg;
+            }
+        })();
+        this.initPromise = initPromise;
+        try {
+            await initPromise;
+        }
+        finally {
+            if (this.initPromise === initPromise)
+                this.initPromise = undefined;
+        }
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        const closePromise = (async () => {
+            if (this.initPromise)
+                await this.initPromise.catch(() => undefined);
+            if (this.databaseOpened) {
+                await this.database.close();
+                this.databaseOpened = false;
+            }
+            this.initialized = false;
+        })();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+        }
+        finally {
+            if (this.closePromise === closePromise)
+                this.closePromise = undefined;
+        }
+    }
+    async listSessionPage(scopeIdArg, optionsArg = {}, signalArg) {
+        const limit = validateLimit(optionsArg.limit);
+        const cursor = optionsArg.cursor
+            ? this.parseCursor(optionsArg.cursor, 'sessions', scopeIdArg)
+            : undefined;
+        const selection = await this.selectCandidate(scopeIdArg, cursor, signalArg);
+        const records = await this.loadSessionRecords(selection, signalArg);
+        const startIndex = cursor
+            ? this.findAnchorIndex(records, cursor.anchorId, cursor.anchorTimestamp, (record) => record.session.sessionId, (record) => record.session.updatedAt) + 1
+            : 0;
+        let selected = records.slice(startIndex, startIndex + limit);
+        let page = this.createSessionPage(selection, selected, startIndex + selected.length < records.length);
+        while (serializedBytes(page).byteLength > flexPublicPageBytesLimit && selected.length > 0) {
+            selected = selected.slice(0, -1);
+            page = this.createSessionPage(selection, selected, true);
+        }
+        if (selected.length === 0 && records.length > startIndex)
+            throw new FlexProjectionFormatError();
+        return page;
+    }
+    async listAllSessions(scopeIdArg, signalArg) {
+        const selection = await this.selectCandidate(scopeIdArg, undefined, signalArg);
+        const records = await this.loadSessionRecords(selection, signalArg);
+        return {
+            candidateId: selection.manifest.candidateId,
+            revision: selection.manifest.revision,
+            sessions: records.map((record) => JSON.parse(JSON.stringify(record.session))),
+            truncated: selection.manifest.sessionsTruncated,
+        };
+    }
+    async getSession(scopeIdArg, sessionIdArg, signalArg) {
+        const selection = await this.selectCandidate(scopeIdArg, undefined, signalArg);
+        const records = await this.loadSessionRecords(selection, signalArg);
+        const record = records.find((entry) => entry.session.sessionId === sessionIdArg);
+        if (!record)
+            throw new FlexProjectionNotFoundError();
+        return JSON.parse(JSON.stringify(record.session));
+    }
+    async listMessagePage(scopeIdArg, sessionIdArg, optionsArg = {}, signalArg) {
+        const limit = validateLimit(optionsArg.limit);
+        const cursor = optionsArg.cursor
+            ? this.parseCursor(optionsArg.cursor, 'messages', scopeIdArg, sessionIdArg)
+            : undefined;
+        const selection = await this.selectCandidate(scopeIdArg, cursor, signalArg);
+        const records = (await this.loadMessageRecords(selection, signalArg))
+            .filter((entry) => entry.message.sessionId === sessionIdArg)
+            .sort(compareNewestMessage);
+        const startIndex = cursor
+            ? records.findIndex((record) => (record.message.messageId === cursor.anchorId
+                && record.messageIndex === cursor.anchorMessageIndex)) + 1
+            : 0;
+        if (cursor && startIndex === 0)
+            throw new FlexProjectionCursorError();
+        let newestFirst = records.slice(startIndex, startIndex + limit);
+        let page = this.createMessagePage(selection, sessionIdArg, newestFirst, startIndex + newestFirst.length < records.length);
+        while (serializedBytes(page).byteLength > flexPublicPageBytesLimit && newestFirst.length > 0) {
+            newestFirst = newestFirst.slice(0, -1);
+            page = this.createMessagePage(selection, sessionIdArg, newestFirst, true);
+        }
+        if (newestFirst.length === 0 && records.length > startIndex)
+            throw new FlexProjectionFormatError();
+        return page;
+    }
+    async listAllSessionMessages(scopeIdArg, sessionIdArg, signalArg) {
+        const selection = await this.selectCandidate(scopeIdArg, undefined, signalArg);
+        const records = (await this.loadMessageRecords(selection, signalArg))
+            .filter((entry) => entry.message.sessionId === sessionIdArg)
+            .sort(compareNewestMessage);
+        return {
+            candidateId: selection.manifest.candidateId,
+            revision: selection.manifest.revision,
+            messages: records.map((record) => ({
+                messageIndex: record.messageIndex,
+                message: JSON.parse(JSON.stringify(record.message)),
+            })).reverse(),
+            truncated: selection.manifest.messagesTruncated
+                || selection.manifest.messageBytesTruncated,
+        };
+    }
+    async getMessage(scopeIdArg, sessionIdArg, messageIdArg, signalArg) {
+        const selection = await this.selectCandidate(scopeIdArg, undefined, signalArg);
+        const records = await this.loadMessageRecords(selection, signalArg);
+        const record = records.find((entry) => (entry.message.sessionId === sessionIdArg && entry.message.messageId === messageIdArg));
+        if (!record)
+            throw new FlexProjectionNotFoundError();
+        return {
+            messageIndex: record.messageIndex,
+            message: JSON.parse(JSON.stringify(record.message)),
+        };
+    }
+    async listProviderConnections(signalArg) {
+        signalArg?.throwIfAborted();
+        await this.init();
+        signalArg?.throwIfAborted();
+        const cursor = this.database.mongoDb.collection('flex_provider_connections').find({ controllerId: this.controllerId }, {
+            projection: {
+                _id: 0,
+                id: 1,
+                controllerId: 1,
+                providerId: 1,
+                state: 1,
+                generation: 1,
+                createdAt: 1,
+                updatedAt: 1,
+                account: 1,
+            },
+            sort: { updatedAt: -1, id: 1 },
+            limit: 513,
+            ...(signalArg === undefined ? {} : { signal: signalArg }),
+        });
+        try {
+            const rawDocuments = await cursor.toArray();
+            if (rawDocuments.length > 512) {
+                throw new Error('The persisted Flex provider connection limit was exceeded.');
+            }
+            return rawDocuments.map((rawDocument) => {
+                assertFlexProviderConnectionDocument(rawDocument);
+                const document = rawDocument;
+                if (document.controllerId !== this.controllerId)
+                    throw new FlexProjectionFormatError();
+                return {
+                    loginId: document.id,
+                    providerId: document.providerId,
+                    status: document.state,
+                    ...(document.account === undefined
+                        ? {}
+                        : { account: JSON.parse(JSON.stringify(document.account)) }),
+                };
+            });
+        }
+        finally {
+            await cursor.close();
+        }
+    }
+    async selectCandidate(scopeIdArg, cursorArg, signalArg) {
+        signalArg?.throwIfAborted();
+        await this.init();
+        signalArg?.throwIfAborted();
+        if (cursorArg) {
+            const head = await this.loadHead(scopeIdArg, signalArg);
+            const manifest = head.publicCandidates.find((candidate) => (candidate.candidateId === cursorArg.candidateId
+                && candidate.revision === cursorArg.revision));
+            if (!manifest)
+                throw new FlexProjectionStaleCursorError();
+            const candidate = await this.loadCandidate(scopeIdArg, manifest, signalArg);
+            if (!candidate)
+                throw new FlexProjectionStaleCursorError();
+            return { head, manifest, candidate };
+        }
+        let head = await this.loadHead(scopeIdArg, signalArg);
+        let manifest = head.publicCandidates.find((candidate) => candidate.candidateId === head.currentPublicCandidateId);
+        if (!manifest)
+            throw new FlexProjectionFormatError();
+        let candidate = await this.loadCandidate(scopeIdArg, manifest, signalArg);
+        if (!candidate) {
+            head = await this.loadHead(scopeIdArg, signalArg);
+            manifest = head.publicCandidates.find((entry) => entry.candidateId === head.currentPublicCandidateId);
+            if (!manifest)
+                throw new FlexProjectionFormatError();
+            candidate = await this.loadCandidate(scopeIdArg, manifest, signalArg);
+        }
+        if (!candidate)
+            throw new FlexProjectionFormatError();
+        return { head, manifest, candidate };
+    }
+    async loadHead(scopeIdArg, signalArg) {
+        const raw = await this.database.mongoDb.collection('flex_public_heads').findOne({ id: flexPublicHeadId(this.controllerId, scopeIdArg) }, {
+            projection: {
+                _id: 0,
+                id: 1,
+                controllerId: 1,
+                storageKey: 1,
+                revision: 1,
+                currentPublicCandidateId: 1,
+                publicCandidates: 1,
+            },
+            ...(signalArg === undefined ? {} : { signal: signalArg }),
+        });
+        if (!raw)
+            throw new FlexProjectionNotFoundError();
+        assertPublicHeadView(raw);
+        if (raw.controllerId !== this.controllerId || raw.storageKey !== scopeIdArg) {
+            throw new FlexProjectionFormatError();
+        }
+        return raw;
+    }
+    async loadCandidate(scopeIdArg, manifestArg, signalArg) {
+        const raw = await FlexPublicCandidateModel.collection.mongoDbCollection.findOne({
+            candidateId: manifestArg.candidateId,
+            controllerId: this.controllerId,
+            scopeId: scopeIdArg,
+        }, {
+            projection: { _id: 0 },
+            ...(signalArg === undefined ? {} : { signal: signalArg }),
+        });
+        if (!raw)
+            return undefined;
+        const candidate = projectCandidate(raw);
+        assertFlexPublicCandidateDocument(candidate);
+        const bytes = manifestBytes(manifestArg);
+        if (candidate.candidateId !== manifestArg.candidateId
+            || candidate.revision !== manifestArg.revision
+            || candidate.sha256 !== manifestArg.sha256
+            || candidate.bytes !== manifestArg.bytes
+            || !recordManifestsEqual(candidate.sessionRecords, manifestArg.sessionRecords)
+            || !recordManifestsEqual(candidate.messageRecords, manifestArg.messageRecords)
+            || candidate.sessionsTruncated !== manifestArg.sessionsTruncated
+            || candidate.messagesTruncated !== manifestArg.messagesTruncated
+            || candidate.messageBytesTruncated !== manifestArg.messageBytesTruncated
+            || bytes.byteLength !== manifestArg.bytes
+            || sha256(bytes) !== manifestArg.sha256)
+            throw new FlexProjectionFormatError();
+        return candidate;
+    }
+    async loadSessionRecords(selectionArg, signalArg) {
+        const cursor = FlexPublicSessionRecordModel.collection.mongoDbCollection.find({
+            candidateId: selectionArg.candidate.candidateId,
+            controllerId: this.controllerId,
+            scopeId: selectionArg.head.storageKey,
+        }, {
+            projection: { _id: 0 },
+            ...(signalArg === undefined ? {} : { signal: signalArg }),
+        });
+        try {
+            const documents = await cursor.toArray();
+            if (documents.length !== selectionArg.manifest.sessionRecords.length) {
+                throw new FlexProjectionFormatError();
+            }
+            const manifestById = new Map(selectionArg.manifest.sessionRecords.map((manifest) => [manifest.id, manifest]));
+            return documents.map((raw) => {
+                const document = projectSessionRecord(raw);
+                assertFlexPublicSessionRecordDocument(document);
+                const manifest = manifestById.get(document.id);
+                if (!manifest || document.revision !== selectionArg.manifest.revision) {
+                    throw new FlexProjectionFormatError();
+                }
+                verifyRecordManifest(document, manifest);
+                return document;
+            }).sort(compareNewestSession);
+        }
+        finally {
+            await cursor.close();
+        }
+    }
+    async loadMessageRecords(selectionArg, signalArg) {
+        const cursor = FlexPublicMessageRecordModel.collection.mongoDbCollection.find({
+            candidateId: selectionArg.candidate.candidateId,
+            controllerId: this.controllerId,
+            scopeId: selectionArg.head.storageKey,
+        }, {
+            projection: { _id: 0 },
+            ...(signalArg === undefined ? {} : { signal: signalArg }),
+        });
+        try {
+            const documents = await cursor.toArray();
+            if (documents.length !== selectionArg.manifest.messageRecords.length) {
+                throw new FlexProjectionFormatError();
+            }
+            const manifestById = new Map(selectionArg.manifest.messageRecords.map((manifest) => [manifest.id, manifest]));
+            const records = documents.map((raw) => {
+                const document = projectMessageRecord(raw);
+                assertFlexPublicMessageRecordDocument(document);
+                const manifest = manifestById.get(document.id);
+                if (!manifest || document.revision !== selectionArg.manifest.revision) {
+                    throw new FlexProjectionFormatError();
+                }
+                verifyRecordManifest(document, manifest);
+                return document;
+            });
+            if (new Set(records.map((record) => (`${record.message.sessionId}\0${record.messageIndex}`))).size !== records.length)
+                throw new FlexProjectionFormatError();
+            return records;
+        }
+        finally {
+            await cursor.close();
+        }
+    }
+    createSessionPage(selectionArg, recordsArg, hasMoreArg) {
+        const anchor = recordsArg.at(-1);
+        return {
+            candidateId: selectionArg.manifest.candidateId,
+            revision: selectionArg.manifest.revision,
+            sessions: recordsArg.map((record) => JSON.parse(JSON.stringify(record.session))),
+            ...(hasMoreArg && anchor ? {
+                nextCursor: this.encodeCursor({
+                    version: 2,
+                    kind: 'sessions',
+                    controllerId: this.controllerId,
+                    scopeId: selectionArg.head.storageKey,
+                    candidateId: selectionArg.manifest.candidateId,
+                    revision: selectionArg.manifest.revision,
+                    anchorId: anchor.session.sessionId,
+                    anchorTimestamp: anchor.session.updatedAt,
+                }),
+            } : {}),
+            truncated: selectionArg.manifest.sessionsTruncated,
+        };
+    }
+    createMessagePage(selectionArg, sessionIdArg, newestFirstArg, hasMoreArg) {
+        const anchor = newestFirstArg.at(-1);
+        return {
+            candidateId: selectionArg.manifest.candidateId,
+            revision: selectionArg.manifest.revision,
+            messages: newestFirstArg
+                .map((record) => ({
+                messageIndex: record.messageIndex,
+                message: JSON.parse(JSON.stringify(record.message)),
+            }))
+                .reverse(),
+            ...(hasMoreArg && anchor ? {
+                nextCursor: this.encodeCursor({
+                    version: 2,
+                    kind: 'messages',
+                    controllerId: this.controllerId,
+                    scopeId: selectionArg.head.storageKey,
+                    candidateId: selectionArg.manifest.candidateId,
+                    revision: selectionArg.manifest.revision,
+                    anchorId: anchor.message.messageId,
+                    anchorMessageIndex: anchor.messageIndex,
+                    sessionId: sessionIdArg,
+                }),
+            } : {}),
+            truncated: selectionArg.manifest.messagesTruncated
+                || selectionArg.manifest.messageBytesTruncated,
+        };
+    }
+    encodeCursor(cursorArg) {
+        return serializedBytes(cursorArg).toString('base64url');
+    }
+    parseCursor(cursorArg, kindArg, scopeIdArg, sessionIdArg) {
+        if (!isBoundedString(cursorArg, 4096))
+            throw new FlexProjectionCursorError();
+        let parsed;
+        try {
+            const bytes = Buffer.from(cursorArg, 'base64url');
+            if (bytes.toString('base64url') !== cursorArg)
+                throw new Error('non-canonical');
+            parsed = JSON.parse(bytes.toString('utf8'));
+        }
+        catch {
+            throw new FlexProjectionCursorError();
+        }
+        if (!isFlexPlainObject(parsed)
+            || !hasFlexExactKeys(parsed, [
+                'version', 'kind', 'controllerId', 'scopeId', 'candidateId',
+                'revision', 'anchorId',
+            ], ['sessionId', 'anchorTimestamp', 'anchorMessageIndex'])
+            || parsed.version !== 2
+            || parsed.kind !== kindArg
+            || parsed.controllerId !== this.controllerId
+            || parsed.scopeId !== scopeIdArg
+            || !isBoundedString(parsed.candidateId, 64)
+            || !isNonNegativeInteger(parsed.revision)
+            || !isBoundedString(parsed.anchorId, 512)
+            || (kindArg === 'messages' && (parsed.sessionId !== sessionIdArg
+                || !isNonNegativeInteger(parsed.anchorMessageIndex)
+                || parsed.anchorTimestamp !== undefined))
+            || (kindArg === 'sessions' && (parsed.sessionId !== undefined
+                || !isIsoDate(parsed.anchorTimestamp)
+                || parsed.anchorMessageIndex !== undefined)))
+            throw new FlexProjectionCursorError();
+        return parsed;
+    }
+    findAnchorIndex(recordsArg, anchorIdArg, anchorTimestampArg, idArg, timestampArg) {
+        const index = recordsArg.findIndex((record) => (idArg(record) === anchorIdArg && timestampArg(record) === anchorTimestampArg));
+        if (index < 0)
+            throw new FlexProjectionCursorError();
+        return index;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexprojectionreader.js","sourceRoot":"","sources":["../../ts/classes.flexprojectionreader.ts"],"names":[],"mappings":"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"}