wiki-graph-core 0.3.1

package/dist/document/stores.js

@@ -0,0 +1,1678 @@
+import { getNumber, getOptionalString, getString } from "./database.js";
+import {
+  isChunkImportance,
+  isChunkRetention
+} from "./types.js";
+import { createHash } from "../utils/hash.js";
+const MAX_SQL_BIND_PARAMS = 900;
+class ObjectMetadataStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async getMap(objectPath) {
+    const rows = await this.#database.queryAll(
+      `
+        SELECT key, value_json
+        FROM object_metadata
+        WHERE object_path = ?
+        ORDER BY key
+      `,
+      [objectPath],
+      (row) => ({
+        key: getString(row, "key"),
+        value: parseMetadataValue(getString(row, "value_json"))
+      })
+    );
+    const result = {};
+    for (const row of rows) {
+      result[row.key] = row.value;
+    }
+    return result;
+  }
+  async replaceMap(target, map) {
+    await this.#database.transaction(async () => {
+      await this.clear(target.objectPath);
+      for (const [key, value] of Object.entries(map)) {
+        await this.put(target, key, value);
+      }
+    });
+  }
+  async put(target, key, value) {
+    await this.#database.run(
+      `
+        INSERT INTO object_metadata (
+          object_kind,
+          object_path,
+          key,
+          value_json,
+          updated_at,
+          chapter_id,
+          chunk_id,
+          entity_qid,
+          triple_subject_qid,
+          triple_predicate,
+          triple_object_qid
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(object_path, key) DO UPDATE SET
+          object_kind = excluded.object_kind,
+          value_json = excluded.value_json,
+          updated_at = excluded.updated_at,
+          chapter_id = excluded.chapter_id,
+          chunk_id = excluded.chunk_id,
+          entity_qid = excluded.entity_qid,
+          triple_subject_qid = excluded.triple_subject_qid,
+          triple_predicate = excluded.triple_predicate,
+          triple_object_qid = excluded.triple_object_qid
+      `,
+      [
+        target.kind,
+        target.objectPath,
+        key,
+        JSON.stringify(value),
+        (/* @__PURE__ */ new Date()).toISOString(),
+        target.chapterId ?? null,
+        target.chunkId ?? null,
+        target.entityQid ?? null,
+        target.tripleSubjectQid ?? null,
+        target.triplePredicate ?? null,
+        target.tripleObjectQid ?? null
+      ]
+    );
+  }
+  async deleteKey(objectPath, key) {
+    await this.#database.run(
+      `
+        DELETE FROM object_metadata
+        WHERE object_path = ?
+          AND key = ?
+      `,
+      [objectPath, key]
+    );
+  }
+  async clear(objectPath) {
+    await this.#database.run(
+      `
+        DELETE FROM object_metadata
+        WHERE object_path = ?
+      `,
+      [objectPath]
+    );
+  }
+  async deleteChapterSubtree(chapterId) {
+    await this.#database.run(
+      `
+        DELETE FROM object_metadata
+        WHERE chapter_id = ?
+      `,
+      [chapterId]
+    );
+  }
+  async deleteDeletedChunks() {
+    await this.#database.run(`
+      DELETE FROM object_metadata
+      WHERE chunk_id IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1
+          FROM chunks
+          WHERE chunks.id = object_metadata.chunk_id
+        )
+    `);
+  }
+  async deleteDeletedEntitiesAndTriples() {
+    await this.#database.run(`
+      DELETE FROM object_metadata
+      WHERE entity_qid IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1
+          FROM mentions
+          WHERE mentions.qid = object_metadata.entity_qid
+        )
+    `);
+    await this.#database.run(`
+      DELETE FROM object_metadata
+      WHERE triple_subject_qid IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1
+          FROM mention_links
+          JOIN mentions AS source_mentions
+            ON source_mentions.id = mention_links.source_mention_id
+          JOIN mentions AS target_mentions
+            ON target_mentions.id = mention_links.target_mention_id
+          WHERE source_mentions.qid = object_metadata.triple_subject_qid
+            AND mention_links.predicate = object_metadata.triple_predicate
+            AND target_mentions.qid = object_metadata.triple_object_qid
+        )
+    `);
+  }
+}
+class SerialStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async create() {
+    return await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          INSERT INTO serials DEFAULT VALUES
+        `
+      );
+      const serialId = await this.#database.getLastInsertRowId();
+      await this.#database.run(
+        `
+          INSERT INTO serial_states (
+            serial_id, revision, topology_ready, knowledge_graph_ready
+          )
+          VALUES (?, ?, ?, ?)
+        `,
+        [serialId, 0, 0, 0]
+      );
+      return serialId;
+    });
+  }
+  async createWithId(serialId) {
+    try {
+      await this.#database.transaction(async () => {
+        await this.#database.run(
+          `
+            INSERT INTO serials (id)
+            VALUES (?)
+          `,
+          [serialId]
+        );
+        await this.#database.run(
+          `
+            INSERT INTO serial_states (
+            serial_id, revision, topology_ready, knowledge_graph_ready
+          )
+          VALUES (?, ?, ?, ?)
+        `,
+          [serialId, 0, 0, 0]
+        );
+      });
+    } catch (error) {
+      if (isSqliteConstraintError(error)) {
+        throw new Error(`Serial ${serialId} already exists`);
+      }
+      throw error;
+    }
+  }
+  async ensure(serialId) {
+    await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          INSERT OR IGNORE INTO serials (id)
+          VALUES (?)
+        `,
+        [serialId]
+      );
+      await this.#database.run(
+        `
+          INSERT OR IGNORE INTO serial_states (
+            serial_id, revision, topology_ready, knowledge_graph_ready
+          )
+          VALUES (?, ?, ?, ?)
+        `,
+        [serialId, 0, 0, 0]
+      );
+    });
+  }
+  async getById(serialId) {
+    return await this.#database.queryOne(
+      `
+        SELECT
+          serials.id AS id,
+          serials.document_order AS document_order,
+          COALESCE(serial_states.revision, 0) AS revision,
+          COALESCE(serial_states.topology_ready, 0) AS topology_ready,
+          serial_states.topology_parameter_hash AS topology_parameter_hash,
+          COALESCE(serial_states.knowledge_graph_ready, 0) AS knowledge_graph_ready,
+          serial_states.knowledge_graph_parameter_hash AS knowledge_graph_parameter_hash
+        FROM serials
+        LEFT JOIN serial_states
+          ON serial_states.serial_id = serials.id
+        WHERE serials.id = ?
+      `,
+      [serialId],
+      mapSerialRow
+    );
+  }
+  async getRevision(serialId) {
+    return await this.#database.queryOne(
+      `
+          SELECT COALESCE(revision, 0) AS revision
+          FROM serial_states
+          WHERE serial_id = ?
+        `,
+      [serialId],
+      (row) => getNumber(row, "revision")
+    ) ?? 0;
+  }
+  async getRevisions(serialIds) {
+    const uniqueIds = [...new Set(serialIds)].sort(compareNumber);
+    if (uniqueIds.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const rows = await this.#database.queryAll(
+      `
+        SELECT serial_id, COALESCE(revision, 0) AS revision
+        FROM serial_states
+        WHERE serial_id IN (${uniqueIds.map(() => "?").join(", ")})
+        ORDER BY serial_id
+      `,
+      uniqueIds,
+      (row) => [getNumber(row, "serial_id"), getNumber(row, "revision")]
+    );
+    return new Map(rows);
+  }
+  async bumpRevision(serialId) {
+    await this.ensure(serialId);
+    await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          UPDATE serial_states
+          SET revision = revision + 1
+          WHERE serial_id = ?
+        `,
+        [serialId]
+      );
+      await this.bumpChaptersRevision();
+    });
+  }
+  async bumpChaptersRevision() {
+    await this.#database.run(
+      `
+        INSERT INTO archive_revisions (key, value)
+        VALUES ('chapters', 1)
+        ON CONFLICT(key) DO UPDATE SET value = value + 1
+      `
+    );
+  }
+  async getChaptersRevision() {
+    return await this.#database.queryOne(
+      `
+          SELECT value
+          FROM archive_revisions
+          WHERE key = 'chapters'
+        `,
+      void 0,
+      (row) => getNumber(row, "value")
+    ) ?? 0;
+  }
+  async getMaxId() {
+    const maxId = await this.#database.queryOne(
+      `
+          SELECT COALESCE(MAX(id), 0) AS max_id
+          FROM serials
+        `,
+      void 0,
+      (row) => getNumber(row, "max_id")
+    );
+    return maxId ?? 0;
+  }
+  async setTopologyReady(serialId, ready = true, parameterHash) {
+    await this.ensure(serialId);
+    if (ready) {
+      await this.#database.run(
+        `
+          UPDATE serial_states
+          SET
+            topology_ready = ?,
+            topology_parameter_hash = COALESCE(?, topology_parameter_hash)
+          WHERE serial_id = ?
+        `,
+        [1, parameterHash ?? null, serialId]
+      );
+      return;
+    }
+    await this.#database.run(
+      `
+        UPDATE serial_states
+        SET
+          topology_ready = ?,
+          topology_parameter_hash = NULL
+        WHERE serial_id = ?
+      `,
+      [0, serialId]
+    );
+  }
+  async setKnowledgeGraphReady(serialId, ready = true, parameterHash) {
+    await this.ensure(serialId);
+    if (ready) {
+      await this.#database.run(
+        `
+          UPDATE serial_states
+          SET
+            knowledge_graph_ready = ?,
+            knowledge_graph_parameter_hash = COALESCE(?, knowledge_graph_parameter_hash)
+          WHERE serial_id = ?
+        `,
+        [1, parameterHash ?? null, serialId]
+      );
+      return;
+    }
+    await this.#database.run(
+      `
+        UPDATE serial_states
+        SET
+          knowledge_graph_ready = ?,
+          knowledge_graph_parameter_hash = NULL
+        WHERE serial_id = ?
+      `,
+      [0, serialId]
+    );
+  }
+  async listIds() {
+    return await this.#database.queryAll(
+      `
+        SELECT id
+        FROM serials
+        ORDER BY id
+      `,
+      void 0,
+      (row) => getNumber(row, "id")
+    );
+  }
+  async listDocumentOrders() {
+    const rows = await this.#database.queryAll(
+      `
+        SELECT id, document_order
+        FROM serials
+        ORDER BY id
+      `,
+      void 0,
+      (row) => [getNumber(row, "id"), getNumber(row, "document_order")]
+    );
+    return new Map(rows);
+  }
+  async setDocumentOrders(entries) {
+    await this.#database.transaction(async () => {
+      for (const entry of entries) {
+        await this.#database.run(
+          `
+            INSERT OR IGNORE INTO serials (id)
+            VALUES (?)
+          `,
+          [entry.serialId]
+        );
+        await this.#database.run(
+          `
+            INSERT OR IGNORE INTO serial_states (
+              serial_id, revision, topology_ready, knowledge_graph_ready
+            )
+            VALUES (?, ?, ?, ?)
+          `,
+          [entry.serialId, 0, 0, 0]
+        );
+        await this.#database.run(
+          `
+            UPDATE serials
+            SET document_order = ?
+            WHERE id = ?
+          `,
+          [entry.documentOrder, entry.serialId]
+        );
+      }
+    });
+  }
+}
+function mapSerialRow(row) {
+  const topologyParameterHash = getOptionalString(
+    row,
+    "topology_parameter_hash"
+  );
+  const knowledgeGraphParameterHash = getOptionalString(
+    row,
+    "knowledge_graph_parameter_hash"
+  );
+  return {
+    documentOrder: getNumber(row, "document_order"),
+    id: getNumber(row, "id"),
+    knowledgeGraphReady: getNumber(row, "knowledge_graph_ready") !== 0,
+    ...knowledgeGraphParameterHash === void 0 ? {} : { knowledgeGraphParameterHash },
+    revision: getNumber(row, "revision"),
+    topologyReady: getNumber(row, "topology_ready") !== 0,
+    ...topologyParameterHash === void 0 ? {} : { topologyParameterHash }
+  };
+}
+function compareNumber(left, right) {
+  return left - right;
+}
+class GraphBuildParameterStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(input) {
+    const hash = createHash({
+      language: input.language ?? null,
+      prompt: input.prompt
+    });
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.#database.run(
+      `
+        INSERT OR IGNORE INTO graph_build_parameters (
+          hash, prompt, language, created_at
+        )
+        VALUES (?, ?, ?, ?)
+      `,
+      [hash, input.prompt, input.language ?? null, createdAt]
+    );
+    return await this.getByHash(hash);
+  }
+  async getByHash(hash) {
+    return await this.#database.queryOne(
+      `
+        SELECT hash, prompt, language, created_at
+        FROM graph_build_parameters
+        WHERE hash = ?
+      `,
+      [hash],
+      (row) => {
+        const language = getOptionalString(row, "language");
+        return {
+          createdAt: getString(row, "created_at"),
+          hash: getString(row, "hash"),
+          ...language === void 0 ? {} : { language },
+          prompt: getString(row, "prompt")
+        };
+      }
+    );
+  }
+  async deleteUnreferenced() {
+    await this.#database.run(`
+      DELETE FROM graph_build_parameters
+      WHERE hash NOT IN (
+        SELECT topology_parameter_hash
+        FROM serial_states
+        WHERE topology_parameter_hash IS NOT NULL
+        UNION
+        SELECT knowledge_graph_parameter_hash
+        FROM serial_states
+        WHERE knowledge_graph_parameter_hash IS NOT NULL
+      )
+    `);
+  }
+}
+function isSqliteConstraintError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && error.code.startsWith("SQLITE_CONSTRAINT");
+}
+class ChunkStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async countAll() {
+    return await this.#database.queryOne(
+      `
+          SELECT COUNT(*) AS count
+          FROM chunks
+        `,
+      void 0,
+      (row) => getNumber(row, "count")
+    ) ?? 0;
+  }
+  async create(record) {
+    return await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          INSERT INTO chunks (
+            generation,
+            serial_id,
+            sentence_index,
+            label,
+            content,
+            retention,
+            importance,
+            wordsCount,
+            weight
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          record.generation,
+          record.sentenceId[0],
+          record.sentenceId[1],
+          record.label,
+          record.content,
+          record.retention ?? null,
+          record.importance ?? null,
+          record.wordsCount,
+          record.weight
+        ]
+      );
+      const id = await this.#database.getLastInsertRowId();
+      const createdRecord = {
+        ...record,
+        id
+      };
+      await this.#replaceChunkSentences(createdRecord);
+      return createdRecord;
+    });
+  }
+  async save(record) {
+    await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          INSERT OR REPLACE INTO chunks (
+            id,
+            generation,
+            serial_id,
+            sentence_index,
+            label,
+            content,
+            retention,
+            importance,
+            wordsCount,
+            weight
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          record.id,
+          record.generation,
+          record.sentenceId[0],
+          record.sentenceId[1],
+          record.label,
+          record.content,
+          record.retention ?? null,
+          record.importance ?? null,
+          record.wordsCount,
+          record.weight
+        ]
+      );
+      await this.#replaceChunkSentences(record);
+    });
+  }
+  async getById(chunkId) {
+    const row = await this.#database.queryOne(
+      `
+        SELECT
+          id,
+          generation,
+          serial_id,
+          sentence_index,
+          label,
+          content,
+          retention,
+          importance,
+          wordsCount,
+          weight
+        FROM chunks
+        WHERE id = ?
+      `,
+      [chunkId],
+      (value) => value
+    );
+    if (row === void 0) {
+      return void 0;
+    }
+    return await this.#mapChunkRow(row);
+  }
+  async listAll() {
+    const rows = await this.#database.queryAll(
+      `
+          SELECT
+            id,
+            generation,
+            serial_id,
+            sentence_index,
+            label,
+            content,
+            retention,
+            importance,
+            wordsCount,
+            weight
+          FROM chunks
+          ORDER BY id
+        `,
+      void 0,
+      (row) => row
+    );
+    return await Promise.all(
+      rows.map(async (row) => await this.#mapChunkRow(row))
+    );
+  }
+  async listBySentenceStartIndexes(serialId, sentenceStartIndexes) {
+    if (sentenceStartIndexes.length === 0) {
+      return [];
+    }
+    const results = await Promise.all(
+      sentenceStartIndexes.map(
+        async (sentenceStartIndex) => await this.listBySentenceRange(
+          serialId,
+          sentenceStartIndex,
+          sentenceStartIndex
+        )
+      )
+    );
+    return deduplicateById(results.flat());
+  }
+  async listBySentenceRange(serialId, startSentenceIndex, endSentenceIndex) {
+    const rows = await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          generation,
+          serial_id,
+          sentence_index,
+          label,
+          content,
+          retention,
+          importance,
+          wordsCount,
+          weight
+        FROM chunks
+        WHERE serial_id = ?
+          AND sentence_index BETWEEN ? AND ?
+        ORDER BY id
+      `,
+      [serialId, startSentenceIndex, endSentenceIndex],
+      (row) => row
+    );
+    return await Promise.all(
+      rows.map(async (row) => await this.#mapChunkRow(row))
+    );
+  }
+  async listBySerial(serialId) {
+    const rows = await this.#database.queryAll(
+      `
+          SELECT
+            id,
+            generation,
+            serial_id,
+            sentence_index,
+            label,
+            content,
+            retention,
+            importance,
+            wordsCount,
+            weight
+          FROM chunks
+          WHERE serial_id = ?
+          ORDER BY id
+        `,
+      [serialId],
+      (row) => row
+    );
+    return await Promise.all(
+      rows.map(async (row) => await this.#mapChunkRow(row))
+    );
+  }
+  async getMaxId() {
+    return await this.#database.queryOne(
+      `
+          SELECT MAX(id) AS id
+          FROM chunks
+        `,
+      void 0,
+      (row) => {
+        const value = row.id;
+        return typeof value === "number" ? value : 0;
+      }
+    ) ?? 0;
+  }
+  async listFragmentPairs() {
+    return await this.#database.queryAll(
+      `
+        SELECT DISTINCT serial_id, sentence_index
+        FROM chunks
+        ORDER BY serial_id, sentence_index
+      `,
+      void 0,
+      (row) => [
+        getNumber(row, "serial_id"),
+        getNumber(row, "sentence_index")
+      ]
+    );
+  }
+  async #getSentenceIds(chunkId) {
+    return await this.#database.queryAll(
+      `
+        SELECT serial_id, sentence_index
+        FROM chunk_sentences
+        WHERE chunk_id = ?
+        ORDER BY serial_id, sentence_index
+      `,
+      [chunkId],
+      (row) => [
+        getNumber(row, "serial_id"),
+        getNumber(row, "sentence_index")
+      ]
+    );
+  }
+  async #replaceChunkSentences(record) {
+    await this.#database.run(
+      `
+        DELETE FROM chunk_sentences
+        WHERE chunk_id = ?
+      `,
+      [record.id]
+    );
+    for (const sentenceId of record.sentenceIds) {
+      await this.#database.run(
+        `
+          INSERT INTO chunk_sentences (
+            chunk_id,
+            serial_id,
+            sentence_index
+          )
+          VALUES (?, ?, ?)
+        `,
+        [record.id, sentenceId[0], sentenceId[1]]
+      );
+    }
+  }
+  async #mapChunkRow(row) {
+    const chunkId = getNumber(row, "id");
+    const importance = parseChunkImportance(
+      getOptionalString(row, "importance")
+    );
+    const retention = parseChunkRetention(getOptionalString(row, "retention"));
+    return {
+      content: getString(row, "content"),
+      generation: getNumber(row, "generation"),
+      id: chunkId,
+      label: getString(row, "label"),
+      sentenceId: [
+        getNumber(row, "serial_id"),
+        getNumber(row, "sentence_index")
+      ],
+      sentenceIds: await this.#getSentenceIds(chunkId),
+      wordsCount: getNumber(row, "wordsCount"),
+      weight: getNumber(row, "weight"),
+      ...importance === void 0 ? {} : { importance },
+      ...retention === void 0 ? {} : { retention }
+    };
+  }
+}
+class ReadingEdgeStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async countAll() {
+    return await this.#database.queryOne(
+      `
+          SELECT COUNT(*) AS count
+          FROM reading_edges
+        `,
+      void 0,
+      (row) => getNumber(row, "count")
+    ) ?? 0;
+  }
+  async save(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO reading_edges (from_id, to_id, strength, weight)
+        VALUES (?, ?, ?, ?)
+      `,
+      [record.fromId, record.toId, record.strength ?? null, record.weight]
+    );
+  }
+  async listAll() {
+    return await this.#database.queryAll(
+      `
+        SELECT from_id, to_id, strength, weight
+        FROM reading_edges
+        ORDER BY from_id, to_id
+      `,
+      void 0,
+      (row) => mapReadingEdgeRow(row)
+    );
+  }
+  async listBySerial(serialId) {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          reading_edges.from_id AS from_id,
+          reading_edges.to_id AS to_id,
+          reading_edges.strength AS strength,
+          reading_edges.weight AS weight
+        FROM reading_edges
+        INNER JOIN chunks AS from_chunks
+          ON from_chunks.id = reading_edges.from_id
+        INNER JOIN chunks AS to_chunks
+          ON to_chunks.id = reading_edges.to_id
+        WHERE from_chunks.serial_id = ? AND to_chunks.serial_id = ?
+        ORDER BY reading_edges.from_id, reading_edges.to_id
+      `,
+      [serialId, serialId],
+      (row) => mapReadingEdgeRow(row)
+    );
+  }
+  async listIncoming(chunkId) {
+    return await this.#listByDirection("to_id", chunkId);
+  }
+  async listOutgoing(chunkId) {
+    return await this.#listByDirection("from_id", chunkId);
+  }
+  async #listByDirection(column, chunkId) {
+    return await this.#database.queryAll(
+      `
+        SELECT from_id, to_id, strength, weight
+        FROM reading_edges
+        WHERE ${column} = ?
+        ORDER BY from_id, to_id
+      `,
+      [chunkId],
+      (row) => mapReadingEdgeRow(row)
+    );
+  }
+}
+class SnakeStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async create(record) {
+    await this.#database.run(
+      `
+        INSERT INTO snakes (
+          serial_id,
+          group_id,
+          local_snake_id,
+          size,
+          first_label,
+          last_label,
+          wordsCount,
+          weight
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      [
+        record.serialId,
+        record.groupId,
+        record.localSnakeId,
+        record.size,
+        record.firstLabel,
+        record.lastLabel,
+        record.wordsCount ?? 0,
+        record.weight ?? 0
+      ]
+    );
+    return await this.#database.getLastInsertRowId();
+  }
+  async getById(snakeId) {
+    return await this.#database.queryOne(
+      `
+        SELECT
+          id,
+          serial_id,
+          group_id,
+          local_snake_id,
+          size,
+          first_label,
+          last_label,
+          wordsCount,
+          weight
+        FROM snakes
+        WHERE id = ?
+      `,
+      [snakeId],
+      (row) => ({
+        serialId: getNumber(row, "serial_id"),
+        firstLabel: getString(row, "first_label"),
+        groupId: getNumber(row, "group_id"),
+        id: getNumber(row, "id"),
+        lastLabel: getString(row, "last_label"),
+        localSnakeId: getNumber(row, "local_snake_id"),
+        size: getNumber(row, "size"),
+        wordsCount: getNumber(row, "wordsCount"),
+        weight: getNumber(row, "weight")
+      })
+    );
+  }
+  async listIdsByGroup(serialId, groupId) {
+    return await this.#database.queryAll(
+      `
+        SELECT id
+        FROM snakes
+        WHERE serial_id = ? AND group_id = ?
+        ORDER BY id
+      `,
+      [serialId, groupId],
+      (row) => getNumber(row, "id")
+    );
+  }
+  async listBySerial(serialId) {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          serial_id,
+          group_id,
+          local_snake_id,
+          size,
+          first_label,
+          last_label,
+          wordsCount,
+          weight
+        FROM snakes
+        WHERE serial_id = ?
+        ORDER BY group_id, id
+      `,
+      [serialId],
+      (row) => ({
+        serialId: getNumber(row, "serial_id"),
+        firstLabel: getString(row, "first_label"),
+        groupId: getNumber(row, "group_id"),
+        id: getNumber(row, "id"),
+        lastLabel: getString(row, "last_label"),
+        localSnakeId: getNumber(row, "local_snake_id"),
+        size: getNumber(row, "size"),
+        wordsCount: getNumber(row, "wordsCount"),
+        weight: getNumber(row, "weight")
+      })
+    );
+  }
+}
+class MentionStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO mentions (
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      [
+        record.id,
+        record.chapterId,
+        record.sentenceIndex ?? null,
+        record.rangeStart,
+        record.rangeEnd,
+        record.surface,
+        record.qid,
+        record.confidence ?? null,
+        record.note ?? null
+      ]
+    );
+  }
+  async saveMany(records) {
+    await this.#database.transaction(async () => {
+      for (const record of records) {
+        await this.save(record);
+      }
+    });
+  }
+  async getById(mentionId) {
+    return await this.#database.queryOne(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        WHERE id = ?
+      `,
+      [mentionId],
+      mapMentionRow
+    );
+  }
+  async listAll() {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        ORDER BY chapter_id, sentence_index, range_start, range_end, id
+      `,
+      void 0,
+      mapMentionRow
+    );
+  }
+  async listByQid(qid) {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        WHERE qid = ?
+        ORDER BY chapter_id, sentence_index, range_start, range_end, id
+      `,
+      [qid],
+      mapMentionRow
+    );
+  }
+  async listBySurfaces(surfaces) {
+    const normalizedSurfaces = [
+      ...new Set(surfaces.map((surface) => surface.trim()))
+    ].filter((surface) => surface !== "");
+    if (normalizedSurfaces.length === 0) {
+      return [];
+    }
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        WHERE surface IN (${normalizedSurfaces.map(() => "?").join(", ")})
+        ORDER BY chapter_id, sentence_index, range_start, range_end, id
+      `,
+      normalizedSurfaces,
+      mapMentionRow
+    );
+  }
+  async listBySurfaceTerms(terms) {
+    const normalizedTerms = [
+      ...new Set(terms.map((term) => term.trim().toLowerCase()))
+    ].filter((term) => term !== "");
+    if (normalizedTerms.length === 0) {
+      return [];
+    }
+    const filters = normalizedTerms.map(() => "lower(surface) LIKE ? ESCAPE '\\'").join(" OR ");
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        WHERE ${filters}
+        ORDER BY chapter_id, sentence_index, range_start, range_end, id
+      `,
+      normalizedTerms.map((term) => `%${escapeLikePattern(term)}%`),
+      mapMentionRow
+    );
+  }
+  async listByChapter(chapterId) {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          id,
+          chapter_id,
+          sentence_index,
+          range_start,
+          range_end,
+          surface,
+          qid,
+          confidence,
+          note
+        FROM mentions
+        WHERE chapter_id = ?
+        ORDER BY sentence_index, range_start, range_end, id
+      `,
+      [chapterId],
+      mapMentionRow
+    );
+  }
+  async deleteByChapter(chapterId) {
+    await this.#database.run(
+      `
+        DELETE FROM mentions
+        WHERE chapter_id = ?
+      `,
+      [chapterId]
+    );
+  }
+}
+class MentionLinkStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(record) {
+    await this.#database.transaction(async () => {
+      await this.#saveRecord(record);
+    });
+  }
+  async #saveRecord(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO mention_links (
+          id,
+          source_mention_id,
+          target_mention_id,
+          predicate,
+          confidence,
+          note
+        )
+        VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      [
+        record.id,
+        record.sourceMentionId,
+        record.targetMentionId,
+        record.predicate,
+        record.confidence ?? null,
+        record.note ?? null
+      ]
+    );
+    await this.#database.run(
+      `
+        DELETE FROM mention_link_evidence_sentences
+        WHERE link_id = ?
+      `,
+      [record.id]
+    );
+    for (const [chapterId, sentenceIndex] of record.evidenceSentenceIds) {
+      await this.#database.run(
+        `
+          INSERT INTO mention_link_evidence_sentences (
+            link_id,
+            chapter_id,
+            sentence_index
+          )
+          VALUES (?, ?, ?)
+        `,
+        [record.id, chapterId, sentenceIndex]
+      );
+    }
+  }
+  async saveMany(records) {
+    await this.#database.transaction(async () => {
+      for (const record of records) {
+        await this.#saveRecord(record);
+      }
+    });
+  }
+  async getById(linkId) {
+    const row = await this.#database.queryOne(
+      `
+        SELECT
+          id,
+          source_mention_id,
+          target_mention_id,
+          predicate,
+          confidence,
+          note
+        FROM mention_links
+        WHERE id = ?
+      `,
+      [linkId],
+      mapMentionLinkRow
+    );
+    return row === void 0 ? void 0 : await this.#hydrateEvidence(row);
+  }
+  async listByTriple(input) {
+    const rows = await this.#database.queryAll(
+      `
+        SELECT
+          mention_links.id AS id,
+          mention_links.source_mention_id AS source_mention_id,
+          mention_links.target_mention_id AS target_mention_id,
+          mention_links.predicate AS predicate,
+          mention_links.confidence AS confidence,
+          mention_links.note AS note
+        FROM mention_links
+        INNER JOIN mentions AS source_mentions
+          ON source_mentions.id = mention_links.source_mention_id
+        INNER JOIN mentions AS target_mentions
+          ON target_mentions.id = mention_links.target_mention_id
+        WHERE source_mentions.qid = ?
+          AND mention_links.predicate = ?
+          AND target_mentions.qid = ?
+        ORDER BY
+          source_mentions.chapter_id,
+          source_mentions.sentence_index,
+          mention_links.id
+      `,
+      [input.subjectQid, input.predicate, input.objectQid],
+      mapMentionLinkRow
+    );
+    return await this.#hydrateEvidenceMany(rows);
+  }
+  async listByChapter(chapterId) {
+    const rows = await this.#database.queryAll(
+      `
+        SELECT
+          mention_links.id AS id,
+          mention_links.source_mention_id AS source_mention_id,
+          mention_links.target_mention_id AS target_mention_id,
+          mention_links.predicate AS predicate,
+          mention_links.confidence AS confidence,
+          mention_links.note AS note
+        FROM mention_links
+        INNER JOIN mentions AS source_mentions
+          ON source_mentions.id = mention_links.source_mention_id
+        INNER JOIN mentions AS target_mentions
+          ON target_mentions.id = mention_links.target_mention_id
+        WHERE source_mentions.chapter_id = ?
+          OR target_mentions.chapter_id = ?
+        ORDER BY mention_links.id
+      `,
+      [chapterId, chapterId],
+      mapMentionLinkRow
+    );
+    return await this.#hydrateEvidenceMany(rows);
+  }
+  async deleteByChapter(chapterId) {
+    await this.#database.transaction(async () => {
+      await this.#database.run(
+        `
+          DELETE FROM mention_link_evidence_sentences
+          WHERE link_id IN (
+            SELECT mention_links.id
+            FROM mention_links
+            INNER JOIN mentions AS source_mentions
+              ON source_mentions.id = mention_links.source_mention_id
+            INNER JOIN mentions AS target_mentions
+              ON target_mentions.id = mention_links.target_mention_id
+            WHERE source_mentions.chapter_id = ?
+              OR target_mentions.chapter_id = ?
+          )
+        `,
+        [chapterId, chapterId]
+      );
+      await this.#database.run(
+        `
+        DELETE FROM mention_links
+        WHERE source_mention_id IN (
+          SELECT id
+          FROM mentions
+          WHERE chapter_id = ?
+        )
+        OR target_mention_id IN (
+          SELECT id
+          FROM mentions
+          WHERE chapter_id = ?
+        )
+      `,
+        [chapterId, chapterId]
+      );
+    });
+  }
+  async #hydrateEvidenceMany(records) {
+    if (records.length === 0) {
+      return [];
+    }
+    const sentenceIdsByLinkId = /* @__PURE__ */ new Map();
+    const linkIds = [...new Set(records.map((record) => record.id))];
+    for (const linkIdBatch of chunkArray(linkIds, MAX_SQL_BIND_PARAMS)) {
+      const placeholders = linkIdBatch.map(() => "?").join(", ");
+      const rows = await this.#database.queryAll(
+        `
+          SELECT link_id, chapter_id, sentence_index
+          FROM mention_link_evidence_sentences
+          WHERE link_id IN (${placeholders})
+          ORDER BY link_id, chapter_id, sentence_index
+        `,
+        linkIdBatch,
+        (row) => ({
+          linkId: getString(row, "link_id"),
+          sentenceId: [
+            getNumber(row, "chapter_id"),
+            getNumber(row, "sentence_index")
+          ]
+        })
+      );
+      for (const row of rows) {
+        const sentenceIds = sentenceIdsByLinkId.get(row.linkId) ?? [];
+        sentenceIds.push(row.sentenceId);
+        sentenceIdsByLinkId.set(row.linkId, sentenceIds);
+      }
+    }
+    return records.map((record) => ({
+      ...record,
+      evidenceSentenceIds: sentenceIdsByLinkId.get(record.id) ?? []
+    }));
+  }
+  async #hydrateEvidence(record) {
+    const evidenceSentenceIds = await this.#database.queryAll(
+      `
+        SELECT chapter_id, sentence_index
+        FROM mention_link_evidence_sentences
+        WHERE link_id = ?
+        ORDER BY chapter_id, sentence_index
+      `,
+      [record.id],
+      (row) => [
+        getNumber(row, "chapter_id"),
+        getNumber(row, "sentence_index")
+      ]
+    );
+    return {
+      ...record,
+      evidenceSentenceIds
+    };
+  }
+}
+function chunkArray(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+class SnakeChunkStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO snake_chunks (snake_id, chunk_id, position)
+        VALUES (?, ?, ?)
+      `,
+      [record.snakeId, record.chunkId, record.position]
+    );
+  }
+  async listChunkIds(snakeId) {
+    return await this.#database.queryAll(
+      `
+        SELECT chunk_id
+        FROM snake_chunks
+        WHERE snake_id = ?
+        ORDER BY position
+      `,
+      [snakeId],
+      (row) => getNumber(row, "chunk_id")
+    );
+  }
+  async listBySnake(snakeId) {
+    return await this.#database.queryAll(
+      `
+        SELECT snake_id, chunk_id, position
+        FROM snake_chunks
+        WHERE snake_id = ?
+        ORDER BY position
+      `,
+      [snakeId],
+      (row) => ({
+        chunkId: getNumber(row, "chunk_id"),
+        position: getNumber(row, "position"),
+        snakeId: getNumber(row, "snake_id")
+      })
+    );
+  }
+}
+class SnakeEdgeStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO snake_edges (from_snake_id, to_snake_id, weight)
+        VALUES (?, ?, ?)
+      `,
+      [record.fromSnakeId, record.toSnakeId, record.weight]
+    );
+  }
+  async listIncoming(snakeId) {
+    return await this.#listByDirection("to_snake_id", snakeId);
+  }
+  async listOutgoing(snakeId) {
+    return await this.#listByDirection("from_snake_id", snakeId);
+  }
+  async listWithin(snakeIds) {
+    if (snakeIds.length === 0) {
+      return [];
+    }
+    const placeholders = snakeIds.map(() => "?").join(", ");
+    return await this.#database.queryAll(
+      `
+        SELECT from_snake_id, to_snake_id, weight
+        FROM snake_edges
+        WHERE from_snake_id IN (${placeholders})
+          AND to_snake_id IN (${placeholders})
+        ORDER BY from_snake_id, to_snake_id
+      `,
+      [...snakeIds, ...snakeIds],
+      (row) => ({
+        fromSnakeId: getNumber(row, "from_snake_id"),
+        toSnakeId: getNumber(row, "to_snake_id"),
+        weight: getNumber(row, "weight")
+      })
+    );
+  }
+  async listBySerial(serialId) {
+    return await this.#database.queryAll(
+      `
+        SELECT
+          snake_edges.from_snake_id AS from_snake_id,
+          snake_edges.to_snake_id AS to_snake_id,
+          snake_edges.weight AS weight
+        FROM snake_edges
+        INNER JOIN snakes AS from_snakes
+          ON from_snakes.id = snake_edges.from_snake_id
+        INNER JOIN snakes AS to_snakes
+          ON to_snakes.id = snake_edges.to_snake_id
+        WHERE from_snakes.serial_id = ? AND to_snakes.serial_id = ?
+        ORDER BY snake_edges.from_snake_id, snake_edges.to_snake_id
+      `,
+      [serialId, serialId],
+      (row) => ({
+        fromSnakeId: getNumber(row, "from_snake_id"),
+        toSnakeId: getNumber(row, "to_snake_id"),
+        weight: getNumber(row, "weight")
+      })
+    );
+  }
+  async #listByDirection(column, snakeId) {
+    return await this.#database.queryAll(
+      `
+        SELECT from_snake_id, to_snake_id, weight
+        FROM snake_edges
+        WHERE ${column} = ?
+        ORDER BY from_snake_id, to_snake_id
+      `,
+      [snakeId],
+      (row) => ({
+        fromSnakeId: getNumber(row, "from_snake_id"),
+        toSnakeId: getNumber(row, "to_snake_id"),
+        weight: getNumber(row, "weight")
+      })
+    );
+  }
+}
+class FragmentGroupStore {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  async save(record) {
+    await this.#database.run(
+      `
+        INSERT OR REPLACE INTO sentence_groups (
+          serial_id,
+          group_id,
+          start_sentence_index,
+          end_sentence_index
+        )
+        VALUES (?, ?, ?, ?)
+      `,
+      [
+        record.serialId,
+        record.groupId,
+        record.startSentenceIndex,
+        record.endSentenceIndex
+      ]
+    );
+  }
+  async saveMany(records) {
+    await this.#database.transaction(async () => {
+      for (const record of records) {
+        await this.save(record);
+      }
+    });
+  }
+  async listBySerial(serialId) {
+    return await this.#database.queryAll(
+      `
+        SELECT serial_id, group_id, start_sentence_index, end_sentence_index
+        FROM sentence_groups
+        WHERE serial_id = ?
+        ORDER BY group_id, start_sentence_index
+      `,
+      [serialId],
+      (row) => ({
+        serialId: getNumber(row, "serial_id"),
+        groupId: getNumber(row, "group_id"),
+        startSentenceIndex: getNumber(row, "start_sentence_index"),
+        endSentenceIndex: getNumber(row, "end_sentence_index")
+      })
+    );
+  }
+  async listSerialIds() {
+    return await this.#database.queryAll(
+      `
+        SELECT DISTINCT serial_id
+        FROM sentence_groups
+        ORDER BY serial_id
+      `,
+      void 0,
+      (row) => getNumber(row, "serial_id")
+    );
+  }
+  async listGroupIdsForSerial(serialId) {
+    return await this.#database.queryAll(
+      `
+        SELECT DISTINCT group_id
+        FROM sentence_groups
+        WHERE serial_id = ?
+        ORDER BY group_id
+      `,
+      [serialId],
+      (row) => getNumber(row, "group_id")
+    );
+  }
+}
+function mapReadingEdgeRow(row) {
+  const strength = getOptionalString(row, "strength");
+  return {
+    fromId: getNumber(row, "from_id"),
+    toId: getNumber(row, "to_id"),
+    weight: getNumber(row, "weight"),
+    ...strength === void 0 ? {} : { strength }
+  };
+}
+function mapMentionRow(row) {
+  const sentenceIndex = getOptionalNumber(row, "sentence_index");
+  const confidence = getOptionalNumber(row, "confidence");
+  const note = getOptionalString(row, "note");
+  return {
+    chapterId: getNumber(row, "chapter_id"),
+    ...confidence === void 0 ? {} : { confidence },
+    id: getString(row, "id"),
+    ...note === void 0 ? {} : { note },
+    qid: getString(row, "qid"),
+    rangeEnd: getNumber(row, "range_end"),
+    rangeStart: getNumber(row, "range_start"),
+    ...sentenceIndex === void 0 ? {} : { sentenceIndex },
+    surface: getString(row, "surface")
+  };
+}
+function deduplicateById(records) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const record of records) {
+    if (seen.has(record.id)) {
+      continue;
+    }
+    seen.add(record.id);
+    result.push(record);
+  }
+  return result;
+}
+function mapMentionLinkRow(row) {
+  const confidence = getOptionalNumber(row, "confidence");
+  const note = getOptionalString(row, "note");
+  return {
+    ...confidence === void 0 ? {} : { confidence },
+    evidenceSentenceIds: [],
+    id: getString(row, "id"),
+    ...note === void 0 ? {} : { note },
+    predicate: getString(row, "predicate"),
+    sourceMentionId: getString(row, "source_mention_id"),
+    targetMentionId: getString(row, "target_mention_id")
+  };
+}
+function parseMetadataValue(valueJson) {
+  try {
+    return JSON.parse(valueJson);
+  } catch (error) {
+    throw new Error(
+      `Invalid object metadata JSON: ${formatUnknownError(error)}`
+    );
+  }
+}
+function getOptionalNumber(row, key) {
+  const value = row[key];
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number") {
+    throw new TypeError(`Expected ${key} to be a number`);
+  }
+  return value;
+}
+function formatUnknownError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function escapeLikePattern(value) {
+  return value.replace(/[\\%_]/gu, (character) => `\\${character}`);
+}
+function parseChunkImportance(value) {
+  return value !== void 0 && isChunkImportance(value) ? value : void 0;
+}
+function parseChunkRetention(value) {
+  return value !== void 0 && isChunkRetention(value) ? value : void 0;
+}
+export {
+  ChunkStore,
+  FragmentGroupStore,
+  GraphBuildParameterStore,
+  MentionLinkStore,
+  MentionStore,
+  ObjectMetadataStore,
+  ReadingEdgeStore,
+  SerialStore,
+  SnakeChunkStore,
+  SnakeEdgeStore,
+  SnakeStore
+};
+//# sourceMappingURL=stores.js.map