@evomap/evolver-core 2.0.0-beta.0

package/dist/events/reports.d.ts

@@ -0,0 +1,90 @@
+import { type CycleFailureClass } from '../algo/cycleFailureClassifier.js';
+/** root_events 行(报表读视图). */
+export interface ReportEvent {
+    type: string;
+    seq: number;
+    ts: string;
+    human?: {
+        title?: string;
+        detail?: string;
+        why?: string;
+        next?: string;
+        severity?: string;
+    };
+    payload?: Record<string, unknown>;
+}
+export declare function readEvents(eventsPath?: string): ReportEvent[];
+export interface StatusReport {
+    totalEvents: number;
+    byType: Record<string, number>;
+    cycles: number;
+    lastTs: string | null;
+}
+export declare function statusReport(evts: readonly ReportEvent[]): StatusReport;
+export interface CycleSummary {
+    cycleId: string;
+    events: number;
+    finalStage: string;
+    lastTs: string;
+    failureClass?: CycleFailureClass;
+    failureSuppressed?: boolean;
+}
+export declare function listCycles(evts: readonly ReportEvent[]): CycleSummary[];
+export interface CycleTimeline {
+    cycleId: string;
+    timeline: Array<{
+        type: string;
+        title: string;
+        why?: string;
+        ts: string;
+        seq: number;
+        payload?: Record<string, unknown>;
+    }>;
+}
+export declare function showCycle(evts: readonly ReportEvent[], cycleId: string): CycleTimeline;
+export interface TriggerRow {
+    patternId: string;
+    triggered: boolean;
+    value: number;
+    reasons: string[];
+}
+export declare function listTriggers(evts: readonly ReportEvent[]): TriggerRow[];
+/** 每日总结(保活, M7-4): 当日 cycle 数/成功率/触发数. */
+export interface DailySummary {
+    date: string;
+    cycles: number;
+    solidified: number;
+    failed: number;
+    triggered: number;
+    suppressed: number;
+    failureBuckets: Partial<Record<CycleFailureClass, number>>;
+    suppressedFailures: number;
+}
+export declare function dailySummary(evts: readonly ReportEvent[], dayPrefix: string): DailySummary;
+export type NarrativeOutcome = 'success' | 'failed' | 'inert' | 'unknown';
+export interface NarrativeEntry {
+    seq: number;
+    ts: string;
+    type: string;
+    title: string;
+    cycleId?: string;
+    summary?: string;
+    action?: string;
+    outcome?: NarrativeOutcome;
+    geneId?: string;
+    score?: number;
+}
+export interface NarrativeSnapshot {
+    totalEvents: number;
+    includedEvents: number;
+    cycles: number;
+    reflections: number;
+    outcomes: Record<NarrativeOutcome, number>;
+    entries: NarrativeEntry[];
+}
+export interface NarrativeSnapshotOptions {
+    limit?: number;
+}
+export declare const NARRATIVE_DEFAULT_LIMIT = 30;
+export declare const NARRATIVE_MAX_LIMIT = 200;
+export declare function buildNarrativeSnapshot(evts: readonly ReportEvent[], opts?: NarrativeSnapshotOptions): NarrativeSnapshot;

package/dist/events/reports.js

