wiki-graph-core 0.3.1 → 0.4.0

package/dist/object-stream.js

@@ -0,0 +1,732 @@
+import { createReadStream, createWriteStream } from "fs";
+import { createInterface } from "readline";
+import { z } from "zod";
+import { ChunkImportance, ChunkRetention } from "./document/types.js";
+import { readSerialFragments } from "./text/summary-build/source.js";
+const WIKG_OBJECT_SCHEMA_VERSION = 1;
+const nonNegativeIntegerSchema = z.number().int().nonnegative();
+const positiveSchemaVersionSchema = z.literal(WIKG_OBJECT_SCHEMA_VERSION);
+const qidSchema = z.string().regex(/^Q[1-9][0-9]*$/u);
+const optionalConfidenceSchema = z.number().min(0).max(1).optional();
+const sentenceRecordSchema = z.object({
+  text: z.string(),
+  wordsCount: nonNegativeIntegerSchema
+}).strict();
+const metaObjectSchema = z.object({
+  type: z.literal("meta"),
+  schemaVersion: positiveSchemaVersionSchema,
+  chapterId: z.number().int(),
+  stream: z.enum(["knowledge-graph", "reading-graph", "summary"])
+}).strict();
+const parameterObjectSchema = z.object({
+  type: z.literal("parameter"),
+  scope: z.enum(["knowledge-graph", "reading-graph", "summary"]),
+  language: z.string().optional(),
+  prompt: z.string()
+}).strict();
+const sourceFragmentObjectSchema = z.object({
+  type: z.literal("source-fragment"),
+  fragmentId: nonNegativeIntegerSchema,
+  summary: z.string(),
+  sentences: z.array(sentenceRecordSchema)
+}).strict();
+const readingChunkObjectSchema = z.object({
+  type: z.literal("reading-chunk"),
+  id: z.string().min(1),
+  generation: z.number().int(),
+  sentenceIndex: nonNegativeIntegerSchema,
+  label: z.string(),
+  content: z.string(),
+  sentenceIndexes: z.array(nonNegativeIntegerSchema).min(1),
+  retention: z.enum(ChunkRetention).optional(),
+  importance: z.enum(ChunkImportance).optional(),
+  wordsCount: nonNegativeIntegerSchema,
+  weight: z.number()
+}).strict();
+const readingEdgeObjectSchema = z.object({
+  type: z.literal("reading-edge"),
+  fromChunkId: z.string().min(1),
+  toChunkId: z.string().min(1),
+  strength: z.string().optional(),
+  weight: z.number()
+}).strict();
+const fragmentGroupObjectSchema = z.object({
+  type: z.literal("fragment-group"),
+  groupId: nonNegativeIntegerSchema,
+  startSentenceIndex: nonNegativeIntegerSchema,
+  endSentenceIndex: nonNegativeIntegerSchema
+}).strict();
+const snakeObjectSchema = z.object({
+  type: z.literal("snake"),
+  id: z.string().min(1),
+  groupId: nonNegativeIntegerSchema,
+  localSnakeId: nonNegativeIntegerSchema,
+  size: nonNegativeIntegerSchema,
+  firstLabel: z.string(),
+  lastLabel: z.string(),
+  wordsCount: nonNegativeIntegerSchema,
+  weight: z.number()
+}).strict();
+const snakeChunkObjectSchema = z.object({
+  type: z.literal("snake-chunk"),
+  snakeId: z.string().min(1),
+  chunkId: z.string().min(1),
+  position: nonNegativeIntegerSchema
+}).strict();
+const snakeEdgeObjectSchema = z.object({
+  type: z.literal("snake-edge"),
+  fromSnakeId: z.string().min(1),
+  toSnakeId: z.string().min(1),
+  weight: z.number()
+}).strict();
+const summaryObjectSchema = z.object({
+  type: z.literal("summary"),
+  text: z.string()
+}).strict();
+const mentionObjectSchema = z.object({
+  type: z.literal("mention"),
+  id: z.string().min(1),
+  fragmentId: nonNegativeIntegerSchema.optional(),
+  sentenceIndex: nonNegativeIntegerSchema.optional(),
+  rangeStart: nonNegativeIntegerSchema,
+  rangeEnd: nonNegativeIntegerSchema,
+  surface: z.string().min(1),
+  qid: qidSchema,
+  confidence: optionalConfidenceSchema,
+  note: z.string().optional()
+}).strict();
+const mentionLinkObjectSchema = z.object({
+  type: z.literal("mention-link"),
+  id: z.string().min(1),
+  sourceMentionId: z.string().min(1),
+  targetMentionId: z.string().min(1),
+  predicate: z.string().min(1),
+  evidenceSentenceIndexes: z.array(nonNegativeIntegerSchema).min(1),
+  confidence: optionalConfidenceSchema,
+  note: z.string().optional()
+}).strict();
+const endObjectSchema = z.object({
+  type: z.literal("end")
+}).strict();
+const wikgObjectSchema = z.discriminatedUnion("type", [
+  metaObjectSchema,
+  parameterObjectSchema,
+  sourceFragmentObjectSchema,
+  readingChunkObjectSchema,
+  readingEdgeObjectSchema,
+  fragmentGroupObjectSchema,
+  snakeObjectSchema,
+  snakeChunkObjectSchema,
+  snakeEdgeObjectSchema,
+  summaryObjectSchema,
+  mentionObjectSchema,
+  mentionLinkObjectSchema,
+  endObjectSchema
+]);
+function parseWikgObject(record) {
+  return wikgObjectSchema.parse(record);
+}
+async function writeWikgObjectsToJsonl(path, objects) {
+  const stream = createWriteStream(path, { encoding: "utf8", flags: "wx" });
+  try {
+    for await (const object of objects) {
+      await writeLine(stream, `${JSON.stringify(parseWikgObject(object))}
+`);
+    }
+  } finally {
+    await closeWritableStream(stream);
+  }
+}
+async function* readWikgObjectsFromJsonl(path) {
+  const lines = createInterface({
+    crlfDelay: Infinity,
+    input: createReadStream(path, { encoding: "utf8" })
+  });
+  let lineNumber = 0;
+  for await (const line of lines) {
+    lineNumber += 1;
+    if (line.trim() === "") {
+      continue;
+    }
+    try {
+      yield parseWikgObject(JSON.parse(line));
+    } catch (error) {
+      throw new Error(
+        `Invalid WikgObject JSONL record at ${path}:${lineNumber}`,
+        {
+          cause: error
+        }
+      );
+    }
+  }
+}
+async function* createChapterKnowledgeGraphObjectStream(input) {
+  yield {
+    chapterId: input.chapterId,
+    schemaVersion: WIKG_OBJECT_SCHEMA_VERSION,
+    stream: "knowledge-graph",
+    type: "meta"
+  };
+  if (input.parameter !== void 0) {
+    yield {
+      ...input.parameter.language === void 0 ? {} : { language: input.parameter.language },
+      prompt: input.parameter.prompt,
+      scope: "knowledge-graph",
+      type: "parameter"
+    };
+  }
+  for await (const mention of input.mentions) {
+    if (mention.chapterId !== input.chapterId) {
+      throw new Error(
+        `Mention ${mention.id} belongs to chapter ${mention.chapterId}, expected chapter ${input.chapterId}.`
+      );
+    }
+    yield mentionRecordToObject(mention);
+  }
+  for await (const link of input.mentionLinks) {
+    yield mentionLinkRecordToObject(input.chapterId, link);
+  }
+  yield { type: "end" };
+}
+async function collectChapterKnowledgeGraphObjects(chapterId, objects) {
+  const mentions = [];
+  const mentionLinks = [];
+  let parameter;
+  let sawMeta = false;
+  let sawEnd = false;
+  for await (const object of objects) {
+    switch (object.type) {
+      case "meta":
+        if (object.chapterId !== chapterId) {
+          throw new Error(
+            `WikgObject stream belongs to chapter ${object.chapterId}, expected chapter ${chapterId}.`
+          );
+        }
+        if (object.stream !== "knowledge-graph") {
+          throw new Error(
+            `Expected knowledge-graph stream, received ${object.stream}.`
+          );
+        }
+        sawMeta = true;
+        break;
+      case "parameter":
+        if (object.scope === "knowledge-graph") {
+          parameter = object;
+        }
+        break;
+      case "mention":
+        mentions.push(mentionObjectToRecord(chapterId, object));
+        break;
+      case "mention-link":
+        mentionLinks.push(mentionLinkObjectToRecord(chapterId, object));
+        break;
+      case "end":
+        sawEnd = true;
+        break;
+      default:
+        throw new Error(
+          `Unexpected ${object.type} record in knowledge graph stream.`
+        );
+    }
+  }
+  if (!sawMeta) {
+    throw new Error("WikgObject stream is missing a meta record.");
+  }
+  if (!sawEnd) {
+    throw new Error("WikgObject stream is missing an end record.");
+  }
+  return {
+    mentionLinks,
+    mentions,
+    ...parameter === void 0 ? {} : { parameter }
+  };
+}
+async function* createChapterReadingGraphObjectStream(input) {
+  yield {
+    chapterId: input.chapterId,
+    schemaVersion: WIKG_OBJECT_SCHEMA_VERSION,
+    stream: "reading-graph",
+    type: "meta"
+  };
+  if (input.parameter !== void 0) {
+    yield {
+      ...input.parameter.language === void 0 ? {} : { language: input.parameter.language },
+      prompt: input.parameter.prompt,
+      scope: "reading-graph",
+      type: "parameter"
+    };
+  }
+  for (const fragment of await readSerialFragments(
+    input.document,
+    input.chapterId
+  )) {
+    yield sourceFragmentRecordToObject(fragment);
+  }
+  const chunkIds = /* @__PURE__ */ new Map();
+  let chunkIndex = 0;
+  for (const chunk of await input.document.chunks.listBySerial(
+    input.chapterId
+  )) {
+    const id = `chunk-${chunkIndex}`;
+    chunkIndex += 1;
+    chunkIds.set(chunk.id, id);
+    yield chunkRecordToObject(input.chapterId, id, chunk);
+  }
+  for (const edge of await input.document.readingEdges.listBySerial(
+    input.chapterId
+  )) {
+    const fromChunkId = chunkIds.get(edge.fromId);
+    const toChunkId = chunkIds.get(edge.toId);
+    if (fromChunkId === void 0 || toChunkId === void 0) {
+      continue;
+    }
+    yield readingEdgeRecordToObject(fromChunkId, toChunkId, edge);
+  }
+  for (const group of await input.document.fragmentGroups.listBySerial(
+    input.chapterId
+  )) {
+    yield fragmentGroupRecordToObject(group);
+  }
+  const snakeIds = /* @__PURE__ */ new Map();
+  let snakeIndex = 0;
+  const snakes = await input.document.snakes.listBySerial(input.chapterId);
+  for (const snake of snakes) {
+    const id = `snake-${snakeIndex}`;
+    snakeIndex += 1;
+    snakeIds.set(snake.id, id);
+    yield snakeRecordToObject(id, snake);
+    for (const snakeChunk of await input.document.snakeChunks.listBySnake(
+      snake.id
+    )) {
+      const chunkId = chunkIds.get(snakeChunk.chunkId);
+      if (chunkId === void 0) {
+        continue;
+      }
+      yield {
+        chunkId,
+        position: snakeChunk.position,
+        snakeId: id,
+        type: "snake-chunk"
+      };
+    }
+  }
+  for (const edge of await input.document.snakeEdges.listBySerial(
+    input.chapterId
+  )) {
+    const fromSnakeId = snakeIds.get(edge.fromSnakeId);
+    const toSnakeId = snakeIds.get(edge.toSnakeId);
+    if (fromSnakeId === void 0 || toSnakeId === void 0) {
+      continue;
+    }
+    yield {
+      fromSnakeId,
+      toSnakeId,
+      type: "snake-edge",
+      weight: edge.weight
+    };
+  }
+  yield { type: "end" };
+}
+async function collectReadingGraphObjects(chapterId, objects) {
+  const chunks = [];
+  const fragmentGroups = [];
+  const fragments = [];
+  const readingEdges = [];
+  const snakeChunks = [];
+  const snakeEdges = [];
+  const snakes = [];
+  let parameter;
+  let sawMeta = false;
+  let sawEnd = false;
+  for await (const object of objects) {
+    switch (object.type) {
+      case "meta":
+        if (object.chapterId !== chapterId) {
+          throw new Error(
+            `WikgObject stream belongs to chapter ${object.chapterId}, expected chapter ${chapterId}.`
+          );
+        }
+        if (object.stream !== "reading-graph") {
+          throw new Error(
+            `Expected reading-graph stream, received ${object.stream}.`
+          );
+        }
+        sawMeta = true;
+        break;
+      case "parameter":
+        if (object.scope === "reading-graph") {
+          parameter = object;
+        }
+        break;
+      case "source-fragment":
+        fragments.push(sourceFragmentObjectToRecord(chapterId, object));
+        break;
+      case "reading-chunk":
+        chunks.push(object);
+        break;
+      case "reading-edge":
+        readingEdges.push(object);
+        break;
+      case "fragment-group":
+        fragmentGroups.push(object);
+        break;
+      case "snake":
+        snakes.push(object);
+        break;
+      case "snake-chunk":
+        snakeChunks.push(object);
+        break;
+      case "snake-edge":
+        snakeEdges.push(object);
+        break;
+      case "end":
+        sawEnd = true;
+        break;
+      default:
+        throw new Error(
+          `Unexpected ${object.type} record in reading graph stream.`
+        );
+    }
+  }
+  if (!sawMeta) {
+    throw new Error("WikgObject stream is missing a meta record.");
+  }
+  if (!sawEnd) {
+    throw new Error("WikgObject stream is missing an end record.");
+  }
+  validateReadingGraphReferences({
+    chunks,
+    readingEdges,
+    snakeChunks,
+    snakeEdges,
+    snakes
+  });
+  return {
+    chunks,
+    fragmentGroups,
+    fragments,
+    ...parameter === void 0 ? {} : { parameter },
+    readingEdges,
+    snakeChunks,
+    snakeEdges,
+    snakes
+  };
+}
+async function createSummaryInputSnapshotFromReadingGraphObjects(chapterId, objects) {
+  const graph = await collectReadingGraphObjects(chapterId, objects);
+  const chunkIdMap = /* @__PURE__ */ new Map();
+  const snakeIdMap = /* @__PURE__ */ new Map();
+  const chunks = graph.chunks.map((chunk, index) => {
+    const id = index + 1;
+    chunkIdMap.set(chunk.id, id);
+    return readingChunkObjectToRecord(chapterId, id, chunk);
+  });
+  const snakes = graph.snakes.map((snake, index) => {
+    const id = index + 1;
+    snakeIdMap.set(snake.id, id);
+    return snakeObjectToRecord(chapterId, id, snake);
+  });
+  return {
+    chunks,
+    fragmentGroups: graph.fragmentGroups.map(
+      (group) => fragmentGroupObjectToRecord(chapterId, group)
+    ),
+    fragments: graph.fragments,
+    readingEdges: graph.readingEdges.map(
+      (edge) => readingEdgeObjectToRecord(chunkIdMap, edge)
+    ),
+    serial: {
+      documentOrder: chapterId,
+      id: chapterId,
+      knowledgeGraphReady: false,
+      revision: 0,
+      topologyReady: true
+    },
+    snakeChunks: graph.snakeChunks.map(
+      (snakeChunk) => snakeChunkObjectToRecord(chunkIdMap, snakeIdMap, snakeChunk)
+    ),
+    snakeEdges: graph.snakeEdges.map(
+      (edge) => snakeEdgeObjectToRecord(snakeIdMap, edge)
+    ),
+    snakes
+  };
+}
+function graphParameterRecordToObject(scope, parameter) {
+  return {
+    ...parameter.language === void 0 ? {} : { language: parameter.language },
+    prompt: parameter.prompt,
+    scope,
+    type: "parameter"
+  };
+}
+function mentionRecordToObject(record) {
+  return {
+    ...record.confidence === void 0 ? {} : { confidence: record.confidence },
+    ...record.fragmentId === void 0 ? {} : { fragmentId: record.fragmentId },
+    id: record.id,
+    ...record.note === void 0 ? {} : { note: record.note },
+    qid: record.qid,
+    rangeEnd: record.rangeEnd,
+    rangeStart: record.rangeStart,
+    ...record.sentenceIndex === void 0 ? {} : { sentenceIndex: record.sentenceIndex },
+    surface: record.surface,
+    type: "mention"
+  };
+}
+function mentionObjectToRecord(chapterId, object) {
+  return {
+    chapterId,
+    ...object.confidence === void 0 ? {} : { confidence: object.confidence },
+    ...object.fragmentId === void 0 ? {} : { fragmentId: object.fragmentId },
+    id: object.id,
+    ...object.note === void 0 ? {} : { note: object.note },
+    qid: object.qid,
+    rangeEnd: object.rangeEnd,
+    rangeStart: object.rangeStart,
+    ...object.sentenceIndex === void 0 ? {} : { sentenceIndex: object.sentenceIndex },
+    surface: object.surface
+  };
+}
+function mentionLinkRecordToObject(chapterId, record) {
+  return {
+    ...record.confidence === void 0 ? {} : { confidence: record.confidence },
+    evidenceSentenceIndexes: record.evidenceSentenceIds.map((sentenceId) => {
+      if (sentenceId[0] !== chapterId) {
+        throw new Error(
+          `Mention link ${record.id} evidence sentence ${formatSentenceId(sentenceId)} is outside chapter ${chapterId}.`
+        );
+      }
+      return sentenceId[1];
+    }),
+    id: record.id,
+    ...record.note === void 0 ? {} : { note: record.note },
+    predicate: record.predicate,
+    sourceMentionId: record.sourceMentionId,
+    targetMentionId: record.targetMentionId,
+    type: "mention-link"
+  };
+}
+function mentionLinkObjectToRecord(chapterId, object) {
+  return {
+    ...object.confidence === void 0 ? {} : { confidence: object.confidence },
+    evidenceSentenceIds: object.evidenceSentenceIndexes.map(
+      (sentenceIndex) => [chapterId, sentenceIndex]
+    ),
+    id: object.id,
+    ...object.note === void 0 ? {} : { note: object.note },
+    predicate: object.predicate,
+    sourceMentionId: object.sourceMentionId,
+    targetMentionId: object.targetMentionId
+  };
+}
+function sourceFragmentRecordToObject(record) {
+  return {
+    fragmentId: record.fragmentId,
+    sentences: record.sentences.map((sentence) => ({
+      text: sentence.text,
+      wordsCount: sentence.wordsCount
+    })),
+    summary: record.summary,
+    type: "source-fragment"
+  };
+}
+function sourceFragmentObjectToRecord(chapterId, object) {
+  return {
+    fragmentId: object.fragmentId,
+    sentences: object.sentences,
+    serialId: chapterId,
+    summary: object.summary
+  };
+}
+function chunkRecordToObject(chapterId, id, record) {
+  return {
+    content: record.content,
+    generation: record.generation,
+    id,
+    ...record.importance === void 0 ? {} : { importance: record.importance },
+    label: record.label,
+    ...record.retention === void 0 ? {} : { retention: record.retention },
+    sentenceIndex: requireLocalSentenceIndex(chapterId, record.sentenceId),
+    sentenceIndexes: record.sentenceIds.map(
+      (sentenceId) => requireLocalSentenceIndex(chapterId, sentenceId)
+    ),
+    type: "reading-chunk",
+    weight: record.weight,
+    wordsCount: record.wordsCount
+  };
+}
+function readingChunkObjectToRecord(chapterId, id, object) {
+  return {
+    content: object.content,
+    generation: object.generation,
+    id,
+    ...object.importance === void 0 ? {} : { importance: object.importance },
+    label: object.label,
+    ...object.retention === void 0 ? {} : { retention: object.retention },
+    sentenceId: [chapterId, object.sentenceIndex],
+    sentenceIds: object.sentenceIndexes.map(
+      (sentenceIndex) => [chapterId, sentenceIndex]
+    ),
+    weight: object.weight,
+    wordsCount: object.wordsCount
+  };
+}
+function readingEdgeRecordToObject(fromChunkId, toChunkId, record) {
+  return {
+    fromChunkId,
+    ...record.strength === void 0 ? {} : { strength: record.strength },
+    toChunkId,
+    type: "reading-edge",
+    weight: record.weight
+  };
+}
+function readingEdgeObjectToRecord(chunkIdMap, object) {
+  return {
+    fromId: requireMappedId(chunkIdMap, object.fromChunkId, "chunk"),
+    ...object.strength === void 0 ? {} : { strength: object.strength },
+    toId: requireMappedId(chunkIdMap, object.toChunkId, "chunk"),
+    weight: object.weight
+  };
+}
+function fragmentGroupRecordToObject(record) {
+  return {
+    endSentenceIndex: record.endSentenceIndex,
+    groupId: record.groupId,
+    startSentenceIndex: record.startSentenceIndex,
+    type: "fragment-group"
+  };
+}
+function fragmentGroupObjectToRecord(chapterId, object) {
+  return {
+    endSentenceIndex: object.endSentenceIndex,
+    groupId: object.groupId,
+    serialId: chapterId,
+    startSentenceIndex: object.startSentenceIndex
+  };
+}
+function snakeRecordToObject(id, record) {
+  return {
+    firstLabel: record.firstLabel,
+    groupId: record.groupId,
+    id,
+    lastLabel: record.lastLabel,
+    localSnakeId: record.localSnakeId,
+    size: record.size,
+    type: "snake",
+    weight: record.weight,
+    wordsCount: record.wordsCount
+  };
+}
+function snakeObjectToRecord(chapterId, id, object) {
+  return {
+    firstLabel: object.firstLabel,
+    groupId: object.groupId,
+    id,
+    lastLabel: object.lastLabel,
+    localSnakeId: object.localSnakeId,
+    serialId: chapterId,
+    size: object.size,
+    weight: object.weight,
+    wordsCount: object.wordsCount
+  };
+}
+function snakeChunkObjectToRecord(chunkIdMap, snakeIdMap, object) {
+  return {
+    chunkId: requireMappedId(chunkIdMap, object.chunkId, "chunk"),
+    position: object.position,
+    snakeId: requireMappedId(snakeIdMap, object.snakeId, "snake")
+  };
+}
+function snakeEdgeObjectToRecord(snakeIdMap, object) {
+  return {
+    fromSnakeId: requireMappedId(snakeIdMap, object.fromSnakeId, "snake"),
+    toSnakeId: requireMappedId(snakeIdMap, object.toSnakeId, "snake"),
+    weight: object.weight
+  };
+}
+function validateReadingGraphReferences(input) {
+  const chunkIds = /* @__PURE__ */ new Set();
+  for (const chunk of input.chunks) {
+    if (chunkIds.has(chunk.id)) {
+      throw new Error(`Duplicate reading chunk id ${chunk.id}.`);
+    }
+    chunkIds.add(chunk.id);
+  }
+  const snakeIds = /* @__PURE__ */ new Set();
+  for (const snake of input.snakes) {
+    if (snakeIds.has(snake.id)) {
+      throw new Error(`Duplicate snake id ${snake.id}.`);
+    }
+    snakeIds.add(snake.id);
+  }
+  for (const edge of input.readingEdges) {
+    requireKnownId(chunkIds, edge.fromChunkId, "chunk");
+    requireKnownId(chunkIds, edge.toChunkId, "chunk");
+  }
+  for (const snakeChunk of input.snakeChunks) {
+    requireKnownId(snakeIds, snakeChunk.snakeId, "snake");
+    requireKnownId(chunkIds, snakeChunk.chunkId, "chunk");
+  }
+  for (const edge of input.snakeEdges) {
+    requireKnownId(snakeIds, edge.fromSnakeId, "snake");
+    requireKnownId(snakeIds, edge.toSnakeId, "snake");
+  }
+}
+function requireKnownId(ids, id, kind) {
+  if (!ids.has(id)) {
+    throw new Error(`Unknown ${kind} id ${id}.`);
+  }
+}
+function requireMappedId(ids, id, kind) {
+  const mapped = ids.get(id);
+  if (mapped === void 0) {
+    throw new Error(`Unknown ${kind} id ${id}.`);
+  }
+  return mapped;
+}
+function requireLocalSentenceIndex(chapterId, sentenceId) {
+  if (sentenceId[0] !== chapterId) {
+    throw new Error(
+      `Sentence ${formatSentenceId(sentenceId)} is outside chapter ${chapterId}.`
+    );
+  }
+  return sentenceId[1];
+}
+function formatSentenceId(sentenceId) {
+  return sentenceId.join(":");
+}
+async function writeLine(stream, line) {
+  await new Promise((resolveWrite, rejectWrite) => {
+    stream.write(line, (error) => {
+      if (error !== void 0 && error !== null) {
+        rejectWrite(error);
+        return;
+      }
+      resolveWrite();
+    });
+  });
+}
+async function closeWritableStream(stream) {
+  await new Promise((resolveClose, rejectClose) => {
+    stream.end((error) => {
+      if (error !== void 0 && error !== null) {
+        rejectClose(error);
+        return;
+      }
+      resolveClose();
+    });
+  });
+}
+export {
+  WIKG_OBJECT_SCHEMA_VERSION,
+  collectChapterKnowledgeGraphObjects,
+  collectReadingGraphObjects,
+  createChapterKnowledgeGraphObjectStream,
+  createChapterReadingGraphObjectStream,
+  createSummaryInputSnapshotFromReadingGraphObjects,
+  graphParameterRecordToObject,
+  parseWikgObject,
+  readWikgObjectsFromJsonl,
+  writeWikgObjectsToJsonl
+};
+//# sourceMappingURL=object-stream.js.map