mcp-event-intelligence 0.1.0 → 0.2.0

package/dist/src/composite/engine.js

@@ -2,169 +2,19 @@ import { SemanticConditionEngine } from '../semantic/conditionEngine.js';
 import { sha256Hex } from '../intelligenceProtocol/canonical.js';
 import { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerMatchRecordSchema, } from '../intelligenceProtocol/triggerSchemas.js';
 import { evaluateTemporalConditions, } from './temporal.js';
-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 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) {
-        case 'eq':
-            return value === predicate.value;
-        case 'neq':
-            return value !== predicate.value;
-        case 'contains':
-            if (typeof value === 'string')
-                return value.includes(String(predicate.value));
-            if (Array.isArray(value))
-                return value.includes(predicate.value);
-            return false;
-        case 'in':
-            return predicate.value.includes(value);
-        case 'exists':
-            return predicate.value ? value !== undefined : value === undefined;
-    }
-}
-function clauseMatches(clause, event) {
-    const contractVersion = getByPath(event.data, '_derived.contractVersion');
-    return (clause.event === event.name &&
-        (!clause.serverId || clause.serverId === event.serverId) &&
-        (!clause.contractVersion ||
-            String(contractVersion ?? '') === String(clause.contractVersion)) &&
-        clause.where.every((predicate) => predicateMatches(event, predicate)));
-}
-function asSourceEvent(clauseId, event) {
-    return {
-        clauseId,
-        traceId: event.traceId,
-        sourceEventId: event.sourceEventId,
-        eventName: event.name,
-        occurredAt: event.occurredAt,
-        ...(event.provider ? { provider: event.provider } : {}),
-        ...(event.serverId ? { serverId: event.serverId } : {}),
-        ...(event.payloadHash ? { payloadHash: event.payloadHash } : {}),
-        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));
-}
-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;
-}
-function semanticSource(record) {
-    const source = {};
-    for (const event of record.sourceEvents) {
-        source[event.clauseId] = event.data;
-    }
-    return source;
-}
-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));
-}
-function sameEventIdentity(source, event) {
-    return (source.sourceEventId === event.sourceEventId &&
-        (source.serverId ?? null) === (event.serverId ?? null));
-}
-function matchesCorrelationKey(record, key) {
-    if (record.correlationKey === null || key === null)
-        return true;
-    return record.correlationKey === key;
-}
-const DERIVED_SERVER_ID = 'event-intelligence:derived';
-function eventNode(eventName, serverId) {
-    return `${serverId || DERIVED_SERVER_ID}::${eventName}`;
-}
-function assertNoDerivedEventCycle(existing, candidate, getState) {
-    const definitions = [
-        ...existing.filter((definition) => {
-            const state = getState?.(definition.triggerId, definition.version);
-            return !state || state.status === 'active' || state.status === 'paused';
-        }),
-        candidate,
-    ].filter((definition) => definition.derivedEvent);
-    const graph = new Map();
-    for (const definition of definitions) {
-        const output = eventNode(definition.derivedEvent.name, DERIVED_SERVER_ID);
-        for (const clause of definition.clauses) {
-            const input = eventNode(clause.event, clause.serverId);
-            const edges = graph.get(input) ?? new Set();
-            edges.add(output);
-            graph.set(input, edges);
-        }
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const dfs = (node) => {
-        if (visiting.has(node))
-            return true;
-        if (visited.has(node))
-            return false;
-        visiting.add(node);
-        for (const next of graph.get(node) ?? []) {
-            if (dfs(next))
-                return true;
-        }
-        visiting.delete(node);
-        visited.add(node);
-        return false;
-    };
-    for (const node of graph.keys()) {
-        if (dfs(node)) {
-            const error = new Error(`Derived event graph contains a cycle involving ${node}`);
-            error.code = 'TRIGGER_DERIVED_EVENT_CYCLE';
-            throw error;
-        }
-    }
-}
+import { asSourceEvent, clauseMatches, deterministicKeyForClause, expressionSatisfied, matchesCorrelationKey, sameEventIdentity, semanticSource, } from './matching.js';
+import { assertNoDerivedEventCycle } from './derivedGraph.js';
+import { CompositeTriggerRuntimeSupport, } from './runtimeSupport.js';
 export class CompositeTriggerEngine {
     store;
     evaluator;
     now;
+    support;
     constructor(store, evaluator = null, now = () => new Date()) {
         this.store = store;
         this.evaluator = evaluator;
         this.now = now;
+        this.support = new CompositeTriggerRuntimeSupport(store, now);
     }
     async register(definitionInput) {
         const definition = CompositeTriggerDefinitionSchema.parse(definitionInput);
@@ -180,7 +30,7 @@ export class CompositeTriggerEngine {
         const results = [];
         for (const definition of this.store.listTriggers()) {
             const triggerState = this.store.getTriggerState?.(definition.triggerId, definition.version) ?? null;
-            if (!(await this.lifecycleAllows(definition, triggerState, this.now()))) {
+            if (!(await this.support.lifecycleAllows(definition, triggerState, this.now()))) {
                 continue;
             }
             const matchingClauses = definition.clauses.filter((clause) => clauseMatches(clause, event));
@@ -221,9 +71,9 @@ export class CompositeTriggerEngine {
             updatedAt: this.now().toISOString(),
         });
         await this.store.appendTriggerMatch(fired);
-        await this.cancelDeadlinesForMatch(matchId);
-        await this.audit(fired, 'trigger.fired', { wakeId });
-        await this.advanceLifecycleAfterEffect(fired, 'wake', wakeId);
+        await this.support.cancelDeadlinesForMatch(matchId);
+        await this.support.auditMatch(fired, 'trigger.fired', { wakeId });
+        await this.support.advanceLifecycleAfterEffect(fired, 'wake', wakeId);
         return fired;
     }
     async markDerivedEmitted(matchId, derivedEventId) {
@@ -246,11 +96,11 @@ export class CompositeTriggerEngine {
             ],
         });
         await this.store.appendTriggerMatch(emitted);
-        await this.cancelDeadlinesForMatch(matchId);
-        await this.audit(emitted, 'trigger.emitted', {
+        await this.support.cancelDeadlinesForMatch(matchId);
+        await this.support.auditMatch(emitted, 'trigger.emitted', {
             derivedEventId,
         });
-        await this.advanceLifecycleAfterEffect(emitted, 'derived_event', derivedEventId);
+        await this.support.advanceLifecycleAfterEffect(emitted, 'derived_event', derivedEventId);
         return emitted;
     }
     async ingestTimerEvent(event) {
@@ -265,7 +115,7 @@ export class CompositeTriggerEngine {
         if (!definition)
             return [];
         const triggerState = this.store.getTriggerState?.(definition.triggerId, definition.version) ?? null;
-        if (!(await this.lifecycleAllows(definition, triggerState, this.now()))) {
+        if (!(await this.support.lifecycleAllows(definition, triggerState, this.now()))) {
             return [];
         }
         const match = this.latestMatch(deadline.matchId);
@@ -283,8 +133,8 @@ export class CompositeTriggerEngine {
                 updatedAt: event.occurredAt,
             });
             await this.store.appendTriggerMatch(expired);
-            await this.cancelDeadlinesForMatch(expired.matchId);
-            await this.audit(expired, 'trigger.expired', {
+            await this.support.cancelDeadlinesForMatch(expired.matchId);
+            await this.support.auditMatch(expired, 'trigger.expired', {
                 reason: 'temporal_deadline_after_event_window',
             });
             return [{
@@ -323,8 +173,8 @@ export class CompositeTriggerEngine {
                 updatedAt: nowIso,
             });
             await this.store.appendTriggerMatch(expired);
-            await this.cancelDeadlinesForMatch(expired.matchId);
-            await this.audit(expired, 'trigger.expired', {
+            await this.support.cancelDeadlinesForMatch(expired.matchId);
+            await this.support.auditMatch(expired, 'trigger.expired', {
                 reason: 'window_expired_before_event',
             });
             record = await this.newMatch(definition, key, event);
@@ -343,7 +193,7 @@ export class CompositeTriggerEngine {
         }
         if (!expressionSatisfied(definition, record)) {
             await this.store.appendTriggerMatch(record);
-            await this.audit(record, 'trigger.partial', {
+            await this.support.auditMatch(record, 'trigger.partial', {
                 clauseId: clause.id,
                 sourceEventId: event.sourceEventId,
             });
@@ -366,8 +216,8 @@ export class CompositeTriggerEngine {
                 updatedAt: nowIso,
             });
             await this.store.appendTriggerMatch(expired);
-            await this.cancelDeadlinesForMatch(expired.matchId);
-            await this.audit(expired, 'trigger.expired', {
+            await this.support.cancelDeadlinesForMatch(expired.matchId);
+            await this.support.auditMatch(expired, 'trigger.expired', {
                 reason: 'temporal_condition_blocked',
                 temporal: temporal.conditionStates,
             });
@@ -384,8 +234,8 @@ export class CompositeTriggerEngine {
                 status: 'partial',
                 updatedAt: nowIso,
             }));
-            await this.scheduleDeadlines(definition, record, temporal.pendingDeadlines);
-            await this.audit(record, 'trigger.partial', {
+            await this.support.scheduleDeadlines(definition, record, temporal.pendingDeadlines);
+            await this.support.auditMatch(record, 'trigger.partial', {
                 reason: 'temporal_wait',
                 temporal: temporal.conditionStates,
             });
@@ -396,11 +246,11 @@ export class CompositeTriggerEngine {
                 fired: false,
             };
         }
-        await this.cancelDeadlinesForMatch(record.matchId);
+        await this.support.cancelDeadlinesForMatch(record.matchId);
         if (definition.correlation?.semantic) {
             if (!this.evaluator) {
                 await this.store.appendTriggerMatch(record);
-                await this.audit(record, 'trigger.partial', {
+                await this.support.auditMatch(record, 'trigger.partial', {
                     reason: 'semantic_evaluator_unavailable',
                 });
                 return {
@@ -434,7 +284,7 @@ export class CompositeTriggerEngine {
                 updatedAt: nowIso,
             });
             await this.store.appendTriggerMatch(record);
-            await this.audit(record, 'trigger.correlation', {
+            await this.support.auditMatch(record, 'trigger.correlation', {
                 outcome: decision.outcome,
                 probability: decision.probability,
                 evaluator: decision.evaluator,
@@ -454,7 +304,7 @@ export class CompositeTriggerEngine {
             updatedAt: nowIso,
         });
         await this.store.appendTriggerMatch(matched);
-        await this.audit(matched, 'trigger.matched', {
+        await this.support.auditMatch(matched, 'trigger.matched', {
             sourceEventIds: matched.sourceEvents.map((item) => item.sourceEventId),
             temporal: temporal.conditionStates,
         });
@@ -465,156 +315,6 @@ export class CompositeTriggerEngine {
             fired: false,
         };
     }
-    async scheduleDeadlines(definition, record, deadlines) {
-        if (!this.store.putTemporalDeadline)
-            return;
-        for (const deadline of deadlines) {
-            const deadlineId = `td_${(await sha256Hex([
-                definition.triggerId,
-                definition.version,
-                record.matchId,
-                deadline.conditionId,
-                deadline.dueAt,
-            ].join(':'))).slice(0, 24)}`;
-            const existing = this.store.getTemporalDeadline?.(deadlineId);
-            if (existing?.status === 'pending' || existing?.status === 'fired') {
-                continue;
-            }
-            await this.store.putTemporalDeadline({
-                deadlineId,
-                triggerId: definition.triggerId,
-                triggerVersion: definition.version,
-                matchId: record.matchId,
-                conditionId: deadline.conditionId,
-                dueAt: deadline.dueAt,
-                status: 'pending',
-            });
-        }
-    }
-    async cancelDeadlinesForMatch(matchId) {
-        if (!this.store.listTemporalDeadlines ||
-            !this.store.setTemporalDeadlineStatus)
-            return;
-        const pending = this.store.listTemporalDeadlines({
-            matchId,
-            status: 'pending',
-        });
-        for (const deadline of pending) {
-            await this.store.setTemporalDeadlineStatus(deadline.deadlineId, 'cancelled');
-        }
-    }
-    async advanceLifecycleAfterEffect(match, effectKind, effectId) {
-        const definition = this.store.listTriggers().find((candidate) => candidate.triggerId === match.triggerId &&
-            candidate.version === match.triggerVersion);
-        const triggerState = this.store.getTriggerState?.(match.triggerId, match.triggerVersion) ?? null;
-        if (!definition || !this.store.setTriggerState)
-            return;
-        const previousCount = triggerState?.fireCount ?? 0;
-        const fireCount = previousCount + 1;
-        const lifecycle = definition.lifecycle ?? {};
-        const complete = lifecycle.oneShot === true ||
-            lifecycle.completeOnGoal === true ||
-            (lifecycle.maxFirings !== undefined &&
-                fireCount >= lifecycle.maxFirings);
-        const nextStatus = complete ? 'completed' : 'active';
-        const effectAt = this.now().toISOString();
-        await this.store.setTriggerState(match.triggerId, match.triggerVersion, nextStatus, {
-            type: 'system',
-            principal_id: 'event-intelligence:lifecycle',
-        }, {
-            owner: triggerState?.owner ?? null,
-            connectionIds: triggerState?.connectionIds ?? [],
-            fireCount,
-            lastFiredAt: effectAt,
-        });
-        if (complete) {
-            await this.auditTriggerLifecycle(definition, 'trigger.completed', {
-                reason: lifecycle.oneShot
-                    ? 'one_shot'
-                    : lifecycle.completeOnGoal
-                        ? 'complete_on_goal'
-                        : 'max_firings',
-                fireCount,
-                effectKind,
-                effectId,
-            });
-        }
-    }
-    async lifecycleAllows(definition, state, now) {
-        const lifecycle = definition.lifecycle ?? {};
-        const effectiveState = state ?? {
-            status: 'active',
-            fireCount: 0,
-            lastFiredAt: null,
-            connectionIds: [],
-            owner: null,
-        };
-        if (effectiveState.status !== 'active')
-            return false;
-        const expiresAt = lifecycle.expiresAt
-            ? Date.parse(lifecycle.expiresAt)
-            : Number.POSITIVE_INFINITY;
-        const leaseUntil = lifecycle.leaseUntil
-            ? Date.parse(lifecycle.leaseUntil)
-            : Number.POSITIVE_INFINITY;
-        if (now.getTime() > Math.min(expiresAt, leaseUntil)) {
-            if (this.store.setTriggerState) {
-                await this.store.setTriggerState(definition.triggerId, definition.version, 'expired', {
-                    type: 'system',
-                    principal_id: 'event-intelligence:lifecycle',
-                }, {
-                    owner: effectiveState.owner ?? null,
-                    connectionIds: effectiveState.connectionIds ?? [],
-                    fireCount: effectiveState.fireCount ?? 0,
-                    lastFiredAt: effectiveState.lastFiredAt ?? null,
-                });
-            }
-            await this.auditTriggerLifecycle(definition, 'trigger.lifecycle_expired', {
-                expiresAt: lifecycle.expiresAt ?? null,
-                leaseUntil: lifecycle.leaseUntil ?? null,
-            });
-            return false;
-        }
-        const fireCount = effectiveState.fireCount ?? 0;
-        if ((lifecycle.oneShot && fireCount >= 1) ||
-            (lifecycle.maxFirings !== undefined &&
-                fireCount >= lifecycle.maxFirings)) {
-            if (this.store.setTriggerState) {
-                await this.store.setTriggerState(definition.triggerId, definition.version, 'completed', {
-                    type: 'system',
-                    principal_id: 'event-intelligence:lifecycle',
-                }, {
-                    owner: effectiveState.owner ?? null,
-                    connectionIds: effectiveState.connectionIds ?? [],
-                    fireCount,
-                    lastFiredAt: effectiveState.lastFiredAt ?? null,
-                });
-            }
-            return false;
-        }
-        if (lifecycle.cooldownMs > 0 &&
-            effectiveState.lastFiredAt &&
-            now.getTime() - Date.parse(effectiveState.lastFiredAt) <
-                lifecycle.cooldownMs) {
-            return false;
-        }
-        return true;
-    }
-    async auditTriggerLifecycle(definition, kind, details) {
-        const timestamp = this.now().toISOString();
-        await this.store.appendAudit({
-            auditId: `audit_${(await sha256Hex(`${definition.triggerId}:${definition.version}:${kind}:${timestamp}`)).slice(0, 24)}`,
-            traceId: `trigger:${definition.triggerId}`,
-            timestamp,
-            kind,
-            entityType: 'trigger',
-            entityId: definition.triggerId,
-            details: {
-                triggerVersion: definition.version,
-                ...details,
-            },
-        });
-    }
     async newMatch(definition, key, event) {
         const openedAt = event.occurredAt;
         const expiresAt = new Date(Date.parse(openedAt) + definition.withinMs).toISOString();
@@ -647,21 +347,4 @@ export class CompositeTriggerEngine {
             .filter((record) => record.matchId === matchId)
             .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0] ?? null;
     }
-    async audit(record, kind, details = {}) {
-        await this.store.appendAudit({
-            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${this.store.listTriggerMatches().length}`)).slice(0, 24)}`,
-            traceId: record.sourceEvents[0]?.traceId ?? record.matchId,
-            timestamp: this.now().toISOString(),
-            kind,
-            entityType: 'trigger_match',
-            entityId: record.matchId,
-            details: {
-                triggerId: record.triggerId,
-                triggerVersion: record.triggerVersion,
-                status: record.status,
-                correlationKey: record.correlationKey,
-                ...details,
-            },
-        });
-    }
 }

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

@@ -0,0 +1,8 @@
+import type { CompositeTriggerDefinition, CorrelatableEvent, TriggerClause, TriggerMatchRecord, 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'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId'>): boolean;
+export declare function matchesCorrelationKey(record: TriggerMatchRecord, key: string | null): boolean;

package/dist/src/composite/matching.js

@@ -0,0 +1,109 @@
+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 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) {
+        case 'eq':
+            return value === predicate.value;
+        case 'neq':
+            return value !== predicate.value;
+        case 'contains':
+            if (typeof value === 'string')
+                return value.includes(String(predicate.value));
+            if (Array.isArray(value))
+                return value.includes(predicate.value);
+            return false;
+        case 'in':
+            return predicate.value.includes(value);
+        case 'exists':
+            return predicate.value ? value !== undefined : value === undefined;
+    }
+}
+export function clauseMatches(clause, event) {
+    const contractVersion = getByPath(event.data, '_derived.contractVersion');
+    return (clause.event === event.name &&
+        (!clause.serverId || clause.serverId === event.serverId) &&
+        (!clause.contractVersion ||
+            String(contractVersion ?? '') === String(clause.contractVersion)) &&
+        clause.where.every((predicate) => predicateMatches(event, predicate)));
+}
+export function asSourceEvent(clauseId, event) {
+    return {
+        clauseId,
+        traceId: event.traceId,
+        sourceEventId: event.sourceEventId,
+        eventName: event.name,
+        occurredAt: event.occurredAt,
+        ...(event.provider ? { provider: event.provider } : {}),
+        ...(event.serverId ? { serverId: event.serverId } : {}),
+        ...(event.payloadHash ? { payloadHash: event.payloadHash } : {}),
+        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));
+}
+export function matchesCorrelationKey(record, key) {
+    if (record.correlationKey === null || key === null)
+        return true;
+    return record.correlationKey === key;
+}

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

@@ -0,0 +1,24 @@
+import type { CompositeTriggerDefinition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
+import type { CompositeTriggerAudit, CompositeTriggerStore } from './store.js';
+type TriggerState = {
+    status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted';
+    owner?: unknown;
+    connectionIds?: string[];
+    fireCount?: number;
+    lastFiredAt?: string | null;
+};
+export declare class CompositeTriggerRuntimeSupport {
+    private readonly store;
+    private readonly now;
+    constructor(store: CompositeTriggerStore & CompositeTriggerAudit, now?: () => Date);
+    scheduleDeadlines(definition: CompositeTriggerDefinition, record: TriggerMatchRecord, deadlines: Array<{
+        conditionId: string;
+        dueAt: string;
+    }>): Promise<void>;
+    cancelDeadlinesForMatch(matchId: string): Promise<void>;
+    advanceLifecycleAfterEffect(match: TriggerMatchRecord, effectKind: 'wake' | 'derived_event', effectId: string): Promise<void>;
+    lifecycleAllows(definition: CompositeTriggerDefinition, state: TriggerState | null, now: Date): Promise<boolean>;
+    auditTriggerLifecycle(definition: CompositeTriggerDefinition, kind: string, details: Record<string, unknown>): Promise<void>;
+    auditMatch(record: TriggerMatchRecord, kind: 'trigger.partial' | 'trigger.matched' | 'trigger.fired' | 'trigger.emitted' | 'trigger.expired' | 'trigger.correlation', details?: Record<string, unknown>): Promise<void>;
+}
+export {};