mcp-event-intelligence 0.5.0 → 0.6.0

package/dist/src/composite/matching.d.ts

@@ -1,8 +1,4 @@
-import type { CompositeTriggerDefinition, CorrelatableEvent, TriggerClause, TriggerMatchRecord, TriggerSourceEvent } from '../intelligenceProtocol/triggerSchemas.js';
+import type { CorrelatableEvent, TriggerClause, TriggerSourceEvent } from '../intelligenceProtocol/triggerSchemas.js';
 export declare function clauseMatches(clause: TriggerClause, event: CorrelatableEvent): boolean;
 export declare function asSourceEvent(clauseId: string, event: CorrelatableEvent): TriggerSourceEvent;
-export declare function expressionSatisfied(definition: CompositeTriggerDefinition, record: TriggerMatchRecord): boolean;
-export declare function semanticSource(record: TriggerMatchRecord): Record<string, unknown>;
-export declare function deterministicKeyForClause(definition: CompositeTriggerDefinition, clauseId: string, event: CorrelatableEvent): string | null;
 export declare function sameEventIdentity(source: Pick<TriggerSourceEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>): boolean;
-export declare function matchesCorrelationKey(record: TriggerMatchRecord, key: string | null): boolean;

package/dist/src/composite/matching.js

@@ -26,13 +26,6 @@ function sameSubscriptionArguments(left, right) {
     return JSON.stringify(stableValue(left ?? {})) ===
         JSON.stringify(stableValue(right ?? {}));
 }
