@piwitests/server 0.25.0 → 0.26.0

package/.output/server/chunks/build/db.client-DijpEH6i.mjs

@@ -1,1101 +0,0 @@
-import * as initSqlJsLib from 'sql.js';
-import { drizzle } from 'drizzle-orm/sqlite-proxy';
-import { sqliteTable, integer, text, uniqueIndex, index, real, primaryKey } from 'drizzle-orm/sqlite-core';
-import { sql } from 'drizzle-orm';
-
-const projects = sqliteTable(
-  "projects",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    name: text("name").notNull().unique(),
-    label: text("label"),
-    // Display label (defaults to name if not set)
-    description: text("description"),
-    diagnosisInstructions: text("diagnosis_instructions"),
-    scmToken: text("scm_token"),
-    // Per-project SCM token for GitHub/GitLab/Bitbucket API access
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    updatedAtIdx: index("idx_projects_updated_at").on(table.updatedAt)
-  })
-);
-const testRuns = sqliteTable(
-  "test_runs",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    status: text("status").notNull(),
-    // 'passed', 'failed', 'timedout', 'interrupted', 'running', 'cancelled', 'initialising', 'finalizing'
-    startTime: integer("start_time", { mode: "timestamp" }).notNull(),
-    duration: integer("duration"),
-    // in milliseconds
-    totalTests: integer("total_tests").notNull().default(0),
-    passedTests: integer("passed_tests").notNull().default(0),
-    failedTests: integer("failed_tests").notNull().default(0),
-    skippedTests: integer("skipped_tests").notNull().default(0),
-    didNotRunTests: integer("did_not_run_tests").notNull().default(0),
-    // Tests that never executed (maxFailures cutoff or serial-group failure)
-    flakyTests: integer("flaky_tests").notNull().default(0),
-    avgTestDuration: integer("avg_test_duration"),
-    // average test case duration in ms
-    p90TestDuration: integer("p90_test_duration"),
-    // 90th percentile test duration in ms
-    shardTotal: integer("shard_total"),
-    // Total number of shards for sharded runs; null = not sharded
-    shardsFinished: integer("shards_finished").notNull().default(0),
-    // How many shards have finished
-    isFullRun: integer("is_full_run").notNull().default(1),
-    // 1 = full suite, 0 = partial/filtered (--grep, file filter, etc.)
-    filterDetails: text("filter_details", { mode: "json" }),
-    // JSON: { grep?, grepInvert? }
-    environment: text("environment"),
-    // Deployment environment (e.g. 'production', 'staging', 'development')
-    metadata: text("metadata", { mode: "json" }),
-    // Additional metadata as JSON
-    setupSteps: text("setup_steps", { mode: "json" }),
-    // Array of suite-level hook/fixture steps (beforeAll/afterAll) for the timeline
-    label: text("label"),
-    // Optional human-readable label (e.g. "v2.3.1 release")
-    streamToken: text("stream_token"),
-    // Token for authenticating streaming updates
-    instanceId: text("instance_id"),
-    // Unique identifier for the reporter instance that created this run
-    playwrightVersion: text("playwright_version"),
-    // Playwright framework version used for this run
-    reporterVersion: text("reporter_version"),
-    // Piwi reporter package version that produced this run
-    importHash: text("import_hash"),
-    // SHA-256 of the imported archive; null for reported runs. Makes re-importing a no-op.
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectIdIdx: index("idx_test_runs_project_id").on(table.projectId),
-    projectStartTimeIdx: index("idx_test_runs_project_start").on(table.projectId, table.startTime),
-    startTimeIdx: index("idx_test_runs_start_time").on(table.startTime),
-    statusIdx: index("idx_test_runs_status").on(table.status),
-    importHashIdx: uniqueIndex("idx_test_runs_import_hash").on(table.projectId, table.importHash)
-  })
-);
-const testSuites = sqliteTable(
-  "test_suites",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    filePath: text("file_path").notNull(),
-    suitePath: text("suite_path").notNull(),
-    // \x1f-delimited full path, e.g. 'Auth\x1fLogin'
-    mode: text("mode").notNull().default("default"),
-    // 'parallel' | 'serial' | 'default'
-    annotations: text("annotations", { mode: "json" }),
-    // Array<{ type, description? }>
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    uniqueIdx: uniqueIndex("idx_test_suites_unique").on(table.projectId, table.filePath, table.suitePath)
-  })
-);
-const testCases = sqliteTable(
-  "test_cases",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    filePath: text("file_path").notNull(),
-    // relative path from project root
-    suitePath: text("suite_path").notNull().default(""),
-    // \x1f-delimited describe block path, e.g. 'Auth\x1fLogin'
-    suiteId: integer("suite_id").references(() => testSuites.id),
-    // FK to immediate parent describe block (null for root-level tests)
-    title: text("title").notNull(),
-    flakyRootCause: text("flaky_root_cause"),
-    // 'timing' | 'network' | 'assertion' | 'environment' | 'other'
-    // Latest-known test-level tags and `piwi:` metadata, refreshed on every run
-    // that reports this test. Per-execution truth lives on test_runs_cases;
-    // these denormalized columns let project-wide views filter without a join.
-    tags: text("tags", { mode: "json" }),
-    // string[] — normalized, '@' stripped
-    owner: text("owner"),
-    priority: text("priority"),
-    // 'critical' | 'high' | 'medium' | 'low'
-    feature: text("feature"),
-    link: text("link"),
-    // absolute http(s) URL
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectIdIdx: index("idx_test_cases_project_id").on(table.projectId),
-    filePathTitleIdx: index("idx_test_cases_file_path_title").on(
-      table.projectId,
-      table.filePath,
-      table.suitePath,
-      table.title
-    ),
-    suiteIdIdx: index("idx_test_cases_suite").on(table.suiteId),
-    ownerIdx: index("idx_test_cases_owner").on(table.projectId, table.owner)
-  })
-);
-const quarantinedTests = sqliteTable(
-  "quarantined_tests",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    testCaseId: integer("test_case_id").notNull().references(() => testCases.id, { onDelete: "cascade" }),
-    reason: text("reason"),
-    source: text("source").notNull().default("manual"),
-    // 'manual' | 'proposed'
-    /** Run id at quarantine time — passes are counted from after this run. */
-    quarantinedAtRunId: integer("quarantined_at_run_id"),
-    createdBy: integer("created_by").references(() => users.id, { onDelete: "set null" }),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    /** Null while active; set when the test is let back out. */
-    releasedAt: integer("released_at", { mode: "timestamp" }),
-    releasedReason: text("released_reason")
-  },
-  (table) => ({
-    projectIdx: index("idx_quarantined_tests_project").on(table.projectId, table.releasedAt),
-    createdByIdx: index("idx_quarantined_tests_created_by").on(table.createdBy),
-    // One active quarantine per test; released rows stay as history.
-    activeUnique: uniqueIndex("idx_quarantined_tests_active").on(table.testCaseId).where(sql`released_at IS NULL`)
-  })
-);
-const failureClusters = sqliteTable(
-  "failure_clusters",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    fingerprint: text("fingerprint").notNull(),
-    // SHA-256 over FINGERPRINT_VERSION + normalized error signals (shared/error-fingerprint.ts)
-    signature: text("signature").notNull(),
-    // normalized first error line — human-readable cluster name
-    errorType: text("error_type"),
-    // 'timeout', 'assertion', 'strict-mode', 'navigation', 'crash', 'unknown'
-    selector: text("selector"),
-    // locator extracted from the error, if any
-    sampleError: text("sample_error"),
-    // one full raw error kept for display
-    // Run ids are intentionally NOT foreign keys: runs are deleted independently
-    // and clusters must survive them (stale ids are tolerated)
-    firstSeenRunId: integer("first_seen_run_id").notNull(),
-    lastSeenRunId: integer("last_seen_run_id").notNull(),
-    status: text("status").notNull().default("open"),
-    // 'open', 'resolved', 'ignored' — triage workflow
-    triageNote: text("triage_note"),
-    // Optional comment attached when triaging (status change)
-    manualBaseCommit: text("manual_base_commit"),
-    // user-pinned baseline commit SHA for AI diagnosis diff context
-    occurrences: integer("occurrences").notNull().default(0),
-    // denormalized count of linked test_runs_cases rows (not decremented on run deletion)
-    title: text("title"),
-    // short human-readable cluster name generated by a cheap model; falls back to `signature`
-    embedding: text("embedding"),
-    // JSON-encoded number[] — semantic centroid for near-duplicate clustering (Phase 2)
-    embeddingModel: text("embedding_model"),
-    // `<model>#v<N>` tag (model id + embed-input recipe version) that produced `embedding`; vectors are only compared within one tag, stale ones are re-embedded by the reconciler's backfill
-    // Fix verification — set when a later run stops failing this cluster, so
-    // "did my fix work?" is answered rather than merely asked.
-    fixLandedRunId: integer("fix_landed_run_id"),
-    // the run in which every affected test passed again
-    fixLandedAt: integer("fix_landed_at", { mode: "timestamp" }),
-    fixCommit: text("fix_commit"),
-    // commit of that run, when the reporter recorded one
-    timeToResolutionMs: integer("time_to_resolution_ms"),
-    // first seen → fix landed
-    fixVerification: text("fix_verification"),
-    // 'stopped-failing' | 'diagnosis-verified' | 'regressed'
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectFingerprintIdx: uniqueIndex("idx_failure_clusters_project_fingerprint").on(
-      table.projectId,
-      table.fingerprint
-    ),
-    projectLastSeenIdx: index("idx_failure_clusters_project_last_seen").on(table.projectId, table.lastSeenRunId),
-    projectStatusIdx: index("idx_failure_clusters_project_status").on(table.projectId, table.status)
-  })
-);
-const failureClusterAliases = sqliteTable(
-  "failure_cluster_aliases",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    fingerprint: text("fingerprint").notNull(),
-    clusterId: integer("cluster_id").notNull().references(() => failureClusters.id, { onDelete: "cascade" }),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectFingerprintIdx: uniqueIndex("idx_failure_cluster_aliases_project_fingerprint").on(
-      table.projectId,
-      table.fingerprint
-    ),
-    clusterIdx: index("idx_failure_cluster_aliases_cluster").on(table.clusterId)
-  })
-);
-const clusterMergeSuggestions = sqliteTable(
-  "cluster_merge_suggestions",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    // Convention: clusterAId < clusterBId so a symmetric pair maps to one row.
-    clusterAId: integer("cluster_a_id").notNull().references(() => failureClusters.id, { onDelete: "cascade" }),
-    clusterBId: integer("cluster_b_id").notNull().references(() => failureClusters.id, { onDelete: "cascade" }),
-    score: real("score"),
-    // cosine similarity that surfaced the pair
-    method: text("method").notNull(),
-    // 'embedding' | 'llm'
-    llmConfidence: text("llm_confidence"),
-    // 'high' | 'medium' | 'low' (when method = 'llm')
-    llmReason: text("llm_reason"),
-    // adjudicator rationale
-    status: text("status").notNull().default("pending"),
-    // 'pending' | 'approved' | 'rejected'
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    pairIdx: uniqueIndex("idx_cluster_merge_suggestions_pair").on(table.clusterAId, table.clusterBId),
-    projectStatusIdx: index("idx_cluster_merge_suggestions_project_status").on(table.projectId, table.status),
-    clusterBIdx: index("idx_cluster_merge_suggestions_cluster_b").on(table.clusterBId)
-  })
-);
-const failureDiagnoses = sqliteTable(
-  "failure_diagnoses",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    // Nullable: execution-scoped diagnoses key on `testRunsCaseId` and carry no cluster
-    // (a failure may have no cluster, and it keeps the (cluster_id, scope) unique index
-    // from colliding across executions of the same cluster).
-    clusterId: integer("cluster_id").references(() => failureClusters.id, { onDelete: "cascade" }),
-    scope: text("scope").notNull().default("cluster"),
-    // 'cluster', 'execution'
-    testRunsCaseId: integer("test_runs_case_id").references(() => testRunsCases.id, { onDelete: "cascade" }),
-    contextSha: text("context_sha"),
-    // hash of the context sent, for staleness detection
-    status: text("status").notNull().default("running"),
-    // 'running', 'completed', 'failed'
-    provider: text("provider"),
-    // 'anthropic', 'openai'
-    model: text("model"),
-    // model id that produced the diagnosis
-    category: text("category"),
-    // 'app-bug', 'test-bug', 'flaky-test', 'infrastructure', 'environment', 'unknown'
-    confidence: text("confidence"),
-    // 'high', 'medium', 'low'
-    summary: text("summary"),
-    // one-line diagnosis shown in lists
-    rootCause: text("root_cause"),
-    // short root-cause explanation
-    details: text("details", { mode: "json" }),
-    // full structured result: evidence, suggestedFix, preventionTips
-    error: text("error"),
-    // failure reason when status = 'failed'
-    inputTokens: integer("input_tokens"),
-    outputTokens: integer("output_tokens"),
-    durationMs: integer("duration_ms"),
-    feedback: text("feedback"),
-    // 'up', 'down'
-    feedbackNote: text("feedback_note"),
-    // optional note from user
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    clusterScopeIdx: uniqueIndex("idx_failure_diagnoses_cluster_scope").on(table.clusterId, table.scope),
-    executionIdx: uniqueIndex("idx_failure_diagnoses_execution").on(table.testRunsCaseId, table.scope)
-  })
-);
-const failureDiagnosisVersions = sqliteTable(
-  "failure_diagnosis_versions",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    diagnosisId: integer("diagnosis_id").notNull().references(() => failureDiagnoses.id, { onDelete: "cascade" }),
-    // Nullable to match `failureDiagnoses.clusterId` (execution-scoped snapshots have no cluster).
-    clusterId: integer("cluster_id").references(() => failureClusters.id, { onDelete: "cascade" }),
-    scope: text("scope").notNull().default("cluster"),
-    testRunsCaseId: integer("test_runs_case_id").references(() => testRunsCases.id, { onDelete: "cascade" }),
-    status: text("status").notNull().default("running"),
-    provider: text("provider"),
-    model: text("model"),
-    category: text("category"),
-    confidence: text("confidence"),
-    summary: text("summary"),
-    rootCause: text("root_cause"),
-    details: text("details", { mode: "json" }),
-    error: text("error"),
-    inputTokens: integer("input_tokens"),
-    outputTokens: integer("output_tokens"),
-    durationMs: integer("duration_ms"),
-    contextSha: text("context_sha"),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    diagnosisIdIdx: index("idx_fdv_diagnosis_id").on(table.diagnosisId),
-    clusterIdIdx: index("idx_fdv_cluster_id").on(table.clusterId),
-    testRunsCaseIdx: index("idx_fdv_test_runs_case").on(table.testRunsCaseId)
-  })
-);
-const appSettings = sqliteTable("app_settings", {
-  key: text("key").primaryKey(),
-  value: text("value", { mode: "json" }),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-const casePayloads = sqliteTable(
-  "case_payloads",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    hash: text("hash").notNull(),
-    // SHA-256 hex of content
-    content: text("content").notNull(),
-    size: integer("size").notNull(),
-    // content length in characters, for storage stats
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectHashIdx: uniqueIndex("idx_case_payloads_project_hash").on(table.projectId, table.hash)
-  })
-);
-const testRunsCases = sqliteTable(
-  "test_runs_cases",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    testRunId: integer("test_run_id").notNull().references(() => testRuns.id, { onDelete: "cascade" }),
-    testCaseId: integer("test_case_id").notNull().references(() => testCases.id, { onDelete: "cascade" }),
-    status: text("status").notNull(),
-    // 'passed', 'failed', 'timedout', 'skipped'
-    duration: integer("duration"),
-    // in milliseconds
-    timeout: integer("timeout"),
-    // Effective per-test timeout in ms (TestCase.timeout); 0 = unbounded, null = unknown/legacy
-    error: text("error"),
-    failureClusterId: integer("failure_cluster_id").references(() => failureClusters.id),
-    // set for failed rows with an error — groups rows sharing a fingerprint
-    retries: integer("retries").default(0),
-    line: integer("line"),
-    // line number in file
-    column: integer("column"),
-    // column number in file
-    steps: text("steps", { mode: "json" }),
-    // Array of { title, duration, category, location?, startTime? } step objects
-    stepEvents: text("step_events", { mode: "json" }),
-    // Array of { title, category, startedAt, duration, status, location } — hook/fixture steps for timeline
-    slowestStep: text("slowest_step"),
-    // Title of the slowest step
-    slowestStepDuration: integer("slowest_step_duration"),
-    // Duration of the slowest step in ms
-    wastedTimeMs: integer("wasted_time_ms"),
-    // Aggregated ms spent in wait steps
-    webVitals: text("web_vitals", { mode: "json" }),
-    // { navigation: {...}, paint: {...} }
-    pageState: text("page_state", { mode: "json" }),
-    // URL/history/storage-keys/cookie-flags at test end (values never captured)
-    aiUsage: text("ai_usage", { mode: "json" }),
-    // { entries: string[], intents?: {template,locator,kind}[] } — replayed AI-step artifacts + their prompts
-    consoleLogs: text("console_logs", { mode: "json" }),
-    // Array of { type, text, timestamp, location } console entries
-    // Legacy inline payload columns: still readable on old rows, no longer
-    // written — new rows store these payloads content-addressed in
-    // case_payloads and reference them via the *PayloadId columns below.
-    ariaSnapshot: text("aria_snapshot"),
-    // ARIA snapshot of the page (YAML-like string from locator.ariaSnapshot())
-    testSource: text("test_source"),
-    // Source snippet around the failing assertion (sent by reporter)
-    testSourceFrames: text("test_source_frames", { mode: "json" }),
-    // Array<{ file, line, snippet }> — in-project call-stack frames (innermost first)
-    ariaSnapshotPayloadId: integer("aria_snapshot_payload_id").references(() => casePayloads.id),
-    testSourcePayloadId: integer("test_source_payload_id").references(() => casePayloads.id),
-    testSourceFramesPayloadId: integer("test_source_frames_payload_id").references(() => casePayloads.id),
-    browser: text("browser", { mode: "json" }),
-    // Playwright project/browser config: { projectName, browserName, channel, viewport }
-    browserName: text("browser_name"),
-    // Scalar browser identity (projectName) for index efficiency
-    testAnnotations: text("test_annotations", { mode: "json" }),
-    // Array<{ type, description? }> — runtime test marks (@fixme, @slow …)
-    tags: text("tags", { mode: "json" }),
-    // string[] — tags this execution declared ('@' stripped)
-    testMeta: text("test_meta", { mode: "json" }),
-    // { owner?, priority?, feature?, link? } from `piwi:` annotations
-    workerIndex: integer("worker_index"),
-    // Parallel worker index (from Playwright's parallelIndex)
-    shardIndex: integer("shard_index"),
-    // Shard index (1-based) for sharded runs; null = not sharded
-    startedAt: integer("started_at"),
-    // Unix timestamp in ms when the test started (stored/read as a plain number)
-    isNewRegression: integer("is_new_regression"),
-    // boolean: passed in baseline, failed in this run
-    isNewFlaky: integer("is_new_flaky"),
-    // boolean: no retries in baseline, retry-pass in this run
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    testRunIdIdx: index("idx_test_runs_cases_test_run_id").on(table.testRunId),
-    // Composite: covers plain test_case_id lookups (prefix) and the
-    // per-case recency sorts used by history/flakiness queries.
-    testCaseCreatedIdx: index("idx_test_runs_cases_case_created").on(table.testCaseId, table.createdAt),
-    failureClusterIdIdx: index("idx_test_runs_cases_failure_cluster_id").on(table.failureClusterId),
-    runCaseBrowserUnique: uniqueIndex("idx_test_runs_cases_run_browser").on(
-      table.testRunId,
-      table.testCaseId,
-      table.retries,
-      table.browserName
-    ),
-    // Partial indexes back the payload-GC reachability probes; populated on
-    // failures only, so the hot insert path pays almost nothing for them.
-    ariaPayloadIdx: index("idx_trc_aria_payload").on(table.ariaSnapshotPayloadId).where(sql`aria_snapshot_payload_id IS NOT NULL`),
-    sourcePayloadIdx: index("idx_trc_source_payload").on(table.testSourcePayloadId).where(sql`test_source_payload_id IS NOT NULL`),
-    framesPayloadIdx: index("idx_trc_frames_payload").on(table.testSourceFramesPayloadId).where(sql`test_source_frames_payload_id IS NOT NULL`)
-  })
-);
-const locatorSnapshots = sqliteTable(
-  "locator_snapshots",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    testCaseId: integer("test_case_id").notNull().references(() => testCases.id, { onDelete: "cascade" }),
-    location: text("location").notNull(),
-    usedMethod: text("used_method").notNull(),
-    usedArgs: text("used_args").notNull(),
-    usedArgsFp: text("used_args_fp").notNull(),
-    elementTag: text("element_tag"),
-    elementAttrs: text("element_attrs").notNull(),
-    elementText: text("element_text"),
-    alternatives: text("alternatives").notNull(),
-    lastSeenRunId: integer("last_seen_run_id").references(() => testRuns.id, {
-      onDelete: "set null"
-    }),
-    lastSeenAt: integer("last_seen_at", { mode: "timestamp_ms" }).notNull()
-  },
-  (table) => ({
-    uniqueLocation: uniqueIndex("idx_locator_snapshots_location").on(table.testCaseId, table.location),
-    fingerprintIdx: index("idx_locator_snapshots_fp").on(table.testCaseId, table.usedMethod, table.usedArgsFp),
-    // Cross-test healing looks a signature up across all of a project's cases.
-    argsFpIdx: index("idx_locator_snapshots_args_fp").on(table.usedArgsFp),
-    lastSeenRunIdx: index("idx_locator_snapshots_last_seen_run").on(table.lastSeenRunId)
-  })
-);
-const networkRequests = sqliteTable(
-  "network_requests",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    testRunsCaseId: integer("test_runs_case_id").notNull().references(() => testRunsCases.id, { onDelete: "cascade" }),
-    testRunId: integer("test_run_id").notNull().references(() => testRuns.id, { onDelete: "cascade" }),
-    method: text("method").notNull(),
-    url: text("url"),
-    // Raw URL (query-params stripped by sanitizeUrl)
-    normalizedUrl: text("normalized_url"),
-    // Route pattern for grouping (no ids, no query)
-    status: integer("status").notNull(),
-    duration: integer("duration"),
-    // Response time in ms
-    resourceType: text("resource_type"),
-    // 'fetch', 'xhr', 'document', 'other'
-    contentType: text("content_type"),
-    // Response content-type header
-    serverLogs: text("server_logs", { mode: "json" }),
-    // Backend server logs from X-Piwi-Logs header
-    serverTraces: text("server_traces", { mode: "json" })
-    // Server-side spans from X-Piwi-Trace header
-  },
-  (t) => ({
-    runIdx: index("idx_nr_run").on(t.testRunId),
-    caseStatusIdx: index("idx_nr_case").on(t.testRunsCaseId, t.status),
-    normalizedUrlIdx: index("idx_nr_normalized_url").on(t.normalizedUrl)
-  })
-);
-const traceResources = sqliteTable(
-  "trace_resources",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    // filename as stored in resources/ dir, e.g. "abc123.net"
-    path: text("path").notNull(),
-    // project-{id}/trace-resources/{name}
-    size: integer("size").notNull(),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectNameIdx: uniqueIndex("idx_trace_resources_project_name").on(table.projectId, table.name)
-  })
-);
-const traceBlobs = sqliteTable(
-  "trace_blobs",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    hash: text("hash").notNull(),
-    // SHA-256 hex digest of the trace file content
-    path: text("path").notNull(),
-    // content-addressed path: project-{id}/blobs/{hash}.zip
-    size: integer("size").notNull(),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectHashIdx: uniqueIndex("idx_trace_blobs_project_hash").on(table.projectId, table.hash)
-  })
-);
-const files = sqliteTable(
-  "files",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    testRunId: integer("test_run_id").references(() => testRuns.id, { onDelete: "cascade" }),
-    testRunsCaseId: integer("test_runs_case_id").references(() => testRunsCases.id, { onDelete: "cascade" }),
-    type: text("type").notNull(),
-    // 'report', 'trace', 'screenshot', etc.
-    subtype: text("subtype"),
-    // 'html', 'monocart', 'blob' for reports; null for traces
-    label: text("label"),
-    // Display label e.g. 'HTML Report'
-    path: text("path").notNull(),
-    // Relative path in storage
-    size: integer("size"),
-    // File/directory size in bytes
-    blobId: integer("blob_id").references(() => traceBlobs.id),
-    // Set when the file is a deduplicated trace blob
-    metadata: text("metadata", { mode: "json" }),
-    // Type-specific extras (e.g. visual-diff metrics)
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    testRunIdIdx: index("idx_files_test_run_id").on(table.testRunId),
-    testRunsCaseIdIdx: index("idx_files_test_runs_case_id").on(table.testRunsCaseId),
-    // Trace deletion refcounts blob references with a COUNT(*) on this column.
-    blobIdIdx: index("idx_files_blob_id").on(table.blobId)
-  })
-);
-const entityLinks = sqliteTable(
-  "entity_links",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    testRunId: integer("test_run_id").references(() => testRuns.id, { onDelete: "cascade" }),
-    testRunsCaseId: integer("test_runs_case_id").references(() => testRunsCases.id, { onDelete: "cascade" }),
-    testCaseId: integer("test_case_id").references(() => testCases.id, { onDelete: "cascade" }),
-    url: text("url").notNull(),
-    // Detected nature — drives the icon
-    provider: text("provider").notNull().default("generic"),
-    // 'jira' | 'github-issue' | 'github-pr' | 'gitlab-issue' | 'gitlab-mr' |
-    // 'bitbucket' | 'confluence' | 'slack' | 'linear' | 'notion' | 'generic'
-    // Smart-link enrichment (best-effort; null until/if unfurled)
-    key: text("key"),
-    // compact id, e.g. 'PROJ-123' or '#456'
-    title: text("title"),
-    // fetched or user-supplied label
-    statusText: text("status_text"),
-    // e.g. 'In Progress', 'open', 'closed'
-    statusColor: text("status_color"),
-    // resolved badge color token (e.g. 'success')
-    metadata: text("metadata", { mode: "json" }),
-    // raw unfurl payload
-    unfurledAt: integer("unfurled_at", { mode: "timestamp_ms" }),
-    // last successful fetch
-    createdBy: integer("created_by").references(() => users.id, { onDelete: "set null" }),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    runIdx: index("idx_entity_links_run").on(t.testRunId),
-    caseRunIdx: index("idx_entity_links_case_run").on(t.testRunsCaseId),
-    caseIdx: index("idx_entity_links_case").on(t.testCaseId),
-    createdByIdx: index("idx_entity_links_created_by").on(t.createdBy)
-  })
-);
-const tags = sqliteTable(
-  "tags",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    text: text("text").notNull().unique(),
-    color: text("color").notNull().default("neutral"),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    updatedAtIdx: index("idx_tags_updated_at").on(table.updatedAt)
-  })
-);
-const projectTags = sqliteTable(
-  "project_tags",
-  {
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    tagId: integer("tag_id").notNull().references(() => tags.id, { onDelete: "cascade" })
-  },
-  (table) => ({
-    pk: primaryKey({ columns: [table.projectId, table.tagId] }),
-    projectIdIdx: index("idx_project_tags_project_id").on(table.projectId),
-    tagIdIdx: index("idx_project_tags_tag_id").on(table.tagId)
-  })
-);
-const markers = sqliteTable(
-  "markers",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    occurredAt: integer("occurred_at", { mode: "timestamp" }).notNull(),
-    // The event time; drives the chart x-position
-    label: text("label").notNull(),
-    description: text("description"),
-    category: text("category").notNull().default("event"),
-    // 'deploy', 'config', 'infra', 'incident', 'release', 'event'
-    environment: text("environment"),
-    // Optional scope; null = applies to all environments
-    source: text("source").notNull().default("manual"),
-    // 'manual' | 'auto'
-    runId: integer("run_id").references(() => testRuns.id, { onDelete: "set null" }),
-    // Optional link to the run that triggered/relates to the marker
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectIdIdx: index("idx_markers_project_id").on(table.projectId),
-    projectOccurredIdx: index("idx_markers_project_occurred").on(table.projectId, table.occurredAt),
-    runIdIdx: index("idx_markers_run_id").on(table.runId)
-  })
-);
-const users = sqliteTable(
-  "users",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    username: text("username").notNull().unique(),
-    password: text("password").notNull(),
-    // hashed password (empty string for OAuth-only users)
-    role: text("role").notNull(),
-    // Role enum: 'administrator', 'reporter', 'user'
-    name: text("name"),
-    // Display name
-    email: text("email"),
-    // Email address (nullable; OAuth callback can populate it)
-    emailVerified: integer("email_verified", { mode: "boolean" }).notNull().default(false),
-    avatarUrl: text("avatar_url"),
-    // Avatar from OAuth provider
-    oauthProvider: text("oauth_provider"),
-    // 'google', 'github', etc.
-    oauthProviderId: text("oauth_provider_id"),
-    // User ID from the OAuth provider
-    // Incremented to revoke all of a user's existing sessions (password change/reset, role change, unlink).
-    sessionEpoch: integer("session_epoch").notNull().default(0),
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    oauthIdx: uniqueIndex("idx_users_oauth").on(table.oauthProvider, table.oauthProviderId),
-    emailIdx: uniqueIndex("idx_users_email").on(table.email)
-  })
-);
-const accountTokens = sqliteTable(
-  "account_tokens",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    userId: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    purpose: text("purpose").notNull(),
-    // 'reset' | 'verify' | 'invite'
-    tokenHash: text("token_hash").notNull(),
-    // SHA-256 of the emailed token
-    expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
-    usedAt: integer("used_at", { mode: "timestamp_ms" }),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    hashIdx: uniqueIndex("idx_account_tokens_hash").on(t.tokenHash),
-    userIdx: index("idx_account_tokens_user").on(t.userId)
-  })
-);
-const notificationChannels = sqliteTable(
-  "notification_channels",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    name: text("name").notNull(),
-    type: text("type").notNull(),
-    // 'email' | 'slack' | 'webhook'
-    config: text("config", { mode: "json" }),
-    // { address } | { webhookUrl } | { url, secret (encrypted) }
-    userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }),
-    // null = global (admin-managed)
-    verified: integer("verified", { mode: "boolean" }).notNull().default(false),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    userIdx: index("idx_notification_channels_user").on(t.userId)
-  })
-);
-const subscriptions = sqliteTable(
-  "subscriptions",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }),
-    channelId: integer("channel_id").notNull().references(() => notificationChannels.id, { onDelete: "cascade" }),
-    projectId: integer("project_id").references(() => projects.id, { onDelete: "cascade" }),
-    // null = all projects
-    events: text("events", { mode: "json" }),
-    // string[] of event keys
-    filters: text("filters", { mode: "json" }),
-    // { branches?, tags?, statuses?, defaultBranchOnly?, flakinessThreshold?, perfRegressionPct? }
-    mode: text("mode").notNull().default("realtime"),
-    // 'realtime' | 'digest'
-    digestAt: text("digest_at"),
-    // 'HH:mm' UTC for daily digest
-    mutedUntil: integer("muted_until", { mode: "timestamp_ms" }),
-    active: integer("active", { mode: "boolean" }).notNull().default(true),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    projectIdx: index("idx_subscriptions_project").on(t.projectId),
-    userIdx: index("idx_subscriptions_user").on(t.userId),
-    channelIdx: index("idx_subscriptions_channel").on(t.channelId)
-  })
-);
-const notificationDeliveries = sqliteTable(
-  "notification_deliveries",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    subscriptionId: integer("subscription_id").references(() => subscriptions.id, { onDelete: "cascade" }),
-    channelId: integer("channel_id").notNull().references(() => notificationChannels.id, { onDelete: "cascade" }),
-    event: text("event").notNull(),
-    payload: text("payload", { mode: "json" }),
-    dedupeKey: text("dedupe_key"),
-    // e.g. `${event}:${runId}:${channelId}` — prevents double-send
-    status: text("status").notNull().default("pending"),
-    // 'pending' | 'sent' | 'failed' | 'skipped'
-    attempts: integer("attempts").notNull().default(0),
-    error: text("error"),
-    scheduledFor: integer("scheduled_for", { mode: "timestamp_ms" }),
-    // digest batching / backoff
-    sentAt: integer("sent_at", { mode: "timestamp_ms" }),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    statusScheduledIdx: index("idx_notification_deliveries_status").on(t.status, t.scheduledFor),
-    dedupeKeyIdx: uniqueIndex("idx_notification_deliveries_dedupe").on(t.dedupeKey),
-    subscriptionIdx: index("idx_notification_deliveries_subscription").on(t.subscriptionId),
-    channelIdx: index("idx_notification_deliveries_channel").on(t.channelId)
-  })
-);
-const projectAssignments = sqliteTable(
-  "project_assignments",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    userId: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    // null = affectation GLOBALE (tous les projets, présents et futurs)
-    projectId: integer("project_id").references(() => projects.id, { onDelete: "cascade" }),
-    createdBy: integer("created_by").references(() => users.id, { onDelete: "set null" }),
-    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (t) => ({
-    userIdx: index("idx_project_assignments_user").on(t.userId),
-    projectIdx: index("idx_project_assignments_project").on(t.projectId),
-    userProjectUnique: uniqueIndex("idx_project_assignments_user_project").on(t.userId, t.projectId),
-    createdByIdx: index("idx_project_assignments_created_by").on(t.createdBy)
-  })
-);
-const testFunctions = sqliteTable(
-  "test_functions",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    projectId: integer("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    kind: text("kind").notNull(),
-    // 'page-object-method' | 'helper' | 'fixture'
-    module: text("module").notNull(),
-    // import specifier, e.g. './pages/CartPage'
-    receiver: text("receiver"),
-    // instance variable name for page-object-method, e.g. 'cartPage'; null otherwise
-    importName: text("import_name"),
-    // class name to import + instantiate for page-object-method; null otherwise
-    params: text("params").notNull(),
-    // JSON: FunctionParam[]
-    returnsPage: integer("returns_page", { mode: "boolean" }).notNull().default(false),
-    urlPattern: text("url_pattern"),
-    // glob matched against a recorded step's page URL; null matches any page
-    steps: text("steps").notNull(),
-    // JSON: FunctionPatternStep[] — the DOM pattern this function drives
-    paramSources: text("param_sources").notNull(),
-    // JSON: FunctionParamSource[]
-    source: text("source").notNull().default("manual"),
-    // 'manual' | 'scanned' | 'recorded' | 'ai-extracted'
-    confidence: real("confidence").notNull().default(1),
-    // 0-1; 1 for manual/reviewed entries
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-  },
-  (table) => ({
-    projectIdIdx: index("idx_test_functions_project_id").on(table.projectId),
-    uniqueName: uniqueIndex("idx_test_functions_project_module_name").on(table.projectId, table.module, table.name)
-  })
-);
-const apiKeys = sqliteTable(
-  "api_keys",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    userId: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    // Human-readable label, e.g. "CI pipeline"
-    keyHash: text("key_hash").notNull().unique(),
-    // SHA-256 hash of the full key
-    keyPrefix: text("key_prefix").notNull(),
-    // First 8 chars after "pd_" prefix – shown in UI
-    createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-    lastUsedAt: integer("last_used_at", { mode: "timestamp" }),
-    expiresAt: integer("expires_at", { mode: "timestamp" })
-  },
-  (table) => ({
-    userIdIdx: index("idx_api_keys_user_id").on(table.userId)
-  })
-);
-const schema = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  accountTokens,
-  apiKeys,
-  appSettings,
-  casePayloads,
-  clusterMergeSuggestions,
-  entityLinks,
-  failureClusterAliases,
-  failureClusters,
-  failureDiagnoses,
-  failureDiagnosisVersions,
-  files,
-  locatorSnapshots,
-  markers,
-  networkRequests,
-  notificationChannels,
-  notificationDeliveries,
-  projectAssignments,
-  projectTags,
-  projects,
-  quarantinedTests,
-  subscriptions,
-  tags,
-  testCases,
-  testFunctions,
-  testRuns,
-  testRunsCases,
-  testSuites,
-  traceBlobs,
-  traceResources,
-  users
-}, Symbol.toStringTag, { value: "Module" }));
-
-const initSqlJs = initSqlJsLib.default || initSqlJsLib;
-const IDB_NAME = "piwi-dashboard-demo";
-const IDB_STORE = "state";
-const IDB_DB_KEY = "sqlite";
-const IDB_VERSION_KEY = "seed-version";
-const IDB_BLOB_PREFIX = "import-file:";
-function adoptConnection(db) {
-  db.onversionchange = () => {
-    db.close();
-    if (idbInstance === db) idbInstance = null;
-  };
-  return db;
-}
-function createStoreOnUpgrade(req) {
-  req.onupgradeneeded = () => {
-    if (!req.result.objectStoreNames.contains(IDB_STORE)) {
-      req.result.createObjectStore(IDB_STORE);
-    }
-  };
-}
-function openIDB() {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(IDB_NAME);
-    createStoreOnUpgrade(req);
-    req.onerror = () => reject(req.error);
-    req.onsuccess = () => {
-      const db = req.result;
-      if (db.objectStoreNames.contains(IDB_STORE)) {
-        resolve(adoptConnection(db));
-        return;
-      }
-      const retry = indexedDB.open(IDB_NAME, db.version + 1);
-      db.close();
-      createStoreOnUpgrade(retry);
-      retry.onblocked = () => console.warn("[Demo DB] store repair blocked by another open connection");
-      retry.onerror = () => reject(retry.error);
-      retry.onsuccess = () => resolve(adoptConnection(retry.result));
-    };
-  });
-}
-function idbGet(idb, key) {
-  return new Promise((resolve, reject) => {
-    const tx = idb.transaction(IDB_STORE, "readonly");
-    const req = tx.objectStore(IDB_STORE).get(key);
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-function idbPut(idb, key, value) {
-  return new Promise((resolve, reject) => {
-    const tx = idb.transaction(IDB_STORE, "readwrite");
-    tx.objectStore(IDB_STORE).put(value, key);
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
-  });
-}
-function idbKeys(idb) {
-  return new Promise((resolve, reject) => {
-    const tx = idb.transaction(IDB_STORE, "readonly");
-    const req = tx.objectStore(IDB_STORE).getAllKeys();
-    req.onsuccess = () => resolve(req.result.map(String));
-    req.onerror = () => reject(req.error);
-  });
-}
-function idbDelete(idb, key) {
-  return new Promise((resolve, reject) => {
-    const tx = idb.transaction(IDB_STORE, "readwrite");
-    tx.objectStore(IDB_STORE).delete(key);
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
-  });
-}
-let sqliteDb = null;
-let drizzleDb = null;
-let initPromise = null;
-let idbInstance = null;
-let persistTimer = null;
-let cachedStoredVersion = null;
-let demoDbBaseUrl = "/";
-function configureDemoDb(baseUrl) {
-  demoDbBaseUrl = baseUrl;
-}
-function getDemoDbBaseUrl() {
-  return demoDbBaseUrl;
-}
-async function doPersist() {
-  if (!sqliteDb) {
-    console.warn("[Demo DB] doPersist called but db not ready – skipping");
-    return;
-  }
-  const data = sqliteDb.export();
-  idbInstance ??= await openIDB();
-  await idbPut(idbInstance, IDB_DB_KEY, data);
-}
-function schedulePersist() {
-  if (persistTimer) clearTimeout(persistTimer);
-  persistTimer = setTimeout(doPersist, 500);
-}
-async function fetchCurrentSeedVersion(base) {
-  try {
-    const resp = await fetch(`${base}/demo/seed.version.json`, { cache: "no-cache" });
-    if (!resp.ok) return null;
-    const info = await resp.json();
-    return typeof info.hash === "string" && info.hash.length > 0 ? info.hash : null;
-  } catch {
-    return null;
-  }
-}
-async function seedFreshDatabase(SQL, base, version) {
-  const resp = await fetch(`${base}/demo/seed.sql`);
-  if (!resp.ok) {
-    throw new Error(`[Demo] Failed to load seed.sql: ${resp.status} ${resp.statusText}`);
-  }
-  const seedSql = await resp.text();
-  sqliteDb = new SQL.Database();
-  sqliteDb.run(seedSql);
-  await doPersist();
-  cachedStoredVersion = version;
-  if (idbInstance && version) {
-    await idbPut(idbInstance, IDB_VERSION_KEY, version);
-  }
-}
-function canReusePersistedDemoDb(storedVersion, currentVersion) {
-  if (currentVersion === null) return true;
-  return storedVersion === currentVersion;
-}
-async function initialize() {
-  const base = demoDbBaseUrl.replace(/\/$/, "");
-  const SQL = await initSqlJs({
-    locateFile: (file) => `${base}/demo/${file}`
-  });
-  idbInstance = await openIDB();
-  const savedData = await idbGet(idbInstance, IDB_DB_KEY);
-  const hasSaved = savedData instanceof Uint8Array && savedData.length > 0;
-  const currentVersion = await fetchCurrentSeedVersion(base);
-  if (hasSaved) {
-    const v = await idbGet(idbInstance, IDB_VERSION_KEY);
-    const storedVersion = typeof v === "string" ? v : null;
-    if (canReusePersistedDemoDb(storedVersion, currentVersion)) {
-      sqliteDb = new SQL.Database(savedData);
-      cachedStoredVersion = storedVersion;
-    } else {
-      console.info("[Demo DB] seed version changed — reseeding with the latest demo data");
-      await seedFreshDatabase(SQL, base, currentVersion);
-    }
-  } else {
-    await seedFreshDatabase(SQL, base, currentVersion);
-  }
-  drizzleDb = drizzle(
-    async (sql, params, method) => {
-      try {
-        if (method === "run") {
-          sqliteDb.run(sql, params);
-          schedulePersist();
-          return { rows: [] };
-        }
-        const stmt = sqliteDb.prepare(sql);
-        stmt.bind(params);
-        const rows = [];
-        while (stmt.step()) {
-          rows.push(stmt.get());
-        }
-        stmt.free();
-        return { rows };
-      } catch (e) {
-        console.error("[Demo DB] query error", e, "\nSQL:", sql, "\nParams:", params);
-        throw e;
-      }
-    },
-    { schema }
-  );
-}
-async function getDemoDb() {
-  if (!initPromise) {
-    initPromise = initialize().catch((e) => {
-      initPromise = null;
-      throw e;
-    });
-  }
-  await initPromise;
-  return drizzleDb;
-}
-async function getStoredDemoVersion() {
-  if (cachedStoredVersion !== null) return cachedStoredVersion;
-  idbInstance ??= await openIDB();
-  const v = await idbGet(idbInstance, IDB_VERSION_KEY);
-  cachedStoredVersion = typeof v === "string" ? v : null;
-  return cachedStoredVersion;
-}
-async function putDemoImportedFile(path, bytes) {
-  idbInstance ??= await openIDB();
-  await idbPut(idbInstance, IDB_BLOB_PREFIX + path, bytes);
-}
-async function getDemoImportedFile(path) {
-  idbInstance ??= await openIDB();
-  const value = await idbGet(idbInstance, IDB_BLOB_PREFIX + path);
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof Blob) return new Uint8Array(await value.arrayBuffer());
-  return null;
-}
-async function resetDemoDb() {
-  if (persistTimer) clearTimeout(persistTimer);
-  persistTimer = null;
-  sqliteDb?.close();
-  sqliteDb = null;
-  drizzleDb = null;
-  initPromise = null;
-  cachedStoredVersion = null;
-  if (idbInstance) {
-    await idbDelete(idbInstance, IDB_DB_KEY);
-    await idbDelete(idbInstance, IDB_VERSION_KEY);
-    for (const key of await idbKeys(idbInstance)) {
-      if (key.startsWith(IDB_BLOB_PREFIX)) await idbDelete(idbInstance, key);
-    }
-    idbInstance.close();
-    idbInstance = null;
-  }
-}
-
-export { canReusePersistedDemoDb, configureDemoDb, getDemoDb, getDemoDbBaseUrl, getDemoImportedFile, getStoredDemoVersion, putDemoImportedFile, resetDemoDb };
-//# sourceMappingURL=db.client-DijpEH6i.mjs.map