@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/chunk-AFDUOYHD.js

@@ -0,0 +1,2060 @@
+import {
+  createCircuitBreaker,
+  withRetry
+} from "./chunk-NTMBOESX.js";
+
+// ../../lib/pglite/db.ts
+import { PGliteWorker } from "@electric-sql/pglite/worker";
+import { live } from "@electric-sql/pglite/live";
+
+// ../../lib/biosignal/domain-taxonomy.ts
+var SIGNAL_DOMAIN_ORDER = [
+  "neural",
+  "physical",
+  "digital",
+  "environmental",
+  "social",
+  "derived"
+];
+function classifySignalFamilyDomains(families) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const family of families) {
+    switch (family) {
+      case "eeg":
+      case "eog":
+      case "emg":
+        domains.add("neural");
+        break;
+      case "ppg":
+      case "eda":
+      case "imu":
+        domains.add("physical");
+        break;
+    }
+  }
+  return SIGNAL_DOMAIN_ORDER.filter((domain) => domains.has(domain));
+}
+
+// ../../lib/biosignal/bridge-catalog.ts
+var DORMANT_BIOSIGNAL_BRIDGES = [
+  {
+    id: "muse-ble",
+    label: "Muse BLE ingest",
+    transport: "ble",
+    signalFamilies: ["eeg", "ppg", "imu"],
+    domains: classifySignalFamilyDomains(["eeg", "ppg", "imu"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "web-bluetooth-or-native",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  },
+  {
+    id: "openbci-ganglion",
+    label: "OpenBCI Ganglion ingest",
+    transport: "ble",
+    signalFamilies: ["eeg"],
+    domains: classifySignalFamilyDomains(["eeg"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "ble",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  },
+  {
+    id: "openbci-cyton-serial",
+    label: "OpenBCI Cyton serial ingest",
+    transport: "serial",
+    signalFamilies: ["eeg", "emg"],
+    domains: classifySignalFamilyDomains(["eeg", "emg"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "usb-serial",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  },
+  {
+    id: "openbci-cyton-wifi",
+    label: "OpenBCI Cyton WiFi ingest",
+    transport: "tcp",
+    signalFamilies: ["eeg", "emg"],
+    domains: classifySignalFamilyDomains(["eeg", "emg"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "wifi-or-udp",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  },
+  {
+    id: "brainflow-gateway",
+    label: "BrainFlow gateway ingest",
+    transport: "process",
+    signalFamilies: ["eeg", "ppg", "eda", "emg", "imu"],
+    domains: classifySignalFamilyDomains(["eeg", "ppg", "eda", "emg", "imu"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "native-sidecar",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  },
+  {
+    id: "lsl-ingest",
+    label: "LSL ingest",
+    transport: "tcp",
+    signalFamilies: ["eeg", "ppg", "eda", "emg", "imu"],
+    domains: classifySignalFamilyDomains(["eeg", "ppg", "eda", "emg", "imu"]),
+    status: "dormant",
+    enabled: false,
+    config: {
+      transportHint: "lab-streaming-layer-bridge",
+      notes: "Scaffold only. Not wired to acquisition runtime."
+    }
+  }
+];
+var BIOSIGNAL_BRIDGE_ID_SET = new Set(
+  DORMANT_BIOSIGNAL_BRIDGES.map((bridge) => bridge.id)
+);
+function isBiosignalBridgeId(value) {
+  return BIOSIGNAL_BRIDGE_ID_SET.has(value);
+}
+
+// ../../lib/biosignal/provider-catalog.ts
+var DORMANT_BIOSIGNAL_PROVIDERS = [
+  {
+    id: "apple-healthkit",
+    label: "Apple HealthKit",
+    providerType: "platform",
+    acquisitionMode: "hybrid",
+    domains: ["physical", "digital"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "hrv", "sleep", "steps", "workouts", "respiration"],
+    status: "dormant",
+    enabled: false,
+    notes: "Best-in-class Apple ecosystem physical health substrate; keep dormant until entitlement/runtime path exists."
+  },
+  {
+    id: "google-health-connect",
+    label: "Google Health Connect",
+    providerType: "platform",
+    acquisitionMode: "hybrid",
+    domains: ["physical", "digital"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "hrv", "sleep", "steps", "exercise", "oxygen_saturation"],
+    status: "dormant",
+    enabled: false,
+    notes: "Android-first physical health substrate; preferred over legacy Google Fit paths."
+  },
+  {
+    id: "oura-cloud",
+    label: "Oura Cloud",
+    providerType: "wearable",
+    acquisitionMode: "cloud-sync",
+    domains: ["physical", "derived"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "hrv", "sleep_stages", "temperature", "readiness"],
+    status: "dormant",
+    enabled: false,
+    notes: "High-signal recovery and sleep feed for longitudinal physical baselines."
+  },
+  {
+    id: "whoop-cloud",
+    label: "WHOOP",
+    providerType: "wearable",
+    acquisitionMode: "cloud-sync",
+    domains: ["physical", "derived"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "hrv", "sleep", "strain", "recovery", "respiration"],
+    status: "dormant",
+    enabled: false,
+    notes: "High-value performance/recovery stream for physical state modeling."
+  },
+  {
+    id: "garmin-health",
+    label: "Garmin Health",
+    providerType: "wearable",
+    acquisitionMode: "cloud-sync",
+    domains: ["physical", "digital"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "hrv", "sleep", "body_battery", "stress", "activity"],
+    status: "dormant",
+    enabled: false,
+    notes: "Strong all-day physical telemetry with durable longitudinal fitness coverage."
+  },
+  {
+    id: "polar-flow",
+    label: "Polar Flow",
+    providerType: "wearable",
+    acquisitionMode: "cloud-sync",
+    domains: ["physical"],
+    signalFamilies: ["ppg"],
+    metrics: ["heart_rate", "rr_intervals", "training_load", "sleep"],
+    status: "dormant",
+    enabled: false,
+    notes: "Useful when RR intervals and HR precision matter more than general wellness UX."
+  },
+  {
+    id: "withings",
+    label: "Withings",
+    providerType: "wearable",
+    acquisitionMode: "cloud-sync",
+    domains: ["physical"],
+    signalFamilies: ["ppg", "imu"],
+    metrics: ["heart_rate", "sleep", "weight", "blood_pressure", "spo2"],
+    status: "dormant",
+    enabled: false,
+    notes: "Useful for home-health physical context and longer-horizon body-state tracking."
+  },
+  {
+    id: "muse-live",
+    label: "Muse Live",
+    providerType: "neural",
+    acquisitionMode: "local",
+    domains: ["neural", "physical"],
+    signalFamilies: ["eeg", "ppg", "imu"],
+    metrics: ["raw_eeg", "band_power", "faa", "heart_rate", "hrv"],
+    status: "dormant",
+    enabled: false,
+    notes: "Primary neural consumer-grade live interface when direct headset support lands."
+  },
+  {
+    id: "openbci-live",
+    label: "OpenBCI Live",
+    providerType: "neural",
+    acquisitionMode: "local",
+    domains: ["neural"],
+    signalFamilies: ["eeg", "emg", "eog"],
+    metrics: ["raw_eeg", "multi_channel_bands", "event_markers"],
+    status: "dormant",
+    enabled: false,
+    notes: "Research-grade neural path for richer channel counts and protocol flexibility."
+  },
+  {
+    id: "brainflow-gateway",
+    label: "BrainFlow Gateway",
+    providerType: "gateway",
+    acquisitionMode: "hybrid",
+    domains: ["neural", "physical", "digital"],
+    signalFamilies: ["eeg", "ppg", "eda", "emg", "imu"],
+    metrics: ["board_stream", "markers", "derived_bands"],
+    status: "dormant",
+    enabled: false,
+    notes: "Fastest route to broad board coverage with one adapter surface."
+  },
+  {
+    id: "lsl-lab",
+    label: "LSL Lab Feed",
+    providerType: "gateway",
+    acquisitionMode: "local",
+    domains: ["neural", "physical", "digital", "social"],
+    signalFamilies: ["eeg", "ppg", "eda", "emg", "imu"],
+    metrics: ["stream_sync", "markers", "cross_device_alignment"],
+    status: "dormant",
+    enabled: false,
+    notes: "Best lab interop surface for cross-device synchronization and experiment markers."
+  }
+];
+var BIOSIGNAL_PROVIDER_ID_SET = new Set(
+  DORMANT_BIOSIGNAL_PROVIDERS.map((provider) => provider.id)
+);
+function isBiosignalProviderId(value) {
+  return BIOSIGNAL_PROVIDER_ID_SET.has(value);
+}
+
+// ../../lib/pglite/schema.ts
+var LATEST_SCHEMA_VERSION = "1.18";
+var USER_PROFILES_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS user_profiles (
+    user_id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+    username VARCHAR(255),
+    avatar_url TEXT,
+    xverse_ord_address VARCHAR(255) UNIQUE,
+    shape_hash TEXT,
+    api_keys JSONB DEFAULT '{}',
+    preferences JSONB DEFAULT '{"unlocked_reward_ids": []}',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`;
+function versionLt(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na < nb) return true;
+    if (na > nb) return false;
+  }
+  return false;
+}
+async function initializeSchema(db, onProgress) {
+  try {
+    await db.transaction(async (tx) => {
+      console.log("Initializing database schema...");
+      onProgress?.({ step: "connect", label: "Connecting", status: "active" });
+      await tx.query("SELECT 1 as test");
+      console.log("Database connectivity confirmed");
+      onProgress?.({ step: "connect", label: "Connected", status: "done" });
+      await tx.query(`CREATE TABLE IF NOT EXISTS schema_version (version TEXT PRIMARY KEY);`);
+      const versionResult = await tx.query(
+        `SELECT version FROM schema_version`
+      );
+      let currentVersion = versionResult.rows[0]?.version || "0";
+      console.log(`Current DB schema version: ${currentVersion}`);
+      if (!versionLt(currentVersion, LATEST_SCHEMA_VERSION)) {
+        console.log(
+          `Schema already at latest version (${LATEST_SCHEMA_VERSION}) \u2014 skipping initialization`
+        );
+        onProgress?.({ step: "done", label: "Ready", status: "done" });
+        return;
+      }
+      if (currentVersion === "0") {
+        const extensions = ["uuid-ossp", "pg_trgm", "vector", "ltree", "seg", "tcn", "tablefunc"];
+        for (const ext of extensions) {
+          try {
+            await tx.query(`CREATE EXTENSION IF NOT EXISTS "${ext}";`);
+          } catch (extErr) {
+            console.warn(`[schema] Extension "${ext}" not available:`, extErr);
+          }
+        }
+      }
+      await tx.query(USER_PROFILES_TABLE_SQL);
+      if (versionLt(currentVersion, "1.1")) {
+        onProgress?.({ step: "v1.1", label: "v1.1 Core Tables", status: "active" });
+        console.log("Migrating schema to version 1.1...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS user_artifacts (
+            id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+            user_id UUID,
+            source_applet VARCHAR(50) NOT NULL,
+            artifact_type VARCHAR(50) NOT NULL,
+            artifact_name TEXT NOT NULL,
+            content TEXT,
+            blob_content BYTEA,
+            metadata JSONB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        const columns = await tx.query(`
+          SELECT column_name FROM information_schema.columns
+          WHERE table_name = 'user_artifacts' AND column_name = 'display_type'
+        `);
+        if (columns.rows.length === 0) {
+          await tx.query(`ALTER TABLE user_artifacts ADD COLUMN display_type VARCHAR(50);`);
+        }
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.1');`);
+        console.log("Schema migration to 1.1 successful.");
+        onProgress?.({ step: "v1.1", label: "v1.1 Core Tables", status: "done" });
+        currentVersion = "1.1";
+      }
+      if (versionLt(currentVersion, "1.2")) {
+        onProgress?.({ step: "v1.2", label: "v1.2 Mesh Events", status: "active" });
+        console.log("Migrating schema to version 1.2 (Zero-Lite Mesh)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS mesh_events (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            user_id UUID,
+            interaction_id TEXT,
+            run_id TEXT,
+            stack_id TEXT,
+            prev_hash TEXT,
+            trace_path ltree NOT NULL,
+            type TEXT NOT NULL,
+            payload JSONB NOT NULL,
+            metadata JSONB,
+            embedding vector(384),
+            span JSONB,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_mesh_events_path ON mesh_events USING GIST (trace_path);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_mesh_events_interaction ON mesh_events(interaction_id);`
+        );
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_mesh_events_run ON mesh_events(run_id);`);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_mesh_events_type ON mesh_events(type);`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_mesh_events_embedding ON mesh_events USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_mesh_events_created ON mesh_events(created_at);`
+        );
+        try {
+          await tx.query(
+            `CREATE TRIGGER mesh_events_tcn_trigger AFTER INSERT OR UPDATE OR DELETE ON mesh_events FOR EACH ROW EXECUTE FUNCTION triggered_change_notification();`
+          );
+        } catch (_e) {
+          console.warn("TCN trigger creation failed:", _e);
+        }
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.2');`);
+        console.log("Schema migration to 1.2 successful.");
+        onProgress?.({ step: "v1.2", label: "v1.2 Mesh Events", status: "done" });
+        currentVersion = "1.2";
+      }
+      if (versionLt(currentVersion, "1.3")) {
+        onProgress?.({ step: "v1.3", label: "v1.3 Ralph Loop", status: "active" });
+        console.log("Migrating schema to version 1.3 (Ralph Loop)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS state_spans (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            session_id UUID NOT NULL,
+            start_time BIGINT NOT NULL,
+            end_time BIGINT,
+            mode VARCHAR(20) NOT NULL CHECK (mode IN ('live', 'recorded')),
+            start_clock JSONB NOT NULL DEFAULT '[]',
+            end_clock JSONB,
+            start_state JSONB NOT NULL,
+            end_state JSONB,
+            resonance JSONB NOT NULL DEFAULT '{"semantic": 0, "hierarchical": 0, "phaseLock": 0}',
+            signature TEXT NOT NULL,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS span_events (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            span_id UUID NOT NULL REFERENCES state_spans(id) ON DELETE CASCADE,
+            event_type VARCHAR(100) NOT NULL,
+            timestamp BIGINT NOT NULL,
+            payload JSONB,
+            source VARCHAR(255),
+            caused_by UUID[],
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS ralph_worlds (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            name TEXT NOT NULL,
+            config JSONB NOT NULL,
+            node_count INTEGER NOT NULL DEFAULT 1,
+            state_backend VARCHAR(20) NOT NULL CHECK (state_backend IN ('pglite', 'file', 'git')),
+            hvm_enabled BOOLEAN NOT NULL DEFAULT false,
+            convergence_config JSONB NOT NULL DEFAULT '{"type": "resonance", "threshold": 0.8}',
+            loom_config JSONB NOT NULL DEFAULT '{"topology": "linear", "choicePoints": []}',
+            status VARCHAR(20) NOT NULL DEFAULT 'created' CHECK (status IN ('created', 'running', 'paused', 'completed', 'failed')),
+            current_tick BIGINT NOT NULL DEFAULT 0,
+            total_ticks BIGINT,
+            started_at TIMESTAMPTZ,
+            completed_at TIMESTAMPTZ,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS ralph_paths (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            world_id UUID NOT NULL REFERENCES ralph_worlds(id) ON DELETE CASCADE,
+            parent_path_id UUID REFERENCES ralph_paths(id) ON DELETE SET NULL,
+            branch_point TEXT,
+            choice_id TEXT,
+            pulse_id TEXT NOT NULL,
+            status VARCHAR(20) NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'completed', 'pruned', 'failed')),
+            tick_start BIGINT NOT NULL DEFAULT 0,
+            tick_end BIGINT,
+            resonance_final JSONB,
+            checkpoint_signature TEXT,
+            metadata JSONB DEFAULT '{}',
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_state_spans_session ON state_spans(session_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_state_spans_signature ON state_spans(signature);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_state_spans_time ON state_spans(start_time, end_time);`
+        );
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_span_events_span ON span_events(span_id);`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_span_events_type ON span_events(event_type);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_span_events_timestamp ON span_events(timestamp);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_ralph_worlds_status ON ralph_worlds(status);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_ralph_paths_world ON ralph_paths(world_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_ralph_paths_parent ON ralph_paths(parent_path_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_ralph_paths_pulse ON ralph_paths(pulse_id);`
+        );
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_ralph_paths_status ON ralph_paths(status);`);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.3');`);
+        console.log("Schema migration to 1.3 (Ralph Loop) successful.");
+        onProgress?.({ step: "v1.3", label: "v1.3 Ralph Loop", status: "done" });
+        currentVersion = "1.3";
+      }
+      if (versionLt(currentVersion, "1.4")) {
+        onProgress?.({ step: "v1.4", label: "v1.4 Mesh Metadata", status: "active" });
+        console.log("Migrating schema to version 1.4 (Mesh Events Metadata)...");
+        const columns = await tx.query(`
+          SELECT column_name FROM information_schema.columns
+          WHERE table_name = 'mesh_events' AND column_name = 'metadata'
+        `);
+        if (columns.rows.length === 0) {
+          await tx.query(`ALTER TABLE mesh_events ADD COLUMN metadata JSONB;`);
+        }
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.4');`);
+        console.log("Schema migration to 1.4 (Mesh Events Metadata) successful.");
+        onProgress?.({ step: "v1.4", label: "v1.4 Mesh Metadata", status: "done" });
+        currentVersion = "1.4";
+      }
+      if (versionLt(currentVersion, "1.5")) {
+        onProgress?.({ step: "v1.5", label: "v1.5 Supabase Parity", status: "active" });
+        console.log("Migrating schema to version 1.5 (Mesh Events Supabase Parity)...");
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS interaction_id TEXT;`);
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS run_id TEXT;`);
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS stack_id TEXT;`);
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS type TEXT;`);
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS user_id UUID;`);
+        await tx.query(`ALTER TABLE mesh_events ADD COLUMN IF NOT EXISTS metadata JSONB;`);
+        await tx.query(`
+          UPDATE mesh_events
+          SET trace_path = COALESCE(trace_path, 'root.unknown'::ltree),
+              payload = COALESCE(payload, 'null'::jsonb)
+          WHERE trace_path IS NULL OR payload IS NULL;
+        `);
+        await tx.query(`
+          UPDATE mesh_events
+          SET type = COALESCE(
+            type,
+            CASE
+              WHEN trace_path IS NOT NULL THEN subpath(trace_path, nlevel(trace_path) - 1, 1)::text
+              ELSE 'event'
+            END
+          )
+          WHERE type IS NULL;
+        `);
+        await tx.query(`
+          UPDATE mesh_events
+          SET created_at = COALESCE(created_at, CURRENT_TIMESTAMP)
+          WHERE created_at IS NULL;
+        `);
+        await tx.query(`ALTER TABLE mesh_events ALTER COLUMN trace_path SET NOT NULL;`);
+        await tx.query(`ALTER TABLE mesh_events ALTER COLUMN type SET NOT NULL;`);
+        await tx.query(`ALTER TABLE mesh_events ALTER COLUMN payload SET NOT NULL;`);
+        await tx.query(`ALTER TABLE mesh_events ALTER COLUMN created_at SET NOT NULL;`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_mesh_events_interaction ON mesh_events(interaction_id);`
+        );
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_mesh_events_run ON mesh_events(run_id);`);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_mesh_events_type ON mesh_events(type);`);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.5');`);
+        console.log("Schema migration to 1.5 (Mesh Events Supabase Parity) successful.");
+        onProgress?.({ step: "v1.5", label: "v1.5 Supabase Parity", status: "done" });
+        currentVersion = "1.5";
+      }
+      if (versionLt(currentVersion, "1.6")) {
+        onProgress?.({ step: "v1.6", label: "v1.6 Deploy History", status: "active" });
+        console.log("Migrating schema to version 1.6 (Deploy History + Workspace State)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS deployments (
+            id TEXT PRIMARY KEY,
+            user_id TEXT,
+            stack_id TEXT,
+            provider TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'idle',
+            deploy_url TEXT,
+            preview_url TEXT,
+            inspector_url TEXT,
+            error TEXT,
+            config JSONB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_deployments_user ON deployments(user_id);`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_deployments_stack ON deployments(stack_id);`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS workspace_state (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            stack_id TEXT,
+            open_files JSONB DEFAULT '[]',
+            active_file TEXT,
+            cursor_positions JSONB DEFAULT '{}',
+            scroll_positions JSONB DEFAULT '{}',
+            pane_layout JSONB,
+            editor_settings JSONB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_workspace_user ON workspace_state(user_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_workspace_stack ON workspace_state(user_id, stack_id);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.6');`);
+        console.log("Schema migration to 1.6 (Deploy History + Workspace State) successful.");
+        onProgress?.({ step: "v1.6", label: "v1.6 Deploy History", status: "done" });
+        currentVersion = "1.6";
+      }
+      if (versionLt(currentVersion, "1.7")) {
+        onProgress?.({ step: "v1.7", label: "v1.7 Skill Runs", status: "active" });
+        console.log("Migrating schema to version 1.7 (Skill Runs)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS skill_runs (
+            id TEXT PRIMARY KEY,
+            user_id TEXT,
+            skill_slug TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            input JSONB,
+            artifacts JSONB DEFAULT '[]',
+            agent_log JSONB DEFAULT '[]',
+            started_at TIMESTAMP,
+            completed_at TIMESTAMP,
+            error TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_skill_runs_user ON skill_runs(user_id);`);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_skill_runs_slug ON skill_runs(skill_slug);`);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.7');`);
+        console.log("Schema migration to 1.7 (Skill Runs) successful.");
+        onProgress?.({ step: "v1.7", label: "v1.7 Skill Runs", status: "done" });
+        currentVersion = "1.7";
+      }
+      if (versionLt(currentVersion, "1.8")) {
+        onProgress?.({ step: "v1.8", label: "v1.8 User Skills", status: "active" });
+        console.log("Migrating schema to version 1.8...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS user_skills (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            slug TEXT NOT NULL,
+            manifest JSONB NOT NULL,
+            markdown TEXT,
+            visibility TEXT DEFAULT 'private',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(user_id, slug)
+          );
+        `);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_user_skills_user ON user_skills(user_id);`);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_user_skills_slug ON user_skills(slug);`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_user_skills_visibility ON user_skills(visibility);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.8');`);
+        console.log("Schema migrated to version 1.8 (user_skills table)");
+        onProgress?.({ step: "v1.8", label: "v1.8 User Skills", status: "done" });
+        currentVersion = "1.8";
+      }
+      if (versionLt(currentVersion, "1.9")) {
+        onProgress?.({ step: "v1.9", label: "v1.9 Projects", status: "active" });
+        console.log("Migrating schema to version 1.9 (Projects & Knowledge Base)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS projects (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            name TEXT NOT NULL,
+            description TEXT,
+            settings JSONB DEFAULT '{}',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_projects_user ON projects(user_id);`);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS project_files (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            filename TEXT NOT NULL,
+            mime_type TEXT NOT NULL,
+            size_bytes INTEGER NOT NULL DEFAULT 0,
+            content TEXT,
+            embedding vector(384),
+            metadata JSONB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_project_files_project ON project_files(project_id);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.9');`);
+        console.log("Schema migrated to version 1.9 (Projects & Knowledge Base)");
+        onProgress?.({ step: "v1.9", label: "v1.9 Projects", status: "done" });
+        currentVersion = "1.9";
+      }
+      if (versionLt(currentVersion, "1.10")) {
+        onProgress?.({ step: "v1.10", label: "v1.10 Project Scope", status: "active" });
+        console.log("Migrating schema to version 1.10 (Project Scope)...");
+        await tx.query(`ALTER TABLE projects ADD COLUMN IF NOT EXISTS color TEXT;`);
+        await tx.query(
+          `ALTER TABLE projects ADD COLUMN IF NOT EXISTS focus_level TEXT DEFAULT 'ambient';`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS project_artifacts (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            artifact_id TEXT NOT NULL,
+            source_type TEXT NOT NULL,
+            source_id TEXT,
+            title TEXT NOT NULL,
+            content_type TEXT NOT NULL,
+            pinned BOOLEAN DEFAULT FALSE,
+            content_preview TEXT,
+            metadata JSONB DEFAULT '{}',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (project_id, artifact_id)
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_pa_project ON project_artifacts(project_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_pa_pinned ON project_artifacts(project_id, pinned);`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS project_sessions (
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            session_id TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (project_id, session_id)
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS project_skill_runs (
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            run_id TEXT NOT NULL,
+            skill_slug TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (project_id, run_id)
+          );
+        `);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.10');`);
+        console.log("Schema migrated to version 1.10 (Project Scope)");
+        onProgress?.({ step: "v1.10", label: "v1.10 Project Scope", status: "done" });
+        currentVersion = "1.10";
+      }
+      if (versionLt(currentVersion, "1.11")) {
+        onProgress?.({ step: "v1.11", label: "v1.11 Dashboard & Checkpoints", status: "active" });
+        console.log(
+          "Migrating schema to version 1.11 (Dashboard Widgets, Checkpoints, Effective Dating)..."
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS skill_run_checkpoints (
+            id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL,
+            level_index INTEGER NOT NULL,
+            completed_agents JSONB DEFAULT '[]',
+            pending_agents JSONB DEFAULT '[]',
+            artifacts JSONB DEFAULT '[]',
+            state_snapshot JSONB DEFAULT '{}',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_src_run ON skill_run_checkpoints(run_id);`);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_src_level ON skill_run_checkpoints(run_id, level_index);`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS dashboard_widgets (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            user_id TEXT NOT NULL,
+            position JSONB NOT NULL DEFAULT '{"x":0,"y":0,"w":1,"h":1}',
+            config JSONB NOT NULL DEFAULT '{"type":"note"}',
+            data_cache JSONB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_dw_project ON dashboard_widgets(project_id);`
+        );
+        await tx.query(`CREATE INDEX IF NOT EXISTS idx_dw_user ON dashboard_widgets(user_id);`);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS effective_dated_bindings (
+            id TEXT PRIMARY KEY,
+            entity_id TEXT NOT NULL,
+            seat_type TEXT NOT NULL,
+            seat_id TEXT NOT NULL,
+            registered_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            active_from TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            active_to TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_edb_entity ON effective_dated_bindings(entity_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_edb_seat ON effective_dated_bindings(seat_type, seat_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_edb_active ON effective_dated_bindings(active_from, active_to);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.11');`);
+        console.log(
+          "Schema migrated to version 1.11 (Dashboard Widgets, Checkpoints, Effective Dating)"
+        );
+        onProgress?.({ step: "v1.11", label: "v1.11 Dashboard & Checkpoints", status: "done" });
+        currentVersion = "1.11";
+      }
+      if (versionLt(currentVersion, "1.12")) {
+        onProgress?.({ step: "v1.12", label: "v1.12 Forge Tables", status: "active" });
+        console.log("Migrating schema to version 1.12...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS forge_scenes (
+            id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+            user_id UUID,
+            name TEXT NOT NULL,
+            scene_data JSONB NOT NULL,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS forge_iterations (
+            id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+            scene_id UUID REFERENCES forge_scenes(id) ON DELETE CASCADE,
+            user_id UUID,
+            tau REAL NOT NULL,
+            sync_order REAL,
+            coherence JSONB,
+            parameter_snapshot JSONB,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS forge_material_profiles (
+            id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+            user_id UUID,
+            name TEXT NOT NULL,
+            properties JSONB NOT NULL,
+            acoustic_signature JSONB,
+            neural_baseline JSONB,
+            crystallization REAL DEFAULT 0,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_forge_iterations_scene ON forge_iterations(scene_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_forge_profiles_user ON forge_material_profiles(user_id);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.12');`);
+        console.log("Schema migration to 1.12 successful.");
+        onProgress?.({ step: "v1.12", label: "v1.12 Forge Tables", status: "done" });
+        currentVersion = "1.12";
+      }
+      if (versionLt(currentVersion, "1.13")) {
+        onProgress?.({ step: "v1.13", label: "v1.13 Resonant Sessions", status: "active" });
+        console.log("Migrating schema to version 1.13 (Resonant Sessions, Frames, Onboarding)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS resonant_sessions (
+            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            user_id UUID,
+            audio_fingerprint TEXT NOT NULL,
+            audio_file_name TEXT NOT NULL,
+            duration_ms INTEGER NOT NULL,
+            sampling_rate INTEGER NOT NULL DEFAULT 30,
+            config JSONB NOT NULL,
+            summary JSONB NOT NULL,
+            frame_count INTEGER NOT NULL,
+            attribution JSONB NOT NULL,
+            tier TEXT NOT NULL DEFAULT 'FREE_LOCAL',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS resonant_session_frames (
+            id BIGSERIAL PRIMARY KEY,
+            session_id UUID NOT NULL REFERENCES resonant_sessions(id) ON DELETE CASCADE,
+            frame_index INTEGER NOT NULL,
+            data JSONB NOT NULL
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_resonant_sessions_user ON resonant_sessions(user_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_resonant_frames_session_idx ON resonant_session_frames(session_id, frame_index);`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS resonant_onboarding (
+            user_id UUID PRIMARY KEY,
+            welcome_seen BOOLEAN NOT NULL DEFAULT false,
+            consent_accepted BOOLEAN NOT NULL DEFAULT false,
+            consent_timestamp TIMESTAMPTZ,
+            keys_configured BOOLEAN NOT NULL DEFAULT false,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.13');`);
+        console.log("Schema migration to 1.13 (Resonant Sessions, Frames, Onboarding) successful.");
+        onProgress?.({ step: "v1.13", label: "v1.13 Resonant Sessions", status: "done" });
+        currentVersion = "1.13";
+      }
+      if (versionLt(currentVersion, "1.14")) {
+        onProgress?.({ step: "v1.14", label: "v1.14 Society Run Ledger", status: "active" });
+        console.log("Migrating schema to version 1.14 (Society Run Ledger)...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS society_runs (
+            id TEXT PRIMARY KEY,
+            plan_id TEXT NOT NULL,
+            project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+            user_id TEXT,
+            user_request TEXT NOT NULL,
+            status TEXT NOT NULL,
+            plan_json JSONB NOT NULL,
+            skill_artifacts JSONB DEFAULT '{}',
+            synthesized_output TEXT,
+            error TEXT,
+            started_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            completed_at TIMESTAMPTZ,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS society_run_nodes (
+            id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL REFERENCES society_runs(id) ON DELETE CASCADE,
+            node_id TEXT NOT NULL,
+            skill_slug TEXT NOT NULL,
+            status TEXT NOT NULL,
+            artifacts JSONB DEFAULT '[]',
+            error TEXT,
+            started_at TIMESTAMPTZ,
+            completed_at TIMESTAMPTZ,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS society_run_events (
+            id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL REFERENCES society_runs(id) ON DELETE CASCADE,
+            event_type TEXT NOT NULL,
+            payload JSONB DEFAULT '{}',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS project_society_runs (
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            run_id TEXT NOT NULL,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (project_id, run_id)
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_society_runs_project ON society_runs(project_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_society_runs_status ON society_runs(status);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_society_run_nodes_run ON society_run_nodes(run_id);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_society_run_events_run ON society_run_events(run_id);`
+        );
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.14');`);
+        console.log("Schema migration to 1.14 (Society Run Ledger) successful.");
+        onProgress?.({ step: "v1.14", label: "v1.14 Society Run Ledger", status: "done" });
+        currentVersion = "1.14";
+      }
+      if (versionLt(currentVersion, "1.15")) {
+        onProgress?.({ step: "v1.15", label: "v1.15 Intent Oscillator", status: "active" });
+        console.log("Migrating schema to version 1.15...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS intent_signals (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            user_id TEXT NOT NULL,
+            project_id TEXT NOT NULL,
+            signal_type TEXT NOT NULL,
+            dimension TEXT,
+            payload JSONB,
+            created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_intent_signals_user_time ON intent_signals(user_id, created_at DESC);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_intent_signals_project ON intent_signals(project_id, created_at DESC);`
+        );
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS oscillator_state (
+            id TEXT PRIMARY KEY,
+            phases JSONB NOT NULL DEFAULT '{}',
+            frequencies JSONB NOT NULL DEFAULT '{}',
+            coupling_k FLOAT DEFAULT 0.5,
+            order_parameter_r FLOAT DEFAULT 0.0,
+            updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.15');`);
+        console.log("Schema migration to 1.15 (Intent Oscillator) successful.");
+        onProgress?.({ step: "v1.15", label: "v1.15 Intent Oscillator", status: "done" });
+        currentVersion = "1.15";
+      }
+      if (versionLt(currentVersion, "1.16")) {
+        onProgress?.({ step: "v1.16", label: "v1.16 API Keys", status: "active" });
+        console.log("Migrating schema to version 1.16...");
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.16');`);
+        console.log("Schema migration to 1.16 (API Keys) successful.");
+        onProgress?.({ step: "v1.16", label: "v1.16 API Keys", status: "done" });
+        currentVersion = "1.16";
+      }
+      if (versionLt(currentVersion, "1.17")) {
+        onProgress?.({ step: "v1.17", label: "v1.17 Biosignal Substrate", status: "active" });
+        console.log("Migrating schema to version 1.17...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS biosignal_bridge_config (
+            id TEXT PRIMARY KEY,
+            label TEXT NOT NULL,
+            transport TEXT NOT NULL,
+            domains JSONB NOT NULL DEFAULT '[]',
+            signal_families JSONB NOT NULL DEFAULT '[]',
+            status TEXT NOT NULL DEFAULT 'dormant',
+            enabled BOOLEAN NOT NULL DEFAULT false,
+            config JSONB NOT NULL DEFAULT '{}',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS biosignal_sessions (
+            id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+            user_id UUID,
+            bridge_id TEXT NOT NULL REFERENCES biosignal_bridge_config(id) ON DELETE RESTRICT,
+            signal_family TEXT NOT NULL,
+            sampling_hz REAL,
+            channel_count INTEGER,
+            status TEXT NOT NULL DEFAULT 'created',
+            metadata JSONB NOT NULL DEFAULT '{}',
+            provenance JSONB NOT NULL DEFAULT '{}',
+            started_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            ended_at TIMESTAMPTZ,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS biosignal_epochs (
+            id BIGSERIAL PRIMARY KEY,
+            session_id UUID NOT NULL REFERENCES biosignal_sessions(id) ON DELETE CASCADE,
+            epoch_index INTEGER NOT NULL,
+            window_started_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            window_ended_at TIMESTAMPTZ,
+            raw_pointer JSONB,
+            signals JSONB NOT NULL DEFAULT '{}',
+            metrics JSONB NOT NULL DEFAULT '{}',
+            quality JSONB NOT NULL DEFAULT '{}',
+            labels JSONB NOT NULL DEFAULT '[]',
+            embedding vector(384),
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_bridge_status ON biosignal_bridge_config(status, enabled);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_sessions_user_time ON biosignal_sessions(user_id, started_at DESC);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_sessions_bridge_time ON biosignal_sessions(bridge_id, started_at DESC);`
+        );
+        await tx.query(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_biosignal_epochs_session_idx ON biosignal_epochs(session_id, epoch_index);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_epochs_time ON biosignal_epochs(window_started_at DESC);`
+        );
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_epochs_embedding ON biosignal_epochs USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);`
+        );
+        for (const bridge of DORMANT_BIOSIGNAL_BRIDGES) {
+          await tx.query(
+            `INSERT INTO biosignal_bridge_config
+              (id, label, transport, domains, signal_families, status, enabled, config)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+             ON CONFLICT (id) DO NOTHING`,
+            [
+              bridge.id,
+              bridge.label,
+              bridge.transport,
+              JSON.stringify(bridge.domains),
+              JSON.stringify(bridge.signalFamilies),
+              bridge.status,
+              bridge.enabled,
+              JSON.stringify(bridge.config)
+            ]
+          );
+        }
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.17');`);
+        console.log("Schema migration to 1.17 (Dormant Biosignal Bridge Substrate) successful.");
+        onProgress?.({ step: "v1.17", label: "v1.17 Biosignal Substrate", status: "done" });
+        currentVersion = "1.17";
+      }
+      if (versionLt(currentVersion, "1.18")) {
+        onProgress?.({ step: "v1.18", label: "v1.18 Biosignal Providers", status: "active" });
+        console.log("Migrating schema to version 1.18...");
+        await tx.query(`
+          CREATE TABLE IF NOT EXISTS biosignal_provider_config (
+            id TEXT PRIMARY KEY,
+            label TEXT NOT NULL,
+            provider_type TEXT NOT NULL,
+            acquisition_mode TEXT NOT NULL,
+            domains JSONB NOT NULL DEFAULT '[]',
+            signal_families JSONB NOT NULL DEFAULT '[]',
+            metrics JSONB NOT NULL DEFAULT '[]',
+            status TEXT NOT NULL DEFAULT 'dormant',
+            enabled BOOLEAN NOT NULL DEFAULT false,
+            notes TEXT NOT NULL DEFAULT '',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+        await tx.query(
+          `CREATE INDEX IF NOT EXISTS idx_biosignal_provider_status ON biosignal_provider_config(status, enabled);`
+        );
+        for (const provider of DORMANT_BIOSIGNAL_PROVIDERS) {
+          await tx.query(
+            `INSERT INTO biosignal_provider_config
+              (id, label, provider_type, acquisition_mode, domains, signal_families, metrics, status, enabled, notes)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+             ON CONFLICT (id) DO NOTHING`,
+            [
+              provider.id,
+              provider.label,
+              provider.providerType,
+              provider.acquisitionMode,
+              JSON.stringify(provider.domains),
+              JSON.stringify(provider.signalFamilies),
+              JSON.stringify(provider.metrics),
+              provider.status,
+              provider.enabled,
+              provider.notes
+            ]
+          );
+        }
+        await tx.query(`DELETE FROM schema_version;`);
+        await tx.query(`INSERT INTO schema_version (version) VALUES ('1.18');`);
+        console.log("Schema migration to 1.18 (Dormant Biosignal Provider Catalog) successful.");
+        onProgress?.({ step: "v1.18", label: "v1.18 Biosignal Providers", status: "done" });
+        currentVersion = "1.18";
+      }
+      await tx.query(USER_PROFILES_TABLE_SQL);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS chat_sessions (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          user_id UUID REFERENCES user_profiles(user_id) ON DELETE CASCADE,
+          session_title VARCHAR(500),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          metadata JSONB DEFAULT '{}'
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS chat_messages (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          session_id UUID REFERENCES chat_sessions(id) ON DELETE CASCADE,
+          user_id UUID REFERENCES user_profiles(user_id) ON DELETE SET NULL,
+          role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant', 'system', 'tool')),
+          content TEXT NOT NULL,
+          tool_call_id VARCHAR(255),
+          tool_calls JSONB,
+          name VARCHAR(255),
+          timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          metadata JSONB DEFAULT '{}'
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS quizzes (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          title VARCHAR(255) NOT NULL,
+          description TEXT,
+          questions JSONB NOT NULL DEFAULT '[]',
+          associated_resource_slug VARCHAR(255),
+          difficulty VARCHAR(50),
+          tags TEXT[],
+          reward_id UUID,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS user_artifacts (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          user_id UUID REFERENCES user_profiles(user_id) ON DELETE CASCADE,
+          source_applet VARCHAR(50) NOT NULL,
+          artifact_type VARCHAR(50) NOT NULL,
+          display_type VARCHAR(50),
+          artifact_name TEXT NOT NULL,
+          content TEXT,
+          blob_content BYTEA,
+          metadata JSONB,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS rewards (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          title VARCHAR(255) NOT NULL,
+          description TEXT,
+          type VARCHAR(100),
+          unlock_criteria JSONB,
+          asset_url TEXT,
+          quiz_ids_required UUID[],
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS user_progress (
+          user_id UUID REFERENCES user_profiles(user_id) ON DELETE CASCADE,
+          quiz_id UUID REFERENCES quizzes(id) ON DELETE CASCADE,
+          highest_score INTEGER,
+          completed_at TIMESTAMP,
+          unlocked_rewards UUID[],
+          current_question_index INTEGER,
+          answers JSONB,
+          last_attempted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          PRIMARY KEY (user_id, quiz_id)
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS resource_categories (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          name VARCHAR(255) NOT NULL,
+          description TEXT,
+          icon_identifier VARCHAR(100),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS resource_documents (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          title VARCHAR(255) NOT NULL,
+          description TEXT,
+          category_id UUID REFERENCES resource_categories(id) ON DELETE SET NULL,
+          content TEXT NOT NULL,
+          icon_identifier VARCHAR(100),
+          tags TEXT[],
+          has_quiz BOOLEAN DEFAULT FALSE,
+          quiz_id UUID REFERENCES quizzes(id) ON DELETE SET NULL,
+          embedding vector(384),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS friends (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          name VARCHAR(255) NOT NULL,
+          description TEXT,
+          url TEXT,
+          logo_url TEXT,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS inspirations (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          name VARCHAR(255) NOT NULL,
+          description TEXT,
+          url TEXT,
+          type VARCHAR(50) CHECK (type IN ('person', 'project', 'company')),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS key_value_store (
+          key TEXT PRIMARY KEY,
+          value JSONB
+        );
+      `);
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_chat_messages_session_id ON chat_messages(session_id);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_chat_messages_timestamp ON chat_messages(timestamp);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_user_progress_user_id ON user_progress(user_id);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_resource_documents_category_id ON resource_documents(category_id);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_quizzes_title_trgm ON quizzes USING gin (title gin_trgm_ops);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_resource_documents_title_trgm ON resource_documents USING gin (title gin_trgm_ops);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_user_artifacts_user_id ON user_artifacts(user_id);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_user_artifacts_source_applet ON user_artifacts(source_applet);`
+      );
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS s4_usage (
+          id TEXT PRIMARY KEY,
+          user_id TEXT NOT NULL,
+          model_name TEXT,
+          tokens_used INTEGER DEFAULT 0,
+          endpoint TEXT NOT NULL,
+          timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          metadata JSONB
+        );
+      `);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_s4_usage_user_id ON s4_usage(user_id);`);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_s4_usage_timestamp ON s4_usage(timestamp);`);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_s4_usage_model_name ON s4_usage(model_name);`);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS conversation_embeddings (
+          session_id UUID NOT NULL,
+          message_id UUID NOT NULL,
+          role VARCHAR(20) NOT NULL,
+          content_snippet TEXT,
+          embedding vector(384),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          PRIMARY KEY (session_id, message_id)
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS context_anchors (
+          session_id UUID NOT NULL,
+          anchor_id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          title TEXT,
+          summary TEXT,
+          embedding vector(384),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_conv_emb_session ON conversation_embeddings(session_id);`
+      );
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_ctx_anchor_session ON context_anchors(session_id);`
+      );
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS run_spans (
+          trace_id TEXT NOT NULL,
+          span_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          start_time TIMESTAMP NOT NULL,
+          end_time TIMESTAMP,
+          attributes JSONB,
+          PRIMARY KEY (trace_id, span_id)
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS run_span_events (
+          trace_id TEXT NOT NULL,
+          span_id TEXT NOT NULL,
+          ts TIMESTAMP NOT NULL,
+          event TEXT NOT NULL,
+          attributes JSONB,
+          PRIMARY KEY (trace_id, span_id, ts, event)
+        );
+      `);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_run_spans_trace ON run_spans(trace_id);`);
+      await tx.query(
+        `CREATE INDEX IF NOT EXISTS idx_run_span_events_trace ON run_span_events(trace_id);`
+      );
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS stacks (
+          id TEXT PRIMARY KEY,
+          name TEXT,
+          manifest JSONB NOT NULL,
+          shape_hash TEXT,
+          deleted_at TIMESTAMP,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS policy_asks (
+          id UUID PRIMARY KEY DEFAULT COALESCE(uuid_generate_v4(), gen_random_uuid()),
+          stack_id TEXT NOT NULL,
+          node_id TEXT NOT NULL,
+          url TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          decided_at TIMESTAMP
+        );
+      `);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_policy_asks_stack ON policy_asks(stack_id);`);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_policy_asks_status ON policy_asks(status);`);
+      await tx.query(`
+        CREATE TABLE IF NOT EXISTS replays (
+          id TEXT PRIMARY KEY,
+          owner_user_id UUID REFERENCES user_profiles(user_id) ON DELETE SET NULL,
+          blob_url TEXT NOT NULL,
+          events_count INTEGER,
+          visibility TEXT DEFAULT 'public',
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+      await tx.query(`CREATE INDEX IF NOT EXISTS idx_replays_owner ON replays(owner_user_id);`);
+      console.log("Database schema initialized successfully");
+      onProgress?.({ step: "done", label: "Ready", status: "done" });
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("Failed to initialize database schema:", errorMessage);
+    if (errorMessage.includes("syntax error")) {
+      console.error("SQL syntax error during initialization. Check PGLite compatibility.");
+    } else if (errorMessage.includes("extension")) {
+      console.error("Extension loading failed. Some features may not be available.");
+    }
+    throw new Error(`Database initialization failed: ${errorMessage}`);
+  }
+}
+
+// ../../lib/pglite/db.ts
+var DEFAULT_SCOPE = { kind: "global", id: "main" };
+var currentScope = DEFAULT_SCOPE;
+function sanitizeScopeId(input) {
+  return input.toLowerCase().replace(/[^a-z0-9_-]+/g, "_").slice(0, 64);
+}
+function scopeToId(scope) {
+  switch (scope.kind) {
+    case "global":
+      return scope.id ?? "main";
+    case "user":
+      return scope.userId;
+    case "session":
+      return scope.sessionId;
+    case "custom":
+      return scope.name;
+  }
+}
+function getDataDirForScope(scope) {
+  const id = sanitizeScopeId(scopeToId(scope));
+  return `idb://terminals_${scope.kind}_${id}`;
+}
+var currentDataDir = getDataDirForScope(currentScope);
+var PGLiteConnectionPool = class _PGLiteConnectionPool {
+  static instance = null;
+  connection = null;
+  isInitialized = false;
+  initializationPromise = null;
+  dataDir = currentDataDir;
+  initGeneration = 0;
+  // Monotonic counter — only the latest init can mutate status
+  // Status tracking (consumed by usePGLiteStatus hook via useSyncExternalStore)
+  initStatus = "idle";
+  initError = null;
+  statusListeners = /* @__PURE__ */ new Set();
+  progressSteps = [];
+  cachedStatusSnapshot = { status: "idle", error: null, steps: [] };
+  // L1 Core circuit breaker — prevents cascading init attempts after repeated failures.
+  // Opens after 3 failures, half-open after 30s allows one probe attempt.
+  circuitBreaker = createCircuitBreaker({
+    failureThreshold: 3,
+    resetTimeoutMs: 3e4,
+    halfOpenRequests: 1
+  });
+  // Health monitor state
+  healthMonitorInterval = null;
+  healthMonitorFailures = 0;
+  static MAX_HEALTH_FAILURES = 5;
+  static HEALTH_MONITOR_INTERVAL_MS = 35e3;
+  constructor() {
+  }
+  notifyStatusChange() {
+    this.cachedStatusSnapshot = {
+      status: this.initStatus,
+      error: this.initError,
+      steps: this.progressSteps
+    };
+    for (const cb of this.statusListeners) {
+      try {
+        cb();
+      } catch (e) {
+        console.warn("[PGLite] Status listener error:", e);
+      }
+    }
+  }
+  addProgressStep(p) {
+    const idx = this.progressSteps.findIndex((s) => s.step === p.step);
+    if (idx >= 0) {
+      this.progressSteps[idx] = p;
+    } else {
+      this.progressSteps.push(p);
+    }
+    this.progressSteps = [...this.progressSteps];
+    this.notifyStatusChange();
+  }
+  getInitStatus() {
+    return this.cachedStatusSnapshot;
+  }
+  onInitStatusChange(cb) {
+    this.statusListeners.add(cb);
+    return () => {
+      this.statusListeners.delete(cb);
+    };
+  }
+  /** Expose circuit breaker state for health monitoring */
+  getCircuitState() {
+    return this.circuitBreaker.getState();
+  }
+  static getInstance() {
+    if (!_PGLiteConnectionPool.instance) {
+      _PGLiteConnectionPool.instance = new _PGLiteConnectionPool();
+    }
+    return _PGLiteConnectionPool.instance;
+  }
+  async initialize() {
+    if (typeof window === "undefined" && typeof document === "undefined") return;
+    if (this.isInitialized) return;
+    if (this.initializationPromise) return this.initializationPromise;
+    const cbState = this.circuitBreaker.getState();
+    if (cbState.isOpen && cbState.nextAttempt && Date.now() < cbState.nextAttempt) {
+      this.initStatus = "failed";
+      this.initError = `Circuit open \u2014 too many init failures. Next attempt after ${new Date(cbState.nextAttempt).toISOString()}`;
+      this.notifyStatusChange();
+      throw new Error(this.initError);
+    }
+    this.initializationPromise = this.circuitBreaker.execute(() => this.doInitialize()).catch((err) => {
+      this.initializationPromise = null;
+      if (this.circuitBreaker.getState().isOpen) {
+        this.startHealthMonitor();
+      }
+      throw err;
+    });
+    return this.initializationPromise;
+  }
+  /**
+   * Boot the WASM worker. Extracted so `withRetry` can wrap just this step.
+   * Each retry creates a fresh Worker — previous failed workers are abandoned.
+   */
+  /** Max time to wait for WASM worker boot before giving up. */
+  static BOOT_TIMEOUT_MS = 3e4;
+  async bootInMainThreadFallback(expectedDataDir) {
+    const [
+      { PGlite },
+      { vector },
+      { uuid_ossp },
+      { pg_trgm },
+      { ltree },
+      { seg },
+      { tcn },
+      { tablefunc }
+    ] = await Promise.all([
+      import("@electric-sql/pglite"),
+      import("@electric-sql/pglite/vector"),
+      import("@electric-sql/pglite/contrib/uuid_ossp"),
+      import("@electric-sql/pglite/contrib/pg_trgm"),
+      import("@electric-sql/pglite/contrib/ltree"),
+      import("@electric-sql/pglite/contrib/seg"),
+      import("@electric-sql/pglite/contrib/tcn"),
+      import("@electric-sql/pglite/contrib/tablefunc")
+    ]);
+    const db = new PGlite(expectedDataDir, {
+      extensions: {
+        vector,
+        uuid_ossp,
+        pg_trgm,
+        ltree,
+        seg,
+        tcn,
+        tablefunc,
+        live
+      }
+    });
+    await db.waitReady;
+    return db;
+  }
+  shouldPreferCompatibilityMode() {
+    if (typeof window === "undefined") return false;
+    if (process.env.NEXT_PUBLIC_PGLITE_FORCE_COMPAT_MODE === "true") return true;
+    const host = window.location.hostname;
+    const isVercelPreview = host.endsWith(".vercel.app");
+    return isVercelPreview;
+  }
+  async bootWorker(expectedDataDir) {
+    if (this.dataDir !== expectedDataDir) {
+      throw new Error("Scope changed during boot");
+    }
+    if (this.shouldPreferCompatibilityMode()) {
+      this.addProgressStep({
+        step: "fallback",
+        label: "Compatibility mode (preview)",
+        status: "active"
+      });
+      const db = await this.bootInMainThreadFallback(expectedDataDir);
+      this.addProgressStep({
+        step: "fallback",
+        label: "Compatibility mode active",
+        status: "done"
+      });
+      return db;
+    }
+    const workerScript = new Worker(
+      new URL("../../public/workers/pglite-worker.js", import.meta.url),
+      { type: "module" }
+    );
+    const workerOptions = {
+      extensions: { live },
+      dataDir: this.dataDir
+    };
+    let timeoutId = null;
+    const bootPromise = PGliteWorker.create(workerScript, workerOptions).then(async (db) => {
+      await db.waitReady;
+      return db;
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        try {
+          workerScript.terminate();
+        } catch {
+        }
+        reject(new Error("Database loading timed out \u2014 click retry"));
+      }, _PGLiteConnectionPool.BOOT_TIMEOUT_MS);
+    });
+    try {
+      return await Promise.race([bootPromise, timeoutPromise]);
+    } catch (workerErr) {
+      this.addProgressStep({
+        step: "fallback",
+        label: "Switching to compatibility mode",
+        status: "active"
+      });
+      try {
+        const fallbackDb = await this.bootInMainThreadFallback(expectedDataDir);
+        this.addProgressStep({
+          step: "fallback",
+          label: "Compatibility mode active",
+          status: "done"
+        });
+        return fallbackDb;
+      } catch (fallbackErr) {
+        this.addProgressStep({
+          step: "fallback",
+          label: fallbackErr instanceof Error ? `Compatibility mode failed: ${fallbackErr.message}` : "Compatibility mode failed",
+          status: "done"
+        });
+        throw workerErr;
+      }
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+  async doInitialize() {
+    if (typeof window === "undefined" && typeof document === "undefined") return;
+    const initDataDir = this.dataDir;
+    const myGeneration = ++this.initGeneration;
+    const isStale = () => this.initGeneration !== myGeneration;
+    this.initStatus = "initializing";
+    this.initError = null;
+    this.progressSteps = [];
+    this.notifyStatusChange();
+    try {
+      this.addProgressStep({ step: "wasm", label: "Loading database", status: "active" });
+      const typedDb = await withRetry(() => this.bootWorker(initDataDir), {
+        maxAttempts: 3,
+        baseDelayMs: 1500,
+        maxDelayMs: 12e3,
+        jitter: 0.2,
+        shouldRetry: (error, _attempt) => {
+          if (isStale()) return false;
+          if (this.dataDir !== initDataDir) return false;
+          if (error.message.includes("not found") || error.message.includes("404")) return false;
+          if (error.message === "Scope changed during boot") return false;
+          return true;
+        },
+        onRetry: (error, attempt, delayMs) => {
+          if (isStale()) return;
+          console.warn(`[PGLite] WASM boot retry ${attempt}/3 in ${delayMs}ms:`, error.message);
+          this.addProgressStep({
+            step: "wasm",
+            label: `Retrying (${attempt}/3)...`,
+            status: "active"
+          });
+        }
+      });
+      if (isStale()) {
+        try {
+          typedDb.close?.();
+        } catch (e) {
+          console.warn("[PGLite] Close on stale:", e);
+        }
+        return;
+      }
+      this.addProgressStep({ step: "wasm", label: "Database loaded", status: "done" });
+      if (this.dataDir !== initDataDir) {
+        try {
+          typedDb.close?.();
+        } catch (e) {
+          console.warn("[PGLite] Close on stale:", e);
+        }
+        this.initializationPromise = null;
+        this.initStatus = "idle";
+        this.notifyStatusChange();
+        return;
+      }
+      await initializeSchema(typedDb, (p) => {
+        if (!isStale()) this.addProgressStep(p);
+      });
+      if (this.dataDir !== initDataDir || isStale()) {
+        try {
+          typedDb.close?.();
+        } catch (e) {
+          console.warn("[PGLite] Close on stale:", e);
+        }
+        this.initializationPromise = null;
+        if (!isStale()) {
+          this.initStatus = "idle";
+          this.notifyStatusChange();
+        }
+        return;
+      }
+      this.addProgressStep({ step: "done", label: "Database ready", status: "done" });
+      this.connection = typedDb;
+      this.isInitialized = true;
+      this.initStatus = "ready";
+      this.notifyStatusChange();
+    } catch (error) {
+      if (this.dataDir === initDataDir && !isStale()) {
+        const msg = error instanceof Error ? error.message : String(error);
+        this.initStatus = "failed";
+        this.initError = msg;
+        this.notifyStatusChange();
+        console.error("[PGLite] Init failed after retries:", msg);
+        throw error;
+      }
+      this.initializationPromise = null;
+    }
+  }
+  /** Return the single connection. Must be initialized first. */
+  getConnection() {
+    if (!this.connection) {
+      throw new Error("[PGLite] No connection available \u2014 not initialized");
+    }
+    return this.connection;
+  }
+  /** Run an operation against the single connection. */
+  async withConnection(operation) {
+    await this.initialize();
+    return operation(this.getConnection());
+  }
+  /** Close current connection and prepare for new scope. */
+  resetForScope(dataDir) {
+    this.stopHealthMonitor();
+    this.healthMonitorFailures = 0;
+    if (this.connection) {
+      try {
+        this.connection.close?.();
+      } catch (e) {
+        console.warn("[PGLite] Close error:", e);
+      }
+    }
+    this.connection = null;
+    this.isInitialized = false;
+    this.initializationPromise = null;
+    this.dataDir = dataDir;
+    this.initStatus = "idle";
+    this.initError = null;
+    this.progressSteps = [];
+    this.circuitBreaker.reset();
+    this.notifyStatusChange();
+  }
+  shutdown() {
+    this.stopHealthMonitor();
+    this.healthMonitorFailures = 0;
+    if (this.connection) {
+      try {
+        this.connection.close?.();
+      } catch (e) {
+        console.warn("[PGLite] Close error:", e);
+      }
+    }
+    this.connection = null;
+    this.isInitialized = false;
+    this.initializationPromise = null;
+    this.circuitBreaker.reset();
+  }
+  getStats() {
+    return {
+      poolSize: this.connection ? 1 : 0,
+      availableConnections: this.connection && this.isInitialized ? 1 : 0,
+      busyConnections: 0,
+      isInitialized: this.isInitialized,
+      averageQueryTime: 0
+    };
+  }
+  getPoolStatus() {
+    return { active: 0, idle: this.connection ? 1 : 0, total: this.connection ? 1 : 0 };
+  }
+  async healthCheck() {
+    try {
+      if (!this.connection) return false;
+      await this.connection.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Start automatic health monitoring for circuit breaker recovery.
+   * When circuit is open, periodically probes via half-open path.
+   * Stops after MAX_HEALTH_FAILURES consecutive probe failures.
+   */
+  startHealthMonitor() {
+    if (this.healthMonitorInterval) return;
+    this.healthMonitorInterval = setInterval(async () => {
+      const cbState = this.circuitBreaker.getState();
+      if (!cbState.isOpen) {
+        this.healthMonitorFailures = 0;
+        return;
+      }
+      if (this.healthMonitorFailures >= _PGLiteConnectionPool.MAX_HEALTH_FAILURES) {
+        this.stopHealthMonitor();
+        console.warn(
+          "[PGLite] Health monitor stopped after",
+          this.healthMonitorFailures,
+          "consecutive failures. Call retryDbInit() manually."
+        );
+        return;
+      }
+      try {
+        this.initializationPromise = null;
+        await this.initialize();
+        this.healthMonitorFailures = 0;
+        console.info("[PGLite] Health monitor: circuit recovered");
+      } catch {
+        this.healthMonitorFailures++;
+        console.warn(
+          `[PGLite] Health monitor probe failed (${this.healthMonitorFailures}/${_PGLiteConnectionPool.MAX_HEALTH_FAILURES})`
+        );
+      }
+    }, _PGLiteConnectionPool.HEALTH_MONITOR_INTERVAL_MS);
+  }
+  stopHealthMonitor() {
+    if (this.healthMonitorInterval) {
+      clearInterval(this.healthMonitorInterval);
+      this.healthMonitorInterval = null;
+    }
+  }
+  // Kept for import compat — no-ops for single connection
+  releaseConnection(_connection) {
+  }
+  forceRecycleStale(_maxAgeMs) {
+    return 0;
+  }
+};
+var connectionManager = PGLiteConnectionPool.getInstance();
+function getDbInitStatus() {
+  return connectionManager.getInitStatus();
+}
+function onDbInitStatusChange(cb) {
+  return connectionManager.onInitStatusChange(cb);
+}
+async function retryDbInit() {
+  const { status } = connectionManager.getInitStatus();
+  if (status === "ready") {
+    const healthy = await connectionManager.healthCheck();
+    if (healthy) return;
+  }
+  connectionManager.resetForScope(currentDataDir);
+  await connectionManager.initialize();
+}
+async function restartDbInit() {
+  connectionManager.resetForScope(currentDataDir);
+  await connectionManager.initialize();
+}
+async function forceHardReset() {
+  connectionManager.shutdown();
+  try {
+    const { deleteDatabaseByDataDir } = await import("./storage-L7MWNSPG.js");
+    await deleteDatabaseByDataDir(currentDataDir);
+  } catch (err) {
+    console.warn("[PGLite] forceHardReset: IDB delete failed (continuing anyway):", err);
+  }
+  connectionManager.resetForScope(currentDataDir);
+  await connectionManager.initialize();
+}
+function isDatabaseReady() {
+  if (typeof window === "undefined" && typeof document === "undefined") return false;
+  return connectionManager.getStats().isInitialized;
+}
+async function getDB() {
+  if (typeof window === "undefined" && typeof document === "undefined") {
+    throw new Error("PGLite is browser-only");
+  }
+  const { status, error } = connectionManager.getInitStatus();
+  if (status === "idle") {
+    throw new Error("Database not yet initialized \u2014 PGLiteProvider has not set scope");
+  }
+  if (status === "failed") {
+    console.warn("[PGLite] getDB() called in failed state \u2014 attempting via circuit breaker");
+    try {
+      await connectionManager.initialize();
+      return connectionManager.getConnection();
+    } catch (retryErr) {
+      throw new Error(
+        `Database initialization failed: ${error ?? (retryErr instanceof Error ? retryErr.message : "unknown error")}`
+      );
+    }
+  }
+  await connectionManager.initialize();
+  return connectionManager.getConnection();
+}
+async function withDB(operation) {
+  const db = await getDB();
+  return operation(db);
+}
+async function withTransaction(operation) {
+  return withDB((db) => db.transaction(operation));
+}
+function getConnectionPoolStats() {
+  return connectionManager.getStats();
+}
+async function checkConnectionPoolHealth() {
+  return connectionManager.healthCheck();
+}
+function getDbHealth() {
+  return {
+    isReady: isDatabaseReady(),
+    stats: connectionManager.getStats(),
+    circuit: connectionManager.getCircuitState()
+  };
+}
+function getPoolStatus() {
+  return connectionManager.getPoolStatus();
+}
+function forceRecycleStale(_maxAgeMs) {
+  return 0;
+}
+async function getSchemaVersion() {
+  try {
+    const pool = PGLiteConnectionPool.getInstance();
+    const db = pool.getConnection();
+    const result = await db.query(
+      "SELECT version FROM schema_version LIMIT 1"
+    );
+    return result.rows[0]?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function shutdownPool() {
+  connectionManager.shutdown();
+  pgInstance = null;
+  instancePromise = null;
+}
+function getCurrentScope() {
+  return currentScope;
+}
+function getCurrentDataDir() {
+  return currentDataDir;
+}
+function setDbScope(scope) {
+  const nextDataDir = getDataDirForScope(scope);
+  if (nextDataDir === currentDataDir) {
+    currentScope = scope;
+    return;
+  }
+  currentScope = scope;
+  currentDataDir = nextDataDir;
+  connectionManager.resetForScope(nextDataDir);
+  pgInstance = null;
+  instancePromise = null;
+}
+var pgInstance = null;
+var instancePromise = null;
+async function getDatabase() {
+  if (pgInstance) return pgInstance;
+  if (instancePromise) return instancePromise;
+  instancePromise = (async () => {
+    try {
+      const workerScript = new Worker(
+        new URL("../../public/workers/pglite-worker.js", import.meta.url),
+        { type: "module" }
+      );
+      const workerOptions = {
+        extensions: { live },
+        dataDir: currentDataDir
+      };
+      const dbFromCreate = await PGliteWorker.create(workerScript, workerOptions);
+      await dbFromCreate.waitReady;
+      const fullyTypedDb = dbFromCreate;
+      await initializeSchema(fullyTypedDb);
+      pgInstance = fullyTypedDb;
+      return fullyTypedDb;
+    } catch (error) {
+      console.error("Failed to initialize PGLite:", error);
+      instancePromise = null;
+      throw error;
+    }
+  })();
+  return instancePromise;
+}
+
+export {
+  DORMANT_BIOSIGNAL_BRIDGES,
+  isBiosignalBridgeId,
+  DORMANT_BIOSIGNAL_PROVIDERS,
+  isBiosignalProviderId,
+  initializeSchema,
+  getDataDirForScope,
+  PGLiteConnectionPool,
+  getDbInitStatus,
+  onDbInitStatusChange,
+  retryDbInit,
+  restartDbInit,
+  forceHardReset,
+  isDatabaseReady,
+  getDB,
+  withDB,
+  withTransaction,
+  getConnectionPoolStats,
+  checkConnectionPoolHealth,
+  getDbHealth,
+  getPoolStatus,
+  forceRecycleStale,
+  getSchemaVersion,
+  shutdownPool,
+  getCurrentScope,
+  getCurrentDataDir,
+  setDbScope,
+  getDatabase
+};