@cortexkit/pi-magic-context 0.47.0 → 0.49.0

package/dist/{index-td885aah.js → index-mcgehvgw.js}

@@ -1,6 +1,54 @@
 import {
-  sessionLog
-} from "./index-7n8gb6j3.js";
+  sessionLog2
+} from "./index-x3dcnxh0.js";
+
+// ../plugin/src/shared/stable-json.ts
+function stableStringify(value, seen = new WeakSet) {
+  const pieces = [];
+  writeStable(value, seen, pieces);
+  return pieces.join("");
+}
+function writeStable(value, seen, pieces) {
+  if (value === undefined) {
+    pieces.push("undefined");
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    pieces.push(JSON.stringify(value) ?? String(value));
+    return;
+  }
+  if (seen.has(value)) {
+    pieces.push('"[Circular]"');
+    return;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    pieces.push("[");
+    for (let index = 0;index < value.length; index += 1) {
+      if (index > 0)
+        pieces.push(",");
+      if (index in value)
+        writeStable(value[index], seen, pieces);
+    }
+    pieces.push("]");
+    return;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => {
+    if (a < b)
+      return -1;
+    if (a > b)
+      return 1;
+    return 0;
+  });
+  pieces.push("{");
+  entries.forEach(([key, child], index) => {
+    if (index > 0)
+      pieces.push(",");
+    pieces.push(JSON.stringify(key), ":");
+    writeStable(child, seen, pieces);
+  });
+  pieces.push("}");
+}
 
 // ../plugin/src/shared/sqlite-helpers.ts
 function closeQuietly(db) {
@@ -19,28 +67,6 @@ function isKnownAutocommit(db) {
   }
 }
 
