mcp-event-intelligence 0.5.0 → 0.6.1

package/dist/src/patternV2/evaluator.js

@@ -13,6 +13,33 @@ function stableValue(value) {
     }
     return value;
 }
+function durableSemanticCacheKey(context, node, candidate) {
+    const evaluatorIdentity = String(context.evaluator?.cacheIdentity ?? '').trim();
+    if (!evaluatorIdentity || !context.semanticCacheNamespace) {
+        return null;
+    }
+    const payload = stableValue({
+        schema: 'pattern-v2-semantic-cache.v1',
+        namespace: context.semanticCacheNamespace,
+        evaluator: evaluatorIdentity,
+        node: {
+            id: node.id,
+            refs: node.refs,
+            instruction: node.instruction,
+            input: node.input,
+            matchThreshold: node.matchThreshold,
+            rejectThreshold: node.rejectThreshold,
+            uncertain: node.uncertain,
+        },
+        candidate: candidate.events.map((event) => ({
+            clauseId: event.clauseId,
+            serverId: event.serverId ?? null,
+            sourceEventId: event.sourceEventId,
+            subscriptionArguments: event.subscriptionArguments ?? {},
+        })),
+    });
+    return JSON.stringify(payload);
+}
 function eventIdentity(event) {
     return [
         event.serverId ?? '-',
@@ -843,13 +870,35 @@ async function evaluateNode(node, context) {
             context.truncated = true;
             break;
         }
-        const cacheKey = [
+        const localCacheKey = [
             node.id,
             candidateSignature(candidate),
             node.instruction,
+            JSON.stringify(node.input),
+            node.matchThreshold,
+            node.rejectThreshold,
+            node.uncertain,
         ].join(':');
-        let decision = context.semanticCache.get(cacheKey);
+        const durableCacheKey = node.execution.cache
+            ? durableSemanticCacheKey(context, node, candidate)
+            : null;
+        let decision = context.semanticCache.get(localCacheKey);
+        if (decision) {
+            context.semanticCacheHits += 1;
+        }
+        if (!decision &&
+            durableCacheKey &&
+            context.durableSemanticCache) {
+            decision =
+                await context.durableSemanticCache.get(durableCacheKey) ??
+                    undefined;
+            if (decision) {
+                context.semanticCacheHits += 1;
+                context.semanticCache.set(localCacheKey, decision);
+            }
+        }
         if (!decision) {
+            context.semanticCacheMisses += 1;
             context.semanticEvaluations += 1;
             decision = await withTimeout(new SemanticConditionEngine(context.evaluator).evaluate(semanticSource(candidate, node.refs), {
                 type: 'semantic_boolean',
@@ -860,7 +909,11 @@ async function evaluateNode(node, context) {
                 uncertain: node.uncertain,
             }), node.execution.timeoutMs, `Semantic node ${node.id}`);
             if (node.execution.cache) {
-                context.semanticCache.set(cacheKey, decision);
+                context.semanticCache.set(localCacheKey, decision);
+                if (durableCacheKey &&
+                    context.durableSemanticCache) {
+                    await context.durableSemanticCache.set(durableCacheKey, decision);
+                }
             }
         }
         context.semanticTrace.push({
@@ -893,7 +946,7 @@ export function evaluatePatternMeasure(candidate, measure) {
     }
     return evaluateValue(expression, candidate);
 }
-export async function evaluatePatternV2({ definition, events, evaluator = null, now = new Date(), allowedLatenessMs = 0, }) {
+export async function evaluatePatternV2({ definition, events, evaluator = null, now = new Date(), allowedLatenessMs = 0, semanticCache = null, semanticCacheNamespace = '', }) {
     const ordered = [...events].sort(eventOrder);
     const context = {
         events: ordered,
@@ -902,8 +955,12 @@ export async function evaluatePatternV2({ definition, events, evaluator = null,
         maxCandidates: definition.execution.maxCandidates,
         maxSemanticEvaluations: definition.execution.maxSemanticEvaluations,
         semanticEvaluations: 0,
+        semanticCacheHits: 0,
+        semanticCacheMisses: 0,
         truncated: false,
         semanticCache: new Map(),
+        durableSemanticCache: semanticCache,
+        semanticCacheNamespace,
         semanticTrace: [],
         allowedLatenessMs,
     };
@@ -918,6 +975,8 @@ export async function evaluatePatternV2({ definition, events, evaluator = null,
         matches,
         pending,
         semanticEvaluations: context.semanticEvaluations,
+        semanticCacheHits: context.semanticCacheHits,
+        semanticCacheMisses: context.semanticCacheMisses,
         semanticTrace: context.semanticTrace,
         truncated: context.truncated,
     };

package/dist/src/semantic/types.d.ts

@@ -17,6 +17,12 @@ export interface SemanticEvaluation {
     metadata?: Record<string, unknown>;
 }
 export interface SemanticEvaluator {
+    /**
+     * Stable identity for durable semantic-decision caching. It must change when
+     * evaluator semantics/model configuration changes. Evaluators that omit it
+     * remain eligible only for evaluation-pass caching.
+     */
+    readonly cacheIdentity?: string;
     evaluate(request: SemanticEvaluationRequest): Promise<SemanticEvaluation>;
 }
 export type SemanticOutcome = 'match' | 'reject' | 'uncertain';

package/dist/src/semantic/typesafeJevEvaluator.d.ts

@@ -10,6 +10,7 @@ export interface TypeSafeJevEvaluatorOptions {
 }
 export declare class TypeSafeJevEvaluator implements SemanticEvaluator {
     private readonly options;
+    readonly cacheIdentity: string;
     private readonly model;
     private readonly baseUrl;
     private readonly fetchFn;

package/dist/src/semantic/typesafeJevEvaluator.js

@@ -1,5 +1,6 @@
 export class TypeSafeJevEvaluator {
     options;
+    cacheIdentity;
     model;
     baseUrl;
     fetchFn;
@@ -15,6 +16,11 @@ export class TypeSafeJevEvaluator {
         this.fetchFn = options.fetchFn ?? fetch;
         this.maxRetries = options.maxRetries ?? 2;
         this.retryBaseMs = options.retryBaseMs ?? 100;
+        this.cacheIdentity = [
+            'typesafe-jev',
+            this.baseUrl,
+            this.model,
+        ].join(':');
     }
     static fromEnvironment(env) {
         const apiKey = env.TYPESAFE_API_KEY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-event-intelligence",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "MCP-native complex event processing for durable agent workflows: event-time patterns, semantic predicates, derived events, and targeted wakeups.",
   "license": "Apache-2.0",
   "type": "module",
@@ -54,7 +54,10 @@
     "mcp": "npm run build && node scripts/mcp-stdio.mjs",
     "mcp:inspect": "npm run build && npx @modelcontextprotocol/inspector node scripts/mcp-stdio.mjs",
     "registry:validate": "mcp-publisher validate server.json",
-    "pack:mcp-smoke": "node scripts/package-mcp-smoke.mjs"
+    "pack:mcp-smoke": "node scripts/package-mcp-smoke.mjs",
+    "conformance:pattern-v2": "npm run build && node scripts/evidence/pattern-v2-conformance.mjs",
+    "bench:pattern-v2": "npm run build && node scripts/evidence/pattern-v2-benchmark.mjs --profile quick",
+    "evidence:pattern-v2": "npm run build && node scripts/evidence/pattern-v2-conformance.mjs && node scripts/evidence/pattern-v2-benchmark.mjs --profile quick"
   },
   "keywords": [
     "mcp",

package/scripts/host-integration.d.mts

@@ -83,11 +83,37 @@ export type HostWakeHandler = (
   activation?: ActivationEnvelope,
 ) => Promise<HostWakeReceipt | string> | HostWakeReceipt | string;
 
+export interface EventIntelligenceStoreCapabilities {
+  version: string;
+  sharedState: 'none' | 'single-process' | 'strong' | string;
+  scopeIsolation: 'unknown' | 'strong' | string;
+  wakeClaims: 'unknown' | 'process-atomic' | 'distributed-atomic' | string;
+  partitionLeases: 'none' | 'process-atomic' | 'distributed-atomic' | string;
+  mutableCompaction: 'none' | 'atomic-snapshot' | string;
+  readModel: string;
+}
+
 export interface EventIntelligenceStore {
   init?(): Promise<unknown>;
+  storeCapabilities?(): EventIntelligenceStoreCapabilities;
   /** Required when non-default scopes are used. Implementations should return an isolated store view. */
   forScope?(scopeId: string): Promise<EventIntelligenceStore> | EventIntelligenceStore;
   listScopeIds?(): Promise<string[]> | string[];
+  claimPartitionLease?(partitionKey: string, options: {
+    workerId: string;
+    now?: string;
+    leaseMs?: number;
+  }): Promise<unknown | null>;
+  renewPartitionLease?(partitionKey: string, options: {
+    workerId: string;
+    now?: string;
+    leaseMs?: number;
+  }): Promise<unknown | null>;
+  releasePartitionLease?(partitionKey: string, options: {
+    workerId: string;
+    now?: string;
+  }): Promise<boolean>;
+  compactMutableState?(): Promise<unknown>;
   [key: string]: any;
 }
 
@@ -114,25 +140,26 @@ export interface EventIntelligenceScopedHost {
   readonly triggerInspector: any;
   readonly triggerPlanner: any;
   readonly activationHydrator: any;
-  readonly eventSources: any[];
+  readonly eventSources: Promise<any[]> | any[];
+  readonly storeCapabilities?: EventIntelligenceStoreCapabilities;
   describeTriggerLanguage(input?: {
-    category?: 'predicates' | 'composition' | 'temporal' | 'pattern' | 'windows' | 'aggregates' | 'state' | 'selection' | 'semantic' | 'execution' | 'correlation' | 'timing' | 'lifecycle';
+    category?: 'predicates' | 'pattern' | 'windows' | 'aggregates' | 'state' | 'selection' | 'semantic' | 'execution' | 'timing' | 'lifecycle';
     operator?: string;
   }): Record<string, unknown>;
   planTrigger(input: TriggerPlanInput): Promise<{
-    planVersion: '1';
+    planVersion: '2';
     definition: any;
     connectionIds: string[];
     resolvedSources: any[];
     warnings: any[];
     explanation: any;
   }>;
-  hydrateWake(wakeId: string): ActivationEnvelope;
+  hydrateWake(wakeId: string): Promise<ActivationEnvelope> | ActivationEnvelope;
   attachMcpClient(connection: HostMcpConnectionOptions): Promise<{
     connectionId: string;
     events: any[];
   }>;
-  mcpStatus(): any[];
+  mcpStatus(): Promise<any[]> | any[];
 }
 
 export interface EventIntelligenceHost extends EventIntelligenceScopedHost {
@@ -170,6 +197,22 @@ export function createEventIntelligenceHost(
 ): Promise<EventIntelligenceHost>;
 
 
+export function describeStoreCapabilities(
+  store: EventIntelligenceStore,
+): EventIntelligenceStoreCapabilities;
+
+export function validateSharedStoreCapabilities(
+  store: EventIntelligenceStore,
+): {
+  ok: boolean;
+  capabilities: EventIntelligenceStoreCapabilities;
+  errors: string[];
+};
+
+export function assertSharedStoreCapabilities(
+  store: EventIntelligenceStore,
+): EventIntelligenceStoreCapabilities;
+
 export class PersistentEventStore implements EventIntelligenceStore {
   constructor(dataDir: string);
   readonly dataDir: string;

package/scripts/host-integration.mjs

@@ -12,6 +12,11 @@ import {
   PersistentEventStore,
   normalizeEventScopeId,
 } from './lib/persistent-event-store.mjs';
+import {
+  assertSharedStoreCapabilities,
+  describeStoreCapabilities,
+  validateSharedStoreCapabilities,
+} from './lib/store-capabilities.mjs';
 
 function normalizeMcpConnection(input) {
   const connectionId = String(
@@ -75,6 +80,7 @@ function scopedHostView(runtime, context) {
     scopeId,
     runtime: context,
     store: context.store,
+    storeCapabilities: describeStoreCapabilities(context.store),
     triggerControl: context.triggerControl,
     triggerInspector: context.triggerInspector,
     triggerPlanner: context.triggerPlanner,
@@ -98,8 +104,8 @@ function scopedHostView(runtime, context) {
       });
       return runtime.mcpEventsClient.attachConnection(normalized);
     },
-    mcpStatus() {
-      return runtime.mcpEventsClient.status()
+    async mcpStatus() {
+      return (await runtime.mcpEventsClient.status())
         .filter((entry) => entry.scopeId === scopeId);
     },
   };
@@ -231,6 +237,9 @@ export async function createEventIntelligenceHost({
     get store() {
       return runtime.store;
     },
+    get storeCapabilities() {
+      return runtime.storeCapabilities;
+    },
     get triggerControl() {
       return runtime.triggerControl;
     },
@@ -264,8 +273,8 @@ export async function createEventIntelligenceHost({
       registryManaged.delete(connectionId);
       return runtime.mcpEventsClient.detachConnection(connectionId);
     },
-    mcpStatus() {
-      return runtime.mcpEventsClient.status();
+    async mcpStatus() {
+      return await runtime.mcpEventsClient.status();
     },
     loadedScopes() {
       return runtime.loadedScopes();
@@ -283,6 +292,9 @@ export async function createEventIntelligenceHost({
 }
 
 export {
+  assertSharedStoreCapabilities,
   createHostMcpEventsConnection,
+  describeStoreCapabilities,
   PersistentEventStore,
+  validateSharedStoreCapabilities,
 };

package/scripts/lib/activation-hydrator.mjs

@@ -2,21 +2,21 @@ import {
   parseActivationEnvelope,
 } from '../../dist/src/intelligenceProtocol/index.js';
 
-function latestMatchForWake(store, wake, delivery) {
+async function latestMatchForWake(store, wake, delivery) {
   const matchId =
     delivery?.matchId ||
     (wake?.subscriptionId?.startsWith('trigger:') ? wake.sourceEventId : null);
   if (!matchId) return null;
 
-  return store.listTriggerMatches()
+  return (await store.listTriggerMatches())
     .find((candidate) => candidate.matchId === matchId) ?? null;
 }
 
-function definitionForMatch(store, match, delivery) {
+async function definitionForMatch(store, match, delivery) {
   if (!match && !delivery) return null;
   const triggerId = match?.triggerId ?? delivery?.triggerId;
   const triggerVersion = match?.triggerVersion ?? delivery?.triggerVersion;
-  return store.listTriggers().find((candidate) =>
+  return (await store.listTriggers()).find((candidate) =>
     candidate.triggerId === triggerId &&
     candidate.version === triggerVersion
   ) ?? null;
@@ -42,7 +42,7 @@ export class ActivationHydrator {
     this.store = store;
   }
 
-  hydrateWake(wakeIdInput) {
+  async hydrateWake(wakeIdInput) {
     const wakeId = String(wakeIdInput || '').trim();
     if (!wakeId) {
       const error = new Error('wakeId is required');
@@ -50,7 +50,7 @@ export class ActivationHydrator {
       throw error;
     }
 
-    const wake = this.store.latestWake(wakeId);
+    const wake = await this.store.latestWake(wakeId);
     if (!wake) {
       const error = new Error(`Unknown wake: ${wakeId}`);
       error.code = 'ACTIVATION_WAKE_NOT_FOUND';
@@ -59,9 +59,9 @@ export class ActivationHydrator {
 
     const delivery =
       typeof this.store.getWakeDelivery === 'function'
-        ? this.store.getWakeDelivery(wakeId)
+        ? await this.store.getWakeDelivery(wakeId)
         : null;
-    const match = latestMatchForWake(this.store, wake, delivery);
+    const match = await latestMatchForWake(this.store, wake, delivery);
     if (!match) {
       const error = new Error(
         `Wake ${wakeId} is not backed by a composite trigger match`,
@@ -70,7 +70,7 @@ export class ActivationHydrator {
       throw error;
     }
 
-    const definition = definitionForMatch(this.store, match, delivery);
+    const definition = await definitionForMatch(this.store, match, delivery);
     if (!definition?.target) {
       const error = new Error(
         `Trigger definition missing for wake ${wakeId}`,
@@ -106,7 +106,7 @@ export class ActivationHydrator {
     }));
 
     return parseActivationEnvelope({
-      activationVersion: '1',
+      activationVersion: '2',
       wake: {
         wakeId,
         status: wake.status,
@@ -118,14 +118,14 @@ export class ActivationHydrator {
         triggerId: definition.triggerId,
         version: definition.version,
         description: definition.description ?? null,
-        expression: definition.expression,
+        pattern: definition.pattern,
         lifecycle: definition.lifecycle ?? {},
       },
       continuation,
       match: {
         matchId: match.matchId,
         status: match.status,
-        correlationKey: match.correlationKey,
+        partitionKey: match.partitionKey,
         openedAt: match.openedAt,
         updatedAt: match.updatedAt,
       },

package/scripts/lib/composite-event-consumer.mjs

@@ -9,7 +9,6 @@ export class CompositeEventConsumer {
     wakeCoordinator = null,
     wakeCoordinators = null,
     derivedEventCoordinator = null,
-    processor = null,
     maxDerivedDepth = 16,
   }) {
     this.store = store;
@@ -19,7 +18,6 @@ export class CompositeEventConsumer {
       ? wakeCoordinators
       : new Map();
     this.derivedEventCoordinator = derivedEventCoordinator;
-    this.processor = processor;
     this.maxDerivedDepth = Math.max(1, Number(maxDerivedDepth) || 16);
   }
 
@@ -60,7 +58,7 @@ export class CompositeEventConsumer {
     for (const result of results) {
       if (!result.matched || !result.match) continue;
 
-      const definition = this.store.listTriggers().find(
+      const definition = (await this.store.listTriggers()).find(
         (candidate) =>
           candidate.triggerId === result.match.triggerId &&
           candidate.version === result.match.triggerVersion,
@@ -139,31 +137,13 @@ export class CompositeEventConsumer {
       const delivery = await coordinator.deliverMatched(result.match);
       const persistedWake = delivery.wake;
 
-      if (
-        persistedWake?.status === 'delivered' &&
-        persistedWake.runtimeReceiptId &&
-        this.processor
-      ) {
-        const handled = await this.processor.acknowledgeWake(
-          persistedWake.wakeId,
-          persistedWake.runtimeReceiptId,
-        );
-        deliveries.push({
-          triggerId: result.triggerId,
-          matchId: result.match.matchId,
-          wakeId: handled.wakeId,
-          status: handled.status,
-          runtimeReceiptId: handled.runtimeReceiptId ?? null,
-        });
-      } else {
-        deliveries.push({
-          triggerId: result.triggerId,
-          matchId: result.match.matchId,
-          wakeId: persistedWake?.wakeId ?? null,
-          status: delivery.status,
-          runtimeReceiptId: persistedWake?.runtimeReceiptId ?? null,
-        });
-      }
+      deliveries.push({
+        triggerId: result.triggerId,
+        matchId: result.match.matchId,
+        wakeId: persistedWake?.wakeId ?? null,
+        status: delivery.status,
+        runtimeReceiptId: persistedWake?.runtimeReceiptId ?? null,
+      });
     }
 
     return {

package/scripts/lib/composite-wake-coordinator.mjs

@@ -64,11 +64,11 @@ export class CompositeWakeCoordinator {
   }
 
   async deliveredResult({ match, wakeId, definition, delivery }) {
-    const existing = this.store.latestWake(wakeId);
+    const existing = await this.store.latestWake(wakeId);
     let delivered = existing;
     if (
       !delivered ||
-      (delivered.status !== 'delivered' && delivered.status !== 'handled')
+      delivered.status !== 'delivered'
     ) {
       delivered = WakeRecordSchema.parse({
         wakeId,
@@ -85,7 +85,7 @@ export class CompositeWakeCoordinator {
       await this.store.appendAudit({
         auditId: await stableId(
           'audit',
-          `${wakeId}:delivered-recovered:${this.store.auditLength()}`,
+          `${wakeId}:delivered-recovered:${await this.store.auditLength()}`,
         ),
         traceId: delivered.traceId,
         timestamp: this.now().toISOString(),
@@ -108,7 +108,7 @@ export class CompositeWakeCoordinator {
     }
 
     return {
-      status: delivered.status === 'handled' ? 'handled' : 'wake_delivered',
+      status: 'wake_delivered',
       wake: delivered,
     };
   }
@@ -120,7 +120,7 @@ export class CompositeWakeCoordinator {
 
     if (match.status === 'fired') {
       const existing = match.firedWakeId
-        ? this.store.latestWake(match.firedWakeId)
+        ? await this.store.latestWake(match.firedWakeId)
         : null;
       return {
         status: 'already_fired',
@@ -128,7 +128,7 @@ export class CompositeWakeCoordinator {
       };
     }
 
-    const definition = this.store.listTriggers().find(
+    const definition = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === match.triggerId &&
         candidate.version === match.triggerVersion,
@@ -148,13 +148,13 @@ export class CompositeWakeCoordinator {
       `composite:${match.matchId}:${definition.target.runtime}:${definition.target.id}`,
     );
 
-    const existingWake = this.store.latestWake(wakeId);
-    if (existingWake?.status === 'handled' || existingWake?.status === 'delivered') {
+    const existingWake = await this.store.latestWake(wakeId);
+    if (existingWake?.status === 'delivered') {
       if (match.status !== 'fired') {
         await this.triggerEngine.markFired(match.matchId, wakeId);
       }
       return {
-        status: existingWake.status === 'handled' ? 'handled' : 'wake_delivered',
+        status: 'wake_delivered',
         wake: existingWake,
       };
     }
@@ -179,7 +179,7 @@ export class CompositeWakeCoordinator {
         await this.store.appendAudit({
           auditId: await stableId(
             'audit',
-            `${wakeId}:queued:${this.store.auditLength()}`,
+            `${wakeId}:queued:${await this.store.auditLength()}`,
           ),
           traceId: queued.traceId,
           timestamp: this.now().toISOString(),
@@ -196,7 +196,7 @@ export class CompositeWakeCoordinator {
       }
       return {
         status: 'wake_queued',
-        wake: this.store.latestWake(wakeId) ?? queued,
+        wake: await this.store.latestWake(wakeId) ?? queued,
       };
     }
 
@@ -210,7 +210,7 @@ export class CompositeWakeCoordinator {
       now: nowIso,
     });
 
-    const currentDelivery = this.store.getWakeDelivery(wakeId);
+    const currentDelivery = await this.store.getWakeDelivery(wakeId);
     if (currentDelivery?.status === 'delivered') {
       return this.deliveredResult({
         match,
@@ -240,25 +240,25 @@ export class CompositeWakeCoordinator {
     });
 
     if (!claim) {
-      const delivery = this.store.getWakeDelivery(wakeId);
+      const delivery = await this.store.getWakeDelivery(wakeId);
       return {
         status:
           delivery?.status === 'claimed'
             ? 'delivery_in_progress'
             : 'retry_scheduled',
-        wake: this.store.latestWake(wakeId) ?? queued,
+        wake: await this.store.latestWake(wakeId) ?? queued,
         delivery,
       };
     }
 
-    let persistedQueued = this.store.latestWake(wakeId);
+    let persistedQueued = await this.store.latestWake(wakeId);
     if (!persistedQueued) {
       await this.store.appendWake(queued);
       persistedQueued = queued;
       await this.store.appendAudit({
         auditId: await stableId(
           'audit',
-          `${wakeId}:queued:${this.store.auditLength()}`,
+          `${wakeId}:queued:${await this.store.auditLength()}`,
         ),
         traceId: queued.traceId,
         timestamp: this.now().toISOString(),
@@ -305,7 +305,7 @@ export class CompositeWakeCoordinator {
       await this.store.appendAudit({
         auditId: await stableId(
           'audit',
-          `${wakeId}:delivered:${this.store.auditLength()}`,
+          `${wakeId}:delivered:${await this.store.auditLength()}`,
         ),
         traceId: delivered.traceId,
         timestamp: this.now().toISOString(),
@@ -350,7 +350,7 @@ export class CompositeWakeCoordinator {
         await this.store.appendAudit({
           auditId: await stableId(
             'audit',
-            `${wakeId}:retry:${delivery?.attemptCount ?? claim.attemptCount}:${this.store.auditLength()}`,
+            `${wakeId}:retry:${delivery?.attemptCount ?? claim.attemptCount}:${await this.store.auditLength()}`,
           ),
           traceId: queued.traceId,
           timestamp: this.now().toISOString(),
@@ -382,7 +382,7 @@ export class CompositeWakeCoordinator {
       await this.store.appendAudit({
         auditId: await stableId(
           'audit',
-          `${wakeId}:dead-letter:${this.store.auditLength()}`,
+          `${wakeId}:dead-letter:${await this.store.auditLength()}`,
         ),
         traceId: deadLetter.traceId,
         timestamp: this.now().toISOString(),

package/scripts/lib/derived-contract-registry.mjs

@@ -42,11 +42,11 @@ export class DerivedContractRegistry {
     return sha256Hex(canonicalize(payloadSchema ?? {}));
   }
 
-  list(eventName) {
+  async list(eventName) {
     return this.store.listDerivedContracts(eventName);
   }
 
-  get(eventName, contractVersion) {
+  async get(eventName, contractVersion) {
     return this.store.getDerivedContract(eventName, contractVersion);
   }
 
@@ -57,7 +57,7 @@ export class DerivedContractRegistry {
   }) {
     const canonicalSchema = canonicalize(payloadSchema ?? {});
     const schemaFingerprint = await this.fingerprint(canonicalSchema);
-    const existing = this.get(eventName, contractVersion);
+    const existing = await this.get(eventName, contractVersion);
     if (
       existing &&
       existing.schemaFingerprint !== schemaFingerprint
@@ -89,7 +89,7 @@ export class DerivedContractRegistry {
   }) {
     const canonicalSchema = canonicalize(payloadSchema ?? {});
     const schemaFingerprint = await this.fingerprint(canonicalSchema);
-    const existing = this.get(eventName, contractVersion);
+    const existing = await this.get(eventName, contractVersion);
 
     if (
       existing &&