@zq-silk/yui 0.13.9 → 0.14.0

package/dist/scheduler/activeTaskProgress.js

@@ -1,126 +0,0 @@
-import { selectedActiveSchedulerTasks, isSchedulerTaskWorkspaceReady } from "./ports.js";
-import { queueLeaderWakeup } from "./wakeupQueue.js";
-import { wakeReason } from "./wakeReason.js";
-import { projectTaskExecution } from "./taskExecutionProjection.js";
-import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake, hasDispatchableQueuedResourceLane } from "./actionability.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-/**
- * Repairs an active Task that has no durable owner capable of advancing it.
- * This is a low-frequency safety net; normal transitions enqueue their own
- * Role mailbox signal in the same transaction.
- *
- * Issue 05: a `task-orphaned` wake is suppressed when the last Leader Run
- * ended waiting/blocked and its observed actionability digest equals the
- * current digest. Suppression is silent — no Message, Event, or progress
- * record is written — because a periodic scan that changes nothing is Yui
- * engineering behavior with no Task-visible effect. Computation errors fail
- * open: the Task is woken once and the error is recorded so it can never be
- * silently starved.
- */
-export function repairOrphanedActiveTasks(store, now, selection) {
-    const repaired = [];
-    for (const task of selectedActiveSchedulerTasks(store, selection)) {
-        const roles = store.listRoles(task.id);
-        const activeRuns = roles.flatMap((role) => {
-            const run = store.getActiveAgentRun(task.id, role.name);
-            return run === null ? [] : [run];
-        });
-        const leaderTarget = { kind: "role", taskId: task.id, roleName: "leader" };
-        const leaderMailbox = store.getWorkMailbox(leaderTarget);
-        const projection = projectTaskExecution({
-            task,
-            roles,
-            runs: activeRuns,
-            pendingWakeup: store.getPendingWakeup(task.id),
-            leaderMailbox,
-            leaderFailure: store.getLeaderFailure(task.id)
-        });
-        const queuedAlongsideActiveSibling = hasDispatchableQueuedResourceLane(store, task.id)
-            && !activeRuns.some(({ roleName }) => roleName === "leader")
-            && activeRuns.some(({ roleName }) => roleName !== "leader")
-            && projection.status === "waiting-on-agents";
-        if (store.hasOpenInputRequest(task.id)
-            || store.getLeaderFailure(task.id) !== null
-            || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
-            || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {
-            continue;
-        }
-        // Digest admission covers both an ownerless Task and a resource-queued
-        // Task with active siblings. The latter wakes only when capacity/deadline
-        // actionability changes, so repeated full scans remain silent.
-        if (projection.reason === "no-executor" || queuedAlongsideActiveSibling) {
-            if (admitOrphanWake(store, task.id, now) === "suppress")
-                continue;
-        }
-        const taskWorkspace = store.getTaskWorkspace(task.id);
-        if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
-            store.queueTaskProgress(task.id, "task-orphaned", now);
-        }
-        if (leaderMailbox?.processing !== null && leaderMailbox?.processing !== undefined) {
-            const recovered = store.releaseLeaderWakeupAndEnqueue === undefined
-                ? store.releaseWorkMailbox(leaderTarget, leaderMailbox.processing.batchId)
-                    && (queueLeaderWakeup(store, task.id, wakeReason("task-orphaned"), now), true)
-                : store.releaseLeaderWakeupAndEnqueue(task.id, leaderMailbox.processing.batchId, wakeReason("task-orphaned"), now);
-            if (recovered) {
-                repaired.push(task.id);
-            }
-            continue;
-        }
-        queueLeaderWakeup(store, task.id, wakeReason("task-orphaned"), now);
-        repaired.push(task.id);
-    }
-    return repaired;
-}
-/**
- * Decide whether one `task-orphaned` scan should wake the Leader. Returns
- * `"suppress"` without writing anything when the digest is unchanged since
- * the last waiting/blocked Leader Run. Computation errors fail open.
- */
-function admitOrphanWake(store, taskId, now) {
-    let digest;
-    try {
-        const input = collectTaskActionability(store, taskId, now);
-        digest = computeActionabilityDigest(input);
-    }
-    catch (error) {
-        // Fail open: wake once and record the computation error so the Task can
-        // never be silently starved by a broken projection.
-        store.queueTaskProgress(taskId, "actionability-unknown", new Date());
-        return "wake";
-    }
-    const lastLeaderRun = findLastLeaderRun(store, taskId);
-    const decision = decideOrphanWake({ currentDigest: digest, lastLeaderRun });
-    return decision.kind === "suppress" ? "suppress" : "wake";
-}
-/**
- * The most recent Leader Run (terminal or active). Active Runs are returned
- * so the admission check never suppresses while a Leader is still running.
- */
-function findLastLeaderRun(store, taskId) {
-    const runs = operationalTaskRecords(store.listAgentRuns?.(taskId) ?? [], store.listEvents?.(taskId) ?? [], "agent-run");
-    let latest = null;
-    for (const run of runs) {
-        if (run.roleName !== "leader")
-            continue;
-        if (latest === null || run.createdAt > latest.createdAt)
-            latest = run;
-    }
-    if (latest === null)
-        return null;
-    return {
-        status: latest.status,
-        ...(latest.disposition === undefined ? {} : { disposition: latest.disposition }),
-        ...(latest.observedActionabilityDigest === undefined
-            ? {}
-            : { observedActionabilityDigest: latest.observedActionabilityDigest })
-    };
-}
-function hasUnclaimedLeaderWork(store, taskId, leaderMailbox) {
-    if (store.getPendingWakeup(taskId) !== null)
-        return true;
-    if (leaderMailbox === null)
-        return false;
-    return leaderMailbox.processing === null
-        && (leaderMailbox.pending.normal !== null
-            || leaderMailbox.pending.userCorrection !== null);
-}