-function scalarKey(value) {
-    if (typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean')
-        return String(value);
-    return null;
-}
 function predicateMatches(event, predicate) {
     const value = getByPath(event.data, predicate.path);
     switch (predicate.op) {
@@ -128,55 +121,8 @@ export function asSourceEvent(clauseId, event) {
         data: event.data,
     };
 }
-function clauseEvents(record, ref) {
-    return record.sourceEvents
-        .filter((event) => event.clauseId === ref)
-        .sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
-}
-export function expressionSatisfied(definition, record) {
-    const expression = definition.expression;
-    if (expression.kind === 'allOf') {
-        return expression.refs.every((ref) => clauseEvents(record, ref).length > 0);
-    }
-    if (expression.kind === 'anyOf') {
-        return expression.refs.some((ref) => clauseEvents(record, ref).length > 0);
-    }
-    if (expression.kind === 'count') {
-        return clauseEvents(record, expression.ref).length >= expression.atLeast;
-    }
-    let previous = Number.NEGATIVE_INFINITY;
-    for (const ref of expression.refs) {
-        const candidate = clauseEvents(record, ref)
-            .find((event) => Date.parse(event.occurredAt) > previous);
-        if (!candidate)
-            return false;
-        previous = Date.parse(candidate.occurredAt);
-    }
-    return true;
-}
-export function semanticSource(record) {
-    const source = {};
-    for (const event of record.sourceEvents) {
-        source[event.clauseId] = event.data;
-    }
-    return source;
-}
-export function deterministicKeyForClause(definition, clauseId, event) {
-    const deterministic = definition.correlation?.deterministic;
-    if (!deterministic)
-        return null;
-    const field = deterministic.fields.find((item) => item.ref === clauseId);
-    if (!field)
-        return null;
-    return scalarKey(getByPath(event.data, field.path));
-}
 export function sameEventIdentity(source, event) {
     return (source.sourceEventId === event.sourceEventId &&
         (source.serverId ?? null) === (event.serverId ?? null) &&
         sameSubscriptionArguments(source.subscriptionArguments, event.subscriptionArguments));
 }
-export function matchesCorrelationKey(record, key) {
-    if (record.correlationKey === null || key === null)
-        return true;
-    return record.correlationKey === key;
-}

package/dist/src/composite/runtimeSupport.js

@@ -17,7 +17,9 @@ export class CompositeTriggerRuntimeSupport {
                 deadline.conditionId,
                 deadline.dueAt,
             ].join(':'))).slice(0, 24)}`;
-            const existing = this.store.getTemporalDeadline?.(deadlineId);
+            const existing = this.store.getTemporalDeadline
+                ? await this.store.getTemporalDeadline(deadlineId)
+                : null;
             if (existing?.status === 'pending' || existing?.status === 'fired') {
                 continue;
             }
@@ -36,7 +38,7 @@ export class CompositeTriggerRuntimeSupport {
         if (!this.store.listTemporalDeadlines ||
             !this.store.setTemporalDeadlineStatus)
             return;
-        const pending = this.store.listTemporalDeadlines({
+        const pending = await this.store.listTemporalDeadlines({
             matchId,
             status: 'pending',
         });
@@ -45,9 +47,11 @@ export class CompositeTriggerRuntimeSupport {
         }
     }
     async advanceLifecycleAfterEffect(match, effectKind, effectId) {
-        const definition = this.store.listTriggers().find((candidate) => candidate.triggerId === match.triggerId &&
+        const definition = (await this.store.listTriggers()).find((candidate) => candidate.triggerId === match.triggerId &&
             candidate.version === match.triggerVersion);
-        const triggerState = this.store.getTriggerState?.(match.triggerId, match.triggerVersion) ?? null;
+        const triggerState = this.store.getTriggerState
+            ? await this.store.getTriggerState(match.triggerId, match.triggerVersion)
+            : null;
         if (!definition || !this.store.setTriggerState)
             return;
         const previousCount = triggerState?.fireCount ?? 0;
@@ -158,7 +162,7 @@ export class CompositeTriggerRuntimeSupport {
     }
     async auditMatch(record, kind, details = {}) {
         await this.store.appendAudit({
-            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${this.store.listTriggerMatches().length}`)).slice(0, 24)}`,
+            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${(await this.store.listTriggerMatches()).length}`)).slice(0, 24)}`,
             traceId: record.sourceEvents[0]?.traceId ?? record.matchId,
             timestamp: this.now().toISOString(),
             kind,
@@ -168,7 +172,7 @@ export class CompositeTriggerRuntimeSupport {
                 triggerId: record.triggerId,
                 triggerVersion: record.triggerVersion,
                 status: record.status,
-                correlationKey: record.correlationKey,
+                partitionKey: record.partitionKey,
                 ...details,
             },
         });

package/dist/src/composite/store.d.ts

@@ -1,7 +1,25 @@
 import type { CompositeTriggerDefinition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
 export interface CompositeTriggerStore {
+    storeCapabilities?(): {
+        partitionLeases?: string;
+        [key: string]: unknown;
+    };
+    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>;
     putTrigger(definition: CompositeTriggerDefinition): Promise<void>;
-    listTriggers(): CompositeTriggerDefinition[];
+    listTriggers(): CompositeTriggerDefinition[] | Promise<CompositeTriggerDefinition[]>;
     getTriggerState?(triggerId: string, version: string): {
         status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted';
         owner?: unknown;
@@ -12,7 +30,7 @@ export interface CompositeTriggerStore {
     } | null;
     setTriggerState?(triggerId: string, version: string, status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted', actor?: unknown, metadata?: Record<string, unknown>): Promise<unknown>;
     appendTriggerMatch(record: TriggerMatchRecord): Promise<void>;
-    listTriggerMatches(triggerId?: string): TriggerMatchRecord[];
+    listTriggerMatches(triggerId?: string): TriggerMatchRecord[] | Promise<TriggerMatchRecord[]>;
     getTemporalDeadline?(deadlineId: string): {
         deadlineId: string;
         triggerId: string;
@@ -21,7 +39,15 @@ export interface CompositeTriggerStore {
         conditionId: string;
         dueAt: string;
         status: 'pending' | 'cancelled' | 'fired';
-    } | null;
+    } | null | Promise<{
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: 'pending' | 'cancelled' | 'fired';
+    } | null>;
     listTemporalDeadlines?(filter?: {
         triggerId?: string;
         matchId?: string;
@@ -34,7 +60,15 @@ export interface CompositeTriggerStore {
         conditionId: string;
         dueAt: string;
         status: string;
-    }>;
+    }> | Promise<Array<{
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: string;
+    }>>;
     putTemporalDeadline?(input: {
         deadlineId: string;
         triggerId: string;

package/dist/src/composite/temporal.d.ts

@@ -1,19 +1,3 @@
-import type { CompositeTriggerDefinition, TemporalCondition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
-export interface TemporalPendingDeadline {
-    conditionId: string;
-    dueAt: string;
-}
-export interface TemporalEvaluation {
-    outcome: 'satisfied' | 'pending' | 'blocked';
-    pendingDeadlines: TemporalPendingDeadline[];
-    conditionStates: Array<{
-        conditionId: string;
-        kind: TemporalCondition['kind'];
-        status: 'satisfied' | 'pending' | 'blocked';
-        dueAt?: string;
-        reason?: string;
-    }>;
-}
 export declare function zonedParts(timestamp: string | Date, timeZone: string): {
     year: number;
     month: number;
@@ -29,4 +13,3 @@ export declare function localDateTimeToUtc(date: {
     month: number;
     day: number;
 }, clock: string, timeZone: string): Date;
-export declare function evaluateTemporalConditions(definition: CompositeTriggerDefinition, record: TriggerMatchRecord, now: Date): TemporalEvaluation;

package/dist/src/composite/temporal.js

@@ -1,26 +1,3 @@
-function getByPath(source, path) {
-    let current = source;
-    for (const part of path.split('.')) {
-        if (current === null ||
-            typeof current !== 'object' ||
-            Array.isArray(current))
-            return undefined;
-        current = current[part];
-    }
-    return current;
-}
-function eventsFor(record, ref) {
-    return record.sourceEvents
-        .filter((event) => event.clauseId === ref)
-        .sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
-}
-function latestEvent(record, ref) {
-    return eventsFor(record, ref).at(-1) ?? null;
-}
-function parseClock(value) {
-    const [hour, minute] = value.split(':').map(Number);
-    return hour * 60 + minute;
-}
 const WEEKDAY_TO_ISO = {
     Mon: 1,
     Tue: 2,
@@ -72,246 +49,3 @@ export function localDateTimeToUtc(date, clock, timeZone) {
     }
     return new Date(guess);
 }
-function calendarMatches(condition, event) {
-    const parts = zonedParts(event.occurredAt, condition.timezone);
-    const minutes = parts.hour * 60 + parts.minute;
-    if (condition.weekdays && !condition.weekdays.includes(parts.weekday)) {
-        return false;
-    }
-    if (condition.dates && !condition.dates.includes(parts.date)) {
-        return false;
-    }
-    if (condition.dateRange &&
-        (parts.date < condition.dateRange.start ||
-            parts.date > condition.dateRange.end)) {
-        return false;
-    }
-    if (condition.dayOfMonth &&
-        !condition.dayOfMonth.includes(parts.day)) {
-        return false;
-    }
-    if (condition.before && condition.after) {
-        const before = parseClock(condition.before);
-        const after = parseClock(condition.after);
-        if (after <= before) {
-            if (minutes < after || minutes > before)
-                return false;
-        }
-        else {
-            if (!(minutes >= after || minutes <= before))
-                return false;
-        }
-    }
-    else {
-        if (condition.before && minutes > parseClock(condition.before)) {
-            return false;
-        }
-        if (condition.after && minutes < parseClock(condition.after)) {
-            return false;
-        }
-    }
-    return true;
-}
-function absenceDueAt(condition, anchor) {
-    const anchorMs = Date.parse(anchor.occurredAt);
-    if (condition.forMs) {
-        return new Date(anchorMs + condition.forMs);
-    }
-    const zone = condition.timezone;
-    const parts = zonedParts(anchor.occurredAt, zone);
-    const due = localDateTimeToUtc(parts, condition.untilLocalTime, zone);
-    return due.getTime() < anchorMs ? new Date(anchorMs) : due;
-}
-function state(condition, status, extra = {}) {
-    return {
-        conditionId: condition.id,
-        kind: condition.kind,
-        status,
-        ...extra,
-    };
-}
-export function evaluateTemporalConditions(definition, record, now) {
-    const states = [];
-    const pendingDeadlines = [];
-    for (const condition of definition.temporal ?? []) {
-        if (condition.kind === 'calendar') {
-            const event = latestEvent(record, condition.ref);
-            if (!event) {
-                states.push(state(condition, 'pending', {
-                    reason: 'referenced event has not occurred',
-                }));
-                continue;
-            }
-            states.push(calendarMatches(condition, event)
-                ? state(condition, 'satisfied')
-                : state(condition, 'blocked', {
-                    reason: 'event is outside the configured calendar window',
-                }));
-            continue;
-        }
-        if (condition.kind === 'not' || condition.kind === 'unless') {
-            const exists = eventsFor(record, condition.ref).length > 0;
-            states.push(exists
-                ? state(condition, 'blocked', {
-                    reason: `${condition.ref} occurred`,
-                })
-                : state(condition, 'satisfied'));
-            continue;
-        }
-        if (condition.kind === 'after') {
-            const event = latestEvent(record, condition.ref);
-            const anchor = latestEvent(record, condition.afterRef);
-            if (!event || !anchor) {
-                states.push(state(condition, 'pending', {
-                    reason: 'ordering events are incomplete',
-                }));
-            }
-            else if (Date.parse(event.occurredAt) > Date.parse(anchor.occurredAt)) {
-                states.push(state(condition, 'satisfied'));
-            }
-            else {
-                states.push(state(condition, 'blocked', {
-                    reason: `${condition.ref} did not occur after ${condition.afterRef}`,
-                }));
-            }
-            continue;
-        }
-        if (condition.kind === 'until') {
-            const event = latestEvent(record, condition.ref);
-            const boundary = latestEvent(record, condition.beforeRef);
-            if (!event || !boundary) {
-                states.push(state(condition, 'pending', {
-                    reason: 'ordering events are incomplete',
-                }));
-            }
-            else if (Date.parse(event.occurredAt) <= Date.parse(boundary.occurredAt)) {
-                states.push(state(condition, 'satisfied'));
-            }
-            else {
-                states.push(state(condition, 'blocked', {
-                    reason: `${condition.ref} occurred after ${condition.beforeRef}`,
-                }));
-            }
-            continue;
-        }
-        if (condition.kind === 'threshold') {
-            const count = eventsFor(record, condition.ref).length;
-            states.push(count >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${count}/${condition.atLeast} occurrences`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'distinct') {
-            const values = new Set(eventsFor(record, condition.ref)
-                .map((event) => getByPath(event.data, condition.path))
-                .filter((value) => typeof value === 'string' ||
-                typeof value === 'number' ||
-                typeof value === 'boolean')
-                .map(String));
-            states.push(values.size >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${values.size}/${condition.atLeast} distinct values`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'rate') {
-            const events = eventsFor(record, condition.ref);
-            if (!events.length) {
-                states.push(state(condition, 'pending', {
-                    reason: 'no events in rate window',
-                }));
-                continue;
-            }
-            const end = Math.max(now.getTime(), Date.parse(events.at(-1).occurredAt));
-            const count = events.filter((event) => end - Date.parse(event.occurredAt) <= condition.perMs).length;
-            states.push(count >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${count}/${condition.atLeast} occurrences in rate window`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'debounce') {
-            const event = latestEvent(record, condition.ref);
-            if (!event) {
-                states.push(state(condition, 'pending', {
-                    reason: 'debounced event has not occurred',
-                }));
-                continue;
-            }
-            const dueAt = new Date(Date.parse(event.occurredAt) + condition.forMs).toISOString();
-            if (now.getTime() >= Date.parse(dueAt)) {
-                states.push(state(condition, 'satisfied', { dueAt }));
-            }
-            else {
-                states.push(state(condition, 'pending', {
-                    dueAt,
-                    reason: 'waiting for quiet period',
-                }));
-                pendingDeadlines.push({
-                    conditionId: condition.id,
-                    dueAt,
-                });
-            }
-            continue;
-        }
-        if (condition.kind === 'absence') {
-            const anchor = latestEvent(record, condition.afterRef);
-            if (!anchor) {
-                states.push(state(condition, 'pending', {
-                    reason: `waiting for anchor ${condition.afterRef}`,
-                }));
-                continue;
-            }
-            const due = absenceDueAt(condition, anchor);
-            const dueAt = due.toISOString();
-            const anchorMs = Date.parse(anchor.occurredAt);
-            const disqualifying = eventsFor(record, condition.ref)
-                .some((event) => {
-                const at = Date.parse(event.occurredAt);
-                return at >= anchorMs && at <= due.getTime();
-            });
-            if (disqualifying) {
-                states.push(state(condition, 'blocked', {
-                    dueAt,
-                    reason: `${condition.ref} occurred before the absence deadline`,
-                }));
-            }
-            else if (now.getTime() >= due.getTime()) {
-                states.push(state(condition, 'satisfied', { dueAt }));
-            }
-            else {
-                states.push(state(condition, 'pending', {
-                    dueAt,
-                    reason: 'absence window is still open',
-                }));
-                pendingDeadlines.push({
-                    conditionId: condition.id,
-                    dueAt,
-                });
-            }
-        }
-    }
-    if (states.some((entry) => entry.status === 'blocked')) {
-        return {
-            outcome: 'blocked',
-            pendingDeadlines,
-            conditionStates: states,
-        };
-    }
-    if (states.some((entry) => entry.status === 'pending')) {
-        return {
-            outcome: 'pending',
-            pendingDeadlines,
-            conditionStates: states,
-        };
-    }
-    return {
-        outcome: 'satisfied',
-        pendingDeadlines,
-        conditionStates: states,
-    };
-}

