@zq-silk/yui 0.13.9 → 0.14.0

package/dist/storage/migration/registry.js

@@ -1,169 +0,0 @@
-/**
- * The central migration registry.
- *
- * Declarations and offline transforms are discoverable strictly by
- * `axis + (recordKind) + fromVersion`. There is no version-magnitude or semver
- * guessing: only an explicitly declared chain of adjacent transitions is
- * usable. A fresh registry is EMPTY, so every older version fails closed until
- * its compatible normalization or offline migration is authored explicitly.
- */
-export class MigrationRegistryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "MigrationRegistryError";
-    }
-}
-/**
- * Explicit key-field delimiter: the ASCII Unit Separator (U+001F), built with
- * `String.fromCharCode` so this source file stays pure printable ASCII (no raw
- * control byte embedded in the text). The Unit Separator never appears in an
- * `axis` literal, a `recordKind`, or a decimal version, so the three key fields
- * cannot run together and the composite key is unambiguous.
- */
-const KEY_SEPARATOR = String.fromCharCode(0x1f);
-/**
- * Composite lookup key. The record axis includes its `recordKind`; the layout
- * and aggregate axes use a fixed sentinel so a single map serves all axes.
- */
-function stepKey(axis, recordKind, fromVersion) {
-    const family = axis === "record" ? requireRecordKind(recordKind) : "-";
-    return `${axis}${KEY_SEPARATOR}${family}${KEY_SEPARATOR}${fromVersion}`;
-}
-function requireRecordKind(recordKind) {
-    if (typeof recordKind !== "string" || recordKind.trim().length === 0) {
-        throw new MigrationRegistryError("A record-axis migration step must declare a non-empty recordKind.");
-    }
-    return recordKind;
-}
-/**
- * A discoverable set of adjacent migration steps. Register at most one step per
- * `(axis, recordKind, fromVersion)`; lookup returns only that exact adjacent
- * step (or `undefined`) — it never infers a step from version ordering.
- */
-export class MigrationRegistry {
-    #steps = new Map();
-    #declarations = new Map();
-    /** Backward-compatible spelling: explicitly registers one offline transition and its transform. */
-    register(step) {
-        this.#validateMigrationStep(step);
-        const key = stepKey(step.axis, step.recordKind, step.fromVersion);
-        this.#assertDeclarationAvailable(step, key);
-        this.#assertStepAvailable(step, key);
-        // Publish the declaration and transform together only after every check has
-        // passed. A rejected combined registration must not leave a newly-runnable
-        // half update behind in the registry.
-        this.#declarations.set(key, { ...step, kind: "offline-migration" });
-        this.#steps.set(key, step);
-        return this;
-    }
-    /** Explicitly register the declaration and transform for an offline change. */
-    registerOfflineMigration(step) {
-        return this.register(step);
-    }
-    /** Declare an offline change. A missing transform remains fail-closed. */
-    declareOfflineMigration(declaration) {
-        this.#validateCoordinates(declaration);
-        this.#registerDeclaration({ ...declaration, kind: "offline-migration" });
-        return this;
-    }
-    /** Declare an online-compatible normalization with deterministic defaults. */
-    registerCompatible(step) {
-        const runtimeAxis = step.axis;
-        if (runtimeAxis !== "record") {
-            throw new MigrationRegistryError("A compatible transition must use the record axis; layout and aggregate changes require offline migration.");
-        }
-        this.#validateCoordinates(step);
-        if (!Array.isArray(step.defaults)
-            || step.defaults.length === 0
-            || step.defaults.some((value) => typeof value !== "string" || value.trim().length === 0)) {
-            throw new MigrationRegistryError("A compatible transition must declare at least one deterministic default or rebuild rule.");
-        }
-        if (typeof step.normalize !== "function" || typeof step.validateSource !== "function") {
-            throw new MigrationRegistryError("A compatible transition must provide a strict source validator and normalizer.");
-        }
-        this.#registerDeclaration({ ...step, kind: "compatible" });
-        return this;
-    }
-    /** Register a transform without inferring its operational declaration. */
-    registerMigrationStep(step) {
-        this.#validateMigrationStep(step);
-        const key = stepKey(step.axis, step.recordKind, step.fromVersion);
-        this.#assertStepAvailable(step, key);
-        this.#steps.set(key, step);
-        return this;
-    }
-    #validateMigrationStep(step) {
-        this.#validateCoordinates(step);
-        if (!Array.isArray(step.declaredEffects)
-            || typeof step.transform !== "function"
-            || typeof step.preconditions !== "function") {
-            throw new MigrationRegistryError("A migration step must provide its transform contract.");
-        }
-    }
-    #assertStepAvailable(step, key) {
-        if (!this.#steps.has(key))
-            return;
-        throw new MigrationRegistryError(`A migration step is already registered for ${step.axis}` +
-            `${step.recordKind ? `/${step.recordKind}` : ""} ${step.fromVersion}->${step.toVersion}.`);
-    }
-    #assertDeclarationAvailable(declaration, key) {
-        if (!this.#declarations.has(key))
-            return;
-        throw new MigrationRegistryError(`A transition is already registered for ${declaration.axis}` +
-            `${declaration.recordKind ? `/${declaration.recordKind}` : ""} ` +
-            `${declaration.fromVersion}->${declaration.toVersion}.`);
-    }
-    #validateCoordinates(step) {
-        if (step.axis === "record") {
-            requireRecordKind(step.recordKind);
-        }
-        else if (step.recordKind !== undefined) {
-            throw new MigrationRegistryError(`A ${step.axis}-axis transition must not declare a recordKind.`);
-        }
-        if (!Number.isSafeInteger(step.fromVersion) || step.fromVersion < 0) {
-            throw new MigrationRegistryError(`Transition fromVersion must be a non-negative integer: ${String(step.fromVersion)}.`);
-        }
-        if (step.fromVersion === 0) {
-            if (step.axis !== "record" || step.introduction !== true || step.toVersion !== 1) {
-                throw new MigrationRegistryError("Only an explicit record-family introduction may use the 0->1 transition.");
-            }
-        }
-        else if (step.introduction === true) {
-            throw new MigrationRegistryError("A record-family introduction must be the explicit 0->1 transition.");
-        }
-        if (step.toVersion !== step.fromVersion + 1) {
-            throw new MigrationRegistryError(`Transitions must be adjacent and one-directional: ${step.axis}` +
-                `${step.recordKind ? `/${step.recordKind}` : ""} ${step.fromVersion}->${step.toVersion} ` +
-                `(expected ${step.fromVersion}->${step.fromVersion + 1}).`);
-        }
-    }
-    #registerDeclaration(declaration) {
-        const key = stepKey(declaration.axis, declaration.recordKind, declaration.fromVersion);
-        this.#assertDeclarationAvailable(declaration, key);
-        this.#declarations.set(key, declaration);
-    }
-    /** Look up the exact adjacent step advancing `fromVersion -> fromVersion + 1`. */
-    lookup(axis, recordKind, fromVersion) {
-        return this.#steps.get(stepKey(axis, recordKind, fromVersion));
-    }
-    /** Look up the exact compatible/offline declaration for one adjacent change. */
-    lookupDeclaration(axis, recordKind, fromVersion) {
-        return this.#declarations.get(stepKey(axis, recordKind, fromVersion));
-    }
-    /** Total number of declared adjacent transitions (0 for an EMPTY registry). */
-    get size() {
-        return this.#declarations.size;
-    }
-    /** True when neither declarations nor offline transforms are registered. */
-    isEmpty() {
-        return this.#declarations.size === 0 && this.#steps.size === 0;
-    }
-}
-/**
- * Create a fresh, EMPTY registry for isolated planning or callers that
- * authorize no transitions. Production wiring builds its explicit graph in a
- * separate factory.
- */
-export function createEmptyRegistry() {
-    return new MigrationRegistry();
-}

