mcp-event-intelligence 0.1.0

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -0,0 +1,379 @@
+import { z } from 'zod';
+import { RuntimeTargetSchema } from './schemas.js';
+export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.1.0';
+export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.1';
+const Id = z.string().min(1).max(200);
+const Timestamp = z.string().datetime({ offset: true });
+const Scalar = z.union([z.string(), z.number(), z.boolean()]);
+const ClockTime = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
+const CalendarDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+export const StructuredPredicateSchema = z.discriminatedUnion('op', [
+    z.object({ path: z.string().min(1), op: z.literal('eq'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('neq'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('contains'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('in'), value: z.array(Scalar).min(1) }),
+    z.object({ path: z.string().min(1), op: z.literal('exists'), value: z.boolean().default(true) }),
+]);
+export const TriggerClauseSchema = z.object({
+    id: Id,
+    event: z.string().min(1),
+    serverId: Id.optional(),
+    contractVersion: z.string().min(1).max(50).optional(),
+    where: z.array(StructuredPredicateSchema).default([]),
+});
+const TriggerExpressionSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('allOf'), refs: z.array(Id).min(2) }),
+    z.object({ kind: z.literal('anyOf'), refs: z.array(Id).min(1) }),
+    z.object({ kind: z.literal('sequence'), refs: z.array(Id).min(2) }),
+    z.object({ kind: z.literal('count'), ref: Id, atLeast: z.number().int().min(1) }),
+]);
+export const CalendarTemporalConditionSchema = z.object({
+    id: Id,
+    kind: z.literal('calendar'),
+    ref: Id,
+    timezone: z.string().min(1),
+    before: ClockTime.optional(),
+    after: ClockTime.optional(),
+    weekdays: z.array(z.number().int().min(1).max(7)).min(1).optional(),
+    dates: z.array(CalendarDate).min(1).optional(),
+    dateRange: z.object({
+        start: CalendarDate,
+        end: CalendarDate,
+    }).optional(),
+    dayOfMonth: z.array(z.number().int().min(1).max(31)).min(1).optional(),
+}).strict();
+export const AbsenceTemporalConditionSchema = z.object({
+    id: Id,
+    kind: z.literal('absence'),
+    ref: Id,
+    afterRef: Id,
+    forMs: z.number().int().positive().optional(),
+    untilLocalTime: ClockTime.optional(),
+    timezone: z.string().min(1).optional(),
+}).superRefine((value, ctx) => {
+    if (!value.forMs && !value.untilLocalTime) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'absence requires forMs or untilLocalTime',
+        });
+    }
+    if (value.untilLocalTime && !value.timezone) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'absence untilLocalTime requires timezone',
+        });
+    }
+});
+export const TemporalConditionSchema = z.discriminatedUnion('kind', [
+    CalendarTemporalConditionSchema,
+    AbsenceTemporalConditionSchema,
+    z.object({ id: Id, kind: z.literal('not'), ref: Id }),
+    z.object({ id: Id, kind: z.literal('unless'), ref: Id }),
+    z.object({ id: Id, kind: z.literal('after'), ref: Id, afterRef: Id }),
+    z.object({ id: Id, kind: z.literal('until'), ref: Id, beforeRef: Id }),
+    z.object({
+        id: Id,
+        kind: z.literal('debounce'),
+        ref: Id,
+        forMs: z.number().int().positive(),
+    }),
+    z.object({
+        id: Id,
+        kind: z.literal('threshold'),
+        ref: Id,
+        atLeast: z.number().int().min(1),
+    }),
+    z.object({
+        id: Id,
+        kind: z.literal('rate'),
+        ref: Id,
+        atLeast: z.number().int().min(1),
+        perMs: z.number().int().positive(),
+    }),
+    z.object({
+        id: Id,
+        kind: z.literal('distinct'),
+        ref: Id,
+        path: z.string().min(1),
+        atLeast: z.number().int().min(1),
+    }),
+]);
+export const DerivedEventProjectionSchema = z.object({
+    key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/),
+    ref: Id,
+    path: z.string().min(1),
+}).strict();
+export const DerivedEventDefinitionSchema = z.object({
+    name: z.string().min(1).max(200),
+    contractVersion: z.string().min(1).max(50),
+    projections: z.array(DerivedEventProjectionSchema).max(32).default([]),
+    constants: z.record(z.string(), Scalar).default({}),
+}).strict();
+export const DerivedEventEvidenceRefSchema = z.object({
+    serverId: Id.nullable(),
+    eventName: z.string().min(1),
+    sourceEventId: Id,
+    traceId: Id,
+    occurredAt: Timestamp,
+    payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+    contractVersion: z.string().min(1).nullable().optional(),
+    schemaFingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().optional(),
+}).strict();
+export const TriggerLifecyclePolicySchema = z.object({
+    oneShot: z.boolean().default(false),
+    maxFirings: z.number().int().min(1).optional(),
+    cooldownMs: z.number().int().nonnegative().default(0),
+    expiresAt: Timestamp.optional(),
+    leaseUntil: Timestamp.optional(),
+    completeOnGoal: z.boolean().default(false),
+}).superRefine((value, ctx) => {
+    if (value.oneShot && value.maxFirings && value.maxFirings !== 1) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'oneShot is incompatible with maxFirings other than 1',
+        });
+    }
+    if (value.expiresAt &&
+        value.leaseUntil &&
+        Date.parse(value.leaseUntil) > Date.parse(value.expiresAt)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'leaseUntil cannot be after expiresAt',
+        });
+    }
+});
+export const DeterministicCorrelationSchema = z.object({
+    kind: z.literal('same_value'),
+    fields: z.array(z.object({
+        ref: Id,
+        path: z.string().min(1),
+    })).min(2),
+});
+export const SemanticCorrelationSchema = z.object({
+    instruction: z.string().min(1),
+    input: z.array(z.string().min(1)).min(1),
+    matchThreshold: z.number().min(0).max(1),
+    rejectThreshold: z.number().min(0).max(1),
+    uncertain: z.enum(['escalate', 'reject', 'match']).default('escalate'),
+});
+export const CompositeTriggerDefinitionSchema = z.object({
+    protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION)
+        .default(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
+    schemaVersion: z.literal(COMPOSITE_TRIGGER_SCHEMA_VERSION)
+        .default(COMPOSITE_TRIGGER_SCHEMA_VERSION),
+    triggerId: Id,
+    version: z.string().min(1),
+    description: z.string().max(500).optional(),
+    clauses: z.array(TriggerClauseSchema).min(1),
+    expression: TriggerExpressionSchema,
+    temporal: z.array(TemporalConditionSchema).default([]),
+    lifecycle: TriggerLifecyclePolicySchema.default({
+        oneShot: false,
+        cooldownMs: 0,
+        completeOnGoal: false,
+    }),
+    withinMs: z.number().int().positive().max(1000 * 60 * 60 * 24 * 30),
+    correlation: z.object({
+        deterministic: DeterministicCorrelationSchema.optional(),
+        semantic: SemanticCorrelationSchema.optional(),
+    }).optional(),
+    target: RuntimeTargetSchema.optional(),
+    derivedEvent: DerivedEventDefinitionSchema.optional(),
+}).superRefine((value, ctx) => {
+    if (!value.target && !value.derivedEvent) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Trigger requires target, derivedEvent, or both',
+        });
+    }
+    const ids = new Set(value.clauses.map((clause) => clause.id));
+    if (ids.size !== value.clauses.length) {
+        ctx.addIssue({ code: 'custom', message: 'Trigger clause ids must be unique' });
+    }
+    const refs = value.expression.kind === 'count'
+        ? [value.expression.ref]
+        : value.expression.refs;
+    for (const ref of refs) {
+        if (!ids.has(ref)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Expression references unknown clause: ${ref}`,
+            });
+        }
+    }
+    for (const field of value.correlation?.deterministic?.fields ?? []) {
+        if (!ids.has(field.ref)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Correlation references unknown clause: ${field.ref}`,
+            });
+        }
+    }
+    if (value.derivedEvent) {
+        const projectionKeys = new Set();
+        for (const projection of value.derivedEvent.projections) {
+            if (!ids.has(projection.ref)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event projection references unknown clause: ${projection.ref}`,
+                });
+            }
+            if (projectionKeys.has(projection.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event projection key must be unique: ${projection.key}`,
+                });
+            }
+            if (projection.key === '_derived') {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'Derived event projection key _derived is reserved',
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(value.derivedEvent.constants, projection.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both constant and projection: ${projection.key}`,
+                });
+            }
+            projectionKeys.add(projection.key);
+        }
+        if (Object.prototype.hasOwnProperty.call(value.derivedEvent.constants, '_derived')) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'Derived event constant key _derived is reserved',
+            });
+        }
+    }
+    const conditionIds = new Set();
+    for (const condition of value.temporal) {
+        if (conditionIds.has(condition.id)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Temporal condition id must be unique: ${condition.id}`,
+            });
+        }
+        conditionIds.add(condition.id);
+        const conditionRefs = [];
+        if ('ref' in condition)
+            conditionRefs.push(condition.ref);
+        if ('afterRef' in condition)
+            conditionRefs.push(condition.afterRef);
+        if ('beforeRef' in condition)
+            conditionRefs.push(condition.beforeRef);
+        for (const ref of conditionRefs) {
+            if (!ids.has(ref)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Temporal condition ${condition.id} references unknown clause: ${ref}`,
+                });
+            }
+        }
+        if (condition.kind === 'calendar') {
+            try {
+                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
+            }
+            catch {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Invalid IANA timezone: ${condition.timezone}`,
+                });
+            }
+            if (condition.before &&
+                condition.after &&
+                condition.before === condition.after) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'calendar before and after cannot be identical',
+                });
+            }
+        }
+        if (condition.kind === 'absence' &&
+            condition.timezone) {
+            try {
+                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
+            }
+            catch {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Invalid IANA timezone: ${condition.timezone}`,
+                });
+            }
+        }
+    }
+});
+export const CorrelatableEventSchema = z.object({
+    traceId: Id,
+    sourceEventId: Id,
+    name: z.string().min(1),
+    occurredAt: Timestamp,
+    provider: z.string().min(1).optional(),
+    serverId: Id.optional(),
+    payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    data: z.record(z.string(), z.unknown()),
+});
+export const DerivedEventRecordSchema = z.object({
+    event: CorrelatableEventSchema,
+    triggerId: Id,
+    triggerVersion: z.string().min(1),
+    matchId: Id,
+    directParents: z.array(DerivedEventEvidenceRefSchema).min(1),
+    rootEvidence: z.array(DerivedEventEvidenceRefSchema).min(1),
+    createdAt: Timestamp,
+}).strict();
+export const TriggerSourceEventSchema = z.object({
+    clauseId: Id,
+    traceId: Id,
+    sourceEventId: Id,
+    eventName: z.string().min(1),
+    occurredAt: Timestamp,
+    provider: z.string().min(1).optional(),
+    serverId: Id.optional(),
+    payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    data: z.record(z.string(), z.unknown()),
+});
+export const CompositeCorrelationDecisionSchema = z.object({
+    evaluator: z.string().min(1),
+    outcome: z.enum(['match', 'reject', 'uncertain']),
+    probability: z.number().min(0).max(1),
+    matched: z.boolean(),
+    shouldEscalate: z.boolean(),
+    inputFields: z.array(z.string().min(1)),
+    providerEvidence: z.record(z.string(), z.unknown()).optional(),
+    evaluatedAt: Timestamp,
+});
+export const TriggerMatchStatusSchema = z.enum([
+    'partial',
+    'matched',
+    'emitted',
+    'fired',
+    'expired',
+]);
+export const TriggerMatchRecordSchema = z.object({
+    protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
+    schemaVersion: z.literal(COMPOSITE_TRIGGER_SCHEMA_VERSION),
+    matchId: Id,
+    triggerId: Id,
+    triggerVersion: z.string().min(1),
+    status: TriggerMatchStatusSchema,
+    correlationKey: z.string().nullable(),
+    openedAt: Timestamp,
+    expiresAt: Timestamp,
+    updatedAt: Timestamp,
+    sourceEvents: z.array(TriggerSourceEventSchema),
+    correlationDecision: CompositeCorrelationDecisionSchema.nullable(),
+    firedWakeId: Id.nullable(),
+    derivedEventIds: z.array(Id).default([]),
+});
+export function parseCompositeTriggerDefinition(value) {
+    return CompositeTriggerDefinitionSchema.parse(value);
+}
+export function parseCorrelatableEvent(value) {
+    return CorrelatableEventSchema.parse(value);
+}
+export function parseTriggerMatchRecord(value) {
+    return TriggerMatchRecordSchema.parse(value);
+}
+export function parseDerivedEventRecord(value) {
+    return DerivedEventRecordSchema.parse(value);
+}

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

@@ -0,0 +1,7 @@
+export declare const EVENT_INTELLIGENCE_PROTOCOL: "mcp-event-intelligence";
+export declare const EVENT_INTELLIGENCE_PROTOCOL_VERSION: "0.1.0";
+export declare const EVENT_INTELLIGENCE_SCHEMA_VERSION: "ei.v0.1";
+export declare const EVENT_INTELLIGENCE_COMPATIBILITY: {
+    readonly mcpEvents: "experimental-ext-triggers-events/design-sketch";
+    readonly mcpCore: "2026-07-28";
+};

package/dist/src/intelligenceProtocol/version.js

@@ -0,0 +1,7 @@
+export const EVENT_INTELLIGENCE_PROTOCOL = 'mcp-event-intelligence';
+export const EVENT_INTELLIGENCE_PROTOCOL_VERSION = '0.1.0';
+export const EVENT_INTELLIGENCE_SCHEMA_VERSION = 'ei.v0.1';
+export const EVENT_INTELLIGENCE_COMPATIBILITY = {
+    mcpEvents: 'experimental-ext-triggers-events/design-sketch',
+    mcpCore: '2026-07-28',
+};

package/dist/src/mcpEvents/consumer.d.ts

@@ -0,0 +1,7 @@
+import type { EventOccurrence } from '../protocol/types.js';
+import { type CorrelatableEvent } from '../intelligenceProtocol/triggerSchemas.js';
+export declare function mcpOccurrenceToCorrelatableEvent(event: EventOccurrence, input: {
+    traceId: string;
+    provider?: string;
+    serverId?: string;
+}): Promise<CorrelatableEvent>;

package/dist/src/mcpEvents/consumer.js

@@ -0,0 +1,14 @@
+import { sha256Hex } from '../intelligenceProtocol/canonical.js';
+import { CorrelatableEventSchema, } from '../intelligenceProtocol/triggerSchemas.js';
+export async function mcpOccurrenceToCorrelatableEvent(event, input) {
+    return CorrelatableEventSchema.parse({
+        traceId: input.traceId,
+        sourceEventId: event.eventId,
+        name: event.name,
+        occurredAt: event.timestamp,
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(input.serverId ? { serverId: input.serverId } : {}),
+        payloadHash: await sha256Hex(event.data),
+        data: event.data,
+    });
+}

package/dist/src/mcpEvents/server.d.ts

@@ -0,0 +1,41 @@
+import type { EventDescriptor, EventOccurrence, JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
+export interface PersistedMcpOccurrence {
+    sequence: number;
+    serverId: string;
+    event: EventOccurrence;
+}
+export interface McpEventOccurrenceStore {
+    latestMcpEventSequence(): number;
+    listMcpOccurrencesAfter(sequence: number): PersistedMcpOccurrence[];
+}
+export interface RegisteredMcpEvent {
+    descriptor: EventDescriptor;
+    matcher: (args: Record<string, unknown>, event: EventOccurrence) => boolean;
+}
+export interface PollEventsParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+    cursor?: string | null;
+    maxAgeMs?: number;
+    maxEvents?: number;
+}
+export interface PollEventsResult {
+    events: EventOccurrence[];
+    cursor: string;
+    truncated: boolean;
+    hasMore: boolean;
+    nextPollMs: number;
+}
+export declare function encodeMcpEventCursor(sequence: number): string;
+export declare function decodeMcpEventCursor(cursor: string): number;
+export declare class ExperimentalMcpEventsServer {
+    private readonly store;
+    private readonly now;
+    private readonly events;
+    constructor(store: McpEventOccurrenceStore, now?: () => Date);
+    registerEvent(event: RegisteredMcpEvent): void;
+    handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    poll(params: PollEventsParams): PollEventsResult;
+    private ok;
+    private error;
+}

package/dist/src/mcpEvents/server.js

@@ -0,0 +1,122 @@
+const CURSOR_PREFIX = 'mcp-events-v1:';
+export function encodeMcpEventCursor(sequence) {
+    return `${CURSOR_PREFIX}${sequence}`;
+}
+export function decodeMcpEventCursor(cursor) {
+    if (!cursor.startsWith(CURSOR_PREFIX)) {
+        throw new Error('Invalid MCP Events cursor');
+    }
+    const value = Number(cursor.slice(CURSOR_PREFIX.length));
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error('Invalid MCP Events cursor');
+    }
+    return value;
+}
+export class ExperimentalMcpEventsServer {
+    store;
+    now;
+    events = new Map();
+    constructor(store, now = () => new Date()) {
+        this.store = store;
+        this.now = now;
+    }
+    registerEvent(event) {
+        this.events.set(event.descriptor.name, event);
+    }
+    async handleRequest(request) {
+        try {
+            switch (request.method) {
+                case 'server/discover':
+                    return this.ok(request.id, {
+                        supportedVersions: ['2026-07-28'],
+                        capabilities: {
+                            experimental: {
+                                'io.modelcontextprotocol.experimental/events': {
+                                    status: 'draft',
+                                    designDate: '2026-02-19',
+                                    methods: ['events/list', 'events/poll'],
+                                    listChanged: false,
+                                },
+                            },
+                        },
+                        instructions: 'Experimental MCP Events provider. Events follow the Triggers & Events WG design sketch; this is not finalized MCP conformance.',
+                    });
+                case 'events/list':
+                    return this.ok(request.id, {
+                        events: [...this.events.values()].map((entry) => entry.descriptor),
+                    });
+                case 'events/poll':
+                    return this.ok(request.id, this.poll((request.params ?? {})));
+                default:
+                    return this.error(request.id, -32601, `Method not found: ${request.method}`);
+            }
+        }
+        catch (error) {
+            return this.error(request.id, -32602, error instanceof Error ? error.message : 'Invalid params');
+        }
+    }
+    poll(params) {
+        const registered = this.events.get(params.name);
+        if (!registered) {
+            throw new Error(`Unknown event: ${params.name}`);
+        }
+        const latest = this.store.latestMcpEventSequence();
+        if (params.cursor === null || params.cursor === undefined) {
+            return {
+                events: [],
+                cursor: encodeMcpEventCursor(latest),
+                truncated: false,
+                hasMore: false,
+                nextPollMs: 5000,
+            };
+        }
+        const start = decodeMcpEventCursor(params.cursor);
+        const limit = Math.max(1, Math.min(params.maxEvents ?? 50, 500));
+        const minTimestamp = params.maxAgeMs === undefined
+            ? Number.NEGATIVE_INFINITY
+            : this.now().getTime() - params.maxAgeMs;
+        const candidates = this.store.listMcpOccurrencesAfter(start);
+        const args = params.arguments ?? {};
+        const events = [];
+        let cursorSequence = start;
+        let truncated = false;
+        let stoppedIndex = candidates.length;
+        for (let index = 0; index < candidates.length; index += 1) {
+            const record = candidates[index];
+            cursorSequence = record.sequence;
+            if (record.event.name !== params.name)
+                continue;
+            if (Date.parse(record.event.timestamp) < minTimestamp) {
+                truncated = true;
+                continue;
+            }
+            if (!registered.matcher(args, record.event))
+                continue;
+            events.push(record.event);
+            if (events.length >= limit) {
+                stoppedIndex = index + 1;
+                break;
+            }
+        }
+        const remaining = candidates.slice(stoppedIndex);
+        const hasMore = remaining.some((record) => record.event.name === params.name &&
+            Date.parse(record.event.timestamp) >= minTimestamp &&
+            registered.matcher(args, record.event));
+        if (!hasMore && candidates.length > 0) {
+            cursorSequence = candidates[candidates.length - 1].sequence;
+        }
+        return {
+            events,
+            cursor: encodeMcpEventCursor(cursorSequence),
+            truncated,
+            hasMore,
+            nextPollMs: hasMore ? 0 : 5000,
+        };
+    }
+    ok(id, result) {
+        return { jsonrpc: '2.0', id, result };
+    }
+    error(id, code, message) {
+        return { jsonrpc: '2.0', id, error: { code, message } };
+    }
+}

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

@@ -0,0 +1,37 @@
+export type JsonRpcId = string | number;
+export interface JsonRpcRequest<T = unknown> {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    method: string;
+    params?: T;
+}
+export interface JsonRpcSuccess<T = unknown> {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result: T;
+}
+export interface JsonRpcError {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type JsonRpcResponse<T = unknown> = JsonRpcSuccess<T> | JsonRpcError;
+export interface EventDescriptor {
+    name: string;
+    description: string;
+    delivery: Array<'poll' | 'push' | 'webhook'>;
+    inputSchema: Record<string, unknown>;
+    payloadSchema: Record<string, unknown>;
+}
+export interface EventOccurrence<TData extends Record<string, unknown> = Record<string, unknown>> {
+    eventId: string;
+    name: string;
+    timestamp: string;
+    data: TData;
+    cursor?: string | null;
+    _meta?: Record<string, unknown>;
+}

package/dist/src/protocol/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import type { SemanticBooleanCondition, SemanticDecision, SemanticEvaluator } from './types.js';
+export declare function projectSemanticInput(source: Record<string, unknown>, paths: string[]): Record<string, unknown>;
+export declare class SemanticConditionEngine {
+    private readonly evaluator;
+    constructor(evaluator: SemanticEvaluator);
+    evaluate(source: Record<string, unknown>, condition: SemanticBooleanCondition): Promise<SemanticDecision>;
+}