package/dist/src/intelligenceProtocol/activationSchemas.d.ts

@@ -11,7 +11,7 @@ export declare const ActivationEvidenceSchema: z.ZodObject<{
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export declare const ActivationEnvelopeSchema: z.ZodObject<{
-    activationVersion: z.ZodLiteral<"1">;
+    activationVersion: z.ZodLiteral<"2">;
     wake: z.ZodObject<{
         wakeId: z.ZodString;
         status: z.ZodString;
@@ -27,7 +27,40 @@ export declare const ActivationEnvelopeSchema: z.ZodObject<{
         triggerId: z.ZodString;
         version: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
-        expression: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        pattern: z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<"2">>;
+            root: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+            partitionBy: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                fields: z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    path: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            selection: z.ZodDefault<z.ZodObject<{
+                overlap: z.ZodDefault<z.ZodEnum<{
+                    allow: "allow";
+                    disallow: "disallow";
+                }>>;
+                afterMatch: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+                    skipPastLast: "skipPastLast";
+                    skipToNext: "skipToNext";
+                    keepAll: "keepAll";
+                }>, z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        skipToFirst: "skipToFirst";
+                        skipToLast: "skipToLast";
+                    }>;
+                    ref: z.ZodString;
+                }, z.core.$strict>]>>;
+                maxMatchesPerEvent: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            execution: z.ZodDefault<z.ZodObject<{
+                maxCandidates: z.ZodDefault<z.ZodNumber>;
+                maxSemanticEvaluations: z.ZodDefault<z.ZodNumber>;
+                maxBufferedEvents: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
         lifecycle: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strict>;
     continuation: z.ZodNullable<z.ZodObject<{
@@ -44,7 +77,7 @@ export declare const ActivationEnvelopeSchema: z.ZodObject<{
     match: z.ZodObject<{
         matchId: z.ZodString;
         status: z.ZodString;
-        correlationKey: z.ZodNullable<z.ZodString>;
+        partitionKey: z.ZodNullable<z.ZodString>;
         openedAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strict>;

package/dist/src/intelligenceProtocol/activationSchemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ContinuationContractSchema } from './triggerSchemas.js';
+import { PatternAstV2DefinitionSchema } from './patternV2Schemas.js';
 const Id = z.string().min(1).max(200);
 const Timestamp = z.string().datetime({ offset: true });
 export const ActivationEvidenceSchema = z.object({
@@ -14,7 +15,7 @@ export const ActivationEvidenceSchema = z.object({
     data: z.record(z.string(), z.unknown()).optional(),
 }).strict();
 export const ActivationEnvelopeSchema = z.object({
-    activationVersion: z.literal('1'),
+    activationVersion: z.literal('2'),
     wake: z.object({
         wakeId: Id,
         status: z.string().min(1),
@@ -30,14 +31,14 @@ export const ActivationEnvelopeSchema = z.object({
         triggerId: Id,
         version: z.string().min(1),
         description: z.string().nullable(),
-        expression: z.record(z.string(), z.unknown()),
+        pattern: PatternAstV2DefinitionSchema,
         lifecycle: z.record(z.string(), z.unknown()),
     }).strict(),
     continuation: ContinuationContractSchema.nullable(),
     match: z.object({
         matchId: Id,
         status: z.string().min(1),
-        correlationKey: z.string().nullable(),
+        partitionKey: z.string().nullable(),
         openedAt: Timestamp,
         updatedAt: Timestamp,
     }).strict(),

package/dist/src/intelligenceProtocol/index.d.ts

@@ -1,23 +1,19 @@
 export { PATTERN_AST_VERSION, PatternValueSelectorSchema, PatternArithmeticValueSchema, PatternCompareOperatorSchema, AggregateFunctionSchema, PatternWindowSchema, PatternNodeV2Schema, PatternPartitionDimensionSchema, PatternAfterMatchSchema, PatternSelectionSchema, PatternExecutionPolicySchema, PatternMeasureSchema, PatternAstV2DefinitionSchema, collectPatternDurationsMs, collectGuaranteedPatternBindings, collectPatternMeasureRefs, collectPatternRefs, } from './patternV2Schemas.js';
 export type { PatternValueSelector, PatternArithmeticValue, PatternWindow, PatternNodeV2, PatternAfterMatch, PatternAstV2Definition, PatternMeasure, } from './patternV2Schemas.js';
-export { compileLegacyTriggerToPatternV2, } from '../patternV2/legacyCompiler.js';
 export { evaluatePatternV2, evaluatePatternAggregate, evaluatePatternMeasure, patternV2CandidateSignature, } from '../patternV2/evaluator.js';
-export type { PatternV2Candidate, PatternV2Evaluation, PatternV2SemanticDecision, PatternV2SemanticTrace, } from '../patternV2/evaluator.js';
-export { TRIGGER_LANGUAGE_VERSION, PREDICATE_OPERATOR, COMPOSITION_OPERATOR, TEMPORAL_OPERATOR, TRIGGER_LANGUAGE_CATALOG, describeTriggerLanguage, } from './operatorRegistry.js';
+export type { PatternV2Candidate, PatternV2Evaluation, PatternV2SemanticCache, PatternV2SemanticDecision, PatternV2SemanticTrace, } from '../patternV2/evaluator.js';
+export { TRIGGER_LANGUAGE_VERSION, PREDICATE_OPERATOR, TRIGGER_LANGUAGE_CATALOG, describeTriggerLanguage, } from './operatorRegistry.js';
 export type { TriggerLanguageCategory, } from './operatorRegistry.js';
 export { EVENT_INTELLIGENCE_PROTOCOL, EVENT_INTELLIGENCE_PROTOCOL_VERSION, EVENT_INTELLIGENCE_SCHEMA_VERSION, EVENT_INTELLIGENCE_COMPATIBILITY, } from './version.js';
-export { RuntimeTargetSchema, EventSourceSchema, EventLineageSchema, McpEventOccurrenceSchema, SemanticConditionWireSchema, EventIngestRequestSchema, SemanticDecisionRecordSchema, WakeRecordSchema, LifecycleStateSchema, AuditKindSchema, AuditRecordSchema, parseEventIngestRequest, parseEventLineage, parseSemanticDecisionRecord, parseWakeRecord, parseAuditRecord, } from './schemas.js';
-export type { RuntimeTarget, McpEventOccurrence, SemanticConditionWire, EventIngestRequest, EventLineage, SemanticDecisionRecord, WakeRecord, LifecycleState, AuditRecord, } from './schemas.js';
+export { RuntimeTargetSchema, McpEventOccurrenceSchema, WakeRecordSchema, LifecycleStateSchema, AuditKindSchema, AuditRecordSchema, parseWakeRecord, parseAuditRecord, } from './schemas.js';
+export type { RuntimeTarget, McpEventOccurrence, WakeRecord, LifecycleState, AuditRecord, } from './schemas.js';
 export { canTransition, assertTransition, allowedTransitions, } from './lifecycle.js';
 export { canonicalJson, sha256Hex, } from './canonical.js';
 export { AuditChain, } from './audit.js';
 export type { AppendAuditInput, } from './audit.js';
-export { mapMcpEventToLineage, } from './mapper.js';
-export type { MapMcpEventInput, } from './mapper.js';
-export { assertDecisionLineage, assertWakeLineage, } from './invariants.js';
-export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, TemporalConditionSchema, ContinuationContextPolicySchema, ContinuationContractSchema, EventTimePolicySchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, PatternMatchStateSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
-export type { StructuredPredicate, TriggerClause, TemporalCondition, ContinuationContextPolicy, ContinuationContract, EventTimePolicy, DerivedEventDefinition, DerivedEventRecord, CompositeTriggerDefinition, CorrelatableEvent, TriggerSourceEvent, PatternMatchState, TriggerMatchRecord, CompositeCorrelationDecision, } from './triggerSchemas.js';
-export { TriggerPlanEventSchema, TriggerPlanMatchSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
-export type { TriggerPlanEvent, TriggerPlanMatch, TriggerPlanInput, } from './triggerPlanSchemas.js';
+export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, ContinuationContextPolicySchema, ContinuationContractSchema, EventTimePolicySchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, PatternSemanticDecisionSchema, TriggerMatchStatusSchema, PatternMatchStateSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
+export type { StructuredPredicate, TriggerClause, ContinuationContextPolicy, ContinuationContract, EventTimePolicy, DerivedEventDefinition, DerivedEventRecord, CompositeTriggerDefinition, CorrelatableEvent, TriggerSourceEvent, PatternMatchState, TriggerMatchRecord, PatternSemanticDecision, } from './triggerSchemas.js';
+export { TriggerPlanEventSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
+export type { TriggerPlanEvent, TriggerPlanInput, } from './triggerPlanSchemas.js';
 export { ActivationEvidenceSchema, ActivationEnvelopeSchema, parseActivationEnvelope, } from './activationSchemas.js';
 export type { ActivationEvidence, ActivationEnvelope, } from './activationSchemas.js';

package/dist/src/intelligenceProtocol/index.js

@@ -1,14 +1,11 @@
 export { PATTERN_AST_VERSION, PatternValueSelectorSchema, PatternArithmeticValueSchema, PatternCompareOperatorSchema, AggregateFunctionSchema, PatternWindowSchema, PatternNodeV2Schema, PatternPartitionDimensionSchema, PatternAfterMatchSchema, PatternSelectionSchema, PatternExecutionPolicySchema, PatternMeasureSchema, PatternAstV2DefinitionSchema, collectPatternDurationsMs, collectGuaranteedPatternBindings, collectPatternMeasureRefs, collectPatternRefs, } from './patternV2Schemas.js';
-export { compileLegacyTriggerToPatternV2, } from '../patternV2/legacyCompiler.js';
 export { evaluatePatternV2, evaluatePatternAggregate, evaluatePatternMeasure, patternV2CandidateSignature, } from '../patternV2/evaluator.js';
-export { TRIGGER_LANGUAGE_VERSION, PREDICATE_OPERATOR, COMPOSITION_OPERATOR, TEMPORAL_OPERATOR, TRIGGER_LANGUAGE_CATALOG, describeTriggerLanguage, } from './operatorRegistry.js';
+export { TRIGGER_LANGUAGE_VERSION, PREDICATE_OPERATOR, TRIGGER_LANGUAGE_CATALOG, describeTriggerLanguage, } from './operatorRegistry.js';
 export { EVENT_INTELLIGENCE_PROTOCOL, EVENT_INTELLIGENCE_PROTOCOL_VERSION, EVENT_INTELLIGENCE_SCHEMA_VERSION, EVENT_INTELLIGENCE_COMPATIBILITY, } from './version.js';
-export { RuntimeTargetSchema, EventSourceSchema, EventLineageSchema, McpEventOccurrenceSchema, SemanticConditionWireSchema, EventIngestRequestSchema, SemanticDecisionRecordSchema, WakeRecordSchema, LifecycleStateSchema, AuditKindSchema, AuditRecordSchema, parseEventIngestRequest, parseEventLineage, parseSemanticDecisionRecord, parseWakeRecord, parseAuditRecord, } from './schemas.js';
+export { RuntimeTargetSchema, McpEventOccurrenceSchema, WakeRecordSchema, LifecycleStateSchema, AuditKindSchema, AuditRecordSchema, parseWakeRecord, parseAuditRecord, } from './schemas.js';
 export { canTransition, assertTransition, allowedTransitions, } from './lifecycle.js';
 export { canonicalJson, sha256Hex, } from './canonical.js';
 export { AuditChain, } from './audit.js';
-export { mapMcpEventToLineage, } from './mapper.js';
-export { assertDecisionLineage, assertWakeLineage, } from './invariants.js';
-export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, TemporalConditionSchema, ContinuationContextPolicySchema, ContinuationContractSchema, EventTimePolicySchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, PatternMatchStateSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
-export { TriggerPlanEventSchema, TriggerPlanMatchSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
+export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, ContinuationContextPolicySchema, ContinuationContractSchema, EventTimePolicySchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, PatternSemanticDecisionSchema, TriggerMatchStatusSchema, PatternMatchStateSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
+export { TriggerPlanEventSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
 export { ActivationEvidenceSchema, ActivationEnvelopeSchema, parseActivationEnvelope, } from './activationSchemas.js';