@caupulican/pi-adaptative 0.81.39 → 0.81.41

package/dist/core/orchestration/event-store.js

@@ -0,0 +1,560 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { stateFile } from "../agent-paths.js";
+import { withFileLockSync, writeFileAtomicSync } from "../util/atomic-file.js";
+import { isOrchestrationEvent, ORCHESTRATION_SCHEMA_VERSION, } from "./contracts.js";
+const EVENT_FILE_PATTERN = /^(\d{16})\.json$/;
+const SNAPSHOT_FILE_PATTERN = /^(\d{16})\.json$/;
+const DEFAULT_MAX_TAIL_EVENTS = 256;
+const DEFAULT_MAX_TAIL_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_IDEMPOTENCY_EVENTS = 512;
+export class OrchestrationEventStoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OrchestrationEventStoreError";
+    }
+}
+export class OrchestrationConcurrencyError extends OrchestrationEventStoreError {
+    constructor(expected, actual) {
+        super(`Orchestration event cursor changed: expected ${expected}, actual ${actual}.`);
+        this.name = "OrchestrationConcurrencyError";
+    }
+}
+export class OrchestrationSnapshotRequiredError extends OrchestrationEventStoreError {
+    throughOrdinal;
+    constructor(throughOrdinal) {
+        super(`Orchestration projection snapshot through ordinal ${throughOrdinal} is required.`);
+        this.name = "OrchestrationSnapshotRequiredError";
+        this.throughOrdinal = throughOrdinal;
+    }
+}
+function safeSessionDirectoryName(sessionId) {
+    const readable = encodeURIComponent(sessionId).replaceAll("%", "_").slice(0, 80) || "session";
+    const digest = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    return `${readable}-${digest}`;
+}
+function parseCursor(filePath) {
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const record = parsed;
+        if (record.version !== 1 || !Number.isSafeInteger(record.lastOrdinal) || Number(record.lastOrdinal) < 0) {
+            return undefined;
+        }
+        if (record.tailBytes !== undefined && (!Number.isSafeInteger(record.tailBytes) || Number(record.tailBytes) < 0)) {
+            return undefined;
+        }
+        return {
+            version: 1,
+            lastOrdinal: Number(record.lastOrdinal),
+            ...(record.tailBytes !== undefined ? { tailBytes: Number(record.tailBytes) } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function serialize(value) {
+    return `${JSON.stringify(value, null, "\t")}\n`;
+}
+function eventFileName(ordinal) {
+    return `${String(ordinal).padStart(16, "0")}.json`;
+}
+function snapshotDigest(content) {
+    return createHash("sha256").update(JSON.stringify(content)).digest("hex");
+}
+function positiveSafeInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1) {
+        throw new OrchestrationEventStoreError(`${label} must be a positive safe integer.`);
+    }
+    return resolved;
+}
+/**
+ * Append-only event tail with a replaceable full-state projection snapshot. Atomic rename prevents
+ * torn records. Snapshot publication is two-phase (payload, then small baseline pointer), after which
+ * covered event/idempotency files are pruned. A crash at any point leaves either the old replay prefix
+ * or the new verified snapshot authoritative; ordinals never reset.
+ */
+export class OrchestrationEventStore {
+    rootDir;
+    eventsDir;
+    idempotencyDir;
+    cursorPath;
+    snapshotsDir;
+    baselinePath;
+    now;
+    createEventId;
+    maxTailEvents;
+    maxTailBytes;
+    maxIdempotencyEvents;
+    listeners = new Set();
+    verifiedSnapshotBaseline;
+    constructor(options) {
+        this.rootDir = stateFile(options.agentDir, "orchestration", safeSessionDirectoryName(options.sessionId));
+        this.eventsDir = join(this.rootDir, "events");
+        this.idempotencyDir = join(this.rootDir, "idempotency");
+        this.cursorPath = join(this.rootDir, "cursor.json");
+        this.snapshotsDir = join(this.rootDir, "snapshots");
+        this.baselinePath = join(this.rootDir, "projection-baseline.json");
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.createEventId = options.createEventId ?? randomUUID;
+        this.maxTailEvents = positiveSafeInteger(options.maxTailEvents, DEFAULT_MAX_TAIL_EVENTS, "maxTailEvents");
+        this.maxTailBytes = positiveSafeInteger(options.maxTailBytes, DEFAULT_MAX_TAIL_BYTES, "maxTailBytes");
+        this.maxIdempotencyEvents = positiveSafeInteger(options.maxIdempotencyEvents, DEFAULT_MAX_IDEMPOTENCY_EVENTS, "maxIdempotencyEvents");
+    }
+    append(input, options = {}) {
+        const committed = withFileLockSync(this.cursorPath, () => {
+            const cursor = this.synchronizeIndexesUnlocked();
+            const actual = cursor.lastOrdinal;
+            if (input.idempotencyKey) {
+                const existing = this.readIdempotentEventUnlocked(input.idempotencyKey);
+                if (existing)
+                    return { event: existing, appended: false };
+            }
+            if (options.expectedLastOrdinal !== undefined) {
+                if (actual !== options.expectedLastOrdinal) {
+                    throw new OrchestrationConcurrencyError(options.expectedLastOrdinal, actual);
+                }
+            }
+            const ordinal = actual + 1;
+            const next = {
+                schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+                ordinal,
+                eventId: this.createEventId(),
+                type: input.type,
+                aggregateId: input.aggregateId,
+                actor: input.actor,
+                occurredAt: this.now(),
+                ...(input.correlationId ? { correlationId: input.correlationId } : {}),
+                ...(input.causationId ? { causationId: input.causationId } : {}),
+                ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+                payload: structuredClone(input.payload),
+            };
+            const serializedEvent = serialize(next);
+            writeFileAtomicSync(join(this.eventsDir, eventFileName(ordinal)), serializedEvent);
+            if (input.idempotencyKey)
+                this.writeIdempotencyMarkerUnlocked(input.idempotencyKey, ordinal);
+            writeFileAtomicSync(this.cursorPath, serialize({
+                version: 1,
+                lastOrdinal: ordinal,
+                tailBytes: cursor.tailBytes + Buffer.byteLength(serializedEvent),
+            }));
+            return { event: next, appended: true };
+        });
+        if (committed.appended) {
+            for (const listener of this.listeners)
+                listener(structuredClone(committed.event));
+        }
+        return structuredClone(committed.event);
+    }
+    readAll() {
+        return this.readAllUnlocked();
+    }
+    readAfter(ordinal) {
+        const baseline = this.readBaselineUnlocked();
+        if (baseline && ordinal < baseline.throughOrdinal) {
+            throw new OrchestrationSnapshotRequiredError(baseline.throughOrdinal);
+        }
+        const events = [];
+        const names = this.eventFileNamesUnlocked();
+        this.assertReadableTailUnlocked(names, baseline?.throughOrdinal ?? 0);
+        let previousOrdinal = ordinal;
+        for (const name of names) {
+            const match = EVENT_FILE_PATTERN.exec(name);
+            if (!match)
+                continue;
+            const fileOrdinal = Number(match[1]);
+            if (fileOrdinal <= ordinal)
+                continue;
+            const event = this.readEventFileUnlocked(name);
+            if (event.ordinal !== fileOrdinal || event.ordinal <= previousOrdinal) {
+                throw new OrchestrationEventStoreError(`Non-monotonic orchestration event ordinal in ${name}`);
+            }
+            previousOrdinal = event.ordinal;
+            events.push(structuredClone(event));
+        }
+        return events;
+    }
+    readProjectionSnapshot() {
+        const snapshot = this.readProjectionSnapshotUnlocked();
+        return snapshot
+            ? { throughOrdinal: snapshot.throughOrdinal, projection: structuredClone(snapshot.projection) }
+            : undefined;
+    }
+    /** Replace a large replay prefix with one verified current-state snapshot and a bounded tail. */
+    compactIfNeeded(throughOrdinal, projection) {
+        const baselineBeforeLock = this.readBaselineUnlocked()?.throughOrdinal ?? 0;
+        const cursorBeforeLock = parseCursor(this.cursorPath);
+        if (cursorBeforeLock?.lastOrdinal === throughOrdinal &&
+            cursorBeforeLock.tailBytes !== undefined &&
+            throughOrdinal - baselineBeforeLock < this.maxTailEvents &&
+            cursorBeforeLock.tailBytes < this.maxTailBytes) {
+            return false;
+        }
+        return withFileLockSync(this.cursorPath, () => {
+            const cursor = this.synchronizeIndexesUnlocked();
+            if (cursor.lastOrdinal !== throughOrdinal)
+                return false;
+            const baselineOrdinal = this.readBaselineUnlocked()?.throughOrdinal ?? 0;
+            const tailNames = this.eventFileNamesUnlocked().filter((name) => Number(EVENT_FILE_PATTERN.exec(name)?.[1] ?? 0) > baselineOrdinal);
+            if (tailNames.length < this.maxTailEvents && cursor.tailBytes < this.maxTailBytes)
+                return false;
+            const retainedByKey = new Map();
+            for (const event of this.readProjectionSnapshotUnlocked()?.idempotencyEvents ?? []) {
+                if (event.idempotencyKey)
+                    retainedByKey.set(event.idempotencyKey, event);
+            }
+            for (const name of tailNames) {
+                const event = this.readEventFileUnlocked(name);
+                if (event.ordinal <= throughOrdinal && event.idempotencyKey) {
+                    retainedByKey.set(event.idempotencyKey, event);
+                }
+            }
+            const idempotencyEvents = [...retainedByKey.values()]
+                .sort((left, right) => left.ordinal - right.ordinal)
+                .slice(-this.maxIdempotencyEvents)
+                .map((event) => structuredClone(event));
+            const content = {
+                version: 1,
+                schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+                throughOrdinal,
+                createdAt: this.now(),
+                projection: structuredClone(projection()),
+                idempotencyEvents,
+            };
+            const digest = snapshotDigest(content);
+            const snapshotFile = eventFileName(throughOrdinal);
+            writeFileAtomicSync(join(this.snapshotsDir, snapshotFile), serialize({ ...content, digest }));
+            writeFileAtomicSync(this.baselinePath, serialize({ version: 1, throughOrdinal, digest, snapshotFile }));
+            for (const name of this.idempotencyFileNamesUnlocked()) {
+                this.unlinkManagedFile(join(this.idempotencyDir, name));
+            }
+            for (const name of this.eventFileNamesUnlocked()) {
+                const ordinal = Number(EVENT_FILE_PATTERN.exec(name)?.[1] ?? 0);
+                if (ordinal <= throughOrdinal)
+                    this.unlinkManagedFile(join(this.eventsDir, name));
+            }
+            for (const name of this.snapshotFileNamesUnlocked()) {
+                if (name !== snapshotFile)
+                    this.unlinkManagedFile(join(this.snapshotsDir, name));
+            }
+            writeFileAtomicSync(this.cursorPath, serialize({ version: 1, lastOrdinal: throughOrdinal, tailBytes: 0 }));
+            return true;
+        });
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    readAllUnlocked() {
+        const names = this.eventFileNamesUnlocked();
+        const events = [];
+        const baselineOrdinal = this.readProjectionSnapshotUnlocked()?.throughOrdinal ?? 0;
+        this.assertReadableTailUnlocked(names, baselineOrdinal);
+        let previousOrdinal = baselineOrdinal;
+        for (const name of names) {
+            const match = EVENT_FILE_PATTERN.exec(name);
+            if (!match)
+                continue;
+            const fileOrdinal = Number(match[1]);
+            if (fileOrdinal <= baselineOrdinal)
+                continue;
+            const parsed = this.readEventFileUnlocked(name);
+            if (parsed.ordinal !== fileOrdinal || parsed.ordinal <= previousOrdinal) {
+                throw new OrchestrationEventStoreError(`Non-monotonic orchestration event ordinal in ${name}`);
+            }
+            previousOrdinal = parsed.ordinal;
+            events.push(structuredClone(parsed));
+        }
+        return events;
+    }
+    eventFileNamesUnlocked() {
+        try {
+            return readdirSync(this.eventsDir)
+                .filter((candidate) => EVENT_FILE_PATTERN.test(candidate))
+                .sort();
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+    }
+    idempotencyFileNamesUnlocked() {
+        try {
+            return readdirSync(this.idempotencyDir).filter((candidate) => candidate.endsWith(".json"));
+        }
+        catch {
+            return [];
+        }
+    }
+    snapshotFileNamesUnlocked() {
+        try {
+            return readdirSync(this.snapshotsDir)
+                .filter((candidate) => SNAPSHOT_FILE_PATTERN.test(candidate))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Event files are a contiguous append-only tail after the published snapshot. */
+    assertContiguousTailOrdinalsUnlocked(names, baselineOrdinal) {
+        let expectedOrdinal = baselineOrdinal + 1;
+        for (const name of names) {
+            const ordinal = Number(EVENT_FILE_PATTERN.exec(name)?.[1] ?? 0);
+            // A crash after publishing the baseline but before pruning is safe: the snapshot covers these files.
+            if (ordinal <= baselineOrdinal)
+                continue;
+            if (ordinal !== expectedOrdinal) {
+                throw new OrchestrationEventStoreError(`Missing orchestration event ordinal ${expectedOrdinal} before ${name}.`);
+            }
+            expectedOrdinal++;
+        }
+    }
+    /** A valid cursor may lag a newly published snapshot, but it must never lead its committed tail. */
+    assertReadableTailUnlocked(names, baselineOrdinal) {
+        this.assertContiguousTailOrdinalsUnlocked(names, baselineOrdinal);
+        const highestEventOrdinal = names.length > 0 ? Number(EVENT_FILE_PATTERN.exec(names.at(-1))?.[1] ?? 0) : 0;
+        const highestCommittedOrdinal = Math.max(baselineOrdinal, highestEventOrdinal);
+        const cursor = parseCursor(this.cursorPath);
+        if (cursor && cursor.lastOrdinal > highestCommittedOrdinal) {
+            throw new OrchestrationEventStoreError(`Orchestration cursor ${cursor.lastOrdinal} is ahead of the last committed event ${highestCommittedOrdinal}.`);
+        }
+    }
+    readBaselineUnlocked() {
+        if (!existsSync(this.baselinePath))
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(this.baselinePath, "utf-8"));
+        }
+        catch (error) {
+            throw new OrchestrationEventStoreError(`Failed to parse orchestration snapshot baseline: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new OrchestrationEventStoreError("Invalid orchestration snapshot baseline.");
+        }
+        const baseline = parsed;
+        if (baseline.version !== 1 ||
+            !Number.isSafeInteger(baseline.throughOrdinal) ||
+            Number(baseline.throughOrdinal) < 1 ||
+            typeof baseline.digest !== "string" ||
+            baseline.digest.length === 0 ||
+            typeof baseline.snapshotFile !== "string" ||
+            !SNAPSHOT_FILE_PATTERN.test(baseline.snapshotFile) ||
+            Number(SNAPSHOT_FILE_PATTERN.exec(baseline.snapshotFile)?.[1] ?? 0) !== Number(baseline.throughOrdinal)) {
+            throw new OrchestrationEventStoreError("Invalid orchestration snapshot baseline.");
+        }
+        return {
+            version: 1,
+            throughOrdinal: Number(baseline.throughOrdinal),
+            digest: baseline.digest,
+            snapshotFile: baseline.snapshotFile,
+        };
+    }
+    readProjectionSnapshotUnlocked() {
+        const baseline = this.readBaselineUnlocked();
+        if (!baseline)
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(join(this.snapshotsDir, baseline.snapshotFile), "utf-8"));
+        }
+        catch (error) {
+            throw new OrchestrationEventStoreError(`Failed to parse orchestration projection snapshot: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new OrchestrationEventStoreError("Invalid orchestration projection snapshot.");
+        }
+        const snapshot = parsed;
+        if (snapshot.version !== 1 ||
+            snapshot.schemaVersion !== ORCHESTRATION_SCHEMA_VERSION ||
+            snapshot.throughOrdinal !== baseline.throughOrdinal ||
+            typeof snapshot.createdAt !== "string" ||
+            !snapshot.projection ||
+            typeof snapshot.projection !== "object" ||
+            Array.isArray(snapshot.projection) ||
+            !Array.isArray(snapshot.idempotencyEvents) ||
+            !snapshot.idempotencyEvents.every(isOrchestrationEvent) ||
+            !snapshot.idempotencyEvents.every((event) => event.ordinal <= baseline.throughOrdinal && event.idempotencyKey !== undefined) ||
+            new Set(snapshot.idempotencyEvents.map((event) => event.idempotencyKey)).size !==
+                snapshot.idempotencyEvents.length ||
+            typeof snapshot.digest !== "string" ||
+            snapshot.digest !== baseline.digest) {
+            throw new OrchestrationEventStoreError("Invalid orchestration projection snapshot.");
+        }
+        const content = {
+            version: 1,
+            schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+            throughOrdinal: baseline.throughOrdinal,
+            createdAt: snapshot.createdAt,
+            projection: structuredClone(snapshot.projection),
+            idempotencyEvents: snapshot.idempotencyEvents.map((event) => structuredClone(event)),
+        };
+        if (snapshotDigest(content) !== baseline.digest) {
+            throw new OrchestrationEventStoreError("Orchestration projection snapshot digest mismatch.");
+        }
+        return { ...content, digest: baseline.digest };
+    }
+    /**
+     * Appends need a verified snapshot baseline but must not deserialize its projection on every event.
+     * The baseline pointer remains small and is reread each time; an immutable snapshot is reparsed only
+     * when its pointer or filesystem identity changes.
+     */
+    readVerifiedSnapshotBaselineUnlocked() {
+        const baseline = this.readBaselineUnlocked();
+        if (!baseline) {
+            this.verifiedSnapshotBaseline = undefined;
+            return undefined;
+        }
+        const signature = this.snapshotFileSignatureUnlocked(baseline);
+        const cached = this.verifiedSnapshotBaseline;
+        if (cached &&
+            cached.baseline.throughOrdinal === baseline.throughOrdinal &&
+            cached.baseline.digest === baseline.digest &&
+            cached.baseline.snapshotFile === baseline.snapshotFile &&
+            cached.signature.size === signature.size &&
+            cached.signature.mtimeMs === signature.mtimeMs &&
+            cached.signature.ctimeMs === signature.ctimeMs) {
+            return baseline;
+        }
+        this.readProjectionSnapshotUnlocked();
+        const verifiedSignature = this.snapshotFileSignatureUnlocked(baseline);
+        if (verifiedSignature.size !== signature.size ||
+            verifiedSignature.mtimeMs !== signature.mtimeMs ||
+            verifiedSignature.ctimeMs !== signature.ctimeMs) {
+            throw new OrchestrationEventStoreError("Orchestration projection snapshot changed while being verified.");
+        }
+        this.verifiedSnapshotBaseline = { baseline, signature };
+        return baseline;
+    }
+    snapshotFileSignatureUnlocked(baseline) {
+        try {
+            const stats = statSync(join(this.snapshotsDir, baseline.snapshotFile));
+            if (!stats.isFile())
+                throw new OrchestrationEventStoreError("Orchestration projection snapshot is not a file.");
+            return { size: stats.size, mtimeMs: stats.mtimeMs, ctimeMs: stats.ctimeMs };
+        }
+        catch (error) {
+            if (error instanceof OrchestrationEventStoreError)
+                throw error;
+            throw new OrchestrationEventStoreError(`Failed to parse orchestration projection snapshot: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    unlinkManagedFile(filePath) {
+        try {
+            unlinkSync(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    readEventFileUnlocked(name) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(join(this.eventsDir, name), "utf-8"));
+        }
+        catch (error) {
+            throw new OrchestrationEventStoreError(`Failed to parse orchestration event ${name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!isOrchestrationEvent(parsed)) {
+            throw new OrchestrationEventStoreError(`Invalid orchestration event record: ${name}`);
+        }
+        return parsed;
+    }
+    idempotencyPath(key) {
+        return join(this.idempotencyDir, `${createHash("sha256").update(key).digest("hex")}.json`);
+    }
+    writeIdempotencyMarkerUnlocked(key, ordinal) {
+        writeFileAtomicSync(this.idempotencyPath(key), serialize({ version: 1, key, ordinal }));
+    }
+    readIdempotentEventUnlocked(key) {
+        const markerPath = this.idempotencyPath(key);
+        if (!existsSync(markerPath)) {
+            return this.readProjectionSnapshotUnlocked()?.idempotencyEvents.find((event) => event.idempotencyKey === key);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(markerPath, "utf-8"));
+        }
+        catch (error) {
+            throw new OrchestrationEventStoreError(`Failed to parse orchestration idempotency marker: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new OrchestrationEventStoreError("Invalid orchestration idempotency marker.");
+        }
+        const marker = parsed;
+        if (marker.version !== 1 ||
+            marker.key !== key ||
+            !Number.isSafeInteger(marker.ordinal) ||
+            Number(marker.ordinal) < 1) {
+            throw new OrchestrationEventStoreError("Invalid orchestration idempotency marker.");
+        }
+        const ordinal = Number(marker.ordinal);
+        if (!existsSync(join(this.eventsDir, eventFileName(ordinal)))) {
+            const retained = this.readProjectionSnapshotUnlocked()?.idempotencyEvents.find((event) => event.idempotencyKey === key && event.ordinal === ordinal);
+            if (retained)
+                return retained;
+        }
+        const event = this.readEventFileUnlocked(eventFileName(ordinal));
+        if (event.ordinal !== ordinal || event.idempotencyKey !== key) {
+            throw new OrchestrationEventStoreError("Orchestration idempotency marker does not match its event.");
+        }
+        return event;
+    }
+    /**
+     * Reconcile only the crash tail when an event rename committed before its marker/cursor. Normal
+     * appends read directory metadata plus one marker, never the accumulated event payload prefix.
+     */
+    synchronizeIndexesUnlocked() {
+        const names = this.eventFileNamesUnlocked();
+        const baselineOrdinal = this.readVerifiedSnapshotBaselineUnlocked()?.throughOrdinal ?? 0;
+        this.assertReadableTailUnlocked(names, baselineOrdinal);
+        const highestEventOrdinal = names.length > 0 ? Number(EVENT_FILE_PATTERN.exec(names.at(-1))?.[1] ?? 0) : 0;
+        const highest = Math.max(baselineOrdinal, highestEventOrdinal);
+        const cursor = parseCursor(this.cursorPath);
+        if (cursor?.lastOrdinal === highest &&
+            cursor.tailBytes !== undefined &&
+            (highest > baselineOrdinal || cursor.tailBytes === 0)) {
+            return { lastOrdinal: highest, tailBytes: cursor.tailBytes };
+        }
+        if (cursor && cursor.lastOrdinal > highest) {
+            throw new OrchestrationEventStoreError(`Orchestration cursor ${cursor.lastOrdinal} is ahead of the last committed event ${highest}.`);
+        }
+        const rebuildFrom = Math.max(baselineOrdinal + 1, cursor && cursor.lastOrdinal >= baselineOrdinal && cursor.lastOrdinal <= highest
+            ? cursor.lastOrdinal + 1
+            : baselineOrdinal + 1);
+        for (const name of names) {
+            const ordinal = Number(EVENT_FILE_PATTERN.exec(name)?.[1] ?? 0);
+            if (ordinal < rebuildFrom || ordinal <= baselineOrdinal)
+                continue;
+            const event = this.readEventFileUnlocked(name);
+            if (event.ordinal !== ordinal) {
+                throw new OrchestrationEventStoreError(`Event ordinal does not match file name: ${name}`);
+            }
+            if (event.idempotencyKey)
+                this.writeIdempotencyMarkerUnlocked(event.idempotencyKey, ordinal);
+        }
+        const tailBytes = names.reduce((total, name) => {
+            const ordinal = Number(EVENT_FILE_PATTERN.exec(name)?.[1] ?? 0);
+            if (ordinal <= baselineOrdinal)
+                return total;
+            try {
+                return total + statSync(join(this.eventsDir, name)).size;
+            }
+            catch {
+                return total;
+            }
+        }, 0);
+        writeFileAtomicSync(this.cursorPath, serialize({ version: 1, lastOrdinal: highest, tailBytes }));
+        return { lastOrdinal: highest, tailBytes };
+    }
+}
+//# sourceMappingURL=event-store.js.map