@ornexus/neocortex 4.60.71 → 4.60.73

package/packages/client/dist/migrations/epic-lifecycle-backfill.js

@@ -0,0 +1,1060 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, writeFileSync, } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { inspectEpicOperationalSqliteBinding, } from '../continuity/sqlite-store.js';
+import { GIT_LIFECYCLE_RUNTIME_DIRECTORY, GIT_LIFECYCLE_RUNTIME_FILE, mutateGitLifecycleRuntime, readGitLifecycleRuntimeSync, } from '../git/git-lifecycle-store.js';
+import { EPIC_OPERATIONAL_PAYLOAD_LIMIT_BYTES, EPIC_OPERATIONAL_RECEIPT_CAP, assertEpicOperationalState, createEpicOperationalIdentity, createInitialEpicOperationalState, epicOperationalCanonicalJson, epicOperationalHash, mutateEpicOperationalState, readEpicOperationalState, } from '../git/epic-operational-state.js';
+import { createDefaultCounters } from '../yoloop/yoloop-client-state-store.js';
+import { applyStateMigration, previewStateMigration, readStateMigrationSourceSnapshot, restoreStateMigrationPreimage, STATE_MIGRATION_INPUT_LIMIT_BYTES, } from './state-json.js';
+const CHECKOUT_CAP = 32;
+const PUBLIC_PATH_LIMIT = 1_024;
+const HASH = /^[a-f0-9]{64}$/;
+const SAFE_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const BACKUP_SCHEMA = 'EpicLifecycleBackfillBackup/1.0';
+const YOLOOP_CAPABILITIES = Object.freeze([
+    'rollover-session-v1',
+    'successor-transition-v1',
+    'continuation-replan-v1',
+    'cross-epic-continuation-reconcile-v1',
+]);
+const PRIVATE_PLANS = new WeakMap();
+const APPROVALS = new WeakMap();
+export async function previewEpicLifecycleBackfill(projectRoot, options) {
+    validateOptions(options);
+    const preview = await collectPreview(projectRoot, options);
+    const plan = buildPlan(preview);
+    if (Buffer.byteLength(epicOperationalCanonicalJson(plan), 'utf8') > EPIC_OPERATIONAL_PAYLOAD_LIMIT_BYTES) {
+        throw new Error('epic-operational-plan-oversized');
+    }
+    const frozen = deepFreeze(plan);
+    PRIVATE_PLANS.set(frozen, preview);
+    return frozen;
+}
+export function approveEpicLifecycleBackfill(plan) {
+    const preview = PRIVATE_PLANS.get(plan);
+    if (!preview || plan.blockers.length > 0 || plan.conflicts.length > 0
+        || computePlanDigest(plan) !== plan.planDigest) {
+        throw new Error('epic-operational-approval-invalid');
+    }
+    const authority = Object.freeze(Object.create(null));
+    APPROVALS.set(authority, { plan, preview });
+    return authority;
+}
+export async function applyEpicLifecycleBackfill(projectRoot, plan, approval, hooks = {}) {
+    assertPlan(plan);
+    const root = realpathSync(resolve(projectRoot));
+    const current = readGitLifecycleRuntimeSync(root);
+    if (current.schemaVersion === 2 && current.operational !== undefined) {
+        assertEpicOperationalState(current.operational);
+        const existing = current.operational.backfillReceipts.find((receipt) => receipt.operationId === plan.operationId || receipt.idempotencyKey === plan.idempotencyKey);
+        if (existing) {
+            if (existing.planDigest !== plan.planDigest || existing.sourceInventoryDigest !== plan.sourceInventoryDigest) {
+                throw new Error('epic-operational-replay-conflict');
+            }
+            return {
+                applied: false,
+                replay: true,
+                receipt: existing,
+                revision: current.revision,
+                writerEpoch: current.operational.writerEpoch,
+            };
+        }
+    }
+    let backup;
+    let document = current;
+    let operational = current.schemaVersion === 2 && current.operational !== undefined
+        ? current.operational
+        : null;
+    const active = operational?.activeJournal;
+    if (active) {
+        if (active.kind !== 'backfill' || active.operationId !== plan.operationId
+            || active.idempotencyKey !== plan.idempotencyKey || active.payloadHash !== plan.planDigest) {
+            throw new Error('epic-operational-journal-conflict');
+        }
+        if (active.phase === 'aborted-before-authority')
+            throw new Error('epic-operational-source-raced');
+        backup = readBackfillBackup(root, active.backupManifestRef, active.preimageDigest, plan);
+    }
+    else {
+        const binding = approval ? APPROVALS.get(approval) : undefined;
+        if (!binding || binding.plan !== plan || binding.preview.projectRoot !== root
+            || computePlanDigest(plan) !== plan.planDigest) {
+            throw new Error('epic-operational-approval-invalid');
+        }
+        if (document.schemaVersion !== plan.expectedRuntimeSchema && !(plan.expectedRuntimeSchema === 0 && document.revision === 0)) {
+            throw new Error('epic-operational-revision-conflict');
+        }
+        if (document.revision !== plan.expectedRevision)
+            throw new Error('epic-operational-revision-conflict');
+        verifyPrivateSources(binding.preview.sourceBindings, binding.preview.tracked.byteDigest);
+        verifyPhysicalBranch(root, binding.preview.physicalBranch);
+        backup = writeBackfillBackup(binding.preview, plan);
+        await hooks.afterBackup?.();
+        const journal = backfillJournal(plan, backup, 'prepared');
+        const preparedOperational = {
+            ...binding.preview.initialOperational,
+            activeJournal: journal,
+        };
+        const promoted = await mutateGitLifecycleRuntime(root, (mutable) => {
+            if (mutable.schemaVersion !== document.schemaVersion || mutable.revision !== plan.expectedRevision) {
+                throw new Error('epic-operational-revision-conflict');
+            }
+            mutable.operational = preparedOperational;
+        }, {
+            expectedRevision: plan.expectedRevision,
+            nextSchemaVersion: 2,
+            preCommit: async () => {
+                verifyPrivateSources(binding.preview.sourceBindings, binding.preview.tracked.byteDigest);
+                verifyPhysicalBranch(root, binding.preview.physicalBranch);
+            },
+        });
+        document = promoted.document;
+        operational = document.operational;
+        await hooks.afterPrepared?.();
+    }
+    if (!operational)
+        throw new Error('epic-operational-store-missing');
+    try {
+        if (operational.activeJournal?.phase === 'prepared') {
+            verifyBackupSources(backup, backup.plan.trackedStateMigration.sourceByteDigest);
+            verifyPhysicalBranch(root, backup.physicalBranch);
+            const transitioned = await mutateEpicOperationalState(root, {
+                identityHash: plan.identity.identityHash,
+                expectedRevision: document.revision,
+                expectedWriterEpoch: plan.nextWriterEpoch,
+            }, (state) => {
+                state.activeJournal = {
+                    ...state.activeJournal,
+                    phase: 'authority-applied',
+                };
+            });
+            document = transitioned.document;
+            operational = document.operational;
+            await hooks.afterAuthorityApplied?.();
+        }
+    }
+    catch (error) {
+        if (operational.activeJournal?.phase === 'prepared' && isSourceRace(error)) {
+            await markBackfillAborted(root, document, operational, plan);
+        }
+        throw error;
+    }
+    let trackedPostDigest = backup.plan.trackedStateMigration.targetByteDigest;
+    if (operational.activeJournal?.phase === 'authority-applied') {
+        verifyBackupSourcesOneOf(backup, backup.trackedMigration
+            ? [backup.plan.trackedStateMigration.sourceByteDigest, trackedPostDigest]
+            : [trackedPostDigest]);
+        if (backup.trackedMigration) {
+            const trackedBeforeApply = readStateMigrationSourceSnapshot(root).byteDigest;
+            applyStateMigration(root, {
+                operationId: backup.trackedMigration.operationId,
+                sourceCanonicalHash: backup.trackedMigration.sourceCanonicalHash,
+                targetCanonicalHash: backup.trackedMigration.targetCanonicalHash,
+                ...(trackedBeforeApply === backup.plan.trackedStateMigration.sourceByteDigest
+                    ? { sourceByteDigest: backup.plan.trackedStateMigration.sourceByteDigest }
+                    : {}),
+            });
+        }
+        const trackedReadback = readStateMigrationSourceSnapshot(root);
+        trackedPostDigest = trackedReadback.byteDigest;
+        if (trackedPostDigest !== backup.plan.trackedStateMigration.targetByteDigest) {
+            throw new Error('epic-operational-projection-conflict');
+        }
+        await hooks.afterTrackedProjection?.();
+        const sqlite = await inspectEpicOperationalSqliteBinding({
+            projectRoot: root,
+            authorityRevision: document.revision,
+            sourceDigest: plan.authorityPostimageDigest,
+        });
+        const transitioned = await mutateEpicOperationalState(root, {
+            identityHash: plan.identity.identityHash,
+            expectedRevision: document.revision,
+            expectedWriterEpoch: plan.nextWriterEpoch,
+        }, (state) => {
+            state.projectionBindings = {
+                ...state.projectionBindings,
+                trackedState: {
+                    status: 'bound',
+                    sourceDigest: trackedPostDigest,
+                    authorityRevision: document.revision,
+                    reasonCodes: ['epic-operational-tracked-state-bound'],
+                },
+                sqlite: {
+                    status: sqlite.status,
+                    sourceDigest: sqlite.sourceDigest,
+                    authorityRevision: document.revision,
+                    reasonCodes: sqlite.reasonCodes,
+                },
+            };
+            state.activeJournal = {
+                ...state.activeJournal,
+                phase: 'projections-applied',
+                projectionStatuses: {
+                    trackedState: 'applied',
+                    sqlite: sqlite.status === 'bound' ? 'applied' : 'unavailable',
+                },
+            };
+        });
+        document = transitioned.document;
+        operational = document.operational;
+        await hooks.afterProjectionsApplied?.();
+    }
+    if (operational.activeJournal?.phase !== 'projections-applied') {
+        throw new Error('epic-operational-journal-corrupt');
+    }
+    verifyBackupSources(backup, trackedPostDigest);
+    const receipt = backfillReceipt(plan, backup, trackedPostDigest, document.revision + 1);
+    const committed = await mutateEpicOperationalState(root, {
+        identityHash: plan.identity.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: plan.nextWriterEpoch,
+    }, (state) => {
+        if (state.backfillReceipts.length >= EPIC_OPERATIONAL_RECEIPT_CAP) {
+            throw new Error('epic-operational-receipt-capacity');
+        }
+        state.backfillReceipts = [...state.backfillReceipts, receipt];
+        state.activeJournal = null;
+    });
+    const finalState = committed.document.operational;
+    return {
+        applied: true,
+        replay: false,
+        receipt,
+        revision: committed.document.revision,
+        writerEpoch: finalState.writerEpoch,
+    };
+}
+export async function rollbackEpicLifecycleBackfill(input) {
+    const root = realpathSync(resolve(input.projectRoot));
+    let { document, operational } = readEpicOperationalState(root, {
+        expectedRevision: input.expectedRevision,
+        expectedWriterEpoch: input.expectedWriterEpoch,
+    });
+    if (operational.activeJournal)
+        throw new Error('epic-operational-journal-conflict');
+    const target = operational.backfillReceipts.find((receipt) => receipt.operationId === input.targetOperationId);
+    if (!target)
+        throw new Error('epic-operational-rollback-target-missing');
+    const existing = operational.rollbackReceipts.find((receipt) => receipt.targetOperationId === input.targetOperationId);
+    if (existing)
+        return { receipt: existing, revision: document.revision };
+    if (operational.rollbackReceipts.length >= EPIC_OPERATIONAL_RECEIPT_CAP) {
+        throw new Error('epic-operational-receipt-capacity');
+    }
+    const backupRef = `backups/${input.targetOperationId}.backfill.json`;
+    const backup = readBackfillBackup(root, backupRef, target.backupManifestDigest, undefined);
+    const tracked = readStateMigrationSourceSnapshot(root);
+    if (tracked.byteDigest !== target.postimageDigest)
+        throw new Error('epic-operational-rollback-postimage-conflict');
+    const operationId = `elrb_${epicOperationalHash('p224-backfill-rollback-id-v1', {
+        targetOperationId: input.targetOperationId,
+        expectedRevision: input.expectedRevision,
+        expectedWriterEpoch: input.expectedWriterEpoch,
+    }).slice(0, 32)}`;
+    const payloadHash = epicOperationalHash('p224-backfill-rollback-v1', {
+        operationId,
+        targetOperationId: input.targetOperationId,
+        expectedRevision: input.expectedRevision,
+        expectedWriterEpoch: input.expectedWriterEpoch,
+        postimageDigest: target.postimageDigest,
+        preimageDigest: target.preimageDigest,
+    });
+    const journal = {
+        schemaVersion: 'EpicOperationalJournal/1.0',
+        kind: 'rollback',
+        operationId,
+        idempotencyKey: operationId,
+        payloadHash,
+        identityHash: target.identityHash,
+        expectedRevision: input.expectedRevision,
+        expectedWriterEpoch: input.expectedWriterEpoch,
+        preimageDigest: target.postimageDigest,
+        backupManifestRef: backupRef,
+        phase: 'prepared',
+        projectionStatuses: { trackedState: 'pending', sqlite: 'not-applicable' },
+        reasonCodes: ['epic-operational-backup-verified'],
+    };
+    let transition = await mutateEpicOperationalState(root, {
+        identityHash: target.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: operational.writerEpoch,
+    }, (state) => {
+        state.activeJournal = journal;
+    });
+    document = transition.document;
+    operational = document.operational;
+    transition = await mutateEpicOperationalState(root, {
+        identityHash: target.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: operational.writerEpoch,
+    }, (state) => {
+        state.writerEpoch = state.writerEpoch + 1;
+        state.activeJournal = {
+            ...state.activeJournal,
+            phase: 'authority-applied',
+        };
+    });
+    document = transition.document;
+    operational = document.operational;
+    if (backup.trackedMigration) {
+        restoreStateMigrationPreimage({
+            projectRoot: root,
+            operationId: backup.trackedMigration.operationId,
+            expectedCurrentDigest: target.postimageDigest,
+            expectedBackupDigest: target.preimageDigest,
+        });
+    }
+    else if (target.preimageDigest !== target.postimageDigest) {
+        throw new Error('epic-operational-rollback-backup-invalid');
+    }
+    const restored = readStateMigrationSourceSnapshot(root);
+    if (restored.byteDigest !== target.preimageDigest)
+        throw new Error('epic-operational-rollback-readback-failed');
+    transition = await mutateEpicOperationalState(root, {
+        identityHash: target.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: operational.writerEpoch,
+    }, (state) => {
+        state.projectionBindings = {
+            ...state.projectionBindings,
+            trackedState: {
+                status: 'bound',
+                sourceDigest: restored.byteDigest,
+                authorityRevision: document.revision,
+                reasonCodes: ['epic-operational-rollback-projection-restored'],
+            },
+        };
+        state.activeJournal = {
+            ...state.activeJournal,
+            phase: 'projections-applied',
+            projectionStatuses: { trackedState: 'applied', sqlite: 'not-applicable' },
+        };
+    });
+    document = transition.document;
+    operational = document.operational;
+    const receipt = {
+        schemaVersion: 'EpicOperationalRollbackReceipt/1.0',
+        operationId,
+        targetOperationId: input.targetOperationId,
+        expectedPostimageDigest: target.postimageDigest,
+        restoredPreimageDigest: target.preimageDigest,
+        reasonCodes: ['epic-operational-rollback-verified'],
+        publicSafe: true,
+    };
+    const committed = await mutateEpicOperationalState(root, {
+        identityHash: target.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: operational.writerEpoch,
+    }, (state) => {
+        state.rollbackReceipts = [...state.rollbackReceipts, receipt];
+        state.activeJournal = null;
+    });
+    return { receipt, revision: committed.document.revision };
+}
+async function collectPreview(projectRoot, options) {
+    const root = realpathSync(resolve(projectRoot));
+    const commonDir = resolveCommonDir(root);
+    const runtimePath = resolveRuntimePath(commonDir);
+    const runtimeRaw = existsSync(runtimePath) ? readBoundedRaw(runtimePath).raw : null;
+    const runtime = readGitLifecycleRuntimeSync(root);
+    const tracked = readStateMigrationSourceSnapshot(root);
+    const trackedMigration = previewStateMigration(root);
+    const trackedTargetRaw = trackedMigration
+        ? `${JSON.stringify(trackedMigration.targetState, null, 2)}\n`
+        : tracked.raw;
+    const trackedTargetDigest = sha256(trackedTargetRaw);
+    const identity = createEpicOperationalIdentity(root, options);
+    const nowIso = options.nowIso ?? new Date().toISOString();
+    if (!Number.isFinite(Date.parse(nowIso)))
+        throw new Error('epic-operational-time-invalid');
+    const worktrees = listWorktrees(root, commonDir);
+    const sources = [];
+    const bindings = [];
+    sources.push(sourceFromRaw('common-runtime', commonDir, runtimeRaw, 'authority-candidate'));
+    sources.push(sourceFromRaw('tracked-state', root, tracked.raw, 'projection'));
+    bindings.push({ path: join(root, '.neocortex', 'state.json'), presence: 'present', digest: tracked.byteDigest, kind: 'tracked-state' });
+    const validStates = [];
+    let selectedLock = null;
+    const collectionBlockers = [];
+    for (const worktree of worktrees) {
+        const statePath = join(worktree.path, '.neocortex', 'yoloop-state.json');
+        const lockPath = join(worktree.path, '.neocortex', 'yoloop.lock');
+        const state = inspectLegacyJson(statePath, 'legacy-yoloop-state', worktree.fingerprint, strictCounters);
+        sources.push(state.source);
+        bindings.push(state.binding);
+        if (state.parsed)
+            validStates.push({ fingerprint: worktree.fingerprint, parsed: state.parsed, digest: state.source.canonicalDigest });
+        if (state.source.presence === 'corrupt' || state.source.presence === 'unsafe' || state.source.presence === 'unsupported') {
+            collectionBlockers.push(...state.source.reasonCodes);
+        }
+        const lock = inspectLegacyJson(lockPath, 'legacy-yoloop-lock', worktree.fingerprint, strictLock);
+        sources.push(lock.source);
+        bindings.push(lock.binding);
+        if (lock.parsed)
+            selectedLock = lock.parsed;
+        if (lock.source.presence !== 'missing') {
+            if (lock.parsed)
+                collectionBlockers.push('epic-operational-writer-active');
+            else
+                collectionBlockers.push(...lock.source.reasonCodes);
+        }
+    }
+    const stateDigests = [...new Set(validStates.map((entry) => entry.digest))];
+    if (stateDigests.length > 1)
+        collectionBlockers.push('epic-operational-source-conflict');
+    const selected = validStates[0];
+    if (!selected && hasTrackedProgress(tracked.state))
+        collectionBlockers.push('epic-operational-progress-source-missing');
+    const selectedYoloop = selected?.parsed ?? createDefaultCounters(nowIso);
+    const initialOperational = createInitialEpicOperationalState({
+        identity,
+        yoloop: {
+            lock: null,
+            state: selectedYoloop,
+            capabilities: YOLOOP_CAPABILITIES,
+        },
+        trackedStateDigest: tracked.byteDigest,
+        sqliteStatus: 'unavailable',
+        sqliteReasonCodes: ['epic-operational-projection-unavailable'],
+    });
+    const sqlite = await inspectEpicOperationalSqliteBinding({
+        projectRoot: root,
+        authorityRevision: runtime.revision,
+        sourceDigest: epicOperationalHash('p224-backfill-authority-v1', initialOperational),
+        ...(options.sqliteAdapter ? { adapter: options.sqliteAdapter } : {}),
+        ...(options.sqliteAdapterLoader ? { adapterLoader: options.sqliteAdapterLoader } : {}),
+    });
+    sources.push({
+        schemaVersion: 'EpicLifecycleBackfillSource/1.0',
+        kind: 'sqlite-projection',
+        sourceFingerprint: epicOperationalHash('p224-backfill-source-v1', { kind: 'sqlite-projection', repository: identity.repositoryFingerprint }),
+        presence: sqlite.status === 'unavailable' ? 'unavailable' : 'present',
+        byteLength: null,
+        byteDigest: sqlite.sourceDigest,
+        canonicalDigest: sqlite.sourceDigest,
+        sourceSchema: 'continuity-state_snapshots',
+        status: 'projection',
+        role: 'projection',
+        reasonCodes: sqlite.reasonCodes,
+        publicSafe: true,
+    });
+    const physicalBranch = execFileSync('git', ['branch', '--show-current'], { cwd: root, encoding: 'utf8' }).trim();
+    const privatePreview = {
+        projectRoot: root,
+        commonDir,
+        runtimePath,
+        runtimeRaw,
+        runtime,
+        tracked,
+        trackedMigration,
+        trackedTargetRaw,
+        trackedTargetDigest,
+        selectedYoloop,
+        selectedYoloopLock: selectedLock,
+        initialOperational,
+        sourceBindings: bindings,
+        publicSources: sources.sort(compareSources),
+        collectionBlockers,
+        physicalBranch,
+        options: {
+            epicId: options.epicId,
+            executionBranch: options.executionBranch,
+            graphRevision: options.graphRevision,
+            originBindingDigest: options.originBindingDigest,
+            managedClients: options.managedClients ?? [],
+            nowIso,
+            ...(options.sqliteAdapter ? { sqliteAdapter: options.sqliteAdapter } : {}),
+            ...(options.sqliteAdapterLoader ? { sqliteAdapterLoader: options.sqliteAdapterLoader } : {}),
+        },
+    };
+    return privatePreview;
+}
+function buildPlan(preview) {
+    const sourceInventory = preview.collectionBlockers;
+    const sources = collectPublicSources(preview);
+    const blockers = [...sourceInventory];
+    if (preview.physicalBranch !== preview.options.executionBranch)
+        blockers.push('epic-operational-branch-mismatch');
+    const trackedEpic = findTrackedEpic(preview.tracked.state, preview.options.epicId);
+    const runtimeEpic = record(preview.runtime.epics[preview.options.epicId]);
+    if (!trackedEpic)
+        blockers.push('epic-operational-epic-missing');
+    if (trackedEpic && trackedEpic.branch_mode !== undefined && trackedEpic.branch_mode !== 'epic') {
+        blockers.push('epic-operational-branch-mode-conflict');
+    }
+    if (trackedEpic && typeof trackedEpic.execution_branch === 'string'
+        && trackedEpic.execution_branch !== preview.options.executionBranch)
+        blockers.push('epic-operational-branch-mismatch');
+    if (trackedEpic && typeof trackedEpic.graph_revision === 'string'
+        && trackedEpic.graph_revision !== preview.options.graphRevision)
+        blockers.push('epic-operational-graph-mismatch');
+    if (runtimeEpic && typeof runtimeEpic.execution_branch === 'string'
+        && runtimeEpic.execution_branch !== preview.options.executionBranch)
+        blockers.push('epic-operational-branch-mismatch');
+    if (runtimeEpic && typeof runtimeEpic.graph_revision === 'string'
+        && runtimeEpic.graph_revision !== preview.options.graphRevision)
+        blockers.push('epic-operational-graph-mismatch');
+    if (isLiveLease(trackedEpic?.branch_lease, preview.options.nowIso)
+        || isLiveLease(runtimeEpic?.branch_lease, preview.options.nowIso)) {
+        blockers.push('epic-operational-writer-active');
+    }
+    const expectedWriterEpoch = preview.runtime.schemaVersion === 2 && preview.runtime.operational
+        ? Number(preview.runtime.operational.writerEpoch) : 0;
+    for (const client of preview.options.managedClients) {
+        if (client.activeWriter)
+            blockers.push('epic-operational-writer-active');
+        if (client.writerEpoch !== expectedWriterEpoch
+            || !client.capabilities.includes('epic-operational-state-v1')) {
+            blockers.push('epic-operational-legacy-writer-unfenced');
+        }
+    }
+    if (preview.runtime.schemaVersion === 2) {
+        try {
+            assertEpicOperationalState(preview.runtime.operational);
+            const state = preview.runtime.operational;
+            blockers.push('epic-operational-already-adopted');
+            if (state.activeJournal)
+                blockers.push('epic-operational-journal-conflict');
+            if (state.backfillReceipts.length >= EPIC_OPERATIONAL_RECEIPT_CAP)
+                blockers.push('epic-operational-receipt-capacity');
+        }
+        catch {
+            blockers.push('epic-operational-store-corrupt');
+        }
+    }
+    const requiredSources = sources.filter((source) => source.kind !== 'sqlite-projection');
+    const sourceInventoryDigest = epicOperationalHash('p224-backfill-source-inventory-v1', sources);
+    const requiredSourceDigest = epicOperationalHash('p224-backfill-required-sources-v1', requiredSources);
+    const checkoutFingerprints = [...new Set(sources
+            .filter((source) => source.kind === 'legacy-yoloop-state')
+            .map((source) => source.sourceFingerprint))].sort();
+    const managedClientFenceDigest = epicOperationalHash('p224-managed-client-fence-v1', preview.options.managedClients);
+    const migration = preview.trackedMigration;
+    const body = {
+        schemaVersion: 'EpicLifecycleBackfillPlan/1.0',
+        repositoryFingerprint: preview.initialOperational.repositoryFingerprint,
+        identity: Object.values(preview.initialOperational.identities)[0],
+        expectedRuntimeSchema: (preview.runtimeRaw === null ? 0 : preview.runtime.schemaVersion),
+        expectedRevision: preview.runtime.revision,
+        expectedWriterEpoch,
+        nextWriterEpoch: Math.max(1, expectedWriterEpoch + 1),
+        sourceInventory: sources,
+        sourceInventoryDigest,
+        requiredSourceDigest,
+        checkoutCount: checkoutFingerprints.length,
+        checkoutSetDigest: epicOperationalHash('p224-backfill-checkout-set-v1', checkoutFingerprints),
+        managedClientFenceDigest,
+        selectedYoloopSourceFingerprint: sources.find((source) => source.kind === 'legacy-yoloop-state' && source.presence === 'present')?.sourceFingerprint ?? null,
+        selectedYoloopCanonicalDigest: epicOperationalHash('p224-backfill-yoloop-v1', preview.selectedYoloop),
+        trackedStateMigration: {
+            outcome: migration ? 'migrate' : 'unchanged',
+            operationId: migration?.operationId ?? null,
+            sourceByteDigest: preview.tracked.byteDigest,
+            targetByteDigest: preview.trackedTargetDigest,
+            sourceCanonicalHash: migration?.sourceCanonicalHash ?? null,
+            targetCanonicalHash: migration?.targetCanonicalHash ?? null,
+        },
+        conflicts: [...new Set(blockers.filter((reason) => reason === 'epic-operational-source-conflict'))].sort(),
+        blockers: [...new Set(blockers)].sort(),
+        proposedEffects: [
+            'promote-common-runtime-v2',
+            'install-common-yoloop-authority',
+            ...(migration ? ['migrate-owned-tracked-state'] : []),
+            'record-explicit-sqlite-binding',
+            'append-backfill-receipt',
+        ],
+        rollbackPreconditions: [
+            'exact-runtime-revision-and-writer-epoch',
+            'exact-tracked-postimage',
+            'verified-private-backup',
+            'quiescent-writers',
+        ],
+        authorityPostimageDigest: epicOperationalHash('p224-backfill-authority-v1', preview.initialOperational),
+        publicSafe: true,
+    };
+    const operationId = `elbf_${epicOperationalHash('p224-backfill-operation-id-v1', body).slice(0, 32)}`;
+    const planWithoutDigest = { ...body, operationId, idempotencyKey: operationId };
+    return { ...planWithoutDigest, planDigest: epicOperationalHash('p224-backfill-plan-v1', planWithoutDigest) };
+}
+function collectPublicSources(preview) {
+    return preview.publicSources;
+}
+function writeBackfillBackup(preview, plan) {
+    const runtimeDir = join(preview.commonDir, GIT_LIFECYCLE_RUNTIME_DIRECTORY);
+    ensurePrivateRuntimeDirectory(runtimeDir, preview.commonDir);
+    const backupsDir = join(runtimeDir, 'backups');
+    ensurePrivateRuntimeDirectory(backupsDir, runtimeDir);
+    const payload = {
+        schemaVersion: BACKUP_SCHEMA,
+        operationId: plan.operationId,
+        plan,
+        runtimeRaw: preview.runtimeRaw,
+        trackedSourceRaw: preview.tracked.raw,
+        trackedTargetRaw: preview.trackedTargetRaw,
+        trackedMigration: preview.trackedMigration,
+        initialOperational: preview.initialOperational,
+        sourceBindings: preview.sourceBindings,
+        physicalBranch: preview.physicalBranch,
+    };
+    const manifest = {
+        ...payload,
+        manifestDigest: epicOperationalHash('p224-backfill-backup-v1', payload),
+    };
+    const path = join(backupsDir, `${plan.operationId}.backfill.json`);
+    const raw = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (existsSync(path)) {
+        const existing = parseBackup(readFileSync(path, 'utf8'));
+        if (existing.manifestDigest !== manifest.manifestDigest)
+            throw new Error('epic-operational-backup-failed');
+        return existing;
+    }
+    const fd = openSync(path, 'wx', 0o600);
+    try {
+        writeFileSync(fd, raw);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    fsyncDirectory(backupsDir);
+    return manifest;
+}
+function readBackfillBackup(projectRoot, backupRef, expectedDigest, plan) {
+    if (!/^backups\/elbf_[a-f0-9]{32}\.backfill\.json$/.test(backupRef) || !HASH.test(expectedDigest)) {
+        throw new Error('epic-operational-backup-failed');
+    }
+    const commonDir = resolveCommonDir(projectRoot);
+    const runtimeDir = join(commonDir, GIT_LIFECYCLE_RUNTIME_DIRECTORY);
+    const path = join(runtimeDir, backupRef);
+    assertPrivateEntry(runtimeDir, 'directory');
+    assertPrivateEntry(path, 'file');
+    const backup = parseBackup(readFileSync(path, 'utf8'));
+    if (backup.manifestDigest !== expectedDigest
+        || (plan && (backup.plan.planDigest !== plan.planDigest || backup.operationId !== plan.operationId))) {
+        throw new Error('epic-operational-backup-failed');
+    }
+    return backup;
+}
+function parseBackup(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('epic-operational-backup-failed');
+    }
+    const item = record(parsed);
+    if (!item || item.schemaVersion !== BACKUP_SCHEMA || !SAFE_ID.test(String(item.operationId))
+        || !record(item.plan) || !record(item.initialOperational) || !Array.isArray(item.sourceBindings)
+        || typeof item.trackedSourceRaw !== 'string' || typeof item.trackedTargetRaw !== 'string'
+        || typeof item.physicalBranch !== 'string' || !HASH.test(String(item.manifestDigest))) {
+        throw new Error('epic-operational-backup-failed');
+    }
+    const { manifestDigest, ...payload } = item;
+    if (manifestDigest !== epicOperationalHash('p224-backfill-backup-v1', payload)) {
+        throw new Error('epic-operational-backup-failed');
+    }
+    assertPlan(item.plan);
+    assertEpicOperationalState(item.initialOperational);
+    return item;
+}
+function backfillJournal(plan, backup, phase) {
+    return {
+        schemaVersion: 'EpicOperationalJournal/1.0',
+        kind: 'backfill',
+        operationId: plan.operationId,
+        idempotencyKey: plan.idempotencyKey,
+        payloadHash: plan.planDigest,
+        identityHash: plan.identity.identityHash,
+        expectedRevision: plan.expectedRevision,
+        expectedWriterEpoch: plan.expectedWriterEpoch,
+        preimageDigest: backup.manifestDigest,
+        backupManifestRef: `backups/${plan.operationId}.backfill.json`,
+        phase,
+        projectionStatuses: { trackedState: 'pending', sqlite: 'pending' },
+        reasonCodes: ['epic-operational-backup-verified'],
+    };
+}
+function backfillReceipt(plan, backup, trackedPostDigest, appliedRevision) {
+    return Object.freeze({
+        schemaVersion: 'EpicLifecycleBackfillReceipt/1.0',
+        operationId: plan.operationId,
+        idempotencyKey: plan.idempotencyKey,
+        payloadHash: plan.planDigest,
+        planDigest: plan.planDigest,
+        sourceInventoryDigest: plan.sourceInventoryDigest,
+        preimageDigest: plan.trackedStateMigration.sourceByteDigest,
+        postimageDigest: trackedPostDigest,
+        authorityPostimageDigest: plan.authorityPostimageDigest,
+        backupManifestDigest: backup.manifestDigest,
+        identityHash: plan.identity.identityHash,
+        appliedRevision,
+        writerEpoch: plan.nextWriterEpoch,
+        stateMigrationOperationId: plan.trackedStateMigration.operationId,
+        outcome: 'applied',
+        reasonCodes: ['epic-operational-backfill-applied', 'epic-operational-backup-verified'],
+        publicSafe: true,
+    });
+}
+function verifyBackupSources(backup, expectedTrackedDigest) {
+    verifyPrivateSources(backup.sourceBindings, expectedTrackedDigest);
+}
+function verifyBackupSourcesOneOf(backup, expectedTrackedDigests) {
+    for (const binding of backup.sourceBindings) {
+        if (binding.kind === 'tracked-state') {
+            const source = readBoundedRaw(binding.path);
+            if (!expectedTrackedDigests.includes(source.digest))
+                throw new Error('epic-operational-source-raced');
+            continue;
+        }
+        if (binding.presence === 'missing') {
+            if (existsSync(binding.path))
+                throw new Error('epic-operational-source-raced');
+            continue;
+        }
+        if (readBoundedRaw(binding.path).digest !== binding.digest) {
+            throw new Error('epic-operational-source-raced');
+        }
+    }
+}
+function verifyPrivateSources(bindings, expectedTrackedDigest) {
+    for (const binding of bindings) {
+        if (binding.kind === 'tracked-state') {
+            const source = readBoundedRaw(binding.path);
+            if (source.digest !== expectedTrackedDigest)
+                throw new Error('epic-operational-source-raced');
+            continue;
+        }
+        if (binding.presence === 'missing') {
+            if (existsSync(binding.path))
+                throw new Error('epic-operational-source-raced');
+            continue;
+        }
+        const source = readBoundedRaw(binding.path);
+        if (source.digest !== binding.digest)
+            throw new Error('epic-operational-source-raced');
+    }
+}
+async function markBackfillAborted(projectRoot, document, operational, plan) {
+    if (operational.activeJournal?.phase !== 'prepared')
+        return;
+    await mutateEpicOperationalState(projectRoot, {
+        identityHash: plan.identity.identityHash,
+        expectedRevision: document.revision,
+        expectedWriterEpoch: plan.nextWriterEpoch,
+    }, (state) => {
+        state.activeJournal = {
+            ...state.activeJournal,
+            phase: 'aborted-before-authority',
+            reasonCodes: [...state.activeJournal.reasonCodes, 'epic-operational-source-raced'],
+        };
+    });
+}
+function inspectLegacyJson(path, kind, worktreeFingerprint, validate) {
+    const fingerprint = epicOperationalHash('p224-backfill-source-v1', { kind, worktreeFingerprint });
+    if (!existsSync(path)) {
+        return {
+            source: missingSource(kind, fingerprint),
+            binding: { path, presence: 'missing', digest: null, kind },
+            parsed: null,
+        };
+    }
+    try {
+        const raw = readBoundedRaw(path);
+        const parsed = validate(JSON.parse(raw.raw));
+        return {
+            source: sourceFromParsed(kind, fingerprint, raw.raw, parsed),
+            binding: { path, presence: 'present', digest: raw.digest, kind },
+            parsed,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error && error.message.startsWith('epic-operational-')
+            ? error.message : 'epic-operational-source-corrupt';
+        return {
+            source: blockedSource(kind, fingerprint, reason.endsWith('unsafe') ? 'unsafe' : 'corrupt', reason),
+            binding: { path, presence: 'present', digest: safeFileDigest(path), kind },
+            parsed: null,
+        };
+    }
+}
+function strictCounters(value) {
+    const item = record(value);
+    if (!item || !['1.1', '1.2'].includes(String(item.version))
+        || !Number.isFinite(item.storiesRunToday) || Number(item.storiesRunToday) < 0
+        || !Number.isFinite(item.iterationsToday) || Number(item.iterationsToday) < 0
+        || !Number.isFinite(item.tokensUsedToday) || Number(item.tokensUsedToday) < 0
+        || !Number.isFinite(item.totalRunsAllTime) || Number(item.totalRunsAllTime) < 0
+        || !Number.isFinite(item.totalStoriesAllTime) || Number(item.totalStoriesAllTime) < 0
+        || !(item.currentSession === null || record(item.currentSession))
+        || !Array.isArray(item.pendingContinuationAuthorities ?? [])) {
+        throw new Error('epic-operational-source-corrupt');
+    }
+    return item;
+}
+function strictLock(value) {
+    const item = record(value);
+    if (!item || !Number.isSafeInteger(item.pid) || Number(item.pid) < 0
+        || typeof item.hostname !== 'string' || typeof item.startedAt !== 'string'
+        || typeof item.sessionId !== 'string' || item.sessionId.length > 128
+        || !Array.isArray(item.epicQueue) || !item.epicQueue.every((entry) => typeof entry === 'string')
+        || typeof item.currentEpicId !== 'string' || typeof item.ttlExpiresAt !== 'string') {
+        throw new Error('epic-operational-source-corrupt');
+    }
+    return item;
+}
+function sourceFromRaw(kind, identityPath, raw, role) {
+    const fingerprint = sourceFingerprint(identityPath, kind);
+    if (raw === null)
+        return missingSource(kind, fingerprint);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return blockedSource(kind, fingerprint, 'corrupt', 'epic-operational-source-corrupt');
+    }
+    const source = sourceFromParsed(kind, fingerprint, raw, parsed);
+    return { ...source, role, status: role === 'projection' ? 'projection' : 'candidate' };
+}
+function sourceFromParsed(kind, fingerprint, raw, parsed) {
+    const item = record(parsed);
+    return {
+        schemaVersion: 'EpicLifecycleBackfillSource/1.0',
+        kind,
+        sourceFingerprint: fingerprint,
+        presence: 'present',
+        byteLength: Buffer.byteLength(raw, 'utf8'),
+        byteDigest: sha256(raw),
+        canonicalDigest: epicOperationalHash('p224-backfill-source-canonical-v1', parsed),
+        sourceSchema: typeof item?.schemaVersion === 'string' || typeof item?.schemaVersion === 'number'
+            ? String(item.schemaVersion) : typeof item?.version === 'string' ? item.version : 'legacy',
+        status: kind.includes('lock') ? 'activity' : kind === 'tracked-state' || kind === 'sqlite-projection' ? 'projection' : 'candidate',
+        role: kind.includes('lock') ? 'activity-signal' : kind === 'tracked-state' || kind === 'sqlite-projection'
+            ? 'projection' : 'authority-candidate',
+        reasonCodes: ['epic-operational-source-complete'],
+        publicSafe: true,
+    };
+}
+function missingSource(kind, fingerprint) {
+    return {
+        schemaVersion: 'EpicLifecycleBackfillSource/1.0',
+        kind,
+        sourceFingerprint: fingerprint,
+        presence: 'missing',
+        byteLength: null,
+        byteDigest: null,
+        canonicalDigest: null,
+        sourceSchema: null,
+        status: 'absent',
+        role: kind.includes('lock') ? 'activity-signal' : kind === 'tracked-state' || kind === 'sqlite-projection'
+            ? 'projection' : 'authority-candidate',
+        reasonCodes: ['epic-operational-source-missing'],
+        publicSafe: true,
+    };
+}
+function blockedSource(kind, fingerprint, presence, reason) {
+    return {
+        schemaVersion: 'EpicLifecycleBackfillSource/1.0',
+        kind,
+        sourceFingerprint: fingerprint,
+        presence,
+        byteLength: null,
+        byteDigest: null,
+        canonicalDigest: null,
+        sourceSchema: null,
+        status: 'blocked',
+        role: kind.includes('lock') ? 'activity-signal' : kind === 'tracked-state' ? 'projection' : 'authority-candidate',
+        reasonCodes: [reason],
+        publicSafe: true,
+    };
+}
+function listWorktrees(projectRoot, expectedCommonDir) {
+    const raw = execFileSync('git', ['worktree', 'list', '--porcelain', '-z'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        maxBuffer: 4 * 1024 * 1024,
+    });
+    const paths = raw.split('\0')
+        .filter((token) => token.startsWith('worktree '))
+        .map((token) => token.slice('worktree '.length));
+    if (paths.length === 0 || paths.length > CHECKOUT_CAP)
+        throw new Error('epic-operational-checkout-capacity');
+    return paths.map((path) => {
+        const canonical = realpathSync(path);
+        const common = resolveCommonDir(canonical);
+        if (common !== expectedCommonDir)
+            throw new Error('epic-operational-foreign-common-dir');
+        const info = lstatSync(canonical);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error('epic-operational-path-unsafe');
+        return {
+            path: canonical,
+            fingerprint: epicOperationalHash('p224-backfill-worktree-v1', {
+                repository: epicOperationalHash('p224-backfill-common-v1', expectedCommonDir),
+                dev: Number(info.dev),
+                ino: Number(info.ino),
+            }),
+        };
+    }).sort((left, right) => left.fingerprint.localeCompare(right.fingerprint));
+}
+function resolveCommonDir(projectRoot) {
+    const raw = execFileSync('git', ['rev-parse', '--git-common-dir'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    const absolute = isAbsolute(raw) ? resolve(raw) : resolve(projectRoot, raw);
+    const canonical = realpathSync(absolute);
+    const info = lstatSync(canonical);
+    if (canonical !== absolute || !info.isDirectory() || info.isSymbolicLink()) {
+        throw new Error('epic-operational-path-unsafe');
+    }
+    return canonical;
+}
+function resolveRuntimePath(commonDir) {
+    const current = join(commonDir, GIT_LIFECYCLE_RUNTIME_DIRECTORY, GIT_LIFECYCLE_RUNTIME_FILE);
+    if (existsSync(current))
+        return current;
+    return join(commonDir, 'neocortex-yoloop-runtime.json');
+}
+function readBoundedRaw(path) {
+    const info = lstatSync(path);
+    if (!info.isFile() || info.isSymbolicLink())
+        throw new Error('epic-operational-path-unsafe');
+    if (typeof process.getuid === 'function' && info.uid !== process.getuid())
+        throw new Error('epic-operational-path-unsafe');
+    if (info.size > STATE_MIGRATION_INPUT_LIMIT_BYTES)
+        throw new Error('epic-operational-source-oversized');
+    const raw = readFileSync(path, 'utf8');
+    if (Buffer.byteLength(raw, 'utf8') !== info.size)
+        throw new Error('epic-operational-source-raced');
+    return { raw, digest: sha256(raw) };
+}
+function safeFileDigest(path) {
+    try {
+        return readBoundedRaw(path).digest;
+    }
+    catch {
+        return null;
+    }
+}
+function sourceFingerprint(path, kind) {
+    let physical = { presence: 'missing' };
+    if (existsSync(path)) {
+        const info = lstatSync(path);
+        physical = { dev: Number(info.dev), ino: Number(info.ino), type: info.isDirectory() ? 'directory' : 'file' };
+    }
+    return epicOperationalHash('p224-backfill-source-v1', { kind, physical });
+}
+function findTrackedEpic(state, epicId) {
+    const epics = state.epics;
+    if (Array.isArray(epics))
+        return epics.map(record).find((epic) => epic?.id === epicId);
+    return record(epics)?.[epicId];
+}
+function hasTrackedProgress(state) {
+    const stories = state.stories;
+    const values = Array.isArray(stories) ? stories : Object.values(record(stories) ?? {});
+    return values.some((value) => {
+        const story = record(value);
+        return Boolean(story && ((Array.isArray(story.steps_completed) && story.steps_completed.length > 0)
+            || story.checkpoint || story.branch_name || (typeof story.status === 'string' && !['backlog', 'planned'].includes(story.status))));
+    });
+}
+function isLiveLease(value, nowIso) {
+    const lease = record(value);
+    if (!lease)
+        return false;
+    const expires = Date.parse(String(lease.expiresAt ?? ''));
+    return !Number.isFinite(expires) || expires > Date.parse(nowIso);
+}
+function verifyPhysicalBranch(projectRoot, expected) {
+    const current = execFileSync('git', ['branch', '--show-current'], { cwd: projectRoot, encoding: 'utf8' }).trim();
+    if (current !== expected)
+        throw new Error('epic-operational-source-raced');
+}
+function ensurePrivateRuntimeDirectory(path, parent) {
+    if (!existsSync(path)) {
+        mkdirSync(path, { mode: 0o700 });
+        fsyncDirectory(parent);
+    }
+    assertPrivateEntry(path, 'directory');
+    if (realpathSync(path) !== resolve(path) || relative(resolve(parent), resolve(path)).startsWith('..')) {
+        throw new Error('epic-operational-path-unsafe');
+    }
+}
+function assertPrivateEntry(path, kind) {
+    const info = lstatSync(path);
+    if (info.isSymbolicLink() || (kind === 'file' ? !info.isFile() : !info.isDirectory())
+        || (typeof process.getuid === 'function' && info.uid !== process.getuid())
+        || (process.platform !== 'win32' && (info.mode & 0o077) !== 0)) {
+        throw new Error('epic-operational-path-unsafe');
+    }
+}
+function fsyncDirectory(path) {
+    if (process.platform === 'win32')
+        return;
+    const fd = openSync(path, 'r');
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function validateOptions(options) {
+    if (!/^P[1-9][0-9]*$/.test(options.epicId)
+        || !/^[A-Za-z0-9][A-Za-z0-9._/-]{0,239}$/.test(options.executionBranch)
+        || options.executionBranch.includes('..') || options.executionBranch.includes('//')
+        || !HASH.test(options.graphRevision) || !HASH.test(options.originBindingDigest)
+        || (options.managedClients?.length ?? 0) > 128
+        || options.managedClients?.some((client) => !SAFE_ID.test(client.clientId)
+            || !Number.isSafeInteger(client.writerEpoch) || client.writerEpoch < 0
+            || client.capabilities.length > 16)) {
+        throw new Error('epic-operational-preview-input-invalid');
+    }
+}
+function assertPlan(plan) {
+    if (plan.schemaVersion !== 'EpicLifecycleBackfillPlan/1.0'
+        || !/^elbf_[a-f0-9]{32}$/.test(plan.operationId)
+        || plan.idempotencyKey !== plan.operationId
+        || !HASH.test(plan.repositoryFingerprint) || !HASH.test(plan.planDigest)
+        || !HASH.test(plan.sourceInventoryDigest) || !HASH.test(plan.requiredSourceDigest)
+        || computePlanDigest(plan) !== plan.planDigest
+        || plan.sourceInventory.length > CHECKOUT_CAP * 2 + 3
+        || plan.blockers.some((reason) => !/^[a-z0-9][a-z0-9-]{0,79}$/.test(reason))) {
+        throw new Error('epic-operational-plan-invalid');
+    }
+}
+function computePlanDigest(plan) {
+    const { planDigest: _planDigest, ...body } = plan;
+    return epicOperationalHash('p224-backfill-plan-v1', body);
+}
+function compareSources(left, right) {
+    return `${left.kind}:${left.sourceFingerprint}`.localeCompare(`${right.kind}:${right.sourceFingerprint}`);
+}
+function isSourceRace(error) {
+    return error instanceof Error && [
+        'epic-operational-source-raced',
+        'epic-operational-branch-mismatch',
+        'epic-operational-writer-active',
+        'epic-operational-legacy-writer-unfenced',
+    ].includes(error.message);
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value : undefined;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}