@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/unit/storage/goal-lifecycle-store.test.js

@@ -1,143 +0,0 @@
-/**
- * T-SMS.C.3 — GoalLifecycleStore 单元测试
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createGoalLifecycleStore } from "../../../src/storage/services/goal-lifecycle-store.js";
-describe("GoalLifecycleStore", () => {
-    it("upserts a goal and marks acknowledged", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createGoalLifecycleStore(db);
-        const goal = {
-            goalId: "g-1",
-            kind: "short_term",
-            scope: "global",
-            status: "accepted",
-            origin: "owner_set",
-            description: "Test goal",
-            completionCriteria: "Done",
-            risk: "low",
-            priorityHint: 1,
-            sourceRefs: ["ref:1"],
-            createdAt: "2026-05-21T00:00:00Z",
-            updatedAt: "2026-05-21T00:00:00Z",
-        };
-        const result = await store.upsertAgentGoal(goal);
-        assert.strictEqual(result.status, "acknowledged");
-        const loaded = await store.loadAgentGoal("g-1");
-        assert.ok(loaded);
-        assert.strictEqual(loaded.goalId, "g-1");
-        assert.strictEqual(loaded.status, "accepted");
-    });
-    it("replaces same kind+scope active goal (DR-014 replace semantics)", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createGoalLifecycleStore(db);
-        const oldGoal = {
-            goalId: "g-old",
-            kind: "short_term",
-            scope: "global",
-            status: "accepted",
-            origin: "owner_set",
-            description: "Old",
-            completionCriteria: "Done",
-            risk: "low",
-            priorityHint: 1,
-            sourceRefs: ["ref:1"],
-            createdAt: "2026-05-21T00:00:00Z",
-            updatedAt: "2026-05-21T00:00:00Z",
-        };
-        const newGoal = {
-            goalId: "g-new",
-            kind: "short_term",
-            scope: "global",
-            status: "accepted",
-            origin: "agent_proposed",
-            description: "New",
-            completionCriteria: "Done",
-            risk: "medium",
-            priorityHint: 2,
-            sourceRefs: ["ref:2"],
-            createdAt: "2026-05-21T00:00:00Z",
-            updatedAt: "2026-05-21T00:00:00Z",
-        };
-        await store.upsertAgentGoal(oldGoal);
-        await store.upsertAgentGoal(newGoal);
-        const oldLoaded = await store.loadAgentGoal("g-old");
-        assert.strictEqual(oldLoaded.status, "replaced");
-        const newLoaded = await store.loadAgentGoal("g-new");
-        assert.strictEqual(newLoaded.status, "accepted");
-    });
-    it("transitions paused → expired (DR-015)", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createGoalLifecycleStore(db);
-        const goal = {
-            goalId: "g-1",
-            kind: "short_term",
-            scope: "global",
-            status: "paused",
-            origin: "owner_set",
-            description: "Paused goal",
-            completionCriteria: "Done",
-            risk: "low",
-            priorityHint: 1,
-            sourceRefs: ["ref:1"],
-            createdAt: "2026-05-21T00:00:00Z",
-            updatedAt: "2026-05-21T00:00:00Z",
-        };
-        await store.upsertAgentGoal(goal);
-        const result = await store.transitionGoalLifecycle({
-            goalId: "g-1",
-            newStatus: "expired",
-            updatedAt: "2026-05-21T01:00:00Z",
-        });
-        assert.strictEqual(result.status, "acknowledged");
-        const loaded = await store.loadAgentGoal("g-1");
-        assert.strictEqual(loaded.status, "expired");
-    });
-    it("rejects invalid transition", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createGoalLifecycleStore(db);
-        const goal = {
-            goalId: "g-1",
-            kind: "short_term",
-            scope: "global",
-            status: "completed",
-            origin: "owner_set",
-            description: "Done",
-            completionCriteria: "Done",
-            risk: "low",
-            priorityHint: 1,
-            sourceRefs: ["ref:1"],
-            createdAt: "2026-05-21T00:00:00Z",
-            updatedAt: "2026-05-21T00:00:00Z",
-        };
-        await store.upsertAgentGoal(goal);
-        const result = await store.transitionGoalLifecycle({
-            goalId: "g-1",
-            newStatus: "accepted",
-            updatedAt: "2026-05-21T01:00:00Z",
-        });
-        assert.strictEqual(result.status, "degraded");
-    });
-    it("lists active goals", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createGoalLifecycleStore(db);
-        const g1 = {
-            goalId: "g-1", kind: "short_term", scope: "global", status: "accepted",
-            origin: "owner_set", description: "A", completionCriteria: "Done",
-            risk: "low", priorityHint: 1, sourceRefs: ["ref:1"],
-            createdAt: "2026-05-21T00:00:00Z", updatedAt: "2026-05-21T00:00:00Z",
-        };
-        const g2 = {
-            goalId: "g-2", kind: "long_term", scope: "global", status: "accepted",
-            origin: "owner_set", description: "B", completionCriteria: "Done",
-            risk: "low", priorityHint: 2, sourceRefs: ["ref:2"],
-            createdAt: "2026-05-21T00:00:00Z", updatedAt: "2026-05-21T00:00:00Z",
-        };
-        await store.upsertAgentGoal(g1);
-        await store.upsertAgentGoal(g2);
-        const active = await store.listActiveGoals();
-        assert.strictEqual(active.length, 2);
-    });
-});

package/dist/tests/unit/storage/history-digest-store.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * HistoryDigestStore tests — T-SMS.C.7
- *
- * Coverage:
- * - appendNarrativeTimeline is append-only (no overwrite)
- * - listNarrativeTimeline filters by subjectId
- * - writeHeartbeatDigest + loadHeartbeatDigest round-trip
- * - HeartbeatDigest day-keyed upsert semantics
- */
-export {};

