@flowcore/pathways 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## [0.2.1](https://github.com/flowcore-io/flowcore-pathways/compare/v0.2.0...v0.2.1) (2025-03-15)
+
+
+### Bug Fixes
+
+* **dependencies:** :art: Update package versions in deno.lock and import statements ([e47298e](https://github.com/flowcore-io/flowcore-pathways/commit/e47298e565743ebc7381d7d9683ddc7f33b98bf0))
+
+## [0.2.0](https://github.com/flowcore-io/flowcore-pathways/compare/v0.1.0...v0.2.0) (2025-03-15)
+
+
+### Features
+
+* :sparkles: Add support for file-based pathways and multi-event writes ([e9d9bcc](https://github.com/flowcore-io/flowcore-pathways/commit/e9d9bcc8d4f6ff8959f99760c736671ba422e4a5))
+* :sparkles: Allow non-async pathway handlers in PathwaysBuilder ([4313e63](https://github.com/flowcore-io/flowcore-pathways/commit/4313e635c04a6bd9a395f9df782482a0c18d0f37))
+* :sparkles: Enhance PathwaysBuilder with improved type safety and writable pathway support ([a2c1c36](https://github.com/flowcore-io/flowcore-pathways/commit/a2c1c36aa5537be2aeec9b8e7bb744ed9a1243a8))
+* :sparkles: Initialize core Flowcore Pathways library with essential components ([dfa32f1](https://github.com/flowcore-io/flowcore-pathways/commit/dfa32f1601b1c6851d87fb749fd9688b13fe398e))
+* Add pathway state management with key-value storage support ([c717a2e](https://github.com/flowcore-io/flowcore-pathways/commit/c717a2e3757445cfb52b580c0ca67c746a16a622))
+* **pathways:** :sparkles: Add audit functionality to PathwaysBuilder ([bdc68fe](https://github.com/flowcore-io/flowcore-pathways/commit/bdc68fe36d49c8b1827d63ee686f15afd76769bb))
+* **pathways:** :sparkles: Implement error handling and retry mechanism in PathwaysBuilder ([5300036](https://github.com/flowcore-io/flowcore-pathways/commit/5300036370ce573a06dac65fc5b0fdf1ee9f3ffd))
+* **pathways:** :sparkles: Introduce logging functionality in PathwaysBuilder ([9cef56a](https://github.com/flowcore-io/flowcore-pathways/commit/9cef56a8111336d2cfd26e72edbc01784cc0ef1a))
+* **postgres:** :sparkles: Integrate PostgreSQL support for pathway state management ([710ab3f](https://github.com/flowcore-io/flowcore-pathways/commit/710ab3f24e4865f5259f773a73cbae12fe3f8795))
+* **router:** :sparkles: Add secret key validation for PathwayRouter ([3a6a70a](https://github.com/flowcore-io/flowcore-pathways/commit/3a6a70a194ac8589ea6cc56cae741f2902befcf0))
+* **tests:** :sparkles: Add comprehensive tests for pathways and router functionality ([ae032fd](https://github.com/flowcore-io/flowcore-pathways/commit/ae032fdec6c2f9c58c95dd1153c951d0d9915b2c))
+
+
+### Bug Fixes
+
+* **deno.json:** :art: Update test commands to remove unstable flag ([7fb6dd2](https://github.com/flowcore-io/flowcore-pathways/commit/7fb6dd22e4cf7f778725fb53a84b0f3ab222fa0a))
+* **deno.lock:** :wrench: Fixed the npm building by updating the imports to be consisten ([5700b20](https://github.com/flowcore-io/flowcore-pathways/commit/5700b20ee2b93dca88ce3d4cc3d826ffe6db2cc4))
+* **readme:** :fire: Remove Example Projects section from README ([bd27270](https://github.com/flowcore-io/flowcore-pathways/commit/bd27270ae0f80c46074def5ef3a08410677ebb68))
+* **readme:** :memo: Update library description and installation instructions in README ([cbd3d33](https://github.com/flowcore-io/flowcore-pathways/commit/cbd3d330a8e6809c9cbb1bc8582598d3cd1992d5))
+* **readme:** :memo: Update README with detailed usage examples and core concepts ([5e26e9b](https://github.com/flowcore-io/flowcore-pathways/commit/5e26e9b8f2b06c56e0c65dbce09d6c7e2fe36edd))
+* **router:** :bug: Improve error handling in PathwayRouter processing ([56a00eb](https://github.com/flowcore-io/flowcore-pathways/commit/56a00eb9c9d8b056b40398eb40c213fd876e4226))
+* **router:** :bug: Update processEvent method to include return type ([af5b821](https://github.com/flowcore-io/flowcore-pathways/commit/af5b821187404d72c1566f2ebdb9c7fbcbb0bb3b))

package/README.md

@@ -0,0 +1,420 @@
+# Flowcore Pathways
+
+A TypeScript Library for creating Flowcore Pathways, simplifying the integration with the Flowcore platform. Flowcore Pathways helps you build event-driven applications with type-safe pathways for processing and producing events.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Getting Started](#getting-started)
+- [Core Concepts](#core-concepts)
+- [Usage](#usage)
+  - [Creating a Pathways Builder](#creating-a-pathways-builder)
+  - [Registering Pathways](#registering-pathways)
+  - [Handling Events](#handling-events)
+  - [Writing Events](#writing-events)
+  - [Error Handling](#error-handling)
+  - [Event Observability](#event-observability)
+  - [Setting up a Router](#setting-up-a-router)
+  - [HTTP Server Integration](#http-server-integration)
+  - [Persistence Options](#persistence-options)
+- [Advanced Usage](#advanced-usage)
+  - [Auditing](#auditing)
+  - [Custom Loggers](#custom-loggers)
+  - [Retry Mechanisms](#retry-mechanisms)
+- [API Reference](#api-reference)
+
+## Installation
+
+```bash
+# Bun
+bunx jsr add @flowcore/pathways
+
+# Deno
+deno add jsr:@flowcore/pathways
+
+# npm / yarn
+npx jsr add @flowcore/pathways
+```
+
+or using npm:
+
+```bash
+npm install @flowcore/pathways
+```
+
+or using yarn:
+
+```bash
+yarn add @flowcore/pathways
+```
+
+## Getting Started
+
+Here's a basic example to get you started with Flowcore Pathways:
+
+```typescript
+import { Type } from "@sinclair/typebox";
+import { PathwaysBuilder } from "@flowcore/pathways";
+
+// Define your event schema
+const userSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  email: Type.String()
+});
+
+// Create a pathways builder
+const pathways = new PathwaysBuilder({
+  baseUrl: "https://api.flowcore.io",
+  tenant: "your-tenant",
+  dataCore: "your-data-core",
+  apiKey: "your-api-key"
+});
+
+// Register a pathway
+pathways
+  .register({
+    flowType: "user",
+    eventType: "created",
+    schema: userSchema
+  })
+  .handle("user/created", async (event) => {
+    console.log(`Processing user created event: ${event.eventId}`);
+    console.log(`User data:`, event.payload);
+    
+    // Process the event...
+    
+    // You can write to another pathway if needed
+    await pathways.write("notifications/sent", {
+      userId: event.payload.id,
+      message: `Welcome ${event.payload.name}!`,
+      channel: "email"
+    });
+  });
+```
+
+## Core Concepts
+
+Flowcore Pathways is built around these core concepts:
+
+- **PathwaysBuilder**: The main entry point for creating and managing pathways
+- **Pathways**: Define event flows with schemas for type safety
+- **Handlers**: Process incoming events
+- **Writers**: Send events to pathways
+- **Router**: Direct incoming events to the appropriate pathway
+- **Persistence**: Store pathway state for reliable processing
+
+## Usage
+
+### Creating a Pathways Builder
+
+The `PathwaysBuilder` is the main configuration point for your pathways:
+
+```typescript
+import { PathwaysBuilder } from "@flowcore/pathways";
+
+const pathways = new PathwaysBuilder({
+  baseUrl: "https://api.flowcore.io",
+  tenant: "your-tenant",
+  dataCore: "your-data-core",
+  apiKey: "your-api-key",
+  pathwayTimeoutMs: 10000, // Optional, default is 10000 (10s)
+  logger: customLogger     // Optional, defaults to NoopLogger
+});
+```
+
+### Registering Pathways
+
+Register pathways with their schemas for type-safe event handling:
+
+```typescript
+import { Type } from "@sinclair/typebox";
+
+// Define your event schema
+const orderSchema = Type.Object({
+  orderId: Type.String(),
+  userId: Type.String(),
+  total: Type.Number(),
+  items: Type.Array(
+    Type.Object({
+      id: Type.String(),
+      quantity: Type.Number()
+    })
+  )
+});
+
+// Register pathway
+pathways.register({
+  flowType: "order",
+  eventType: "placed",
+  schema: orderSchema,
+  writable: true,       // Optional, default is true
+  maxRetries: 3,        // Optional, default is 3
+  retryDelayMs: 500     // Optional, default is 500
+});
+```
+
+### Handling Events
+
+Set up handlers to process events for specific pathways:
+
+```typescript
+const pathwayKey = "order/placed";
+
+pathways.handle(pathwayKey, async (event) => {
+  console.log(`Processing order ${event.payload.orderId}`);
+  
+  // Access typed payload data
+  const { userId, total, items } = event.payload;
+  
+  // Your business logic here
+  await updateInventory(items);
+  await notifyUser(userId, total);
+});
+```
+
+### Writing Events
+
+Send events to pathways:
+
+```typescript
+// Basic write
+const eventId = await pathways.write("order/placed", {
+  orderId: "ord-123",
+  userId: "user-456",
+  total: 99.99,
+  items: [
+    { id: "item-1", quantity: 2 }
+  ]
+});
+
+// Write with metadata
+const eventId2 = await pathways.write(
+  "order/placed", 
+  orderData,
+  { 
+    correlationId: "corr-789",
+    source: "checkout-service" 
+  }
+);
+
+// Fire-and-forget mode (doesn't wait for processing)
+const eventId3 = await pathways.write(
+  "order/placed", 
+  orderData,
+  undefined,
+  { fireAndForget: true }
+);
+```
+
+### Error Handling
+
+Handle errors in pathway processing:
+
+```typescript
+// Error handler for a specific pathway
+pathways.onError("order/placed", (error, event) => {
+  console.error(`Error processing order ${event.payload.orderId}:`, error);
+  reportToMonitoring(error, event);
+});
+
+// Global error handler for all pathways
+pathways.onAnyError((error, event, pathway) => {
+  console.error(`Error in pathway ${pathway}:`, error);
+  reportToMonitoring(error, event, pathway);
+});
+```
+
+### Event Observability
+
+Subscribe to events for observability at different stages:
+
+```typescript
+// Before processing
+pathways.subscribe("order/placed", (event) => {
+  console.log(`About to process order ${event.payload.orderId}`);
+}, "before");
+
+// After processing
+pathways.subscribe("order/placed", (event) => {
+  console.log(`Finished processing order ${event.payload.orderId}`);
+}, "after");
+
+// At both stages
+pathways.subscribe("order/placed", (event) => {
+  console.log(`Event ${event.eventId} at ${new Date().toISOString()}`);
+}, "all");
+```
+
+### Setting up a Router
+
+The `PathwayRouter` routes incoming events to the appropriate pathway:
+
+```typescript
+import { PathwayRouter } from "@flowcore/pathways";
+
+// Create a router with a secret key for validation
+const WEBHOOK_SECRET = "your-webhook-secret";
+const router = new PathwayRouter(pathways, WEBHOOK_SECRET);
+
+// Process an incoming event from a webhook
+async function handleWebhook(req: Request) {
+  const event = await req.json();
+  const secret = req.headers.get("X-Webhook-Secret");
+  
+  try {
+    // This validates the secret and routes to the right pathway
+    await router.processEvent(event, secret);
+    return new Response("Event processed", { status: 200 });
+  } catch (error) {
+    console.error("Error processing event:", error);
+    return new Response("Error processing event", { status: 500 });
+  }
+}
+```
+
+### HTTP Server Integration
+
+Integrate with Deno's HTTP server:
+
+```typescript
+import { serve } from "https://deno.land/std/http/server.ts";
+
+serve(async (req: Request) => {
+  const url = new URL(req.url);
+  
+  if (req.method === "POST" && url.pathname === "/webhook") {
+    return handleWebhook(req);
+  }
+  
+  return new Response("Not found", { status: 404 });
+}, { port: 3000 });
+```
+
+### Persistence Options
+
+Flowcore Pathways supports different persistence options to track processed events and ensure exactly-once processing.
+
+#### Default In-Memory KV Store (Development)
+
+By default, Flowcore Pathways uses an internal in-memory KV store for persistence:
+
+```typescript
+// The default persistence is used automatically, no explicit setup required
+const pathways = new PathwaysBuilder({
+  baseUrl: "https://api.flowcore.io",
+  tenant: "your-tenant",
+  dataCore: "your-data-core",
+  apiKey: "your-api-key"
+});
+```
+
+The internal store uses the appropriate KV adapter for your environment (Bun, Node, or Deno), but note that this state is not persistent across application restarts and should be used primarily for development.
+
+#### PostgreSQL Persistence (Production)
+
+For production environments, you can use PostgreSQL for reliable and scalable persistence:
+
+```typescript
+import { PostgresPathwayState, createPostgresPathwayState } from "@flowcore/pathways";
+
+// Create a PostgreSQL state handler
+const postgresState = createPostgresPathwayState({
+  host: "localhost",
+  port: 5432,
+  user: "postgres",
+  password: "postgres",
+  database: "pathway_db",
+  tableName: "pathway_state", // Optional, defaults to "pathway_state"
+  ttlMs: 300000,              // Optional, defaults to 5 minutes (300000ms)
+  ssl: false                  // Optional, defaults to false
+});
+
+// Use PostgreSQL for pathway state
+pathways.withPathwayState(postgresState);
+```
+
+The PostgreSQL implementation:
+
+- Automatically creates the necessary table if it doesn't exist
+- Includes TTL-based automatic cleanup of processed events
+- Creates appropriate indexes for performance
+
+## Advanced Usage
+
+### Auditing
+
+Enable auditing to track events:
+
+```typescript
+// Set up auditing
+pathways.withAudit(
+  // Audit handler
+  (path, event) => {
+    console.log(`Audit: ${path} event ${event.eventId}`);
+    logToAuditSystem(path, event);
+  },
+  // User ID resolver
+  async () => {
+    // Get the current user ID from context
+    return getCurrentUserId();
+  }
+);
+```
+
+### Custom Loggers
+
+Create a custom logger:
+
+```typescript
+import { Logger } from "@flowcore/pathways";
+
+class MyCustomLogger implements Logger {
+  debug(message: string, context?: Record<string, unknown>): void {
+    console.debug(`[DEBUG] ${message}`, context);
+  }
+  
+  info(message: string, context?: Record<string, unknown>): void {
+    console.info(`[INFO] ${message}`, context);
+  }
+  
+  warn(message: string, context?: Record<string, unknown>): void {
+    console.warn(`[WARN] ${message}`, context);
+  }
+  
+  error(message: string, error?: Error, context?: Record<string, unknown>): void {
+    console.error(`[ERROR] ${message}`, error, context);
+  }
+}
+
+// Use custom logger
+const pathways = new PathwaysBuilder({
+  // ...other config
+  logger: new MyCustomLogger()
+});
+```
+
+### Retry Mechanisms
+
+Configure retry behavior for pathways:
+
+```typescript
+// Global timeout for pathway processing
+const pathways = new PathwaysBuilder({
+  // ...other config
+  pathwayTimeoutMs: 15000 // 15 seconds
+});
+
+// Per-pathway retry configuration
+pathways.register({
+  flowType: "payment",
+  eventType: "process",
+  schema: paymentSchema,
+  maxRetries: 5,           // Retry up to 5 times
+  retryDelayMs: 1000       // 1 second between retries
+});
+```
+
+## API Reference
+
+For a complete API reference, please see the [API documentation](https://jsr.io/@flowcore/pathways).

package/esm/common/flowcore.type.d.ts

@@ -0,0 +1,11 @@
+import type { FlowcoreEvent } from "../contracts/event.js";
+/**
+ * Extends the FlowcoreEvent with legacy fields
+ *
+ * @typedef {Object} FlowcoreLegacyEvent
+ * @property {string} [aggregator] - Optional aggregator information for legacy support
+ */
+export type FlowcoreLegacyEvent = FlowcoreEvent & {
+    aggregator?: string;
+};
+//# sourceMappingURL=flowcore.type.d.ts.map

package/esm/common/flowcore.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowcore.type.d.ts","sourceRoot":"","sources":["../../src/common/flowcore.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA"}

package/esm/common/flowcore.type.js

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

package/esm/common/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Common types and utilities for Flowcore Pathways
+ *
+ * This module exports common types and utilities that are used across the Flowcore Pathways library.
+ */
+export * from "./flowcore.type.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,oBAAoB,CAAC"}

package/esm/common/index.js

@@ -0,0 +1,6 @@
+/**
+ * Common types and utilities for Flowcore Pathways
+ *
+ * This module exports common types and utilities that are used across the Flowcore Pathways library.
+ */
+export * from "./flowcore.type.js";

package/esm/compatibility/flowcore-transformer-core.sdk.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Compatibility layer for the Flowcore Transformer Core SDK
+ *
+ * This module re-exports components from the @flowcore/sdk-transformer-core package
+ * to provide backwards compatibility with existing transformer implementations.
+ */
+import transformerCore from "@flowcore/sdk-transformer-core";
+/**
+ * WebhookBuilder from the transformer core SDK for sending webhook events
+ */
+export declare const WebhookBuilder: typeof transformerCore.WebhookBuilder;
+/**
+ * Options for configuring webhook send operations
+ */
+export type { WebhookSendOptions } from "@flowcore/sdk-transformer-core";
+//# sourceMappingURL=flowcore-transformer-core.sdk.d.ts.map

package/esm/compatibility/flowcore-transformer-core.sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowcore-transformer-core.sdk.d.ts","sourceRoot":"","sources":["../../src/compatibility/flowcore-transformer-core.sdk.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,eAAe,MAAM,gCAAgC,CAAA;AAE5D;;GAEG;AACH,eAAO,MAAQ,cAAc,uCAAoB,CAAA;AAEjD;;GAEG;AACH,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA"}

package/esm/compatibility/flowcore-transformer-core.sdk.js

@@ -0,0 +1,11 @@
+/**
+ * Compatibility layer for the Flowcore Transformer Core SDK
+ *
+ * This module re-exports components from the @flowcore/sdk-transformer-core package
+ * to provide backwards compatibility with existing transformer implementations.
+ */
+import transformerCore from "@flowcore/sdk-transformer-core";
+/**
+ * WebhookBuilder from the transformer core SDK for sending webhook events
+ */
+export const { WebhookBuilder } = transformerCore;

package/esm/contracts/event.d.ts

@@ -0,0 +1,20 @@
+import { type Static, type TObject, type TRecord, type TString, type TUnknown } from "@sinclair/typebox";
+/**
+ * The schema for an event
+ */
+export declare const FlowcoreEventSchema: TObject<{
+    eventId: TString;
+    timeBucket: TString;
+    tenant: TString;
+    dataCoreId: TString;
+    flowType: TString;
+    eventType: TString;
+    metadata: TRecord<TString, TUnknown>;
+    payload: TRecord<TString, TUnknown>;
+    validTime: TString;
+}>;
+/**
+ * The type for an event
+ */
+export type FlowcoreEvent = Static<typeof FlowcoreEventSchema>;
+//# sourceMappingURL=event.d.ts.map

package/esm/contracts/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/contracts/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,mBAAmB,CAAA;AAE9G;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC;IACxC,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,OAAO,CAAA;IACnB,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IACpC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IACnC,SAAS,EAAE,OAAO,CAAA;CACnB,CAUC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/esm/contracts/event.js

@@ -0,0 +1,15 @@
+import { Type } from "@sinclair/typebox";
+/**
+ * The schema for an event
+ */
+export const FlowcoreEventSchema = Type.Object({
+    eventId: Type.String(),
+    timeBucket: Type.String(),
+    tenant: Type.String(),
+    dataCoreId: Type.String(),
+    flowType: Type.String(),
+    eventType: Type.String(),
+    metadata: Type.Record(Type.String(), Type.Unknown()),
+    payload: Type.Record(Type.String(), Type.Unknown()),
+    validTime: Type.String(),
+});

package/esm/contracts/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Export all contract types and schemas for Flowcore events
+ */
+export * from "./event.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,YAAY,CAAC"}

package/esm/contracts/index.js

@@ -0,0 +1,4 @@
+/**
+ * Export all contract types and schemas for Flowcore events
+ */
+export * from "./event.js";

package/esm/mod.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Main export module for Flowcore Pathways
+ *
+ * This module re-exports all the components needed to work with Flowcore Pathways:
+ * - Common types and utilities
+ * - Event contracts and schemas
+ * - Pathway definitions and builders
+ * - Event routing functionality
+ */
+export * from "./common/index.js";
+export * from "./contracts/index.js";
+export * from "./pathways/index.js";
+export * from "./router/index.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/esm/mod.js

@@ -0,0 +1,13 @@
+/**
+ * Main export module for Flowcore Pathways
+ *
+ * This module re-exports all the components needed to work with Flowcore Pathways:
+ * - Common types and utilities
+ * - Event contracts and schemas
+ * - Pathway definitions and builders
+ * - Event routing functionality
+ */
+export * from "./common/index.js";
+export * from "./contracts/index.js";
+export * from "./pathways/index.js";
+export * from "./router/index.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}