package/dist/storage/migration/report.js

@@ -1,54 +0,0 @@
-/**
- * Pure helpers for building and describing {@link MigrationReport}s.
- *
- * These never perform I/O and never interpret domain data — they only shape the
- * structured evidence the engine emits.
- */
-/** Reduce a planned step to the concise summary carried in reports. */
-export function toStepSummary(planned) {
-    return {
-        axis: planned.axis,
-        ...(planned.recordKind ? { recordKind: planned.recordKind } : {}),
-        fromVersion: planned.fromVersion,
-        toVersion: planned.toVersion,
-        transition: planned.transition,
-        declaredEffects: planned.step.declaredEffects
-    };
-}
-/**
- * The de-duplicated union of every planned step's declared effects, in
- * first-seen deterministic order. This is exactly what the engine forwards to
- * the injected `rebuildDerivedState` — the generic core keeps no domain list.
- */
-export function collectEffects(steps) {
-    const seen = new Set();
-    const effects = [];
-    for (const planned of steps) {
-        for (const effect of planned.step.declaredEffects) {
-            if (!seen.has(effect)) {
-                seen.add(effect);
-                effects.push(effect);
-            }
-        }
-    }
-    return effects;
-}
-/** A short, human-readable one-line description of a report outcome. */
-export function describeReport(report) {
-    switch (report.outcome) {
-        case "already-current":
-            return "Storage is already at the current version; nothing to migrate.";
-        case "blocked":
-            return `Migration blocked (${report.blocker.reason}): ${report.blocker.message} ${report.blocker.action}`;
-        case "active-runtime":
-            return `Migration refused: a live runtime is active${report.detail ? ` (${report.detail})` : ""}.`;
-        case "dry-run":
-            return `Dry run validated ${report.steps.length} step(s); fresh output discarded, source unchanged.`;
-        case "migrated":
-            return `Migrated through ${report.steps.length} step(s); source backed up at ${report.switch.backupPath ?? "(unspecified)"}.`;
-        case "failed":
-            return `Migration failed at ${report.stage}: ${report.error} Source is unchanged; delete any partial output and retry.`;
-        case "switch-ambiguous":
-            return `Migration switch is AMBIGUOUS: ${report.error} Recover from the backup at ${report.backupPath}.`;
-    }
-}