@@ -0,0 +1,244 @@
+import { Ingestor } from './ingest.js';
+import { rootEventsPath } from './paths.js';
+import { HOST_SUPPRESS_CLASSES } from '../algo/cycleFailureClassifier.js';
+export function readEvents(eventsPath) {
+    const ing = new Ingestor({ path: eventsPath ?? rootEventsPath() });
+    return ing.readAll();
+}
+const cycleIdOf = (e) => e.payload?.['cycleId'];
+const failureClassOf = (e) => {
+    const v = e.payload?.['failure_class'];
+    return typeof v === 'string' ? v : undefined;
+};
+const suppressesFailure = (failureClass) => failureClass !== undefined && HOST_SUPPRESS_CLASSES.has(failureClass);
+export function statusReport(evts) {
+    const byType = {};
+    const cycles = new Set();
+    for (const e of evts) {
+        byType[e.type] = (byType[e.type] ?? 0) + 1;
+        const c = cycleIdOf(e);
+        if (c)
+            cycles.add(c);
+    }
+    return { totalEvents: evts.length, byType, cycles: cycles.size, lastTs: evts.length ? evts[evts.length - 1].ts : null };
+}
+export function listCycles(evts) {
+    const byCycle = new Map();
+    for (const e of evts) {
+        const c = cycleIdOf(e);
+        if (!c)
+            continue;
+        (byCycle.get(c) ?? byCycle.set(c, []).get(c)).push(e);
+    }
+    const STAGE = new Set(['cycle.solidified', 'cycle.failed', 'cycle.aborted']);
+    return [...byCycle.entries()].map(([cycleId, es]) => {
+        const terminal = [...es].reverse().find((e) => STAGE.has(e.type));
+        const failureClass = terminal?.type === 'cycle.failed' ? failureClassOf(terminal) : undefined;
+        return {
+            cycleId,
+            events: es.length,
+            finalStage: terminal?.type.replace('cycle.', '') ?? 'in_progress',
+            lastTs: es[es.length - 1].ts,
+            ...(failureClass !== undefined ? { failureClass, failureSuppressed: suppressesFailure(failureClass) } : {}),
+        };
+    });
+}
+export function showCycle(evts, cycleId) {
+    const timeline = evts.filter((e) => cycleIdOf(e) === cycleId).map((e) => ({
+        type: e.type, title: e.human?.title ?? '', ts: e.ts, seq: e.seq,
+        ...(e.human?.why ? { why: e.human.why } : {}), ...(e.payload ? { payload: e.payload } : {}),
+    }));
+    return { cycleId, timeline };
+}
+export function listTriggers(evts) {
+    return evts.filter((e) => e.type === 'decision.triggered' || e.type === 'decision.suppressed').map((e) => ({
+        patternId: e.payload?.['patternId'] ?? '?',
+        triggered: e.type === 'decision.triggered',
+        value: e.payload?.['value'] ?? 0,
+        reasons: e.payload?.['reasons'] ?? (e.human?.why ? [e.human.why] : []),
+    }));
+}
+export function dailySummary(evts, dayPrefix) {
+    const today = evts.filter((e) => e.ts.startsWith(dayPrefix));
+    const count = (t) => today.filter((e) => e.type === t).length;
+    const cycleIds = new Set(today.map(cycleIdOf).filter(Boolean));
+    const failureBuckets = {};
+    let suppressedFailures = 0;
+    for (const e of today) {
+        if (e.type !== 'cycle.failed')
+            continue;
+        const failureClass = failureClassOf(e);
+        if (failureClass !== undefined) {
+            failureBuckets[failureClass] = (failureBuckets[failureClass] ?? 0) + 1;
+            if (suppressesFailure(failureClass))
+                suppressedFailures += 1;
+        }
+    }
+    return {
+        date: dayPrefix,
+        cycles: cycleIds.size,
+        solidified: count('cycle.solidified'),
+        failed: count('cycle.failed'),
+        triggered: count('decision.triggered'),
+        suppressed: count('decision.suppressed'),
+        failureBuckets,
+        suppressedFailures,
+    };
+}
+export const NARRATIVE_DEFAULT_LIMIT = 30;
+export const NARRATIVE_MAX_LIMIT = 200;
+const NARRATIVE_EVENTS = new Set([
+    'reflection.recorded',
+    'cycle.solidified',
+    'cycle.failed',
+    'cycle.aborted',
+    'decision.gene_selected',
+    'value.reuse_hit',
+    'value.inject',
+    'value.reuse_outcome',
+    'value.recall',
+]);
+const TOKEN_LIKE = /\b[A-Za-z0-9_-]{24,}\b|\b[A-Fa-f0-9]{16,}\b/g;
+export function buildNarrativeSnapshot(evts, opts = {}) {
+    const limit = clampLimit(opts.limit);
+    const allEntries = evts.map(toNarrativeEntry).filter((entry) => entry !== null);
+    const entries = allEntries.slice(-limit);
+    const cycles = new Set();
+    const outcomes = { success: 0, failed: 0, inert: 0, unknown: 0 };
+    let reflections = 0;
+    for (const entry of entries) {
+        if (entry.cycleId)
+            cycles.add(entry.cycleId);
+        if (entry.type === 'reflection.recorded')
+            reflections += 1;
+        if (entry.outcome)
+            outcomes[entry.outcome] += 1;
+    }
+    return {
+        totalEvents: evts.length,
+        includedEvents: entries.length,
+        cycles: cycles.size,
+        reflections,
+        outcomes,
+        entries,
+    };
+}
+function toNarrativeEntry(event) {
+    if (!isNarrativeEvent(event))
+        return null;
+    const payload = event.payload ?? {};
+    const base = {
+        seq: event.seq,
+        ts: event.ts,
+        type: event.type,
+        title: cleanText(event.human?.title ?? event.type, 120) ?? event.type,
+    };
+    if (event.type === 'reflection.recorded') {
+        return cleanUndefined({
+            ...base,
+            cycleId: stringOf(payload['cycleId']),
+            summary: cleanText(stringOf(payload['summary']) ?? event.human?.detail ?? event.human?.why),
+            action: stringOf(payload['action']),
+            outcome: narrativeOutcome(stringOf(payload['outcome'])),
+            geneId: stringOf(payload['geneId']),
+            score: numberOf(payload['score']),
+        });
+    }
+    if (event.type === 'cycle.solidified' || event.type === 'cycle.failed' || event.type === 'cycle.aborted') {
+        const outcome = event.type === 'cycle.failed'
+            ? 'failed'
+            : event.type === 'cycle.aborted'
+                ? 'unknown'
+                : payload['producedValue'] === false
+                    ? 'inert'
+                    : narrativeOutcome(stringOf(asRecord(payload['outcome'])?.['status'])) ?? 'success';
+        return cleanUndefined({
+            ...base,
+            cycleId: stringOf(payload['cycleId']),
+            summary: cycleSummary(event, payload),
+            action: event.type.replace('cycle.', 'cycle_'),
+            outcome,
+            geneId: stringOf(payload['gene']),
+            score: numberOf(asRecord(payload['outcome'])?.['score']),
+        });
+    }
+    if (event.type === 'decision.gene_selected') {
+        return cleanUndefined({
+            ...base,
+            cycleId: stringOf(payload['cycleId']),
+            summary: cleanText(event.human?.detail ?? event.human?.why),
+            action: 'gene_selected',
+            geneId: stringOf(payload['selectedGeneId']) ?? stringOf(payload['geneId']) ?? stringOf(payload['gene']),
+        });
+    }
+    if (event.type.startsWith('actor.human.')) {
+        return cleanUndefined({
+            ...base,
+            cycleId: stringOf(payload['cycleId']),
+            summary: cleanText(stringOf(payload['reason']) ?? stringOf(payload['note']) ?? event.human?.detail ?? event.human?.why ?? event.human?.next),
+            action: event.type.replace('actor.human.', 'human_').replace(/\./g, '_'),
+            geneId: stringOf(payload['geneId']),
+        });
+    }
+    return cleanUndefined({
+        ...base,
+        cycleId: stringOf(payload['cycleId']),
+        summary: cleanText(event.human?.detail ?? event.human?.why ?? stringOf(payload['outcome'])),
+        action: event.type.replace('value.', 'value_'),
+        geneId: stringOf(payload['geneId']) ?? stringOf(payload['assetId']),
+    });
+}
+function isNarrativeEvent(event) {
+    return NARRATIVE_EVENTS.has(event.type) || event.type.startsWith('actor.human.');
+}
+function cycleSummary(event, payload) {
+    const outcome = asRecord(payload['outcome']);
+    return cleanText(event.human?.detail
+        ?? event.human?.why
+        ?? stringOf(payload['error'])
+        ?? stringOf(payload['reason'])
+        ?? stringListOf(payload['reasons'])
+        ?? stringOf(outcome?.['reason'])
+        ?? stringOf(payload['failure_class_reason'])
+        ?? stringOf(payload['failure_class']));
+}
+function clampLimit(limit) {
+    if (typeof limit !== 'number' || !Number.isFinite(limit))
+        return NARRATIVE_DEFAULT_LIMIT;
+    return Math.min(NARRATIVE_MAX_LIMIT, Math.max(1, Math.floor(limit)));
+}
+function cleanText(value, max = 240) {
+    if (!value)
+        return undefined;
+    const normalized = value.replace(/\s+/g, ' ').trim().replace(TOKEN_LIKE, '[redacted]');
+    if (!normalized)
+        return undefined;
+    return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+function narrativeOutcome(value) {
+    if (value === 'success' || value === 'failed' || value === 'inert' || value === 'unknown')
+        return value;
+    return undefined;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+function stringListOf(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+    return parts.length > 0 ? parts.join('; ') : undefined;
+}
+function numberOf(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function cleanUndefined(record) {
+    for (const key of Object.keys(record)) {
+        if (record[key] === undefined)
+            delete record[key];
+    }
+    return record;
+}

package/dist/events/retention.d.ts

@@ -0,0 +1,70 @@
+export type RetentionState = 'ok' | 'watch' | 'over_limit';
+export declare const RETENTION_DEFAULT_MAX_ROOT_EVENTS = 100000;
+export declare const RETENTION_DEFAULT_MAX_ROOT_BYTES: number;
+export declare const RETENTION_DEFAULT_MAX_MATERIAL_RECORDS = 10000;
+export declare const RETENTION_DEFAULT_MAX_MATERIAL_BYTES: number;
+export declare const RETENTION_DEFAULT_WATCH_RATIO = 0.8;
+export declare const RETENTION_DEFAULT_ROOT_TAIL_EVENTS: number;
+export interface RetentionThresholds {
+    maxRecords: number;
+    maxBytes: number;
+    watchRatio: number;
+}
+export interface RootRetentionSnapshot {
+    name: 'root_events';
+    exists: boolean;
+    bytes: number;
+    records: number;
+    invalidLines: number;
+    state: RetentionState;
+    thresholds: RetentionThresholds;
+    firstSeq: number | null;
+    lastSeq: number | null;
+    firstTs: string | null;
+    lastTs: string | null;
+    protectTailEvents: number;
+    destructivePruneSafe: false;
+    reason: string;
+}
+export interface MaterialRetentionSnapshot {
+    name: 'material';
+    exists: boolean;
+    bytes: number;
+    records: number;
+    invalidLines: number;
+    state: RetentionState;
+    thresholds: RetentionThresholds;
+    firstCapturedAt: string | null;
+    lastCapturedAt: string | null;
+    cursorValid: boolean;
+    cursorInRange: boolean;
+    cursor: number;
+    effectiveCursor: number;
+    consumedPrefix: number;
+    pending: number;
+    destructivePruneSafe: false;
+    reason: string;
+}
+export interface RetentionReport {
+    generatedAt: string;
+    mode: 'read_only_policy';
+    destructivePruneSupported: false;
+    rootEvents: RootRetentionSnapshot;
+    material: MaterialRetentionSnapshot;
+    warnings: string[];
+    nextActions: string[];
+}
+export interface RetentionReportOptions {
+    rootEventsPath?: string;
+    materialStorePath?: string;
+    materialCursorPath?: string;
+    now?: () => number;
+    maxRootEvents?: number;
+    maxRootBytes?: number;
+    maxMaterialRecords?: number;
+    maxMaterialBytes?: number;
+    watchRatio?: number;
+    protectRootTailEvents?: number;
+}
+export declare function defaultMaterialCursorPath(path?: string): string;
+export declare function buildRetentionReport(opts?: RetentionReportOptions): RetentionReport;

package/dist/events/retention.js

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { material } from '../schema/material.js';
+import { rootEvent } from './eventSchema.js';
+import { materialStorePath as defaultMaterialStorePath, rootEventsPath as defaultRootEventsPath } from './paths.js';
+import { NARRATIVE_MAX_LIMIT } from './reports.js';
+export const RETENTION_DEFAULT_MAX_ROOT_EVENTS = 100_000;
+export const RETENTION_DEFAULT_MAX_ROOT_BYTES = 64 * 1024 * 1024;
+export const RETENTION_DEFAULT_MAX_MATERIAL_RECORDS = 10_000;
+export const RETENTION_DEFAULT_MAX_MATERIAL_BYTES = 64 * 1024 * 1024;
+export const RETENTION_DEFAULT_WATCH_RATIO = 0.8;
+export const RETENTION_DEFAULT_ROOT_TAIL_EVENTS = Math.max(1_000, NARRATIVE_MAX_LIMIT);
+export function defaultMaterialCursorPath(path = defaultMaterialStorePath()) {
+    return join(dirname(path), 'cycle-consumer.json');
+}
+export function buildRetentionReport(opts = {}) {
+    const now = new Date((opts.now ?? Date.now)()).toISOString();
+    const watchRatio = ratioOf(opts.watchRatio, RETENTION_DEFAULT_WATCH_RATIO);
+    const rootPath = opts.rootEventsPath ?? defaultRootEventsPath();
+    const materialPath = opts.materialStorePath ?? defaultMaterialStorePath();
+    const cursorPath = opts.materialCursorPath ?? defaultMaterialCursorPath(materialPath);
+    const rootThresholds = {
+        maxRecords: positiveInt(opts.maxRootEvents, RETENTION_DEFAULT_MAX_ROOT_EVENTS),
+        maxBytes: positiveInt(opts.maxRootBytes, RETENTION_DEFAULT_MAX_ROOT_BYTES),
+        watchRatio,
+    };
+    const materialThresholds = {
+        maxRecords: positiveInt(opts.maxMaterialRecords, RETENTION_DEFAULT_MAX_MATERIAL_RECORDS),
+        maxBytes: positiveInt(opts.maxMaterialBytes, RETENTION_DEFAULT_MAX_MATERIAL_BYTES),
+        watchRatio,
+    };
+    const rootEvents = rootSnapshot(rootPath, rootThresholds, positiveInt(opts.protectRootTailEvents, RETENTION_DEFAULT_ROOT_TAIL_EVENTS));
+    const material = materialSnapshot(materialPath, cursorPath, materialThresholds);
+    const warnings = buildWarnings(rootEvents, material);
+    const nextActions = buildNextActions(rootEvents, material);
+    return {
+        generatedAt: now,
+        mode: 'read_only_policy',
+        destructivePruneSupported: false,
+        rootEvents,
+        material,
+        warnings,
+        nextActions,
+    };
+}
+function rootSnapshot(path, thresholds, protectTailEvents) {
+    const stats = readJsonl(path, (value) => rootEvent.parse(value));
+    return {
+        name: 'root_events',
+        exists: stats.exists,
+        bytes: stats.bytes,
+        records: stats.records,
+        invalidLines: stats.invalidLines,
+        state: retentionState(stats.records, stats.bytes, thresholds),
+        thresholds,
+        firstSeq: stats.first?.seq ?? null,
+        lastSeq: stats.last?.seq ?? null,
+        firstTs: stats.first?.ts ?? null,
+        lastTs: stats.last?.ts ?? null,
+        protectTailEvents: Math.min(stats.records, protectTailEvents),
+        destructivePruneSafe: false,
+        reason: 'root_events is the replay and audit source; archive readers must exist before destructive prune is safe',
+    };
+}
+function materialSnapshot(path, cursorPath, thresholds) {
+    const stats = readJsonl(path, (value) => material.parse(value));
+    const cursor = readCycleCursor(cursorPath);
+    const cursorInRange = cursor.value >= 0 && cursor.value <= stats.records;
+    const effectiveCursor = cursorInRange ? cursor.value : clampCursor(cursor.value, stats.records);
+    return {
+        name: 'material',
+        exists: stats.exists,
+        bytes: stats.bytes,
+        records: stats.records,
+        invalidLines: stats.invalidLines,
+        state: retentionState(stats.records, stats.bytes, thresholds),
+        thresholds,
+        firstCapturedAt: stats.first?.capturedAt ?? null,
+        lastCapturedAt: stats.last?.capturedAt ?? null,
+        cursorValid: cursor.valid,
+        cursorInRange,
+        cursor: cursor.value,
+        effectiveCursor,
+        consumedPrefix: effectiveCursor,
+        pending: Math.max(0, stats.records - effectiveCursor),
+        destructivePruneSafe: false,
+        reason: 'material cursor is index-based; prune requires atomic archive plus cursor rewrite',
+    };
+}
+function readJsonl(path, parse) {
+    if (!existsSync(path)) {
+        return { exists: false, bytes: 0, records: 0, invalidLines: 0, first: null, last: null };
+    }
+    const bytes = statSync(path).size;
+    let records = 0;
+    let invalidLines = 0;
+    let first = null;
+    let last = null;
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const parsed = parse(JSON.parse(line));
+            first ??= parsed;
+            last = parsed;
+            records += 1;
+        }
+        catch {
+            invalidLines += 1;
+        }
+    }
+    return { exists: true, bytes, records, invalidLines, first, last };
+}
+function readCycleCursor(path) {
+    if (!existsSync(path))
+        return { exists: false, valid: true, value: 0 };
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof parsed.cycle === 'number' && Number.isFinite(parsed.cycle)) {
+            return { exists: true, valid: true, value: Math.floor(parsed.cycle) };
+        }
+        return { exists: true, valid: false, value: 0 };
+    }
+    catch {
+        return { exists: true, valid: false, value: 0 };
+    }
+}
+function retentionState(records, bytes, thresholds) {
+    if (records > thresholds.maxRecords || bytes > thresholds.maxBytes)
+        return 'over_limit';
+    if (records >= thresholds.maxRecords * thresholds.watchRatio || bytes >= thresholds.maxBytes * thresholds.watchRatio)
+        return 'watch';
+    return 'ok';
+}
+function buildWarnings(root, mat) {
+    const out = [];
+    if (root.invalidLines > 0)
+        out.push(`root_events has ${root.invalidLines} invalid jsonl line(s); recover before rotating`);
+    if (mat.invalidLines > 0)
+        out.push(`material store has ${mat.invalidLines} invalid jsonl line(s); inspect before rotating`);
+    if (!mat.cursorValid)
+        out.push('material cursor is unreadable; retention uses effectiveCursor=0 until the cursor is repaired');
+    if (mat.cursorValid && !mat.cursorInRange)
+        out.push(`material cursor ${mat.cursor} is outside material record range 0..${mat.records}; retention uses effectiveCursor=${mat.effectiveCursor}`);
+    if (root.state === 'over_limit')
+        out.push('root_events exceeds retention thresholds; plan archive support before deleting audit lines');
+    if (mat.state === 'over_limit')
+        out.push('material store exceeds retention thresholds; archive consumed prefix only with cursor rewrite');
+    if (mat.pending > 0)
+        out.push(`material store has ${mat.pending} pending record(s); do not prune pending material`);
+    return out;
+}
+function buildNextActions(root, mat) {
+    const out = [
+        'keep destructive prune disabled until archive readers are wired into reports, replay and cycle recovery',
+    ];
+    if (root.state !== 'ok')
+        out.push(`root_events ${root.state}: keep at least the last ${root.protectTailEvents} event(s) active after future archive`);
+    if (!mat.cursorValid || !mat.cursorInRange)
+        out.push('material: repair the cycle cursor before archiving consumed material');
+    if (mat.consumedPrefix > 0)
+        out.push(`material: ${mat.consumedPrefix} consumed prefix record(s) are archive candidates after atomic cursor rewrite exists`);
+    if (mat.pending > 0)
+        out.push('material: process or inspect pending records before any future prune');
+    return out;
+}
+function positiveInt(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function ratioOf(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.min(0.99, Math.max(0.1, value));
+}
+function clampCursor(value, records) {
+    return Math.min(records, Math.max(0, Math.floor(value)));
+}

package/dist/events/sink.d.ts

@@ -0,0 +1,5 @@
+import type { RootEvent } from './eventSchema.js';
+/** ingest 成功落盘后的 fan-out 接收口 (observer bus 实现之). */
+export interface EventSink {
+    dispatch(event: RootEvent): void;
+}

package/dist/events/sink.js

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