sensemaking 0.25.0 → 0.26.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import { type Config, featureEnabled } from '../config/index.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 type { EmbedChangeKind } from './embed-scope.ts';\nimport type { FeatureToggle } from './feature-scope.ts';\nimport { NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { type ReconcilePaths, reconcile } from './reconcile.ts';\nimport { getColumns } from './shared.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// Owns bringing a store's index current: the write half `Store` (types.ts) deliberately does not\n// carry. A one-shot open calls build() once; a watcher calls it repeatedly on the same instance.\nexport interface Builder {\n  // forcedPaths (open.ts's preset-only narrow rebuild) applies to this call alone, not future ones.\n  build(forcedPaths?: ReadonlySet<string>): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Repairs an incomplete generation in place, including state owned by disabled features.\n  recover(): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Narrow embed invalidation (open.ts, embed-scope.ts's classifyEmbedChange): 'model' nulls every\n  // vector/scale in place; 'chunk' rebuilds every embedding row. Neither touches another table.\n  invalidate(kind: EmbedChangeKind): Promise<{ parsed: number }>;\n  // Narrow feature-toggle invalidation (open.ts, feature-scope.ts's classifyFeatureToggles): a\n  // toggle drops (or, turning back on, fully re-derives) that feature's own table; rank instead\n  // nulls or recomputes its `_rank` column, since rows written while a feature was off are\n  // untrustworthy (reconcile.ts's activeFeatures skips a disabled feature's hooks entirely).\n  invalidateFeatures(toggles: FeatureToggle[]): Promise<{ parsed: number }>;\n  // Releases the parse worker pool, if this lifetime ever created one; never the connection.\n  close(): Promise<void>;\n  // Pools this lifetime has constructed, so reuse is observable rather than inferred.\n  readonly poolsCreated: number;\n}\n\n// 'model': the provider or model name moved but chunk boundaries did not, so only the vector\n// values are stale. No reparse, and no table but embeddings is touched.\nasync function nullEmbedVectors(conn: Connection, dialect: ReconcileDialect): Promise<{ parsed: number }> {\n  await withTransaction(conn, () => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL'), dialect.beginMode());\n  return { parsed: 0 };\n}\n\n// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds\n// every embedding row through the embed feature's own remove/store, touching no other table.\nasync function rebuildEmbeddings(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number }> {\n  const existingStmt = await conn.prepare('SELECT \"path\" FROM frontmatter');\n  const existingPaths = new Set((await existingStmt.all()).map((r) => (r as { path: string }).path));\n  // A file added since the last build has no row yet; leaving it for build() to insert avoids a\n  // primary-key collision between this INSERT and build()'s own insert for the same new file.\n  const files = listFiles(cfg, baseDir).filter((f) => f.embed && existingPaths.has(f.relPath));\n  if (files.length === 0) return { parsed: 0 };\n\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const paths = docs.map((d) => d.relPath);\n  const delta: ReconcileDelta = { files, reparsed: paths, added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await embed.remove?.(conn, paths, delta);\n      await embed.store?.(\n        conn,\n        docs.map((d) => ({ path: d.relPath, extracted: d.extracted.embed })),\n        delta\n      );\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.\n// Rows left over from before this feature was disabled are untrustworthy by construction (files\n// added, edited, or deleted got no remove/store for it), so this never diffs against them --\n// dropping every row and reparsing the whole tree is the only safe path back to consistent state.\nasync function invalidateFeatureTable(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggle: FeatureToggle): Promise<{ parsed: number }> {\n  const table = NARROW_FEATURE_TABLE[toggle.name];\n  const feature = FEATURES.find((f) => f.name === toggle.name);\n  if (!feature) throw new Error(`invalidateFeatureTable: no registered feature named \"${toggle.name}\"`);\n\n  if (!toggle.turnedOn) {\n    await withTransaction(conn, () => conn.exec(`DELETE FROM ${table}`), dialect.beginMode());\n    return { parsed: 0 };\n  }\n\n  const files = listFiles(cfg, baseDir);\n  const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n  const docsForFeature = docs.map((d) => ({ path: d.relPath, extracted: d.extracted[feature.name] }));\n  const paths = docs.map((d) => d.relPath);\n  // Every path counts as added, not just touched: nothing stale to diff against. Links resolves\n  // dst inside store() itself when added.length equals files.length (a cold build).\n  const delta: ReconcileDelta = { files, reparsed: paths, added: paths, vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await conn.exec(`DELETE FROM ${table}`);\n      await feature.store?.(conn, docsForFeature, delta);\n      await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column\n// presence, since links can toggle off while rank has never been enabled for this tree.\nasync function nullRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const columns = await getColumns(conn);\n  if (!columns.has('_rank')) return;\n  await withTransaction(conn, () => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL'), dialect.beginMode());\n}\n\n// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so\n// turning rank back on needs no reparseFiles pass at all.\nasync function rerunRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const delta: ReconcileDelta = { files: [], reparsed: [], added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await rank.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n}\n\nasync function invalidateFeatureToggles(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggles: FeatureToggle[]): Promise<{ parsed: number }> {\n  const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n  let parsed = 0;\n\n  // links first, if present: rank's rerun below (whether from its own toggle or the co-change\n  // rankToggle carries) must read the links table after it is back in its new state.\n  const linksToggle = byName.get('links');\n  if (linksToggle) {\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)).parsed;\n    // Unconditional, per rank's dependency on links: nulling is a no-op (guarded) when rank was\n    // never enabled for this tree, so this is safe even when no feature:rank segment changed.\n    if (!linksToggle.turnedOn) await nullRank(conn, dialect);\n  }\n\n  // rank's effective on/off (featureEnabled's links dependency) only appears as a changed\n  // `feature:rank` segment when it actually flips -- whether that's rank's own config or a\n  // links toggle taking it along -- so honoring it here is complete on its own.\n  const rankToggle = byName.get('rank');\n  if (rankToggle) {\n    if (rankToggle.turnedOn) await rerunRank(conn, dialect);\n    else await nullRank(conn, dialect);\n  }\n\n  for (const toggle of toggles) {\n    if (toggle.name === 'links' || toggle.name === 'rank') continue;\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)).parsed;\n  }\n  return { parsed };\n}\n\nasync function recoverIncomplete(conn: Connection, cfg: Config, paths: ReconcilePaths, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number; warnings: string[]; stages: Stages }> {\n  const disabled = FEATURES.filter((feature) => !featureEnabled(cfg, feature.name));\n  for (const feature of disabled) {\n    if (feature.name !== 'embed') await feature.schema(conn);\n  }\n\n  const toggles: FeatureToggle[] = disabled.filter((feature) => feature.name !== 'embed').map((feature) => ({ name: feature.name, turnedOn: false }));\n  await invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles);\n  if (disabled.some((feature) => feature.name === 'embed')) {\n    const embeddingsTable = await conn.prepare(\"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'embeddings'\");\n    if ((await embeddingsTable.all()).length > 0) await withTransaction(conn, () => conn.exec('DELETE FROM embeddings'), dialect.beginMode());\n  }\n\n  const forcedPaths = new Set(listFiles(cfg, paths.rootDir).map((file) => file.relPath));\n  return reconcile(conn, cfg, paths, dialect, pool, forcedPaths);\n}\n\n// The pool is created at most once, lazily, on whichever build() or invalidate() call first\n// needs it, and reused by every later call on this instance.\nexport function createBuilder(conn: Connection, cfg: Config, paths: ReconcilePaths, dialect: ReconcileDialect): Builder {\n  const pool = new ParsePool();\n  return {\n    build: (forcedPaths) => reconcile(conn, cfg, paths, dialect, pool, forcedPaths),\n    recover: () => recoverIncomplete(conn, cfg, paths, dialect, pool),\n    invalidate: (kind) => (kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, paths.rootDir, dialect, pool)),\n    invalidateFeatures: (toggles) => invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles),\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","nullEmbedVectors","conn","dialect","withTransaction","exec","beginMode","parsed","rebuildEmbeddings","cfg","baseDir","pool","existingStmt","existingPaths","files","docs","paths","delta","prepare","Set","all","map","r","path","listFiles","filter","f","embed","has","relPath","length","reparseFiles","undefined","d","reparsed","added","vanished","remove","store","extracted","invalidateFeatureTable","toggle","table","feature","docsForFeature","NARROW_FEATURE_TABLE","name","FEATURES","find","Error","turnedOn","afterReconcile","nullRank","columns","getColumns","rerunRank","rank","invalidateFeatureToggles","toggles","byName","linksToggle","rankToggle","Map","get","recoverIncomplete","disabled","embeddingsTable","forcedPaths","featureEnabled","schema","rootDir","some","file","reconcile","ParsePool","build","recover","invalidate","kind","invalidateFeatures","close","poolsCreated"],"mappings":"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"}
+{"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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"}

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