package/dist/tests/unit/storage/history-digest-store.test.js

@@ -1,126 +0,0 @@
-/**
- * HistoryDigestStore tests — T-SMS.C.7
- *
- * Coverage:
- * - appendNarrativeTimeline is append-only (no overwrite)
- * - listNarrativeTimeline filters by subjectId
- * - writeHeartbeatDigest + loadHeartbeatDigest round-trip
- * - HeartbeatDigest day-keyed upsert semantics
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createHistoryDigestStore } from "../../../src/storage/services/history-digest-store.js";
-describe("HistoryDigestStore", () => {
-    it("appendNarrativeTimeline is append-only", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createHistoryDigestStore(db);
-        await store.appendNarrativeTimeline({
-            timelineId: "tl-1",
-            entryType: "mood_delta",
-            subjectId: "user-1",
-            delta: { mood: 0.8 },
-            previousHash: "h0",
-            currentHash: "h1",
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        await store.appendNarrativeTimeline({
-            timelineId: "tl-2",
-            entryType: "mood_delta",
-            subjectId: "user-1",
-            delta: { mood: 0.9 },
-            previousHash: "h1",
-            currentHash: "h2",
-            createdAt: "2025-01-02T00:00:00Z",
-        });
-        const all = await store.listNarrativeTimeline({ limit: 10 });
-        assert.strictEqual(all.length, 2);
-        assert.strictEqual(all[0].timelineId, "tl-2");
-        assert.strictEqual(all[1].timelineId, "tl-1");
-        db.close();
-    });
-    it("listNarrativeTimeline filters by subjectId", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createHistoryDigestStore(db);
-        await store.appendNarrativeTimeline({
-            timelineId: "tl-a",
-            entryType: "goal_created",
-            subjectId: "user-1",
-            delta: {},
-            previousHash: "",
-            currentHash: "ha",
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        await store.appendNarrativeTimeline({
-            timelineId: "tl-b",
-            entryType: "goal_created",
-            subjectId: "user-2",
-            delta: {},
-            previousHash: "",
-            currentHash: "hb",
-            createdAt: "2025-01-02T00:00:00Z",
-        });
-        const forUser1 = await store.listNarrativeTimeline({
-            subjectId: "user-1",
-            limit: 10,
-        });
-        assert.strictEqual(forUser1.length, 1);
-        assert.strictEqual(forUser1[0].subjectId, "user-1");
-        db.close();
-    });
-    it("writeHeartbeatDigest + loadHeartbeatDigest round-trip", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createHistoryDigestStore(db);
-        const digest = {
-            digestId: "hd-1",
-            day: "2025-01-15",
-            connectorSummary: [
-                { platformId: "twitter", status: "ok", attemptCount: 3 },
-            ],
-            goalSummary: [{ kind: "daily", activeCount: 2 }],
-            quietCount: 1,
-            dreamCount: 0,
-            breakerSummary: [],
-            healthStatus: "ok",
-            createdAt: "2025-01-15T23:59:59Z",
-        };
-        await store.writeHeartbeatDigest(digest);
-        const loaded = await store.loadHeartbeatDigest("2025-01-15");
-        assert.strictEqual(loaded.day, "2025-01-15");
-        assert.strictEqual(loaded.connectorSummary.length, 1);
-        assert.strictEqual(loaded.quietCount, 1);
-        assert.strictEqual(loaded.healthStatus, "ok");
-        db.close();
-    });
-    it("writeHeartbeatDigest upserts by day", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createHistoryDigestStore(db);
-        await store.writeHeartbeatDigest({
-            digestId: "hd-1",
-            day: "2025-01-15",
-            connectorSummary: [],
-            goalSummary: [],
-            quietCount: 1,
-            dreamCount: 0,
-            breakerSummary: [],
-            healthStatus: "ok",
-            createdAt: "2025-01-15T00:00:00Z",
-        });
-        await store.writeHeartbeatDigest({
-            digestId: "hd-2",
-            day: "2025-01-15",
-            connectorSummary: [],
-            goalSummary: [],
-            quietCount: 3,
-            dreamCount: 1,
-            breakerSummary: [],
-            healthStatus: "degraded",
-            createdAt: "2025-01-15T12:00:00Z",
-        });
-        const loaded = await store.loadHeartbeatDigest("2025-01-15");
-        assert.strictEqual(loaded.quietCount, 3);
-        assert.strictEqual(loaded.dreamCount, 1);
-        assert.strictEqual(loaded.healthStatus, "degraded");
-        db.close();
-    });
-});

package/dist/tests/unit/storage/identity-profile-store.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * T-SMS.C.4 — IdentityProfileStore 单元测试
- */
-export {};