package/dist/storage/migration/types.js

@@ -1,31 +0,0 @@
-/**
- * Generic, pure migration-core vocabulary.
- *
- * This module is deliberately domain-agnostic: it knows about three independent
- * monotonic version axes and how to chain adjacent steps, but it never encodes a
- * list of concrete Yui records, derived-state fields, or reference invariants.
- * Those live behind the injected {@link MigrationTarget} boundary so a new record
- * family can be added without editing the generic engine.
- */
-/**
- * Thrown by a target's `atomicSwitchWithBackup` when the switch is left in a
- * partially-applied, ambiguous state (the original was moved aside but the
- * promotion and its rollback both failed). It carries the exact recovery path so
- * the orchestrator can report a truthful, actionable manual recovery rather than
- * a false "the Home is unchanged".
- */
-export class AmbiguousSwitchError extends Error {
-    /** The logical Home path that is now partially switched. */
-    homePath;
-    /** Where the original Home currently lives (the recovery source). */
-    backupPath;
-    /** The staged output that was not promoted. */
-    stagingPath;
-    constructor(options) {
-        super(options.detail);
-        this.name = "AmbiguousSwitchError";
-        this.homePath = options.homePath;
-        this.backupPath = options.backupPath;
-        this.stagingPath = options.stagingPath;
-    }
-}

package/dist/storage/upgrade/homeClassification.js

