engineering-memory 0.1.0

package/runtime/dist/src/journal/journal-store.js

@@ -0,0 +1,1300 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { assertManagedPath, atomicWrite, ensureManagedDirectory, ensureWithinRoot, readJson, safeSegment, writeJson, } from '../utilities/files.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { assertSafeToPersist } from '../runtime/offline-outbox.js';
+const canonicalJournalSchemaVersion = 3;
+const supportedJournalSchemaVersions = new Set([1, 2, 3]);
+const absentJournalToken = '(none)';
+const emptyJournalToken = '(empty)';
+const journalTypeSeparator = ' · ';
+const journalTextSeparator = ' — ';
+const journalDetailsPrefix = '  details: ';
+export class JournalStore {
+    root;
+    queues = new Map();
+    constructor(stateRoot) {
+        this.root = join(stateRoot, 'task-memory');
+    }
+    async apply(input) {
+        const result = await this.stage(input, null);
+        return { directory: result.directory, applied: result.applied };
+    }
+    async stage(input, deliveryBase) {
+        assertSafeToPersist(JSON.parse(JSON.stringify({ input, deliveryBase })));
+        const directory = this.taskDirectory(input.projectId, input.taskSlug);
+        return await this.exclusive(directory, async () => {
+            await ensureManagedDirectory(this.root, this.eventsDirectory(directory));
+            const eventPath = this.eventPath(directory, input.eventId);
+            const existingRecord = await readJson(eventPath, this.root);
+            let record = existingRecord;
+            let applied = false;
+            if (record) {
+                this.assertSameEvent(record, input, deliveryBase);
+            }
+            else {
+                record = {
+                    schemaVersion: 1,
+                    input,
+                    deliveryBase,
+                    delivery: null,
+                    deliveryStatus: deliveryBase ? 'pending' : 'local_only',
+                    synchronizedAt: null,
+                    lastDeliveryError: null,
+                };
+                await writeJson(eventPath, record, this.root);
+                applied = true;
+            }
+            await this.recoverDirectory(directory, input);
+            record =
+                (await readJson(eventPath, this.root)) ??
+                    this.missingEventRecord(input.eventId);
+            return {
+                directory,
+                applied,
+                delivery: record.delivery
+                    ? this.pendingDelivery(record, input.projectId, input.taskSlug)
+                    : null,
+            };
+        });
+    }
+    async load(projectId, taskSlug) {
+        const directory = this.taskDirectory(projectId, taskSlug);
+        return await this.exclusive(directory, async () => {
+            const projection = await this.recoverDirectory(directory);
+            const records = await this.readEventRecords(directory);
+            return {
+                directory,
+                projection,
+                pendingDeliveryCount: records.filter((record) => record.deliveryBase && record.deliveryStatus === 'pending').length,
+            };
+        });
+    }
+    async readDocuments(projectId, taskSlug) {
+        const directory = this.taskDirectory(projectId, taskSlug);
+        return await this.exclusive(directory, async () => {
+            const projection = await this.recoverDirectory(directory);
+            if (!projection) {
+                throw new Error('Task journal does not exist');
+            }
+            return this.renderDocuments(projection);
+        });
+    }
+    async canonicalResumeState(projectId, taskSlug) {
+        const directory = this.taskDirectory(projectId, taskSlug);
+        return await this.exclusive(directory, async () => {
+            const projection = await this.recoverDirectory(directory);
+            if (!projection) {
+                throw new Error('Task journal does not exist');
+            }
+            const documents = this.renderDocuments(projection);
+            return {
+                events: projection.appliedEventIds.map((idempotencyKey, index) => ({
+                    sequence: index + 1,
+                    idempotencyKey,
+                })),
+                documents: Object.entries(documents).map(([documentType, content]) => ({
+                    documentType,
+                    content,
+                    contentHash: sha256(content),
+                })),
+            };
+        });
+    }
+    async assertEventContent(input) {
+        const directory = this.taskDirectory(input.projectId, input.taskSlug);
+        return await this.exclusive(directory, async () => {
+            const record = await readJson(this.eventPath(directory, input.eventId), this.root);
+            if (!record) {
+                return false;
+            }
+            const storedInput = { ...record.input, createdAt: null };
+            const receivedInput = { ...input, createdAt: null };
+            if (stableStringify(storedInput) !== stableStringify(receivedInput)) {
+                throw new Error('Journal idempotency key was reused with different content');
+            }
+            return true;
+        });
+    }
+    async hydrateFromBackend(input) {
+        const directory = this.taskDirectory(input.projectId, input.taskSlug);
+        return await this.exclusive(directory, async () => {
+            const current = await this.recoverDirectory(directory);
+            const records = await this.readEventRecords(directory);
+            const events = input.events
+                .map(backendEvent)
+                .sort((left, right) => left.sequence - right.sequence);
+            if (events.length !== input.lastSequence ||
+                events.some((event, index) => event.sequence !== index + 1)) {
+                throw new Error('Backend journal event sequence is incomplete');
+            }
+            const documents = backendDocuments(input.documents);
+            const state = parseStateDocument(documents.state);
+            if (state.projectId !== input.projectId ||
+                state.taskId !== input.taskId ||
+                state.taskSlug !== input.taskSlug) {
+                throw new Error('Backend journal documents do not match the active task identity');
+            }
+            const eventIds = events.map((event) => event.idempotencyKey);
+            const baseline = {
+                schemaVersion: state.schemaVersion,
+                projectId: input.projectId,
+                taskId: input.taskId,
+                taskSlug: input.taskSlug,
+                appliedEventIds: eventIds,
+                state: state.state,
+                decisions: parseLineDocument(documents.decisions, eventIds, state.schemaVersion),
+                discovery: parseLineDocument(documents.discovery, eventIds, state.schemaVersion),
+                validation: parseLineDocument(documents.validation, eventIds, state.schemaVersion),
+                handoff: parseHandoffDocument(documents.handoff, state.schemaVersion),
+                lastCheckpoint: state.lastCheckpoint,
+            };
+            assertSafeToPersist(JSON.parse(JSON.stringify(baseline)));
+            const rendered = this.renderDocuments(baseline);
+            for (const [type, content] of Object.entries(documents)) {
+                if (rendered[type] !== content) {
+                    throw new Error(`Backend ${type} document is not a canonical journal projection`);
+                }
+            }
+            const backendIds = new Set(eventIds);
+            const recordById = new Map(records.map((record) => [record.input.eventId, record]));
+            const pendingRecords = records
+                .filter((record) => record.deliveryStatus === 'pending' && !backendIds.has(record.input.eventId))
+                .sort((left, right) => (left.deliveryBase?.expectedTaskVersion ?? 0) -
+                (right.deliveryBase?.expectedTaskVersion ?? 0));
+            const pendingIds = new Set(pendingRecords.map((record) => record.input.eventId));
+            const unmatchedLocalIds = (current?.appliedEventIds ?? []).filter((eventId) => !backendIds.has(eventId) && !pendingIds.has(eventId));
+            if (unmatchedLocalIds.length > 0) {
+                throw new Error('Local journal history diverges from the authoritative backend baseline');
+            }
+            const synchronizedEventIds = [];
+            for (const eventId of eventIds) {
+                const record = recordById.get(eventId);
+                if (record?.deliveryBase && record.deliveryStatus === 'pending') {
+                    const updated = {
+                        ...record,
+                        deliveryStatus: 'synchronized',
+                        synchronizedAt: new Date().toISOString(),
+                        lastDeliveryError: null,
+                    };
+                    await writeJson(this.eventPath(directory, eventId), updated, this.root);
+                    synchronizedEventIds.push(eventId);
+                }
+            }
+            await ensureManagedDirectory(this.root, this.eventsDirectory(directory));
+            await writeJson(join(directory, '.backend-baseline.json'), baseline, this.root);
+            let projection = baseline;
+            const pendingDeliveries = [];
+            const blockedEventIds = [];
+            for (const [index, record] of pendingRecords.entries()) {
+                if (!record.deliveryBase) {
+                    throw new Error('Pending journal delta is missing its delivery contract');
+                }
+                projection = this.project(projection, record.input);
+                if (requiresExplicitResolution(record.lastDeliveryError)) {
+                    blockedEventIds.push(record.input.eventId);
+                    pendingDeliveries.push(this.pendingDelivery(record, input.projectId, input.taskSlug));
+                    continue;
+                }
+                const expectedTaskVersion = input.taskVersion + index;
+                const deliveryBase = { ...record.deliveryBase, expectedTaskVersion };
+                const updated = {
+                    ...record,
+                    deliveryBase,
+                    delivery: {
+                        ...deliveryBase,
+                        body: this.deliveryBody(record.input, deliveryBase, this.renderDocuments(projection)),
+                    },
+                    lastDeliveryError: null,
+                };
+                await writeJson(this.eventPath(directory, record.input.eventId), updated, this.root);
+                pendingDeliveries.push(this.pendingDelivery(updated, input.projectId, input.taskSlug));
+            }
+            await writeJson(join(directory, '.projection.json'), projection, this.root);
+            await this.writeDocuments(directory, projection);
+            return { synchronizedEventIds, pendingDeliveries, blockedEventIds };
+        });
+    }
+    async listPendingDeliveries(projectId, taskSlug) {
+        await ensureManagedDirectory(this.root, this.root);
+        const directories = await this.taskDirectories(projectId, taskSlug);
+        const pending = [];
+        for (const directory of directories) {
+            await this.exclusive(directory.path, async () => {
+                await this.recoverDirectory(directory.path);
+                const records = await this.readEventRecords(directory.path);
+                for (const record of records) {
+                    if (record.delivery && record.deliveryStatus === 'pending') {
+                        pending.push(this.pendingDelivery(record, directory.projectId, directory.taskSlug));
+                    }
+                }
+            });
+        }
+        return pending.sort((left, right) => left.eventId.localeCompare(right.eventId));
+    }
+    async markDeliverySynchronized(projectId, taskSlug, eventId) {
+        await this.updateDelivery(projectId, taskSlug, eventId, (record) => ({
+            ...record,
+            deliveryStatus: 'synchronized',
+            synchronizedAt: new Date().toISOString(),
+            lastDeliveryError: null,
+        }));
+    }
+    async markDeliveryAttempt(projectId, taskSlug, eventId, errorKind) {
+        await this.updateDelivery(projectId, taskSlug, eventId, (record) => ({
+            ...record,
+            lastDeliveryError: safeErrorKind(errorKind),
+        }));
+    }
+    async rebaseDelivery(projectId, taskSlug, eventId, expectedTaskVersion) {
+        if (!Number.isInteger(expectedTaskVersion) || expectedTaskVersion < 1) {
+            throw new Error('Rebased task version must be a positive integer');
+        }
+        const directory = this.taskDirectory(projectId, taskSlug);
+        return await this.exclusive(directory, async () => {
+            const path = this.eventPath(directory, eventId);
+            const record = await readJson(path, this.root);
+            if (!record?.deliveryBase || !record.delivery || record.deliveryStatus !== 'pending') {
+                throw new Error('Pending journal delivery could not be rebased');
+            }
+            const records = await this.readEventRecords(directory);
+            const targetIndex = records.findIndex((value) => value.input.eventId === eventId);
+            if (records
+                .slice(0, targetIndex)
+                .some((value) => value.deliveryStatus === 'pending' && value.deliveryBase)) {
+                throw new Error('Earlier pending journal deliveries must be resolved first');
+            }
+            const deliveryBase = { ...record.deliveryBase, expectedTaskVersion };
+            const projection = await this.projectionThroughEvent(directory, records, eventId);
+            const body = this.deliveryBody(record.input, deliveryBase, this.renderDocuments(projection));
+            const updated = {
+                ...record,
+                deliveryBase,
+                delivery: { ...record.delivery, expectedTaskVersion, body },
+                lastDeliveryError: null,
+            };
+            await writeJson(path, updated, this.root);
+            return this.pendingDelivery(updated, projectId, taskSlug);
+        });
+    }
+    async discardDelivery(projectId, taskSlug, eventId) {
+        const directory = this.taskDirectory(projectId, taskSlug);
+        await this.exclusive(directory, async () => {
+            const path = this.eventPath(directory, eventId);
+            const record = await readJson(path, this.root);
+            if (!record?.deliveryBase || record.deliveryStatus !== 'pending') {
+                throw new Error('Pending journal delivery could not be discarded');
+            }
+            await writeJson(path, {
+                ...record,
+                deliveryStatus: 'discarded',
+                lastDeliveryError: null,
+            }, this.root);
+            await this.recoverDirectory(directory, undefined, true);
+        });
+    }
+    async updateDelivery(projectId, taskSlug, eventId, update) {
+        const directory = this.taskDirectory(projectId, taskSlug);
+        await this.exclusive(directory, async () => {
+            const path = this.eventPath(directory, eventId);
+            const record = await readJson(path, this.root);
+            if (!record || !record.deliveryBase) {
+                throw new Error('Pending journal delivery could not be found');
+            }
+            await writeJson(path, update(record), this.root);
+        });
+    }
+    async recoverDirectory(directory, identity, rebuild = false) {
+        const statePath = join(directory, '.projection.json');
+        const baseline = await readJson(join(directory, '.backend-baseline.json'), this.root);
+        let projection = await readJson(statePath, this.root);
+        const records = await this.readEventRecords(directory);
+        if (!projection && !baseline && records.length === 0) {
+            return null;
+        }
+        if (rebuild) {
+            const persistedIds = new Set(projection?.appliedEventIds ?? []);
+            const eventIds = new Set(records.map((record) => record.input.eventId));
+            const baselineIds = new Set(baseline?.appliedEventIds ?? []);
+            if ([...persistedIds].some((eventId) => !eventIds.has(eventId) && !baselineIds.has(eventId))) {
+                throw new Error('Legacy journal projection cannot discard an event automatically');
+            }
+            projection = baseline ?? this.emptyProjection(identity ?? records[0].input);
+        }
+        else {
+            projection ??= baseline ?? this.emptyProjection(identity ?? records[0].input);
+        }
+        for (const record of records) {
+            if (record.deliveryStatus === 'discarded') {
+                continue;
+            }
+            if (projection.taskId !== record.input.taskId ||
+                projection.projectId !== record.input.projectId ||
+                projection.taskSlug !== record.input.taskSlug) {
+                throw new Error('Task journal identity does not match its event log');
+            }
+            if (!projection.appliedEventIds.includes(record.input.eventId)) {
+                projection = this.project(projection, record.input);
+            }
+            if (rebuild && record.deliveryBase && record.deliveryStatus === 'pending') {
+                const updated = {
+                    ...record,
+                    delivery: {
+                        ...record.deliveryBase,
+                        body: this.deliveryBody(record.input, record.deliveryBase, this.renderDocuments(projection)),
+                    },
+                };
+                await writeJson(this.eventPath(directory, record.input.eventId), updated, this.root);
+            }
+        }
+        await writeJson(statePath, projection, this.root);
+        await this.writeDocuments(directory, projection);
+        const documents = this.renderDocuments(projection);
+        for (const record of records) {
+            if (!rebuild && record.deliveryBase && !record.delivery) {
+                const updated = {
+                    ...record,
+                    delivery: {
+                        ...record.deliveryBase,
+                        body: this.deliveryBody(record.input, record.deliveryBase, documents),
+                    },
+                };
+                await writeJson(this.eventPath(directory, record.input.eventId), updated, this.root);
+            }
+        }
+        return projection;
+    }
+    async projectionThroughEvent(directory, records, eventId) {
+        const baseline = await readJson(join(directory, '.backend-baseline.json'), this.root);
+        const identity = records[0]?.input;
+        if (!baseline && !identity) {
+            throw new Error('Task journal cannot reconstruct the delivery projection');
+        }
+        let projection = baseline ?? this.emptyProjection(identity);
+        for (const record of records) {
+            if (record.deliveryStatus === 'discarded') {
+                continue;
+            }
+            if (!projection.appliedEventIds.includes(record.input.eventId)) {
+                projection = this.project(projection, record.input);
+            }
+            if (record.input.eventId === eventId) {
+                return projection;
+            }
+        }
+        throw new Error('Task journal cannot find the rebased delivery event');
+    }
+    deliveryBody(input, delivery, documents) {
+        return JSON.parse(JSON.stringify({
+            taskId: input.taskId,
+            idempotencyKey: input.eventId,
+            expectedTaskVersion: delivery.expectedTaskVersion,
+            ...(delivery.correction
+                ? {}
+                : { eventType: 'checkpoint', checkpointType: input.checkpointType }),
+            payload: {
+                summary: input.summary,
+                ...(input.details !== undefined ? { details: input.details } : {}),
+                createdAt: input.createdAt,
+            },
+            documents,
+        }));
+    }
+    async readEventRecords(directory) {
+        const eventDirectory = this.eventsDirectory(directory);
+        try {
+            await assertManagedPath(this.root, eventDirectory, false);
+        }
+        catch (error) {
+            if (isMissing(error)) {
+                return [];
+            }
+            throw error;
+        }
+        const entries = await readdir(eventDirectory, { withFileTypes: true });
+        const files = entries.filter((entry) => entry.name.endsWith('.json'));
+        for (const entry of files) {
+            if (!entry.isFile() || entry.isSymbolicLink()) {
+                throw new Error(`Unsafe journal event entry: ${entry.name}`);
+            }
+        }
+        const records = await Promise.all(files.map(async (entry) => {
+            const path = await assertManagedPath(this.root, join(eventDirectory, entry.name), false);
+            return await readJson(path, this.root);
+        }));
+        return records
+            .filter((record) => record !== null)
+            .sort((left, right) => left.input.createdAt === right.input.createdAt
+            ? left.input.eventId.localeCompare(right.input.eventId)
+            : left.input.createdAt.localeCompare(right.input.createdAt));
+    }
+    async taskDirectories(projectId, taskSlug) {
+        const projectNames = projectId
+            ? [safeSegment(projectId)]
+            : await this.directoryNames(this.root, 'project');
+        const directories = [];
+        for (const projectName of projectNames) {
+            const projectDirectory = join(this.root, projectName);
+            try {
+                await assertManagedPath(this.root, projectDirectory, false);
+            }
+            catch (error) {
+                if (isMissing(error) && projectId) {
+                    continue;
+                }
+                throw error;
+            }
+            const taskNames = taskSlug
+                ? [safeSegment(taskSlug)]
+                : await this.directoryNames(projectDirectory, 'task');
+            for (const taskName of taskNames) {
+                const path = join(projectDirectory, taskName);
+                try {
+                    await assertManagedPath(this.root, path, false);
+                }
+                catch (error) {
+                    if (isMissing(error) && taskSlug) {
+                        continue;
+                    }
+                    throw error;
+                }
+                directories.push({ path, projectId: projectName, taskSlug: taskName });
+            }
+        }
+        return directories;
+    }
+    async directoryNames(directory, label) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const names = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            if (!entry.isDirectory() || entry.isSymbolicLink()) {
+                throw new Error(`Unsafe ${label} journal directory: ${entry.name}`);
+            }
+            names.push(entry.name);
+        }
+        return names.sort();
+    }
+    emptyProjection(input) {
+        return {
+            schemaVersion: canonicalJournalSchemaVersion,
+            projectId: input.projectId,
+            taskId: input.taskId,
+            taskSlug: input.taskSlug,
+            appliedEventIds: [],
+            state: {},
+            decisions: [],
+            discovery: [],
+            validation: [],
+            handoff: {},
+            lastCheckpoint: null,
+        };
+    }
+    project(current, input) {
+        const line = {
+            eventId: input.eventId,
+            createdAt: input.createdAt,
+            checkpointType: input.checkpointType,
+            summary: input.summary,
+            ...(input.details !== undefined ? { details: input.details } : {}),
+        };
+        const entry = {
+            eventId: input.eventId,
+            createdAt: input.createdAt,
+            checkpointType: input.checkpointType,
+            summary: input.summary,
+        };
+        const documents = input.documents ?? {};
+        const decisions = [
+            ...current.decisions,
+            ...(documents.decisions ?? []).map((summary) => ({ ...entry, summary })),
+        ];
+        const discovery = [
+            ...current.discovery,
+            ...(documents.discovery ?? []).map((summary) => ({ ...entry, summary })),
+        ];
+        const validation = [
+            ...current.validation,
+            ...(documents.validation ?? []).map((summary) => ({ ...entry, summary })),
+        ];
+        return {
+            ...current,
+            schemaVersion: canonicalJournalSchemaVersion,
+            appliedEventIds: [...current.appliedEventIds, input.eventId],
+            state: mergeState(current.state, documents.state),
+            decisions: uniqueLines(decisions),
+            discovery: uniqueLines(discovery),
+            validation: uniqueLines(validation),
+            handoff: mergeHandoff(current.handoff, documents.handoff),
+            lastCheckpoint: line,
+        };
+    }
+    async writeDocuments(directory, projection) {
+        const documents = this.renderDocuments(projection);
+        await Promise.all(Object.entries(documents).map(async ([name, content]) => {
+            const fileName = `${name.toUpperCase()}.md`;
+            await atomicWrite(join(directory, fileName), content, this.root);
+        }));
+    }
+    renderDocuments(projection) {
+        const lineRenderer = projection.schemaVersion === 1
+            ? renderLegacyLines
+            : projection.schemaVersion === 2
+                ? renderLinesV2
+                : renderLines;
+        return {
+            state: renderState(projection),
+            decisions: lineRenderer('Decisions', projection.decisions),
+            discovery: lineRenderer('Discovery', projection.discovery),
+            validation: lineRenderer('Validation', projection.validation),
+            handoff: renderHandoff(projection),
+        };
+    }
+    assertSameEvent(record, input, deliveryBase) {
+        const storedInput = { ...record.input, createdAt: null };
+        const receivedInput = { ...input, createdAt: null };
+        if (stableStringify(storedInput) !== stableStringify(receivedInput) ||
+            stableStringify(record.deliveryBase) !== stableStringify(deliveryBase)) {
+            throw new Error('Journal idempotency key was reused with different content');
+        }
+    }
+    pendingDelivery(record, projectId, taskSlug) {
+        if (!record.delivery) {
+            throw new Error('Journal delivery has not been materialized');
+        }
+        return {
+            projectId,
+            taskSlug,
+            eventId: record.input.eventId,
+            operation: record.delivery.operation,
+            method: record.delivery.method,
+            path: record.delivery.path,
+            body: record.delivery.body,
+            idempotencyKey: record.input.eventId,
+        };
+    }
+    missingEventRecord(eventId) {
+        throw new Error(`Journal event disappeared during projection: ${eventId}`);
+    }
+    eventPath(directory, eventId) {
+        return join(this.eventsDirectory(directory), `${safeSegment(eventId)}.json`);
+    }
+    eventsDirectory(directory) {
+        return join(directory, '.events');
+    }
+    taskDirectory(projectId, taskSlug) {
+        return ensureWithinRoot(this.root, join(this.root, safeSegment(projectId), safeSegment(taskSlug)));
+    }
+    async exclusive(key, action) {
+        const previous = this.queues.get(key) ?? Promise.resolve();
+        let release = () => undefined;
+        const current = new Promise((resolvePromise) => {
+            release = resolvePromise;
+        });
+        const tail = previous.then(() => current);
+        this.queues.set(key, tail);
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+            if (this.queues.get(key) === tail) {
+                this.queues.delete(key);
+            }
+        }
+    }
+}
+function mergeState(current, update) {
+    if (!update) {
+        return current;
+    }
+    return {
+        ...current,
+        ...update,
+        completed: uniqueStrings([...(current.completed ?? []), ...(update.completed ?? [])]),
+        blockers: update.blockers ?? current.blockers,
+        forbiddenActions: uniqueStrings([
+            ...(current.forbiddenActions ?? []),
+            ...(update.forbiddenActions ?? []),
+        ]),
+    };
+}
+function mergeHandoff(current, update) {
+    if (!update) {
+        return current;
+    }
+    return {
+        ...current,
+        ...update,
+        completed: uniqueStrings([...(current.completed ?? []), ...(update.completed ?? [])]),
+    };
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function uniqueLines(lines) {
+    const seen = new Set();
+    return lines.filter((line) => {
+        const key = `${line.eventId}:${line.summary}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function renderState(projection) {
+    if (projection.schemaVersion === 1) {
+        return renderLegacyState(projection);
+    }
+    if (projection.schemaVersion === 2) {
+        return renderStateV2(projection);
+    }
+    assertCanonicalJournalSchema(projection.schemaVersion);
+    const state = projection.state;
+    const last = projection.lastCheckpoint;
+    return [
+        '# Task State',
+        '',
+        `- Format: ${canonicalJournalSchemaVersion}`,
+        `- Task: ${encodeJournalText(projection.taskSlug)}`,
+        `- Task ID: ${encodeJournalText(projection.taskId)}`,
+        `- Project ID: ${encodeJournalText(projection.projectId)}`,
+        `- Objective: ${encodeOptionalJournalText(state.objective)}`,
+        `- Active phase: ${encodeOptionalJournalText(state.phase)}`,
+        `- Next action: ${encodeOptionalJournalText(state.nextAction)}`,
+        '',
+        '## Completed',
+        '',
+        renderTextList(state.completed),
+        '',
+        '## Blockers',
+        '',
+        renderTextList(state.blockers),
+        '',
+        '## Forbidden Actions',
+        '',
+        renderTextList(state.forbiddenActions),
+        '',
+        '## Last Checkpoint',
+        '',
+        ...(last ? renderJournalEntry(last, true) : [`- ${absentJournalToken}`]),
+        '',
+    ].join('\n');
+}
+function renderStateV2(projection) {
+    const state = projection.state;
+    const last = projection.lastCheckpoint;
+    return [
+        '# Task State',
+        '',
+        '- Format: 2',
+        `- Task: ${stableStringify(projection.taskSlug)}`,
+        `- Task ID: ${stableStringify(projection.taskId)}`,
+        `- Project ID: ${stableStringify(projection.projectId)}`,
+        `- Objective: ${stableStringify(state.objective ?? null)}`,
+        `- Active phase: ${stableStringify(state.phase ?? null)}`,
+        `- Next action: ${stableStringify(state.nextAction ?? null)}`,
+        '',
+        '## Completed',
+        '',
+        renderCanonicalList(state.completed),
+        '',
+        '## Blockers',
+        '',
+        renderCanonicalList(state.blockers),
+        '',
+        '## Forbidden Actions',
+        '',
+        renderCanonicalList(state.forbiddenActions),
+        '',
+        '## Last Checkpoint',
+        '',
+        `- ${stableStringify(last ? journalLineValue(last) : null)}`,
+        '',
+    ].join('\n');
+}
+function renderLines(title, lines) {
+    const values = lines.length
+        ? lines.flatMap((line) => renderJournalEntry(line))
+        : [`- ${absentJournalToken}`];
+    return [`# ${title}`, '', ...values, ''].join('\n');
+}
+function renderLinesV2(title, lines) {
+    const values = lines.length
+        ? lines.map((line) => `- ${stableStringify(journalLineValue(line))}`)
+        : ['- null'];
+    return [`# ${title}`, '', ...values, ''].join('\n');
+}
+function renderHandoff(projection) {
+    if (projection.schemaVersion === 1) {
+        return renderLegacyHandoff(projection);
+    }
+    if (projection.schemaVersion === 2) {
+        return renderHandoffV2(projection);
+    }
+    assertCanonicalJournalSchema(projection.schemaVersion);
+    return [
+        '# Handoff',
+        '',
+        '## Completed',
+        '',
+        renderTextList(projection.handoff.completed),
+        '',
+        '## Remaining',
+        '',
+        renderTextList(projection.handoff.remaining),
+        '',
+        '## Restart From',
+        '',
+        `- ${encodeOptionalJournalText(projection.handoff.restartFrom ?? projection.state.nextAction)}`,
+        '',
+    ].join('\n');
+}
+function renderHandoffV2(projection) {
+    return [
+        '# Handoff',
+        '',
+        '## Completed',
+        '',
+        renderCanonicalList(projection.handoff.completed),
+        '',
+        '## Remaining',
+        '',
+        renderCanonicalList(projection.handoff.remaining),
+        '',
+        '## Restart From',
+        '',
+        stableStringify(projection.handoff.restartFrom ?? projection.state.nextAction ?? null),
+        '',
+    ].join('\n');
+}
+function renderLegacyState(projection) {
+    const state = projection.state;
+    const last = projection.lastCheckpoint;
+    return [
+        '# Task State',
+        '',
+        `- Task: ${projection.taskSlug}`,
+        `- Task ID: ${projection.taskId}`,
+        `- Project ID: ${projection.projectId}`,
+        `- Objective: ${state.objective ?? 'Not recorded'}`,
+        `- Active phase: ${state.phase ?? 'Not recorded'}`,
+        `- Next action: ${state.nextAction ?? 'Not recorded'}`,
+        '',
+        '## Completed',
+        '',
+        renderLegacyBullets(state.completed),
+        '',
+        '## Blockers',
+        '',
+        renderLegacyBullets(state.blockers),
+        '',
+        '## Forbidden Actions',
+        '',
+        renderLegacyBullets(state.forbiddenActions),
+        '',
+        '## Last Checkpoint',
+        '',
+        last ? `- ${last.createdAt} | ${last.checkpointType} | ${last.summary}` : '- Not recorded',
+        '',
+    ].join('\n');
+}
+function renderLegacyLines(title, lines) {
+    return [
+        `# ${title}`,
+        '',
+        ...(lines.length === 0
+            ? ['- Not recorded']
+            : lines.map((line) => `- ${line.createdAt} | ${line.checkpointType} | ${line.summary}${line.details ? ` — ${line.details}` : ''}`)),
+        '',
+    ].join('\n');
+}
+function renderLegacyHandoff(projection) {
+    return [
+        '# Handoff',
+        '',
+        '## Completed',
+        '',
+        renderLegacyBullets(projection.handoff.completed),
+        '',
+        '## Remaining',
+        '',
+        renderLegacyBullets(projection.handoff.remaining),
+        '',
+        '## Restart From',
+        '',
+        projection.handoff.restartFrom ?? projection.state.nextAction ?? 'Not recorded',
+        '',
+    ].join('\n');
+}
+function journalLineValue(line) {
+    return {
+        checkpointType: line.checkpointType,
+        createdAt: line.createdAt,
+        ...(line.details !== undefined ? { details: line.details } : {}),
+        summary: line.summary,
+    };
+}
+function renderCanonicalList(values) {
+    return `- ${stableStringify(values ?? [])}`;
+}
+function encodeJournalText(value) {
+    if (value === '') {
+        return emptyJournalToken;
+    }
+    const escaped = value.replace(/\\/g, '\\\\').replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+    return escaped === absentJournalToken || escaped === emptyJournalToken ? `\\${escaped}` : escaped;
+}
+function encodeOptionalJournalText(value) {
+    return value === undefined ? absentJournalToken : encodeJournalText(value);
+}
+function decodeJournalText(value, label) {
+    if (value === emptyJournalToken) {
+        return '';
+    }
+    const source = value === `\\${absentJournalToken}` || value === `\\${emptyJournalToken}`
+        ? value.slice(1)
+        : value;
+    let result = '';
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (character !== '\\') {
+            result += character;
+            continue;
+        }
+        const escape = source[index + 1];
+        if (escape === '\\') {
+            result += '\\';
+        }
+        else if (escape === 'r') {
+            result += '\r';
+        }
+        else if (escape === 'n') {
+            result += '\n';
+        }
+        else {
+            throw new Error(`Backend journal ${label} is not canonical`);
+        }
+        index += 1;
+    }
+    return result;
+}
+function decodeOptionalJournalText(value, label) {
+    return value === absentJournalToken ? undefined : decodeJournalText(value, label);
+}
+function renderTextList(values) {
+    return values?.length
+        ? values.map((value) => `- ${encodeJournalText(value)}`).join('\n')
+        : `- ${absentJournalToken}`;
+}
+function renderJournalEntry(line, includeDetails = false) {
+    const entry = `- ${line.createdAt}${journalTypeSeparator}${line.checkpointType}${journalTextSeparator}${encodeJournalText(line.summary)}`;
+    return includeDetails && line.details !== undefined
+        ? [entry, `${journalDetailsPrefix}${encodeJournalText(line.details)}`]
+        : [entry];
+}
+function renderLegacyBullets(values) {
+    return values?.length ? values.map((value) => `- ${value}`).join('\n') : '- None';
+}
+function backendEvent(value) {
+    const event = objectBody(value);
+    const sequence = Number(event.sequence);
+    if (!Number.isSafeInteger(sequence) ||
+        sequence < 1 ||
+        typeof event.idempotencyKey !== 'string' ||
+        !event.idempotencyKey) {
+        throw new Error('Backend journal event identity is invalid');
+    }
+    return { sequence, idempotencyKey: event.idempotencyKey };
+}
+function backendDocuments(values) {
+    const documents = {};
+    for (const value of values) {
+        const document = objectBody(value);
+        if (typeof document.documentType !== 'string' ||
+            typeof document.content !== 'string' ||
+            typeof document.contentHash !== 'string' ||
+            sha256(document.content) !== document.contentHash) {
+            throw new Error('Backend journal document integrity is invalid');
+        }
+        if (documents[document.documentType] !== undefined) {
+            throw new Error('Backend journal contains a duplicate document type');
+        }
+        documents[document.documentType] = document.content;
+    }
+    const required = ['state', 'decisions', 'discovery', 'validation', 'handoff'];
+    if (required.some((type) => documents[type] === undefined)) {
+        throw new Error('Backend journal does not contain all canonical documents');
+    }
+    return {
+        state: documents.state,
+        decisions: documents.decisions,
+        discovery: documents.discovery,
+        validation: documents.validation,
+        handoff: documents.handoff,
+    };
+}
+function parseStateDocument(content) {
+    const format = optionalLineValue(content, '- Format: ');
+    if (format === undefined) {
+        return parseLegacyStateDocument(content);
+    }
+    const schemaVersion = parseCanonicalJson(format, 'journal format');
+    if (typeof schemaVersion !== 'number' || !supportedJournalSchemaVersions.has(schemaVersion)) {
+        throw new Error('Backend journal format is unsupported');
+    }
+    if (schemaVersion === canonicalJournalSchemaVersion) {
+        return parseStateDocumentV3(content);
+    }
+    const taskSlug = parseCanonicalString(lineValue(content, '- Task: '), 'task slug');
+    const taskId = parseCanonicalString(lineValue(content, '- Task ID: '), 'task id');
+    const projectId = parseCanonicalString(lineValue(content, '- Project ID: '), 'project id');
+    const objective = parseCanonicalOptionalString(lineValue(content, '- Objective: '), 'objective');
+    const phase = parseCanonicalOptionalString(lineValue(content, '- Active phase: '), 'active phase');
+    const nextAction = parseCanonicalOptionalString(lineValue(content, '- Next action: '), 'next action');
+    const lastValue = singleSectionValue(content, '## Last Checkpoint', null, true);
+    return {
+        schemaVersion,
+        projectId,
+        taskId,
+        taskSlug,
+        state: {
+            ...(objective !== undefined ? { objective } : {}),
+            ...(phase !== undefined ? { phase } : {}),
+            ...(nextAction !== undefined ? { nextAction } : {}),
+            completed: parseCanonicalList(content, '## Completed', '## Blockers'),
+            blockers: parseCanonicalList(content, '## Blockers', '## Forbidden Actions'),
+            forbiddenActions: parseCanonicalList(content, '## Forbidden Actions', '## Last Checkpoint'),
+        },
+        lastCheckpoint: parseCanonicalJournalLine(lastValue, 'hydrated-last-checkpoint', true),
+    };
+}
+function parseStateDocumentV3(content) {
+    const objective = decodeOptionalJournalText(rawLineValue(content, '- Objective: '), 'objective');
+    const phase = decodeOptionalJournalText(rawLineValue(content, '- Active phase: '), 'phase');
+    const nextAction = decodeOptionalJournalText(rawLineValue(content, '- Next action: '), 'next action');
+    return {
+        schemaVersion: canonicalJournalSchemaVersion,
+        projectId: decodeJournalText(rawLineValue(content, '- Project ID: '), 'project id'),
+        taskId: decodeJournalText(rawLineValue(content, '- Task ID: '), 'task id'),
+        taskSlug: decodeJournalText(rawLineValue(content, '- Task: '), 'task slug'),
+        state: {
+            ...(objective !== undefined ? { objective } : {}),
+            ...(phase !== undefined ? { phase } : {}),
+            ...(nextAction !== undefined ? { nextAction } : {}),
+            completed: parseTextList(content, '## Completed', '## Blockers'),
+            blockers: parseTextList(content, '## Blockers', '## Forbidden Actions'),
+            forbiddenActions: parseTextList(content, '## Forbidden Actions', '## Last Checkpoint'),
+        },
+        lastCheckpoint: parseLastCheckpoint(content),
+    };
+}
+function parseLastCheckpoint(content) {
+    const lines = rawSectionLines(content, '## Last Checkpoint', null).filter(Boolean);
+    const entry = lines[0];
+    if (entry === undefined) {
+        throw new Error('Backend journal section is not canonical: ## Last Checkpoint');
+    }
+    if (entry === `- ${absentJournalToken}`) {
+        return null;
+    }
+    const line = parseJournalEntry(entry, 'hydrated-last-checkpoint');
+    const details = lines[1];
+    if (details === undefined) {
+        return line;
+    }
+    if (lines.length !== 2 || !details.startsWith(journalDetailsPrefix)) {
+        throw new Error('Backend journal section is not canonical: ## Last Checkpoint');
+    }
+    return {
+        ...line,
+        details: decodeJournalText(details.slice(journalDetailsPrefix.length), 'details'),
+    };
+}
+function parseJournalEntry(value, eventId) {
+    if (!value.startsWith('- ')) {
+        throw new Error('Backend journal line is not canonical');
+    }
+    const body = value.slice(2);
+    const typeIndex = body.indexOf(journalTypeSeparator);
+    if (typeIndex <= 0) {
+        throw new Error('Backend journal line is not canonical');
+    }
+    const remainder = body.slice(typeIndex + journalTypeSeparator.length);
+    const textIndex = remainder.indexOf(journalTextSeparator);
+    if (textIndex <= 0) {
+        throw new Error('Backend journal line is not canonical');
+    }
+    return {
+        eventId,
+        createdAt: body.slice(0, typeIndex),
+        checkpointType: remainder.slice(0, textIndex),
+        summary: decodeJournalText(remainder.slice(textIndex + journalTextSeparator.length), 'summary'),
+    };
+}
+function rawSectionLines(content, start, end) {
+    const lines = content.split('\n');
+    const startIndex = lines.indexOf(start);
+    if (startIndex < 0) {
+        throw new Error(`Backend journal section is missing: ${start}`);
+    }
+    const endIndex = end ? lines.indexOf(end, startIndex + 1) : lines.length;
+    if (end && endIndex < 0) {
+        throw new Error(`Backend journal section is missing: ${end}`);
+    }
+    return lines.slice(startIndex + 1, endIndex);
+}
+function rawLineValue(content, prefix) {
+    const line = content.split('\n').find((value) => value.startsWith(prefix));
+    if (line === undefined) {
+        throw new Error(`Backend journal field is missing: ${prefix}`);
+    }
+    return line.slice(prefix.length);
+}
+function parseTextList(content, start, end) {
+    const values = rawSectionLines(content, start, end)
+        .filter((line) => line.startsWith('- '))
+        .map((line) => line.slice(2));
+    if (values.length === 1 && values[0] === absentJournalToken) {
+        return [];
+    }
+    return values.map((value) => decodeJournalText(value, `${start} list`));
+}
+function parseLineDocument(content, eventIds, schemaVersion) {
+    if (schemaVersion === 1) {
+        return parseLegacyLineDocument(content, eventIds);
+    }
+    if (schemaVersion === canonicalJournalSchemaVersion) {
+        return parseLineDocumentV3(content, eventIds);
+    }
+    const lines = content
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('- '))
+        .map((line) => line.slice(2));
+    if (lines.length === 1 && lines[0] === 'null') {
+        return [];
+    }
+    return lines.map((line, index) => parseCanonicalJournalLine(line, eventIds[Math.min(index, eventIds.length - 1)] ?? `hydrated-${index + 1}`, false));
+}
+function parseLegacyStateDocument(content) {
+    const taskSlug = lineValue(content, '- Task: ');
+    const taskId = lineValue(content, '- Task ID: ');
+    const projectId = lineValue(content, '- Project ID: ');
+    const objective = optionalLegacyRecorded(lineValue(content, '- Objective: '));
+    const phase = optionalLegacyRecorded(lineValue(content, '- Active phase: '));
+    const nextAction = optionalLegacyRecorded(lineValue(content, '- Next action: '));
+    const lastLine = sectionLines(content, '## Last Checkpoint', null)[0];
+    return {
+        schemaVersion: 1,
+        projectId,
+        taskId,
+        taskSlug,
+        state: {
+            ...(objective ? { objective } : {}),
+            ...(phase ? { phase } : {}),
+            ...(nextAction ? { nextAction } : {}),
+            completed: sectionLegacyBullets(content, '## Completed', '## Blockers'),
+            blockers: sectionLegacyBullets(content, '## Blockers', '## Forbidden Actions'),
+            forbiddenActions: sectionLegacyBullets(content, '## Forbidden Actions', '## Last Checkpoint'),
+        },
+        lastCheckpoint: lastLine && lastLine !== '- Not recorded'
+            ? parseLegacyJournalLine(lastLine, 'hydrated-last-checkpoint')
+            : null,
+    };
+}
+function parseLegacyLineDocument(content, eventIds) {
+    const lines = content
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('- ') && line !== '- Not recorded');
+    return lines.map((line, index) => parseLegacyJournalLine(line, eventIds[Math.min(index, eventIds.length - 1)] ?? `hydrated-${index + 1}`));
+}
+function parseLegacyJournalLine(line, eventId) {
+    const match = /^- ([^|]+) \| ([^|]+) \| (.*)$/.exec(line);
+    if (!match) {
+        throw new Error('Backend journal line is not canonical');
+    }
+    const [summary, details] = match[3].split(' — ', 2);
+    return {
+        eventId,
+        createdAt: match[1].trim(),
+        checkpointType: match[2].trim(),
+        summary: summary.trim(),
+        ...(details ? { details: details.trim() } : {}),
+    };
+}
+function parseLineDocumentV3(content, eventIds) {
+    const values = content.split('\n').filter((line) => line.startsWith('- '));
+    if (values.length === 1 && values[0] === `- ${absentJournalToken}`) {
+        return [];
+    }
+    return values.map((value, index) => parseJournalEntry(value, eventIds[Math.min(index, eventIds.length - 1)] ?? `hydrated-${index + 1}`));
+}
+function parseHandoffDocument(content, schemaVersion) {
+    if (schemaVersion === 1) {
+        return parseLegacyHandoffDocument(content);
+    }
+    if (schemaVersion === canonicalJournalSchemaVersion) {
+        return parseHandoffDocumentV3(content);
+    }
+    const restartFrom = parseCanonicalOptionalString(singleSectionValue(content, '## Restart From', null, false), 'restart from');
+    return {
+        completed: parseCanonicalList(content, '## Completed', '## Remaining'),
+        remaining: parseCanonicalList(content, '## Remaining', '## Restart From'),
+        ...(restartFrom !== undefined ? { restartFrom } : {}),
+    };
+}
+function parseHandoffDocumentV3(content) {
+    const restart = rawSectionLines(content, '## Restart From', null).filter(Boolean);
+    const value = restart[0];
+    if (restart.length !== 1 || value === undefined || !value.startsWith('- ')) {
+        throw new Error('Backend journal section is not canonical: ## Restart From');
+    }
+    const restartFrom = decodeOptionalJournalText(value.slice(2), 'restart from');
+    return {
+        completed: parseTextList(content, '## Completed', '## Remaining'),
+        remaining: parseTextList(content, '## Remaining', '## Restart From'),
+        ...(restartFrom !== undefined ? { restartFrom } : {}),
+    };
+}
+function parseLegacyHandoffDocument(content) {
+    const restartFrom = sectionLines(content, '## Restart From', null)[0];
+    return {
+        completed: sectionLegacyBullets(content, '## Completed', '## Remaining'),
+        remaining: sectionLegacyBullets(content, '## Remaining', '## Restart From'),
+        ...(restartFrom && restartFrom !== 'Not recorded' ? { restartFrom } : {}),
+    };
+}
+function sectionLegacyBullets(content, start, end) {
+    return sectionLines(content, start, end)
+        .filter((line) => line.startsWith('- ') && line !== '- None')
+        .map((line) => line.slice(2));
+}
+function sectionLines(content, start, end) {
+    const lines = content.split(/\r?\n/);
+    const startIndex = lines.indexOf(start);
+    if (startIndex < 0) {
+        throw new Error(`Backend journal section is missing: ${start}`);
+    }
+    const endIndex = end ? lines.indexOf(end, startIndex + 1) : lines.length;
+    if (end && endIndex < 0) {
+        throw new Error(`Backend journal section is missing: ${end}`);
+    }
+    return lines
+        .slice(startIndex + 1, endIndex)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function lineValue(content, prefix) {
+    const line = content.split(/\r?\n/).find((value) => value.startsWith(prefix));
+    if (!line) {
+        throw new Error(`Backend journal field is missing: ${prefix}`);
+    }
+    return line.slice(prefix.length).trim();
+}
+function optionalLineValue(content, prefix) {
+    const line = content.split(/\r?\n/).find((value) => value.startsWith(prefix));
+    return line?.slice(prefix.length).trim();
+}
+function optionalLegacyRecorded(value) {
+    return value === 'Not recorded' ? undefined : value;
+}
+function parseCanonicalList(content, start, end) {
+    const value = singleSectionValue(content, start, end, true);
+    const parsed = parseCanonicalJson(value, `${start} list`);
+    if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== 'string')) {
+        throw new Error(`Backend journal ${start} list is not canonical`);
+    }
+    return [...parsed];
+}
+function singleSectionValue(content, start, end, bullet) {
+    const lines = sectionLines(content, start, end);
+    if (lines.length !== 1 || (bullet && !lines[0].startsWith('- '))) {
+        throw new Error(`Backend journal section is not canonical: ${start}`);
+    }
+    return bullet ? lines[0].slice(2) : lines[0];
+}
+function parseCanonicalJournalLine(value, eventId, nullable) {
+    const parsed = parseCanonicalJson(value, 'journal line');
+    if (nullable && parsed === null) {
+        return null;
+    }
+    if (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new Error('Backend journal line is not canonical');
+    }
+    const line = parsed;
+    if (typeof line.createdAt !== 'string' ||
+        typeof line.checkpointType !== 'string' ||
+        typeof line.summary !== 'string' ||
+        (Object.hasOwn(line, 'details') && typeof line.details !== 'string')) {
+        throw new Error('Backend journal line is not canonical');
+    }
+    return {
+        eventId,
+        createdAt: line.createdAt,
+        checkpointType: line.checkpointType,
+        summary: line.summary,
+        ...(Object.hasOwn(line, 'details') ? { details: line.details } : {}),
+    };
+}
+function parseCanonicalString(value, label) {
+    const parsed = parseCanonicalJson(value, label);
+    if (typeof parsed !== 'string') {
+        throw new Error(`Backend journal ${label} is not canonical`);
+    }
+    return parsed;
+}
+function parseCanonicalOptionalString(value, label) {
+    const parsed = parseCanonicalJson(value, label);
+    if (parsed === null) {
+        return undefined;
+    }
+    if (typeof parsed !== 'string') {
+        throw new Error(`Backend journal ${label} is not canonical`);
+    }
+    return parsed;
+}
+function parseCanonicalJson(value, label) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(`Backend journal ${label} is not canonical`);
+    }
+}
+function assertCanonicalJournalSchema(schemaVersion) {
+    if (schemaVersion !== canonicalJournalSchemaVersion) {
+        throw new Error('Journal projection format is unsupported');
+    }
+}
+function safeErrorKind(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '_')
+        .slice(0, 80);
+    return normalized || 'unknown_error';
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+function objectBody(value) {
+    if (value === null || Array.isArray(value) || typeof value !== 'object') {
+        throw new Error('Pending journal delivery body is invalid');
+    }
+    return { ...value };
+}
+function requiresExplicitResolution(errorKind) {
+    if (!errorKind || errorKind === 'backend_unavailable') {
+        return false;
+    }
+    const status = /^api_(\d{3})_/.exec(errorKind)?.[1];
+    if (!status) {
+        return true;
+    }
+    const value = Number(status);
+    return value >= 400 && value < 500 && value !== 408 && value !== 429;
+}
+//# sourceMappingURL=journal-store.js.map