@adjedaini/clockwork-node 0.0.1

package/node_modules/@adjedaini/clockwork-log-interceptor/src/winston.ts

@@ -0,0 +1,66 @@
+/**
+ * Winston plugin: intercepts winston logger output and attaches to current request.
+ * Only applied if the 'winston' module is installed.
+ */
+
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+import type { LogData } from '@adjedaini/clockwork-shared';
+
+const LEVEL_MAP: Record<string, LogData['level']> = {
+  error: 'error',
+  warn: 'warning',
+  warning: 'warning',
+  info: 'info',
+  http: 'info',
+  verbose: 'debug',
+  debug: 'debug',
+  silly: 'debug',
+};
+
+function wrapWinston(ctx: IPluginContext): () => void {
+  let winstonId: string;
+  try {
+    winstonId = require.resolve('winston');
+  } catch {
+    return () => {};
+  }
+  const mod = require.cache[winstonId] as { exports: { createLogger?: (opts?: unknown) => WinstonLogger } } | undefined;
+  if (!mod?.exports?.createLogger) return () => {};
+
+  const winston = mod.exports;
+  const originalCreateLogger = winston.createLogger!.bind(winston);
+
+  winston.createLogger = function (opts?: unknown) {
+    const logger = originalCreateLogger(opts) as WinstonLogger;
+    const origLog = logger.log?.bind(logger);
+    if (typeof origLog !== 'function') return logger;
+
+    logger.log = function (this: WinstonLogger, levelOrMeta: string | object, msg?: string | (() => void), ...args: unknown[]) {
+      const requestId = ctx.getRequestId();
+      if (requestId) {
+        const level = typeof levelOrMeta === 'string' ? levelOrMeta : 'info';
+        const message = typeof msg === 'string' ? msg : (typeof levelOrMeta === 'object' && levelOrMeta !== null && 'message' in levelOrMeta)
+          ? String((levelOrMeta as { message?: unknown }).message)
+          : String(msg ?? levelOrMeta);
+        const levelMapped = LEVEL_MAP[level] ?? 'info';
+        ctx.core.captureNativeLog(requestId, levelMapped, message, undefined);
+      }
+      return origLog(levelOrMeta as string, msg as string, ...args);
+    };
+
+    return logger;
+  };
+
+  return function restore() {
+    winston.createLogger = originalCreateLogger;
+  };
+}
+
+interface WinstonLogger {
+  log?(level: string, msg: string, ...args: unknown[]): unknown;
+}
+
+export const winstonPlugin: ClockworkPlugin = {
+  name: 'winston',
+  install: wrapWinston,
+};

package/node_modules/@adjedaini/clockwork-log-interceptor/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": { "composite": false }
+}

package/node_modules/@adjedaini/clockwork-log-interceptor/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "references": [{ "path": "../core" }, { "path": "../shared" }]
+}

package/node_modules/@adjedaini/clockwork-log-interceptor/tsup.config.ts

@@ -0,0 +1,13 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { defineConfig } from 'tsup';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs'],
+  dts: true,
+  outDir: 'dist',
+  tsconfig: path.join(__dirname, 'tsconfig.build.json'),
+});

package/node_modules/@adjedaini/clockwork-plugins/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { IPluginContext, ClockworkPlugin } from '@adjedaini/clockwork-core';
+import { NextLike } from '@adjedaini/clockwork-transport-http';
+export { defaultLogPlugins, pinoPlugin, winstonPlugin } from '@adjedaini/clockwork-log-interceptor';
+export { defaultDbPlugins, mysql2Plugin, pgPlugin } from '@adjedaini/clockwork-db-interceptor';
+
+/**
+ * Context plugin: provides AsyncLocalStorage and request-scoped getRequestId.
+ * Must be installed first so other plugins receive a working getRequestId.
+ */
+
+/** Extended context that allows the context plugin to register getRequestId and runner. */
+interface ContextPluginContext extends IPluginContext {
+    registerContext(getRequestId: () => string | undefined, contextRunner: (requestId: string, next: NextLike) => void): void;
+}
+declare const contextPlugin: ClockworkPlugin;
+
+/**
+ * Console plugin: intercepts console.* (native log) and attaches to current request.
+ */
+
+declare const consolePlugin: ClockworkPlugin;
+
+/**
+ * Process errors plugin: captures uncaughtException and unhandledRejection.
+ */
+
+declare const processErrorsPlugin: ClockworkPlugin;
+
+/**
+ * @adjedaini/clockwork-plugins
+ * Built-in plugins (context, console, process-errors) and default plugin composition.
+ */
+
+/** Context + console + processErrors. Context must be first. */
+declare const defaultCorePlugins: ClockworkPlugin[];
+/** Build default plugin list from options. */
+declare function getDefaultPlugins(options: {
+    console?: boolean;
+    errors?: boolean;
+    logPlugins?: boolean;
+    db?: boolean;
+    dbPlugins?: ClockworkPlugin[];
+}): ClockworkPlugin[];
+
+export { type ContextPluginContext, consolePlugin, contextPlugin, defaultCorePlugins, getDefaultPlugins, processErrorsPlugin };

