@aigne/afs-index 1.12.0-beta.5

package/dist/backend/schema.mjs

@@ -0,0 +1,188 @@
+import { sql } from "drizzle-orm";
+
+//#region src/backend/schema.ts
+const DEFAULT_FTS_TOKENIZER = "unicode61 remove_diacritics 2";
+/**
+* Schema version. Bumped to 2 when the per-caller tenant `scope` column landed
+* on every data table (cross-user isolation, mirroring the D1 backend). Bumped
+* to 3 when `idx_index_cursor.served_at` landed for scheduler fairness. A v1
+* file has NO `scope` column and cannot be back-filled (the tenant scope is not
+* recoverable from `entry_path`), so `migrateToScopedSchema` DROPS the derived
+* index (data tables + follower cursors) and lets the changelog follower
+* re-index from seq 0 — the index is a rebuildable derived model.
+*/
+const SCHEMA_VERSION = 3;
+async function createSchema(db, opts = {}) {
+	const tokenizer = opts.ftsTokenizer ?? DEFAULT_FTS_TOKENIZER;
+	await migrateToScopedSchema(db);
+	await renameAnchorTables(db);
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS ds_indexed_entry (
+      scope         TEXT NOT NULL,
+      entry_path    TEXT NOT NULL,
+      source_path   TEXT,
+      source_hash   TEXT,
+      domain        TEXT NOT NULL,
+      state         TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'stale', 'removed')),
+      extractor_id  TEXT,
+      indexed_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL,
+      anchor_count  INTEGER DEFAULT 0,
+      meta          TEXT,
+      PRIMARY KEY (scope, entry_path)
+    )
+  `));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_domain    ON ds_indexed_entry(scope, domain)`));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_state     ON ds_indexed_entry(scope, state)`));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_extractor ON ds_indexed_entry(scope, extractor_id)`));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_source    ON ds_indexed_entry(scope, source_path)`));
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_anchor_data (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope        TEXT NOT NULL,
+      entry_path   TEXT NOT NULL,
+      anchor_type  TEXT NOT NULL,
+      confidence   REAL NOT NULL,
+      raw_anchor   TEXT NOT NULL
+    )
+  `));
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_anchor_key (
+      scope        TEXT NOT NULL,
+      index_key    TEXT,
+      entry_path   TEXT,
+      anchor_type  TEXT,
+      confidence   REAL,
+      PRIMARY KEY (scope, index_key, entry_path, anchor_type)
+    ) WITHOUT ROWID
+  `));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_ad_path ON idx_anchor_data(scope, entry_path)`));
+	await db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_ak_path ON idx_anchor_key(scope, entry_path)`));
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_embedding_vector (
+      scope          TEXT NOT NULL,
+      entry_path     TEXT NOT NULL,
+      embedding      TEXT,
+      embedding_blob BLOB,
+      dimension      INTEGER NOT NULL,
+      PRIMARY KEY (scope, entry_path)
+    )
+  `));
+	if ((await db.all(sql.raw("SELECT name FROM sqlite_master WHERE type='table' AND name='idx_fts'"))).length === 0) await db.run(sql.raw(`
+      CREATE VIRTUAL TABLE idx_fts USING fts5(
+        scope UNINDEXED,
+        entry_path UNINDEXED,
+        summary,
+        tokenize='${tokenizer.replace(/'/g, "''")}'
+      )
+    `));
+	await ensureFtsRowidMapping(db);
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_index_cursor (
+      consumer_id  TEXT NOT NULL PRIMARY KEY,
+      last_seq     INTEGER NOT NULL DEFAULT 0,
+      watermarks   TEXT,
+      updated_at   INTEGER NOT NULL,
+      served_at    INTEGER,
+      instance_did TEXT,
+      domains      TEXT
+    )
+  `));
+	await ensureCursorServedAt(db);
+	await setSchemaVersion(db, SCHEMA_VERSION);
+}
+/**
+* Drop the v1 (scope-less) derived index in place so `createSchema` can rebuild
+* it with the tenant `scope` column. A v1 file is detected by the ABSENCE of a
+* `scope` column on `ds_indexed_entry` (the version table doesn't exist yet).
+*
+* Data tables AND the follower cursors are dropped together: keeping the
+* cursors would leave the follower believing it is already caught up
+* (`last_seq` high) against now-empty tables, so it would never re-index. With
+* the cursors gone, `initCursor` recreates them at seq 0 and the follower
+* re-materializes every tenant's index from the changelog.
+*
+* Idempotent: on a fresh db (no `ds_indexed_entry` yet) and on an already-v2 db
+* it is a no-op. The one-time drop on a shared file rebuilds the index for ALL
+* tenants at once; acceptable because the index is a derived model.
+*/
+async function migrateToScopedSchema(db) {
+	if ((await db.all(sql.raw("SELECT name FROM sqlite_master WHERE type='table' AND name='ds_indexed_entry'"))).length === 0) return;
+	if ((await db.all(sql.raw(`PRAGMA table_info(ds_indexed_entry)`))).some((c) => c.name === "scope")) return;
+	for (const table of [
+		"ds_indexed_entry",
+		"arc_anchor_data",
+		"arc_anchor_key",
+		"idx_anchor_data",
+		"idx_anchor_key",
+		"idx_embedding_vector",
+		"idx_fts",
+		"idx_fts_rowid",
+		"idx_index_cursor"
+	]) await db.run(sql.raw(`DROP TABLE IF EXISTS ${table}`));
+}
+/**
+* Rename the anchor tables from their legacy `arc_` prefix to the correct
+* `idx_` module prefix. These tables are owned by the index provider — the same
+* module as idx_fts / idx_embedding_vector — and were mis-prefixed `arc_`, a
+* prefix reserved for `runtimes/*` Arc-system state (scheduler). Data-preserving:
+* `ALTER TABLE … RENAME` keeps every row and its secondary indexes, so no
+* re-index / follower-cursor reset is needed.
+*
+* Idempotent and safe on fresh / already-migrated / interrupted dbs: renames
+* only when the legacy table exists and the target does not. If BOTH exist (an
+* interrupted prior run), the legacy copy is dropped in favour of the
+* already-created idx_ table. Must run AFTER migrateToScopedSchema (a v1 db has
+* its anchor tables dropped there) and BEFORE the CREATE TABLE IF NOT EXISTS in
+* createSchema (which would otherwise create an empty idx_ table alongside the
+* populated arc_ one).
+*/
+async function renameAnchorTables(db) {
+	const pairs = [["arc_anchor_data", "idx_anchor_data"], ["arc_anchor_key", "idx_anchor_key"]];
+	const names = pairs.flat().map((n) => `'${n}'`);
+	const rows = await db.all(sql.raw(`SELECT name FROM sqlite_master WHERE type='table' AND name IN (${names.join(", ")})`));
+	const present = new Set(rows.map((r) => r.name));
+	for (const [legacy, next] of pairs) {
+		if (!present.has(legacy)) continue;
+		if (present.has(next)) await db.run(sql.raw(`DROP TABLE IF EXISTS ${legacy}`));
+		else await db.run(sql.raw(`ALTER TABLE ${legacy} RENAME TO ${next}`));
+	}
+}
+/**
+* Create the `idx_fts_rowid` mapping table the first time this db sees it,
+* backfilling it from any pre-existing `idx_fts` rows (issue #1103). The
+* backfill maps every existing FTS row to its own rowid so a later `fts_write`
+* REPLACEs in place instead of leaving a duplicate for the same
+* (scope, entry_path) — silently doubling search results for that entry.
+*
+* Race-safe and idempotent (matters on shared backends where two contexts may
+* init at once, and there is no enclosing transaction):
+*   - `CREATE TABLE IF NOT EXISTS` never throws on a concurrent create.
+*   - The one-time backfill runs only while the mapping is still empty (a cheap
+*     LIMIT-1 probe, NOT a scan of `idx_fts`), so steady state costs nothing.
+*   - `INSERT OR IGNORE` makes the backfill itself idempotent, so a racing
+*     backfill (or a re-run) can't collide on the PK/UNIQUE.
+*/
+async function ensureFtsRowidMapping(db) {
+	await db.run(sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_fts_rowid (
+      fts_rowid   INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope       TEXT NOT NULL,
+      entry_path  TEXT NOT NULL,
+      UNIQUE (scope, entry_path)
+    )
+  `));
+	if ((await db.all(sql.raw("SELECT 1 AS one FROM idx_fts_rowid LIMIT 1"))).length > 0) return;
+	await db.run(sql.raw(`INSERT OR IGNORE INTO idx_fts_rowid (fts_rowid, scope, entry_path) SELECT rowid, scope, entry_path FROM idx_fts`));
+}
+async function ensureCursorServedAt(db) {
+	if ((await db.all(sql.raw("PRAGMA table_info(idx_index_cursor)"))).some((c) => c.name === "served_at")) return;
+	await db.run(sql.raw("ALTER TABLE idx_index_cursor ADD COLUMN served_at INTEGER"));
+}
+async function setSchemaVersion(db, version) {
+	await db.run(sql.raw(`PRAGMA user_version = ${version}`));
+}
+
+//#endregion
+export { createSchema };
+//# sourceMappingURL=schema.mjs.map

package/dist/backend/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../src/backend/schema.ts"],"sourcesContent":["/**\n * Schema initialization for AFS Index Provider.\n *\n * Creates tables via the SQLiteAFS database:\n * - ds_indexed_entry: main entry metadata\n * - idx_anchor_data: raw anchor storage\n * - idx_anchor_key: generated keys for fast lookup (WITHOUT ROWID)\n * - idx_fts: FTS5 virtual table for summary search\n * - idx_fts_rowid: (scope, entry_path) -> idx_fts rowid mapping (issue #1103),\n *   used by fts_write/fts_delete to delete by rowid (O(1)) instead of by\n *   (scope, entry_path) (full FTS5 table scan — those columns are UNINDEXED)\n * - idx_index_cursor: changelog-follower per-(scope, consumer_id) progress cursor\n *\n * The FTS5 tokenizer is configurable. Default is `unicode61 remove_diacritics 2`\n * which suits English/Latin text. CJK content (Chinese, Japanese, Korean)\n * has no whitespace, so unicode61 alone treats long strings as a single\n * token. We compensate at write+query time via `segmentCJK` (char-level\n * spaces around CJK code points), which works but indexes per-character so\n * queries like `性别` get split to `性 OR 别`.\n *\n * Alternative: `trigram` tokenizer is FTS5's built-in 3-gram tokenizer,\n * which works without segmentation for CJK because every 3-char window is\n * a token. Trade-off is bigger index + slightly slower writes for better\n * recall on multi-character CJK terms. Pass via AFSIndexOptions.ftsTokenizer\n * to opt in. See planning/memory-system-improvements/design.md §P3.\n */\n\nimport type { SqliteDatabase } from \"@aigne/afs-sqlite\";\nimport { sql } from \"drizzle-orm\";\n\nexport const DEFAULT_FTS_TOKENIZER = \"unicode61 remove_diacritics 2\";\n\n/**\n * Schema version. Bumped to 2 when the per-caller tenant `scope` column landed\n * on every data table (cross-user isolation, mirroring the D1 backend). Bumped\n * to 3 when `idx_index_cursor.served_at` landed for scheduler fairness. A v1\n * file has NO `scope` column and cannot be back-filled (the tenant scope is not\n * recoverable from `entry_path`), so `migrateToScopedSchema` DROPS the derived\n * index (data tables + follower cursors) and lets the changelog follower\n * re-index from seq 0 — the index is a rebuildable derived model.\n */\nconst SCHEMA_VERSION = 3;\n\nexport async function createSchema(\n  db: SqliteDatabase,\n  opts: { ftsTokenizer?: string } = {},\n): Promise<void> {\n  const tokenizer = opts.ftsTokenizer ?? DEFAULT_FTS_TOKENIZER;\n\n  // One-time upgrade from the v1 (scope-less) schema. Must run BEFORE the\n  // CREATE TABLE IF NOT EXISTS below, which would otherwise no-op against the\n  // stale v1 tables and leave them without the `scope` column.\n  await migrateToScopedSchema(db);\n\n  // One-time rename of the anchor tables from the mis-applied `arc_` prefix to\n  // the correct `idx_` module prefix. Runs AFTER migrateToScopedSchema (which\n  // drops v1 tables outright) and BEFORE the CREATE TABLE IF NOT EXISTS below,\n  // so a v2/v3 db keeps its anchor rows via ALTER RENAME instead of orphaning\n  // them behind the new name.\n  await renameAnchorTables(db);\n\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS ds_indexed_entry (\n      scope         TEXT NOT NULL,\n      entry_path    TEXT NOT NULL,\n      source_path   TEXT,\n      source_hash   TEXT,\n      domain        TEXT NOT NULL,\n      state         TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'stale', 'removed')),\n      extractor_id  TEXT,\n      indexed_at    TEXT NOT NULL,\n      updated_at    TEXT NOT NULL,\n      anchor_count  INTEGER DEFAULT 0,\n      meta          TEXT,\n      PRIMARY KEY (scope, entry_path)\n    )\n  `),\n  );\n\n  // Scope-leading composite indexes: every hot filter (boundDomains, markStale\n  // by state, source lookup) is tenant-scoped, so `scope` must lead the index\n  // to stay selective on the shared file.\n  await db.run(\n    sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_domain    ON ds_indexed_entry(scope, domain)`),\n  );\n  await db.run(\n    sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_state     ON ds_indexed_entry(scope, state)`),\n  );\n  await db.run(\n    sql.raw(\n      `CREATE INDEX IF NOT EXISTS idx_entry_extractor ON ds_indexed_entry(scope, extractor_id)`,\n    ),\n  );\n  await db.run(\n    sql.raw(\n      `CREATE INDEX IF NOT EXISTS idx_entry_source    ON ds_indexed_entry(scope, source_path)`,\n    ),\n  );\n\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS idx_anchor_data (\n      id           INTEGER PRIMARY KEY AUTOINCREMENT,\n      scope        TEXT NOT NULL,\n      entry_path   TEXT NOT NULL,\n      anchor_type  TEXT NOT NULL,\n      confidence   REAL NOT NULL,\n      raw_anchor   TEXT NOT NULL\n    )\n  `),\n  );\n\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS idx_anchor_key (\n      scope        TEXT NOT NULL,\n      index_key    TEXT,\n      entry_path   TEXT,\n      anchor_type  TEXT,\n      confidence   REAL,\n      PRIMARY KEY (scope, index_key, entry_path, anchor_type)\n    ) WITHOUT ROWID\n  `),\n  );\n\n  await db.run(\n    sql.raw(`CREATE INDEX IF NOT EXISTS idx_ad_path ON idx_anchor_data(scope, entry_path)`),\n  );\n  await db.run(\n    sql.raw(`CREATE INDEX IF NOT EXISTS idx_ak_path ON idx_anchor_key(scope, entry_path)`),\n  );\n  // No idx_ak_lookup(scope, index_key): idx_anchor_key is WITHOUT ROWID with PK\n  // (scope, index_key, entry_path, anchor_type). A secondary index appends the\n  // missing PK columns, so idx_ak_lookup is a byte-for-byte copy of the PK — it\n  // only doubles anchor_key write cost and the planner ignores it for\n  // `index_key IN (...)` anyway. queryAnchors seeks the PK directly by rewriting\n  // the IN into a UNION of equalities (issue #1120), so no index is needed here.\n\n  // Embedding storage (brute-force vector search, no extensions required).\n  //\n  // Vectors stored as Float32Array bytes in `embedding_blob` (4 bytes/dim,\n  // 6KB for a 1536-d vector vs ~24KB JSON). The legacy `embedding` TEXT\n  // column is kept readable for old rows but new writes only populate the\n  // blob — see `embedding_write` action.\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS idx_embedding_vector (\n      scope          TEXT NOT NULL,\n      entry_path     TEXT NOT NULL,\n      embedding      TEXT,\n      embedding_blob BLOB,\n      dimension      INTEGER NOT NULL,\n      PRIMARY KEY (scope, entry_path)\n    )\n  `),\n  );\n\n  // FTS5 virtual tables don't support IF NOT EXISTS in all SQLite versions.\n  // `scope` is an extra UNINDEXED column (real tenant scope, filtered as\n  // `idx_fts.scope = ?`) — distinct from the `scope:\"/domain\"` path-prefix\n  // shorthand some callers pass to fts_query, which stays a domain filter.\n  const ftsCheck = await db.all<{ name: string }>(\n    sql.raw(\"SELECT name FROM sqlite_master WHERE type='table' AND name='idx_fts'\"),\n  );\n  if (ftsCheck.length === 0) {\n    await db.run(\n      sql.raw(`\n      CREATE VIRTUAL TABLE idx_fts USING fts5(\n        scope UNINDEXED,\n        entry_path UNINDEXED,\n        summary,\n        tokenize='${tokenizer.replace(/'/g, \"''\")}'\n      )\n    `),\n    );\n  }\n\n  // (scope, entry_path) -> idx_fts rowid mapping (issue #1103). A dedicated\n  // table rather than a column on `ds_indexed_entry`: `writeSummary`/\n  // `removeSummary` are called independently of `writeEntry`/`removeEntry`\n  // in this codebase (see test/backend/fts.test.ts), so an entry-keyed\n  // mapping could go stale or simply not exist while FTS rows do.\n  await ensureFtsRowidMapping(db);\n\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS idx_index_cursor (\n      consumer_id  TEXT NOT NULL PRIMARY KEY,\n      last_seq     INTEGER NOT NULL DEFAULT 0,\n      watermarks   TEXT,\n      updated_at   INTEGER NOT NULL,\n      served_at    INTEGER,\n      instance_did TEXT,\n      domains      TEXT\n    )\n  `),\n  );\n  await ensureCursorServedAt(db);\n\n  await setSchemaVersion(db, SCHEMA_VERSION);\n}\n\n/**\n * Drop the v1 (scope-less) derived index in place so `createSchema` can rebuild\n * it with the tenant `scope` column. A v1 file is detected by the ABSENCE of a\n * `scope` column on `ds_indexed_entry` (the version table doesn't exist yet).\n *\n * Data tables AND the follower cursors are dropped together: keeping the\n * cursors would leave the follower believing it is already caught up\n * (`last_seq` high) against now-empty tables, so it would never re-index. With\n * the cursors gone, `initCursor` recreates them at seq 0 and the follower\n * re-materializes every tenant's index from the changelog.\n *\n * Idempotent: on a fresh db (no `ds_indexed_entry` yet) and on an already-v2 db\n * it is a no-op. The one-time drop on a shared file rebuilds the index for ALL\n * tenants at once; acceptable because the index is a derived model.\n */\nasync function migrateToScopedSchema(db: SqliteDatabase): Promise<void> {\n  const entryTable = await db.all<{ name: string }>(\n    sql.raw(\"SELECT name FROM sqlite_master WHERE type='table' AND name='ds_indexed_entry'\"),\n  );\n  if (entryTable.length === 0) return; // fresh db — nothing to migrate\n\n  const cols = await db.all<{ name: string }>(sql.raw(`PRAGMA table_info(ds_indexed_entry)`));\n  if (cols.some((c) => c.name === \"scope\")) return; // already v2\n\n  for (const table of [\n    \"ds_indexed_entry\",\n    // Both prefixes: a v1 file predates the arc_→idx_ anchor rename, so its\n    // anchor tables may still carry either name. DROP IF EXISTS both.\n    \"arc_anchor_data\",\n    \"arc_anchor_key\",\n    \"idx_anchor_data\",\n    \"idx_anchor_key\",\n    \"idx_embedding_vector\",\n    \"idx_fts\",\n    \"idx_fts_rowid\",\n    \"idx_index_cursor\",\n  ]) {\n    await db.run(sql.raw(`DROP TABLE IF EXISTS ${table}`));\n  }\n}\n\n/**\n * Rename the anchor tables from their legacy `arc_` prefix to the correct\n * `idx_` module prefix. These tables are owned by the index provider — the same\n * module as idx_fts / idx_embedding_vector — and were mis-prefixed `arc_`, a\n * prefix reserved for `runtimes/*` Arc-system state (scheduler). Data-preserving:\n * `ALTER TABLE … RENAME` keeps every row and its secondary indexes, so no\n * re-index / follower-cursor reset is needed.\n *\n * Idempotent and safe on fresh / already-migrated / interrupted dbs: renames\n * only when the legacy table exists and the target does not. If BOTH exist (an\n * interrupted prior run), the legacy copy is dropped in favour of the\n * already-created idx_ table. Must run AFTER migrateToScopedSchema (a v1 db has\n * its anchor tables dropped there) and BEFORE the CREATE TABLE IF NOT EXISTS in\n * createSchema (which would otherwise create an empty idx_ table alongside the\n * populated arc_ one).\n */\nasync function renameAnchorTables(db: SqliteDatabase): Promise<void> {\n  const pairs: Array<[legacy: string, next: string]> = [\n    [\"arc_anchor_data\", \"idx_anchor_data\"],\n    [\"arc_anchor_key\", \"idx_anchor_key\"],\n  ];\n  // Single sqlite_master read for all four names (kept in step with\n  // d1-index-backend.ts: one O(1) probe, no per-open scan of the catalog).\n  const names = pairs.flat().map((n) => `'${n}'`);\n  const rows = await db.all<{ name: string }>(\n    sql.raw(`SELECT name FROM sqlite_master WHERE type='table' AND name IN (${names.join(\", \")})`),\n  );\n  const present = new Set(rows.map((r) => r.name));\n  for (const [legacy, next] of pairs) {\n    if (!present.has(legacy)) continue; // fresh db or already renamed\n    if (present.has(next)) {\n      await db.run(sql.raw(`DROP TABLE IF EXISTS ${legacy}`)); // interrupted migration — idx_ wins\n    } else {\n      await db.run(sql.raw(`ALTER TABLE ${legacy} RENAME TO ${next}`));\n    }\n  }\n}\n\n/**\n * Create the `idx_fts_rowid` mapping table the first time this db sees it,\n * backfilling it from any pre-existing `idx_fts` rows (issue #1103). The\n * backfill maps every existing FTS row to its own rowid so a later `fts_write`\n * REPLACEs in place instead of leaving a duplicate for the same\n * (scope, entry_path) — silently doubling search results for that entry.\n *\n * Race-safe and idempotent (matters on shared backends where two contexts may\n * init at once, and there is no enclosing transaction):\n *   - `CREATE TABLE IF NOT EXISTS` never throws on a concurrent create.\n *   - The one-time backfill runs only while the mapping is still empty (a cheap\n *     LIMIT-1 probe, NOT a scan of `idx_fts`), so steady state costs nothing.\n *   - `INSERT OR IGNORE` makes the backfill itself idempotent, so a racing\n *     backfill (or a re-run) can't collide on the PK/UNIQUE.\n */\nasync function ensureFtsRowidMapping(db: SqliteDatabase): Promise<void> {\n  await db.run(\n    sql.raw(`\n    CREATE TABLE IF NOT EXISTS idx_fts_rowid (\n      fts_rowid   INTEGER PRIMARY KEY AUTOINCREMENT,\n      scope       TEXT NOT NULL,\n      entry_path  TEXT NOT NULL,\n      UNIQUE (scope, entry_path)\n    )\n  `),\n  );\n\n  const populated = await db.all<{ one: number }>(\n    sql.raw(\"SELECT 1 AS one FROM idx_fts_rowid LIMIT 1\"),\n  );\n  if (populated.length > 0) return; // already backfilled / in use — no scan.\n\n  // Preserve existing FTS rowids as the owned fts_rowid; explicit inserts into\n  // the AUTOINCREMENT column also seed sqlite_sequence to MAX(rowid) so\n  // newly-allocated ids never collide with a live idx_fts row.\n  await db.run(\n    sql.raw(\n      `INSERT OR IGNORE INTO idx_fts_rowid (fts_rowid, scope, entry_path) SELECT rowid, scope, entry_path FROM idx_fts`,\n    ),\n  );\n}\n\nasync function ensureCursorServedAt(db: SqliteDatabase): Promise<void> {\n  const cols = await db.all<{ name: string }>(sql.raw(\"PRAGMA table_info(idx_index_cursor)\"));\n  if (cols.some((c) => c.name === \"served_at\")) return;\n  await db.run(sql.raw(\"ALTER TABLE idx_index_cursor ADD COLUMN served_at INTEGER\"));\n}\n\nasync function setSchemaVersion(db: SqliteDatabase, version: number): Promise<void> {\n  // PRAGMA user_version is a single 32-bit slot on the db file — perfect for a\n  // monotonic schema marker, no extra table, no row to filter by tenant.\n  await db.run(sql.raw(`PRAGMA user_version = ${version}`));\n}\n"],"mappings":"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"}