@syntrologie/runtime-sdk 2.8.0-canary.4 → 2.8.0-canary.41

package/dist/components/TileIcon.d.ts

@@ -1,8 +1,8 @@
 /**
  * TileIcon — maps emoji identifiers to Lucide icons.
  *
- * Uses the same emoji-to-icon associations as the editor's AdaptiveIcon
- * so tiles render the same icons as the editor sidebar.
+ * Uses the shared emoji-to-icon mapping so tiles render the same
+ * icons as the editor sidebar, nav tips, and notifications.
  */
 import type { ReactElement } from 'react';
 interface TileIconProps {

package/dist/components/emojiToIcon.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared emoji → Lucide icon mapping.
+ *
+ * Used by TileIcon, NavWidget, and NotificationToastStack to render
+ * Lucide SVG icons in place of emoji strings. This keeps icon rendering
+ * consistent and styleable across all surfaces.
+ *
+ * To add a new mapping, add the emoji key and Lucide component here.
+ */
+import type { ReactElement } from 'react';
+interface EmojiIconProps {
+    emoji: string;
+    size?: number;
+    color?: string;
+}
+/**
+ * Render a Lucide icon for a known emoji, or fall back to the raw string.
+ */
+export declare function EmojiIcon({ emoji, size, color, }: EmojiIconProps): ReactElement;
+/**
+ * Check if an emoji string has a Lucide mapping.
+ */
+export declare function hasIconMapping(emoji: string): boolean;
+export {};

package/dist/events/EventBus.d.ts

@@ -6,10 +6,19 @@
  * - Event history for recent event lookups
  * - Filtering by name, pattern, or source
  */
-import type { EventCallback, EventFilter, EventUnsubscribe, NormalizedEvent } from './types';
+import type { EventHistory } from './history';
+import type { EmitResult, EventCallback, EventFilter, EventUnsubscribe, NormalizedEvent } from './types';
 export interface EventBusOptions {
     /** Maximum number of events to keep in history */
     maxHistorySize?: number;
+    /** Enable debug mode — emit() returns EmitResult and logs to console */
+    debug?: boolean;
+    /** EventHistory instance for recording emitted events (debug/test) */
+    history?: EventHistory;
+    /** PostHog capture function for forwarding custom events */
+    posthogCapture?: (name: string, props?: Record<string, unknown>) => void;
+    /** When true, skip PostHog forwarding (for tests) */
+    testMode?: boolean;
 }
 /**
  * EventBus class for managing normalized events.
@@ -18,6 +27,10 @@ export declare class EventBus {
     private subscriptions;
     private history;
     private maxHistorySize;
+    private debug;
+    private emitHistory;
+    private posthogCapture;
+    private testMode;
     constructor(options?: EventBusOptions);
     /**
      * Subscribe to events matching an optional filter.
@@ -32,6 +45,19 @@ export declare class EventBus {
      * Publish a pre-constructed NormalizedEvent.
      */
     publishEvent(event: NormalizedEvent): void;
+    /**
+     * Emit a validated custom event from the host application.
+     *
+     * Custom events must use the `app:` prefix (e.g. `app:cart:abandoned`).
+     * In debug mode, returns an EmitResult with delivery details.
+     * In production mode, returns undefined.
+     */
+    emit(name: string, props?: Record<string, unknown>): EmitResult | undefined;
+    /**
+     * Set the PostHog capture function after construction.
+     * Used by bootstrap to wire PostHog after the EventBus is created.
+     */
+    setPosthogCapture(fn: (name: string, props?: Record<string, unknown>) => void): void;
     /**
      * Get recent events matching an optional filter.
      */

package/dist/events/history.d.ts

@@ -0,0 +1,9 @@
+import type { EmitHistoryEntry } from './types';
+export declare class EventHistory {
+    private entries;
+    private maxSize;
+    constructor(maxSize?: number);
+    record(entry: EmitHistoryEntry): void;
+    getAll(): EmitHistoryEntry[];
+    clear(): void;
+}

package/dist/events/index.d.ts

@@ -5,8 +5,11 @@ export type { EventAccumulator, EventAccumulatorOptions } from './EventAccumulat
 export { createEventAccumulator } from './EventAccumulator';
 export type { EventBusOptions } from './EventBus';
 export { createEventBus, EventBus } from './EventBus';
+export { EventHistory } from './history';
 export { CanvasEvents } from './normalizers/canvas';
 export { createPostHogNormalizer, normalizePostHogEvent, shouldNormalizeEvent, } from './normalizers/posthog';
 export { registerConfigPredicates } from './registerConfigPredicates';
 export * from './schema';
 export * from './types';
+export type { ValidationResult as EventValidationResult } from './validation';
+export { validateEventName, validateProps } from './validation';

package/dist/events/normalizers/posthog.d.ts

@@ -1,53 +1,7 @@
 /**
- * PostHog Event Normalizer
+ * PostHog Event Normalizer — re-exported from @syntrologie/event-processor.
  *
- * Transforms PostHog autocapture events into normalized events for the EventBus.
- *
- * This module is automatically wired up during `Syntro.init()` when PostHog
- * credentials are provided in the token. The flow is:
- *
- * 1. PostHog captures user interactions (clicks, scrolls, navigation, etc.)
- * 2. PostHog's `eventCaptured` callback fires
- * 3. `createPostHogNormalizer()` transforms the event to a NormalizedEvent
- * 4. The normalized event is published to the EventBus
- *
- * This allows canvas components and decision strategies to react to user
- * interactions with the main webapp, not just canvas-specific events.
- *
- * @example
- * ```typescript
- * // In bootstrap.ts (already wired up automatically)
- * const normalizer = createPostHogNormalizer((event) => {
- *   eventBus.publishEvent(event);
- * });
- *
- * // PostHog adapter calls normalizer on each capture
- * posthog.on('eventCaptured', normalizer);
- * ```
- *
- * @see RUNTIME_V2_REFERENCE.md for the full event mapping table
- */
-import type { NormalizedEvent } from '../types';
-/**
- * PostHog event structure (simplified).
- */
-interface PostHogEvent {
-    event: string;
-    properties?: Record<string, unknown>;
-    timestamp?: string | number;
-}
-/**
- * Normalize a PostHog event into a NormalizedEvent.
- */
-export declare function normalizePostHogEvent(phEvent: PostHogEvent): NormalizedEvent;
-/**
- * Check if a PostHog event should be normalized.
- * Filters out internal/system events that aren't useful for adaptives.
- */
-export declare function shouldNormalizeEvent(phEvent: PostHogEvent): boolean;
-/**
- * Create a function that hooks into PostHog's onCapture callback
- * and normalizes events into the EventBus.
+ * The canonical implementation now lives in the event-processor package
+ * so it can be shared between runtime-sdk (browser) and the data pipeline.
  */
-export declare function createPostHogNormalizer(publishFn: (event: NormalizedEvent) => void): (eventName: string, properties?: Record<string, unknown>) => void;
-export {};
+export { createPostHogNormalizer, normalizePostHogEvent, shouldNormalizeEvent, } from '@syntrologie/event-processor/normalizers/posthog';

package/dist/events/types.d.ts

@@ -4,25 +4,8 @@
  * The EventBus provides a normalized event stream that unifies events from
  * PostHog autocapture, Canvas events, and derived behavioral signals.
  */
-/**
- * Event sources in the runtime.
- */
-export type EventSource = 'posthog' | 'canvas' | 'derived';
-/**
- * Normalized event structure for the event bus.
- */
-export interface NormalizedEvent {
-    /** Event timestamp (milliseconds since epoch) */
-    ts: number;
-    /** Normalized event name (e.g., "ui.click", "canvas.opened") */
-    name: string;
-    /** Event source */
-    source: EventSource;
-    /** Event properties/payload */
-    props?: Record<string, unknown>;
-    /** Schema version for forward compatibility */
-    schemaVersion: string;
-}
+export type { EventSource, NormalizedEvent } from '@syntrologie/event-processor';
+export { EVENT_SCHEMA_VERSION } from '@syntrologie/event-processor';
 /**
  * Event filter for subscriptions.
  */
@@ -32,18 +15,22 @@ export interface EventFilter {
     /** Filter by event name patterns (regex) */
     patterns?: string[];
     /** Filter by sources */
-    sources?: EventSource[];
+    sources?: import('@syntrologie/event-processor').EventSource[];
 }
 /**
  * Callback for event subscriptions.
  */
-export type EventCallback = (event: NormalizedEvent) => void;
+export type EventCallback = (event: import('@syntrologie/event-processor').NormalizedEvent) => void;
 /**
  * Unsubscribe function returned by subscribe().
  */
 export type EventUnsubscribe = () => void;
 /**
  * Standard event names used by the runtime.
+ *
+ * This is a superset of event-processor's StandardEvents, adding
+ * canvas, overlay, action, notification, and surface events that
+ * are specific to the runtime SDK.
  */
 export declare const StandardEvents: {
     readonly UI_CLICK: "ui.click";
@@ -78,6 +65,26 @@ export declare const StandardEvents: {
     readonly SURFACE_UNMOUNTED: "surface.unmounted";
 };
 /**
- * Current schema version for normalized events.
+ * Result returned from emit() in debug mode.
+ * In production mode, emit() returns undefined.
+ */
+export interface EmitResult {
+    delivered: boolean;
+    matchedRules: Array<{
+        tileId: string;
+        ruleIndex: number;
+        title: string;
+    }>;
+    posthogCaptured: boolean;
+    listenersNotified: number;
+}
+/**
+ * Entry in the debug/test event history.
  */
-export declare const EVENT_SCHEMA_VERSION = "1.0.0";
+export interface EmitHistoryEntry {
+    name: string;
+    props?: Record<string, unknown>;
+    source: 'custom';
+    timestamp: number;
+    matchedRules: EmitResult['matchedRules'];
+}

package/dist/events/validation.d.ts

@@ -0,0 +1,7 @@
+export interface ValidationResult {
+    valid: boolean;
+    reason?: string;
+    stripped?: string[];
+}
+export declare function validateEventName(name: string): ValidationResult;
+export declare function validateProps(props: Record<string, unknown> | undefined): ValidationResult;

package/dist/index.d.ts

@@ -25,7 +25,6 @@ export * from './apps';
 export * from './context';
 export * from './decisions';
 export * from './events';
-export * from './events';
 export type { NavigationDiagnostics, NavigationListener } from './navigation/NavigationMonitor';
 export { NavigationMonitor } from './navigation/NavigationMonitor';
 export * from './notifications';
@@ -33,7 +32,6 @@ export { RuntimeProvider, useDecision, usePageContext, useRuntime, useRuntimeCon
 export type { RuntimeMode, SmartCanvasRuntime, SmartCanvasRuntimeOptions } from './runtime';
 export { createSmartCanvasRuntime, RUNTIME_VERSION } from './runtime';
 export * from './state';
-export * from './state';
 export * from './surfaces';
 export * from './widgets';
 export type { SyntroInitOptions, SyntroInitResult } from './bootstrap';