sensemaking 0.27.0 → 0.27.1

package/dist/cjs/store/batch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/batch.ts"],"sourcesContent":["// Rewrites a single-row parameterized INSERT into one multi-row statement. Engine-neutral string\n// work, shared by duckdb (batch.ts's rewriteBatch) and turso (turso/connection.ts's runBatch).\n\nconst INSERT_RE = /^(INSERT\\s+(?:OR\\s+\\w+\\s+)?INTO\\s+\\S+\\s*\\([^)]*\\)\\s*VALUES\\s*)\\(([^()]*)\\)(.*)$/is;\n\nfunction placeholderCount(tuple: string): number {\n  return (tuple.match(/\\?/g) ?? []).length;\n}\n\nexport function rewriteInsert(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = INSERT_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, head, tuple, tail] = m;\n  const width = placeholderCount(tuple);\n  if (width === 0) return null;\n  const rows = Array.from({ length: rowCount }, () => `(${tuple})`).join(', ');\n  return { sql: `${head}${rows}${tail}`, width };\n}\n"],"names":["rewriteInsert","INSERT_RE","placeholderCount","tuple","match","length","sql","rowCount","m","exec","trim","head","tail","width","rows","Array","from","join"],"mappings":";;;;+BASgBA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAThB,iGAAiG;AACjG,+FAA+F;AAE/F,IAAMC,YAAY;AAElB,SAASC,iBAAiBC,KAAa;QAC7BA;IAAR,OAAO,EAACA,eAAAA,MAAMC,KAAK,CAAC,oBAAZD,0BAAAA,eAAsB,EAAE,EAAEE,MAAM;AAC1C;AAEO,SAASL,cAAcM,GAAW,EAAEC,QAAgB;IACzD,IAAMC,IAAIP,UAAUQ,IAAI,CAACH,IAAII,IAAI;IACjC,IAAI,CAACF,GAAG,OAAO;IACf,IAA8BA,sBAAAA,OAArBG,OAAqBH,OAAfL,QAAeK,OAARI,OAAQJ;IAC9B,IAAMK,QAAQX,iBAAiBC;IAC/B,IAAIU,UAAU,GAAG,OAAO;IACxB,IAAMC,OAAOC,MAAMC,IAAI,CAAC;QAAEX,QAAQE;IAAS,GAAG;eAAM,AAAC,IAAS,OAANJ,OAAM;OAAIc,IAAI,CAAC;IACvE,OAAO;QAAEX,KAAK,AAAC,GAASQ,OAAPH,MAAcC,OAAPE,MAAY,OAALF;QAAQC,OAAAA;IAAM;AAC/C"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/batch.ts"],"sourcesContent":["// Rewrites a single-row parameterized INSERT into one multi-row statement. Engine-neutral string\n// work, shared by duckdb (batch.ts's rewriteBatch) and turso (turso/connection.ts's runBatch).\n\nconst INSERT_RE = /^(INSERT\\s+(?:OR\\s+\\w+\\s+)?INTO\\s+\\S+\\s*\\([^)]*\\)\\s*VALUES\\s*)\\(([^()]*)\\)(.*)$/is;\n\nfunction placeholderCount(tuple: string): number {\n  return (tuple.match(/\\?/g) ?? []).length;\n}\n\nexport function rewriteInsert(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = INSERT_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, head, tuple, tail] = m;\n  const width = placeholderCount(tuple);\n  if (width === 0) return null;\n  const rows = Array.from({ length: rowCount }, () => `(${tuple})`).join(', ');\n  return { sql: `${head}${rows}${tail}`, width };\n}\n"],"names":["rewriteInsert","INSERT_RE","placeholderCount","tuple","match","length","sql","rowCount","m","exec","trim","head","tail","width","rows","Array","from","join"],"mappings":";;;;+BASgBA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAThB,iGAAiG;AACjG,+FAA+F;AAE/F,IAAMC,YAAY;AAElB,SAASC,iBAAiBC,KAAa;QAC7BA;IAAR,OAAO,EAACA,eAAAA,MAAMC,KAAK,CAAC,oBAAZD,0BAAAA,eAAsB,EAAE,EAAEE,MAAM;AAC1C;AAEO,SAASL,cAAcM,GAAW,EAAEC,QAAgB;IACzD,IAAMC,IAAIP,UAAUQ,IAAI,CAACH,IAAII,IAAI;IACjC,IAAI,CAACF,GAAG,OAAO;IACf,IAA8BA,sBAAAA,OAArBG,OAAqBH,OAAfL,QAAeK,OAARI,OAAQJ;IAC9B,IAAMK,QAAQX,iBAAiBC;IAC/B,IAAIU,UAAU,GAAG,OAAO;IACxB,IAAMC,OAAOC,MAAMC,IAAI,CAAC;QAAEX,QAAQE;IAAS,GAAG;eAAM,AAAC,IAAS,OAANJ,OAAM;OAAIc,IAAI,CAAC;IACvE,OAAO;QAAEX,KAAK,AAAC,GAASQ,OAAPH,MAAcC,OAAPE,MAAY,OAALF;QAAQC,OAAAA;IAAM;AAC/C"}

