wiki-graph-core 0.3.1

package/dist/document/shared-state-database.js

@@ -0,0 +1,193 @@
+import { createHash } from "crypto";
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { dirname, resolve } from "path";
+import { setTimeout as sleep } from "timers/promises";
+import { isNodeError } from "../utils/node-error.js";
+import { Database } from "./database.js";
+const INIT_LOCK_RETRY_MS = 50;
+const INIT_LOCK_STALE_MS = 5 * 60 * 1e3;
+const INIT_LOCK_HEARTBEAT_MS = Math.floor(INIT_LOCK_STALE_MS / 2);
+async function openSharedStateDatabase(databasePath, schemaSql, options = {}) {
+  await ensureSharedStateDatabaseInitialized(databasePath, schemaSql);
+  return await Database.open(databasePath, "", options);
+}
+async function ensureSharedStateDatabaseInitialized(databasePath, schemaSql) {
+  const resolvedDatabasePath = resolve(databasePath);
+  const markerPath = createInitMarkerPath(resolvedDatabasePath);
+  const schemaHash = hashSchema(schemaSql);
+  if (await hasInitMarker(markerPath, schemaHash)) {
+    await hardenSharedStateFile(resolvedDatabasePath);
+    await hardenSharedStateFile(markerPath);
+    return;
+  }
+  await mkdir(dirname(resolvedDatabasePath), { recursive: true });
+  await withInitLock(resolvedDatabasePath, async () => {
+    if (await hasInitMarker(markerPath, schemaHash)) {
+      await hardenSharedStateFile(resolvedDatabasePath);
+      await hardenSharedStateFile(markerPath);
+      return;
+    }
+    await Database.initialize(resolvedDatabasePath, schemaSql);
+    await hardenSharedStateFile(resolvedDatabasePath);
+    await writeInitMarker(markerPath, schemaHash);
+  });
+  await hardenSharedStateFile(resolvedDatabasePath);
+  await hardenSharedStateFile(markerPath);
+}
+async function writeInitMarker(markerPath, schemaHash) {
+  const tempPath = `${markerPath}.${process.pid}.tmp`;
+  await writeFile(tempPath, `${schemaHash}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename(tempPath, markerPath);
+  await hardenSharedStateFile(markerPath);
+}
+async function withInitLock(databasePath, operation) {
+  const lockPath = `${databasePath}.init.lock`;
+  while (true) {
+    try {
+      await mkdir(lockPath, { mode: 448 });
+      break;
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      await removeStaleInitLock(lockPath);
+      await sleep(INIT_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    await writeInitLockOwner(lockPath);
+    const heartbeat = setInterval(() => {
+      void writeInitLockOwner(lockPath).catch(() => void 0);
+    }, INIT_LOCK_HEARTBEAT_MS);
+    try {
+      return await operation();
+    } finally {
+      clearInterval(heartbeat);
+    }
+  } finally {
+    await rm(lockPath, { force: true, recursive: true });
+  }
+}
+async function writeInitLockOwner(lockPath) {
+  await writeFile(
+    `${lockPath}/owner.json`,
+    `${JSON.stringify(
+      {
+        at: Date.now(),
+        pid: process.pid
+      },
+      null,
+      2
+    )}
+`,
+    {
+      encoding: "utf8",
+      mode: 384
+    }
+  );
+}
+async function removeStaleInitLock(lockPath) {
+  try {
+    const owner = await readInitLockOwner(lockPath);
+    if (owner !== void 0) {
+      if (isProcessAlive(owner.pid)) {
+        return;
+      }
+      if (Date.now() - owner.at < INIT_LOCK_STALE_MS) {
+        return;
+      }
+    } else if (!await isPathOlderThan(lockPath, INIT_LOCK_STALE_MS)) {
+      return;
+    }
+    await rm(lockPath, { force: true, recursive: true });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function readInitLockOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(
+      await readFile(`${lockPath}/owner.json`, "utf8")
+    );
+    if (isInitLockOwner(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    if (error instanceof SyntaxError) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function isInitLockOwner(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return typeof record.pid === "number" && Number.isInteger(record.pid) && record.pid > 0 && typeof record.at === "number";
+}
+async function isPathOlderThan(path, ms) {
+  const pathStat = await stat(path);
+  return Date.now() - pathStat.mtimeMs >= ms;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ESRCH") {
+      return false;
+    }
+    return true;
+  }
+}
+async function hasInitMarker(markerPath, schemaHash) {
+  try {
+    return (await readFile(markerPath, "utf8")).trim() === schemaHash;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function createInitMarkerPath(databasePath) {
+  return `${databasePath}.initialized`;
+}
+async function hardenSharedStateFile(path) {
+  try {
+    await chmod(path, 384);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+function hashSchema(schemaSql) {
+  return createHash("sha256").update(schemaSql).digest("hex");
+}
+export {
+  ensureSharedStateDatabaseInitialized,
+  openSharedStateDatabase
+};
+//# sourceMappingURL=shared-state-database.js.map

package/dist/document/shared-state-database.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/document/shared-state-database.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport {\n  chmod,\n  mkdir,\n  readFile,\n  rename,\n  rm,\n  stat,\n  writeFile,\n} from \"fs/promises\";\nimport { dirname, resolve } from \"path\";\nimport { setTimeout as sleep } from \"timers/promises\";\n\nimport { isNodeError } from \"../utils/node-error.js\";\n\nimport { Database } from \"./database.js\";\n\nconst INIT_LOCK_RETRY_MS = 50;\nconst INIT_LOCK_STALE_MS = 5 * 60 * 1000;\nconst INIT_LOCK_HEARTBEAT_MS = Math.floor(INIT_LOCK_STALE_MS / 2);\n\ninterface InitLockOwner {\n  readonly at: number;\n  readonly pid: number;\n}\n\nexport async function openSharedStateDatabase(\n  databasePath: string,\n  schemaSql: string,\n  options: { readonly readonly?: boolean } = {},\n): Promise<Database> {\n  await ensureSharedStateDatabaseInitialized(databasePath, schemaSql);\n\n  return await Database.open(databasePath, \"\", options);\n}\n\nexport async function ensureSharedStateDatabaseInitialized(\n  databasePath: string,\n  schemaSql: string,\n): Promise<void> {\n  const resolvedDatabasePath = resolve(databasePath);\n  const markerPath = createInitMarkerPath(resolvedDatabasePath);\n  const schemaHash = hashSchema(schemaSql);\n\n  if (await hasInitMarker(markerPath, schemaHash)) {\n    await hardenSharedStateFile(resolvedDatabasePath);\n    await hardenSharedStateFile(markerPath);\n    return;\n  }\n\n  await mkdir(dirname(resolvedDatabasePath), { recursive: true });\n  await withInitLock(resolvedDatabasePath, async () => {\n    if (await hasInitMarker(markerPath, schemaHash)) {\n      await hardenSharedStateFile(resolvedDatabasePath);\n      await hardenSharedStateFile(markerPath);\n      return;\n    }\n\n    await Database.initialize(resolvedDatabasePath, schemaSql);\n    await hardenSharedStateFile(resolvedDatabasePath);\n    await writeInitMarker(markerPath, schemaHash);\n  });\n  await hardenSharedStateFile(resolvedDatabasePath);\n  await hardenSharedStateFile(markerPath);\n}\n\nasync function writeInitMarker(\n  markerPath: string,\n  schemaHash: string,\n): Promise<void> {\n  const tempPath = `${markerPath}.${process.pid}.tmp`;\n\n  await writeFile(tempPath, `${schemaHash}\\n`, {\n    encoding: \"utf8\",\n    mode: 0o600,\n  });\n  await rename(tempPath, markerPath);\n  await hardenSharedStateFile(markerPath);\n}\n\nasync function withInitLock<T>(\n  databasePath: string,\n  operation: () => Promise<T>,\n): Promise<T> {\n  const lockPath = `${databasePath}.init.lock`;\n\n  while (true) {\n    try {\n      await mkdir(lockPath, { mode: 0o700 });\n      break;\n    } catch (error) {\n      if (!isNodeError(error) || error.code !== \"EEXIST\") {\n        throw error;\n      }\n\n      await removeStaleInitLock(lockPath);\n      await sleep(INIT_LOCK_RETRY_MS);\n    }\n  }\n\n  try {\n    await writeInitLockOwner(lockPath);\n    const heartbeat = setInterval(() => {\n      void writeInitLockOwner(lockPath).catch(() => undefined);\n    }, INIT_LOCK_HEARTBEAT_MS);\n\n    try {\n      return await operation();\n    } finally {\n      clearInterval(heartbeat);\n    }\n  } finally {\n    await rm(lockPath, { force: true, recursive: true });\n  }\n}\n\nasync function writeInitLockOwner(lockPath: string): Promise<void> {\n  await writeFile(\n    `${lockPath}/owner.json`,\n    `${JSON.stringify(\n      {\n        at: Date.now(),\n        pid: process.pid,\n      },\n      null,\n      2,\n    )}\\n`,\n    {\n      encoding: \"utf8\",\n      mode: 0o600,\n    },\n  );\n}\n\nasync function removeStaleInitLock(lockPath: string): Promise<void> {\n  try {\n    const owner = await readInitLockOwner(lockPath);\n\n    if (owner !== undefined) {\n      if (isProcessAlive(owner.pid)) {\n        return;\n      }\n\n      if (Date.now() - owner.at < INIT_LOCK_STALE_MS) {\n        return;\n      }\n    } else if (!(await isPathOlderThan(lockPath, INIT_LOCK_STALE_MS))) {\n      return;\n    }\n\n    await rm(lockPath, { force: true, recursive: true });\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ENOENT\") {\n      return;\n    }\n\n    throw error;\n  }\n}\n\nasync function readInitLockOwner(\n  lockPath: string,\n): Promise<InitLockOwner | undefined> {\n  try {\n    const parsed = JSON.parse(\n      await readFile(`${lockPath}/owner.json`, \"utf8\"),\n    ) as unknown;\n\n    if (isInitLockOwner(parsed)) {\n      return parsed;\n    }\n\n    return undefined;\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ENOENT\") {\n      return undefined;\n    }\n\n    if (error instanceof SyntaxError) {\n      return undefined;\n    }\n\n    throw error;\n  }\n}\n\nfunction isInitLockOwner(value: unknown): value is InitLockOwner {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n\n  const record = value as Record<string, unknown>;\n\n  return (\n    typeof record.pid === \"number\" &&\n    Number.isInteger(record.pid) &&\n    record.pid > 0 &&\n    typeof record.at === \"number\"\n  );\n}\n\nasync function isPathOlderThan(path: string, ms: number): Promise<boolean> {\n  const pathStat = await stat(path);\n\n  return Date.now() - pathStat.mtimeMs >= ms;\n}\n\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ESRCH\") {\n      return false;\n    }\n\n    return true;\n  }\n}\n\nasync function hasInitMarker(\n  markerPath: string,\n  schemaHash: string,\n): Promise<boolean> {\n  try {\n    return (await readFile(markerPath, \"utf8\")).trim() === schemaHash;\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ENOENT\") {\n      return false;\n    }\n\n    throw error;\n  }\n}\n\nfunction createInitMarkerPath(databasePath: string): string {\n  return `${databasePath}.initialized`;\n}\n\nasync function hardenSharedStateFile(path: string): Promise<void> {\n  try {\n    await chmod(path, 0o600);\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ENOENT\") {\n      return;\n    }\n\n    throw error;\n  }\n}\n\nfunction hashSchema(schemaSql: string): string {\n  return createHash(\"sha256\").update(schemaSql).digest(\"hex\");\n}\n"],"mappings":"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","names":[]}

package/dist/document/stores.d.ts

@@ -0,0 +1,203 @@
+import { Database } from './database.js';
+import { ChunkRecord, CreateChunkRecord, SentenceGroupRecord, GraphBuildParameterRecord, ReadingEdgeRecord, MentionLinkRecord, MentionRecord, SerialRecord, SnakeChunkRecord, SnakeEdgeRecord, SnakeRecord, ObjectMetadataTarget, CreateSnakeRecord } from './types.js';
+import 'sqlite3';
+
+interface ReadonlySerialStore {
+    getById(serialId: number): Promise<SerialRecord | undefined>;
+    getRevision(serialId: number): Promise<number>;
+    getRevisions(serialIds: readonly number[]): Promise<ReadonlyMap<number, number>>;
+    getMaxId(): Promise<number>;
+    getChaptersRevision(): Promise<number>;
+    listIds(): Promise<number[]>;
+    listDocumentOrders(): Promise<ReadonlyMap<number, number>>;
+}
+interface ReadonlyGraphBuildParameterStore {
+    getByHash(hash: string): Promise<GraphBuildParameterRecord | undefined>;
+}
+interface ReadonlyChunkStore {
+    countAll(): Promise<number>;
+    getById(chunkId: number): Promise<ChunkRecord | undefined>;
+    listAll(): Promise<ChunkRecord[]>;
+    listBySentenceStartIndexes(serialId: number, sentenceStartIndexes: readonly number[]): Promise<ChunkRecord[]>;
+    listBySentenceRange(serialId: number, startSentenceIndex: number, endSentenceIndex: number): Promise<ChunkRecord[]>;
+    listBySerial(serialId: number): Promise<ChunkRecord[]>;
+    getMaxId(): Promise<number>;
+    listFragmentPairs(): Promise<ReadonlyArray<readonly [number, number]>>;
+}
+interface ReadonlyReadingEdgeStore {
+    countAll(): Promise<number>;
+    listAll(): Promise<ReadingEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
+    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+}
+interface ReadonlyMentionStore {
+    getById(mentionId: string): Promise<MentionRecord | undefined>;
+    listAll(): Promise<MentionRecord[]>;
+    listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
+    listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
+    listByQid(qid: string): Promise<MentionRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionRecord[]>;
+}
+interface ReadonlyMentionLinkStore {
+    getById(linkId: string): Promise<MentionLinkRecord | undefined>;
+    listByTriple(input: {
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<MentionLinkRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionLinkRecord[]>;
+}
+interface ReadonlySnakeStore {
+    getById(snakeId: number): Promise<SnakeRecord | undefined>;
+    listIdsByGroup(serialId: number, groupId: number): Promise<number[]>;
+    listBySerial(serialId: number): Promise<SnakeRecord[]>;
+}
+interface ReadonlySnakeChunkStore {
+    listChunkIds(snakeId: number): Promise<number[]>;
+    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
+}
+interface ReadonlySnakeEdgeStore {
+    listIncoming(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listOutgoing(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<SnakeEdgeRecord[]>;
+}
+interface ReadonlyFragmentGroupStore {
+    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
+    listSerialIds(): Promise<number[]>;
+    listGroupIdsForSerial(serialId: number): Promise<number[]>;
+}
+interface ReadonlyObjectMetadataStore {
+    getMap(objectPath: string): Promise<Readonly<Record<string, unknown>>>;
+}
+declare class ObjectMetadataStore implements ReadonlyObjectMetadataStore {
+    #private;
+    constructor(database: Database);
+    getMap(objectPath: string): Promise<Readonly<Record<string, unknown>>>;
+    replaceMap(target: ObjectMetadataTarget, map: Readonly<Record<string, unknown>>): Promise<void>;
+    put(target: ObjectMetadataTarget, key: string, value: unknown): Promise<void>;
+    deleteKey(objectPath: string, key: string): Promise<void>;
+    clear(objectPath: string): Promise<void>;
+    deleteChapterSubtree(chapterId: number): Promise<void>;
+    deleteDeletedChunks(): Promise<void>;
+    deleteDeletedEntitiesAndTriples(): Promise<void>;
+}
+declare class SerialStore implements ReadonlySerialStore {
+    #private;
+    constructor(database: Database);
+    create(): Promise<number>;
+    createWithId(serialId: number): Promise<void>;
+    ensure(serialId: number): Promise<void>;
+    getById(serialId: number): Promise<SerialRecord | undefined>;
+    getRevision(serialId: number): Promise<number>;
+    getRevisions(serialIds: readonly number[]): Promise<ReadonlyMap<number, number>>;
+    bumpRevision(serialId: number): Promise<void>;
+    bumpChaptersRevision(): Promise<void>;
+    getChaptersRevision(): Promise<number>;
+    getMaxId(): Promise<number>;
+    setTopologyReady(serialId: number, ready?: boolean, parameterHash?: string): Promise<void>;
+    setKnowledgeGraphReady(serialId: number, ready?: boolean, parameterHash?: string): Promise<void>;
+    listIds(): Promise<number[]>;
+    listDocumentOrders(): Promise<ReadonlyMap<number, number>>;
+    setDocumentOrders(entries: readonly {
+        readonly documentOrder: number;
+        readonly serialId: number;
+    }[]): Promise<void>;
+}
+declare class GraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {
+    #private;
+    constructor(database: Database);
+    save(input: {
+        readonly language?: string;
+        readonly prompt: string;
+    }): Promise<GraphBuildParameterRecord>;
+    getByHash(hash: string): Promise<GraphBuildParameterRecord | undefined>;
+    deleteUnreferenced(): Promise<void>;
+}
+declare class ChunkStore implements ReadonlyChunkStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    create(record: CreateChunkRecord): Promise<ChunkRecord>;
+    save(record: ChunkRecord): Promise<void>;
+    getById(chunkId: number): Promise<ChunkRecord | undefined>;
+    listAll(): Promise<ChunkRecord[]>;
+    listBySentenceStartIndexes(serialId: number, sentenceStartIndexes: readonly number[]): Promise<ChunkRecord[]>;
+    listBySentenceRange(serialId: number, startSentenceIndex: number, endSentenceIndex: number): Promise<ChunkRecord[]>;
+    listBySerial(serialId: number): Promise<ChunkRecord[]>;
+    getMaxId(): Promise<number>;
+    listFragmentPairs(): Promise<ReadonlyArray<readonly [number, number]>>;
+}
+declare class ReadingEdgeStore implements ReadonlyReadingEdgeStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    save(record: ReadingEdgeRecord): Promise<void>;
+    listAll(): Promise<ReadingEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
+    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+}
+declare class SnakeStore implements ReadonlySnakeStore {
+    #private;
+    constructor(database: Database);
+    create(record: CreateSnakeRecord): Promise<number>;
+    getById(snakeId: number): Promise<SnakeRecord | undefined>;
+    listIdsByGroup(serialId: number, groupId: number): Promise<number[]>;
+    listBySerial(serialId: number): Promise<SnakeRecord[]>;
+}
+declare class MentionStore implements ReadonlyMentionStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionRecord): Promise<void>;
+    saveMany(records: readonly MentionRecord[]): Promise<void>;
+    getById(mentionId: string): Promise<MentionRecord | undefined>;
+    listAll(): Promise<MentionRecord[]>;
+    listByQid(qid: string): Promise<MentionRecord[]>;
+    listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
+    listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+declare class MentionLinkStore implements ReadonlyMentionLinkStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionLinkRecord): Promise<void>;
+    saveMany(records: readonly MentionLinkRecord[]): Promise<void>;
+    getById(linkId: string): Promise<MentionLinkRecord | undefined>;
+    listByTriple(input: {
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<MentionLinkRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionLinkRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+declare class SnakeChunkStore implements ReadonlySnakeChunkStore {
+    #private;
+    constructor(database: Database);
+    save(record: SnakeChunkRecord): Promise<void>;
+    listChunkIds(snakeId: number): Promise<number[]>;
+    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
+}
+declare class SnakeEdgeStore implements ReadonlySnakeEdgeStore {
+    #private;
+    constructor(database: Database);
+    save(record: SnakeEdgeRecord): Promise<void>;
+    listIncoming(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listOutgoing(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<SnakeEdgeRecord[]>;
+}
+declare class FragmentGroupStore implements ReadonlyFragmentGroupStore {
+    #private;
+    constructor(database: Database);
+    save(record: SentenceGroupRecord): Promise<void>;
+    saveMany(records: readonly SentenceGroupRecord[]): Promise<void>;
+    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
+    listSerialIds(): Promise<number[]>;
+    listGroupIdsForSerial(serialId: number): Promise<number[]>;
+}
+
+export { ChunkStore, FragmentGroupStore, GraphBuildParameterStore, MentionLinkStore, MentionStore, ObjectMetadataStore, ReadingEdgeStore, type ReadonlyChunkStore, type ReadonlyFragmentGroupStore, type ReadonlyGraphBuildParameterStore, type ReadonlyMentionLinkStore, type ReadonlyMentionStore, type ReadonlyObjectMetadataStore, type ReadonlyReadingEdgeStore, type ReadonlySerialStore, type ReadonlySnakeChunkStore, type ReadonlySnakeEdgeStore, type ReadonlySnakeStore, SerialStore, SnakeChunkStore, SnakeEdgeStore, SnakeStore };