@gobing-ai/ts-llm-jsonl-importer 0.4.15 → 0.4.17

package/dist/importer.d.ts

@@ -1,8 +1,5 @@
 import type { ImportOptions, ImportResult, SourceDefinition } from './types';
-/** Apply importer-owned schema to the target database. */
-export declare function applyHistoryImportSchema(db: ImportOptions['db']): Promise<void>;
-/**
- * Run the JSONL import pipeline for one source.
+/** Run the JSONL import pipeline for one source.
  *
  * @param source - Either a built-in source identifier resolved from the
  *   registry, or a fully-specified {@link SourceDefinition} for a custom

package/dist/importer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../src/importer.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAe,aAAa,EAAE,YAAY,EAAc,gBAAgB,EAAoB,MAAM,SAAS,CAAC;AAWxH,0DAA0D;AAC1D,wBAAsB,wBAAwB,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrF;AAiCD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA8GrH"}
+{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../src/importer.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAe,aAAa,EAAE,YAAY,EAAc,gBAAgB,EAAoB,MAAM,SAAS,CAAC;AAOxH;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA8GrH"}

package/dist/importer.js

@@ -1,50 +1,9 @@
 import { ambientRuntimePaths, createNodeFileSystem, resolvePath, walkDir, } from '@gobing-ai/ts-runtime';
-import { HistoryImportError } from './errors.js';
 import { sha256 } from './hash.js';
+import { applyHistoryImportSchema, ensureTargetTables, insertLedger, insertRecord, ledgerExists, readCheckpoint, resetCheckpoints, targetTableFor, writeCheckpoint, } from './jsonl-importer-dao.js';
 import { redactRecord } from './redaction.js';
-import { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql.js';
-import { resolveSourceDefinition, VALID_TABLE_NAME } from './sources.js';
-/** Apply importer-owned schema to the target database. */
-export async function applyHistoryImportSchema(db) {
-    for (const statement of HISTORY_IMPORT_SCHEMA_SQL.split(';')) {
-        const sql = statement.trim();
-        if (sql.length > 0) {
-            await db.exec(sql);
-        }
-    }
-}
-/**
- * Ensure the ETL table(s) for a source definition exist.
- *
- * WHY: the static {@link HISTORY_IMPORT_SCHEMA_SQL} only creates the built-in
- * `history_etl_*` tables. Custom source definitions (and built-in definitions
- * with a `splitConfig.targetTable` override) need their target table(s) created
- * on demand. The table name is already gated by {@link VALID_TABLE_NAME} in
- * {@link validateSourceDefinition} / {@link targetTableFor}, so it is safe to
- * interpolate into DDL. `CREATE TABLE IF NOT EXISTS` makes this idempotent for
- * built-in tables that the static schema already created.
- */
-async function ensureTargetTables(db, definition) {
-    const tables = new Set([targetTableFor(definition.targetTable)]);
-    if (definition.splitConfig.mode !== 'one-to-one' && definition.splitConfig.targetTable !== undefined) {
-        tables.add(targetTableFor(definition.splitConfig.targetTable));
-    }
-    for (const table of tables) {
-        await db.exec(ETL_TABLE_DDL(table));
-    }
-}
-function ETL_TABLE_DDL(table) {
-    return `CREATE TABLE IF NOT EXISTS ${table} (
-    record_hash TEXT PRIMARY KEY,
-    source_file TEXT NOT NULL,
-    source_line INTEGER NOT NULL,
-    split_index INTEGER NOT NULL,
-    payload_json TEXT NOT NULL,
-    imported_at TEXT NOT NULL
-);`;
-}
-/**
- * Run the JSONL import pipeline for one source.
+import { resolveSourceDefinition } from './sources.js';
+/** Run the JSONL import pipeline for one source.
  *
  * @param source - Either a built-in source identifier resolved from the
  *   registry, or a fully-specified {@link SourceDefinition} for a custom
@@ -234,45 +193,6 @@ function matchesPattern(path, patterns) {
         return path.endsWith(pattern.replace(/^\*/, ''));
     });
 }