@@ -1,353 +0,0 @@
-/**
- * Four-state classification of a real Yui Home.
- *
- * This layers real, I/O-based corruption detection onto the pure WI-3
- * classifier. It reports exactly one shared product state — current,
- * compatible-old, migration-required, or unsupported — together with the
- * on-disk layout and aggregate versions and, when the store cannot be used, the
- * incompatible component (layout vs aggregate).
- *
- * Corruption is only ever reported from a *real* structural failure: a
- * `state.json` that is not parseable / not shaped like the record locators
- * describe / carries a record with an invalid `schemaVersion`, a broken reference
- * graph (detected by the strict loader once every axis is already current), or a
- * `schema.json` manifest that is not valid. It is never inferred from version
- * magnitude. An older or newer version — on ANY axis, including a single older
- * record family — is a version verdict (`COMPATIBLE` for an all-compatible path,
- * `MIGRATABLE` for an offline path, otherwise `NEEDS_NEW_VERSION`), never
- * `CORRUPTED`. An older Home without a complete declared path fails closed with
- * a precise missing declaration/step reason.
- *
- * The three axes are independent: record versions come from the durable
- * manifest and raw `state.json` is traversed structurally only to verify that
- * non-empty families agree. This keeps a record-only-older Home on its version
- * axis without letting an empty target family masquerade as current.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import Database from "better-sqlite3";
-import { classifyStorage } from "../migration/index.js";
-import { inspectStorageSchema } from "../storageSchema.js";
-import { FileTaskStore, STORAGE_STATE_FILE, StorageRecordError } from "../taskStore.js";
-import { SqliteTaskStore } from "../sqliteStore.js";
-import { inspectSqliteSchemaMigrations } from "../sqliteSchema.js";
-import { inspectSourceVersionState } from "./homeMigrationTarget.js";
-import { readMigrationReceipt } from "./migrationReceipt.js";
-/**
- * Classify a real Home. Reads `schema.json` (and, for a current Home,
- * `state.json` through the strict loader) read-only; never mutates the Home.
- */
-export function classifyHome(options) {
-    const { home, registry, latest } = options;
-    const schema = inspectStorageSchema(home);
-    const base = {
-        latestLayoutVersion: latest.layout,
-        latestAggregateVersion: latest.aggregate
-    };
-    if (schema.status === "uninitialized") {
-        return {
-            ...base,
-            classification: { verdict: "USABLE", status: "current" },
-            uninitialized: true
-        };
-    }
-    if (schema.status === "invalid") {
-        // A malformed manifest is real structural damage, not a version verdict.
-        return {
-            ...base,
-            classification: {
-                verdict: "CORRUPTED",
-                status: "unsupported",
-                detail: `Storage schema manifest is invalid: ${schema.detail}`
-            }
-        };
-    }
-    // Read all three durable axes read-only, then structurally cross-check raw
-    // state.json without invoking the strict current loader. Version differences
-    // remain version facts; manifest/state contradictions surface as corruption.
-    const inspected = inspectSourceVersionState(home, latest);
-    if ("corruption" in inspected) {
-        return {
-            ...base,
-            classification: {
-                verdict: "CORRUPTED",
-                status: "unsupported",
-                detail: inspected.corruption.detail
-            },
-            layoutVersion: schema.currentLayoutVersion,
-            aggregateVersion: schema.currentAggregateSchemaVersion,
-            ...(incompatibleComponentOf(schema) === undefined
-                ? {}
-                : { incompatibleComponent: incompatibleComponentOf(schema) })
-        };
-    }
-    const source = inspected.source;
-    // Layout 7 physical-backend invariant (Issue 01): the manifest claims SQLite
-    // WAL as the authoritative store, so `yui.db` must exist and be healthy. A
-    // layout-7 Home without `yui.db` is a *pseudo-layout-7* Home — repairable
-    // when `state.json` is strictly readable, corrupted otherwise. A Home with
-    // both `state.json` and `yui.db` but no persistent migration receipt is an
-    // ambiguous dual-copy conflict. These are physical-backend facts, not
-    // version verdicts, so they are decided before the pure classifier runs.
-    //
-    // The invariant binds a Home whose *layout* is current (7), regardless of
-    // whether the record/aggregate axes are also current. A layout-7 Home with
-    // older record versions and no yui.db is still a pseudo-layout-7 Home: it
-    // needs the state.json→SQLite repair first, then the record-family migration
-    // (multi-phase orchestration in the upgrade executor). Routing it to the
-    // pure version classifier would select the SQLite record target, which
-    // cannot read a yui.db that does not exist yet. A Home with an older/future
-    // *layout* is fenced by version policy below, as before.
-    if (schema.currentLayoutVersion === latest.layout && latest.layout >= 7) {
-        const physical = inspectLayout7PhysicalBackend(home);
-        if (physical !== undefined) {
-            return {
-                ...base,
-                classification: physical,
-                layoutVersion: schema.currentLayoutVersion,
-                aggregateVersion: schema.currentAggregateSchemaVersion,
-                ...(incompatibleComponentOf(schema) === undefined
-                    ? {}
-                    : { incompatibleComponent: incompatibleComponentOf(schema) })
-            };
-        }
-    }
-    // Once the logical Home axes are current, the SQLite ledger is the only
-    // remaining upgrade coordinate. A valid applied prefix with pending entries
-    // is upgradeable in place, not corruption and not a reason to rebuild the
-    // database. Ordinary store opens still validate-and-refuse this state; only
-    // the explicit updater is allowed to apply it.
-    if (schema.status === "current"
-        && schema.currentLayoutVersion >= 7
-        && isFullyCurrent(source, latest)) {
-        let sqliteMigration;
-        try {
-            sqliteMigration = inspectLayout7SqliteMigrations(home);
-        }
-        catch (error) {
-            return {
-                ...base,
-                classification: {
-                    verdict: "CORRUPTED",
-                    status: "unsupported",
-                    detail: error instanceof Error ? error.message : String(error)
-                },
-                layoutVersion: schema.currentLayoutVersion,
-                aggregateVersion: schema.currentAggregateSchemaVersion
-            };
-        }
-        if (sqliteMigration.pendingVersions.length > 0) {
-            return {
-                ...base,
-                classification: {
-                    verdict: "MIGRATABLE",
-                    status: "migration-required",
-                    stepCount: sqliteMigration.pendingVersions.length
-                },
-                layoutVersion: schema.currentLayoutVersion,
-                aggregateVersion: schema.currentAggregateSchemaVersion,
-                sqliteMigration
-            };
-        }
-    }
-    // The reference graph can only be validated by the strict loader, which only
-    // understands the current versions. So run it exactly when every axis is
-    // already current (the plan would be a no-op); a throw there is genuine
-    // structural/reference corruption, never a version mismatch. An older/newer
-    // axis skips the loader and is decided purely by the planner below.
-    //
-    // Crucially, the strict loader is ONLY invoked when the manifest itself is
-    // `current`. An `unsupported` manifest (e.g. a pre-baseline Home with no
-    // recordVersions field) must never reach FileTaskStore: requireStorageSchema
-    // would throw StorageSchemaError, which doctor/upgrade must surface as a
-    // structured NEEDS_NEW_VERSION verdict, not as an invalid/corruption error.
-    const corruption = (schema.status === "current" && isFullyCurrent(source, latest))
-        ? detectCurrentHomeCorruption(home)
-        : undefined;
-    const classification = classifyStorage(registry, source, latest, corruption);
-    return {
-        ...base,
-        classification,
-        layoutVersion: schema.currentLayoutVersion,
-        aggregateVersion: schema.currentAggregateSchemaVersion,
-        ...(incompatibleComponentOf(schema) === undefined
-            ? {}
-            : { incompatibleComponent: incompatibleComponentOf(schema) })
-    };
-}
-function inspectLayout7SqliteMigrations(home) {
-    const db = new Database(join(home, "yui.db"), {
-        readonly: true,
-        fileMustExist: true
-    });
-    try {
-        db.pragma("query_only = ON");
-        return inspectSqliteSchemaMigrations(db);
-    }
-    finally {
-        db.close();
-    }
-}
-/**
- * Load a Home whose every axis is already current through the strict store
- * gate to detect real structural/reference corruption. This is only ever
- * called when the source equals `latest` across all three axes, so a version
- * error cannot occur here and any throw is genuine corruption (bad record
- * shape, a broken reference graph, or a damaged SQLite database).
- *
- * A layout-7 Home whose authoritative store is `yui.db` is verified through
- * {@link SqliteTaskStore}; a layout-7 Home that still uses the aggregate
- * `state.json` (or a layout-6 Home in tests) is verified through
- * {@link FileTaskStore}.
- */
-function detectCurrentHomeCorruption(home) {
-    try {
-        if (existsSync(`${home}/yui.db`)) {
-            const store = new SqliteTaskStore(home);
-            try {
-                store.getConfig();
-                store.listTasks();
-                store.listProjects();
-                store.listConfiguredAgents();
-                store.listWorkMailboxes();
-            }
-            finally {
-                store.close();
-            }
-        }
-        else {
-            const store = new FileTaskStore(home);
-            store.getConfig();
-            store.listTasks();
-            store.listProjects();
-            store.listConfiguredAgents();
-            store.listWorkMailboxes();
-        }
-        return undefined;
-    }
-    catch (error) {
-        if (error instanceof StorageRecordError) {
-            return { corrupted: true, detail: error.message };
-        }
-        // A SQLite-level error (corrupt database file, I/O fault) is structural
-        // damage, not a version mismatch.
-        if (error instanceof Error && (error.name === "SqliteError" || error.message.includes("SQLite"))) {
-            return { corrupted: true, detail: error.message };
-        }
-        // A non-record error (e.g. an unexpected I/O fault) is surfaced, not
-        // silently swallowed as "usable".
-        throw error;
-    }
-}
-/** True when the source is already at `latest` on every axis (a no-op plan). */
-function isFullyCurrent(source, latest) {
-    if (source.layout !== latest.layout || source.aggregate !== latest.aggregate) {
-        return false;
-    }
-    // Every family shared by source and target must already match; a family
-    // present on only one side is a difference the planner reasons about, not a
-    // "current" match, so it is not fully current.
-    const kinds = new Set([
-        ...Object.keys(source.record),
-        ...Object.keys(latest.record)
-    ]);
-    for (const kind of kinds) {
-        const from = source.record[kind]?.version;
-        const to = latest.record[kind]?.version;
-        if (from !== to)
-            return false;
-    }
-    return true;
-}
-function incompatibleComponentOf(schema) {
-    return schema.status === "unsupported" ? schema.incompatibleComponent : undefined;
-}
-/**
- * Inspect the physical-backend invariant of a layout-7 Home (Issue 01):
- * `yui.db` must exist and be healthy. Returns a classification verdict when
- * the invariant is violated, or `undefined` when the Home is physically sound
- * (the pure classifier then decides the version verdict).
- *
- *  - manifest=7, no `yui.db`, `state.json` strictly readable →
- *    `NEEDS_STORAGE_REPAIR` (pseudo-layout-7);
- *  - manifest=7, no `yui.db`, no readable `state.json` → `CORRUPTED`
- *    (no authoritative backend);
- *  - `yui.db` unopenable or failing `PRAGMA quick_check` → `CORRUPTED`
- *    (damaged database);
- *  - both `state.json` and `yui.db` without a persistent migration receipt →
- *    `CORRUPTED` (dual-copy conflict; never guess which copy is newer).
- */
-function inspectLayout7PhysicalBackend(home) {
-    const dbPath = join(home, "yui.db");
-    const statePath = join(home, STORAGE_STATE_FILE);
-    if (!existsSync(dbPath)) {
-        if (isReadableStateObject(statePath)) {
-            return {
-                verdict: "NEEDS_STORAGE_REPAIR",
-                status: "needs-storage-repair",
-                detail: "Storage declares layout 7 but has no yui.db; state.json is the only "
-                    + "authoritative copy (pseudo-layout-7). Run `yui upgrade` to rebuild "
-                    + "the SQLite database."
-            };
-        }
-        return {
-            verdict: "CORRUPTED",
-            status: "unsupported",
-            detail: "Storage declares layout 7 but has neither yui.db nor a readable "
-                + "state.json; there is no authoritative backend."
-        };
-    }
-    // `yui.db` exists: it must open and pass an integrity check.
-    try {
-        const db = new Database(dbPath, { readonly: true });
-        try {
-            const integrity = db.pragma("quick_check", { simple: true });
-            if (integrity !== "ok") {
-                return {
-                    verdict: "CORRUPTED",
-                    status: "unsupported",
-                    detail: `SQLite integrity check failed: ${String(integrity)}.`
-                };
-            }
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch (error) {
-        return {
-            verdict: "CORRUPTED",
-            status: "unsupported",
-            detail: `SQLite database cannot be opened: ${error instanceof Error ? error.message : String(error)}.`
-        };
-    }
-    // A healthy `yui.db` plus `state.json` is only legitimate right after a
-    // certified switch; without the persistent migration receipt it is a
-    // dual-copy conflict.
-    if (existsSync(statePath) && readMigrationReceipt(home) === null) {
-        return {
-            verdict: "CORRUPTED",
-            status: "unsupported",
-            detail: "Both state.json and yui.db exist without a migration receipt; the "
-                + "authoritative copy is ambiguous. Restore one copy from a backup; do "
-                + "not guess which is newer."
-        };
-    }
-    return undefined;
-}
-/** True when `state.json` exists and parses as a strict JSON object. */
-function isReadableStateObject(statePath) {
-    if (!existsSync(statePath))
-        return false;
-    try {
-        const value = JSON.parse(readFileSync(statePath, "utf8"));
-        return typeof value === "object" && value !== null && !Array.isArray(value);
-    }
-    catch {
-        return false;
-    }
-}
-/** A structural corruption check over an already-read snapshot (for tests/reports). */
-export function snapshotHasState(snapshot) {
-    return snapshot.state !== null;
-}