@graphrefly/ts 0.0.1 → 0.0.3

package/dist/patterns/index.cjs

@@ -55,7 +55,12 @@ function depLatest(ctx, depIndex) {
   return ctx[CTX_DEP_CACHE]?.latest[depIndex];
 }
 
-// src/messaging/index.ts
+// src/messaging/utils.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/messaging/event-message.ts
 function eventMessageIssue(value) {
   if (!isObjectRecord(value)) {
     return eventIssue("event message must be an object");
@@ -80,25 +85,6 @@ function eventIssue(message) {
     source: "messageBus.eventMessage"
   };
 }
-var PROMPTS_TOPIC = "prompts";
-var RESPONSES_TOPIC = "responses";
-var INJECTIONS_TOPIC = "injections";
-var DEFERRED_TOPIC = "deferred";
-var SPAWNS_TOPIC = "spawns";
-var CONTEXT_TOPIC = "context";
-var TODOS_TOPIC = "todos";
-var STANDARD_TOPICS = Object.freeze([
-  PROMPTS_TOPIC,
-  RESPONSES_TOPIC,
-  INJECTIONS_TOPIC,
-  DEFERRED_TOPIC,
-  SPAWNS_TOPIC,
-  CONTEXT_TOPIC,
-  TODOS_TOPIC
-]);
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/patterns/event-flow.ts
 function eventFlow(graph, opts) {
@@ -624,466 +610,158 @@ function scoreAtLeast(score, min) {
   return Number.isFinite(score) && score >= min;
 }
 
-// src/patterns/semantic-memory-graph.ts
-function memoryRetrievalBundle(graph, opts) {
-  const name = opts.name ?? "memoryRetrieval";
-  const { fragments, query } = opts;
-  const snapshot = graph.node(
-    [fragments, query],
-    (ctx) => {
-      const state = ctx.state.get() ?? { evaluation: 0 };
-      state.evaluation += 1;
-      const rawFragments = depLatest(ctx, 0);
-      const rawQuery = depLatest(ctx, 1);
-      const queryValidation = validateMemoryRetrievalQuery(rawQuery);
-      const currentQuery = queryValidation.query;
-      const valid = [];
-      const seenIds = /* @__PURE__ */ new Set();
-      const errors = [...queryValidation.errors];
-      if (!Array.isArray(rawFragments)) {
-        errors.push({
-          code: "invalid-fragments-input",
-          message: "memoryRetrievalBundle: fragments input must be an array",
-          fragment: rawFragments
-        });
-      } else {
-        const length = safeArrayLength(rawFragments);
-        if (length === void 0) {
-          errors.push({
-            code: "invalid-fragments-input",
-            message: "memoryRetrievalBundle: fragments input length could not be read",
-            fragment: rawFragments
-          });
+// src/patterns/semantic-memory-graph-utils.ts
+function validateKnowledgeGraphPolicy(value) {
+  if (value === void 0) return { policy: void 0, errors: [] };
+  if (!isPlainObject(value)) {
+    return {
+      errors: [
+        {
+          code: "invalid-policy",
+          message: "knowledgeGraphReducerBundle: policy must be an object",
+          assertion: value
         }
-        for (let i = 0; i < (length ?? 0); i += 1) {
-          const result = validateAndSnapshotFragment(rawFragments, i);
-          if (result.error !== void 0) {
-            errors.push(result.error);
-            continue;
-          }
-          const fragment = result.fragment;
-          if (seenIds.has(fragment.id)) {
-            errors.push({
-              code: "duplicate-fragment-id",
-              message: "memoryRetrievalBundle: duplicate fragment id",
-              index: i,
-              fragment,
-              validationErrors: [`duplicate fragment id '${fragment.id}'`]
-            });
-            continue;
-          }
-          seenIds.add(fragment.id);
-          valid.push(fragment);
+      ]
+    };
+  }
+  const errors = [];
+  const policy = value;
+  if (policy.allowedPredicates !== void 0 && !isDenseArrayOf2(policy.allowedPredicates, (item) => typeof item === "string")) {
+    errors.push("allowedPredicates must be a readonly string array");
+  }
+  if (policy.requireEntityTypes !== void 0 && typeof policy.requireEntityTypes !== "boolean") {
+    errors.push("requireEntityTypes must be a boolean when present");
+  }
+  if (errors.length > 0) {
+    return {
+      errors: [
+        {
+          code: "invalid-policy",
+          message: "knowledgeGraphReducerBundle: policy is invalid",
+          assertion: value,
+          validationErrors: Object.freeze(errors)
         }
-      }
-      const ranked = errors.some((error) => !isRecoverableFragmentError(error)) ? [] : rankFragments(valid, currentQuery);
-      const cursor = Object.freeze({
-        evaluation: state.evaluation,
-        validFragments: valid.length,
-        invalidFragments: errors.filter(
-          (error) => error.code === "invalid-fragment" || error.code === "duplicate-fragment-id"
-        ).length,
-        resultCount: ranked.length
-      });
-      ctx.state.set(state);
-      const answer = Object.freeze({
-        query: currentQuery,
-        results: Object.freeze(ranked)
-      });
-      const status = Object.freeze({
-        state: statusState(errors, ranked.length),
-        query: currentQuery,
-        cursor
-      });
-      const indexed = Object.freeze({
-        ids: Object.freeze(valid.map((fragment) => fragment.id)),
-        byId: indexById(valid),
-        cursor
+      ]
+    };
+  }
+  return {
+    policy: Object.freeze({
+      ...policy.allowedPredicates === void 0 ? {} : { allowedPredicates: Object.freeze([...policy.allowedPredicates]) },
+      ...policy.requireEntityTypes === void 0 ? {} : { requireEntityTypes: policy.requireEntityTypes }
+    }),
+    errors: []
+  };
+}
+function reduceKnowledgeAssertions(value, policy) {
+  const assertions = [];
+  const errors = [];
+  const seenAssertions = /* @__PURE__ */ new Set();
+  if (!Array.isArray(value)) {
+    return {
+      assertions,
+      entities: [],
+      relations: [],
+      topics: [],
+      index: emptyKnowledgeGraphIndex(),
+      errors: [
+        {
+          code: "invalid-assertions-input",
+          message: "knowledgeGraphReducerBundle: assertions input must be an array",
+          assertion: value
+        }
+      ],
+      invalidAssertions: 0
+    };
+  }
+  const length = safeArrayLength(value);
+  if (length === void 0) {
+    return {
+      assertions,
+      entities: [],
+      relations: [],
+      topics: [],
+      index: emptyKnowledgeGraphIndex(),
+      errors: [
+        {
+          code: "invalid-assertions-input",
+          message: "knowledgeGraphReducerBundle: assertions input length could not be read",
+          assertion: value
+        }
+      ],
+      invalidAssertions: 0
+    };
+  }
+  for (let i = 0; i < length; i += 1) {
+    const result = validateKnowledgeAssertion(value[i], i, policy);
+    if (result.error !== void 0) {
+      errors.push(result.error);
+      continue;
+    }
+    const assertion = result.assertion;
+    if (seenAssertions.has(assertion.id)) {
+      errors.push({
+        code: "duplicate-assertion-id",
+        message: "knowledgeGraphReducerBundle: duplicate assertion id",
+        index: i,
+        assertionId: assertion.id,
+        assertion,
+        validationErrors: Object.freeze([`duplicate assertion id '${assertion.id}'`])
       });
-      const errorFacts = Object.freeze(
-        errors.map(
-          (error) => Object.freeze({
-            ...error,
-            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
-            cursor
-          })
-        )
-      );
-      ctx.down([
-        [
-          "DATA",
-          Object.freeze({
-            fragments: Object.freeze([...valid]),
-            indexed,
-            ranked: answer,
-            status,
-            errors: errorFacts,
-            cursor
-          })
-        ]
-      ]);
-    },
-    {
-      name: `${name}/snapshot`,
-      factory: "memoryRetrievalSnapshot",
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
+      continue;
     }
-  );
+    seenAssertions.add(assertion.id);
+    assertions.push(assertion);
+  }
+  const materialized = materializeKnowledgeGraph(assertions);
   return {
-    input: { fragments, query },
-    snapshot,
-    fragments: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/fragments`,
-      "memoryRetrievalFragments",
-      (fact) => fact.fragments
-    ),
-    indexed: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/indexed`,
-      "memoryRetrievalIndexed",
-      (fact) => fact.indexed
-    ),
-    ranked: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/ranked`,
-      "memoryRetrievalRanked",
-      (fact) => fact.ranked
-    ),
-    status: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/status`,
-      "memoryRetrievalStatus",
-      (fact) => fact.status
-    ),
-    errors: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/errors`,
-      "memoryRetrievalErrors",
-      (fact) => fact.errors
-    ),
-    cursor: retrievalProjection(
-      graph,
-      snapshot,
-      `${name}/cursor`,
-      "memoryRetrievalCursor",
-      (fact) => fact.cursor
-    )
+    assertions: Object.freeze(assertions),
+    ...materialized,
+    errors,
+    invalidAssertions: errors.filter((error) => error.code !== "invalid-policy").length
   };
 }
-function knowledgeGraphReducerBundle(graph, opts) {
-  const name = opts.name ?? "knowledgeGraph";
-  const deps = opts.policy === void 0 ? [opts.assertions] : [opts.assertions, opts.policy];
-  const snapshot = graph.node(
-    deps,
-    (ctx) => {
-      const state = ctx.state.get() ?? { evaluation: 0 };
-      state.evaluation += 1;
-      const policy = validateKnowledgeGraphPolicy(
-        opts.policy === void 0 ? void 0 : depLatest(ctx, 1)
-      );
-      const reduced = reduceKnowledgeAssertions(depLatest(ctx, 0), policy.policy);
-      const pendingErrors = [...policy.errors, ...reduced.errors];
-      const cursor = Object.freeze({
-        evaluation: state.evaluation,
-        validAssertions: reduced.assertions.length,
-        invalidAssertions: reduced.invalidAssertions,
-        entityCount: reduced.entities.length,
-        relationCount: reduced.relations.length,
-        predicateCount: reduced.topics.length
-      });
-      const errors = Object.freeze(
-        pendingErrors.map(
-          (error) => Object.freeze({
-            ...error,
-            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
-            cursor
-          })
-        )
-      );
-      const status = Object.freeze({
-        state: reduced.assertions.length === 0 && errors.length === 0 ? "empty" : errors.length === 0 ? "ready" : reduced.assertions.length > 0 ? "partial" : "error",
-        cursor
-      });
-      ctx.state.set(state);
-      ctx.down([
-        [
-          "DATA",
-          Object.freeze({
-            assertions: Object.freeze(reduced.assertions),
-            entities: Object.freeze(reduced.entities),
-            relations: Object.freeze(reduced.relations),
-            topics: Object.freeze(reduced.topics),
-            index: reduced.index,
-            status,
-            errors,
-            cursor
-          })
-        ]
-      ]);
-    },
-    {
-      name: `${name}/snapshot`,
-      factory: "knowledgeGraphReducerSnapshot",
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-  return {
-    input: {
-      assertions: opts.assertions,
-      ...opts.policy === void 0 ? {} : { policy: opts.policy }
-    },
-    snapshot,
-    assertions: kgProjection(
-      graph,
-      snapshot,
-      `${name}/assertions`,
-      "knowledgeGraphAssertions",
-      (fact) => fact.assertions
-    ),
-    entities: kgProjection(
-      graph,
-      snapshot,
-      `${name}/entities`,
-      "knowledgeGraphEntities",
-      (fact) => fact.entities
-    ),
-    relations: kgProjection(
-      graph,
-      snapshot,
-      `${name}/relations`,
-      "knowledgeGraphRelations",
-      (fact) => fact.relations
-    ),
-    topics: kgProjection(
-      graph,
-      snapshot,
-      `${name}/topics`,
-      "knowledgeGraphTopics",
-      (fact) => fact.topics
-    ),
-    index: kgProjection(
-      graph,
-      snapshot,
-      `${name}/index`,
-      "knowledgeGraphIndex",
-      (fact) => fact.index
-    ),
-    status: kgProjection(
-      graph,
-      snapshot,
-      `${name}/status`,
-      "knowledgeGraphStatus",
-      (fact) => fact.status
-    ),
-    errors: kgProjection(
-      graph,
-      snapshot,
-      `${name}/errors`,
-      "knowledgeGraphErrors",
-      (fact) => fact.errors
-    ),
-    cursor: kgProjection(
-      graph,
-      snapshot,
-      `${name}/cursor`,
-      "knowledgeGraphCursor",
-      (fact) => fact.cursor
-    )
-  };
-}
-function retrievalProjection(graph, snapshot, name, factory, select) {
-  return graph.node(
-    [snapshot],
-    (ctx) => {
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const fact = raw;
-        const selected = select(fact);
-        if (selected !== void 0) ctx.down([["DATA", selected]]);
-      }
-    },
-    {
-      name,
-      factory,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-}
-function kgProjection(graph, snapshot, name, factory, select) {
-  return graph.node(
-    [snapshot],
-    (ctx) => {
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        ctx.down([["DATA", select(raw)]]);
-      }
-    },
-    {
-      name,
-      factory,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-}
-function validateKnowledgeGraphPolicy(value) {
-  if (value === void 0) return { policy: void 0, errors: [] };
+function validateKnowledgeAssertion(value, index, policy) {
   if (!isPlainObject(value)) {
-    return {
-      errors: [
-        {
-          code: "invalid-policy",
-          message: "knowledgeGraphReducerBundle: policy must be an object",
-          assertion: value
-        }
-      ]
-    };
+    return invalidKnowledgeAssertion(index, value, ["assertion must be an object"]);
   }
+  const raw = value;
   const errors = [];
-  const policy = value;
-  if (policy.allowedPredicates !== void 0 && !isDenseArrayOf2(policy.allowedPredicates, (item) => typeof item === "string")) {
-    errors.push("allowedPredicates must be a readonly string array");
+  if (!isNonEmptyString(raw.id)) errors.push("id must be a non-empty string");
+  if (!isKnowledgeSubject(raw.subject)) errors.push("subject.id must be a non-empty string");
+  if (!isNonEmptyString(raw.predicate)) errors.push("predicate must be a non-empty string");
+  if (!isKnowledgeObject(raw.object)) errors.push("object shape is invalid");
+  if (raw.confidence !== void 0 && (!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)) {
+    errors.push("confidence must be a finite number in [0, 1] when present");
   }
-  if (policy.requireEntityTypes !== void 0 && typeof policy.requireEntityTypes !== "boolean") {
-    errors.push("requireEntityTypes must be a boolean when present");
+  if (raw.sources !== void 0 && !isDenseArrayOf2(raw.sources, isNonEmptyString)) {
+    errors.push("sources must be a readonly non-empty string array when present");
+  }
+  if (policy?.allowedPredicates !== void 0 && !policy.allowedPredicates.includes(raw.predicate ?? "")) {
+    errors.push(`predicate '${String(raw.predicate)}' is not allowed by policy`);
+  }
+  if (policy?.requireEntityTypes === true) {
+    if (isKnowledgeSubject(raw.subject) && raw.subject.type === void 0) {
+      errors.push("subject.type is required by policy");
+    }
+    if (isKnowledgeObject(raw.object) && raw.object.kind === "entity" && raw.object.type === void 0) {
+      errors.push("object.type is required by policy for entity objects");
+    }
   }
   if (errors.length > 0) {
-    return {
-      errors: [
-        {
-          code: "invalid-policy",
-          message: "knowledgeGraphReducerBundle: policy is invalid",
-          assertion: value,
-          validationErrors: Object.freeze(errors)
-        }
-      ]
-    };
+    return invalidKnowledgeAssertion(index, value, errors, raw.id);
   }
   return {
-    policy: Object.freeze({
-      ...policy.allowedPredicates === void 0 ? {} : { allowedPredicates: Object.freeze([...policy.allowedPredicates]) },
-      ...policy.requireEntityTypes === void 0 ? {} : { requireEntityTypes: policy.requireEntityTypes }
-    }),
-    errors: []
-  };
-}
-function reduceKnowledgeAssertions(value, policy) {
-  const assertions = [];
-  const errors = [];
-  const seenAssertions = /* @__PURE__ */ new Set();
-  if (!Array.isArray(value)) {
-    return {
-      assertions,
-      entities: [],
-      relations: [],
-      topics: [],
-      index: emptyKnowledgeGraphIndex(),
-      errors: [
-        {
-          code: "invalid-assertions-input",
-          message: "knowledgeGraphReducerBundle: assertions input must be an array",
-          assertion: value
-        }
-      ],
-      invalidAssertions: 0
-    };
-  }
-  const length = safeArrayLength(value);
-  if (length === void 0) {
-    return {
-      assertions,
-      entities: [],
-      relations: [],
-      topics: [],
-      index: emptyKnowledgeGraphIndex(),
-      errors: [
-        {
-          code: "invalid-assertions-input",
-          message: "knowledgeGraphReducerBundle: assertions input length could not be read",
-          assertion: value
-        }
-      ],
-      invalidAssertions: 0
-    };
-  }
-  for (let i = 0; i < length; i += 1) {
-    const result = validateKnowledgeAssertion(value[i], i, policy);
-    if (result.error !== void 0) {
-      errors.push(result.error);
-      continue;
-    }
-    const assertion = result.assertion;
-    if (seenAssertions.has(assertion.id)) {
-      errors.push({
-        code: "duplicate-assertion-id",
-        message: "knowledgeGraphReducerBundle: duplicate assertion id",
-        index: i,
-        assertionId: assertion.id,
-        assertion,
-        validationErrors: Object.freeze([`duplicate assertion id '${assertion.id}'`])
-      });
-      continue;
-    }
-    seenAssertions.add(assertion.id);
-    assertions.push(assertion);
-  }
-  const materialized = materializeKnowledgeGraph(assertions);
-  return {
-    assertions: Object.freeze(assertions),
-    ...materialized,
-    errors,
-    invalidAssertions: errors.filter((error) => error.code !== "invalid-policy").length
-  };
-}
-function validateKnowledgeAssertion(value, index, policy) {
-  if (!isPlainObject(value)) {
-    return invalidKnowledgeAssertion(index, value, ["assertion must be an object"]);
-  }
-  const raw = value;
-  const errors = [];
-  if (!isNonEmptyString(raw.id)) errors.push("id must be a non-empty string");
-  if (!isKnowledgeSubject(raw.subject)) errors.push("subject.id must be a non-empty string");
-  if (!isNonEmptyString(raw.predicate)) errors.push("predicate must be a non-empty string");
-  if (!isKnowledgeObject(raw.object)) errors.push("object shape is invalid");
-  if (raw.confidence !== void 0 && (!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)) {
-    errors.push("confidence must be a finite number in [0, 1] when present");
-  }
-  if (raw.sources !== void 0 && !isDenseArrayOf2(raw.sources, isNonEmptyString)) {
-    errors.push("sources must be a readonly non-empty string array when present");
-  }
-  if (policy?.allowedPredicates !== void 0 && !policy.allowedPredicates.includes(raw.predicate ?? "")) {
-    errors.push(`predicate '${String(raw.predicate)}' is not allowed by policy`);
-  }
-  if (policy?.requireEntityTypes === true) {
-    if (isKnowledgeSubject(raw.subject) && raw.subject.type === void 0) {
-      errors.push("subject.type is required by policy");
-    }
-    if (isKnowledgeObject(raw.object) && raw.object.kind === "entity" && raw.object.type === void 0) {
-      errors.push("object.type is required by policy for entity objects");
-    }
-  }
-  if (errors.length > 0) {
-    return invalidKnowledgeAssertion(index, value, errors, raw.id);
-  }
-  return {
-    assertion: Object.freeze({
-      id: raw.id,
-      ...raw.recordId === void 0 ? {} : { recordId: raw.recordId },
-      ...raw.fragmentId === void 0 ? {} : { fragmentId: raw.fragmentId },
-      subject: snapshotSubject(raw.subject),
-      predicate: raw.predicate,
-      object: snapshotObject(raw.object),
-      ...raw.confidence === void 0 ? {} : { confidence: raw.confidence },
-      sources: Object.freeze([...raw.sources ?? []]),
-      ...raw.provenance === void 0 ? {} : { provenance: raw.provenance }
-    })
+    assertion: Object.freeze({
+      id: raw.id,
+      ...raw.recordId === void 0 ? {} : { recordId: raw.recordId },
+      ...raw.fragmentId === void 0 ? {} : { fragmentId: raw.fragmentId },
+      subject: snapshotSubject(raw.subject),
+      predicate: raw.predicate,
+      object: snapshotObject(raw.object),
+      ...raw.confidence === void 0 ? {} : { confidence: raw.confidence },
+      sources: Object.freeze([...raw.sources ?? []]),
+      ...raw.provenance === void 0 ? {} : { provenance: raw.provenance }
+    })
   };
 }
 function invalidKnowledgeAssertion(index, assertion, validationErrors, assertionId) {
@@ -1430,6 +1108,316 @@ function compareBigIntDesc2(a, b) {
   if (a === b) return 0;
   return a > b ? -1 : 1;
 }
+
+// src/patterns/semantic-memory-graph.ts
+function memoryRetrievalBundle(graph, opts) {
+  const name = opts.name ?? "memoryRetrieval";
+  const { fragments, query } = opts;
+  const snapshot = graph.node(
+    [fragments, query],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const rawFragments = depLatest(ctx, 0);
+      const rawQuery = depLatest(ctx, 1);
+      const queryValidation = validateMemoryRetrievalQuery(rawQuery);
+      const currentQuery = queryValidation.query;
+      const valid = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      const errors = [...queryValidation.errors];
+      if (!Array.isArray(rawFragments)) {
+        errors.push({
+          code: "invalid-fragments-input",
+          message: "memoryRetrievalBundle: fragments input must be an array",
+          fragment: rawFragments
+        });
+      } else {
+        const length = safeArrayLength(rawFragments);
+        if (length === void 0) {
+          errors.push({
+            code: "invalid-fragments-input",
+            message: "memoryRetrievalBundle: fragments input length could not be read",
+            fragment: rawFragments
+          });
+        }
+        for (let i = 0; i < (length ?? 0); i += 1) {
+          const result = validateAndSnapshotFragment(rawFragments, i);
+          if (result.error !== void 0) {
+            errors.push(result.error);
+            continue;
+          }
+          const fragment = result.fragment;
+          if (seenIds.has(fragment.id)) {
+            errors.push({
+              code: "duplicate-fragment-id",
+              message: "memoryRetrievalBundle: duplicate fragment id",
+              index: i,
+              fragment,
+              validationErrors: [`duplicate fragment id '${fragment.id}'`]
+            });
+            continue;
+          }
+          seenIds.add(fragment.id);
+          valid.push(fragment);
+        }
+      }
+      const ranked = errors.some((error) => !isRecoverableFragmentError(error)) ? [] : rankFragments(valid, currentQuery);
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validFragments: valid.length,
+        invalidFragments: errors.filter(
+          (error) => error.code === "invalid-fragment" || error.code === "duplicate-fragment-id"
+        ).length,
+        resultCount: ranked.length
+      });
+      ctx.state.set(state);
+      const answer = Object.freeze({
+        query: currentQuery,
+        results: Object.freeze(ranked)
+      });
+      const status = Object.freeze({
+        state: statusState(errors, ranked.length),
+        query: currentQuery,
+        cursor
+      });
+      const indexed = Object.freeze({
+        ids: Object.freeze(valid.map((fragment) => fragment.id)),
+        byId: indexById(valid),
+        cursor
+      });
+      const errorFacts = Object.freeze(
+        errors.map(
+          (error) => Object.freeze({
+            ...error,
+            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
+            cursor
+          })
+        )
+      );
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            fragments: Object.freeze([...valid]),
+            indexed,
+            ranked: answer,
+            status,
+            errors: errorFacts,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/snapshot`,
+      factory: "memoryRetrievalSnapshot",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { fragments, query },
+    snapshot,
+    fragments: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/fragments`,
+      "memoryRetrievalFragments",
+      (fact) => fact.fragments
+    ),
+    indexed: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/indexed`,
+      "memoryRetrievalIndexed",
+      (fact) => fact.indexed
+    ),
+    ranked: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/ranked`,
+      "memoryRetrievalRanked",
+      (fact) => fact.ranked
+    ),
+    status: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/status`,
+      "memoryRetrievalStatus",
+      (fact) => fact.status
+    ),
+    errors: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/errors`,
+      "memoryRetrievalErrors",
+      (fact) => fact.errors
+    ),
+    cursor: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/cursor`,
+      "memoryRetrievalCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function knowledgeGraphReducerBundle(graph, opts) {
+  const name = opts.name ?? "knowledgeGraph";
+  const deps = opts.policy === void 0 ? [opts.assertions] : [opts.assertions, opts.policy];
+  const snapshot = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const policy = validateKnowledgeGraphPolicy(
+        opts.policy === void 0 ? void 0 : depLatest(ctx, 1)
+      );
+      const reduced = reduceKnowledgeAssertions(depLatest(ctx, 0), policy.policy);
+      const pendingErrors = [...policy.errors, ...reduced.errors];
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validAssertions: reduced.assertions.length,
+        invalidAssertions: reduced.invalidAssertions,
+        entityCount: reduced.entities.length,
+        relationCount: reduced.relations.length,
+        predicateCount: reduced.topics.length
+      });
+      const errors = Object.freeze(
+        pendingErrors.map(
+          (error) => Object.freeze({
+            ...error,
+            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
+            cursor
+          })
+        )
+      );
+      const status = Object.freeze({
+        state: reduced.assertions.length === 0 && errors.length === 0 ? "empty" : errors.length === 0 ? "ready" : reduced.assertions.length > 0 ? "partial" : "error",
+        cursor
+      });
+      ctx.state.set(state);
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            assertions: Object.freeze(reduced.assertions),
+            entities: Object.freeze(reduced.entities),
+            relations: Object.freeze(reduced.relations),
+            topics: Object.freeze(reduced.topics),
+            index: reduced.index,
+            status,
+            errors,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/snapshot`,
+      factory: "knowledgeGraphReducerSnapshot",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: {
+      assertions: opts.assertions,
+      ...opts.policy === void 0 ? {} : { policy: opts.policy }
+    },
+    snapshot,
+    assertions: kgProjection(
+      graph,
+      snapshot,
+      `${name}/assertions`,
+      "knowledgeGraphAssertions",
+      (fact) => fact.assertions
+    ),
+    entities: kgProjection(
+      graph,
+      snapshot,
+      `${name}/entities`,
+      "knowledgeGraphEntities",
+      (fact) => fact.entities
+    ),
+    relations: kgProjection(
+      graph,
+      snapshot,
+      `${name}/relations`,
+      "knowledgeGraphRelations",
+      (fact) => fact.relations
+    ),
+    topics: kgProjection(
+      graph,
+      snapshot,
+      `${name}/topics`,
+      "knowledgeGraphTopics",
+      (fact) => fact.topics
+    ),
+    index: kgProjection(
+      graph,
+      snapshot,
+      `${name}/index`,
+      "knowledgeGraphIndex",
+      (fact) => fact.index
+    ),
+    status: kgProjection(
+      graph,
+      snapshot,
+      `${name}/status`,
+      "knowledgeGraphStatus",
+      (fact) => fact.status
+    ),
+    errors: kgProjection(
+      graph,
+      snapshot,
+      `${name}/errors`,
+      "knowledgeGraphErrors",
+      (fact) => fact.errors
+    ),
+    cursor: kgProjection(
+      graph,
+      snapshot,
+      `${name}/cursor`,
+      "knowledgeGraphCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function retrievalProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const fact = raw;
+        const selected = select(fact);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function kgProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", select(raw)]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   admissionFilter3D,