-async function readCheckpoint(db, source, sourceFile) {
-    const row = await db.queryFirst('SELECT last_imported_line FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, sourceFile);
-    return row?.last_imported_line ?? 0;
-}
-async function resetCheckpoints(db, source, files) {
-    for (const file of files) {
-        await db.run('DELETE FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, file);
-    }
-}
-async function writeCheckpoint(db, source, sourceFile, line, now) {
-    await db.run(`INSERT INTO history_import_checkpoint (source, source_file, last_imported_line, updated_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(source, source_file) DO UPDATE SET
-            last_imported_line = excluded.last_imported_line,
-            updated_at = excluded.updated_at`, source, sourceFile, line, timestamp(now));
-}
-async function ledgerExists(db, recordHash) {
-    const row = await db.queryFirst('SELECT record_hash FROM history_import_ledger WHERE record_hash = ?', recordHash);
-    return row !== undefined && row !== null;
-}
-async function insertRecord(db, targetTable, recordHash, sourceFile, sourceLine, splitIndex, payload, now) {
-    const table = targetTableFor(targetTable);
-    await db.run(`INSERT INTO ${table} (record_hash, source_file, source_line, split_index, payload_json, imported_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT(record_hash) DO NOTHING`, recordHash, sourceFile, sourceLine, splitIndex, JSON.stringify(payload), timestamp(now));
-}
-async function insertLedger(db, recordHash, source, sourceFile, sourceLine, splitIndex, targetTable, now) {
-    await db.run(`INSERT INTO history_import_ledger (record_hash, source, source_file, source_line, split_index, target_table, imported_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`, recordHash, source, sourceFile, sourceLine, splitIndex, targetTable, timestamp(now));
-}
-function targetTableFor(table) {
-    if (!VALID_TABLE_NAME.test(table)) {
-        throw new HistoryImportError(`Invalid history ETL target table: ${table}`, { table });
-    }
-    return table;
-}
-function timestamp(now) {
-    return (now?.() ?? new Date()).toISOString();
-}
 /**
  * Yield lines from a file, streaming when the FileSystem supports it.
  *

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { HistoryImportError } from './errors';
 export { sha256, stableJson } from './hash';
-export { applyHistoryImportSchema, runJsonlImport } from './importer';
+export { runJsonlImport } from './importer';
+export { applyHistoryImportSchema } from './jsonl-importer-dao';
 export { DEFAULT_REDACTION_RULES, redactRecord, redactValue } from './redaction';
 export { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql';
 export { getSourceDefinition, resolveSourceDefinition, SOURCE_DEFINITIONS, VALID_TABLE_NAME, validateSourceDefinition, } from './sources';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACH,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,WAAW,CAAC;AACnB,YAAY,EACR,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACnB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACH,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,WAAW,CAAC;AACnB,YAAY,EACR,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACnB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,6 +1,7 @@
 export { HistoryImportError } from './errors.js';
 export { sha256, stableJson } from './hash.js';
-export { applyHistoryImportSchema, runJsonlImport } from './importer.js';
+export { runJsonlImport } from './importer.js';
+export { applyHistoryImportSchema } from './jsonl-importer-dao.js';
 export { DEFAULT_REDACTION_RULES, redactRecord, redactValue } from './redaction.js';
 export { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql.js';
 export { getSourceDefinition, resolveSourceDefinition, SOURCE_DEFINITIONS, VALID_TABLE_NAME, validateSourceDefinition, } from './sources.js';

package/dist/jsonl-importer-dao.d.ts

@@ -0,0 +1,30 @@
+import type { ImportOptions, JsonObject, SourceDefinition } from './types';
+interface CheckpointRow {
+    readonly last_imported_line: number;
+}
+declare function targetTableFor(table: string): string;
+declare function timestamp(now: ImportOptions['now']): string;
+declare function ETL_TABLE_DDL(table: string): string;
+/** Apply importer-owned schema to the target database. */
+export declare function applyHistoryImportSchema(db: ImportOptions['db']): Promise<void>;
+/**
+ * Ensure the ETL table(s) for a source definition exist.
+ *
+ * WHY: the static {@link HISTORY_IMPORT_SCHEMA_SQL} only creates the built-in
+ * `history_etl_*` tables. Custom source definitions (and built-in definitions
+ * with a `splitConfig.targetTable` override) need their target table(s) created
+ * on demand. The table name is already gated by {@link VALID_TABLE_NAME} in
+ * {@link validateSourceDefinition} / {@link targetTableFor}, so it is safe to
+ * interpolate into DDL. `CREATE TABLE IF NOT EXISTS` makes this idempotent for
+ * built-in tables that the static schema already created.
+ */
+declare function ensureTargetTables(db: ImportOptions['db'], definition: SourceDefinition): Promise<void>;
+declare function readCheckpoint(db: ImportOptions['db'], source: string, sourceFile: string): Promise<number>;
+declare function resetCheckpoints(db: ImportOptions['db'], source: string, files: readonly string[]): Promise<void>;
+declare function writeCheckpoint(db: ImportOptions['db'], source: string, sourceFile: string, line: number, now: ImportOptions['now']): Promise<void>;
+declare function ledgerExists(db: ImportOptions['db'], recordHash: string): Promise<boolean>;
+declare function insertRecord(db: ImportOptions['db'], targetTable: string, recordHash: string, sourceFile: string, sourceLine: number, splitIndex: number, payload: JsonObject, now: ImportOptions['now']): Promise<void>;
+declare function insertLedger(db: ImportOptions['db'], recordHash: string, source: string, sourceFile: string, sourceLine: number, splitIndex: number, targetTable: string, now: ImportOptions['now']): Promise<void>;
+export type { CheckpointRow };
+export { ETL_TABLE_DDL, ensureTargetTables, insertLedger, insertRecord, ledgerExists, readCheckpoint, resetCheckpoints, targetTableFor, timestamp, writeCheckpoint, };
+//# sourceMappingURL=jsonl-importer-dao.d.ts.map

package/dist/jsonl-importer-dao.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-importer-dao.d.ts","sourceRoot":"","sources":["../src/jsonl-importer-dao.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3E,UAAU,aAAa;IACnB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACvC;AAED,iBAAS,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED,iBAAS,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,MAAM,CAEpD;AAED,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAS5C;AAED,0DAA0D;AAC1D,wBAAsB,wBAAwB,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrF;AAED;;;;;;;;;;GAUG;AACH,iBAAe,kBAAkB,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtG;AAED,iBAAe,cAAc,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAO1G;AAED,iBAAe,gBAAgB,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhH;AAED,iBAAe,eAAe,CAC1B,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EACvB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,GAC1B,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,iBAAe,YAAY,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMzF;AAED,iBAAe,YAAY,CACvB,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EACvB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,GAC1B,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,iBAAe,YAAY,CACvB,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,EACvB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,GAC1B,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,YAAY,EAAE,aAAa,EAAE,CAAC;AAC9B,OAAO,EACH,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,SAAS,EACT,eAAe,GAClB,CAAC"}

package/dist/jsonl-importer-dao.js

@@ -0,0 +1,82 @@
+import { HistoryImportError } from './errors.js';
+import { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql.js';
+import { VALID_TABLE_NAME } from './sources.js';
+function targetTableFor(table) {
+    if (!VALID_TABLE_NAME.test(table)) {
+        throw new HistoryImportError(`Invalid history ETL target table: ${table}`, { table });
+    }
+    return table;
+}
+function timestamp(now) {
+    return (now?.() ?? new Date()).toISOString();
+}
+function ETL_TABLE_DDL(table) {
+    return `CREATE TABLE IF NOT EXISTS ${table} (
+    record_hash TEXT PRIMARY KEY,
+    source_file TEXT NOT NULL,
+    source_line INTEGER NOT NULL,
+    split_index INTEGER NOT NULL,
+    payload_json TEXT NOT NULL,
+    imported_at TEXT NOT NULL
+);`;
+}
+/** Apply importer-owned schema to the target database. */
+export async function applyHistoryImportSchema(db) {
+    for (const statement of HISTORY_IMPORT_SCHEMA_SQL.split(';')) {
+        const sql = statement.trim();
+        if (sql.length > 0) {
+            await db.exec(sql);
+        }
+    }
+}
+/**
+ * Ensure the ETL table(s) for a source definition exist.
+ *
+ * WHY: the static {@link HISTORY_IMPORT_SCHEMA_SQL} only creates the built-in
+ * `history_etl_*` tables. Custom source definitions (and built-in definitions
+ * with a `splitConfig.targetTable` override) need their target table(s) created
+ * on demand. The table name is already gated by {@link VALID_TABLE_NAME} in
+ * {@link validateSourceDefinition} / {@link targetTableFor}, so it is safe to
+ * interpolate into DDL. `CREATE TABLE IF NOT EXISTS` makes this idempotent for
+ * built-in tables that the static schema already created.
+ */
+async function ensureTargetTables(db, definition) {
+    const tables = new Set([targetTableFor(definition.targetTable)]);
+    if (definition.splitConfig.mode !== 'one-to-one' && definition.splitConfig.targetTable !== undefined) {
+        tables.add(targetTableFor(definition.splitConfig.targetTable));
+    }
+    for (const table of tables) {
+        await db.exec(ETL_TABLE_DDL(table));
+    }
+}
+async function readCheckpoint(db, source, sourceFile) {
+    const row = await db.queryFirst('SELECT last_imported_line FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, sourceFile);
+    return row?.last_imported_line ?? 0;
+}
+async function resetCheckpoints(db, source, files) {
+    for (const file of files) {
+        await db.run('DELETE FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, file);
+    }
+}
+async function writeCheckpoint(db, source, sourceFile, line, now) {
+    await db.run(`INSERT INTO history_import_checkpoint (source, source_file, last_imported_line, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(source, source_file) DO UPDATE SET
+            last_imported_line = excluded.last_imported_line,
+            updated_at = excluded.updated_at`, source, sourceFile, line, timestamp(now));
+}
+async function ledgerExists(db, recordHash) {
+    const row = await db.queryFirst('SELECT record_hash FROM history_import_ledger WHERE record_hash = ?', recordHash);
+    return row !== undefined && row !== null;
+}
+async function insertRecord(db, targetTable, recordHash, sourceFile, sourceLine, splitIndex, payload, now) {
+    const table = targetTableFor(targetTable);
+    await db.run(`INSERT INTO ${table} (record_hash, source_file, source_line, split_index, payload_json, imported_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(record_hash) DO NOTHING`, recordHash, sourceFile, sourceLine, splitIndex, JSON.stringify(payload), timestamp(now));
+}
+async function insertLedger(db, recordHash, source, sourceFile, sourceLine, splitIndex, targetTable, now) {
+    await db.run(`INSERT INTO history_import_ledger (record_hash, source, source_file, source_line, split_index, target_table, imported_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, recordHash, source, sourceFile, sourceLine, splitIndex, targetTable, timestamp(now));
+}
+export { ETL_TABLE_DDL, ensureTargetTables, insertLedger, insertRecord, ledgerExists, readCheckpoint, resetCheckpoints, targetTableFor, timestamp, writeCheckpoint, };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-llm-jsonl-importer",
-    "version": "0.4.15",
+    "version": "0.4.17",
     "description": "@gobing-ai/ts-llm-jsonl-importer — Generic JSONL importer for LLM agent history files.",
     "keywords": [
         "typescript",
@@ -47,9 +47,9 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-llm-jsonl-importer-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-db": "^0.4.15",
-        "@gobing-ai/ts-runtime": "^0.4.15",
-        "@gobing-ai/ts-utils": "^0.4.15",
+        "@gobing-ai/ts-db": "^0.4.17",
+        "@gobing-ai/ts-runtime": "^0.4.17",
+        "@gobing-ai/ts-utils": "^0.4.17",
         "zod": "^4.1.0"
     },
     "devDependencies": {

package/src/importer.ts

@@ -6,11 +6,20 @@ import {
     resolvePath,
     walkDir,
 } from '@gobing-ai/ts-runtime';
-import { HistoryImportError } from './errors';
 import { sha256 } from './hash';
+import {
+    applyHistoryImportSchema,
+    ensureTargetTables,
+    insertLedger,
+    insertRecord,
+    ledgerExists,
+    readCheckpoint,
+    resetCheckpoints,
+    targetTableFor,
+    writeCheckpoint,
+} from './jsonl-importer-dao';
 import { redactRecord } from './redaction';
-import { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql';
-import { resolveSourceDefinition, VALID_TABLE_NAME } from './sources';
+import { resolveSourceDefinition } from './sources';
 import type { ImportIssue, ImportOptions, ImportResult, JsonObject, SourceDefinition, TransformContext } from './types';
 
 interface SplitRecord {
@@ -18,53 +27,7 @@ interface SplitRecord {
     readonly raw: JsonObject;
 }
 
-interface CheckpointRow {
-    readonly last_imported_line: number;
-}
-
-/** Apply importer-owned schema to the target database. */
-export async function applyHistoryImportSchema(db: ImportOptions['db']): Promise<void> {
-    for (const statement of HISTORY_IMPORT_SCHEMA_SQL.split(';')) {
-        const sql = statement.trim();
-        if (sql.length > 0) {
-            await db.exec(sql);
-        }
-    }
-}
-
-/**
- * Ensure the ETL table(s) for a source definition exist.
- *
- * WHY: the static {@link HISTORY_IMPORT_SCHEMA_SQL} only creates the built-in
- * `history_etl_*` tables. Custom source definitions (and built-in definitions
- * with a `splitConfig.targetTable` override) need their target table(s) created
- * on demand. The table name is already gated by {@link VALID_TABLE_NAME} in
- * {@link validateSourceDefinition} / {@link targetTableFor}, so it is safe to
- * interpolate into DDL. `CREATE TABLE IF NOT EXISTS` makes this idempotent for
- * built-in tables that the static schema already created.
- */
-async function ensureTargetTables(db: ImportOptions['db'], definition: SourceDefinition): Promise<void> {
-    const tables = new Set<string>([targetTableFor(definition.targetTable)]);
-    if (definition.splitConfig.mode !== 'one-to-one' && definition.splitConfig.targetTable !== undefined) {
-        tables.add(targetTableFor(definition.splitConfig.targetTable));
-    }
-    for (const table of tables) {
-        await db.exec(ETL_TABLE_DDL(table));
-    }
-}
-
-function ETL_TABLE_DDL(table: string): string {
-    return `CREATE TABLE IF NOT EXISTS ${table} (
-    record_hash TEXT PRIMARY KEY,
-    source_file TEXT NOT NULL,
-    source_line INTEGER NOT NULL,
-    split_index INTEGER NOT NULL,
-    payload_json TEXT NOT NULL,
-    imported_at TEXT NOT NULL
-);`;
-}
-/**
- * Run the JSONL import pipeline for one source.
+/** Run the JSONL import pipeline for one source.
  *
  * @param source - Either a built-in source identifier resolved from the
  *   registry, or a fully-specified {@link SourceDefinition} for a custom
@@ -290,107 +253,6 @@ function matchesPattern(path: string, patterns: readonly string[]): boolean {
     });
 }
 
-async function readCheckpoint(db: ImportOptions['db'], source: string, sourceFile: string): Promise<number> {
-    const row = await db.queryFirst<CheckpointRow>(
-        'SELECT last_imported_line FROM history_import_checkpoint WHERE source = ? AND source_file = ?',
-        source,
-        sourceFile,
-    );
-    return row?.last_imported_line ?? 0;
-}
-
-async function resetCheckpoints(db: ImportOptions['db'], source: string, files: readonly string[]): Promise<void> {
-    for (const file of files) {
-        await db.run('DELETE FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, file);
-    }
-}
-
-async function writeCheckpoint(
-    db: ImportOptions['db'],
-    source: string,
-    sourceFile: string,
-    line: number,
-    now: ImportOptions['now'],
-): Promise<void> {
-    await db.run(
-        `INSERT INTO history_import_checkpoint (source, source_file, last_imported_line, updated_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(source, source_file) DO UPDATE SET
-            last_imported_line = excluded.last_imported_line,
-            updated_at = excluded.updated_at`,
-        source,
-        sourceFile,
-        line,
-        timestamp(now),
-    );
-}
-
-async function ledgerExists(db: ImportOptions['db'], recordHash: string): Promise<boolean> {
-    const row = await db.queryFirst<{ record_hash: string }>(
-        'SELECT record_hash FROM history_import_ledger WHERE record_hash = ?',
-        recordHash,
-    );
-    return row !== undefined && row !== null;
-}
-
-async function insertRecord(
-    db: ImportOptions['db'],
-    targetTable: string,
-    recordHash: string,
-    sourceFile: string,
-    sourceLine: number,
-    splitIndex: number,
-    payload: JsonObject,
-    now: ImportOptions['now'],
-): Promise<void> {
-    const table = targetTableFor(targetTable);
-    await db.run(
-        `INSERT INTO ${table} (record_hash, source_file, source_line, split_index, payload_json, imported_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT(record_hash) DO NOTHING`,
-        recordHash,
-        sourceFile,
-        sourceLine,
-        splitIndex,
-        JSON.stringify(payload),
-        timestamp(now),
-    );
-}
-
-async function insertLedger(
-    db: ImportOptions['db'],
-    recordHash: string,
-    source: string,
-    sourceFile: string,
-    sourceLine: number,
-    splitIndex: number,
-    targetTable: string,
-    now: ImportOptions['now'],
-): Promise<void> {
-    await db.run(
-        `INSERT INTO history_import_ledger (record_hash, source, source_file, source_line, split_index, target_table, imported_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`,
-        recordHash,
-        source,
-        sourceFile,
-        sourceLine,
-        splitIndex,
-        targetTable,
-        timestamp(now),
-    );
-}
-
-function targetTableFor(table: string): string {
-    if (!VALID_TABLE_NAME.test(table)) {
-        throw new HistoryImportError(`Invalid history ETL target table: ${table}`, { table });
-    }
-    return table;
-}
-
-function timestamp(now: ImportOptions['now']): string {
-    return (now?.() ?? new Date()).toISOString();
-}
-
 /**
  * Yield lines from a file, streaming when the FileSystem supports it.
  *

package/src/index.ts

@@ -1,6 +1,7 @@
 export { HistoryImportError } from './errors';
 export { sha256, stableJson } from './hash';
-export { applyHistoryImportSchema, runJsonlImport } from './importer';
+export { runJsonlImport } from './importer';
+export { applyHistoryImportSchema } from './jsonl-importer-dao';
 export { DEFAULT_REDACTION_RULES, redactRecord, redactValue } from './redaction';
 export { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql';
 export {

package/src/jsonl-importer-dao.ts

@@ -0,0 +1,165 @@
+import { HistoryImportError } from './errors';
+import { HISTORY_IMPORT_SCHEMA_SQL } from './schema-sql';
+import { VALID_TABLE_NAME } from './sources';
+import type { ImportOptions, JsonObject, SourceDefinition } from './types';
+
+interface CheckpointRow {
+    readonly last_imported_line: number;
+}
+
+function targetTableFor(table: string): string {
+    if (!VALID_TABLE_NAME.test(table)) {
+        throw new HistoryImportError(`Invalid history ETL target table: ${table}`, { table });
+    }
+    return table;
+}
+
+function timestamp(now: ImportOptions['now']): string {
+    return (now?.() ?? new Date()).toISOString();
+}
+
+function ETL_TABLE_DDL(table: string): string {
+    return `CREATE TABLE IF NOT EXISTS ${table} (
+    record_hash TEXT PRIMARY KEY,
+    source_file TEXT NOT NULL,
+    source_line INTEGER NOT NULL,
+    split_index INTEGER NOT NULL,
+    payload_json TEXT NOT NULL,
+    imported_at TEXT NOT NULL
+);`;
+}
+
+/** Apply importer-owned schema to the target database. */
+export async function applyHistoryImportSchema(db: ImportOptions['db']): Promise<void> {
+    for (const statement of HISTORY_IMPORT_SCHEMA_SQL.split(';')) {
+        const sql = statement.trim();
+        if (sql.length > 0) {
+            await db.exec(sql);
+        }
+    }
+}
+
+/**
+ * Ensure the ETL table(s) for a source definition exist.
+ *
+ * WHY: the static {@link HISTORY_IMPORT_SCHEMA_SQL} only creates the built-in
+ * `history_etl_*` tables. Custom source definitions (and built-in definitions
+ * with a `splitConfig.targetTable` override) need their target table(s) created
+ * on demand. The table name is already gated by {@link VALID_TABLE_NAME} in
+ * {@link validateSourceDefinition} / {@link targetTableFor}, so it is safe to
+ * interpolate into DDL. `CREATE TABLE IF NOT EXISTS` makes this idempotent for
+ * built-in tables that the static schema already created.
+ */
+async function ensureTargetTables(db: ImportOptions['db'], definition: SourceDefinition): Promise<void> {
+    const tables = new Set<string>([targetTableFor(definition.targetTable)]);
+    if (definition.splitConfig.mode !== 'one-to-one' && definition.splitConfig.targetTable !== undefined) {
+        tables.add(targetTableFor(definition.splitConfig.targetTable));
+    }
+    for (const table of tables) {
+        await db.exec(ETL_TABLE_DDL(table));
+    }
+}
+
+async function readCheckpoint(db: ImportOptions['db'], source: string, sourceFile: string): Promise<number> {
+    const row = await db.queryFirst<CheckpointRow>(
+        'SELECT last_imported_line FROM history_import_checkpoint WHERE source = ? AND source_file = ?',
+        source,
+        sourceFile,
+    );
+    return row?.last_imported_line ?? 0;
+}
+
+async function resetCheckpoints(db: ImportOptions['db'], source: string, files: readonly string[]): Promise<void> {
+    for (const file of files) {
+        await db.run('DELETE FROM history_import_checkpoint WHERE source = ? AND source_file = ?', source, file);
+    }
+}
+
+async function writeCheckpoint(
+    db: ImportOptions['db'],
+    source: string,
+    sourceFile: string,
+    line: number,
+    now: ImportOptions['now'],
+): Promise<void> {
+    await db.run(
+        `INSERT INTO history_import_checkpoint (source, source_file, last_imported_line, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(source, source_file) DO UPDATE SET
+            last_imported_line = excluded.last_imported_line,
+            updated_at = excluded.updated_at`,
+        source,
+        sourceFile,
+        line,
+        timestamp(now),
+    );
+}
+
+async function ledgerExists(db: ImportOptions['db'], recordHash: string): Promise<boolean> {
+    const row = await db.queryFirst<{ record_hash: string }>(
+        'SELECT record_hash FROM history_import_ledger WHERE record_hash = ?',
+        recordHash,
+    );
+    return row !== undefined && row !== null;
+}
+
+async function insertRecord(
+    db: ImportOptions['db'],
+    targetTable: string,
+    recordHash: string,
+    sourceFile: string,
+    sourceLine: number,
+    splitIndex: number,
+    payload: JsonObject,
+    now: ImportOptions['now'],
+): Promise<void> {
+    const table = targetTableFor(targetTable);
+    await db.run(
+        `INSERT INTO ${table} (record_hash, source_file, source_line, split_index, payload_json, imported_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(record_hash) DO NOTHING`,
+        recordHash,
+        sourceFile,
+        sourceLine,
+        splitIndex,
+        JSON.stringify(payload),
+        timestamp(now),
+    );
+}
+
+async function insertLedger(
+    db: ImportOptions['db'],
+    recordHash: string,
+    source: string,
+    sourceFile: string,
+    sourceLine: number,
+    splitIndex: number,
+    targetTable: string,
+    now: ImportOptions['now'],
+): Promise<void> {
+    await db.run(
+        `INSERT INTO history_import_ledger (record_hash, source, source_file, source_line, split_index, target_table, imported_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        recordHash,
+        source,
+        sourceFile,
+        sourceLine,
+        splitIndex,
+        targetTable,
+        timestamp(now),
+    );
+}
+
+export type { CheckpointRow };
+export {
+    ETL_TABLE_DDL,
+    ensureTargetTables,
+    insertLedger,
+    insertRecord,
+    ledgerExists,
+    readCheckpoint,
+    resetCheckpoints,
+    targetTableFor,
+    timestamp,
+    writeCheckpoint,
+};