package/node_modules/@adjedaini/clockwork-plugins/dist/index.js

@@ -0,0 +1,172 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  consolePlugin: () => consolePlugin,
+  contextPlugin: () => contextPlugin,
+  defaultCorePlugins: () => defaultCorePlugins,
+  defaultDbPlugins: () => import_clockwork_db_interceptor2.defaultDbPlugins,
+  defaultLogPlugins: () => import_clockwork_log_interceptor2.defaultLogPlugins,
+  getDefaultPlugins: () => getDefaultPlugins,
+  mysql2Plugin: () => import_clockwork_db_interceptor2.mysql2Plugin,
+  pgPlugin: () => import_clockwork_db_interceptor2.pgPlugin,
+  pinoPlugin: () => import_clockwork_log_interceptor2.pinoPlugin,
+  processErrorsPlugin: () => processErrorsPlugin,
+  winstonPlugin: () => import_clockwork_log_interceptor2.winstonPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+var contextPlugin = {
+  name: "context",
+  install(ctx) {
+    const storage = new import_node_async_hooks.AsyncLocalStorage();
+    const getRequestId = () => storage.getStore()?.requestId;
+    const contextRunner = (requestId, next) => {
+      storage.run({ requestId }, next);
+    };
+    ctx.registerContext(getRequestId, contextRunner);
+    return () => {
+    };
+  }
+};
+
+// src/console.ts
+var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug"];
+function formatArgs(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    try {
+      return typeof a === "object" && a !== null ? JSON.stringify(a) : String(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+function patchConsole(core, getRequestId) {
+  const original = {};
+  for (const method of CONSOLE_METHODS) {
+    const orig = console[method];
+    if (typeof orig === "function") {
+      original[method] = orig.bind(console);
+    }
+  }
+  const levelMap = {
+    log: "info",
+    info: "info",
+    warn: "warning",
+    error: "error",
+    debug: "debug"
+  };
+  for (const method of CONSOLE_METHODS) {
+    const orig = original[method];
+    if (typeof orig !== "function") continue;
+    console[method] = function(...args) {
+      const requestId = getRequestId();
+      if (requestId) {
+        const message = formatArgs(args);
+        const level = levelMap[method];
+        core.captureNativeLog(requestId, level, message, void 0);
+      }
+      return orig.apply(console, args);
+    };
+  }
+  return function restore() {
+    for (const method of CONSOLE_METHODS) {
+      if (original[method]) {
+        console[method] = original[method];
+      }
+    }
+  };
+}
+var consolePlugin = {
+  name: "console",
+  install(ctx) {
+    return patchConsole(ctx.core, ctx.getRequestId);
+  }
+};
+
+// src/process-errors.ts
+function patchProcessErrors(core, getRequestId) {
+  const onUncaught = (err) => {
+    const requestId = getRequestId();
+    core.captureError(err, requestId);
+  };
+  const onRejection = (reason) => {
+    const requestId = getRequestId();
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    core.captureError(err, requestId);
+  };
+  process.on("uncaughtException", onUncaught);
+  process.on("unhandledRejection", onRejection);
+  return function restore() {
+    process.off("uncaughtException", onUncaught);
+    process.off("unhandledRejection", onRejection);
+  };
+}
+var processErrorsPlugin = {
+  name: "processErrors",
+  install(ctx) {
+    return patchProcessErrors(ctx.core, ctx.getRequestId);
+  }
+};
+
+// src/index.ts
+var import_clockwork_log_interceptor = require("@adjedaini/clockwork-log-interceptor");
+var import_clockwork_db_interceptor = require("@adjedaini/clockwork-db-interceptor");
+var import_clockwork_log_interceptor2 = require("@adjedaini/clockwork-log-interceptor");
+var import_clockwork_db_interceptor2 = require("@adjedaini/clockwork-db-interceptor");
+var defaultCorePlugins = [
+  contextPlugin,
+  consolePlugin,
+  processErrorsPlugin
+];
+function getDefaultPlugins(options) {
+  const {
+    console: enableConsole = true,
+    errors: enableErrors = true,
+    logPlugins: enableLogPlugins = false,
+    db: enableDb = false,
+    dbPlugins = []
+  } = options;
+  const list = [contextPlugin];
+  if (enableConsole) list.push(consolePlugin);
+  if (enableErrors) list.push(processErrorsPlugin);
+  if (enableLogPlugins) list.push(...import_clockwork_log_interceptor.defaultLogPlugins);
+  if (enableDb && dbPlugins.length === 0) list.push(...import_clockwork_db_interceptor.defaultDbPlugins);
+  else if (dbPlugins.length > 0) list.push(...dbPlugins);
+  return list;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  consolePlugin,
+  contextPlugin,
+  defaultCorePlugins,
+  defaultDbPlugins,
+  defaultLogPlugins,
+  getDefaultPlugins,
+  mysql2Plugin,
+  pgPlugin,
+  pinoPlugin,
+  processErrorsPlugin,
+  winstonPlugin
+});

package/node_modules/@adjedaini/clockwork-plugins/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@adjedaini/clockwork-plugins",
+  "version": "0.0.1",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": { "build": "tsup" },
+  "dependencies": {
+    "@adjedaini/clockwork-core": "*",
+    "@adjedaini/clockwork-shared": "*",
+    "@adjedaini/clockwork-transport-http": "*",
+    "@adjedaini/clockwork-db-interceptor": "*",
+    "@adjedaini/clockwork-log-interceptor": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/node_modules/@adjedaini/clockwork-plugins/src/console.ts

@@ -0,0 +1,70 @@
+/**
+ * Console plugin: intercepts console.* (native log) and attaches to current request.
+ */
+
+import type { MonitorCore } from '@adjedaini/clockwork-core';
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+
+const CONSOLE_METHODS = ['log', 'info', 'warn', 'error', 'debug'] as const;
+type ConsoleMethod = (typeof CONSOLE_METHODS)[number];
+
+function formatArgs(args: unknown[]): string {
+  return args
+    .map((a) => {
+      if (typeof a === 'string') return a;
+      try {
+        return typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a);
+      } catch {
+        return String(a);
+      }
+    })
+    .join(' ');
+}
+
+function patchConsole(core: MonitorCore, getRequestId: () => string | undefined): () => void {
+  const original: Partial<Record<ConsoleMethod, (...args: unknown[]) => void>> = {};
+  for (const method of CONSOLE_METHODS) {
+    const orig = console[method];
+    if (typeof orig === 'function') {
+      original[method] = orig.bind(console);
+    }
+  }
+
+  const levelMap: Record<ConsoleMethod, 'debug' | 'info' | 'warning' | 'error'> = {
+    log: 'info',
+    info: 'info',
+    warn: 'warning',
+    error: 'error',
+    debug: 'debug',
+  };
+
+  for (const method of CONSOLE_METHODS) {
+    const orig = original[method];
+    if (typeof orig !== 'function') continue;
+
+    (console as unknown as Record<string, (...args: unknown[]) => void>)[method] = function (...args: unknown[]) {
+      const requestId = getRequestId();
+      if (requestId) {
+        const message = formatArgs(args);
+        const level = levelMap[method];
+        core.captureNativeLog(requestId, level, message, undefined);
+      }
+      return orig.apply(console, args);
+    };
+  }
+
+  return function restore() {
+    for (const method of CONSOLE_METHODS) {
+      if (original[method]) {
+        (console as unknown as Record<string, (...args: unknown[]) => void>)[method] = original[method]!;
+      }
+    }
+  };
+}
+
+export const consolePlugin: ClockworkPlugin = {
+  name: 'console',
+  install(ctx: IPluginContext): () => void {
+    return patchConsole(ctx.core, ctx.getRequestId);
+  },
+};

package/node_modules/@adjedaini/clockwork-plugins/src/context.ts

@@ -0,0 +1,30 @@
+/**
+ * Context plugin: provides AsyncLocalStorage and request-scoped getRequestId.
+ * Must be installed first so other plugins receive a working getRequestId.
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+import type { ClockworkContext } from '@adjedaini/clockwork-shared';
+import type { NextLike } from '@adjedaini/clockwork-transport-http';
+
+/** Extended context that allows the context plugin to register getRequestId and runner. */
+export interface ContextPluginContext extends IPluginContext {
+  registerContext(
+    getRequestId: () => string | undefined,
+    contextRunner: (requestId: string, next: NextLike) => void
+  ): void;
+}
+
+export const contextPlugin: ClockworkPlugin = {
+  name: 'context',
+  install(ctx: ContextPluginContext): () => void {
+    const storage = new AsyncLocalStorage<ClockworkContext>();
+    const getRequestId = (): string | undefined => storage.getStore()?.requestId;
+    const contextRunner = (requestId: string, next: NextLike): void => {
+      storage.run({ requestId }, next);
+    };
+    ctx.registerContext(getRequestId, contextRunner);
+    return () => {};
+  },
+};

package/node_modules/@adjedaini/clockwork-plugins/src/index.ts

@@ -0,0 +1,50 @@
+/**
+ * @adjedaini/clockwork-plugins
+ * Built-in plugins (context, console, process-errors) and default plugin composition.
+ */
+
+import type { ClockworkPlugin } from '@adjedaini/clockwork-core';
+import { contextPlugin } from './context';
+import { consolePlugin } from './console';
+import { processErrorsPlugin } from './process-errors';
+import { defaultLogPlugins } from '@adjedaini/clockwork-log-interceptor';
+import { defaultDbPlugins } from '@adjedaini/clockwork-db-interceptor';
+
+export type { ContextPluginContext } from './context';
+
+export { contextPlugin, consolePlugin, processErrorsPlugin };
+export { pinoPlugin, winstonPlugin, defaultLogPlugins } from '@adjedaini/clockwork-log-interceptor';
+export { pgPlugin, mysql2Plugin, defaultDbPlugins } from '@adjedaini/clockwork-db-interceptor';
+
+/** Context + console + processErrors. Context must be first. */
+export const defaultCorePlugins: ClockworkPlugin[] = [
+  contextPlugin,
+  consolePlugin,
+  processErrorsPlugin,
+];
+
+/** Build default plugin list from options. */
+export function getDefaultPlugins(options: {
+  console?: boolean;
+  errors?: boolean;
+  logPlugins?: boolean;
+  db?: boolean;
+  dbPlugins?: ClockworkPlugin[];
+}): ClockworkPlugin[] {
+  const {
+    console: enableConsole = true,
+    errors: enableErrors = true,
+    logPlugins: enableLogPlugins = false,
+    db: enableDb = false,
+    dbPlugins = [],
+  } = options;
+
+  const list: ClockworkPlugin[] = [contextPlugin];
+  if (enableConsole) list.push(consolePlugin);
+  if (enableErrors) list.push(processErrorsPlugin);
+  if (enableLogPlugins) list.push(...defaultLogPlugins);
+  if (enableDb && dbPlugins.length === 0) list.push(...defaultDbPlugins);
+  else if (dbPlugins.length > 0) list.push(...dbPlugins);
+
+  return list;
+}

package/node_modules/@adjedaini/clockwork-plugins/src/process-errors.ts

@@ -0,0 +1,33 @@
+/**
+ * Process errors plugin: captures uncaughtException and unhandledRejection.
+ */
+
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+
+function patchProcessErrors(core: IPluginContext['core'], getRequestId: () => string | undefined): () => void {
+  const onUncaught = (err: Error) => {
+    const requestId = getRequestId();
+    core.captureError(err, requestId);
+  };
+
+  const onRejection = (reason: unknown) => {
+    const requestId = getRequestId();
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    core.captureError(err, requestId);
+  };
+
+  process.on('uncaughtException', onUncaught);
+  process.on('unhandledRejection', onRejection);
+
+  return function restore() {
+    process.off('uncaughtException', onUncaught);
+    process.off('unhandledRejection', onRejection);
+  };
+}
+
+export const processErrorsPlugin: ClockworkPlugin = {
+  name: 'processErrors',
+  install(ctx: IPluginContext): () => void {
+    return patchProcessErrors(ctx.core, ctx.getRequestId);
+  },
+};

package/node_modules/@adjedaini/clockwork-plugins/tsconfig.build.json

@@ -0,0 +1 @@
+{"extends": "./tsconfig.json", "compilerOptions": {"composite": false}}

package/node_modules/@adjedaini/clockwork-plugins/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../shared" },
+    { "path": "../transport-http" },
+    { "path": "../db-interceptor" },
+    { "path": "../log-interceptor" }
+  ]
+}

package/node_modules/@adjedaini/clockwork-plugins/tsup.config.ts

@@ -0,0 +1,13 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { defineConfig } from 'tsup';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs'],
+  dts: true,
+  outDir: 'dist',
+  tsconfig: path.join(__dirname, 'tsconfig.build.json'),
+});

package/node_modules/@adjedaini/clockwork-shared/dist/index.d.ts

@@ -0,0 +1,97 @@
+/** Shared types for @adjedaini/clockwork-node. Framework-agnostic. */
+/** Per-request context (AsyncLocalStorage). Used to correlate logs/queries to the current request. */
+interface ClockworkContext {
+    requestId: string;
+}
+interface LogData {
+    level: 'debug' | 'info' | 'warning' | 'error';
+    message: string;
+    context?: Record<string, unknown>;
+    time: number;
+    source?: 'native' | 'clockwork';
+}
+interface QueryData {
+    query: string;
+    bindings?: unknown[];
+    duration?: number;
+    connection?: string;
+}
+interface EventData {
+    name: string;
+    description?: string;
+    duration?: number;
+    start?: number;
+    end?: number;
+    data?: Record<string, unknown>;
+    color?: string;
+}
+interface RequestSnapshot {
+    id: string;
+    type: 'http';
+    method: string;
+    uri: string;
+    headers: Record<string, unknown>;
+    getData: Record<string, unknown>;
+    postData?: unknown;
+    responseData?: unknown;
+    cookies?: Record<string, unknown>;
+    responseStatus: number;
+    responseTime: number;
+    responseDuration: number;
+    memoryUsage: number;
+    time: number;
+    log: LogData[];
+    databaseQueries: QueryData[];
+    timelineData: EventData[];
+    controller?: string;
+}
+interface RequestMetadata {
+    id: string;
+    method: string;
+    uri: string;
+    controller?: string;
+    responseStatus: number;
+    responseDuration: number;
+    time: number;
+}
+interface MetricsSpan {
+    interval: number;
+    retention: number;
+    responseTime: number[];
+    rps: number[];
+    statusCodes?: Record<string, number>[];
+}
+interface Snapshot {
+    requests: RequestMetadata[];
+    metrics?: {
+        spans: MetricsSpan[];
+        timestamp: number;
+        os?: {
+            cpu: number;
+            memory: number;
+            heapUsed: number;
+            heapTotal: number;
+            rss: number;
+        };
+        process?: {
+            uptime: number;
+            eventLoopDelay?: number;
+        };
+    };
+}
+/** Storage backend for request snapshots. Implement for Redis, SQLite, file, etc. */
+interface IRequestStorage {
+    push(id: string, request: RequestSnapshot): void;
+    get(id: string): RequestSnapshot | undefined;
+    getAll(limit: number): RequestSnapshot[];
+    getLatest(): RequestSnapshot | undefined;
+}
+interface CoreConfig {
+    maxRequests?: number;
+    maxBodyDepth?: number;
+    maxBodySize?: number;
+    /** Custom storage backend. Default: in-memory ring buffer. */
+    storage?: IRequestStorage;
+}
+
+export type { ClockworkContext, CoreConfig, EventData, IRequestStorage, LogData, MetricsSpan, QueryData, RequestMetadata, RequestSnapshot, Snapshot };

package/node_modules/@adjedaini/clockwork-shared/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);