@graphrefly/ts 0.0.0 → 0.0.1

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,425 @@ __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/index.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"
+  };
+}
+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) {
+  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,24 +624,6 @@ 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";
@@ -1032,6 +1435,8 @@ function compareBigIntDesc2(a, b) {
   admissionFilter3D,
   admissionScored,
   cosineSimilarity,
+  eventFlow,
+  eventFlowProjection,
   filterMemoryFragments,
   isMemoryFragment,
   knowledgeGraphReducerBundle,