@@ -223,6 +223,12 @@ function _await_async_generator(value) {
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
         return Array.from(iter);
@@ -653,7 +659,7 @@ function createConnection(duckdb) {
                                 4,
                                 (0, _transactionts.withTransaction)(conn, function() {
                                     return _async_to_generator(function() {
-                                        var appender, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, column, idx, value;
+                                        var appender, errors, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, column, idx, value;
                                         return _ts_generator(this, function(_state) {
                                             switch(_state.label){
                                                 case 0:
@@ -663,6 +669,7 @@ function createConnection(duckdb) {
                                                     ];
                                                 case 1:
                                                     appender = _state.sent();
+                                                    errors = [];
                                                     try {
                                                         _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                                         try {
@@ -710,9 +717,16 @@ function createConnection(duckdb) {
                                                             }
                                                         }
                                                         appender.flushSync();
-                                                    } finally{
+                                                    } catch (err) {
+                                                        errors.push(err);
+                                                    }
+                                                    try {
                                                         appender.closeSync();
+                                                    } catch (err) {
+                                                        errors.push(err);
                                                     }
+                                                    if (errors.length === 1) throw errors[0];
+                                                    if (errors.length > 1) throw new AggregateError(errors, _instanceof(errors[0], Error) ? "".concat(errors[0].message, "; appender cleanup also failed") : 'DuckDB appender execution and cleanup failed');
                                                     return [
                                                         2
                                                     ];

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        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        } finally {\n          appender.closeSync();\n        }\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","column","idx","createAppender","undefined","appendDefault","appendNull","type","appendVariant","appendValue","endRow","flushSync","closeSync","runBatch","paramRows","rewritten","stmt","rewriteBatch","flat"],"mappings":"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"}
+{"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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"}

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

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from '../../config/index.js';
 import type { InternalOpenOptions, OpenResult } from '../open.js';
 import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.duckdb";
-export declare const SCHEMA_VERSION = "5";
+export declare const SCHEMA_VERSION = "6";
 export type { OpenResult };
 interface DuckdbHandle {
     instance: DuckDBInstance;

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

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from '../../config/index.js';
 import type { InternalOpenOptions, OpenResult } from '../open.js';
 import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.duckdb";
-export declare const SCHEMA_VERSION = "5";
+export declare const SCHEMA_VERSION = "6";
 export type { OpenResult };
 interface DuckdbHandle {
     instance: DuckDBInstance;

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

@@ -22,10 +22,9 @@ _export(exports, {
         return openDuckdb;
     }
 });
-var _indexts = require("../../config/index.js");
 var _typests = require("../../embed/types.js");
 var _errorsts = require("../../errors.js");
-var _indexts1 = require("../../features/index.js");
+var _indexts = require("../../features/index.js");
 var _opents = require("../open.js");
 var _sharedts = require("../shared.js");
 var _connectionts = require("./connection.js");
@@ -167,13 +166,12 @@ function _ts_generator(thisArg, body) {
     }
 }
 var DB_FILENAME = 'cache.duckdb';
-var SCHEMA_VERSION = '5';
+var SCHEMA_VERSION = '6';
 // `content` is a plain table (not FTS-virtual): build prepares the persistent FTS index over it,
 // while contains() verification reads the table directly.
 // No tokenizer resolution: this store always uses the fts extension's default (porter) stemmer.
-function ensureSchema(handle, conn, cfg) {
+function ensureCoreSchema(_handle, conn) {
     return _async_to_generator(function() {
-        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -207,71 +205,95 @@ function ensureSchema(handle, conn, cfg) {
                     ];
                 case 5:
                     _state.sent();
-                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 6;
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
                 case 6:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        8
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
+                    ];
+                case 7:
+                    _state.sent();
+                    _state.label = 8;
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function ensureFeatureSchema(_handle, conn, cfg) {
+    return _async_to_generator(function() {
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
                     _state.trys.push([
-                        6,
-                        14,
-                        15,
-                        16
+                        1,
+                        8,
+                        9,
+                        10
                     ]);
-                    _iterator = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
-                    _state.label = 7;
-                case 7:
+                    _iterator = (0, _indexts.activeFeatures)(cfg)[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        13
+                        7
                     ];
                     feature = _step.value;
                     if (!(feature.name === 'embed')) return [
                         3,
-                        10
+                        4
                     ];
                     return [
                         4,
-                        conn.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector FLOAT['.concat(_typests.STORE_DIMS, '], PRIMARY KEY ("path", chunk))'))
-                    ];
-                case 8:
-                    _state.sent();
-                    return [
-                        4,
-                        (0, _vectorsts.createVectorWriteStage)(handle.duckdb, _typests.STORE_DIMS)
+                        conn.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector FLOAT['.concat(_typests.STORE_DIMS, '], PRIMARY KEY ("path", chunk))'))
                     ];
-                case 9:
+                case 3:
                     _state.sent();
                     return [
                         3,
-                        12
+                        6
                     ];
-                case 10:
+                case 4:
                     return [
                         4,
                         feature.schema(conn)
                     ];
-                case 11:
+                case 5:
                     _state.sent();
-                    _state.label = 12;
-                case 12:
+                    _state.label = 6;
+                case 6:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        7
+                        2
                     ];
-                case 13:
+                case 7:
                     return [
                         3,
-                        16
+                        10
                     ];
-                case 14:
+                case 8:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        16
+                        10
                     ];
-                case 15:
+                case 9:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -284,41 +306,25 @@ function ensureSchema(handle, conn, cfg) {
                     return [
                         7
                     ];
-                case 16:
-                    return [
-                        4,
-                        (0, _sharedts.getMeta)(conn, 'schema_version')
-                    ];
-                case 17:
-                    if (!(_state.sent() === null)) return [
-                        3,
-                        19
-                    ];
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
-                    ];
-                case 18:
-                    _state.sent();
-                    _state.label = 19;
-                case 19:
+                case 10:
                     return [
-                        4,
-                        (0, _sharedts.getMeta)(conn, 'features')
-                    ];
-                case 20:
-                    if (!(_state.sent() === null)) return [
-                        3,
-                        22
+                        2
                     ];
+            }
+        });
+    })();
+}
+function prepareConnection(handle, _conn, _cfg) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
                     return [
                         4,
-                        (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
+                        (0, _vectorsts.createVectorWriteStage)(handle.duckdb, _typests.STORE_DIMS)
                     ];
-                case 21:
+                case 1:
                     _state.sent();
-                    _state.label = 22;
-                case 22:
                     return [
                         2
                     ];
@@ -454,7 +460,9 @@ var duckdbOpenDialect = {
     isLocked: function isLocked(err) {
         return /Could not set lock on file|being used by another process/.test(err.message);
     },
-    ensureSchema: ensureSchema,
+    ensureCoreSchema: ensureCoreSchema,
+    ensureFeatureSchema: ensureFeatureSchema,
+    prepareConnection: prepareConnection,
     prepareLexical: _lexicalts.prepareFts,
     assertLexicalReady: _lexicalts.assertFtsReady,
     createStore: function createStore(handle, conn) {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/open.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport type { InternalOpenOptions, OpenResult } from '../open.ts';\nimport { openWithDialect } from '../open.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { assertFtsReady, prepareFts } from './lexical.ts';\nimport { DUCKDB_PACKAGE, duckdbApi } from './native.ts';\nimport { duckdbDialect } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\nimport { createVectorWriteStage } from './vectors.ts';\n\nexport const DB_FILENAME = 'cache.duckdb';\n// Independent of sqlite's SCHEMA_VERSION -- the two stores' cache shapes evolve separately (VARIANT frontmatter columns vs untyped).\n// The store name already joins the feature signature, so switching a config's `store` key rebuilds rather than reusing the other engine's cache.\nexport const SCHEMA_VERSION = '5';\n\nexport type { OpenResult };\n\n// The connection plus this store's own native handles (types.ts's OpenDialect<Handle>): the\n// instance owns the WAL and must outlive the connection borrowed from it.\ninterface DuckdbHandle {\n  instance: DuckDBInstance;\n  duckdb: DuckDBConnection;\n}\n\n// `content` is a plain table (not FTS-virtual): build prepares the persistent FTS index over it,\n// while contains() verification reads the table directly.\n// No tokenizer resolution: this store always uses the fts extension's default (porter) stemmer.\nasync function ensureSchema(handle: DuckdbHandle, conn: Connection, cfg: Config): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" DOUBLE, \"_ctime\" DOUBLE, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS content (\"path\" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS indexed_sources (\"path\" TEXT PRIMARY KEY, text TEXT NOT NULL)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) {\n    // Native FLOAT[STORE_DIMS] instead of the embed feature's engine-neutral BLOB+scale DDL (vectors.ts). `scale` is kept, unused,\n    // so the feature's shared reconcile-time INSERT/DELETE (features/embed.ts) names a column that exists on both stores.\n    if (feature.name === 'embed') {\n      await conn.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector FLOAT[${STORE_DIMS}], PRIMARY KEY (\"path\", chunk))`);\n      await createVectorWriteStage(handle.duckdb, STORE_DIMS);\n      continue;\n    }\n    await feature.schema(conn);\n  }\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\n// Order matters: the connection must be gone before the instance closes the WAL.\nasync function close(handle: DuckdbHandle): Promise<void> {\n  handle.duckdb.disconnectSync();\n  handle.instance.closeSync();\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: DuckdbHandle; conn: Connection }> {\n  // Dynamic, not a top-level import: sqlite trees must never attempt to resolve this optional peer dependency, so nothing imports\n  // it as a value until a duckdb tree opens (types-only imports are erased). Installed on first use if missing, shared with sql-functions.ts and vectors.ts via native.ts's duckdbApi.\n  let DuckDBInstance: typeof import('@duckdb/node-api').DuckDBInstance;\n  try {\n    ({ DuckDBInstance } = await duckdbApi());\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" needs the ${DUCKDB_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let duckdb: DuckDBConnection;\n  let instance: DuckDBInstance | undefined;\n  try {\n    // On-disk files default to an older storage format for cross-version compatibility, which rejects VARIANT columns (\"VARIANT\n    // columns are not supported in storage versions prior to v1.5.0\"); this store's dynamic frontmatter columns need VARIANT (reconcile.ts), so the floor is pinned explicitly.\n    instance = await DuckDBInstance.create(dbPath, options.observational ? { access_mode: 'READ_ONLY' } : { storage_compatibility_version: 'v1.5.0' });\n    duckdb = await instance.connect();\n  } catch (err) {\n    // create() may have succeeded before connect() failed: close it, or its WAL stays open.\n    instance?.closeSync();\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  // A throw below would leak the open instance, whose WAL then locks the .duckdb file undeletable on Windows.\n  try {\n    await registerFunctions(duckdb);\n    const conn = createConnection(duckdb);\n    return { handle: { instance, duckdb }, conn };\n  } catch (err) {\n    await close({ instance, duckdb });\n    throw err;\n  }\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const duckdbOpenDialect: OpenDialect<DuckdbHandle> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: duckdbDialect,\n  connect,\n  close,\n  // duckdb's file lock spans the connection's life, and each platform words the refusal its own\n  // way: posix \"Could not set lock on file ... Conflicting lock is held in <exe> (PID n)\", Windows\n  // \"Cannot open file ... being used by another process\". Both are the same condition.\n  isLocked: (err) => /Could not set lock on file|being used by another process/.test(err.message),\n  ensureSchema,\n  prepareLexical: prepareFts,\n  assertLexicalReady: assertFtsReady,\n  createStore: (handle, conn) => createStore(handle.instance, handle.duckdb, conn),\n};\n\nexport async function openDuckdb(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult> {\n  return openWithDialect(cfg, duckdbOpenDialect, options);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","duckdbOpenDialect","openDuckdb","ensureSchema","handle","conn","cfg","feature","exec","activeFeatures","name","STORE_DIMS","createVectorWriteStage","duckdb","schema","getMeta","setMeta","featureSignature","FEATURES","close","disconnectSync","instance","closeSync","connect","dbPath","_cfg","options","DuckDBInstance","err","duckdbApi","SenseError","DUCKDB_PACKAGE","message","create","observational","access_mode","storage_compatibility_version","registerFunctions","createConnection","filename","schemaVersion","reconcileDialect","duckdbDialect","isLocked","test","prepareLexical","prepareFts","assertLexicalReady","assertFtsReady","createStore","openWithDialect"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/open.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures } from '../../features/index.ts';\nimport type { InternalOpenOptions, OpenResult } from '../open.ts';\nimport { openWithDialect } from '../open.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { assertFtsReady, prepareFts } from './lexical.ts';\nimport { DUCKDB_PACKAGE, duckdbApi } from './native.ts';\nimport { duckdbDialect } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\nimport { createVectorWriteStage } from './vectors.ts';\n\nexport const DB_FILENAME = 'cache.duckdb';\n// Independent of sqlite's SCHEMA_VERSION -- the two stores' cache shapes evolve separately (VARIANT frontmatter columns vs untyped).\n// The store name already joins the feature signature, so switching a config's `store` key rebuilds rather than reusing the other engine's cache.\nexport const SCHEMA_VERSION = '6';\n\nexport type { OpenResult };\n\n// The connection plus this store's own native handles (types.ts's OpenDialect<Handle>): the\n// instance owns the WAL and must outlive the connection borrowed from it.\ninterface DuckdbHandle {\n  instance: DuckDBInstance;\n  duckdb: DuckDBConnection;\n}\n\n// `content` is a plain table (not FTS-virtual): build prepares the persistent FTS index over it,\n// while contains() verification reads the table directly.\n// No tokenizer resolution: this store always uses the fts extension's default (porter) stemmer.\nasync function ensureCoreSchema(_handle: DuckdbHandle, conn: Connection): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" DOUBLE, \"_ctime\" DOUBLE, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS content (\"path\" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS indexed_sources (\"path\" TEXT PRIMARY KEY, text TEXT NOT NULL)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n}\n\nasync function ensureFeatureSchema(_handle: DuckdbHandle, conn: Connection, cfg: Config): Promise<void> {\n  for (const feature of activeFeatures(cfg)) {\n    // Native FLOAT[STORE_DIMS] instead of the embed feature's engine-neutral BLOB+scale DDL (vectors.ts). `scale` is kept, unused,\n    // so the feature's shared reconcile-time INSERT/DELETE (features/embed.ts) names a column that exists on both stores.\n    if (feature.name === 'embed') {\n      await conn.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector FLOAT[${STORE_DIMS}], PRIMARY KEY (\"path\", chunk))`);\n      continue;\n    }\n    await feature.schema(conn);\n  }\n}\n\nasync function prepareConnection(handle: DuckdbHandle, _conn: Connection, _cfg: Config): Promise<void> {\n  await createVectorWriteStage(handle.duckdb, STORE_DIMS);\n}\n\n// Order matters: the connection must be gone before the instance closes the WAL.\nasync function close(handle: DuckdbHandle): Promise<void> {\n  handle.duckdb.disconnectSync();\n  handle.instance.closeSync();\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: DuckdbHandle; conn: Connection }> {\n  // Dynamic, not a top-level import: sqlite trees must never attempt to resolve this optional peer dependency, so nothing imports\n  // it as a value until a duckdb tree opens (types-only imports are erased). Installed on first use if missing, shared with sql-functions.ts and vectors.ts via native.ts's duckdbApi.\n  let DuckDBInstance: typeof import('@duckdb/node-api').DuckDBInstance;\n  try {\n    ({ DuckDBInstance } = await duckdbApi());\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" needs the ${DUCKDB_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let duckdb: DuckDBConnection;\n  let instance: DuckDBInstance | undefined;\n  try {\n    // On-disk files default to an older storage format for cross-version compatibility, which rejects VARIANT columns (\"VARIANT\n    // columns are not supported in storage versions prior to v1.5.0\"); this store's dynamic frontmatter columns need VARIANT (reconcile.ts), so the floor is pinned explicitly.\n    instance = await DuckDBInstance.create(dbPath, options.observational ? { access_mode: 'READ_ONLY' } : { storage_compatibility_version: 'v1.5.0' });\n    duckdb = await instance.connect();\n  } catch (err) {\n    // create() may have succeeded before connect() failed: close it, or its WAL stays open.\n    instance?.closeSync();\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  // A throw below would leak the open instance, whose WAL then locks the .duckdb file undeletable on Windows.\n  try {\n    await registerFunctions(duckdb);\n    const conn = createConnection(duckdb);\n    return { handle: { instance, duckdb }, conn };\n  } catch (err) {\n    await close({ instance, duckdb });\n    throw err;\n  }\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const duckdbOpenDialect: OpenDialect<DuckdbHandle> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: duckdbDialect,\n  connect,\n  close,\n  // duckdb's file lock spans the connection's life, and each platform words the refusal its own\n  // way: posix \"Could not set lock on file ... Conflicting lock is held in <exe> (PID n)\", Windows\n  // \"Cannot open file ... being used by another process\". Both are the same condition.\n  isLocked: (err) => /Could not set lock on file|being used by another process/.test(err.message),\n  ensureCoreSchema,\n  ensureFeatureSchema,\n  prepareConnection,\n  prepareLexical: prepareFts,\n  assertLexicalReady: assertFtsReady,\n  createStore: (handle, conn) => createStore(handle.instance, handle.duckdb, conn),\n};\n\nexport async function openDuckdb(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult> {\n  return openWithDialect(cfg, duckdbOpenDialect, options);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","duckdbOpenDialect","openDuckdb","ensureCoreSchema","_handle","conn","exec","getMeta","setMeta","ensureFeatureSchema","cfg","feature","activeFeatures","name","STORE_DIMS","schema","prepareConnection","handle","_conn","_cfg","createVectorWriteStage","duckdb","close","disconnectSync","instance","closeSync","connect","dbPath","options","DuckDBInstance","err","duckdbApi","SenseError","DUCKDB_PACKAGE","message","create","observational","access_mode","storage_compatibility_version","registerFunctions","createConnection","filename","schemaVersion","reconcileDialect","duckdbDialect","isLocked","test","prepareLexical","prepareFts","assertLexicalReady","assertFtsReady","createStore","openWithDialect"],"mappings":"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"}