-// ../plugin/src/shared/stable-json.ts
-function stableStringify(value, seen = new WeakSet) {
-  if (value === undefined)
-    return "undefined";
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value) ?? String(value);
-  if (seen.has(value))
-    return '"[Circular]"';
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
-  }
-  const entries = Object.entries(value).sort(([a], [b]) => {
-    if (a < b)
-      return -1;
-    if (a > b)
-      return 1;
-    return 0;
-  });
-  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
-}
-
 // ../plugin/src/features/magic-context/storage-schema-helpers.ts
 var columnCaches = new WeakMap;
 function readColumnNames(db, table) {
@@ -313,11 +339,11 @@ function installV95PerfSchema(db, verifyExistingMap = false, allowCreateMap = tr
         try {
           entries = JSON.parse(row.entries);
         } catch {
-          sessionLog(row.session_id, "v95 temporal metadata: malformed JSON skipped; original blob retained");
+          sessionLog2(row.session_id, "v95 temporal metadata: malformed JSON skipped; original blob retained");
           continue;
         }
         if (!Array.isArray(entries)) {
-          sessionLog(row.session_id, "v95 temporal metadata: non-array JSON skipped; original blob retained");
+          sessionLog2(row.session_id, "v95 temporal metadata: non-array JSON skipped; original blob retained");
           continue;
         }
         const kept = [];
@@ -364,213 +390,138 @@ function installV95PerfSchema(db, verifyExistingMap = false, allowCreateMap = tr
   }
 }
 var tagOrderIndexes = new WeakMap;
-
-// ../plugin/src/shared/opencode-db-path.ts
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-var cachedResolution = null;
-var lastReadFailure = null;
-var claimedDiagnostics = new Set;
-function openCodeDataDir(env = process.env, dataHome) {
-  return join(dataHome ?? env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
-}
-function environmentKey(dataDir, hostGeneration, channel, env) {
-  return [
-    hostGeneration,
-    dataDir,
-    env.OPENCODE_DB ?? "",
-    env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
-    channel ?? env.OPENCODE_CHANNEL ?? ""
-  ].join("\x00");
-}
-function channelPath(dataDir, channel) {
-  return ["latest", "beta", "prod"].includes(channel) ? join(dataDir, "opencode.db") : join(dataDir, `opencode-${channel}.db`);
-}
-function discoveredCandidateNames(dataDir) {
-  const names = ["opencode.db", "opencode-local.db", "opencode-dev.db"];
-  try {
-    const discovered = readdirSync(dataDir, { withFileTypes: true }).filter((entry) => /^opencode-.+\.db$/.test(entry.name) && !names.includes(entry.name)).map((entry) => entry.name).sort();
-    names.push(...discovered);
-  } catch {}
-  return names;
-}
-function discoverOpenCodeDb(dataDir) {
-  const candidates = discoveredCandidateNames(dataDir).map((name, order) => {
-    const path = join(dataDir, name);
-    try {
-      const metadata = statSync(path);
-      return metadata.isFile() ? { path, order, mtimeMs: metadata.mtimeMs } : null;
-    } catch {
-      return null;
-    }
-  });
-  const existing = candidates.filter((candidate) => candidate !== null).sort((left, right) => right.mtimeMs - left.mtimeMs || left.order - right.order)[0];
-  if (!existing) {
-    return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
-  }
-  const name = existing.path.slice(dataDir.length + 1);
-  const channel = name === "opencode.db" ? null : name.slice("opencode-".length, -".db".length) || null;
-  return { path: existing.path, source: "discovered", channel };
-}
-function resolveV1Fresh(dataDir, env = process.env) {
-  const explicit = env.OPENCODE_DB;
-  if (explicit !== undefined && explicit.length > 0) {
-    if (explicit === ":memory:") {
-      return { path: explicit, source: "OPENCODE_DB", channel: null };
-    }
-    return {
-      path: isAbsolute(explicit) ? explicit : join(dataDir, explicit),
-      source: "OPENCODE_DB",
-      channel: null
-    };
-  }
-  const disableChannelDb = env.OPENCODE_DISABLE_CHANNEL_DB;
-  if (disableChannelDb === "1" || disableChannelDb === "true") {
-    return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
-  }
-  const channel = env.OPENCODE_CHANNEL;
-  if (channel !== undefined && channel.length > 0) {
-    return { path: channelPath(dataDir, channel), source: "channel", channel };
-  }
-  return discoverOpenCodeDb(dataDir);
-}
-function sourceOpenCodeDatabaseFilename(hostGeneration, channel, env = process.env) {
-  if (hostGeneration === "v1") {
-    const explicit = env.OPENCODE_DB;
-    if (explicit !== undefined && explicit.length > 0)
-      return explicit;
-    if (env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
-      return "opencode.db";
-    }
-    return ["latest", "beta", "prod"].includes(channel) ? "opencode.db" : `opencode-${channel}.db`;
-  }
-  return env.OPENCODE_DB ?? (["latest", "dev", "beta", "next", "prod"].includes(channel) || env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true" ? "opencode.db" : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "")}.db`);
-}
-function resolveV2Fresh(dataDir, channel, env) {
-  const filename = sourceOpenCodeDatabaseFilename("v2", channel, env);
-  const explicit = env.OPENCODE_DB !== undefined;
-  return {
-    path: filename === ":memory:" ? filename : resolve(dataDir, filename),
-    source: explicit ? "OPENCODE_DB" : env.OPENCODE_CHANNEL ? "channel" : "default",
-    channel: explicit ? null : channel
-  };
-}
-function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
-  const env = options.env ?? process.env;
-  const dataDir = openCodeDataDir(env, options.dataHome);
-  const channel = options.channel ?? env.OPENCODE_CHANNEL;
-  const key = environmentKey(dataDir, hostGeneration, channel, env);
-  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync(cachedResolution.resolution.path))) {
-    if (cachedResolution.existed)
-      return cachedResolution.resolution;
-  }
-  const resolution = hostGeneration === "v2" ? resolveV2Fresh(dataDir, channel ?? "latest", env) : resolveV1Fresh(dataDir, env);
-  cachedResolution = {
-    key,
-    resolution,
-    existed: resolution.path !== ":memory:" && existsSync(resolution.path)
-  };
-  return resolution;
-}
-function schemaTableNames(db, schema = "main") {
-  const rows = db.prepare(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message', 'session_v2')`).all();
-  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
-}
-function hasV1MessageTables(db, schema = "main") {
-  const tables = schemaTableNames(db, schema);
-  return tables.has("message") && tables.has("part");
-}
-function detectOpenCodeStoreGeneration(db, schema = "main") {
-  const tables = schemaTableNames(db, schema);
-  const hasV1Messages = tables.has("message") && tables.has("part");
-  if (hasV1Messages)
-    return "v1";
-  if (tables.has("session_message"))
-    return "v2";
-  if (tables.has("session") || tables.has("project"))
-    return "v1";
-  return "unknown";
-}
-function hasMigratedV2Schema(tables) {
-  return tables.has("session_message") && tables.has("session_v2");
-}
-function isOpenCodeV2Store(db, schema = "main") {
-  return detectOpenCodeStoreGeneration(db, schema) === "v2" || hasMigratedV2Schema(schemaTableNames(db, schema));
-}
-function assertOpenCodeStoreGeneration(db, expected, path, schema = "main") {
-  const actual = detectOpenCodeStoreGeneration(db, schema);
-  if (actual === expected)
-    return;
-  if (expected === "v2" && isOpenCodeV2Store(db, schema))
-    return;
-  if (actual === "unknown")
-    return;
-  throw new Error(`OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`);
-}
-function openCodeDbPathExists(resolution = resolveOpenCodeDbPath()) {
-  return resolution.path !== ":memory:" && existsSync(resolution.path);
-}
-function getOpenCodeDbProbeDescriptions(resolution = resolveOpenCodeDbPath()) {
-  if (resolution.source === "OPENCODE_DB")
-    return [resolution.path];
-  if (resolution.source === "channel" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
-    return [resolution.path];
+function tagOrderConstraintIndex(db) {
+  const version = db.prepare("PRAGMA schema_version").get().schema_version;
+  const cacheable = isKnownAutocommit(db);
+  if (!cacheable)
+    tagOrderIndexes.delete(db);
+  const cached = tagOrderIndexes.get(db);
+  if (cached?.schemaVersion === version)
+    return cached.name;
+  const candidates = db.prepare("PRAGMA index_list(tags)").all();
+  for (const candidate of candidates) {
+    if (!candidate.unique || candidate.origin !== "u")
+      continue;
+    const quoted = `"${candidate.name.replaceAll('"', '""')}"`;
+    const columns = db.prepare(`PRAGMA index_info(${quoted})`).all();
+    if (columns.length !== 2 || columns[0]?.name !== "session_id" || columns[1]?.name !== "tag_number")
+      continue;
+    if (cacheable)
+      tagOrderIndexes.set(db, { schemaVersion: version, name: quoted });
+    return quoted;
   }
-  const dataDir = openCodeDataDir();
-  return [
-    join(dataDir, "opencode.db"),
-    join(dataDir, "opencode-local.db"),
-    join(dataDir, "opencode-dev.db"),
-    join(dataDir, "opencode-<channel>.db")
-  ];
-}
-function recordOpenCodeDbReadFailure(resolution, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  lastReadFailure = { ...resolution, message };
-  return lastReadFailure;
-}
-function clearOpenCodeDbReadFailure(path) {
-  if (path === undefined || lastReadFailure?.path === path)
-    lastReadFailure = null;
-}
-function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
-  const key = `${surface}\x00${resolution.path}\x00${resolution.source}`;
-  if (claimedDiagnostics.has(key))
-    return false;
-  claimedDiagnostics.add(key);
-  return true;
+  throw new Error("tags lacks its UNIQUE(session_id, tag_number) ordering constraint");
 }
 
-// ../plugin/src/features/magic-context/tool-definition-tokens.ts
-var measurements = new Map;
-var fingerprints = new Map;
-var persistenceDb = null;
-var cachedInsertStmt = null;
-function keyFor(providerID, modelID, agentName) {
-  const agent = agentName && agentName.length > 0 ? agentName : "default";
-  return `${providerID}/${modelID}/${agent}`;
-}
-function setDatabase(db) {
-  persistenceDb = db;
-  cachedInsertStmt = null;
-}
-function loadToolDefinitionMeasurements(db) {
-  let rows = [];
-  try {
-    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
-  } catch {
-    return;
-  }
-  for (const row of rows) {
-    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
-    let inner = measurements.get(key);
-    if (!inner) {
-      inner = new Map;
-      measurements.set(key, inner);
-    }
-    inner.set(row.tool_id, row.token_count);
+// ../plugin/src/features/magic-context/storage-tag-identity-revision.ts
+var TAG_IDENTITY_REVISION_PREFIX = "tag_identity_revision:";
+var TAG_REVISION_PREFIX = "tag_revision:";
+var TAG_TOMBSTONE_OWNER_PREFIX = "tag_revision_owner:";
+var TAG_REVISION_INCARNATION_KEY = "tag_revision_incarnation";
+var tagRevisionIncarnationSql = (value) => `CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, 1, INSTR(${value}, ':') - 1) ELSE '0' END`;
+var tagRevisionCountSql = (value) => `CAST(CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, INSTR(${value}, ':') + 1) ELSE ${value} END AS INTEGER)`;
+var ADVANCE = (delta = "1") => `CASE
+    WHEN ${tagRevisionCountSql("value")} <= 9223372036854775807 - ${delta}
+    THEN (${tagRevisionIncarnationSql("value")}) || ':' || CAST(${tagRevisionCountSql("value")} + ${delta} AS TEXT)
+    ELSE NULL END`;
+function tagTombstoneOwnerRange(sessionId) {
+  const stem = `${TAG_TOMBSTONE_OWNER_PREFIX}${JSON.stringify(sessionId)}`;
+  return [`${stem}:`, `${stem};`];
+}
+function tagTombstoneOwnerKey(sessionId, harness) {
+  return `${tagTombstoneOwnerRange(sessionId)[0]}${harness}`;
+}
+function tagRevisionKey(sessionId) {
+  return `${TAG_REVISION_PREFIX}${sessionId}`;
+}
+function tagIdentityRevisionKey(sessionId) {
+  return `${TAG_IDENTITY_REVISION_PREFIX}${sessionId}`;
+}
+var BUMP = (session, prefix = TAG_IDENTITY_REVISION_PREFIX) => `INSERT INTO schema_migrations_meta (key, value)
+        VALUES ('${prefix}' || ${session}, '1')
+        ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()}`;
+var TAG_INSERT_CONFLICT_ROWS = `SELECT id, session_id, tag_number FROM tags WHERE id = NEW.id
+    UNION SELECT id, session_id, tag_number FROM tags WHERE session_id = NEW.session_id AND tag_number = NEW.tag_number
+    UNION SELECT id, session_id, tag_number FROM tags
+        WHERE NEW.type = 'tool' AND NEW.tool_owner_message_id IS NOT NULL
+          AND type = 'tool' AND tool_owner_message_id IS NOT NULL
+          AND session_id = NEW.session_id AND message_id = NEW.message_id
+          AND tool_owner_message_id = NEW.tool_owner_message_id`;
+var BUMP_INSERT_CONFLICTS = (prefix) => `INSERT INTO schema_migrations_meta (key, value)
+    SELECT '${prefix}' || session_id, CAST(COUNT(*) AS TEXT)
+    FROM (${TAG_INSERT_CONFLICT_ROWS}) GROUP BY session_id
+    ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE("CAST(excluded.value AS INTEGER)")}`;
+var TRIGGER_SQL = `CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_identity_revision_au
+    AFTER UPDATE OF id, session_id, message_id, tag_number, type, tool_owner_message_id, reasoning_token_count
+    ON main.tags
+    BEGIN
+        ${BUMP("OLD.session_id")};
+        INSERT INTO schema_migrations_meta (key, value)
+            SELECT '${TAG_IDENTITY_REVISION_PREFIX}' || NEW.session_id, '1'
+            WHERE NEW.session_id IS NOT OLD.session_id
+            ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()};
+    END`;
+function installTagIdentityRevisionTrigger(db) {
+  db.exec(`DROP TRIGGER IF EXISTS temp.mc_tag_identity_revision_au;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_bi;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_ai;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_au;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_ad;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_seed_ai;`);
+  db.exec(`CREATE TEMP TRIGGER mc_tag_revision_seed_ai AFTER INSERT ON main.schema_migrations_meta
+        WHEN INSTR(NEW.value, ':') = 0 AND (
+          SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+          OR SUBSTR(NEW.key, 1, ${TAG_IDENTITY_REVISION_PREFIX.length}) = '${TAG_IDENTITY_REVISION_PREFIX}')
+        BEGIN
+            INSERT INTO schema_migrations_meta (key, value) VALUES ('${TAG_REVISION_INCARNATION_KEY}', '1')
+                ON CONFLICT(key) DO UPDATE SET value = CAST(CASE
+                    WHEN CAST(value AS INTEGER) < 9223372036854775807 THEN CAST(value AS INTEGER) + 1
+                    ELSE NULL END AS TEXT);
+            UPDATE schema_migrations_meta SET value =
+                (SELECT value FROM schema_migrations_meta WHERE key = '${TAG_REVISION_INCARNATION_KEY}')
+                || ':' || CAST(NEW.value AS TEXT) WHERE key = NEW.key;
+            INSERT INTO schema_migrations_meta (key, value)
+                SELECT '${TAG_REVISION_INCARNATION_KEY}', '1'
+                WHERE SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+                  AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta
+                    WHERE key = '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}))
+                ON CONFLICT(key) DO UPDATE SET value = CAST(CASE
+                    WHEN CAST(value AS INTEGER) < 9223372036854775807 THEN CAST(value AS INTEGER) + 1
+                    ELSE NULL END AS TEXT);
+            INSERT INTO schema_migrations_meta (key, value)
+                SELECT '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}),
+                    (SELECT value FROM schema_migrations_meta WHERE key = '${TAG_REVISION_INCARNATION_KEY}') || ':0'
+                WHERE SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+                  AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta
+                    WHERE key = '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}));
+        END;`);
+  db.exec(TRIGGER_SQL);
+  db.exec(`CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_bi BEFORE INSERT ON main.tags BEGIN
+        ${BUMP_INSERT_CONFLICTS(TAG_REVISION_PREFIX)};
+        ${BUMP_INSERT_CONFLICTS(TAG_IDENTITY_REVISION_PREFIX)};
+        UPDATE session_meta SET tags_version = tags_version + 1
+            WHERE session_id IN (SELECT session_id FROM (${TAG_INSERT_CONFLICT_ROWS}));
+    END;`);
+  db.exec(`CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_ai AFTER INSERT ON main.tags BEGIN
+        ${BUMP("NEW.session_id", TAG_REVISION_PREFIX)};
+    END;
+    CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_au AFTER UPDATE ON main.tags BEGIN
+        ${BUMP("OLD.session_id", TAG_REVISION_PREFIX)};
+        INSERT INTO schema_migrations_meta (key, value)
+            SELECT '${TAG_REVISION_PREFIX}' || NEW.session_id, '1'
+            WHERE NEW.session_id IS NOT OLD.session_id
+            ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()};
+    END;
+    CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_ad AFTER DELETE ON main.tags BEGIN
+        ${BUMP("OLD.session_id", TAG_REVISION_PREFIX)};
+    END;`);
+}
+function deleteTagIdentityRevisions(db, sessionIds) {
+  const statement = db.prepare(`INSERT INTO schema_migrations_meta (key, value) VALUES (?, '1')
+         ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()}`);
+  for (const sessionId of sessionIds) {
+    statement.run(tagIdentityRevisionKey(sessionId));
   }
 }
 
-export { stableStringify, closeQuietly, isKnownAutocommit, getTableColumnNames, ensureColumn, healAllNullColumns, observeTemporalDecisions, freezeTemporalDecisions, installV95PerfSchema, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, setDatabase, loadToolDefinitionMeasurements };
+export { stableStringify, closeQuietly, isKnownAutocommit, getTableColumnNames, ensureColumn, healAllNullColumns, observeTemporalDecisions, freezeTemporalDecisions, installV95PerfSchema, tagOrderConstraintIndex, TAG_TOMBSTONE_OWNER_PREFIX, tagRevisionIncarnationSql, tagRevisionCountSql, tagTombstoneOwnerRange, tagTombstoneOwnerKey, tagRevisionKey, tagIdentityRevisionKey, TAG_INSERT_CONFLICT_ROWS, installTagIdentityRevisionTrigger, deleteTagIdentityRevisions };

package/dist/index-r024r8da.js

@@ -0,0 +1,171 @@
+import {
+  withSqliteBackgroundWriter2,
+  withoutSqliteTransformPass2
+} from "./index-3cgbv47m.js";
+import {
+  logSlowWriteTransaction
+} from "./index-0vrkp1jq.js";
+
+// ../plugin/src/features/magic-context/message-fts-rowid-map.ts
+import { createHash } from "node:crypto";
+var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
+var BACKFILL_STATE_ID = 1;
+var EMPTY_INDEX_CONTENT_HASH = createHash("sha256").update("").digest("hex");
+var upsertMapStatements = new WeakMap;
+var rangeReadyStatements = new WeakMap;
+var updateTimeStatements = new WeakMap;
+var activeBackfills = new WeakMap;
+function getUpsertMapStatement(db) {
+  let statement = upsertMapStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`INSERT INTO message_fts_rowid_map
+                 (session_id, message_ordinal, fts_rowid, message_time_ms)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, message_ordinal) DO UPDATE SET
+                 fts_rowid = excluded.fts_rowid,
+                 message_time_ms = COALESCE(
+                     excluded.message_time_ms,
+                     message_fts_rowid_map.message_time_ms
+                 )`);
+    upsertMapStatements.set(db, statement);
+  }
+  return statement;
+}
+function getBackfillState(db) {
+  const row = db.prepare(`SELECT watermark_rowid AS watermarkRowid, completed
+             FROM message_fts_rowid_map_backfill_state
+             WHERE id = ?`).get(BACKFILL_STATE_ID);
+  return {
+    processed: 0,
+    watermarkRowid: typeof row?.watermarkRowid === "number" && Number.isSafeInteger(row.watermarkRowid) ? row.watermarkRowid : 0,
+    completed: row?.completed === 1
+  };
+}
+function recordMessageFtsRowid(db, sessionId, messageOrdinal, ftsRowid, messageTimeMs = null) {
+  const numericRowid = Number(ftsRowid);
+  if (!Number.isSafeInteger(numericRowid) || numericRowid <= 0) {
+    throw new Error(`invalid message FTS rowid: ${String(ftsRowid)}`);
+  }
+  const normalizedTime = typeof messageTimeMs === "number" && Number.isSafeInteger(messageTimeMs) && messageTimeMs >= 0 ? messageTimeMs : null;
+  getUpsertMapStatement(db).run(sessionId, messageOrdinal, numericRowid, normalizedTime);
+}
+function recordIndexedMessageTime(db, sessionId, messageOrdinal, messageTimeMs) {
+  if (typeof messageTimeMs !== "number" || !Number.isSafeInteger(messageTimeMs) || messageTimeMs < 0) {
+    return;
+  }
+  let statement = updateTimeStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`UPDATE message_fts_rowid_map
+                SET message_time_ms = ?
+              WHERE session_id = ? AND message_ordinal = ?
+                AND message_time_ms IS NULL`);
+    updateTimeStatements.set(db, statement);
+  }
+  statement.run(messageTimeMs, sessionId, messageOrdinal);
+}
+function backfillMessageFtsRowidMapBatch(db, batchSize = MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE) {
+  const boundedBatchSize = Number.isFinite(batchSize) ? Math.min(MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE, Math.max(1, Math.floor(batchSize))) : MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE;
+  let progress = {
+    processed: 0,
+    watermarkRowid: 0,
+    completed: false
+  };
+  let transactionStartedAt = 0;
+  db.transaction(() => {
+    transactionStartedAt = performance.now();
+    db.prepare(`INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
+            (id, watermark_rowid, completed) VALUES (?, 0, 0)`).run(BACKFILL_STATE_ID);
+    const state = getBackfillState(db);
+    if (state.completed) {
+      progress = state;
+      return;
+    }
+    const rows = db.prepare(`SELECT rowid AS ftsRowid,
+            session_id AS sessionId, message_ordinal AS messageOrdinal
+            FROM message_history_fts WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`).all(state.watermarkRowid, boundedBatchSize);
+    let watermarkRowid = state.watermarkRowid;
+    for (const row of rows) {
+      const ftsRowid = Number(row.ftsRowid);
+      const messageOrdinal = Number(row.messageOrdinal);
+      if (Number.isSafeInteger(ftsRowid) && ftsRowid > watermarkRowid) {
+        watermarkRowid = ftsRowid;
+      }
+      if (typeof row.sessionId === "string" && Number.isSafeInteger(messageOrdinal) && messageOrdinal >= 0 && Number.isSafeInteger(ftsRowid) && ftsRowid > 0) {
+        recordMessageFtsRowid(db, row.sessionId, messageOrdinal, ftsRowid);
+      }
+    }
+    const completed = rows.length < boundedBatchSize;
+    db.prepare(`UPDATE message_fts_rowid_map_backfill_state
+             SET watermark_rowid = ?, completed = ?, updated_at = ?
+             WHERE id = ?`).run(watermarkRowid, completed ? 1 : 0, Date.now(), BACKFILL_STATE_ID);
+    progress = {
+      processed: rows.length,
+      watermarkRowid,
+      completed
+    };
+  }).immediate();
+  logSlowWriteTransaction("message_fts_rowid_backfill", transactionStartedAt);
+  return progress;
+}
+async function runMessageFtsRowidMapBackfill(db) {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  for (;; ) {
+    const progress = backfillMessageFtsRowidMapBatch(db);
+    if (progress.completed)
+      return;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+function startMessageFtsRowidMapBackfill(db) {
+  const active = activeBackfills.get(db);
+  if (active)
+    return active;
+  const run = withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => runMessageFtsRowidMapBackfill(db))).finally(() => {
+    activeBackfills.delete(db);
+  });
+  activeBackfills.set(db, run);
+  return run;
+}
+function messageFtsOrdinalRangeIsMapped(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal)
+    return true;
+  if (getBackfillState(db).completed)
+    return true;
+  let statement = rangeReadyStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`SELECT COUNT(DISTINCT source.message_ordinal) AS sourceOrdinalCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                        THEN source.message_ordinal
+                    END) AS expectedMapCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                         AND map.fts_rowid IS NOT NULL
+                        THEN source.message_ordinal
+                    END) AS mappedCount
+             FROM message_history_source AS source
+             LEFT JOIN message_fts_rowid_map AS map
+               ON map.session_id = source.session_id
+              AND map.message_ordinal = source.message_ordinal
+             WHERE source.session_id = ?
+               AND source.message_ordinal BETWEEN ? AND ?`);
+    rangeReadyStatements.set(db, statement);
+  }
+  const row = statement.get(EMPTY_INDEX_CONTENT_HASH, EMPTY_INDEX_CONTENT_HASH, sessionId, startOrdinal, endOrdinal);
+  const ordinalCount = endOrdinal - startOrdinal + 1;
+  return row?.sourceOrdinalCount === ordinalCount && row.expectedMapCount === row.mappedCount;
+}
+function deleteUnmappedMessageFtsRows(db, sessionIds) {
+  if (sessionIds.length === 0)
+    return;
+  const state = getBackfillState(db);
+  if (state.completed)
+    return;
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  db.prepare(`DELETE FROM message_history_fts
+         WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
+}
+
+export { recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows };