@open-mercato/events 0.4.2-canary-c02407ff85

package/build.mjs

@@ -0,0 +1,61 @@
+import * as esbuild from 'esbuild'
+import { glob } from 'glob'
+import { readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+const entryPoints = await glob('src/**/*.ts', {
+  ignore: ['**/__tests__/**', '**/*.test.ts']
+})
+
+// Plugin to add .js extension to relative imports
+const addJsExtension = {
+  name: 'add-js-extension',
+  setup(build) {
+    build.onEnd(async (result) => {
+      if (result.errors.length > 0) return
+      const outputFiles = await glob('dist/**/*.js')
+      for (const file of outputFiles) {
+        const fileDir = dirname(file)
+        let content = readFileSync(file, 'utf-8')
+        // Add .js to relative imports that don't have an extension
+        content = content.replace(
+          /from\s+["'](\.[^"']+)["']/g,
+          (match, path) => {
+            if (path.endsWith('.js') || path.endsWith('.json')) return match
+            // Check if it's a directory with index.js
+            const resolvedPath = join(fileDir, path)
+            if (existsSync(resolvedPath) && existsSync(join(resolvedPath, 'index.js'))) {
+              return `from "${path}/index.js"`
+            }
+            return `from "${path}.js"`
+          }
+        )
+        content = content.replace(
+          /import\s*\(\s*["'](\.[^"']+)["']\s*\)/g,
+          (match, path) => {
+            if (path.endsWith('.js') || path.endsWith('.json')) return match
+            // Check if it's a directory with index.js
+            const resolvedPath = join(fileDir, path)
+            if (existsSync(resolvedPath) && existsSync(join(resolvedPath, 'index.js'))) {
+              return `import("${path}/index.js")`
+            }
+            return `import("${path}.js")`
+          }
+        )
+        writeFileSync(file, content)
+      }
+    })
+  }
+}
+
+await esbuild.build({
+  entryPoints,
+  outdir: 'dist',
+  format: 'esm',
+  platform: 'node',
+  target: 'node18',
+  sourcemap: true,
+  plugins: [addJsExtension],
+})
+
+console.log('events built successfully')

package/dist/bus.js

@@ -0,0 +1,69 @@
+import { createQueue } from "@open-mercato/queue";
+const EVENTS_QUEUE_NAME = "events";
+function createEventBus(opts) {
+  const listeners = /* @__PURE__ */ new Map();
+  const queueStrategy = opts.queueStrategy ?? (process.env.QUEUE_STRATEGY === "async" ? "async" : "local");
+  let queue = null;
+  function getQueue() {
+    if (!queue) {
+      if (queueStrategy === "async") {
+        const redisUrl = process.env.REDIS_URL || process.env.QUEUE_REDIS_URL;
+        if (!redisUrl) {
+          console.warn("[events] No REDIS_URL configured, falling back to localhost:6379");
+        }
+        queue = createQueue(EVENTS_QUEUE_NAME, "async", {
+          connection: { url: redisUrl }
+        });
+      } else {
+        queue = createQueue(EVENTS_QUEUE_NAME, "local");
+      }
+    }
+    return queue;
+  }
+  async function deliver(event, payload) {
+    const handlers = listeners.get(event);
+    if (!handlers || handlers.size === 0) return;
+    for (const handler of handlers) {
+      try {
+        await Promise.resolve(handler(payload, { resolve: opts.resolve }));
+      } catch (error) {
+        console.error(`[events] Handler error for "${event}":`, error);
+      }
+    }
+  }
+  function on(event, handler) {
+    if (!listeners.has(event)) {
+      listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    listeners.get(event).add(handler);
+  }
+  function registerModuleSubscribers(subs) {
+    for (const sub of subs) {
+      on(sub.event, sub.handler);
+    }
+  }
+  async function emit(event, payload, options) {
+    await deliver(event, payload);
+    if (options?.persistent) {
+      const q = getQueue();
+      await q.enqueue({ event, payload });
+    }
+  }
+  async function clearQueue() {
+    const q = getQueue();
+    return q.clear();
+  }
+  const emitEvent = emit;
+  return {
+    emit,
+    emitEvent,
+    // Alias for backward compatibility
+    on,
+    registerModuleSubscribers,
+    clearQueue
+  };
+}
+export {
+  createEventBus
+};
+//# sourceMappingURL=bus.js.map

package/dist/bus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/bus.ts"],
+  "sourcesContent": ["import { createQueue } from '@open-mercato/queue'\nimport type { Queue } from '@open-mercato/queue'\nimport type {\n  EventBus,\n  CreateBusOptions,\n  SubscriberHandler,\n  SubscriberDescriptor,\n  EventPayload,\n  EmitOptions,\n} from './types'\n\n/** Queue name for persistent events */\nconst EVENTS_QUEUE_NAME = 'events'\n\n/** Job data structure for queued events */\ntype EventJobData = {\n  event: string\n  payload: EventPayload\n}\n\n/**\n * Creates an event bus instance.\n *\n * The event bus provides:\n * - In-memory event delivery to registered handlers\n * - Optional persistence via the queue package when `persistent: true`\n *\n * @param opts - Configuration options\n * @returns An EventBus instance\n *\n * @example\n * ```typescript\n * const bus = createEventBus({\n *   resolve: container.resolve.bind(container),\n *   queueStrategy: 'local', // or 'async' for BullMQ\n * })\n *\n * // Register a handler\n * bus.on('user.created', async (payload, ctx) => {\n *   const userService = ctx.resolve('userService')\n *   await userService.sendWelcomeEmail(payload.userId)\n * })\n *\n * // Emit an event (immediate delivery)\n * await bus.emit('user.created', { userId: '123' })\n *\n * // Emit with persistence (for async worker processing)\n * await bus.emit('order.placed', { orderId: '456' }, { persistent: true })\n * ```\n */\nexport function createEventBus(opts: CreateBusOptions): EventBus {\n  // In-memory listeners for immediate event delivery\n  const listeners = new Map<string, Set<SubscriberHandler>>()\n\n  // Determine queue strategy from options or environment\n  const queueStrategy = opts.queueStrategy ??\n    (process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local')\n\n  // Lazy-initialized queue for persistent events\n  let queue: Queue<EventJobData> | null = null\n\n  /**\n   * Gets or creates the queue instance for persistent events.\n   */\n  function getQueue(): Queue<EventJobData> {\n    if (!queue) {\n      if (queueStrategy === 'async') {\n        const redisUrl = process.env.REDIS_URL || process.env.QUEUE_REDIS_URL\n        if (!redisUrl) {\n          console.warn('[events] No REDIS_URL configured, falling back to localhost:6379')\n        }\n        queue = createQueue<EventJobData>(EVENTS_QUEUE_NAME, 'async', {\n          connection: { url: redisUrl }\n        })\n      } else {\n        queue = createQueue<EventJobData>(EVENTS_QUEUE_NAME, 'local')\n      }\n    }\n    return queue\n  }\n\n  /**\n   * Delivers an event to all registered in-memory handlers.\n   */\n  async function deliver(event: string, payload: EventPayload): Promise<void> {\n    const handlers = listeners.get(event)\n    if (!handlers || handlers.size === 0) return\n\n    for (const handler of handlers) {\n      try {\n        await Promise.resolve(handler(payload, { resolve: opts.resolve }))\n      } catch (error) {\n        console.error(`[events] Handler error for \"${event}\":`, error)\n      }\n    }\n  }\n\n  /**\n   * Registers a handler for an event.\n   */\n  function on(event: string, handler: SubscriberHandler): void {\n    if (!listeners.has(event)) {\n      listeners.set(event, new Set())\n    }\n    listeners.get(event)!.add(handler)\n  }\n\n  /**\n   * Registers multiple module subscribers at once.\n   */\n  function registerModuleSubscribers(subs: SubscriberDescriptor[]): void {\n    for (const sub of subs) {\n      on(sub.event, sub.handler)\n    }\n  }\n\n  /**\n   * Emits an event to all registered handlers.\n   *\n   * If `persistent: true`, also enqueues the event for async processing.\n   */\n  async function emit(\n    event: string,\n    payload: EventPayload,\n    options?: EmitOptions\n  ): Promise<void> {\n    // Always deliver to in-memory handlers first\n    await deliver(event, payload)\n\n    // If persistent, also enqueue for async processing\n    if (options?.persistent) {\n      const q = getQueue()\n      await q.enqueue({ event, payload })\n    }\n  }\n\n  /**\n   * Clears all events from the persistent queue.\n   */\n  async function clearQueue(): Promise<{ removed: number }> {\n    const q = getQueue()\n    return q.clear()\n  }\n\n  // Backward compatibility alias\n  const emitEvent = emit\n\n  return {\n    emit,\n    emitEvent, // Alias for backward compatibility\n    on,\n    registerModuleSubscribers,\n    clearQueue,\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAY5B,MAAM,oBAAoB;AAsCnB,SAAS,eAAe,MAAkC;AAE/D,QAAM,YAAY,oBAAI,IAAoC;AAG1D,QAAM,gBAAgB,KAAK,kBACxB,QAAQ,IAAI,mBAAmB,UAAU,UAAU;AAGtD,MAAI,QAAoC;AAKxC,WAAS,WAAgC;AACvC,QAAI,CAAC,OAAO;AACV,UAAI,kBAAkB,SAAS;AAC7B,cAAM,WAAW,QAAQ,IAAI,aAAa,QAAQ,IAAI;AACtD,YAAI,CAAC,UAAU;AACb,kBAAQ,KAAK,kEAAkE;AAAA,QACjF;AACA,gBAAQ,YAA0B,mBAAmB,SAAS;AAAA,UAC5D,YAAY,EAAE,KAAK,SAAS;AAAA,QAC9B,CAAC;AAAA,MACH,OAAO;AACL,gBAAQ,YAA0B,mBAAmB,OAAO;AAAA,MAC9D;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAKA,iBAAe,QAAQ,OAAe,SAAsC;AAC1E,UAAM,WAAW,UAAU,IAAI,KAAK;AACpC,QAAI,CAAC,YAAY,SAAS,SAAS,EAAG;AAEtC,eAAW,WAAW,UAAU;AAC9B,UAAI;AACF,cAAM,QAAQ,QAAQ,QAAQ,SAAS,EAAE,SAAS,KAAK,QAAQ,CAAC,CAAC;AAAA,MACnE,SAAS,OAAO;AACd,gBAAQ,MAAM,+BAA+B,KAAK,MAAM,KAAK;AAAA,MAC/D;AAAA,IACF;AAAA,EACF;AAKA,WAAS,GAAG,OAAe,SAAkC;AAC3D,QAAI,CAAC,UAAU,IAAI,KAAK,GAAG;AACzB,gBAAU,IAAI,OAAO,oBAAI,IAAI,CAAC;AAAA,IAChC;AACA,cAAU,IAAI,KAAK,EAAG,IAAI,OAAO;AAAA,EACnC;AAKA,WAAS,0BAA0B,MAAoC;AACrE,eAAW,OAAO,MAAM;AACtB,SAAG,IAAI,OAAO,IAAI,OAAO;AAAA,IAC3B;AAAA,EACF;AAOA,iBAAe,KACb,OACA,SACA,SACe;AAEf,UAAM,QAAQ,OAAO,OAAO;AAG5B,QAAI,SAAS,YAAY;AACvB,YAAM,IAAI,SAAS;AACnB,YAAM,EAAE,QAAQ,EAAE,OAAO,QAAQ,CAAC;AAAA,IACpC;AAAA,EACF;AAKA,iBAAe,aAA2C;AACxD,UAAM,IAAI,SAAS;AACnB,WAAO,EAAE,MAAM;AAAA,EACjB;AAGA,QAAM,YAAY;AAElB,SAAO;AAAA,IACL;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./bus.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export * from './types'\nexport * from './bus'\n"],
+  "mappings": "AAAA,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/modules/events/index.js

@@ -0,0 +1,9 @@
+const metadata = {
+  id: "events",
+  name: "Events",
+  description: "Event bus and subscriber dispatch"
+};
+export {
+  metadata
+};
+//# sourceMappingURL=index.js.map

package/dist/modules/events/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/events/index.ts"],
+  "sourcesContent": ["export const metadata = {\n  id: 'events',\n  name: 'Events',\n  description: 'Event bus and subscriber dispatch',\n}\n"],
+  "mappings": "AAAO,MAAM,WAAW;AAAA,EACtB,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,aAAa;AACf;",
+  "names": []
+}

package/dist/modules/events/workers/events.worker.js

@@ -0,0 +1,58 @@
+import { getCliModules } from "@open-mercato/shared/modules/registry";
+const EVENTS_QUEUE_NAME = "events";
+const DEFAULT_CONCURRENCY = 1;
+const envConcurrency = process.env.WORKERS_EVENTS_CONCURRENCY;
+const metadata = {
+  queue: EVENTS_QUEUE_NAME,
+  concurrency: envConcurrency ? parseInt(envConcurrency, 10) : DEFAULT_CONCURRENCY
+};
+let cachedListenerMap = null;
+function clearListenerCache() {
+  cachedListenerMap = null;
+}
+function buildListenerMap() {
+  const listeners = /* @__PURE__ */ new Map();
+  for (const mod of getCliModules()) {
+    const subs = mod.subscribers;
+    if (!subs) continue;
+    for (const sub of subs) {
+      if (!listeners.has(sub.event)) listeners.set(sub.event, []);
+      listeners.get(sub.event).push(sub);
+    }
+  }
+  return listeners;
+}
+function getListenerMap() {
+  if (!cachedListenerMap) {
+    cachedListenerMap = buildListenerMap();
+  }
+  return cachedListenerMap;
+}
+async function handle(job, ctx) {
+  const { event, payload } = job.payload;
+  const listeners = getListenerMap();
+  const subscribers = listeners.get(event);
+  if (!subscribers || subscribers.length === 0) return;
+  const errors = [];
+  for (const sub of subscribers) {
+    try {
+      await sub.handler(payload, { resolve: ctx.resolve });
+    } catch (error) {
+      console.error(`[events] Subscriber "${sub.id}" failed for event "${event}":`, error);
+      errors.push({ subscriberId: sub.id, error });
+    }
+  }
+  if (errors.length === subscribers.length) {
+    throw new Error(`All ${errors.length} subscriber(s) failed for event "${event}"`);
+  }
+  if (errors.length > 0) {
+    console.warn(`[events] ${errors.length}/${subscribers.length} subscriber(s) failed for event "${event}"`);
+  }
+}
+export {
+  EVENTS_QUEUE_NAME,
+  clearListenerCache,
+  handle as default,
+  metadata
+};
+//# sourceMappingURL=events.worker.js.map

package/dist/modules/events/workers/events.worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/events/workers/events.worker.ts"],
+  "sourcesContent": ["import type { QueuedJob, JobContext, WorkerMeta } from '@open-mercato/queue'\nimport { getCliModules } from '@open-mercato/shared/modules/registry'\n\nexport const EVENTS_QUEUE_NAME = 'events'\n\nconst DEFAULT_CONCURRENCY = 1\nconst envConcurrency = process.env.WORKERS_EVENTS_CONCURRENCY\n\nexport const metadata: WorkerMeta = {\n  queue: EVENTS_QUEUE_NAME,\n  concurrency: envConcurrency ? parseInt(envConcurrency, 10) : DEFAULT_CONCURRENCY,\n}\n\ntype EventJobPayload = {\n  event: string\n  payload: unknown\n}\n\ntype HandlerContext = { resolve: <T = unknown>(name: string) => T }\n\ntype SubscriberEntry = {\n  id: string\n  event: string\n  handler: (payload: unknown, ctx: unknown) => Promise<void> | void\n}\n\n// Cached listener map - built once on first use\nlet cachedListenerMap: Map<string, SubscriberEntry[]> | null = null\n\n/**\n * Clear the cached listener map (for testing purposes).\n */\nexport function clearListenerCache(): void {\n  cachedListenerMap = null\n}\n\n// Build listener map from module subscribers\nfunction buildListenerMap(): Map<string, SubscriberEntry[]> {\n  const listeners = new Map<string, SubscriberEntry[]>()\n  for (const mod of getCliModules()) {\n    const subs = (mod as { subscribers?: SubscriberEntry[] }).subscribers\n    if (!subs) continue\n    for (const sub of subs) {\n      if (!listeners.has(sub.event)) listeners.set(sub.event, [])\n      listeners.get(sub.event)!.push(sub)\n    }\n  }\n  return listeners\n}\n\n// Get cached listener map, building on first access\nfunction getListenerMap(): Map<string, SubscriberEntry[]> {\n  if (!cachedListenerMap) {\n    cachedListenerMap = buildListenerMap()\n  }\n  return cachedListenerMap\n}\n\n/**\n * Events worker handler.\n * Dispatches queued events to registered module subscribers.\n * Each subscriber is isolated - failures in one don't affect others.\n */\nexport default async function handle(\n  job: QueuedJob<EventJobPayload>,\n  ctx: JobContext & HandlerContext\n): Promise<void> {\n  const { event, payload } = job.payload\n  const listeners = getListenerMap()\n  const subscribers = listeners.get(event)\n\n  if (!subscribers || subscribers.length === 0) return\n\n  const errors: Array<{ subscriberId: string; error: unknown }> = []\n\n  for (const sub of subscribers) {\n    try {\n      await sub.handler(payload, { resolve: ctx.resolve })\n    } catch (error) {\n      // Log error but continue processing other subscribers\n      console.error(`[events] Subscriber \"${sub.id}\" failed for event \"${event}\":`, error)\n      errors.push({ subscriberId: sub.id, error })\n    }\n  }\n\n  // If all subscribers failed, throw to trigger retry\n  if (errors.length === subscribers.length) {\n    throw new Error(`All ${errors.length} subscriber(s) failed for event \"${event}\"`)\n  }\n\n  // Log partial failures but don't fail the job\n  if (errors.length > 0) {\n    console.warn(`[events] ${errors.length}/${subscribers.length} subscriber(s) failed for event \"${event}\"`)\n  }\n}\n"],
+  "mappings": "AACA,SAAS,qBAAqB;AAEvB,MAAM,oBAAoB;AAEjC,MAAM,sBAAsB;AAC5B,MAAM,iBAAiB,QAAQ,IAAI;AAE5B,MAAM,WAAuB;AAAA,EAClC,OAAO;AAAA,EACP,aAAa,iBAAiB,SAAS,gBAAgB,EAAE,IAAI;AAC/D;AAgBA,IAAI,oBAA2D;AAKxD,SAAS,qBAA2B;AACzC,sBAAoB;AACtB;AAGA,SAAS,mBAAmD;AAC1D,QAAM,YAAY,oBAAI,IAA+B;AACrD,aAAW,OAAO,cAAc,GAAG;AACjC,UAAM,OAAQ,IAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,eAAW,OAAO,MAAM;AACtB,UAAI,CAAC,UAAU,IAAI,IAAI,KAAK,EAAG,WAAU,IAAI,IAAI,OAAO,CAAC,CAAC;AAC1D,gBAAU,IAAI,IAAI,KAAK,EAAG,KAAK,GAAG;AAAA,IACpC;AAAA,EACF;AACA,SAAO;AACT;AAGA,SAAS,iBAAiD;AACxD,MAAI,CAAC,mBAAmB;AACtB,wBAAoB,iBAAiB;AAAA,EACvC;AACA,SAAO;AACT;AAOA,eAAO,OACL,KACA,KACe;AACf,QAAM,EAAE,OAAO,QAAQ,IAAI,IAAI;AAC/B,QAAM,YAAY,eAAe;AACjC,QAAM,cAAc,UAAU,IAAI,KAAK;AAEvC,MAAI,CAAC,eAAe,YAAY,WAAW,EAAG;AAE9C,QAAM,SAA0D,CAAC;AAEjE,aAAW,OAAO,aAAa;AAC7B,QAAI;AACF,YAAM,IAAI,QAAQ,SAAS,EAAE,SAAS,IAAI,QAAQ,CAAC;AAAA,IACrD,SAAS,OAAO;AAEd,cAAQ,MAAM,wBAAwB,IAAI,EAAE,uBAAuB,KAAK,MAAM,KAAK;AACnF,aAAO,KAAK,EAAE,cAAc,IAAI,IAAI,MAAM,CAAC;AAAA,IAC7C;AAAA,EACF;AAGA,MAAI,OAAO,WAAW,YAAY,QAAQ;AACxC,UAAM,IAAI,MAAM,OAAO,OAAO,MAAM,oCAAoC,KAAK,GAAG;AAAA,EAClF;AAGA,MAAI,OAAO,SAAS,GAAG;AACrB,YAAQ,KAAK,YAAY,OAAO,MAAM,IAAI,YAAY,MAAM,oCAAoC,KAAK,GAAG;AAAA,EAC1G;AACF;",
+  "names": []
+}

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/jest.config.cjs

@@ -0,0 +1,19 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  rootDir: '.',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
+  transform: {
+    '^.+\\.(t|j)sx?$': [
+      'ts-jest',
+      {
+        tsconfig: {
+          jsx: 'react-jsx',
+        },
+      },
+    ],
+  },
+  testMatch: ['<rootDir>/src/**/__tests__/**/*.test.(ts|tsx)'],
+  passWithNoTests: true,
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@open-mercato/events",
+  "version": "0.4.2-canary-c02407ff85",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "node build.mjs",
+    "watch": "node watch.mjs",
+    "test": "jest --config jest.config.cjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*.ts": {
+      "types": "./src/*.ts",
+      "default": "./dist/*.js"
+    },
+    "./*": {
+      "types": [
+        "./src/*.ts"
+      ],
+      "default": "./dist/*.js"
+    },
+    "./*/*": {
+      "types": [
+        "./src/*/*.ts"
+      ],
+      "default": "./dist/*/*.js"
+    }
+  },
+  "dependencies": {
+    "@open-mercato/queue": "0.4.2-canary-c02407ff85"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "stableVersion": "0.4.1"
+}

package/src/__tests__/local.strategy.test.ts

@@ -0,0 +1,110 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { createEventBus } from '@open-mercato/events/index'
+
+function readJson(p: string) { return JSON.parse(fs.readFileSync(p, 'utf8')) }
+
+describe('Event bus', () => {
+  const origCwd = process.cwd()
+  let tmp: string
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'events-test-'))
+    process.chdir(tmp)
+    delete process.env.QUEUE_STRATEGY
+    delete process.env.EVENTS_STRATEGY
+  })
+  afterEach(() => {
+    process.chdir(origCwd)
+    try { fs.rmSync(tmp, { recursive: true, force: true }) } catch {}
+  })
+
+  test('online delivery via on + emit', async () => {
+    const calls: any[] = []
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+    bus.on('demo', async (payload, ctx) => { calls.push({ payload, resolved: ctx.resolve('em') }) })
+    await bus.emit('demo', { a: 1 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0].payload).toEqual({ a: 1 })
+    expect(calls[0].resolved).toEqual('em')
+  })
+
+  test('emitEvent alias works for backward compatibility', async () => {
+    const calls: any[] = []
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+    bus.on('demo', async (payload) => { calls.push(payload) })
+    await bus.emitEvent('demo', { a: 1 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toEqual({ a: 1 })
+  })
+
+  test('persistent events are recorded to queue', async () => {
+    const queueDir = path.resolve('.queue', 'events')
+    const queuePath = path.join(queueDir, 'queue.json')
+    const recv: any[] = []
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+    bus.on('queued', (payload) => { recv.push(payload) })
+
+    // Emit persistent events
+    await bus.emit('queued', { id: 1 }, { persistent: true })
+    await bus.emit('queued', { id: 2 }, { persistent: true })
+
+    // Events should be delivered immediately
+    expect(recv).toHaveLength(2)
+
+    // And also persisted to queue
+    const list = readJson(queuePath)
+    expect(Array.isArray(list)).toBe(true)
+    expect(list.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test('clearQueue removes all queued events', async () => {
+    const queueDir = path.resolve('.queue', 'events')
+    const queuePath = path.join(queueDir, 'queue.json')
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+
+    await bus.emit('q', { n: 1 }, { persistent: true })
+    await bus.emit('q', { n: 2 }, { persistent: true })
+
+    const before = readJson(queuePath)
+    expect(before.length).toBeGreaterThanOrEqual(2)
+
+    const result = await bus.clearQueue()
+    expect(result.removed).toBeGreaterThanOrEqual(0)
+
+    const after = readJson(queuePath)
+    expect(after.length).toBe(0)
+  })
+
+  test('registerModuleSubscribers registers handlers', async () => {
+    const calls: any[] = []
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+
+    bus.registerModuleSubscribers([
+      { id: 'sub1', event: 'test.event', handler: (p) => { calls.push(p) } },
+      { id: 'sub2', event: 'other.event', handler: (p) => { calls.push(p) } },
+    ])
+
+    await bus.emit('test.event', { value: 1 })
+    await bus.emit('other.event', { value: 2 })
+
+    expect(calls).toHaveLength(2)
+    expect(calls[0]).toEqual({ value: 1 })
+    expect(calls[1]).toEqual({ value: 2 })
+  })
+
+  test('non-persistent events are not queued', async () => {
+    const queueDir = path.resolve('.queue', 'events')
+    const queuePath = path.join(queueDir, 'queue.json')
+    const bus = createEventBus({ resolve: ((name: string) => name) as any })
+
+    await bus.emit('demo', { id: 1 }) // Non-persistent
+
+    // Queue file should not exist or be empty
+    if (fs.existsSync(queuePath)) {
+      const list = readJson(queuePath)
+      expect(list.length).toBe(0)
+    }
+  })
+})

package/src/bus.ts

@@ -0,0 +1,155 @@
+import { createQueue } from '@open-mercato/queue'
+import type { Queue } from '@open-mercato/queue'
+import type {
+  EventBus,
+  CreateBusOptions,
+  SubscriberHandler,
+  SubscriberDescriptor,
+  EventPayload,
+  EmitOptions,
+} from './types'
+
+/** Queue name for persistent events */
+const EVENTS_QUEUE_NAME = 'events'
+
+/** Job data structure for queued events */
+type EventJobData = {
+  event: string
+  payload: EventPayload
+}
+
+/**
+ * Creates an event bus instance.
+ *
+ * The event bus provides:
+ * - In-memory event delivery to registered handlers
+ * - Optional persistence via the queue package when `persistent: true`
+ *
+ * @param opts - Configuration options
+ * @returns An EventBus instance
+ *
+ * @example
+ * ```typescript
+ * const bus = createEventBus({
+ *   resolve: container.resolve.bind(container),
+ *   queueStrategy: 'local', // or 'async' for BullMQ
+ * })
+ *
+ * // Register a handler
+ * bus.on('user.created', async (payload, ctx) => {
+ *   const userService = ctx.resolve('userService')
+ *   await userService.sendWelcomeEmail(payload.userId)
+ * })
+ *
+ * // Emit an event (immediate delivery)
+ * await bus.emit('user.created', { userId: '123' })
+ *
+ * // Emit with persistence (for async worker processing)
+ * await bus.emit('order.placed', { orderId: '456' }, { persistent: true })
+ * ```
+ */
+export function createEventBus(opts: CreateBusOptions): EventBus {
+  // In-memory listeners for immediate event delivery
+  const listeners = new Map<string, Set<SubscriberHandler>>()
+
+  // Determine queue strategy from options or environment
+  const queueStrategy = opts.queueStrategy ??
+    (process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local')
+
+  // Lazy-initialized queue for persistent events
+  let queue: Queue<EventJobData> | null = null
+
+  /**
+   * Gets or creates the queue instance for persistent events.
+   */
+  function getQueue(): Queue<EventJobData> {
+    if (!queue) {
+      if (queueStrategy === 'async') {
+        const redisUrl = process.env.REDIS_URL || process.env.QUEUE_REDIS_URL
+        if (!redisUrl) {
+          console.warn('[events] No REDIS_URL configured, falling back to localhost:6379')
+        }
+        queue = createQueue<EventJobData>(EVENTS_QUEUE_NAME, 'async', {
+          connection: { url: redisUrl }
+        })
+      } else {
+        queue = createQueue<EventJobData>(EVENTS_QUEUE_NAME, 'local')
+      }
+    }
+    return queue
+  }
+
+  /**
+   * Delivers an event to all registered in-memory handlers.
+   */
+  async function deliver(event: string, payload: EventPayload): Promise<void> {
+    const handlers = listeners.get(event)
+    if (!handlers || handlers.size === 0) return
+
+    for (const handler of handlers) {
+      try {
+        await Promise.resolve(handler(payload, { resolve: opts.resolve }))
+      } catch (error) {
+        console.error(`[events] Handler error for "${event}":`, error)
+      }
+    }
+  }
+
+  /**
+   * Registers a handler for an event.
+   */
+  function on(event: string, handler: SubscriberHandler): void {
+    if (!listeners.has(event)) {
+      listeners.set(event, new Set())
+    }
+    listeners.get(event)!.add(handler)
+  }
+
+  /**
+   * Registers multiple module subscribers at once.
+   */
+  function registerModuleSubscribers(subs: SubscriberDescriptor[]): void {
+    for (const sub of subs) {
+      on(sub.event, sub.handler)
+    }
+  }
+
+  /**
+   * Emits an event to all registered handlers.
+   *
+   * If `persistent: true`, also enqueues the event for async processing.
+   */
+  async function emit(
+    event: string,
+    payload: EventPayload,
+    options?: EmitOptions
+  ): Promise<void> {
+    // Always deliver to in-memory handlers first
+    await deliver(event, payload)
+
+    // If persistent, also enqueue for async processing
+    if (options?.persistent) {
+      const q = getQueue()
+      await q.enqueue({ event, payload })
+    }
+  }
+
+  /**
+   * Clears all events from the persistent queue.
+   */
+  async function clearQueue(): Promise<{ removed: number }> {
+    const q = getQueue()
+    return q.clear()
+  }
+
+  // Backward compatibility alias
+  const emitEvent = emit
+
+  return {
+    emit,
+    emitEvent, // Alias for backward compatibility
+    on,
+    registerModuleSubscribers,
+    clearQueue,
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export * from './bus'

package/src/modules/events/index.ts

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: 'events',
+  name: 'Events',
+  description: 'Event bus and subscriber dispatch',
+}

package/src/modules/events/workers/__tests__/events.worker.test.ts

@@ -0,0 +1,311 @@
+import { registerCliModules, getCliModules } from '@open-mercato/shared/modules/registry'
+import type { Module } from '@open-mercato/shared/modules/registry'
+import type { QueuedJob, JobContext } from '@open-mercato/queue'
+import handle, { metadata, EVENTS_QUEUE_NAME, clearListenerCache } from '../events.worker'
+
+// Clear modules and listener cache before each test
+function clearModules() {
+  // Re-register with empty array to clear
+  registerCliModules([])
+  // Clear the listener cache so tests don't affect each other
+  clearListenerCache()
+}
+
+describe('Events Worker', () => {
+  beforeEach(() => {
+    clearModules()
+  })
+
+  afterEach(() => {
+    clearModules()
+  })
+
+  describe('metadata', () => {
+    it('should export correct queue name', () => {
+      expect(metadata.queue).toBe('events')
+      expect(EVENTS_QUEUE_NAME).toBe('events')
+    })
+
+    it('should have default concurrency of 1', () => {
+      // When no env var is set, should default to 1
+      expect(metadata.concurrency).toBe(1)
+    })
+  })
+
+  describe('handle', () => {
+    const createMockJob = (event: string, payload: unknown): QueuedJob<{ event: string; payload: unknown }> => ({
+      id: 'test-job-id',
+      payload: { event, payload },
+      createdAt: new Date().toISOString(),
+    })
+
+    const createMockContext = (): JobContext & { resolve: <T = unknown>(name: string) => T } => ({
+      jobId: 'test-job-id',
+      attemptNumber: 1,
+      queueName: 'events',
+      resolve: <T = unknown>(name: string): T => {
+        throw new Error(`No mock for ${name}`)
+      },
+    })
+
+    it('should do nothing when no subscribers are registered', async () => {
+      const job = createMockJob('test.event', { data: 'test' })
+      const ctx = createMockContext()
+
+      // Should not throw
+      await expect(handle(job, ctx)).resolves.toBeUndefined()
+    })
+
+    it('should dispatch event to matching subscribers', async () => {
+      const receivedPayloads: unknown[] = []
+
+      const mockModule: Module = {
+        id: 'test-module',
+        subscribers: [
+          {
+            id: 'test:subscriber1',
+            event: 'user.created',
+            handler: async (payload: unknown) => {
+              receivedPayloads.push(payload)
+            },
+          },
+        ],
+      }
+
+      registerCliModules([mockModule])
+
+      const job = createMockJob('user.created', { userId: '123', name: 'Test User' })
+      const ctx = createMockContext()
+
+      await handle(job, ctx)
+
+      expect(receivedPayloads.length).toBe(1)
+      expect(receivedPayloads[0]).toEqual({ userId: '123', name: 'Test User' })
+    })
+
+    it('should dispatch to multiple subscribers for same event', async () => {
+      const subscriber1Calls: unknown[] = []
+      const subscriber2Calls: unknown[] = []
+
+      const mockModules: Module[] = [
+        {
+          id: 'module-a',
+          subscribers: [
+            {
+              id: 'a:subscriber',
+              event: 'order.placed',
+              handler: async (payload: unknown) => {
+                subscriber1Calls.push(payload)
+              },
+            },
+          ],
+        },
+        {
+          id: 'module-b',
+          subscribers: [
+            {
+              id: 'b:subscriber',
+              event: 'order.placed',
+              handler: async (payload: unknown) => {
+                subscriber2Calls.push(payload)
+              },
+            },
+          ],
+        },
+      ]
+
+      registerCliModules(mockModules)
+
+      const job = createMockJob('order.placed', { orderId: '456' })
+      const ctx = createMockContext()
+
+      await handle(job, ctx)
+
+      expect(subscriber1Calls.length).toBe(1)
+      expect(subscriber2Calls.length).toBe(1)
+      expect(subscriber1Calls[0]).toEqual({ orderId: '456' })
+      expect(subscriber2Calls[0]).toEqual({ orderId: '456' })
+    })
+
+    it('should not dispatch to non-matching event subscribers', async () => {
+      const receivedPayloads: unknown[] = []
+
+      const mockModule: Module = {
+        id: 'test-module',
+        subscribers: [
+          {
+            id: 'test:subscriber',
+            event: 'user.created',
+            handler: async (payload: unknown) => {
+              receivedPayloads.push(payload)
+            },
+          },
+        ],
+      }
+
+      registerCliModules([mockModule])
+
+      const job = createMockJob('user.deleted', { userId: '123' })
+      const ctx = createMockContext()
+
+      await handle(job, ctx)
+
+      expect(receivedPayloads.length).toBe(0)
+    })
+
+    it('should pass resolve function to subscriber context', async () => {
+      let capturedContext: unknown = null
+
+      const mockModule: Module = {
+        id: 'test-module',
+        subscribers: [
+          {
+            id: 'test:subscriber',
+            event: 'test.event',
+            handler: async (_payload: unknown, ctx: unknown) => {
+              capturedContext = ctx
+            },
+          },
+        ],
+      }
+
+      registerCliModules([mockModule])
+
+      const mockResolve = jest.fn().mockReturnValue('resolved-service')
+      const job = createMockJob('test.event', {})
+      const ctx = {
+        ...createMockContext(),
+        resolve: mockResolve,
+      }
+
+      await handle(job, ctx)
+
+      expect(capturedContext).toBeDefined()
+      expect((capturedContext as { resolve: unknown }).resolve).toBeDefined()
+    })
+
+    it('should handle modules without subscribers', async () => {
+      const mockModule: Module = {
+        id: 'module-without-subscribers',
+        // No subscribers property
+      }
+
+      registerCliModules([mockModule])
+
+      const job = createMockJob('any.event', {})
+      const ctx = createMockContext()
+
+      // Should not throw
+      await expect(handle(job, ctx)).resolves.toBeUndefined()
+    })
+
+    it('should handle synchronous handlers', async () => {
+      let called = false
+
+      const mockModule: Module = {
+        id: 'test-module',
+        subscribers: [
+          {
+            id: 'test:sync-subscriber',
+            event: 'sync.event',
+            handler: () => {
+              called = true
+            },
+          },
+        ],
+      }
+
+      registerCliModules([mockModule])
+
+      const job = createMockJob('sync.event', {})
+      const ctx = createMockContext()
+
+      await handle(job, ctx)
+
+      expect(called).toBe(true)
+    })
+
+    it('should isolate errors - continue processing other subscribers when one fails', async () => {
+      const subscriber1Calls: unknown[] = []
+      const subscriber2Calls: unknown[] = []
+
+      const mockModules: Module[] = [
+        {
+          id: 'module-a',
+          subscribers: [
+            {
+              id: 'a:failing-subscriber',
+              event: 'test.event',
+              handler: async () => {
+                subscriber1Calls.push('called')
+                throw new Error('Subscriber A failed')
+              },
+            },
+          ],
+        },
+        {
+          id: 'module-b',
+          subscribers: [
+            {
+              id: 'b:working-subscriber',
+              event: 'test.event',
+              handler: async (payload: unknown) => {
+                subscriber2Calls.push(payload)
+              },
+            },
+          ],
+        },
+      ]
+
+      registerCliModules(mockModules)
+
+      const job = createMockJob('test.event', { data: 'test' })
+      const ctx = createMockContext()
+
+      // Should not throw - partial failures are logged but don't fail the job
+      await expect(handle(job, ctx)).resolves.toBeUndefined()
+
+      // Both subscribers should have been called
+      expect(subscriber1Calls.length).toBe(1)
+      expect(subscriber2Calls.length).toBe(1)
+      expect(subscriber2Calls[0]).toEqual({ data: 'test' })
+    })
+
+    it('should throw when all subscribers fail', async () => {
+      const mockModules: Module[] = [
+        {
+          id: 'module-a',
+          subscribers: [
+            {
+              id: 'a:failing-subscriber',
+              event: 'test.event',
+              handler: async () => {
+                throw new Error('Subscriber A failed')
+              },
+            },
+          ],
+        },
+        {
+          id: 'module-b',
+          subscribers: [
+            {
+              id: 'b:failing-subscriber',
+              event: 'test.event',
+              handler: async () => {
+                throw new Error('Subscriber B failed')
+              },
+            },
+          ],
+        },
+      ]
+
+      registerCliModules(mockModules)
+
+      const job = createMockJob('test.event', { data: 'test' })
+      const ctx = createMockContext()
+
+      // Should throw when all subscribers fail
+      await expect(handle(job, ctx)).rejects.toThrow('All 2 subscriber(s) failed for event "test.event"')
+    })
+  })
+})

package/src/modules/events/workers/events.worker.ts

@@ -0,0 +1,95 @@
+import type { QueuedJob, JobContext, WorkerMeta } from '@open-mercato/queue'
+import { getCliModules } from '@open-mercato/shared/modules/registry'
+
+export const EVENTS_QUEUE_NAME = 'events'
+
+const DEFAULT_CONCURRENCY = 1
+const envConcurrency = process.env.WORKERS_EVENTS_CONCURRENCY
+
+export const metadata: WorkerMeta = {
+  queue: EVENTS_QUEUE_NAME,
+  concurrency: envConcurrency ? parseInt(envConcurrency, 10) : DEFAULT_CONCURRENCY,
+}
+
+type EventJobPayload = {
+  event: string
+  payload: unknown
+}
+
+type HandlerContext = { resolve: <T = unknown>(name: string) => T }
+
+type SubscriberEntry = {
+  id: string
+  event: string
+  handler: (payload: unknown, ctx: unknown) => Promise<void> | void
+}
+
+// Cached listener map - built once on first use
+let cachedListenerMap: Map<string, SubscriberEntry[]> | null = null
+
+/**
+ * Clear the cached listener map (for testing purposes).
+ */
+export function clearListenerCache(): void {
+  cachedListenerMap = null
+}
+
+// Build listener map from module subscribers
+function buildListenerMap(): Map<string, SubscriberEntry[]> {
+  const listeners = new Map<string, SubscriberEntry[]>()
+  for (const mod of getCliModules()) {
+    const subs = (mod as { subscribers?: SubscriberEntry[] }).subscribers
+    if (!subs) continue
+    for (const sub of subs) {
+      if (!listeners.has(sub.event)) listeners.set(sub.event, [])
+      listeners.get(sub.event)!.push(sub)
+    }
+  }
+  return listeners
+}
+
+// Get cached listener map, building on first access
+function getListenerMap(): Map<string, SubscriberEntry[]> {
+  if (!cachedListenerMap) {
+    cachedListenerMap = buildListenerMap()
+  }
+  return cachedListenerMap
+}
+
+/**
+ * Events worker handler.
+ * Dispatches queued events to registered module subscribers.
+ * Each subscriber is isolated - failures in one don't affect others.
+ */
+export default async function handle(
+  job: QueuedJob<EventJobPayload>,
+  ctx: JobContext & HandlerContext
+): Promise<void> {
+  const { event, payload } = job.payload
+  const listeners = getListenerMap()
+  const subscribers = listeners.get(event)
+
+  if (!subscribers || subscribers.length === 0) return
+
+  const errors: Array<{ subscriberId: string; error: unknown }> = []
+
+  for (const sub of subscribers) {
+    try {
+      await sub.handler(payload, { resolve: ctx.resolve })
+    } catch (error) {
+      // Log error but continue processing other subscribers
+      console.error(`[events] Subscriber "${sub.id}" failed for event "${event}":`, error)
+      errors.push({ subscriberId: sub.id, error })
+    }
+  }
+
+  // If all subscribers failed, throw to trigger retry
+  if (errors.length === subscribers.length) {
+    throw new Error(`All ${errors.length} subscriber(s) failed for event "${event}"`)
+  }
+
+  // Log partial failures but don't fail the job
+  if (errors.length > 0) {
+    console.warn(`[events] ${errors.length}/${subscribers.length} subscriber(s) failed for event "${event}"`)
+  }
+}

package/src/types.ts

@@ -0,0 +1,138 @@
+/**
+ * Events Package Type Definitions
+ *
+ * Provides type-safe abstractions for the event bus system.
+ */
+
+// ============================================================================
+// Core Types
+// ============================================================================
+
+/** Payload type for events - can be any value */
+export type EventPayload = unknown
+
+/** Metadata for subscriber definitions */
+export type SubscriberMeta = {
+  /** Event name to subscribe to */
+  event: string
+  /** Optional unique identifier for the subscriber */
+  id?: string
+}
+
+/** Context passed to event handlers */
+export type SubscriberContext = {
+  /** DI container resolve function */
+  resolve: <T = unknown>(name: string) => T
+}
+
+/** Event handler function signature */
+export type SubscriberHandler = (
+  payload: EventPayload,
+  ctx: SubscriberContext
+) => Promise<void> | void
+
+/** Full descriptor for a module subscriber */
+export type SubscriberDescriptor = {
+  /** Unique identifier for this subscriber */
+  id: string
+  /** Event name to subscribe to */
+  event: string
+  /** Handler function */
+  handler: SubscriberHandler
+}
+
+// ============================================================================
+// Event Bus Types
+// ============================================================================
+
+/** Options for emitting events */
+export type EmitOptions = {
+  /** If true, the event will be persisted to a queue for async processing */
+  persistent?: boolean
+}
+
+/** Options for creating an event bus */
+export type CreateBusOptions = {
+  /** DI container resolve function */
+  resolve: <T = unknown>(name: string) => T
+  /** Queue strategy for persistent events: 'local' (file-based) or 'async' (BullMQ) */
+  queueStrategy?: 'local' | 'async'
+}
+
+/**
+ * Main EventBus interface.
+ *
+ * The event bus handles:
+ * - In-memory event delivery to registered handlers
+ * - Optional persistence of events to a queue for async processing
+ */
+export interface EventBus {
+  /**
+   * Emit an event to all registered handlers.
+   *
+   * @param event - Event name
+   * @param payload - Event payload data
+   * @param options - Emit options
+   *
+   * @example
+   * ```typescript
+   * // Immediate delivery only
+   * await bus.emit('user.created', { userId: '123' })
+   *
+   * // Immediate delivery + queue for async processing
+   * await bus.emit('order.placed', { orderId: '456' }, { persistent: true })
+   * ```
+   */
+  emit(event: string, payload: EventPayload, options?: EmitOptions): Promise<void>
+
+  /**
+   * Register a handler for an event.
+   *
+   * @param event - Event name to listen for
+   * @param handler - Handler function
+   */
+  on(event: string, handler: SubscriberHandler): void
+
+  /**
+   * Register multiple module subscribers at once.
+   *
+   * @param subs - Array of subscriber descriptors
+   */
+  registerModuleSubscribers(subs: SubscriberDescriptor[]): void
+
+  /**
+   * Clear all events from the persistent queue.
+   *
+   * @returns Count of removed events
+   */
+  clearQueue(): Promise<{ removed: number }>
+
+  /**
+   * Alias for emit() for backward compatibility.
+   * @deprecated Use emit() instead
+   */
+  emitEvent(event: string, payload: EventPayload, options?: EmitOptions): Promise<void>
+}
+
+// ============================================================================
+// Legacy Types (for backwards compatibility)
+// ============================================================================
+
+/** @deprecated Use QueuedJob from @open-mercato/queue instead */
+export type QueuedEvent = {
+  id: number
+  event: string
+  payload: EventPayload
+  persistent?: boolean
+  createdAt: string
+}
+
+/** @deprecated Use EventBus interface instead */
+export type EventStrategy = {
+  emit: (evt: Omit<QueuedEvent, 'id' | 'createdAt'> & { createdAt?: string }) => Promise<void>
+  on: (event: string, handler: SubscriberHandler) => void
+  registerModuleSubscribers: (subs: SubscriberDescriptor[]) => void
+  processOffline: (opts?: { limit?: number }) => Promise<{ processed: number; lastId?: number }>
+  clearQueue: () => Promise<{ removed: number }>
+  clearProcessed: () => Promise<{ removed: number; lastId?: number }>
+}

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": false,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/__tests__/**"]
+}

package/watch.mjs

@@ -0,0 +1,6 @@
+import { watch } from '../../scripts/watch.mjs'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+watch(__dirname)