package/dist/tests/unit/storage/identity-profile-store.test.js

@@ -1,48 +0,0 @@
-/**
- * T-SMS.C.4 — IdentityProfileStore 单元测试
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createIdentityProfileStore } from "../../../src/storage/services/identity-profile-store.js";
-describe("IdentityProfileStore", () => {
-    it("upserts and loads identity profile", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createIdentityProfileStore(db);
-        await store.upsertIdentityProfile({
-            profileId: "prof-1",
-            canonicalName: "Nyx",
-            canonicalBio: "Architect",
-            platformHandles: [
-                { platformId: "moltbook", handle: "nyx_ha" },
-                { platformId: "agent_world", handle: "haai-arch" },
-                { platformId: "instreet", handle: "haai_17949e" },
-            ],
-            updatedAt: "2026-05-21T00:00:00Z",
-        });
-        const result = await store.loadIdentityProfile("prof-1");
-        assert.strictEqual(result.status, "loaded");
-        if (result.status === "loaded") {
-            assert.strictEqual(result.profile.canonicalName, "Nyx");
-            assert.strictEqual(result.profile.platformHandles.length, 3);
-        }
-    });
-    it("returns degraded when platform missing", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createIdentityProfileStore(db);
-        await store.upsertIdentityProfile({
-            profileId: "prof-1",
-            canonicalName: "Nyx",
-            platformHandles: [{ platformId: "moltbook", handle: "nyx_ha" }],
-            updatedAt: "2026-05-21T00:00:00Z",
-        });
-        const result = await store.loadIdentityProfile("prof-1");
-        assert.strictEqual(result.status, "degraded");
-    });
-    it("returns not_found for unknown profile", async () => {
-        const db = createStateDatabase(":memory:");
-        const store = createIdentityProfileStore(db);
-        const result = await store.loadIdentityProfile("unknown");
-        assert.strictEqual(result.status, "not_found");
-    });
-});

package/dist/tests/unit/storage/life-evidence-snapshot.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/unit/storage/life-evidence-snapshot.test.js

@@ -1,60 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { appendLifeEvidence, loadLifeEvidenceSnapshot, loadContinuitySnapshot } from "../../../src/storage/index.js";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
-test("T4.2.1 loadLifeEvidenceSnapshot returns empty safe snapshot", async () => {
-    const state = createStateDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-snap-empty-"));
-    const snap = await loadLifeEvidenceSnapshot(state, ws, {});
-    assert.equal(snap.empty, true);
-    assert.equal(snap.platformEvents.length, 0);
-    assert.equal(snap.workEvents.length, 0);
-    state.close();
-});
-test("T4.2.1 loadLifeEvidenceSnapshot classifies platform vs work evidence", async () => {
-    const state = createStateDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-snap-mix-"));
-    await appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_browse",
-        summary: "browse",
-        sourceRefs: [{ id: "a", kind: "platform_item", uri: "p://a" }],
-        sensitivity: "public",
-        producer: "connector-system",
-    });
-    await appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "task_discovery",
-        summary: "task",
-        sourceRefs: [{ id: "b", kind: "platform_item", uri: "p://b" }],
-        sensitivity: "public",
-        producer: "connector-system",
-    });
-    const snap = await loadLifeEvidenceSnapshot(state, ws, { limit: 10 });
-    assert.equal(snap.empty, false);
-    assert.equal(snap.platformEvents.length, 1);
-    assert.equal(snap.workEvents.length, 1);
-    state.close();
-});
-test("T4.2.1 loadContinuitySnapshot exposes quietDebt from evidence", async () => {
-    const state = createStateDatabase(":memory:");
-    const obs = createObservabilityDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-cont-"));
-    await appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "work_progress",
-        summary: "w",
-        sourceRefs: [{ id: "c", kind: "platform_item", uri: "p://c" }],
-        sensitivity: "public",
-        producer: "connector-system",
-    });
-    const cont = await loadContinuitySnapshot({ state, workspaceRoot: ws, observability: obs });
-    assert.equal(cont.quietDebt.hasUnprocessedEvidence, true);
-    assert.ok(cont.quietDebt.pendingCount >= 1);
-    state.close();
-    obs.close();
-});

package/dist/tests/unit/storage/life-evidence.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/unit/storage/life-evidence.test.js

@@ -1,54 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { eq } from "drizzle-orm";
-import { appendLifeEvidence } from "../../../src/storage/life-evidence/append-life-evidence.js";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { lifeEvidenceIndex } from "../../../src/storage/db/schema/life-evidence-index.js";
-test("appendLifeEvidence writes artifact and index row", async () => {
-    const state = createStateDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-ws-"));
-    const ack = await appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_browse",
-        platformId: "moltbook",
-        summary: "Browsed feed",
-        sourceRefs: [{ id: "src-1", kind: "platform_item", uri: "moltbook://item/1" }],
-        sensitivity: "public",
-        producer: "connector-system",
-    });
-    assert.ok(ack.evidenceId.length > 0);
-    const artifactPath = path.join(ws, ".second-nature", "evidence", `${ack.evidenceId}.json`);
-    assert.equal(fs.existsSync(artifactPath), true);
-    const rows = await state.db.select().from(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, ack.evidenceId));
-    assert.equal(rows.length, 1);
-    state.close();
-});
-test("appendLifeEvidence rejects empty sourceRefs", async () => {
-    const state = createStateDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-ws-"));
-    await assert.rejects(() => appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_browse",
-        summary: "bad",
-        sourceRefs: [],
-        sensitivity: "public",
-        producer: "connector-system",
-    }), /life_evidence_missing_source_refs/);
-    state.close();
-});
-test("appendLifeEvidence rejects credential sensitivity", async () => {
-    const state = createStateDatabase(":memory:");
-    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-ws-"));
-    await assert.rejects(() => appendLifeEvidence(state, ws, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_browse",
-        summary: "secret",
-        sourceRefs: [{ id: "src-1", kind: "platform_item", uri: "x" }],
-        sensitivity: "credential",
-        producer: "connector-system",
-    }), /life_evidence_credential_rejected/);
-    state.close();
-});

package/dist/tests/unit/storage/migration-runner.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * T-SMS.F.2 — Migration runner unit tests.
- *
- * Verification (05A / 05B):
- * - migration runner sequential execution
- * - failure marking (schema_migration_failed, not crash)
- * - idempotent re-run (already applied migrations skipped)
- * - schema_version increments correctly
- *
- * Dependencies: sql.js, src/storage/db/migration-runner.ts
- */
-export {};

