@interfere/elysia 0.1.0-canary.1

package/README.md

@@ -0,0 +1,92 @@
+# @interfere/elysia
+
+Elysia plugin for [Interfere](https://interfere.com). Creates a span for every request and reports server-fault errors (5xx and uncaught throws) with request context.
+
+## Install
+
+```sh
+bun add @interfere/elysia
+# or
+npm install @interfere/elysia
+# or
+pnpm add @interfere/elysia
+```
+
+`elysia` and `@elysia/opentelemetry` are peer dependencies:
+
+```sh
+bun add elysia @elysia/opentelemetry
+```
+
+## Setup
+
+Register the plugin once at the root of your app:
+
+```ts
+import { Elysia } from "elysia";
+import { interfere } from "@interfere/elysia";
+
+new Elysia()
+  .use(interfere({ serviceName: "checkout-api" }))
+  .get("/", () => "ok")
+  .listen(3000);
+```
+
+That's it. The plugin exports per-request spans to Interfere, reports 5xx and uncaught errors with request context, and installs process-level handlers for uncaught exceptions and unhandled rejections. Client faults (validation, not-found) still produce spans but are not reported as errors.
+
+When `INTERFERE_PUBLIC_KEY` is unset the plugin is inert, so local runs without the SDK configured don't crash.
+
+## Manual instrumentation
+
+```ts
+import { record, captureError, withSpan } from "@interfere/elysia";
+
+app.get("/users", () =>
+  record("db.query", () => db.query("SELECT * FROM users"))
+);
+```
+
+- `record(name, fn)` — wrap work in a child span that auto-closes and captures exceptions.
+- `withSpan(name, fn)` — same, framework-agnostic.
+- `captureError(error, request?)` / `captureMessage(message, request?)` — report an error from anywhere.
+- `getCurrentSpan()` / `setAttributes(attrs)` — annotate the active span.
+
+## Build & Deploy
+
+Install [`@interfere/cli`](../cli) as a dev dependency and add a `postbuild` script so source maps are uploaded and the release is registered. Without this step, the collector rejects spans from production deployments.
+
+```json
+{
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "interfere sourcemaps upload ./dist"
+  }
+}
+```
+
+The CLI derives the release slug from the same commit SHA the SDK uses at runtime (`INTERFERE_SOURCE_ID`, `GITHUB_SHA`, `VERCEL_GIT_COMMIT_SHA`, or `git rev-parse HEAD`). Both must see the same SHA for the slugs to match.
+
+## Environment Variables
+
+| Variable | Where | Purpose |
+|---|---|---|
+| `INTERFERE_PUBLIC_KEY` | Runtime | Routes spans to your surface (`interfere_pub_us_*` or `interfere_pub_eu_*`) |
+| `INTERFERE_API_KEY` | CI / Build | Authenticates source map uploads and release registration (`interfere_secret_us_*` or `interfere_secret_eu_*`) |
+| `INTERFERE_SOURCE_ID` | Both | Override the commit SHA used to derive the release slug. |
+| `INTERFERE_DEBUG` | Runtime | Set to `1` to log lifecycle events and exporter results. Equivalent to `debug: true`. |
+
+## Options
+
+| Option | Default | Purpose |
+|---|---|---|
+| `serviceName` | `OTEL_SERVICE_NAME` ?? `"elysia-app"` | The identity spans are grouped by. |
+| `serviceNamespace` | — | Groups several services under one product surface. |
+| `environment` | `INTERFERE_ENVIRONMENT` ?? `VERCEL_ENV` ?? `NODE_ENV` ?? `development` | Deployment environment label. |
+| `captureUncaughtException` | `true` | Report and exit on `uncaughtException`. |
+| `captureUnhandledRejection` | `true` | Report on `unhandledRejection`. |
+| `debug` | `false` | Log lifecycle and exporter results to stdout. |
+
+## Compatibility
+
+- Elysia 1.4+
+- Bun and Node.js

package/dist/cors.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_trace_headers=require("./trace-headers.cjs");let _elysia_cors=require("@elysia/cors");function interfereCors(config={}){let{allowedHeaders}=config;return typeof allowedHeaders==`string`||Array.isArray(allowedHeaders)?(0,_elysia_cors.cors)({...config,allowedHeaders:withTraceHeaders(allowedHeaders)}):(0,_elysia_cors.cors)(config)}function withTraceHeaders(allowedHeaders){let existing=Array.isArray(allowedHeaders)?allowedHeaders:allowedHeaders.split(`,`).map(header=>header.trim()).filter(Boolean),seen=new Set(existing.map(header=>header.toLowerCase()));return[...existing,...require_trace_headers.INTERFERE_TRACE_HEADERS.filter(header=>!seen.has(header))]}exports.interfereCors=interfereCors;

package/dist/cors.d.cts

@@ -0,0 +1,23 @@
+import { CORSConfig, cors } from "@elysia/cors";
+
+//#region src/cors.d.ts
+/**
+ * Drop-in for `@elysia/cors`'s `cors()` that also permits the W3C
+ * `traceparent` / `tracestate` / `baggage` request headers, so a
+ * different-origin frontend's traces link to this server. Pass your normal
+ * CORS options — origins, methods, credentials — exactly as you would to
+ * `cors()`.
+ *
+ * ```ts
+ * import { interfereCors } from "@interfere/elysia/cors";
+ *
+ * new Elysia().use(interfereCors({ origin: "https://app.example.com" }));
+ * ```
+ *
+ * Only an *explicit* `allowedHeaders` allowlist (string or array) is extended;
+ * the permissive default (`true`) already reflects the trace headers, so it's
+ * passed through untouched — this never tightens your CORS policy.
+ */
+declare function interfereCors(config?: CORSConfig): ReturnType<typeof cors>;
+//#endregion
+export { interfereCors };

package/dist/cors.d.mts

@@ -0,0 +1,23 @@
+import { CORSConfig, cors } from "@elysia/cors";
+
+//#region src/cors.d.ts
+/**
+ * Drop-in for `@elysia/cors`'s `cors()` that also permits the W3C
+ * `traceparent` / `tracestate` / `baggage` request headers, so a
+ * different-origin frontend's traces link to this server. Pass your normal
+ * CORS options — origins, methods, credentials — exactly as you would to
+ * `cors()`.
+ *
+ * ```ts
+ * import { interfereCors } from "@interfere/elysia/cors";
+ *
+ * new Elysia().use(interfereCors({ origin: "https://app.example.com" }));
+ * ```
+ *
+ * Only an *explicit* `allowedHeaders` allowlist (string or array) is extended;
+ * the permissive default (`true`) already reflects the trace headers, so it's
+ * passed through untouched — this never tightens your CORS policy.
+ */
+declare function interfereCors(config?: CORSConfig): ReturnType<typeof cors>;
+//#endregion
+export { interfereCors };

package/dist/cors.mjs

@@ -0,0 +1 @@
+import{INTERFERE_TRACE_HEADERS}from"./trace-headers.mjs";import{cors}from"@elysia/cors";function interfereCors(config={}){let{allowedHeaders}=config;return cors(typeof allowedHeaders==`string`||Array.isArray(allowedHeaders)?{...config,allowedHeaders:withTraceHeaders(allowedHeaders)}:config)}function withTraceHeaders(allowedHeaders){let existing=Array.isArray(allowedHeaders)?allowedHeaders:allowedHeaders.split(`,`).map(header=>header.trim()).filter(Boolean),seen=new Set(existing.map(header=>header.toLowerCase()));return[...existing,...INTERFERE_TRACE_HEADERS.filter(header=>!seen.has(header))]}export{interfereCors};

package/dist/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_trace_headers=require("./trace-headers.cjs"),require_internal_server_fault=require("./internal/server-fault.cjs"),require_version=require("./version.cjs");let _interfere_node=require("@interfere/node"),_interfere_node_otel_config=require("@interfere/node/otel-config"),_elysia_opentelemetry=require("@elysia/opentelemetry"),_opentelemetry_api=require("@opentelemetry/api"),elysia=require("elysia");const PLUGIN_NAME=`@interfere/elysia`;function interfere(options={}){let debug=options.debug??process.env.INTERFERE_DEBUG===`1`,serviceName=options.serviceName??process.env.OTEL_SERVICE_NAME??`elysia-app`,config=(0,_interfere_node_otel_config.resolveOtelConfig)({serviceName,serviceNamespace:options.serviceNamespace,environment:options.environment,sdkName:PLUGIN_NAME,producerVersion:require_version.PRODUCER_VERSION,debug});if(!config)return console.warn(`[interfere] INTERFERE_PUBLIC_KEY not set; SDK disabled`),new elysia.Elysia({name:PLUGIN_NAME});config.releaseSlug||console.warn(`[interfere] No release slug resolved — the collector will reject spans. Add a postbuild script to your package.json:
+  "postbuild": "interfere sourcemaps upload ./dist"
+and set INTERFERE_API_KEY in your CI environment. See https://interfere.com/docs/elysia#releases`);let flush=async()=>{await Promise.all(config.spanProcessors.map(p=>p.forceFlush()))};return(0,_interfere_node_otel_config.installGlobalHandlers)({captureUncaughtException:options.captureUncaughtException??!0,captureUnhandledRejection:options.captureUnhandledRejection??!0,flush}),debug&&(console.log(`[interfere] init: service=${serviceName}, env=${config.environment}, endpoint=${config.endpoint}`),config.releaseSlug&&console.log(`[interfere] release.slug=${config.releaseSlug}`)),new elysia.Elysia({name:PLUGIN_NAME,seed:options}).use((0,_elysia_opentelemetry.opentelemetry)({resource:config.resource,spanProcessors:config.spanProcessors})).onError({as:`global`},function({error,code,request,set}){require_internal_server_fault.isServerFault(code,set.status)&&(_opentelemetry_api.trace.getActiveSpan()?.setStatus({code:_opentelemetry_api.SpanStatusCode.ERROR}),(0,_interfere_node.captureError)(error,request))}).onStop(async function(){(0,_interfere_node_otel_config.uninstallGlobalHandlers)(),await flush()})}exports.INTERFERE_TRACE_HEADERS=require_trace_headers.INTERFERE_TRACE_HEADERS,Object.defineProperty(exports,"captureError",{enumerable:!0,get:function(){return _interfere_node.captureError}}),Object.defineProperty(exports,"captureMessage",{enumerable:!0,get:function(){return _interfere_node.captureMessage}}),Object.defineProperty(exports,"getCurrentSpan",{enumerable:!0,get:function(){return _elysia_opentelemetry.getCurrentSpan}}),exports.interfere=interfere,Object.defineProperty(exports,"record",{enumerable:!0,get:function(){return _elysia_opentelemetry.record}}),Object.defineProperty(exports,"setAttributes",{enumerable:!0,get:function(){return _elysia_opentelemetry.setAttributes}}),Object.defineProperty(exports,"withSpan",{enumerable:!0,get:function(){return _interfere_node.withSpan}});

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+import { INTERFERE_TRACE_HEADERS } from "./trace-headers.cjs";
+import { Elysia } from "elysia";
+import { CaptureErrorContext, captureError, captureMessage, withSpan } from "@interfere/node";
+import { getCurrentSpan, record, setAttributes } from "@elysia/opentelemetry";
+
+//#region src/index.d.ts
+interface InterfereOptions {
+  /**
+   * Install a `process.on("uncaughtException")` listener that captures the
+   * error, flushes spans, and exits the process. Default `true`. Disable to
+   * use your own handler.
+   */
+  readonly captureUncaughtException?: boolean;
+  /**
+   * Install a `process.on("unhandledRejection")` listener that captures the
+   * rejection and flushes spans. Default `true`. Disable to use your own
+   * handler.
+   */
+  readonly captureUnhandledRejection?: boolean;
+  /**
+   * Log lifecycle events and exporter results to `stdout`. Also activatable
+   * via `INTERFERE_DEBUG=1`. Default `false`.
+   */
+  readonly debug?: boolean;
+  /**
+   * Deployment environment label (e.g. `production`, `staging`, `preview`).
+   * Falls back to `INTERFERE_ENVIRONMENT`, then `VERCEL_ENV`, then `NODE_ENV`,
+   * then `development`.
+   */
+  readonly environment?: string;
+  /**
+   * Sets the OTel `service.name` resource attribute — the identity spans are
+   * grouped by in the dashboard. Defaults to `OTEL_SERVICE_NAME`, then
+   * `"elysia-app"`.
+   */
+  readonly serviceName?: string;
+  /**
+   * Sets the OTel `service.namespace` resource attribute. Optional; groups
+   * several services under one logical product surface.
+   */
+  readonly serviceNamespace?: string;
+}
+/**
+ * Elysia plugin that instruments your server for Interfere: it stands up an
+ * OpenTelemetry tracer that exports per-request spans to the Interfere
+ * collector, and reports server-fault errors (5xx and uncaught throws) with
+ * request context. Client faults (validation, not-found) still produce spans
+ * but are not reported as errors.
+ *
+ * Register once at the root of your app:
+ *
+ * ```ts
+ * new Elysia().use(interfere({ serviceName: "checkout-api" })).listen(3000);
+ * ```
+ *
+ * No-ops when `INTERFERE_PUBLIC_KEY` is unset so local runs without the SDK
+ * configured don't crash.
+ */
+declare function interfere(options?: InterfereOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+//#endregion
+export { type CaptureErrorContext, INTERFERE_TRACE_HEADERS, InterfereOptions, captureError, captureMessage, getCurrentSpan, interfere, record, setAttributes, withSpan };

package/dist/index.d.mts

@@ -0,0 +1,88 @@
+import { INTERFERE_TRACE_HEADERS } from "./trace-headers.mjs";
+import { CaptureErrorContext, captureError, captureMessage, withSpan } from "@interfere/node";
+import { getCurrentSpan, record, setAttributes } from "@elysia/opentelemetry";
+import { Elysia } from "elysia";
+
+//#region src/index.d.ts
+interface InterfereOptions {
+  /**
+   * Install a `process.on("uncaughtException")` listener that captures the
+   * error, flushes spans, and exits the process. Default `true`. Disable to
+   * use your own handler.
+   */
+  readonly captureUncaughtException?: boolean;
+  /**
+   * Install a `process.on("unhandledRejection")` listener that captures the
+   * rejection and flushes spans. Default `true`. Disable to use your own
+   * handler.
+   */
+  readonly captureUnhandledRejection?: boolean;
+  /**
+   * Log lifecycle events and exporter results to `stdout`. Also activatable
+   * via `INTERFERE_DEBUG=1`. Default `false`.
+   */
+  readonly debug?: boolean;
+  /**
+   * Deployment environment label (e.g. `production`, `staging`, `preview`).
+   * Falls back to `INTERFERE_ENVIRONMENT`, then `VERCEL_ENV`, then `NODE_ENV`,
+   * then `development`.
+   */
+  readonly environment?: string;
+  /**
+   * Sets the OTel `service.name` resource attribute — the identity spans are
+   * grouped by in the dashboard. Defaults to `OTEL_SERVICE_NAME`, then
+   * `"elysia-app"`.
+   */
+  readonly serviceName?: string;
+  /**
+   * Sets the OTel `service.namespace` resource attribute. Optional; groups
+   * several services under one logical product surface.
+   */
+  readonly serviceNamespace?: string;
+}
+/**
+ * Elysia plugin that instruments your server for Interfere: it stands up an
+ * OpenTelemetry tracer that exports per-request spans to the Interfere
+ * collector, and reports server-fault errors (5xx and uncaught throws) with
+ * request context. Client faults (validation, not-found) still produce spans
+ * but are not reported as errors.
+ *
+ * Register once at the root of your app:
+ *
+ * ```ts
+ * new Elysia().use(interfere({ serviceName: "checkout-api" })).listen(3000);
+ * ```
+ *
+ * No-ops when `INTERFERE_PUBLIC_KEY` is unset so local runs without the SDK
+ * configured don't crash.
+ */
+declare function interfere(options?: InterfereOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+//#endregion
+export { type CaptureErrorContext, INTERFERE_TRACE_HEADERS, InterfereOptions, captureError, captureMessage, getCurrentSpan, interfere, record, setAttributes, withSpan };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import{INTERFERE_TRACE_HEADERS}from"./trace-headers.mjs";import{isServerFault}from"./internal/server-fault.mjs";import{PRODUCER_VERSION}from"./version.mjs";import{captureError,captureError as captureError$1,captureMessage,withSpan}from"@interfere/node";import{installGlobalHandlers,resolveOtelConfig,uninstallGlobalHandlers}from"@interfere/node/otel-config";import{getCurrentSpan,opentelemetry,record,setAttributes}from"@elysia/opentelemetry";import{SpanStatusCode,trace}from"@opentelemetry/api";import{Elysia}from"elysia";const PLUGIN_NAME=`@interfere/elysia`;function interfere(options={}){let debug=options.debug??process.env.INTERFERE_DEBUG===`1`,serviceName=options.serviceName??process.env.OTEL_SERVICE_NAME??`elysia-app`,config=resolveOtelConfig({serviceName,serviceNamespace:options.serviceNamespace,environment:options.environment,sdkName:PLUGIN_NAME,producerVersion:PRODUCER_VERSION,debug});if(!config)return console.warn(`[interfere] INTERFERE_PUBLIC_KEY not set; SDK disabled`),new Elysia({name:PLUGIN_NAME});config.releaseSlug||console.warn(`[interfere] No release slug resolved — the collector will reject spans. Add a postbuild script to your package.json:
+  "postbuild": "interfere sourcemaps upload ./dist"
+and set INTERFERE_API_KEY in your CI environment. See https://interfere.com/docs/elysia#releases`);let flush=async()=>{await Promise.all(config.spanProcessors.map(p=>p.forceFlush()))};return installGlobalHandlers({captureUncaughtException:options.captureUncaughtException??!0,captureUnhandledRejection:options.captureUnhandledRejection??!0,flush}),debug&&(console.log(`[interfere] init: service=${serviceName}, env=${config.environment}, endpoint=${config.endpoint}`),config.releaseSlug&&console.log(`[interfere] release.slug=${config.releaseSlug}`)),new Elysia({name:PLUGIN_NAME,seed:options}).use(opentelemetry({resource:config.resource,spanProcessors:config.spanProcessors})).onError({as:`global`},function({error,code,request,set}){isServerFault(code,set.status)&&(trace.getActiveSpan()?.setStatus({code:SpanStatusCode.ERROR}),captureError$1(error,request))}).onStop(async function(){uninstallGlobalHandlers(),await flush()})}export{INTERFERE_TRACE_HEADERS,captureError,captureMessage,getCurrentSpan,interfere,record,setAttributes,withSpan};

package/dist/internal/server-fault.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const CLIENT_FAULT_CODES=new Set([`VALIDATION`,`NOT_FOUND`,`PARSE`,`INVALID_COOKIE_SIGNATURE`,`INVALID_FILE_TYPE`]);function isServerFault(code,status){if(typeof code==`string`&&CLIENT_FAULT_CODES.has(code))return!1;let resolved=resolveStatus(code,status);return typeof resolved==`number`?resolved>=500:!0}function resolveStatus(code,status){if(typeof status==`number`)return status;if(typeof code==`number`)return code}exports.isServerFault=isServerFault;

package/dist/internal/server-fault.d.cts

@@ -0,0 +1,9 @@
+//#region src/internal/server-fault.d.ts
+/**
+ * Decides whether an Elysia error represents a server fault worth reporting.
+ * Skips the framework's client-fault codes and any error whose response
+ * status is a 4xx; unknown throws with no status default to reportable.
+ */
+declare function isServerFault(code: string | number, status: number | string | undefined): boolean;
+//#endregion
+export { isServerFault };

package/dist/internal/server-fault.d.mts

@@ -0,0 +1,9 @@
+//#region src/internal/server-fault.d.ts
+/**
+ * Decides whether an Elysia error represents a server fault worth reporting.
+ * Skips the framework's client-fault codes and any error whose response
+ * status is a 4xx; unknown throws with no status default to reportable.
+ */
+declare function isServerFault(code: string | number, status: number | string | undefined): boolean;
+//#endregion
+export { isServerFault };

package/dist/internal/server-fault.mjs

@@ -0,0 +1 @@
+const CLIENT_FAULT_CODES=new Set([`VALIDATION`,`NOT_FOUND`,`PARSE`,`INVALID_COOKIE_SIGNATURE`,`INVALID_FILE_TYPE`]);function isServerFault(code,status){if(typeof code==`string`&&CLIENT_FAULT_CODES.has(code))return!1;let resolved=resolveStatus(code,status);return typeof resolved==`number`?resolved>=500:!0}function resolveStatus(code,status){if(typeof status==`number`)return status;if(typeof code==`number`)return code}export{isServerFault};

package/dist/package.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,"name",{enumerable:!0,get:function(){return`@interfere/elysia`}}),Object.defineProperty(exports,"version",{enumerable:!0,get:function(){return`0.1.0-canary.1`}});

package/dist/package.mjs

@@ -0,0 +1 @@
+var name=`@interfere/elysia`,version=`0.1.0-canary.1`;export{name,version};

package/dist/trace-headers.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const INTERFERE_TRACE_HEADERS=[`traceparent`,`tracestate`,`baggage`];exports.INTERFERE_TRACE_HEADERS=INTERFERE_TRACE_HEADERS;

package/dist/trace-headers.d.cts

@@ -0,0 +1,17 @@
+//#region src/trace-headers.d.ts
+/**
+ * W3C trace-context and baggage request headers the browser SDK injects on
+ * cross-origin requests. Spread these into your CORS `allowedHeaders` allowlist
+ * so preflight requests from a different-origin frontend are accepted and
+ * front-to-back traces stay linked:
+ *
+ * ```ts
+ * cors({ allowedHeaders: ["content-type", ...INTERFERE_TRACE_HEADERS] })
+ * ```
+ *
+ * Unnecessary when the frontend is same-origin, or when your CORS layer
+ * reflects requested headers (the `@elysia/cors` default).
+ */
+declare const INTERFERE_TRACE_HEADERS: readonly ["traceparent", "tracestate", "baggage"];
+//#endregion
+export { INTERFERE_TRACE_HEADERS };

package/dist/trace-headers.d.mts

@@ -0,0 +1,17 @@
+//#region src/trace-headers.d.ts
+/**
+ * W3C trace-context and baggage request headers the browser SDK injects on
+ * cross-origin requests. Spread these into your CORS `allowedHeaders` allowlist
+ * so preflight requests from a different-origin frontend are accepted and
+ * front-to-back traces stay linked:
+ *
+ * ```ts
+ * cors({ allowedHeaders: ["content-type", ...INTERFERE_TRACE_HEADERS] })
+ * ```
+ *
+ * Unnecessary when the frontend is same-origin, or when your CORS layer
+ * reflects requested headers (the `@elysia/cors` default).
+ */
+declare const INTERFERE_TRACE_HEADERS: readonly ["traceparent", "tracestate", "baggage"];
+//#endregion
+export { INTERFERE_TRACE_HEADERS };

package/dist/trace-headers.mjs

@@ -0,0 +1 @@
+const INTERFERE_TRACE_HEADERS=[`traceparent`,`tracestate`,`baggage`];export{INTERFERE_TRACE_HEADERS};

package/dist/version.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_package=require("./package.cjs"),PRODUCER_VERSION=`${require_package.name}@${require_package.version}`;exports.PRODUCER_VERSION=PRODUCER_VERSION;

package/dist/version.d.cts

@@ -0,0 +1,4 @@
+//#region src/version.d.ts
+declare const PRODUCER_VERSION: string;
+//#endregion
+export { PRODUCER_VERSION };

package/dist/version.d.mts

@@ -0,0 +1,4 @@
+//#region src/version.d.ts
+declare const PRODUCER_VERSION: string;
+//#endregion
+export { PRODUCER_VERSION };

package/dist/version.mjs

@@ -0,0 +1 @@
+import{name,version}from"./package.mjs";const PRODUCER_VERSION=`${name}@${version}`;export{PRODUCER_VERSION};

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@interfere/elysia",
+  "version": "0.1.0-canary.1",
+  "license": "MIT",
+  "description": "Elysia plugin for Interfere. Per-request OTel spans and error capture for any Elysia server.",
+  "keywords": [
+    "observability",
+    "typescript",
+    "elysia",
+    "bun",
+    "error-tracking",
+    "opentelemetry"
+  ],
+  "homepage": "https://interfere.com",
+  "bugs": {
+    "url": "mailto:support@interfere.com"
+  },
+  "author": "Interfere <support@interfere.com> (https://interfere.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://interfere.ghe.com/interfere/interfere.git",
+    "directory": "src/packages/public/elysia"
+  },
+  "files": [
+    "dist/**/*.cjs",
+    "dist/**/*.mjs",
+    "dist/**/*.d.cts",
+    "dist/**/*.d.mts",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "monorepo": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./cors": {
+      "monorepo": "./src/cors.ts",
+      "import": {
+        "types": "./dist/cors.d.mts",
+        "default": "./dist/cors.mjs"
+      },
+      "require": {
+        "types": "./dist/cors.d.cts",
+        "default": "./dist/cors.cjs"
+      }
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@interfere/node": "^0.1.0-canary.10",
+    "@opentelemetry/api": "^1.9.1"
+  },
+  "peerDependencies": {
+    "@elysia/cors": "^1.4.1",
+    "@elysia/opentelemetry": "^1.4.11",
+    "elysia": "^1.4.29"
+  },
+  "peerDependenciesMeta": {
+    "@elysia/cors": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@elysia/cors": "^1.4.1",
+    "@elysia/opentelemetry": "^1.4.11",
+    "@interfere/test-utils": "^9.0.1-canary.1",
+    "@interfere/typescript-config": "^9.0.1-canary.1",
+    "@types/node": "^26.1.0",
+    "@vitest/coverage-v8": "4.1.9",
+    "elysia": "^1.4.29",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.9"
+  }
+}