package/dist/storage/compatibleTaskStore.js

@@ -1,248 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { StorageCompatibilityError, loadCompatibleSnapshot } from "./migration/index.js";
-import { createProductionStorageRegistry } from "./migration/productionRegistry.js";
-import { FileTaskStore, STORAGE_STATE_FILE, stateFileFingerprint, StorageRecordError, validateCurrentStorageStateSnapshot } from "./taskStore.js";
-import { readSqliteHomeIdentity, SqliteTaskStore } from "./sqliteStore.js";
-import { COMMITTED_DATABASE_FILENAME } from "./upgrade/sqliteStateMigration.js";
-import { validateHomeIdentity } from "../repository/homeIdentity.js";
-import { CURRENT_STORAGE_LAYOUT_VERSION, ensureStorageSchema, inspectStorageSchema, readStorageSchemaManifest, STORAGE_SCHEMA_FILE } from "./storageSchema.js";
-import { classifyHome } from "./upgrade/homeClassification.js";
-import { inspectSnapshotVersionState } from "./upgrade/homeMigrationTarget.js";
-import { latestStorageVersionState } from "./upgrade/recordVersions.js";
-export { createProductionStorageRegistry } from "./migration/productionRegistry.js";
-/**
- * Initialize a brand-new Home with the current authoritative backend, or open
- * an existing Home through the same compatibility classification as every
- * ordinary command. Setup is the one ordinary flow that is also responsible
- * for creating the initial manifest.
- */
-export function initializeCompatibleTaskStore(home, options = {}) {
-    if (inspectStorageSchema(home).status === "uninitialized") {
-        ensureStorageSchema(home);
-        if (CURRENT_STORAGE_LAYOUT_VERSION >= 7) {
-            return new SqliteTaskStore(home);
-        }
-    }
-    return openCompatibleFileTaskStore(home, options);
-}
-/**
- * Open current or explicitly compatible-old storage. Compatible records are
- * normalized in memory through strict old-shape validators; FileTaskStore then
- * runs its one current parser and its existing writer emits only current bytes.
- *
- * A current Home is opened from a single fingerprint-fenced `state.json`
- * snapshot: the same bytes drive the record-version inspection, the strict
- * shape/reference validation, and the returned store's initial cache seed, so
- * the open never re-reads the (large) state merely to construct or first use
- * the store.
- */
-export function openCompatibleFileTaskStore(home, options = {}) {
-    const registry = options.registry ?? createProductionStorageRegistry();
-    const latest = options.latest ?? latestStorageVersionState();
-    const schema = inspectStorageSchema(home);
-    // Issue 01: a layout-7 Home's authoritative backend is SQLite WAL. When
-    // `yui.db` exists, open it directly — never fall back to a FileTaskStore
-    // over a `state.json` that the repair may already have archived.
-    if (!options.forceStateSource
-        &&
-            (schema.status === "current" || schema.status === "unsupported")
-        && schema.currentLayoutVersion >= 7
-        && existsSync(join(home, COMMITTED_DATABASE_FILENAME))) {
-        return new SqliteTaskStore(home);
-    }
-    if (schema.status === "current") {
-        return openCurrentFileTaskStore(home, latest);
-    }
-    const classification = classifyHome({ home, registry, latest });
-    switch (classification.classification.status) {
-        case "current":
-        case "needs-storage-repair":
-            // A pseudo-layout-7 Home whose aggregate axis is also older cannot be
-            // normalized in memory: the compatible loader (requireCompatibleStorageSchema)
-            // only bypasses record-axis mismatches, not aggregate/layout ones. Such a
-            // Home needs the offline migration path (repair + aggregate migration in
-            // one upgrade), so surface the same migration-required error the pure
-            // version classifier would have produced, rather than a lazy strict-schema
-            // error from the first store read.
-            if (classification.classification.status === "needs-storage-repair"
-                && classification.aggregateVersion !== undefined
-                && classification.aggregateVersion < latest.aggregate) {
-                throw new StorageCompatibilityError("Storage requires an offline migration. Re-run `yui update` when active Sessions are clear.");
-            }
-            // A pseudo-layout-7 Home (manifest 7, no yui.db) may also carry
-            // compatible-old record versions, so open with the same normalization
-            // path as `compatible-old` rather than the strict current gate.
-            return new FileTaskStore(home, {
-                normalizeState: (raw) => normalizeState(home, raw, registry, latest)
-            });
-        case "compatible-old":
-            return new FileTaskStore(home, {
-                normalizeState: (raw) => normalizeState(home, raw, registry, latest)
-            });
-        case "migration-required":
-            throw new StorageCompatibilityError("Storage requires an offline migration. Re-run `yui update` when active Sessions are clear.");
-        case "unsupported":
-            throw new StorageCompatibilityError(describeUnsupported(classification.classification));
-    }
-}
-/**
- * Read the one authoritative durable Home identity without creating runtime
- * state. SQLite is opened read-only; file-backed Homes read only the immutable
- * identity field, so an aggregate that requires offline migration can still
- * authenticate its already-running Controller before the migration stops it.
- */
-export function readCompatibleHomeIdentity(home, options = {}) {
-    const schema = inspectStorageSchema(home);
-    if (!options.forceStateSource
-        && (schema.status === "current" || schema.status === "unsupported")
-        && schema.currentLayoutVersion >= 7
-        && existsSync(join(home, COMMITTED_DATABASE_FILENAME))) {
-        return readSqliteHomeIdentity(home, COMMITTED_DATABASE_FILENAME);
-    }
-    if (!existsSync(join(home, STORAGE_STATE_FILE))) {
-        throw new StorageRecordError("Durable Home identity is missing.");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(join(home, STORAGE_STATE_FILE), "utf8"));
-    }
-    catch {
-        throw new StorageRecordError("Durable Home identity state is invalid JSON.");
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new StorageRecordError("Durable Home identity state is invalid.");
-    }
-    try {
-        return validateHomeIdentity(parsed.homeIdentity);
-    }
-    catch {
-        throw new StorageRecordError("Durable Home identity is invalid.");
-    }
-}
-/**
- * The one-snapshot open for a Home whose manifest is already current. A single
- * fingerprint-fenced read of `state.json` supplies:
- *  - the record-version inspection (structural scan cross-checked against the
- *    durable manifest, never the strict loader),
- *  - the strict shape/reference validation (the store's own parser, run while
- *    seeding its cache), and
- *  - the returned store's initial cache seed under the same fingerprint.
- *
- * A fingerprint that drifts across the read retries once and then fails
- * closed; a later external writer still invalidates the seeded cache on the
- * store's next read. Corruption surfaces as the same `StorageCompatibilityError`
- * diagnosis the classifier produced before this fast path existed.
- */
-function openCurrentFileTaskStore(home, latest) {
-    const statePath = join(home, STORAGE_STATE_FILE);
-    if (!existsSync(statePath)) {
-        // No state.json yet: the store's own missing-file path seeds an empty
-        // state without reading anything.
-        return new FileTaskStore(home);
-    }
-    const manifest = readStorageSchemaManifest(home);
-    const snapshot = readFingerprintFencedState(statePath);
-    let parsed;
-    try {
-        parsed = JSON.parse(snapshot.raw);
-    }
-    catch (error) {
-        throw new StorageCompatibilityError(`Invalid state.json: state.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!isRecord(parsed)) {
-        throw new StorageCompatibilityError("Invalid state.json: state.json is not a JSON object.");
-    }
-    const inspection = inspectSnapshotVersionState(Object.freeze({ schemaManifest: manifest, state: parsed }), latest);
-    if ("corruption" in inspection) {
-        throw new StorageCompatibilityError(`Invalid state.json: ${inspection.corruption.detail}`);
-    }
-    try {
-        return new FileTaskStore(home, {
-            initialStateSnapshot: { fingerprint: snapshot.fingerprint, raw: snapshot.raw }
-        });
-    }
-    catch (error) {
-        if (error instanceof StorageRecordError) {
-            throw new StorageCompatibilityError(`Invalid state.json: ${error.message}`);
-        }
-        throw error;
-    }
-}
-/**
- * Read `state.json` once, fenced by the same fingerprint the store's read cache
- * is keyed on. A fingerprint that changes between the before and after stat
- * means a concurrent writer is mid-update: retry once (bounded), then fail
- * closed rather than seed a store from bytes that may be torn.
- */
-export function readFingerprintFencedState(statePath, io = {}) {
-    const fingerprint = io.fingerprint ?? stateFileFingerprint;
-    const read = io.read ?? ((path) => readFileSync(path, "utf8"));
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const before = fingerprint(statePath);
-        const raw = read(statePath);
-        const after = fingerprint(statePath);
-        if (before === after)
-            return { raw, fingerprint: after };
-    }
-    throw new StorageCompatibilityError("state.json changed while opening; a concurrent writer is updating the Home. Retry the command.");
-}
-/**
- * Eagerly prove that a compatible-old Home reaches the strict current parser.
- * Staged update/upgrade preflight uses this before any Controller or binary
- * action; ordinary commands may keep the store's normal lazy-read behavior.
- */
-export function validateCompatibleFileTaskStore(home, options = {}) {
-    openCompatibleFileTaskStore(home, { ...options, forceStateSource: true }).getConfig();
-}
-function normalizeState(home, raw, registry, latest) {
-    let state;
-    try {
-        state = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new StorageCompatibilityError(`Compatible state is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!isRecord(state)) {
-        throw new StorageCompatibilityError("Compatible state must be a JSON object.");
-    }
-    const schemaManifest = JSON.parse(readFileSync(join(home, STORAGE_SCHEMA_FILE), "utf8"));
-    if (!isRecord(schemaManifest)) {
-        throw new StorageCompatibilityError("Compatible schema manifest must be a JSON object.");
-    }
-    const snapshot = { schemaManifest, state };
-    const source = versionsOf(snapshot, latest);
-    const normalized = loadCompatibleSnapshot({
-        registry,
-        source,
-        latest,
-        snapshot,
-        inspectVersions: (candidate) => versionsOf(candidate, latest),
-        validateCurrent: (candidate) => {
-            if (candidate.state === null) {
-                throw new StorageCompatibilityError("Compatible state unexpectedly disappeared.");
-            }
-            validateCurrentStorageStateSnapshot(candidate.state);
-        }
-    });
-    return `${JSON.stringify(normalized.state)}\n`;
-}
-function versionsOf(snapshot, latest) {
-    const inspection = inspectSnapshotVersionState(snapshot, latest);
-    if ("corruption" in inspection) {
-        throw new StorageCompatibilityError(inspection.corruption.detail);
-    }
-    return inspection.source;
-}
-function describeUnsupported(classification) {
-    if (classification.verdict === "CORRUPTED") {
-        return `Invalid state.json: ${classification.detail}`;
-    }
-    if (classification.verdict === "NEEDS_NEW_VERSION") {
-        return classification.blocker.message;
-    }
-    return "Storage is unsupported by this Yui release.";
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/storage/migration/baseline.js

@@ -1,78 +0,0 @@
-import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storageVersions.js";
-import { currentRecordVersions } from "../upgrade/recordVersions.js";
-export const BASELINE_STORAGE_LAYOUT_VERSION = 6;
-export const BASELINE_AGGREGATE_SCHEMA_VERSION = 16;
-const BASELINE_RECORD_DESCRIPTORS = Object.freeze({
-    config: descriptor(1, "state.json#/config"),
-    configuredAgent: descriptor(2, "state.json#/configuredAgents"),
-    project: descriptor(2, "state.json#/projects"),
-    agentProfile: descriptor(2, "state.json#/agentProfiles"),
-    globalRole: descriptor(3, "state.json#/globalRoles"),
-    globalRoleSessionSet: descriptor(3, "state.json#/globalRoleSessionSets"),
-    storedTask: descriptor(14, "state.json#/tasks/*"),
-    task: descriptor(3, "state.json#/tasks/*/task"),
-    taskBrief: descriptor(2, "state.json#/tasks/*/brief"),
-    taskRole: descriptor(3, "state.json#/tasks/*/roles"),
-    managedWorkspace: descriptor(1, "state.json#/tasks/*/managedWorkspaces"),
-    taskRoleSessionSet: descriptor(4, "state.json#/tasks/*/roleSessionSets"),
-    workItem: descriptor(6, "state.json#/tasks/*/workItems"),
-    agentRun: descriptor(5, "state.json#/tasks/*/agentRuns"),
-    reviewRound: descriptor(2, "state.json#/tasks/*/reviewRounds"),
-    changeSet: descriptor(2, "state.json#/tasks/*/changeSets"),
-    integrationAttempt: descriptor(2, "state.json#/tasks/*/integrationAttempts"),
-    activeRunPointer: descriptor(1, "state.json#/tasks/*/activeRuns"),
-    message: descriptor(2, "state.json#/tasks/*/messages"),
-    inputRequest: descriptor(2, "state.json#/tasks/*/inputRequests"),
-    decision: descriptor(1, "state.json#/tasks/*/decisions"),
-    milestone: descriptor(1, "state.json#/tasks/*/milestones"),
-    event: descriptor(2, "state.json#/tasks/*/events"),
-    leaderFailure: descriptor(1, "state.json#/tasks/*/leaderFailure"),
-    operatorNotification: descriptor(1, "state.json#/tasks/*/operatorNotification"),
-    workMailbox: descriptor(1, "state.json#/mailboxes")
-});
-/** Frozen baseline record-family version map retained as a public delivery contract. */
-export const BASELINE_RECORD_VERSIONS = Object.freeze(Object.fromEntries(Object.entries(BASELINE_RECORD_DESCRIPTORS).map(([kind, entry]) => [kind, entry.version])));
-export function baselineStorageVersionState() {
-    return Object.freeze({
-        layout: BASELINE_STORAGE_LAYOUT_VERSION,
-        aggregate: BASELINE_AGGREGATE_SCHEMA_VERSION,
-        record: Object.freeze({ ...BASELINE_RECORD_DESCRIPTORS })
-    });
-}
-/** Constant spelling used by delivery-gate callers and historical tests. */
-export const BASELINE_STORAGE_VERSION_STATE = baselineStorageVersionState();
-/**
- * Fail the delivery gate if the immutable baseline is ahead of the live schema,
- * loses a record family, or changes a locator without an explicit scalar
- * storage boundary. The production registry gate separately proves the full
- * executable baseline-to-current transition path.
- */
-export function assertBaselineConsistency(current = {
-    layout: CURRENT_STORAGE_LAYOUT_VERSION,
-    aggregate: CURRENT_AGGREGATE_SCHEMA_VERSION,
-    record: currentRecordVersions()
-}) {
-    if (BASELINE_STORAGE_LAYOUT_VERSION > current.layout) {
-        throw new Error(`Baseline layout ${BASELINE_STORAGE_LAYOUT_VERSION} exceeds current layout ${current.layout}.`);
-    }
-    if (BASELINE_AGGREGATE_SCHEMA_VERSION > current.aggregate) {
-        throw new Error(`Baseline aggregate ${BASELINE_AGGREGATE_SCHEMA_VERSION} exceeds current aggregate ${current.aggregate}.`);
-    }
-    const scalarVersionAdvanced = current.layout > BASELINE_STORAGE_LAYOUT_VERSION
-        || current.aggregate > BASELINE_AGGREGATE_SCHEMA_VERSION;
-    for (const [kind, baselineEntry] of Object.entries(BASELINE_RECORD_DESCRIPTORS)) {
-        const currentEntry = current.record[kind];
-        if (!Number.isSafeInteger(baselineEntry.version) || baselineEntry.version < 1) {
-            throw new Error(`Baseline record family '${kind}' has invalid version ${String(baselineEntry.version)}.`);
-        }
-        if (currentEntry === undefined || baselineEntry.version > currentEntry.version) {
-            throw new Error(`Baseline record family '${kind}' is ahead of or missing from current.`);
-        }
-        if (baselineEntry.path !== currentEntry.path && !scalarVersionAdvanced) {
-            throw new Error(`Baseline record family '${kind}' path drift requires a layout or aggregate version change.`);
-        }
-    }
-}
-function descriptor(version, path) {
-    return Object.freeze({ version, path });
-}

package/dist/storage/migration/classifier.js

@@ -1,51 +0,0 @@
-/**
- * The pure four-state compatibility classifier.
- *
- * Given the source and target (latest-supported) version states, an EMPTY-or-
- * populated registry, and an optional caller-supplied corruption signal, it
- * returns exactly one verdict:
- *
- * - `USABLE`            — every axis is already at the current version.
- * - `COMPATIBLE`        — strictly older record axes whose complete adjacent
- *   path consists only of compatible normalizations.
- * - `MIGRATABLE`        — at least one adjacent hop requires offline migration,
- *   and every axis has a complete deterministic path.
- * - `NEEDS_NEW_VERSION` — any axis is newer than supported (`future-version`),
- *   or older with a broken/absent step path (`missing-step`). Carries a precise
- *   reason + action. Under an EMPTY registry, any strictly-older version lands
- *   here via a missing transition contract.
- * - `CORRUPTED`         — only when the caller reports real JSON/structural/
- *   reference-invariant damage. The classifier never infers corruption from
- *   version numbers.
- *
- * There are no baseline/pre-release special cases: compatibility is decided
- * solely by explicit registry step-paths, never by version magnitude or semver.
- */
-import { planMigration } from "./planner.js";
-/**
- * Classify a storage target. Pure: no I/O, no mutation, deterministic.
- *
- * `corruption` is supplied by the caller when parsing/structural/reference
- * validation has already failed; when present it takes precedence, because a
- * corrupted target's version numbers cannot be trusted.
- */
-export function classifyStorage(registry, source, target, corruption) {
-    if (corruption?.corrupted === true) {
-        return { verdict: "CORRUPTED", status: "unsupported", detail: corruption.detail };
-    }
-    const plan = planMigration(registry, source, target);
-    switch (plan.kind) {
-        case "no-op":
-            return { verdict: "USABLE", status: "current" };
-        case "runnable":
-            return plan.path === "compatible"
-                ? { verdict: "COMPATIBLE", status: "compatible-old", stepCount: plan.steps.length }
-                : { verdict: "MIGRATABLE", status: "migration-required", stepCount: plan.steps.length };
-        case "blocked":
-            return {
-                verdict: "NEEDS_NEW_VERSION",
-                status: "unsupported",
-                blocker: plan.blocker
-            };
-    }
-}

package/dist/storage/migration/compatibleCodec.js

@@ -1,53 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import { planMigration } from "./planner.js";
-export class StorageCompatibilityError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "StorageCompatibilityError";
-    }
-}
-/**
- * Apply an all-compatible declaration chain in memory. This never writes the
- * source. It rejects offline paths, missing declarations/steps, non-fresh
- * normalizers, and output which does not pass the strict current-model gate.
- */
-export function loadCompatibleSnapshot(options) {
-    const plan = planMigration(options.registry, options.source, options.latest);
-    if (plan.kind === "blocked") {
-        throw new StorageCompatibilityError(plan.blocker.message);
-    }
-    if (plan.kind === "runnable" && plan.path !== "compatible") {
-        throw new StorageCompatibilityError("Storage requires an offline migration and cannot be normalized by the compatible loader.");
-    }
-    let current = options.snapshot;
-    if (plan.kind === "runnable") {
-        for (const planned of plan.steps) {
-            planned.step.preconditions(current);
-            const next = planned.step.transform(current);
-            if (next === current && typeof next === "object" && next !== null) {
-                throw new StorageCompatibilityError(`Compatible normalizer ${planned.axis}` +
-                    `${planned.recordKind ? `/${planned.recordKind}` : ""} ` +
-                    `${planned.fromVersion}->${planned.toVersion} returned its input object.`);
-            }
-            current = next;
-        }
-    }
-    assertCurrentVersions(options.inspectVersions(current), options.latest, "normalized model");
-    options.validateCurrent(current);
-    return current;
-}
-/**
- * Encode only the current record contract. There is intentionally no old
- * writer or dual-write branch: a non-current encoding fails before persistence.
- */
-export function writeCurrentSnapshot(options) {
-    const snapshot = options.encode(options.model);
-    assertCurrentVersions(options.inspectVersions(snapshot), options.latest, "writer output");
-    options.validateCurrent(snapshot);
-    return snapshot;
-}
-function assertCurrentVersions(actual, latest, label) {
-    if (!isDeepStrictEqual(actual, latest)) {
-        throw new StorageCompatibilityError(`Compatible ${label} is not at the current storage versions; old-version writing is forbidden.`);
-    }
-}