@graphrefly/ts 0.0.0 → 0.0.2

package/dist/patterns/index.cjs

@@ -23,6 +23,8 @@ __export(patterns_exports, {
   admissionFilter3D: () => admissionFilter3D,
   admissionScored: () => admissionScored,
   cosineSimilarity: () => cosineSimilarity,
+  eventFlow: () => eventFlow,
+  eventFlowProjection: () => eventFlowProjection,
   filterMemoryFragments: () => filterMemoryFragments,
   isMemoryFragment: () => isMemoryFragment,
   knowledgeGraphReducerBundle: () => knowledgeGraphReducerBundle,
@@ -35,6 +37,411 @@ __export(patterns_exports, {
 });
 module.exports = __toCommonJS(patterns_exports);
 
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+function depLatest(ctx, depIndex) {
+  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+
+// 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");
+  }
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    return eventIssue("event message id must be a non-empty string");
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    return eventIssue("event message type must be a non-empty string");
+  }
+  if (!("payload" in value)) {
+    return eventIssue("event message payload field is required");
+  }
+  return void 0;
+}
+function eventIssue(message) {
+  return {
+    kind: "issue",
+    code: "malformed-event-message",
+    message,
+    severity: "error",
+    source: "messageBus.eventMessage"
+  };
+}
+
+// src/patterns/event-flow.ts
+function eventFlow(graph, opts) {
+  const name = opts.name ?? opts.flowId ?? "eventFlow";
+  const flowId = opts.flowId ?? name;
+  const now = opts.now ?? Date.now;
+  const sources = normalizeSources(opts.sources);
+  const runtime = graph.node(
+    sources.map((source) => source.node),
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        recordSeq: 0,
+        auditSeq: 0,
+        highWater: /* @__PURE__ */ new Map()
+      };
+      ctx.state.persist(true);
+      for (let i = 0; i < sources.length; i++) {
+        const source = sources[i];
+        for (const raw of depBatch(ctx, i) ?? []) {
+          reduceEventSource(
+            raw,
+            source.source,
+            flowId,
+            now(),
+            state,
+            (fact) => ctx.down([["DATA", fact]])
+          );
+        }
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "eventFlowRuntime",
+      meta: { flowId, sources: sources.map((source) => source.source) },
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    records: runtimeProjection(graph, runtime, "record", `${name}/records`, "eventFlowRecords"),
+    status: runtimeProjection(graph, runtime, "status", `${name}/status`, "eventFlowStatus"),
+    issues: runtimeProjection(graph, runtime, "issue", `${name}/issues`, "eventFlowIssues"),
+    audit: runtimeProjection(graph, runtime, "audit", `${name}/audit`, "eventFlowAudit"),
+    highWater: runtimeProjection(
+      graph,
+      runtime,
+      "high-water",
+      `${name}/highWater`,
+      "eventFlowHighWater"
+    )
+  };
+}
+function eventFlowProjection(graph, flowOrRecords, opts) {
+  const records = isEventFlowBundle(flowOrRecords) ? flowOrRecords.records : flowOrRecords;
+  const name = opts.name ?? opts.projectionId ?? "eventFlowProjection";
+  const projectionId = opts.projectionId ?? name;
+  const now = opts.now ?? Date.now;
+  const runtime = graph.node(
+    [records],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        value: opts.initial,
+        highWater: emptyHighWater(projectionId),
+        sourceHighWater: /* @__PURE__ */ new Map()
+      };
+      ctx.state.persist(true);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const record = raw;
+        try {
+          state.value = opts.reduce(state.value, record);
+          state.highWater = projectionHighWater(projectionId, record, state.sourceHighWater);
+          ctx.down([
+            ["DATA", { kind: "frame", frame: { state: state.value, highWater: state.highWater } }],
+            [
+              "DATA",
+              {
+                kind: "status",
+                status: {
+                  kind: "projected",
+                  projectionId,
+                  recordSeq: record.recordSeq,
+                  timestampMs: now()
+                }
+              }
+            ],
+            ["DATA", { kind: "high-water", highWater: state.highWater }]
+          ]);
+        } catch (error) {
+          const issue = dataIssue(
+            "event-flow-projection-threw",
+            error instanceof Error ? error.message : "eventFlowProjection reducer threw",
+            { projectionId, record }
+          );
+          ctx.down([
+            ["DATA", { kind: "issue", issue }],
+            [
+              "DATA",
+              {
+                kind: "status",
+                status: {
+                  kind: "rejected",
+                  projectionId,
+                  recordSeq: record.recordSeq,
+                  issueCode: issue.code,
+                  timestampMs: now()
+                }
+              }
+            ]
+          ]);
+        }
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "eventFlowProjectionRuntime",
+      meta: { projectionId },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    frames: projectionRuntime(
+      graph,
+      runtime,
+      "frame",
+      `${name}/frames`,
+      "eventFlowProjectionFrames"
+    ),
+    snapshot: projectionRuntime(
+      graph,
+      runtime,
+      "frame",
+      `${name}/snapshot`,
+      "eventFlowProjectionSnapshot",
+      (fact) => fact.frame.state
+    ),
+    status: projectionRuntime(
+      graph,
+      runtime,
+      "status",
+      `${name}/status`,
+      "eventFlowProjectionStatus"
+    ),
+    issues: projectionRuntime(
+      graph,
+      runtime,
+      "issue",
+      `${name}/issues`,
+      "eventFlowProjectionIssues"
+    ),
+    highWater: projectionRuntime(
+      graph,
+      runtime,
+      "high-water",
+      `${name}/highWater`,
+      "eventFlowProjectionHighWater"
+    )
+  };
+}
+function reduceEventSource(raw, source, flowId, timestampMs, state, emit) {
+  const normalized = normalizeInput(raw, source);
+  if (normalized.issue !== void 0) {
+    const status2 = {
+      kind: "rejected",
+      flowId,
+      source: normalized.source,
+      issueCode: normalized.issue.code,
+      timestampMs
+    };
+    const audit2 = auditRecord(flowId, state, "rejected", timestampMs, {
+      source: normalized.source,
+      issueCode: normalized.issue.code
+    });
+    emit({ kind: "issue", issue: normalized.issue });
+    emit({ kind: "status", status: status2 });
+    emit({ kind: "audit", audit: audit2 });
+    emit({ kind: "high-water", highWater: highWaterSnapshot(flowId, state) });
+    return;
+  }
+  const recordSeq = ++state.recordSeq;
+  const record = {
+    recordSeq,
+    flowId,
+    event: normalized.event,
+    source: normalized.source,
+    observedAtMs: timestampMs,
+    ...normalized.event.correlationId === void 0 ? {} : { correlationId: normalized.event.correlationId },
+    ...normalized.event.causationId === void 0 ? {} : { causationId: normalized.event.causationId }
+  };
+  state.highWater.set(sourceKey(normalized.source), {
+    source: normalized.source.source,
+    ...normalized.source.topic === void 0 ? {} : { topic: normalized.source.topic },
+    ...normalized.source.seq === void 0 ? {} : { seq: normalized.source.seq },
+    messageId: normalized.event.id,
+    recordSeq
+  });
+  const audit = auditRecord(flowId, state, "recorded", timestampMs, {
+    source: normalized.source,
+    eventId: normalized.event.id,
+    eventType: normalized.event.type
+  });
+  const highWater = highWaterSnapshot(flowId, state);
+  const status = {
+    kind: "recorded",
+    flowId,
+    recordSeq,
+    eventId: normalized.event.id,
+    eventType: normalized.event.type,
+    source: normalized.source,
+    timestampMs
+  };
+  emit({ kind: "record", record });
+  emit({ kind: "status", status });
+  emit({ kind: "audit", audit });
+  emit({ kind: "high-water", highWater });
+}
+function normalizeInput(raw, source) {
+  const envelope = messageEnvelopeOf(raw);
+  const value = envelope?.payload ?? raw;
+  const sourceRef = envelope === void 0 ? { source, ...eventIdOf(value) === void 0 ? {} : { messageId: eventIdOf(value) } } : {
+    source,
+    topic: envelope.topic,
+    seq: envelope.seq,
+    messageId: envelope.payload.id,
+    ...envelope.idempotencyKey === void 0 ? {} : { idempotencyKey: envelope.idempotencyKey }
+  };
+  const issue = eventMessageIssue(value);
+  if (issue !== void 0) {
+    return {
+      source: sourceRef,
+      issue: dataIssue(issue.code, issue.message, { source: sourceRef, value })
+    };
+  }
+  return { event: value, source: sourceRef };
+}
+function messageEnvelopeOf(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.topic !== "string" || !Number.isInteger(value.seq) || typeof value.timestampMs !== "number" || !("payload" in value)) {
+    return void 0;
+  }
+  const payloadIssue = eventMessageIssue(value.payload);
+  return payloadIssue === void 0 ? value : void 0;
+}
+function normalizeSources(sources) {
+  if (sources.length === 0) throw new Error("eventFlow: sources must be non-empty");
+  return sources.map((source, index) => {
+    if (isRecord(source) && "node" in source) {
+      if (typeof source.source !== "string" || source.source.length === 0) {
+        throw new Error("eventFlow: source name must be non-empty");
+      }
+      return source;
+    }
+    return { source: `source-${index}`, node: source };
+  });
+}
+function runtimeProjection(graph, runtime, kind, name, factory) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind === kind) ctx.down([["DATA", valueOfRuntimeFact(typed)]]);
+      }
+    },
+    { name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function projectionRuntime(graph, runtime, kind, name, factory, map = valueOfRuntimeFact) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind === kind) ctx.down([["DATA", map(typed)]]);
+      }
+    },
+    { name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function valueOfRuntimeFact(fact) {
+  if ("record" in fact) return fact.record;
+  if ("status" in fact) return fact.status;
+  if ("issue" in fact) return fact.issue;
+  if ("audit" in fact) return fact.audit;
+  if ("highWater" in fact) return fact.highWater;
+  if ("frame" in fact) return fact.frame;
+  return void 0;
+}
+function auditRecord(flowId, state, outcome, timestampMs, opts) {
+  return {
+    seq: ++state.auditSeq,
+    flowId,
+    outcome,
+    ...opts.eventId === void 0 ? {} : { eventId: opts.eventId },
+    ...opts.eventType === void 0 ? {} : { eventType: opts.eventType },
+    ...opts.issueCode === void 0 ? {} : { issueCode: opts.issueCode },
+    ...opts.source === void 0 ? {} : { source: opts.source },
+    highWater: highWaterSnapshot(flowId, state),
+    timestampMs
+  };
+}
+function highWaterSnapshot(flowId, state) {
+  return {
+    flowId,
+    recordSeq: state.recordSeq,
+    auditSeq: state.auditSeq,
+    sources: [...state.highWater.values()].sort(
+      (a, b) => a.source.localeCompare(b.source) || (a.topic ?? "").localeCompare(b.topic ?? "")
+    )
+  };
+}
+function emptyHighWater(flowId) {
+  return { flowId, recordSeq: 0, auditSeq: 0, sources: [] };
+}
+function projectionHighWater(flowId, record, sourceHighWater) {
+  sourceHighWater.set(sourceKey(record.source), {
+    source: record.source.source,
+    ...record.source.topic === void 0 ? {} : { topic: record.source.topic },
+    ...record.source.seq === void 0 ? {} : { seq: record.source.seq },
+    messageId: record.event.id,
+    recordSeq: record.recordSeq
+  });
+  return {
+    flowId,
+    recordSeq: record.recordSeq,
+    auditSeq: 0,
+    sources: [...sourceHighWater.values()].sort(
+      (a, b) => a.source.localeCompare(b.source) || (a.topic ?? "").localeCompare(b.topic ?? "")
+    )
+  };
+}
+function sourceKey(source) {
+  return `${source.source}\0${source.topic ?? ""}`;
+}
+function eventIdOf(value) {
+  return isRecord(value) && typeof value.id === "string" ? value.id : void 0;
+}
+function dataIssue(code, message, details) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: "error",
+    source: "eventFlow",
+    ...details === void 0 ? {} : { details }
+  };
+}
+function isEventFlowBundle(value) {
+  return isRecord(value) && "records" in value && "highWater" in value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/patterns/inspection.ts
 function profileSummary(graph, opts = {}) {
   const profile = graph.profile();
@@ -203,362 +610,36 @@ function scoreAtLeast(score, min) {
   return Number.isFinite(score) && score >= min;
 }
 
-// src/protocol/messages.ts
-var SENTINEL = void 0;
-
-// src/ctx/types.ts
-var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
-function depWaves(ctx, depIndex) {
-  return ctx.waveData[depIndex] ?? [];
-}
-function depBatch(ctx, depIndex) {
-  const waves = depWaves(ctx, depIndex);
-  if (waves.length === 0) return null;
-  const flattened = waves.flat().filter((v) => v !== SENTINEL);
-  return flattened.length === 0 ? [] : flattened;
-}
-function depLatest(ctx, depIndex) {
-  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
-}
-
-// 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 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
-    }
-  );
-}
-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
-        }
-      ]
-    };
-  }
-  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 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)
         }
       ]
     };
@@ -1027,11 +1108,323 @@ 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,
   admissionScored,
   cosineSimilarity,
+  eventFlow,
+  eventFlowProjection,
   filterMemoryFragments,
   isMemoryFragment,
   knowledgeGraphReducerBundle,