package/dist/tests/unit/storage/migration-runner.test.js

@@ -1,197 +0,0 @@
-/**
- * T-SMS.F.2 — Migration runner unit tests.
- *
- * Verification (05A / 05B):
- * - migration runner sequential execution
- * - failure marking (schema_migration_failed, not crash)
- * - idempotent re-run (already applied migrations skipped)
- * - schema_version increments correctly
- *
- * Dependencies: sql.js, src/storage/db/migration-runner.ts
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import initSqlJs from "sql.js";
-import { runMigrations, isMigrationFailed, } from "../../../src/storage/db/migration-runner.js";
-async function createMemoryDb() {
-    const SQL = await initSqlJs();
-    return new SQL.Database();
-}
-describe("migration-runner", () => {
-    it("creates _meta table and sets schema_version = 0 on fresh DB", async () => {
-        const sqlite = await createMemoryDb();
-        const result = runMigrations(sqlite, []);
-        assert.equal(result.schemaVersion, 0);
-        assert.deepEqual(result.applied, []);
-        assert.equal(result.failed, false);
-        const rows = sqlite.exec("SELECT value FROM _meta WHERE key = 'schema_version'");
-        assert.equal(rows[0].values[0][0], "0");
-        sqlite.close();
-    });
-    it("applies single migration and increments schema_version", async () => {
-        const sqlite = await createMemoryDb();
-        const migrations = [
-            {
-                version: 1,
-                label: "add-test-table",
-                sql: "CREATE TABLE test_tbl (id TEXT PRIMARY KEY);",
-            },
-        ];
-        const result = runMigrations(sqlite, migrations);
-        assert.equal(result.schemaVersion, 1);
-        assert.deepEqual(result.applied, [1]);
-        assert.equal(result.failed, false);
-        const tableCheck = sqlite.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='test_tbl'");
-        assert.equal(tableCheck.length, 1);
-        sqlite.close();
-    });
-    it("applies multiple migrations in order", async () => {
-        const sqlite = await createMemoryDb();
-        const migrations = [
-            {
-                version: 1,
-                label: "first",
-                sql: "CREATE TABLE tbl_a (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 2,
-                label: "second",
-                sql: "CREATE TABLE tbl_b (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 3,
-                label: "third",
-                sql: "CREATE TABLE tbl_c (id TEXT PRIMARY KEY);",
-            },
-        ];
-        const result = runMigrations(sqlite, migrations);
-        assert.equal(result.schemaVersion, 3);
-        assert.deepEqual(result.applied, [1, 2, 3]);
-        assert.equal(result.failed, false);
-        sqlite.close();
-    });
-    it("skips already-applied migrations (idempotent re-run)", async () => {
-        const sqlite = await createMemoryDb();
-        const migrations = [
-            {
-                version: 1,
-                label: "first",
-                sql: "CREATE TABLE tbl_x (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 2,
-                label: "second",
-                sql: "CREATE TABLE tbl_y (id TEXT PRIMARY KEY);",
-            },
-        ];
-        runMigrations(sqlite, migrations);
-        const result2 = runMigrations(sqlite, migrations);
-        assert.equal(result2.schemaVersion, 2);
-        assert.deepEqual(result2.applied, []);
-        assert.equal(result2.failed, false);
-        sqlite.close();
-    });
-    it("applies only pending migrations when schema_version is mid-range", async () => {
-        const sqlite = await createMemoryDb();
-        const first = [
-            {
-                version: 1,
-                label: "first",
-                sql: "CREATE TABLE tbl_p (id TEXT PRIMARY KEY);",
-            },
-        ];
-        runMigrations(sqlite, first);
-        const all = [
-            ...first,
-            {
-                version: 2,
-                label: "second",
-                sql: "CREATE TABLE tbl_q (id TEXT PRIMARY KEY);",
-            },
-        ];
-        const result = runMigrations(sqlite, all);
-        assert.equal(result.schemaVersion, 2);
-        assert.deepEqual(result.applied, [2]);
-        assert.equal(result.failed, false);
-        sqlite.close();
-    });
-    it("marks schema_migration_failed on SQL error without crashing", async () => {
-        const sqlite = await createMemoryDb();
-        const migrations = [
-            {
-                version: 1,
-                label: "good",
-                sql: "CREATE TABLE tbl_ok (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 2,
-                label: "bad",
-                sql: "THIS IS INVALID SQL;",
-            },
-        ];
-        const result = runMigrations(sqlite, migrations);
-        assert.equal(result.schemaVersion, 1);
-        assert.deepEqual(result.applied, [1]);
-        assert.equal(result.failed, true);
-        assert.equal(result.failedVersion, 2);
-        assert.ok(result.failedError);
-        assert.equal(isMigrationFailed(sqlite), true);
-        // Existing data preserved (tbl_ok still exists)
-        const tableCheck = sqlite.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='tbl_ok'");
-        assert.equal(tableCheck.length, 1);
-        sqlite.close();
-    });
-    it("preserves existing data when a migration fails", async () => {
-        const sqlite = await createMemoryDb();
-        const setupMigration = [
-            {
-                version: 1,
-                label: "setup",
-                sql: `
-          CREATE TABLE keeper (id TEXT PRIMARY KEY, val TEXT);
-          INSERT INTO keeper (id, val) VALUES ('row1', 'precious');
-        `,
-            },
-        ];
-        runMigrations(sqlite, setupMigration);
-        const all = [
-            ...setupMigration,
-            {
-                version: 2,
-                label: "boom",
-                sql: "DROP TABLE nonexistent_table;",
-            },
-        ];
-        const result = runMigrations(sqlite, all);
-        assert.equal(result.failed, true);
-        assert.equal(result.schemaVersion, 1);
-        // Data still intact
-        const rows = sqlite.exec("SELECT val FROM keeper WHERE id = 'row1'");
-        assert.equal(rows[0].values[0][0], "precious");
-        sqlite.close();
-    });
-    it("handles out-of-order migration definitions by sorting", async () => {
-        const sqlite = await createMemoryDb();
-        const migrations = [
-            {
-                version: 3,
-                label: "third",
-                sql: "CREATE TABLE tbl_3 (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 1,
-                label: "first",
-                sql: "CREATE TABLE tbl_1 (id TEXT PRIMARY KEY);",
-            },
-            {
-                version: 2,
-                label: "second",
-                sql: "CREATE TABLE tbl_2 (id TEXT PRIMARY KEY);",
-            },
-        ];
-        const result = runMigrations(sqlite, migrations);
-        assert.equal(result.schemaVersion, 3);
-        assert.deepEqual(result.applied, [1, 2, 3]);
-        sqlite.close();
-    });
-});

package/dist/tests/unit/storage/repair-gate.test.d.ts

@@ -1 +0,0 @@
-export {};