package/dist/cjs/store/builder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { type Config, featureEnabled, featureSignature, type ResolvedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport { classifyEmbedChange } from './embed-scope.ts';\nimport { classifyFeatureToggles, type FeatureToggle, isFeatureOnlyChange, NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { forcedPresetPaths, isPresetOnlyChange } from './preset-scope.ts';\nimport { CORE_GENERATION_META_KEY, CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY } from './readiness.ts';\nimport { createReconcileTiming, prepareReconcile, type ReconcilePaths, type ReconcileSnapshot, type ReconcileTiming, readReconcileSnapshot } from './reconcile.ts';\nimport { setMeta } from './shared.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, signatureDiff } from './signature.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\ninterface BuildResult {\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n  messages: string[];\n}\n\nexport interface Builder {\n  build(): Promise<BuildResult>;\n  close(): Promise<void>;\n  readonly poolsCreated: number;\n}\n\ninterface CoreBaseline {\n  schemaVersion: string | null;\n  features: string | null;\n  ready: string | null;\n  generation: string | null;\n}\n\ninterface PlanningSnapshot {\n  baseline: CoreBaseline;\n  reconcile: ReconcileSnapshot;\n  tables: Set<string>;\n}\n\ninterface PreparedInvalidation {\n  mutated: boolean;\n  parsed: number;\n  apply(conn: Connection): Promise<void>;\n}\n\ninterface BuildClassification {\n  embedKind: ReturnType<typeof classifyEmbedChange>;\n  featureToggles: FeatureToggle[];\n  forcedPaths?: ReadonlySet<string>;\n  fullRebuild: boolean;\n  messages: string[];\n}\n\ntype EnsureFeatureSchema = (cfg: ResolvedConfig) => Promise<void>;\n\nclass StaleBuildPlan extends Error {}\n\nconst buildPlan = channel('sensemaking.store.build-plan');\nconst SCHEMA_VERSION_META_KEY = 'schema_version';\n\nasync function readCoreBaseline(conn: Connection): Promise<CoreBaseline> {\n  const keys = [SCHEMA_VERSION_META_KEY, FEATURE_SIGNATURE_META_KEY, CORE_READY_META_KEY, CORE_GENERATION_META_KEY];\n  const stmt = await conn.prepare(`SELECT key, value FROM meta WHERE key IN (${keys.map(() => '?').join(', ')})`);\n  const values = new Map(((await stmt.all(...keys)) as Array<{ key: string; value: string }>).map((row) => [row.key, row.value]));\n  return {\n    schemaVersion: values.get(SCHEMA_VERSION_META_KEY) ?? null,\n    features: values.get(FEATURE_SIGNATURE_META_KEY) ?? null,\n    ready: values.get(CORE_READY_META_KEY) ?? null,\n    generation: values.get(CORE_GENERATION_META_KEY) ?? null,\n  };\n}\n\nfunction sameBaseline(a: CoreBaseline, b: CoreBaseline): boolean {\n  return a.schemaVersion === b.schemaVersion && a.features === b.features && a.ready === b.ready && a.generation === b.generation;\n}\n\nfunction nextGeneration(value: string | null): string {\n  const current = value === null ? 0 : Number(value);\n  if (!Number.isSafeInteger(current) || current < 0 || current === Number.MAX_SAFE_INTEGER) throw new SenseError('INDEX_NOT_READY', `the durable core generation is invalid (${value ?? 'missing'}); run sense build --force to recreate the derived index`);\n  return String(current + 1);\n}\n\nasync function readPlanningSnapshot(conn: Connection, timing: ReconcileTiming): Promise<PlanningSnapshot> {\n  return withTransaction(conn, async () => {\n    const baseline = await readCoreBaseline(conn);\n    const reconcile = await readReconcileSnapshot(conn, timing);\n    const tablesStmt = await conn.prepare(\"SELECT name FROM sqlite_master WHERE type = 'table'\");\n    const tables = new Set(((await tablesStmt.all()) as Array<{ name: string }>).map((row) => row.name));\n    return { baseline, reconcile, tables };\n  });\n}\n\nfunction activeSchemaMissing(snapshot: PlanningSnapshot, cfg: Config): boolean {\n  for (const feature of FEATURES) {\n    if (!featureEnabled(cfg, feature.name)) continue;\n    if (feature.name === 'rank') {\n      if (!snapshot.reconcile.seenColumns.has('_rank')) return true;\n      continue;\n    }\n    const table = feature.name === 'embed' ? 'embeddings' : NARROW_FEATURE_TABLE[feature.name];\n    if (table && !snapshot.tables.has(table)) return true;\n  }\n  return false;\n}\n\nfunction classifyBuild(snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, wanted: string): BuildClassification {\n  const before = snapshot.baseline.features;\n  const recover = snapshot.baseline.ready === '0';\n  const messages: string[] = [];\n  if (recover) messages.push('sense: recovering an incomplete index generation in place');\n  if (!recover && before !== null && before === wanted && activeSchemaMissing(snapshot, cfg)) {\n    messages.push('sense: recovering missing feature schema in place');\n    return { embedKind: null, featureToggles: [], fullRebuild: true, messages };\n  }\n  if (recover || before === null || before === wanted) return { embedKind: null, featureToggles: [], fullRebuild: recover, messages };\n\n  const changedKeys = changedSignatureKeys(before, wanted);\n  if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(before, wanted)) {\n    messages.push(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n    return { embedKind: null, featureToggles: [], fullRebuild: false, messages };\n  }\n\n  const embedKind = changedKeys.size === 1 && changedKeys.has('embed') ? classifyEmbedChange(before, wanted) : null;\n  if (embedKind !== null) {\n    messages.push(embedKind === 'model' ? 'sense: config change (embed settings) invalidates only the stale vectors' : 'sense: config change (embed settings) rebuilds only the embeddings it affects');\n    return { embedKind, featureToggles: [], fullRebuild: false, messages };\n  }\n\n  const presetForced = isPresetOnlyChange(changedKeys) ? forcedPresetPaths(cfg, paths.rootDir, before, changedKeys) : null;\n  if (presetForced !== null) {\n    messages.push(`sense: config change (${signatureDiff(before, wanted)}) reparses only the files it affects`);\n    return { embedKind: null, featureToggles: [], forcedPaths: presetForced, fullRebuild: false, messages };\n  }\n\n  const toggles = isFeatureOnlyChange(changedKeys) ? classifyFeatureToggles(before, wanted, changedKeys) : null;\n  if (toggles !== null) {\n    messages.push(`sense: config change (${signatureDiff(before, wanted)}) reparses only the feature it affects`);\n    return { embedKind: null, featureToggles: toggles, fullRebuild: false, messages };\n  }\n\n  messages.push(`sense: config change (${signatureDiff(before, wanted)}) rebuilds the index`);\n  return { embedKind: null, featureToggles: [], fullRebuild: true, messages };\n}\n\nasync function prepareEmbedInvalidation(kind: NonNullable<BuildClassification['embedKind']>, snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  if (kind === 'model') {\n    return { mutated: true, parsed: 0, apply: (conn) => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL') };\n  }\n\n  const existing = new Set(snapshot.reconcile.existingRows.map((row) => row.path));\n  const files = listFiles(cfg, paths.rootDir).filter((file) => file.embed && existing.has(file.relPath));\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const pathsChanged = docs.map((doc) => doc.relPath);\n  const delta: ReconcileDelta = { files, reparsed: pathsChanged, added: [], vanished: [] };\n  return {\n    mutated: true,\n    parsed: docs.length,\n    async apply(conn) {\n      // Chunk changes can also change the model. Clear every affected row even when\n      // its text identity happens to match under the new configuration.\n      if (pathsChanged.length > 0)\n        await conn.runBatch(\n          'DELETE FROM embeddings WHERE \"path\" = ?',\n          pathsChanged.map((path) => [path])\n        );\n      await embed.store?.(\n        conn,\n        docs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted.embed })),\n        delta\n      );\n    },\n  };\n}\n\nasync function prepareFeatureInvalidation(toggles: FeatureToggle[], snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  if (toggles.length === 0) return { mutated: false, parsed: 0, apply: async () => {} };\n  const prepared = new Map<string, { feature: (typeof FEATURES)[number]; docs: Awaited<ReturnType<typeof reparseFiles>>['docs']; files: ReturnType<typeof listFiles> }>();\n  let parsed = 0;\n  for (const toggle of toggles) {\n    if (!toggle.turnedOn || toggle.name === 'rank') continue;\n    const feature = FEATURES.find((candidate) => candidate.name === toggle.name);\n    if (!feature) throw new Error(`prepareFeatureInvalidation: no registered feature named \"${toggle.name}\"`);\n    const files = listFiles(cfg, paths.rootDir);\n    const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n    parsed += docs.length;\n    prepared.set(toggle.name, { feature, docs, files });\n  }\n\n  const applyTable = async (conn: Connection, toggle: FeatureToggle): Promise<void> => {\n    const table = NARROW_FEATURE_TABLE[toggle.name];\n    if (!table) return;\n    if (!toggle.turnedOn) {\n      if (snapshot.tables.has(table)) await conn.exec(`DELETE FROM ${table}`);\n      return;\n    }\n    const plan = prepared.get(toggle.name);\n    if (!plan) throw new Error(`prepareFeatureInvalidation: missing prepared feature \"${toggle.name}\"`);\n    const pathsChanged = plan.docs.map((doc) => doc.relPath);\n    const delta: ReconcileDelta = { files: plan.files, reparsed: pathsChanged, added: pathsChanged, vanished: [] };\n    await conn.exec(`DELETE FROM ${table}`);\n    await plan.feature.store?.(\n      conn,\n      plan.docs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted[plan.feature.name] })),\n      delta\n    );\n    await plan.feature.afterReconcile?.(conn, delta);\n  };\n\n  const nullRank = async (conn: Connection): Promise<void> => {\n    if (snapshot.reconcile.seenColumns.has('_rank')) await conn.exec('UPDATE frontmatter SET \"_rank\" = NULL');\n  };\n\n  return {\n    mutated: true,\n    parsed,\n    async apply(conn) {\n      const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n      const linksToggle = byName.get('links');\n      if (linksToggle) {\n        await applyTable(conn, linksToggle);\n        if (!linksToggle.turnedOn) await nullRank(conn);\n      }\n      const rankToggle = byName.get('rank');\n      if (rankToggle) {\n        if (rankToggle.turnedOn) await rank.afterReconcile?.(conn, { files: [], reparsed: [], added: [], vanished: [] });\n        else await nullRank(conn);\n      }\n      for (const toggle of toggles) {\n        if (toggle.name !== 'links' && toggle.name !== 'rank') await applyTable(conn, toggle);\n      }\n    },\n  };\n}\n\nfunction recoveryToggles(cfg: Config, snapshot: PlanningSnapshot): FeatureToggle[] {\n  const toggles: FeatureToggle[] = [];\n  for (const feature of FEATURES) {\n    const table = NARROW_FEATURE_TABLE[feature.name];\n    if (table && !featureEnabled(cfg, feature.name) && snapshot.tables.has(table)) toggles.push({ name: feature.name, turnedOn: false });\n  }\n  return toggles;\n}\n\nasync function prepareInvalidation(classification: BuildClassification, snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  const plans: PreparedInvalidation[] = [];\n  if (classification.embedKind) plans.push(await prepareEmbedInvalidation(classification.embedKind, snapshot, cfg, paths, pool));\n  if (classification.featureToggles.length > 0) plans.push(await prepareFeatureInvalidation(classification.featureToggles, snapshot, cfg, paths, pool));\n  if (classification.fullRebuild) {\n    plans.push(await prepareFeatureInvalidation(recoveryToggles(cfg, snapshot), snapshot, cfg, paths, pool));\n    // Full rebuild and recovery must not reuse vectors from the prior generation.\n    if (snapshot.tables.has('embeddings')) {\n      plans.push({ mutated: true, parsed: 0, apply: (conn) => conn.exec('DELETE FROM embeddings') });\n    }\n    if (!featureEnabled(cfg, 'rank') && snapshot.reconcile.seenColumns.has('_rank')) {\n      plans.push({ mutated: true, parsed: 0, apply: (conn) => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL') });\n    }\n  }\n  return {\n    mutated: plans.some((plan) => plan.mutated),\n    parsed: plans.reduce((sum, plan) => sum + plan.parsed, 0),\n    async apply(conn) {\n      for (const plan of plans) await plan.apply(conn);\n    },\n  };\n}\n\nfunction forcedPaths(classification: BuildClassification, snapshot: PlanningSnapshot): ReadonlySet<string> | undefined {\n  if (!classification.fullRebuild) return classification.forcedPaths;\n  // New paths are reparsed by definition. Forcing every previously indexed path makes every\n  // survivor a reparse without a second filesystem scan outside prepareReconcile's one listing.\n  return new Set(snapshot.reconcile.existingRows.map((row) => row.path));\n}\n\nasync function publishAttempt(conn: Connection, liveCfg: ResolvedConfig, dialect: ReconcileDialect, pool: ParsePool, ensureFeatureSchema: EnsureFeatureSchema, timing: ReconcileTiming, attempt: number): Promise<BuildResult> {\n  const cfg = structuredClone(liveCfg);\n  const configIdentity = JSON.stringify(cfg);\n  const paths: ReconcilePaths = { rootDir: cfg.rootDir ?? cfg.baseDir, configDir: cfg.configDir ?? cfg.baseDir };\n  const wanted = featureSignature(cfg, FEATURES);\n  const snapshot = await readPlanningSnapshot(conn, timing);\n  const classification = classifyBuild(snapshot, cfg, paths, wanted);\n  const invalidation = await prepareInvalidation(classification, snapshot, cfg, paths, pool);\n  const reconcile = await prepareReconcile(snapshot.reconcile, cfg, paths, dialect, timing, pool, forcedPaths(classification, snapshot));\n  const mutated = classification.fullRebuild || invalidation.mutated || reconcile.mutated || snapshot.baseline.features !== wanted || snapshot.baseline.ready !== '1';\n\n  if (buildPlan.hasSubscribers) buildPlan.publish({ attempt, baseline: snapshot.baseline, wantedSignature: wanted });\n  const txStart = Date.now();\n  let txMs: number;\n  try {\n    await withTransaction(\n      conn,\n      async () => {\n        const current = await readCoreBaseline(conn);\n        const currentWanted = featureSignature(liveCfg, FEATURES);\n        if (!sameBaseline(current, snapshot.baseline) || JSON.stringify(liveCfg) !== configIdentity || currentWanted !== wanted) {\n          throw new StaleBuildPlan('core generation or configuration changed while this build was planning');\n        }\n        if (!mutated) return;\n        await ensureFeatureSchema(cfg);\n        await invalidation.apply(conn);\n        await reconcile.apply(conn);\n        const publishedWanted = featureSignature(liveCfg, FEATURES);\n        if (JSON.stringify(liveCfg) !== configIdentity || publishedWanted !== wanted) throw new StaleBuildPlan('configuration changed while this build was publishing');\n        await setMeta(conn, FEATURE_SIGNATURE_META_KEY, wanted);\n        await setMeta(conn, CORE_READY_META_KEY, '1');\n        await setMeta(conn, CORE_GENERATION_META_KEY, nextGeneration(snapshot.baseline.generation));\n      },\n      dialect.beginMode()\n    );\n  } finally {\n    txMs = Date.now() - txStart;\n    timing.txMs += txMs;\n  }\n  if (reconcile.mutated) await reconcile.record(conn, txMs);\n  return {\n    parsed: invalidation.parsed + reconcile.parsed,\n    warnings: reconcile.warnings,\n    stages: reconcile.finish(timing.txMs),\n    messages: classification.messages,\n  };\n}\n\nexport function createBuilder(conn: Connection, cfg: ResolvedConfig, dialect: ReconcileDialect, ensureFeatureSchema: EnsureFeatureSchema): Builder {\n  const pool = new ParsePool();\n  return {\n    async build() {\n      // One clock and recorder span both bounded attempts. Baseline/catalog reads and feature\n      // invalidation preparation are included in totalMs but remain intentionally unlabelled;\n      // existing/list/parse and publication stages accumulate under their established labels.\n      const timing = createReconcileTiming(cfg);\n      for (let attempt = 0; attempt < 2; attempt++) {\n        try {\n          return await publishAttempt(conn, cfg, dialect, pool, ensureFeatureSchema, timing, attempt);\n        } catch (err) {\n          if (!(err instanceof StaleBuildPlan)) throw err;\n          if (attempt === 1) throw new SenseError('STORE_BUSY', 'the index changed during both bounded publication attempts; wait for the competing build to finish and retry');\n        }\n      }\n      throw new Error('unreachable build attempt state');\n    },\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","StaleBuildPlan","Error","buildPlan","channel","SCHEMA_VERSION_META_KEY","readCoreBaseline","conn","stmt","values","keys","FEATURE_SIGNATURE_META_KEY","CORE_READY_META_KEY","CORE_GENERATION_META_KEY","prepare","map","join","Map","all","row","key","value","schemaVersion","get","features","ready","generation","sameBaseline","a","b","nextGeneration","current","Number","isSafeInteger","MAX_SAFE_INTEGER","SenseError","String","readPlanningSnapshot","timing","withTransaction","baseline","reconcile","tablesStmt","tables","readReconcileSnapshot","Set","name","activeSchemaMissing","snapshot","cfg","FEATURES","feature","featureEnabled","seenColumns","has","table","NARROW_FEATURE_TABLE","classifyBuild","paths","wanted","before","recover","messages","push","embedKind","featureToggles","fullRebuild","changedKeys","changedSignatureKeys","size","embedIdentityAdopted","classifyEmbedChange","presetForced","isPresetOnlyChange","forcedPresetPaths","rootDir","signatureDiff","forcedPaths","toggles","isFeatureOnlyChange","classifyFeatureToggles","prepareEmbedInvalidation","kind","pool","existing","files","docs","pathsChanged","delta","mutated","parsed","apply","exec","existingRows","path","listFiles","filter","file","embed","relPath","reparseFiles","undefined","doc","reparsed","added","vanished","length","runBatch","store","extracted","prepareFeatureInvalidation","prepared","applyTable","nullRank","toggle","turnedOn","find","candidate","set","plan","afterReconcile","byName","linksToggle","rankToggle","rank","recoveryToggles","prepareInvalidation","classification","plans","some","reduce","sum","publishAttempt","liveCfg","dialect","ensureFeatureSchema","attempt","configIdentity","invalidation","txStart","txMs","structuredClone","JSON","stringify","baseDir","configDir","featureSignature","prepareReconcile","hasSubscribers","publish","wantedSignature","Date","now","currentWanted","publishedWanted","setMeta","beginMode","record","warnings","stages","finish","ParsePool","build","err","createReconcileTiming","close","poolsCreated"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { type Config, featureEnabled, featureSignature, type ResolvedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport { classifyEmbedChange } from './embed-scope.ts';\nimport { classifyFeatureToggles, type FeatureToggle, isFeatureOnlyChange, NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { forcedPresetPaths, isPresetOnlyChange } from './preset-scope.ts';\nimport { CORE_GENERATION_META_KEY, CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY } from './readiness.ts';\nimport { createReconcileTiming, prepareReconcile, type ReconcilePaths, type ReconcileSnapshot, type ReconcileTiming, readReconcileSnapshot } from './reconcile.ts';\nimport { setMeta } from './shared.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, signatureDiff } from './signature.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\ninterface BuildResult {\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n  messages: string[];\n}\n\nexport interface Builder {\n  build(): Promise<BuildResult>;\n  close(): Promise<void>;\n  readonly poolsCreated: number;\n}\n\ninterface CoreBaseline {\n  schemaVersion: string | null;\n  features: string | null;\n  ready: string | null;\n  generation: string | null;\n}\n\ninterface PlanningSnapshot {\n  baseline: CoreBaseline;\n  reconcile: ReconcileSnapshot;\n  tables: Set<string>;\n}\n\ninterface PreparedInvalidation {\n  mutated: boolean;\n  parsed: number;\n  apply(conn: Connection): Promise<void>;\n}\n\ninterface BuildClassification {\n  embedKind: ReturnType<typeof classifyEmbedChange>;\n  featureToggles: FeatureToggle[];\n  forcedPaths?: ReadonlySet<string>;\n  fullRebuild: boolean;\n  messages: string[];\n}\n\ntype EnsureFeatureSchema = (cfg: ResolvedConfig) => Promise<void>;\n\nclass StaleBuildPlan extends Error {}\n\nconst buildPlan = channel('sensemaking.store.build-plan');\nconst SCHEMA_VERSION_META_KEY = 'schema_version';\n\nasync function readCoreBaseline(conn: Connection): Promise<CoreBaseline> {\n  const keys = [SCHEMA_VERSION_META_KEY, FEATURE_SIGNATURE_META_KEY, CORE_READY_META_KEY, CORE_GENERATION_META_KEY];\n  const stmt = await conn.prepare(`SELECT key, value FROM meta WHERE key IN (${keys.map(() => '?').join(', ')})`);\n  const values = new Map(((await stmt.all(...keys)) as Array<{ key: string; value: string }>).map((row) => [row.key, row.value]));\n  return {\n    schemaVersion: values.get(SCHEMA_VERSION_META_KEY) ?? null,\n    features: values.get(FEATURE_SIGNATURE_META_KEY) ?? null,\n    ready: values.get(CORE_READY_META_KEY) ?? null,\n    generation: values.get(CORE_GENERATION_META_KEY) ?? null,\n  };\n}\n\nfunction sameBaseline(a: CoreBaseline, b: CoreBaseline): boolean {\n  return a.schemaVersion === b.schemaVersion && a.features === b.features && a.ready === b.ready && a.generation === b.generation;\n}\n\nfunction nextGeneration(value: string | null): string {\n  const current = value === null ? 0 : Number(value);\n  if (!Number.isSafeInteger(current) || current < 0 || current === Number.MAX_SAFE_INTEGER) throw new SenseError('INDEX_NOT_READY', `the durable core generation is invalid (${value ?? 'missing'}); run sense build --force to recreate the derived index`);\n  return String(current + 1);\n}\n\nasync function readPlanningSnapshot(conn: Connection, timing: ReconcileTiming): Promise<PlanningSnapshot> {\n  return withTransaction(conn, async () => {\n    const baseline = await readCoreBaseline(conn);\n    const reconcile = await readReconcileSnapshot(conn, timing);\n    const tablesStmt = await conn.prepare(\"SELECT name FROM sqlite_master WHERE type = 'table'\");\n    const tables = new Set(((await tablesStmt.all()) as Array<{ name: string }>).map((row) => row.name));\n    return { baseline, reconcile, tables };\n  });\n}\n\nfunction activeSchemaMissing(snapshot: PlanningSnapshot, cfg: Config): boolean {\n  for (const feature of FEATURES) {\n    if (!featureEnabled(cfg, feature.name)) continue;\n    if (feature.name === 'rank') {\n      if (!snapshot.reconcile.seenColumns.has('_rank')) return true;\n      continue;\n    }\n    const table = feature.name === 'embed' ? 'embeddings' : NARROW_FEATURE_TABLE[feature.name];\n    if (table && !snapshot.tables.has(table)) return true;\n  }\n  return false;\n}\n\nfunction classifyBuild(snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, wanted: string): BuildClassification {\n  const before = snapshot.baseline.features;\n  const recover = snapshot.baseline.ready === '0';\n  const messages: string[] = [];\n  if (recover) messages.push('sense: recovering an incomplete index generation in place');\n  if (!recover && before !== null && before === wanted && activeSchemaMissing(snapshot, cfg)) {\n    messages.push('sense: recovering missing feature schema in place');\n    return { embedKind: null, featureToggles: [], fullRebuild: true, messages };\n  }\n  if (recover || before === null || before === wanted) return { embedKind: null, featureToggles: [], fullRebuild: recover, messages };\n\n  const changedKeys = changedSignatureKeys(before, wanted);\n  if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(before, wanted)) {\n    messages.push(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n    return { embedKind: null, featureToggles: [], fullRebuild: false, messages };\n  }\n\n  const embedKind = changedKeys.size === 1 && changedKeys.has('embed') ? classifyEmbedChange(before, wanted) : null;\n  if (embedKind !== null) {\n    messages.push(embedKind === 'model' ? 'sense: config change (embed settings) invalidates only the stale vectors' : 'sense: config change (embed settings) rebuilds only the embeddings it affects');\n    return { embedKind, featureToggles: [], fullRebuild: false, messages };\n  }\n\n  const presetForced = isPresetOnlyChange(changedKeys) ? forcedPresetPaths(cfg, paths.rootDir, before, changedKeys) : null;\n  if (presetForced !== null) {\n    messages.push(`sense: config change (${signatureDiff(before, wanted)}) reparses only the files it affects`);\n    return { embedKind: null, featureToggles: [], forcedPaths: presetForced, fullRebuild: false, messages };\n  }\n\n  const toggles = isFeatureOnlyChange(changedKeys) ? classifyFeatureToggles(before, wanted, changedKeys) : null;\n  if (toggles !== null) {\n    messages.push(`sense: config change (${signatureDiff(before, wanted)}) reparses only the feature it affects`);\n    return { embedKind: null, featureToggles: toggles, fullRebuild: false, messages };\n  }\n\n  messages.push(`sense: config change (${signatureDiff(before, wanted)}) rebuilds the index`);\n  return { embedKind: null, featureToggles: [], fullRebuild: true, messages };\n}\n\nasync function prepareEmbedInvalidation(kind: NonNullable<BuildClassification['embedKind']>, snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  if (kind === 'model') {\n    return { mutated: true, parsed: 0, apply: (conn) => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL') };\n  }\n\n  const existing = new Set(snapshot.reconcile.existingRows.map((row) => row.path));\n  const files = listFiles(cfg, paths.rootDir).filter((file) => file.embed && existing.has(file.relPath));\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const pathsChanged = docs.map((doc) => doc.relPath);\n  const delta: ReconcileDelta = { files, reparsed: pathsChanged, added: [], vanished: [] };\n  return {\n    mutated: true,\n    parsed: docs.length,\n    async apply(conn) {\n      // Chunk changes can also change the model. Clear every affected row even when\n      // its text identity happens to match under the new configuration.\n      if (pathsChanged.length > 0)\n        await conn.runBatch(\n          'DELETE FROM embeddings WHERE \"path\" = ?',\n          pathsChanged.map((path) => [path])\n        );\n      await embed.store?.(\n        conn,\n        docs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted.embed })),\n        delta\n      );\n    },\n  };\n}\n\nasync function prepareFeatureInvalidation(toggles: FeatureToggle[], snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  if (toggles.length === 0) return { mutated: false, parsed: 0, apply: async () => {} };\n  const prepared = new Map<string, { feature: (typeof FEATURES)[number]; docs: Awaited<ReturnType<typeof reparseFiles>>['docs']; files: ReturnType<typeof listFiles> }>();\n  let parsed = 0;\n  for (const toggle of toggles) {\n    if (!toggle.turnedOn || toggle.name === 'rank') continue;\n    const feature = FEATURES.find((candidate) => candidate.name === toggle.name);\n    if (!feature) throw new Error(`prepareFeatureInvalidation: no registered feature named \"${toggle.name}\"`);\n    const files = listFiles(cfg, paths.rootDir);\n    const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n    parsed += docs.length;\n    prepared.set(toggle.name, { feature, docs, files });\n  }\n\n  const applyTable = async (conn: Connection, toggle: FeatureToggle): Promise<void> => {\n    const table = NARROW_FEATURE_TABLE[toggle.name];\n    if (!table) return;\n    if (!toggle.turnedOn) {\n      if (snapshot.tables.has(table)) await conn.exec(`DELETE FROM ${table}`);\n      return;\n    }\n    const plan = prepared.get(toggle.name);\n    if (!plan) throw new Error(`prepareFeatureInvalidation: missing prepared feature \"${toggle.name}\"`);\n    const pathsChanged = plan.docs.map((doc) => doc.relPath);\n    const delta: ReconcileDelta = { files: plan.files, reparsed: pathsChanged, added: pathsChanged, vanished: [] };\n    await conn.exec(`DELETE FROM ${table}`);\n    await plan.feature.store?.(\n      conn,\n      plan.docs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted[plan.feature.name] })),\n      delta\n    );\n    await plan.feature.afterReconcile?.(conn, delta);\n  };\n\n  const nullRank = async (conn: Connection): Promise<void> => {\n    if (snapshot.reconcile.seenColumns.has('_rank')) await conn.exec('UPDATE frontmatter SET \"_rank\" = NULL');\n  };\n\n  return {\n    mutated: true,\n    parsed,\n    async apply(conn) {\n      const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n      const linksToggle = byName.get('links');\n      if (linksToggle) {\n        await applyTable(conn, linksToggle);\n        if (!linksToggle.turnedOn) await nullRank(conn);\n      }\n      const rankToggle = byName.get('rank');\n      if (rankToggle) {\n        if (rankToggle.turnedOn) await rank.afterReconcile?.(conn, { files: [], reparsed: [], added: [], vanished: [] });\n        else await nullRank(conn);\n      }\n      for (const toggle of toggles) {\n        if (toggle.name !== 'links' && toggle.name !== 'rank') await applyTable(conn, toggle);\n      }\n    },\n  };\n}\n\nfunction recoveryToggles(cfg: Config, snapshot: PlanningSnapshot): FeatureToggle[] {\n  const toggles: FeatureToggle[] = [];\n  for (const feature of FEATURES) {\n    const table = NARROW_FEATURE_TABLE[feature.name];\n    if (table && !featureEnabled(cfg, feature.name) && snapshot.tables.has(table)) toggles.push({ name: feature.name, turnedOn: false });\n  }\n  return toggles;\n}\n\nasync function prepareInvalidation(classification: BuildClassification, snapshot: PlanningSnapshot, cfg: Config, paths: ReconcilePaths, pool: ParsePool): Promise<PreparedInvalidation> {\n  const plans: PreparedInvalidation[] = [];\n  if (classification.embedKind) plans.push(await prepareEmbedInvalidation(classification.embedKind, snapshot, cfg, paths, pool));\n  if (classification.featureToggles.length > 0) plans.push(await prepareFeatureInvalidation(classification.featureToggles, snapshot, cfg, paths, pool));\n  if (classification.fullRebuild) {\n    plans.push(await prepareFeatureInvalidation(recoveryToggles(cfg, snapshot), snapshot, cfg, paths, pool));\n    // Full rebuild and recovery must not reuse vectors from the prior generation.\n    if (snapshot.tables.has('embeddings')) {\n      plans.push({ mutated: true, parsed: 0, apply: (conn) => conn.exec('DELETE FROM embeddings') });\n    }\n    if (!featureEnabled(cfg, 'rank') && snapshot.reconcile.seenColumns.has('_rank')) {\n      plans.push({ mutated: true, parsed: 0, apply: (conn) => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL') });\n    }\n  }\n  return {\n    mutated: plans.some((plan) => plan.mutated),\n    parsed: plans.reduce((sum, plan) => sum + plan.parsed, 0),\n    async apply(conn) {\n      for (const plan of plans) await plan.apply(conn);\n    },\n  };\n}\n\nfunction forcedPaths(classification: BuildClassification, snapshot: PlanningSnapshot): ReadonlySet<string> | undefined {\n  if (!classification.fullRebuild) return classification.forcedPaths;\n  // New paths are reparsed by definition. Forcing every previously indexed path makes every\n  // survivor a reparse without a second filesystem scan outside prepareReconcile's one listing.\n  return new Set(snapshot.reconcile.existingRows.map((row) => row.path));\n}\n\nasync function publishAttempt(conn: Connection, liveCfg: ResolvedConfig, dialect: ReconcileDialect, pool: ParsePool, ensureFeatureSchema: EnsureFeatureSchema, timing: ReconcileTiming, attempt: number): Promise<BuildResult> {\n  const cfg = structuredClone(liveCfg);\n  const configIdentity = JSON.stringify(cfg);\n  const paths: ReconcilePaths = { rootDir: cfg.rootDir ?? cfg.baseDir, configDir: cfg.configDir ?? cfg.baseDir };\n  const wanted = featureSignature(cfg, FEATURES);\n  const snapshot = await readPlanningSnapshot(conn, timing);\n  const classification = classifyBuild(snapshot, cfg, paths, wanted);\n  const invalidation = await prepareInvalidation(classification, snapshot, cfg, paths, pool);\n  const reconcile = await prepareReconcile(snapshot.reconcile, cfg, paths, dialect, timing, pool, forcedPaths(classification, snapshot));\n  const mutated = classification.fullRebuild || invalidation.mutated || reconcile.mutated || snapshot.baseline.features !== wanted || snapshot.baseline.ready !== '1';\n\n  if (buildPlan.hasSubscribers) buildPlan.publish({ attempt, baseline: snapshot.baseline, wantedSignature: wanted });\n  const txStart = Date.now();\n  let txMs: number;\n  try {\n    await withTransaction(\n      conn,\n      async () => {\n        const current = await readCoreBaseline(conn);\n        const currentWanted = featureSignature(liveCfg, FEATURES);\n        if (!sameBaseline(current, snapshot.baseline) || JSON.stringify(liveCfg) !== configIdentity || currentWanted !== wanted) {\n          throw new StaleBuildPlan('core generation or configuration changed while this build was planning');\n        }\n        if (!mutated) return;\n        await ensureFeatureSchema(cfg);\n        await invalidation.apply(conn);\n        await reconcile.apply(conn);\n        const publishedWanted = featureSignature(liveCfg, FEATURES);\n        if (JSON.stringify(liveCfg) !== configIdentity || publishedWanted !== wanted) throw new StaleBuildPlan('configuration changed while this build was publishing');\n        await setMeta(conn, FEATURE_SIGNATURE_META_KEY, wanted);\n        await setMeta(conn, CORE_READY_META_KEY, '1');\n        await setMeta(conn, CORE_GENERATION_META_KEY, nextGeneration(snapshot.baseline.generation));\n      },\n      dialect.beginMode()\n    );\n  } finally {\n    txMs = Date.now() - txStart;\n    timing.txMs += txMs;\n  }\n  if (reconcile.mutated) await reconcile.record(conn, txMs);\n  return {\n    parsed: invalidation.parsed + reconcile.parsed,\n    warnings: reconcile.warnings,\n    stages: reconcile.finish(timing.txMs),\n    messages: classification.messages,\n  };\n}\n\nexport function createBuilder(conn: Connection, cfg: ResolvedConfig, dialect: ReconcileDialect, ensureFeatureSchema: EnsureFeatureSchema): Builder {\n  const pool = new ParsePool();\n  return {\n    async build() {\n      // One clock and recorder span both bounded attempts. Baseline/catalog reads and feature\n      // invalidation preparation are included in totalMs but remain intentionally unlabelled;\n      // existing/list/parse and publication stages accumulate under their established labels.\n      const timing = createReconcileTiming(cfg);\n      for (let attempt = 0; attempt < 2; attempt++) {\n        try {\n          return await publishAttempt(conn, cfg, dialect, pool, ensureFeatureSchema, timing, attempt);\n        } catch (err) {\n          if (!(err instanceof StaleBuildPlan)) throw err;\n          if (attempt === 1) throw new SenseError('STORE_BUSY', 'the index changed during both bounded publication attempts; wait for the competing build to finish and retry');\n        }\n      }\n      throw new Error('unreachable build attempt state');\n    },\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","StaleBuildPlan","Error","buildPlan","channel","SCHEMA_VERSION_META_KEY","readCoreBaseline","conn","stmt","values","keys","FEATURE_SIGNATURE_META_KEY","CORE_READY_META_KEY","CORE_GENERATION_META_KEY","prepare","map","join","Map","all","row","key","value","schemaVersion","get","features","ready","generation","sameBaseline","a","b","nextGeneration","current","Number","isSafeInteger","MAX_SAFE_INTEGER","SenseError","String","readPlanningSnapshot","timing","withTransaction","baseline","reconcile","tablesStmt","tables","readReconcileSnapshot","Set","name","activeSchemaMissing","snapshot","cfg","FEATURES","feature","featureEnabled","seenColumns","has","table","NARROW_FEATURE_TABLE","classifyBuild","paths","wanted","before","recover","messages","push","embedKind","featureToggles","fullRebuild","changedKeys","changedSignatureKeys","size","embedIdentityAdopted","classifyEmbedChange","presetForced","isPresetOnlyChange","forcedPresetPaths","rootDir","signatureDiff","forcedPaths","toggles","isFeatureOnlyChange","classifyFeatureToggles","prepareEmbedInvalidation","kind","pool","existing","files","docs","pathsChanged","delta","mutated","parsed","apply","exec","existingRows","path","listFiles","filter","file","embed","relPath","reparseFiles","undefined","doc","reparsed","added","vanished","length","runBatch","store","extracted","prepareFeatureInvalidation","prepared","applyTable","nullRank","toggle","turnedOn","find","candidate","set","plan","afterReconcile","byName","linksToggle","rankToggle","rank","recoveryToggles","prepareInvalidation","classification","plans","some","reduce","sum","publishAttempt","liveCfg","dialect","ensureFeatureSchema","attempt","configIdentity","invalidation","txStart","txMs","structuredClone","JSON","stringify","baseDir","configDir","featureSignature","prepareReconcile","hasSubscribers","publish","wantedSignature","Date","now","currentWanted","publishedWanted","setMeta","beginMode","record","warnings","stages","finish","ParsePool","build","err","createReconcileTiming","close","poolsCreated"],"mappings":"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"}

package/dist/cjs/store/cache.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/cache.ts"],"sourcesContent":["import { rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { STATE_DIR } from '../config/index.ts';\n\n// Deletes the cache directory and nothing else: the next open() reconciles anyway. Engine-neutral,\n// since every store keeps its files under the same STATE_DIR.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.configDir ?? cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["clearCache","cfg","rmSync","join","configDir","baseDir","STATE_DIR","recursive","force"],"mappings":";;;;+BAOgBA;;;eAAAA;;;sBAPO;wBACF;uBAEK;AAInB,SAASA,WAAWC,GAAmB;QAChCA;IAAZC,IAAAA,cAAM,EAACC,IAAAA,cAAI,GAACF,iBAAAA,IAAIG,SAAS,cAAbH,4BAAAA,iBAAiBA,IAAII,OAAO,EAAEC,kBAAS,GAAG;QAAEC,WAAW;QAAMC,OAAO;IAAK;AACvF"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/cache.ts"],"sourcesContent":["import { rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { STATE_DIR } from '../config/index.ts';\n\n// Deletes the cache directory and nothing else: the next open() reconciles anyway. Engine-neutral,\n// since every store keeps its files under the same STATE_DIR.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.configDir ?? cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["clearCache","cfg","rmSync","join","configDir","baseDir","STATE_DIR","recursive","force"],"mappings":";;;;+BAOgBA;;;eAAAA;;;sBAPO;wBACF;uBAEK;AAInB,SAASA,WAAWC,GAAmB;QAChCA;IAAZC,IAAAA,cAAM,EAACC,IAAAA,cAAI,GAACF,iBAAAA,IAAIG,SAAS,cAAbH,4BAAAA,iBAAiBA,IAAII,OAAO,EAAEC,kBAAS,GAAG;QAAEC,WAAW;QAAMC,OAAO;IAAK;AACvF"}

package/dist/cjs/store/duckdb/batch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/batch.ts"],"sourcesContent":["// Rewrites the store's single-row parameterized INSERT/UPDATE/DELETE into one multi-row statement --\n// DuckDB's columnar engine pays for row-at-a-time writes, not just the round trip (PRINCIPLES: documented-means-tested).\n// rewriteInsert itself lives in the shared ../batch.ts: turso folds INSERTs the same way (3.36 B).\n\nimport { rewriteInsert } from '../batch.ts';\n\nconst UPDATE_RE = /^UPDATE\\s+(\\S+)\\s+SET\\s+(.+?)\\s+WHERE\\s+(.+)$/is;\nconst DELETE_RE = /^DELETE\\s+FROM\\s+(\\S+)\\s+WHERE\\s+(.+)$/is;\n\n// \"a = ?, b = ?\" or \"a = ? AND b = ?\" -> [\"a\", \"b\"]. A clause that doesn't fit yields a shorter\n// list, which rewriteUpdate/rewriteDelete reject as a width mismatch.\nfunction equalityColumns(clause: string, sep: RegExp): string[] | null {\n  const parts = clause.split(sep).map((p) => p.trim());\n  const cols: string[] = [];\n  for (const part of parts) {\n    const m = /^(.+?)=\\s*\\?$/.exec(part);\n    if (!m) return null;\n    cols.push(m[1].trim());\n  }\n  return cols;\n}\n\nfunction tuples(rowCount: number, width: number): string {\n  const row = `(${Array.from({ length: width }, () => '?').join(', ')})`;\n  return Array.from({ length: rowCount }, () => row).join(', ');\n}\n\nexport function rewriteUpdate(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = UPDATE_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, table, setClause, whereClause] = m;\n  const setCols = equalityColumns(setClause, /,/);\n  const whereCols = equalityColumns(whereClause, /\\bAND\\b/i);\n  if (!setCols || !whereCols) return null;\n  const dataCols = [...setCols, ...whereCols];\n  const setAssign = setCols.map((c) => `${c} = data.${c}`).join(', ');\n  const joinCond = whereCols.map((c) => `${table}.${c} = data.${c}`).join(' AND ');\n  return { sql: `UPDATE ${table} SET ${setAssign} FROM (VALUES ${tuples(rowCount, dataCols.length)}) AS data(${dataCols.join(', ')}) WHERE ${joinCond}`, width: dataCols.length };\n}\n\nexport function rewriteDelete(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = DELETE_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, table, whereClause] = m;\n  const cols = equalityColumns(whereClause, /\\bAND\\b/i);\n  if (!cols) return null;\n  if (cols.length === 1) {\n    return { sql: `DELETE FROM ${table} WHERE ${cols[0]} IN (${Array.from({ length: rowCount }, () => '?').join(', ')})`, width: 1 };\n  }\n  return { sql: `DELETE FROM ${table} WHERE (${cols.join(', ')}) IN (VALUES ${tuples(rowCount, cols.length)})`, width: cols.length };\n}\n\n// Tries each shape in turn; null means the caller should fall back to a per-row loop.\nexport function rewriteBatch(sql: string, rowCount: number): { sql: string; width: number } | null {\n  return rewriteInsert(sql, rowCount) ?? rewriteUpdate(sql, rowCount) ?? rewriteDelete(sql, rowCount);\n}\n"],"names":["rewriteBatch","rewriteDelete","rewriteUpdate","UPDATE_RE","DELETE_RE","equalityColumns","clause","sep","parts","split","map","p","trim","cols","part","m","exec","push","tuples","rowCount","width","row","Array","from","length","join","sql","table","setClause","whereClause","setCols","whereCols","dataCols","setAssign","c","joinCond","rewriteInsert"],"mappings":"AAAA,qGAAqG;AACrG,yHAAyH;AACzH,mGAAmG;;;;;;;;;;;;QAmDnFA;eAAAA;;QAbAC;eAAAA;;QAbAC;eAAAA;;;uBAvBc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9B,IAAMC,YAAY;AAClB,IAAMC,YAAY;AAElB,gGAAgG;AAChG,sEAAsE;AACtE,SAASC,gBAAgBC,MAAc,EAAEC,GAAW;IAClD,IAAMC,QAAQF,OAAOG,KAAK,CAACF,KAAKG,GAAG,CAAC,SAACC;eAAMA,EAAEC,IAAI;;IACjD,IAAMC,OAAiB,EAAE;QACpB,kCAAA,2BAAA;;QAAL,QAAK,YAAcL,0BAAd,SAAA,6BAAA,QAAA,yBAAA,iCAAqB;YAArB,IAAMM,OAAN;YACH,IAAMC,IAAI,gBAAgBC,IAAI,CAACF;YAC/B,IAAI,CAACC,GAAG,OAAO;YACfF,KAAKI,IAAI,CAACF,CAAC,CAAC,EAAE,CAACH,IAAI;QACrB;;QAJK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAKL,OAAOC;AACT;AAEA,SAASK,OAAOC,QAAgB,EAAEC,KAAa;IAC7C,IAAMC,MAAM,AAAC,IAAuD,OAApDC,MAAMC,IAAI,CAAC;QAAEC,QAAQJ;IAAM,GAAG;eAAM;OAAKK,IAAI,CAAC,OAAM;IACpE,OAAOH,MAAMC,IAAI,CAAC;QAAEC,QAAQL;IAAS,GAAG;eAAME;OAAKI,IAAI,CAAC;AAC1D;AAEO,SAASvB,cAAcwB,GAAW,EAAEP,QAAgB;IACzD,IAAMJ,IAAIZ,UAAUa,IAAI,CAACU,IAAId,IAAI;IACjC,IAAI,CAACG,GAAG,OAAO;IACf,IAA0CA,sBAAAA,OAAjCY,QAAiCZ,OAA1Ba,YAA0Bb,OAAfc,cAAed;IAC1C,IAAMe,UAAUzB,gBAAgBuB,WAAW;IAC3C,IAAMG,YAAY1B,gBAAgBwB,aAAa;IAC/C,IAAI,CAACC,WAAW,CAACC,WAAW,OAAO;IACnC,IAAMC,WAAW,AAAC,qBAAGF,gBAAS,qBAAGC;IACjC,IAAME,YAAYH,QAAQpB,GAAG,CAAC,SAACwB;eAAM,AAAC,GAAcA,OAAZA,GAAE,YAAY,OAAFA;OAAKT,IAAI,CAAC;IAC9D,IAAMU,WAAWJ,UAAUrB,GAAG,CAAC,SAACwB;eAAM,AAAC,GAAWA,OAATP,OAAM,KAAeO,OAAZA,GAAE,YAAY,OAAFA;OAAKT,IAAI,CAAC;IACxE,OAAO;QAAEC,KAAK,AAAC,UAAsBO,OAAbN,OAAM,SAAiCT,OAA1Be,WAAU,kBAA8DD,OAA9Cd,OAAOC,UAAUa,SAASR,MAAM,GAAE,cAA0CW,OAA9BH,SAASP,IAAI,CAAC,OAAM,YAAmB,OAATU;QAAYf,OAAOY,SAASR,MAAM;IAAC;AAChL;AAEO,SAASvB,cAAcyB,GAAW,EAAEP,QAAgB;IACzD,IAAMJ,IAAIX,UAAUY,IAAI,CAACU,IAAId,IAAI;IACjC,IAAI,CAACG,GAAG,OAAO;IACf,IAA+BA,sBAAAA,OAAtBY,QAAsBZ,OAAfc,cAAed;IAC/B,IAAMF,OAAOR,gBAAgBwB,aAAa;IAC1C,IAAI,CAAChB,MAAM,OAAO;IAClB,IAAIA,KAAKW,MAAM,KAAK,GAAG;QACrB,OAAO;YAAEE,KAAK,AAAC,eAA6Bb,OAAfc,OAAM,WAAwBL,OAAfT,IAAI,CAAC,EAAE,EAAC,SAA8D,OAAvDS,MAAMC,IAAI,CAAC;gBAAEC,QAAQL;YAAS,GAAG;uBAAM;eAAKM,IAAI,CAAC,OAAM;YAAIL,OAAO;QAAE;IACjI;IACA,OAAO;QAAEM,KAAK,AAAC,eAA8Bb,OAAhBc,OAAM,YAAyCT,OAA/BL,KAAKY,IAAI,CAAC,OAAM,iBAA6C,OAA9BP,OAAOC,UAAUN,KAAKW,MAAM,GAAE;QAAIJ,OAAOP,KAAKW,MAAM;IAAC;AACnI;AAGO,SAASxB,aAAa0B,GAAW,EAAEP,QAAgB;QACjDiB,MAAAA;IAAP,QAAOA,QAAAA,iBAAAA,IAAAA,sBAAa,EAACV,KAAKP,uBAAnBiB,4BAAAA,iBAAgClC,cAAcwB,KAAKP,uBAAnDiB,kBAAAA,OAAgEnC,cAAcyB,KAAKP;AAC5F"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/duckdb/batch.ts"],"sourcesContent":["// Rewrites the store's single-row parameterized INSERT/UPDATE/DELETE into one multi-row statement --\n// DuckDB's columnar engine pays for row-at-a-time writes, not just the round trip (PRINCIPLES: documented-means-tested).\n// rewriteInsert itself lives in the shared ../batch.ts: turso folds INSERTs the same way (3.36 B).\n\nimport { rewriteInsert } from '../batch.ts';\n\nconst UPDATE_RE = /^UPDATE\\s+(\\S+)\\s+SET\\s+(.+?)\\s+WHERE\\s+(.+)$/is;\nconst DELETE_RE = /^DELETE\\s+FROM\\s+(\\S+)\\s+WHERE\\s+(.+)$/is;\n\n// \"a = ?, b = ?\" or \"a = ? AND b = ?\" -> [\"a\", \"b\"]. A clause that doesn't fit yields a shorter\n// list, which rewriteUpdate/rewriteDelete reject as a width mismatch.\nfunction equalityColumns(clause: string, sep: RegExp): string[] | null {\n  const parts = clause.split(sep).map((p) => p.trim());\n  const cols: string[] = [];\n  for (const part of parts) {\n    const m = /^(.+?)=\\s*\\?$/.exec(part);\n    if (!m) return null;\n    cols.push(m[1].trim());\n  }\n  return cols;\n}\n\nfunction tuples(rowCount: number, width: number): string {\n  const row = `(${Array.from({ length: width }, () => '?').join(', ')})`;\n  return Array.from({ length: rowCount }, () => row).join(', ');\n}\n\nexport function rewriteUpdate(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = UPDATE_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, table, setClause, whereClause] = m;\n  const setCols = equalityColumns(setClause, /,/);\n  const whereCols = equalityColumns(whereClause, /\\bAND\\b/i);\n  if (!setCols || !whereCols) return null;\n  const dataCols = [...setCols, ...whereCols];\n  const setAssign = setCols.map((c) => `${c} = data.${c}`).join(', ');\n  const joinCond = whereCols.map((c) => `${table}.${c} = data.${c}`).join(' AND ');\n  return { sql: `UPDATE ${table} SET ${setAssign} FROM (VALUES ${tuples(rowCount, dataCols.length)}) AS data(${dataCols.join(', ')}) WHERE ${joinCond}`, width: dataCols.length };\n}\n\nexport function rewriteDelete(sql: string, rowCount: number): { sql: string; width: number } | null {\n  const m = DELETE_RE.exec(sql.trim());\n  if (!m) return null;\n  const [, table, whereClause] = m;\n  const cols = equalityColumns(whereClause, /\\bAND\\b/i);\n  if (!cols) return null;\n  if (cols.length === 1) {\n    return { sql: `DELETE FROM ${table} WHERE ${cols[0]} IN (${Array.from({ length: rowCount }, () => '?').join(', ')})`, width: 1 };\n  }\n  return { sql: `DELETE FROM ${table} WHERE (${cols.join(', ')}) IN (VALUES ${tuples(rowCount, cols.length)})`, width: cols.length };\n}\n\n// Tries each shape in turn; null means the caller should fall back to a per-row loop.\nexport function rewriteBatch(sql: string, rowCount: number): { sql: string; width: number } | null {\n  return rewriteInsert(sql, rowCount) ?? rewriteUpdate(sql, rowCount) ?? rewriteDelete(sql, rowCount);\n}\n"],"names":["rewriteBatch","rewriteDelete","rewriteUpdate","UPDATE_RE","DELETE_RE","equalityColumns","clause","sep","parts","split","map","p","trim","cols","part","m","exec","push","tuples","rowCount","width","row","Array","from","length","join","sql","table","setClause","whereClause","setCols","whereCols","dataCols","setAssign","c","joinCond","rewriteInsert"],"mappings":"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"}

package/dist/cjs/store/duckdb/connection.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/connection.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBPreparedStatement, DuckDBValue } from '@duckdb/node-api';\nimport { quoteIdent } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { rewriteBatch } from './batch.ts';\nimport { duckdbApi } from './native.ts';\n\n// getRowObjectsJS returns INT64 columns as BigInt regardless of magnitude, while sqlite's small\n// ints are numbers and consumers assume number; in-range values convert here, out-of-range stays BigInt.\nconst MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);\nexport function storeValueToJs(value: unknown): unknown {\n  return typeof value === 'bigint' && value >= -MAX_SAFE && value <= MAX_SAFE ? Number(value) : value;\n}\nexport function storeRowToJs(row: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(row)) out[key] = storeValueToJs(value);\n  return out;\n}\n\n// @duckdb/node-api only destroys a prepared statement when its connection closes, but a connection can stay open for a whole `sense watch` session.\n// Statement has no dispose (callers reuse one instance across several calls), so this FinalizationRegistry reclaims it once nothing references the wrapper.\nconst preparedFinalizer = new FinalizationRegistry<DuckDBPreparedStatement>((prepared) => {\n  prepared.destroySync();\n});\n\n// Wraps one already-prepared DuckDB statement: prepare() is the only async step, so run/get/all rebind and\n// re-execute the same native statement, matching how callers like graph/traverse.ts's ring loop reuse one Statement across several calls.\nclass DuckdbStatement implements Statement {\n  private prepared: DuckDBPreparedStatement;\n\n  constructor(prepared: DuckDBPreparedStatement) {\n    this.prepared = prepared;\n    preparedFinalizer.register(this, prepared);\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    if (params.length > 0) this.prepared.bind(params as DuckDBValue[]);\n    const result = await this.prepared.run();\n    return { changes: result.rowsChanged, lastInsertRowid: 0 };\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    const rows = await this.all(...params);\n    return rows[0];\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    if (params.length > 0) this.prepared.bind(params as DuckDBValue[]);\n    const reader = await this.prepared.runAndReadAll();\n    return (reader.getRowObjectsJS() as Array<Record<string, unknown>>).map(storeRowToJs);\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    // Never called on the portable Connection/Statement surface today (only Store.raw streams);\n    // materializing keeps this a correct, if eager, AsyncIterable.\n    yield* await this.all(...params);\n  }\n\n  columns(): Array<{ name: string }> {\n    const out: Array<{ name: string }> = [];\n    for (let i = 0; i < this.prepared.columnCount; i++) out.push({ name: this.prepared.columnName(i) });\n    return out;\n  }\n\n  setReadBigInts(_enabled: boolean): void {\n    // No-op: in-range ints are already numbers here (storeRowToJs converts what getRowObjectsJS\n    // hands back as BigInt), so the node:sqlite throw-at-step-time problem does not exist.\n  }\n}\n\n// Adds the native DuckDBConnection to the portable Connection, so duckdb's own dialect code\n// (reconcile.ts's insertNew) can reach createAppender(); sqlite/turso have no such member.\nexport interface DuckdbConnection extends Connection {\n  readonly duckdb: DuckDBConnection;\n}\n\nexport function createConnection(duckdb: DuckDBConnection): DuckdbConnection {\n  const conn: DuckdbConnection = {\n    duckdb,\n    async exec(sql: string): Promise<void> {\n      await duckdb.run(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new DuckdbStatement(await duckdb.prepare(sql));\n    },\n    // The appender writes columnar vectors with no per-parameter binding, which is the cost\n    // runBatch pays: measured 7.2x on frontmatter at 6,566 rows. Alignment is against the table's\n    // own physical column order, read fresh, so a column the caller does not write (a\n    // feature-owned \"_rank\", say) takes appendDefault() rather than shifting every value one slot.\n    async appendRows(table: string, columns: string[], rows: unknown[][]): Promise<void> {\n      if (rows.length === 0) return;\n      const { variantValue } = await duckdbApi();\n      const infoStmt = await conn.prepare(`PRAGMA table_info(${quoteIdent(table)})`);\n      const physical = (await infoStmt.all()) as Array<{ name: string; type: string }>;\n      const rowIndexOf = new Map(columns.map((name, i) => [name, i]));\n\n      await withTransaction(conn, async () => {\n        const appender = await duckdb.createAppender(table);\n        const errors: unknown[] = [];\n        try {\n          for (const row of rows) {\n            for (const column of physical) {\n              const idx = rowIndexOf.get(column.name);\n              const value = idx === undefined ? undefined : row[idx];\n              if (idx === undefined) appender.appendDefault();\n              else if (value === null || value === undefined) appender.appendNull();\n              // VARIANT is frontmatter's dynamic columns only; every other table is statically\n              // typed, and appendValue is what preserves those types.\n              else if (column.type === 'VARIANT') appender.appendVariant(variantValue(value as DuckDBValue));\n              else appender.appendValue(value as DuckDBValue);\n            }\n            appender.endRow();\n          }\n          appender.flushSync();\n        } catch (err) {\n          errors.push(err);\n        }\n        try {\n          appender.closeSync();\n        } catch (err) {\n          errors.push(err);\n        }\n        if (errors.length === 1) throw errors[0];\n        if (errors.length > 1) throw new AggregateError(errors, errors[0] instanceof Error ? `${errors[0].message}; appender cleanup also failed` : 'DuckDB appender execution and cleanup failed');\n      });\n    },\n    // One crossing regardless of row count: rewriteBatch folds recognized shapes into a multi-row statement (batch.ts),\n    // else falls back to a bind-and-run loop, one call either way. Joins the caller's transaction when there is one, else opens its own.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(conn, async () => {\n        const rewritten = rewriteBatch(sql, paramRows.length);\n        if (rewritten) {\n          const stmt = await duckdb.prepare(rewritten.sql);\n          try {\n            stmt.bind(paramRows.flat() as DuckDBValue[]);\n            await stmt.run();\n          } finally {\n            stmt.destroySync();\n          }\n          return;\n        }\n        const stmt = await duckdb.prepare(sql);\n        try {\n          for (const row of paramRows) {\n            stmt.bind(row as DuckDBValue[]);\n            await stmt.run();\n          }\n        } finally {\n          stmt.destroySync();\n        }\n      });\n    },\n  };\n  return conn;\n}\n"],"names":["createConnection","storeRowToJs","storeValueToJs","MAX_SAFE","BigInt","Number","MAX_SAFE_INTEGER","value","row","out","Object","entries","key","preparedFinalizer","FinalizationRegistry","prepared","destroySync","DuckdbStatement","register","run","params","result","length","bind","changes","rowsChanged","lastInsertRowid","get","rows","all","reader","runAndReadAll","getRowObjectsJS","map","iterate","columns","i","columnCount","push","name","columnName","setReadBigInts","_enabled","duckdb","conn","exec","sql","prepare","appendRows","table","variantValue","infoStmt","physical","rowIndexOf","duckdbApi","quoteIdent","Map","withTransaction","appender","errors","column","idx","createAppender","undefined","appendDefault","appendNull","type","appendVariant","appendValue","endRow","flushSync","err","closeSync","AggregateError","Error","message","runBatch","paramRows","rewritten","stmt","rewriteBatch","flat"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/duckdb/connection.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBPreparedStatement, DuckDBValue } from '@duckdb/node-api';\nimport { quoteIdent } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { rewriteBatch } from './batch.ts';\nimport { duckdbApi } from './native.ts';\n\n// getRowObjectsJS returns INT64 columns as BigInt regardless of magnitude, while sqlite's small\n// ints are numbers and consumers assume number; in-range values convert here, out-of-range stays BigInt.\nconst MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);\nexport function storeValueToJs(value: unknown): unknown {\n  return typeof value === 'bigint' && value >= -MAX_SAFE && value <= MAX_SAFE ? Number(value) : value;\n}\nexport function storeRowToJs(row: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(row)) out[key] = storeValueToJs(value);\n  return out;\n}\n\n// @duckdb/node-api only destroys a prepared statement when its connection closes, but a connection can stay open for a whole `sense watch` session.\n// Statement has no dispose (callers reuse one instance across several calls), so this FinalizationRegistry reclaims it once nothing references the wrapper.\nconst preparedFinalizer = new FinalizationRegistry<DuckDBPreparedStatement>((prepared) => {\n  prepared.destroySync();\n});\n\n// Wraps one already-prepared DuckDB statement: prepare() is the only async step, so run/get/all rebind and\n// re-execute the same native statement, matching how callers like graph/traverse.ts's ring loop reuse one Statement across several calls.\nclass DuckdbStatement implements Statement {\n  private prepared: DuckDBPreparedStatement;\n\n  constructor(prepared: DuckDBPreparedStatement) {\n    this.prepared = prepared;\n    preparedFinalizer.register(this, prepared);\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    if (params.length > 0) this.prepared.bind(params as DuckDBValue[]);\n    const result = await this.prepared.run();\n    return { changes: result.rowsChanged, lastInsertRowid: 0 };\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    const rows = await this.all(...params);\n    return rows[0];\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    if (params.length > 0) this.prepared.bind(params as DuckDBValue[]);\n    const reader = await this.prepared.runAndReadAll();\n    return (reader.getRowObjectsJS() as Array<Record<string, unknown>>).map(storeRowToJs);\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    // Never called on the portable Connection/Statement surface today (only Store.raw streams);\n    // materializing keeps this a correct, if eager, AsyncIterable.\n    yield* await this.all(...params);\n  }\n\n  columns(): Array<{ name: string }> {\n    const out: Array<{ name: string }> = [];\n    for (let i = 0; i < this.prepared.columnCount; i++) out.push({ name: this.prepared.columnName(i) });\n    return out;\n  }\n\n  setReadBigInts(_enabled: boolean): void {\n    // No-op: in-range ints are already numbers here (storeRowToJs converts what getRowObjectsJS\n    // hands back as BigInt), so the node:sqlite throw-at-step-time problem does not exist.\n  }\n}\n\n// Adds the native DuckDBConnection to the portable Connection, so duckdb's own dialect code\n// (reconcile.ts's insertNew) can reach createAppender(); sqlite/turso have no such member.\nexport interface DuckdbConnection extends Connection {\n  readonly duckdb: DuckDBConnection;\n}\n\nexport function createConnection(duckdb: DuckDBConnection): DuckdbConnection {\n  const conn: DuckdbConnection = {\n    duckdb,\n    async exec(sql: string): Promise<void> {\n      await duckdb.run(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new DuckdbStatement(await duckdb.prepare(sql));\n    },\n    // The appender writes columnar vectors with no per-parameter binding, which is the cost\n    // runBatch pays: measured 7.2x on frontmatter at 6,566 rows. Alignment is against the table's\n    // own physical column order, read fresh, so a column the caller does not write (a\n    // feature-owned \"_rank\", say) takes appendDefault() rather than shifting every value one slot.\n    async appendRows(table: string, columns: string[], rows: unknown[][]): Promise<void> {\n      if (rows.length === 0) return;\n      const { variantValue } = await duckdbApi();\n      const infoStmt = await conn.prepare(`PRAGMA table_info(${quoteIdent(table)})`);\n      const physical = (await infoStmt.all()) as Array<{ name: string; type: string }>;\n      const rowIndexOf = new Map(columns.map((name, i) => [name, i]));\n\n      await withTransaction(conn, async () => {\n        const appender = await duckdb.createAppender(table);\n        const errors: unknown[] = [];\n        try {\n          for (const row of rows) {\n            for (const column of physical) {\n              const idx = rowIndexOf.get(column.name);\n              const value = idx === undefined ? undefined : row[idx];\n              if (idx === undefined) appender.appendDefault();\n              else if (value === null || value === undefined) appender.appendNull();\n              // VARIANT is frontmatter's dynamic columns only; every other table is statically\n              // typed, and appendValue is what preserves those types.\n              else if (column.type === 'VARIANT') appender.appendVariant(variantValue(value as DuckDBValue));\n              else appender.appendValue(value as DuckDBValue);\n            }\n            appender.endRow();\n          }\n          appender.flushSync();\n        } catch (err) {\n          errors.push(err);\n        }\n        try {\n          appender.closeSync();\n        } catch (err) {\n          errors.push(err);\n        }\n        if (errors.length === 1) throw errors[0];\n        if (errors.length > 1) throw new AggregateError(errors, errors[0] instanceof Error ? `${errors[0].message}; appender cleanup also failed` : 'DuckDB appender execution and cleanup failed');\n      });\n    },\n    // One crossing regardless of row count: rewriteBatch folds recognized shapes into a multi-row statement (batch.ts),\n    // else falls back to a bind-and-run loop, one call either way. Joins the caller's transaction when there is one, else opens its own.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(conn, async () => {\n        const rewritten = rewriteBatch(sql, paramRows.length);\n        if (rewritten) {\n          const stmt = await duckdb.prepare(rewritten.sql);\n          try {\n            stmt.bind(paramRows.flat() as DuckDBValue[]);\n            await stmt.run();\n          } finally {\n            stmt.destroySync();\n          }\n          return;\n        }\n        const stmt = await duckdb.prepare(sql);\n        try {\n          for (const row of paramRows) {\n            stmt.bind(row as DuckDBValue[]);\n            await stmt.run();\n          }\n        } finally {\n          stmt.destroySync();\n        }\n      });\n    },\n  };\n  return conn;\n}\n"],"names":["createConnection","storeRowToJs","storeValueToJs","MAX_SAFE","BigInt","Number","MAX_SAFE_INTEGER","value","row","out","Object","entries","key","preparedFinalizer","FinalizationRegistry","prepared","destroySync","DuckdbStatement","register","run","params","result","length","bind","changes","rowsChanged","lastInsertRowid","get","rows","all","reader","runAndReadAll","getRowObjectsJS","map","iterate","columns","i","columnCount","push","name","columnName","setReadBigInts","_enabled","duckdb","conn","exec","sql","prepare","appendRows","table","variantValue","infoStmt","physical","rowIndexOf","duckdbApi","quoteIdent","Map","withTransaction","appender","errors","column","idx","createAppender","undefined","appendDefault","appendNull","type","appendVariant","appendValue","endRow","flushSync","err","closeSync","AggregateError","Error","message","runBatch","paramRows","rewritten","stmt","rewriteBatch","flat"],"mappings":"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"}

package/dist/cjs/store/duckdb/fieldStats.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/fieldStats.ts"],"sourcesContent":["import { quoteIdent } from '../shared.ts';\nimport type { Connection, FieldStat } from '../types.ts';\n\n// DuckDB's frontmatter columns are VARIANT (reconcile.ts), so typeof() always reports VARIANT; variant_typeof() reports the boxed native\n// type instead -- INT128, DOUBLE, VARCHAR, or a literal's narrower type like DECIMAL(p, s) -- mapped onto sqlite/turso's integer/real/text vocabulary; an unrecognized name throws (no-silent-modes).\nfunction classifyVariantType(name: string, field: string): 'integer' | 'real' | 'text' {\n  if (/^U?INT\\d+$/.test(name)) return 'integer';\n  if (name === 'FLOAT' || name === 'DOUBLE' || name.startsWith('DECIMAL(')) return 'real';\n  if (name === 'VARCHAR') return 'text';\n  throw new Error(`duckdb: variant_typeof() returned unrecognized type \"${name}\" for column \"${field}\"`);\n}\n\n// duckdb degrades superlinearly in the number of string_agg(DISTINCT variant_typeof()) aggregates\n// per projection, not the column width (301 columns: 1148ms unchunked vs 88ms at chunk size 25);\n// 16 sits inside the measured flat 10-25 range. sqlite/turso need none of this: GROUP_CONCAT over\n// 300 columns runs in 7ms.\nconst AGGREGATES_PER_QUERY = 16;\n\n// COUNT + string_agg(DISTINCT variant_typeof()) per column keeps this O(columns), not O(rows x columns).\n// '|' is the separator, not ',': DECIMAL's display name (\"DECIMAL(4, 2)\") contains a comma.\nexport async function fieldStats(conn: Connection, columns: string[], scopeWhere: string): Promise<FieldStat[]> {\n  const stats: FieldStat[] = [];\n  for (let start = 0; start < columns.length; start += AGGREGATES_PER_QUERY) {\n    const chunk = columns.slice(start, start + AGGREGATES_PER_QUERY);\n    const exprs = chunk.map((name, i) => {\n      const quoted = quoteIdent(name);\n      return `COUNT(${quoted}) AS n${i}, string_agg(DISTINCT variant_typeof(${quoted}), '|') FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n    });\n    const stmt = await conn.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`);\n    const row = (await stmt.get()) as Record<string, number | string | null>;\n    for (const [i, name] of chunk.entries()) {\n      const raw = ((row[`t${i}`] as string) ?? '').split('|').filter(Boolean);\n      const types = [...new Set(raw.map((t) => classifyVariantType(t, name)))].sort();\n      stats.push({ field: name, coverage: Number(row[`n${i}`] ?? 0), type: types.join(',') });\n    }\n  }\n  return stats;\n}\n"],"names":["fieldStats","classifyVariantType","name","field","test","startsWith","Error","AGGREGATES_PER_QUERY","conn","columns","scopeWhere","stats","start","chunk","exprs","stmt","row","length","slice","map","i","quoted","quoteIdent","prepare","join","get","raw","split","filter","Boolean","types","Set","t","sort","push","coverage","Number","type","entries"],"mappings":";;;;+BAoBsBA;;;eAAAA;;;wBApBK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG3B,yIAAyI;AACzI,sMAAsM;AACtM,SAASC,oBAAoBC,IAAY,EAAEC,KAAa;IACtD,IAAI,aAAaC,IAAI,CAACF,OAAO,OAAO;IACpC,IAAIA,SAAS,WAAWA,SAAS,YAAYA,KAAKG,UAAU,CAAC,aAAa,OAAO;IACjF,IAAIH,SAAS,WAAW,OAAO;IAC/B,MAAM,IAAII,MAAM,AAAC,wDAA4EH,OAArBD,MAAK,kBAAsB,OAANC,OAAM;AACrG;AAEA,kGAAkG;AAClG,iGAAiG;AACjG,kGAAkG;AAClG,2BAA2B;AAC3B,IAAMI,uBAAuB;AAItB,SAAeP,WAAWQ,IAAgB,EAAEC,OAAiB,EAAEC,UAAkB;;YAChFC,OACGC,OACDC,OACAC,OAIAC,MACAC,KACD,2BAAA,mBAAA,uBAAA,WAAA;;;;oBATDL;oBACGC,QAAQ;;;yBAAGA,CAAAA,QAAQH,QAAQQ,MAAM,AAAD;;;;oBACjCJ,QAAQJ,QAAQS,KAAK,CAACN,OAAOA,QAAQL;oBACrCO,QAAQD,MAAMM,GAAG,CAAC,SAACjB,MAAMkB;wBAC7B,IAAMC,SAASC,IAAAA,oBAAU,EAACpB;wBAC1B,OAAO,AAAC,SAAuBkB,OAAfC,QAAO,UAAiDA,OAAzCD,GAAE,yCAAsEC,OAA/BA,QAAO,0BAAmDD,OAA3BC,QAAO,sBAAsB,OAAFD;oBACpI;oBACa;;wBAAMZ,KAAKe,OAAO,CAAC,AAAC,UAA8Cb,OAArCI,MAAMU,IAAI,CAAC,OAAM,sBAA+B,OAAXd;;;oBAAzEK,OAAO;oBACA;;wBAAMA,KAAKU,GAAG;;;oBAArBT,MAAO;oBACR,kCAAA,2BAAA;;;4BAAA,mCAAA,iBAAOI,oBAAGlB;gCACCc,OAE6BA;4BAF3C,IAAMU,MAAM,EAAEV,QAAAA,GAAG,CAAC,AAAC,IAAK,OAAFI,GAAI,cAAZJ,mBAAAA,QAA2B,IAAIW,KAAK,CAAC,KAAKC,MAAM,CAACC;4BAC/D,IAAMC,QAAQ,AAAC,qBAAG,IAAIC,IAAIL,IAAIP,GAAG,CAAC,SAACa;uCAAM/B,oBAAoB+B,GAAG9B;iCAAS+B,IAAI;4BAC7EtB,MAAMuB,IAAI,CAAC;gCAAE/B,OAAOD;gCAAMiC,UAAUC,QAAOpB,SAAAA,GAAG,CAAC,AAAC,IAAK,OAAFI,GAAI,cAAZJ,oBAAAA,SAAgB;gCAAIqB,MAAMP,MAAMN,IAAI,CAAC;4BAAK;wBACvF;wBAJA,IAAK,YAAmBX,MAAMyB,OAAO,yBAAhC,6BAAA,QAAA,yBAAA;;wBAAA;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;;;oBARqC1B,SAASL;;;;;;oBAcrD;;wBAAOI;;;;IACT"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/duckdb/fieldStats.ts"],"sourcesContent":["import { quoteIdent } from '../shared.ts';\nimport type { Connection, FieldStat } from '../types.ts';\n\n// DuckDB's frontmatter columns are VARIANT (reconcile.ts), so typeof() always reports VARIANT; variant_typeof() reports the boxed native\n// type instead -- INT128, DOUBLE, VARCHAR, or a literal's narrower type like DECIMAL(p, s) -- mapped onto sqlite/turso's integer/real/text vocabulary; an unrecognized name throws (no-silent-modes).\nfunction classifyVariantType(name: string, field: string): 'integer' | 'real' | 'text' {\n  if (/^U?INT\\d+$/.test(name)) return 'integer';\n  if (name === 'FLOAT' || name === 'DOUBLE' || name.startsWith('DECIMAL(')) return 'real';\n  if (name === 'VARCHAR') return 'text';\n  throw new Error(`duckdb: variant_typeof() returned unrecognized type \"${name}\" for column \"${field}\"`);\n}\n\n// duckdb degrades superlinearly in the number of string_agg(DISTINCT variant_typeof()) aggregates\n// per projection, not the column width (301 columns: 1148ms unchunked vs 88ms at chunk size 25);\n// 16 sits inside the measured flat 10-25 range. sqlite/turso need none of this: GROUP_CONCAT over\n// 300 columns runs in 7ms.\nconst AGGREGATES_PER_QUERY = 16;\n\n// COUNT + string_agg(DISTINCT variant_typeof()) per column keeps this O(columns), not O(rows x columns).\n// '|' is the separator, not ',': DECIMAL's display name (\"DECIMAL(4, 2)\") contains a comma.\nexport async function fieldStats(conn: Connection, columns: string[], scopeWhere: string): Promise<FieldStat[]> {\n  const stats: FieldStat[] = [];\n  for (let start = 0; start < columns.length; start += AGGREGATES_PER_QUERY) {\n    const chunk = columns.slice(start, start + AGGREGATES_PER_QUERY);\n    const exprs = chunk.map((name, i) => {\n      const quoted = quoteIdent(name);\n      return `COUNT(${quoted}) AS n${i}, string_agg(DISTINCT variant_typeof(${quoted}), '|') FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n    });\n    const stmt = await conn.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`);\n    const row = (await stmt.get()) as Record<string, number | string | null>;\n    for (const [i, name] of chunk.entries()) {\n      const raw = ((row[`t${i}`] as string) ?? '').split('|').filter(Boolean);\n      const types = [...new Set(raw.map((t) => classifyVariantType(t, name)))].sort();\n      stats.push({ field: name, coverage: Number(row[`n${i}`] ?? 0), type: types.join(',') });\n    }\n  }\n  return stats;\n}\n"],"names":["fieldStats","classifyVariantType","name","field","test","startsWith","Error","AGGREGATES_PER_QUERY","conn","columns","scopeWhere","stats","start","chunk","exprs","stmt","row","length","slice","map","i","quoted","quoteIdent","prepare","join","get","raw","split","filter","Boolean","types","Set","t","sort","push","coverage","Number","type","entries"],"mappings":";;;;+BAoBsBA;;;eAAAA;;;wBApBK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG3B,yIAAyI;AACzI,sMAAsM;AACtM,SAASC,oBAAoBC,IAAY,EAAEC,KAAa;IACtD,IAAI,aAAaC,IAAI,CAACF,OAAO,OAAO;IACpC,IAAIA,SAAS,WAAWA,SAAS,YAAYA,KAAKG,UAAU,CAAC,aAAa,OAAO;IACjF,IAAIH,SAAS,WAAW,OAAO;IAC/B,MAAM,IAAII,MAAM,AAAC,wDAA4EH,OAArBD,MAAK,kBAAsB,OAANC,OAAM;AACrG;AAEA,kGAAkG;AAClG,iGAAiG;AACjG,kGAAkG;AAClG,2BAA2B;AAC3B,IAAMI,uBAAuB;AAItB,SAAeP,WAAWQ,IAAgB,EAAEC,OAAiB,EAAEC,UAAkB;;YAChFC,OACGC,OACDC,OACAC,OAIAC,MACAC,KACD,2BAAA,mBAAA,uBAAA,WAAA;;;;oBATDL;oBACGC,QAAQ;;;yBAAGA,CAAAA,QAAQH,QAAQQ,MAAM,AAAD;;;;oBACjCJ,QAAQJ,QAAQS,KAAK,CAACN,OAAOA,QAAQL;oBACrCO,QAAQD,MAAMM,GAAG,CAAC,SAACjB,MAAMkB;wBAC7B,IAAMC,SAASC,IAAAA,oBAAU,EAACpB;wBAC1B,OAAO,AAAC,SAAuBkB,OAAfC,QAAO,UAAiDA,OAAzCD,GAAE,yCAAsEC,OAA/BA,QAAO,0BAAmDD,OAA3BC,QAAO,sBAAsB,OAAFD;oBACpI;oBACa;;wBAAMZ,KAAKe,OAAO,CAAC,AAAC,UAA8Cb,OAArCI,MAAMU,IAAI,CAAC,OAAM,sBAA+B,OAAXd;;;oBAAzEK,OAAO;oBACA;;wBAAMA,KAAKU,GAAG;;;oBAArBT,MAAO;oBACR,kCAAA,2BAAA;;;4BAAA,mCAAA,iBAAOI,oBAAGlB;gCACCc,OAE6BA;4BAF3C,IAAMU,MAAM,EAAEV,QAAAA,GAAG,CAAC,AAAC,IAAK,OAAFI,GAAI,cAAZJ,mBAAAA,QAA2B,IAAIW,KAAK,CAAC,KAAKC,MAAM,CAACC;4BAC/D,IAAMC,QAAQ,AAAC,qBAAG,IAAIC,IAAIL,IAAIP,GAAG,CAAC,SAACa;uCAAM/B,oBAAoB+B,GAAG9B;iCAAS+B,IAAI;4BAC7EtB,MAAMuB,IAAI,CAAC;gCAAE/B,OAAOD;gCAAMiC,UAAUC,QAAOpB,SAAAA,GAAG,CAAC,AAAC,IAAK,OAAFI,GAAI,cAAZJ,oBAAAA,SAAgB;gCAAIqB,MAAMP,MAAMN,IAAI,CAAC;4BAAK;wBACvF;wBAJA,IAAK,YAAmBX,MAAMyB,OAAO,yBAAhC,6BAAA,QAAA,yBAAA;;wBAAA;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;;;oBARqC1B,SAASL;;;;;;oBAcrD;;wBAAOI;;;;IACT"}

package/dist/cjs/store/duckdb/lexical.d.cts

@@ -1,14 +1,9 @@
 import type { Connection, LexicalHit, LexicalQueryOptions } from '../types.js';
-interface FtsIndexState {
-    stale: boolean;
-    orderedMacroReady: boolean;
-}
 export declare function markContentStale(conn: Connection): Promise<void>;
 export declare function prepareFts(conn: Connection): Promise<void>;
 export declare function assertFtsReady(conn: Connection): Promise<void>;
-export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, state: FtsIndexState): Promise<LexicalHit[]>;
+export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions): Promise<LexicalHit[]>;
 export declare function createLexicalIndex(conn: Connection): {
     query: (terms: string, opts: LexicalQueryOptions) => Promise<LexicalHit[]>;
     markStale: () => Promise<void>;
 };
-export {};

package/dist/cjs/store/duckdb/lexical.d.ts

@@ -1,14 +1,9 @@
 import type { Connection, LexicalHit, LexicalQueryOptions } from '../types.js';
-interface FtsIndexState {
-    stale: boolean;
-    orderedMacroReady: boolean;
-}
 export declare function markContentStale(conn: Connection): Promise<void>;
 export declare function prepareFts(conn: Connection): Promise<void>;
 export declare function assertFtsReady(conn: Connection): Promise<void>;
-export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, state: FtsIndexState): Promise<LexicalHit[]>;
+export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions): Promise<LexicalHit[]>;
 export declare function createLexicalIndex(conn: Connection): {
     query: (terms: string, opts: LexicalQueryOptions) => Promise<LexicalHit[]>;
     markStale: () => Promise<void>;
 };
-export {};

package/dist/cjs/store/duckdb/lexical.js

@@ -283,7 +283,7 @@ function stateFor(conn) {
                 case 1:
                     // Anything but a persisted '0' (missing key, or '1') means a rebuild is owed: a cache that
                     // never built an index, or one a prior process marked stale and never got to clear.
-                    state = (_tmp.stale = _state.sent() !== '0', _tmp.orderedMacroReady = false, _tmp);
+                    state = (_tmp.stale = _state.sent() !== '0', _tmp);
                     ftsState.set(conn, state);
                     _state.label = 2;
                 case 2:
@@ -326,8 +326,7 @@ function markContentStale(conn) {
             switch(_state.label){
                 case 0:
                     ftsState.set(conn, {
-                        stale: true,
-                        orderedMacroReady: false
+                        stale: true
                     });
                     return [
                         4,
@@ -469,7 +468,6 @@ function rebuildFts(conn, state) {
                         2
                     ];
                     state.stale = true;
-                    state.orderedMacroReady = false;
                     return [
                         4,
                         (0, _transactionts.withTransaction)(conn, function() {
@@ -481,7 +479,7 @@ function rebuildFts(conn, state) {
                                             // default 571-word list would otherwise drop common words (e.g. "and") from the index but not match_bm25's conjunctive gate, breaking multi-word matches.
                                             return [
                                                 4,
-                                                conn.exec("PRAGMA create_fts_index('content', 'path', 'title', 'summary', 'text', stopwords='none', overwrite=1)")
+                                                conn.exec("PRAGMA create_fts_index('content', 'path', 'title', 'summary', 'text', stemmer='".concat(_orderedbm25ts.FTS_STEMMER, "', stopwords='none', overwrite=1)"))
                                             ];
                                         case 1:
                                             _state.sent();
@@ -593,19 +591,19 @@ function assertFtsReady(conn) {
 }
 // Field-weighted fragments (title 10 / summary 5 / text 1), with params emitted in the exact left-to-right order the assembled SQL needs for positional `?` binding.
 // score/gate params stay in separate arrays until joined at the end, since the SQL puts every score part before every gate part; sharing one array would shift binds once a query has both words and substrings (PRINCIPLES: no-silent-modes).
-function buildScoreAndGate(words, bareWords, phraseWords, substrings) {
+function buildScoreAndGate(words, nativeTerms, bareWords, phraseWords, substrings) {
     var scoreParts = [];
     var gateParts = [];
     var scoreParams = [];
     var gateParams = [];
     if (words.length > 0) {
-        var wordQuery = words.map(_segmentts.foldForSearch).join(' ');
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = FIELDS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var field = _step.value;
-                scoreParts.push("".concat(FIELD_WEIGHT[field], ".0 * COALESCE(").concat(_orderedbm25ts.ORDERED_BM25_MACRO, '(content."path", ?, fields := \'').concat(field, "', conjunctive := false), 0)"));
-                scoreParams.push(wordQuery);
+                var _scoreParams;
+                scoreParts.push("".concat(FIELD_WEIGHT[field], ".0 * COALESCE(").concat((0, _orderedbm25ts.orderedBm25Sql)(field, nativeTerms.length), ", 0)"));
+                (_scoreParams = scoreParams).push.apply(_scoreParams, _to_consumable_array(nativeTerms));
             }
         } catch (err) {
             _didIteratorError = true;
@@ -622,13 +620,13 @@ function buildScoreAndGate(words, bareWords, phraseWords, substrings) {
             }
         }
         if (bareWords.length > 0) {
-            var nativeGate = "".concat(_orderedbm25ts.ORDERED_BM25_MACRO, '(content."path", ?, conjunctive := true) IS NOT NULL');
+            var nativeGate = 'fts_main_content.match_bm25(content."path", ?, conjunctive := true) IS NOT NULL';
             gateParts.push(nativeGate);
             gateParams.push(bareWords.map(_segmentts.foldForSearch).join(' '));
         }
         if (phraseWords.length > 0) {
             var _gateParams;
-            var nativeGate1 = "".concat(_orderedbm25ts.ORDERED_BM25_MACRO, '(content."path", ?, conjunctive := true) IS NOT NULL');
+            var nativeGate1 = 'fts_main_content.match_bm25(content."path", ?, conjunctive := true) IS NOT NULL';
             var fallback = phraseWords.map(function(_word) {
                 return "(".concat(FIELDS.map(function(field) {
                     return "contains(strip_accents(lower(content.".concat(field, ")), ?)");
@@ -698,9 +696,9 @@ function buildScoreAndGate(words, bareWords, phraseWords, substrings) {
         params: _to_consumable_array(scoreParams).concat(_to_consumable_array(gateParams))
     };
 }
-function queryLexical(conn, terms, opts, state) {
+function queryLexical(conn, terms, opts) {
     return _async_to_generator(function() {
-        var _stmt, unsupported, whereJoin, whereCond, scopeCond, limit, _splitTerms, words, bareWords, phraseWords, substrings, phrases, emptyPhrase, _buildScoreAndGate, scoreSql, gateSql, params, selectFields, sqlLimit, sql, stmt, rows, matches;
+        var _stmt, unsupported, whereJoin, whereCond, scopeCond, limit, _splitTerms, words, bareWords, phraseWords, substrings, phrases, emptyPhrase, nativeTerms, _tmp, _buildScoreAndGate, scoreSql, gateSql, params, selectFields, sqlLimit, sql, stmt, rows, matches;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -732,13 +730,20 @@ function queryLexical(conn, terms, opts, state) {
                     ];
                     return [
                         4,
-                        (0, _orderedbm25ts.ensureOrderedBm25)(conn, state)
+                        (0, _orderedbm25ts.nativeQueryTerms)(conn, words.map(_segmentts.foldForSearch).join(' '))
                     ];
                 case 3:
-                    _state.sent();
-                    _state.label = 4;
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
                 case 4:
-                    _buildScoreAndGate = buildScoreAndGate(words, bareWords, phraseWords, substrings), scoreSql = _buildScoreAndGate.scoreSql, gateSql = _buildScoreAndGate.gateSql, params = _buildScoreAndGate.params;
+                    _tmp = [];
+                    _state.label = 5;
+                case 5:
+                    nativeTerms = _tmp;
+                    _buildScoreAndGate = buildScoreAndGate(words, nativeTerms, bareWords, phraseWords, substrings), scoreSql = _buildScoreAndGate.scoreSql, gateSql = _buildScoreAndGate.gateSql, params = _buildScoreAndGate.params;
                     selectFields = phrases.length > 0 ? ', content.title, content.summary, content.text' : '';
                     sqlLimit = phrases.length > 0 ? '' : ' LIMIT ?';
                     sql = "SELECT path, score".concat(phrases.length > 0 ? ', title, summary, text' : '', ' FROM (\n    SELECT content."path" AS path, (').concat(scoreSql, ") AS score").concat(selectFields, "\n    FROM content\n    ").concat(whereJoin, "\n    WHERE ").concat(gateSql, "\n    ").concat(whereCond, " ").concat(scopeCond, "\n    ) sq ORDER BY score DESC, path").concat(sqlLimit);
@@ -746,7 +751,7 @@ function queryLexical(conn, terms, opts, state) {
                         4,
                         conn.prepare(sql)
                     ];
-                case 5:
+                case 6:
                     stmt = _state.sent();
                     return [
                         4,
@@ -754,7 +759,7 @@ function queryLexical(conn, terms, opts, state) {
                             limit
                         ])))
                     ];
-                case 6:
+                case 7:
                     rows = _state.sent();
                     matches = phrases.length === 0 ? rows : rows.filter(function(row) {
                         return phrases.every(function(phrase) {
@@ -781,27 +786,11 @@ function createLexicalIndex(conn) {
     return {
         query: function query(terms, opts) {
             return _async_to_generator(function() {
-                var _tmp;
                 return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            _tmp = [
-                                conn,
-                                terms,
-                                opts
-                            ];
-                            return [
-                                4,
-                                stateFor(conn)
-                            ];
-                        case 1:
-                            return [
-                                2,
-                                queryLexical.apply(void 0, _tmp.concat([
-                                    _state.sent()
-                                ]))
-                            ];
-                    }
+                    return [
+                        2,
+                        queryLexical(conn, terms, opts)
+                    ];
                 });
             })();
         },