@interfere/server-core 0.0.0-stage → 0.1.1

package/dist/console-bridge.d.mts

@@ -0,0 +1,22 @@
+import { LoggerProvider, SeverityNumber } from "@opentelemetry/api-logs";
+/**
+ * Patches `console.{debug,log,info,warn,error}` to additionally emit OTel
+ * `LogRecord`s alongside the original output. Every log record carries
+ * the active span's context (so trace ↔ log correlation works in
+ * dashboards) and any `Error` arg gets unpacked into semconv exception
+ * attrs.
+ *
+ * Returns a disposer that restores the original `console.*` methods.
+ *
+ * Cycle protection: `emitting` guards against the bridge re-entering
+ * itself if a logger backend itself logs to console (which would
+ * recursively emit forever). Failures are bounded-rate logged via the
+ * original `console.error` so a broken backend doesn't drown the
+ * customer's logs in bridge-failure messages.
+ *
+ * Serialization is deferred to a microtask and bodies are capped at
+ * {@link MAX_BODY_CHARS} characters, so the synchronous `console.*`
+ * call only captures the active context; an arg mutated before the
+ * microtask runs is serialized in its mutated state.
+ */
+export declare function bridgeConsoleToOtel(provider?: LoggerProvider, minimumSeverity?: SeverityNumber, name?: string): () => void;

package/dist/console-bridge.mjs

@@ -0,0 +1 @@
+import{omitUndefined}from"@interfere/helpers/omit-undefined";import{context,trace}from"@opentelemetry/api";import{SeverityNumber,logs}from"@opentelemetry/api-logs";const CONSOLE_METHODS=[`debug`,`log`,`info`,`warn`,`error`],SEVERITY={debug:SeverityNumber.DEBUG,error:SeverityNumber.ERROR,info:SeverityNumber.INFO,log:SeverityNumber.INFO,warn:SeverityNumber.WARN},MAX_BODY_CHARS=8192;function buildBody(args){let body=args.map(element=>stringify(element)).join(` `);return body.length>MAX_BODY_CHARS?`${body.slice(0,MAX_BODY_CHARS)}…`:body}function stringify(value){if(typeof value==`string`)return value;if(value instanceof Error)return value.stack??`${value.name}: ${value.message}`;try{return JSON.stringify(value)}catch{return String(value)}}function extractException(args){for(let arg of args)if(arg instanceof Error)return arg}function buildExceptionAttributes(args){let exception=extractException(args);if(exception)return omitUndefined({"exception.type":exception.name,"exception.message":exception.message,"exception.stacktrace":exception.stack||void 0})}function bridgeConsoleToOtel(provider=logs,minimumSeverity=SeverityNumber.DEBUG,name=`@interfere/server/console`){let methods=CONSOLE_METHODS.filter(method=>SEVERITY[method]>=minimumSeverity),logger=provider.getLogger(name),emitting=!1,bridgeFailures=0,original={debug:console.debug,error:console.error,info:console.info,log:console.log,warn:console.warn};function emitLog(orig,severity,method,args,activeContext,activeSpan){if(!emitting){emitting=!0;try{let attributes=buildExceptionAttributes(args);logger.emit(omitUndefined({body:buildBody(args),severityNumber:severity,severityText:method.toUpperCase(),context:activeSpan?activeContext:void 0,attributes}))}catch(error){bridgeFailures+=1,bridgeFailures%100==1&&orig.call(console,`[interfere] console→OTel bridge emission failed (${bridgeFailures} total):`,error)}finally{emitting=!1}}}for(let method of methods){let orig=original[method],severity=SEVERITY[method];console[method]=(...args)=>{orig.apply(console,args);let activeContext=context.active(),activeSpan=trace.getSpan(activeContext);queueMicrotask(()=>{emitLog(orig,severity,method,args,activeContext,activeSpan)})}}return(()=>{for(let method of methods)console[method]=original[method]})}export{bridgeConsoleToOtel};

package/dist/contain.d.mts

@@ -0,0 +1,2 @@
+export declare function contain<T>(site: string, run: () => T): T | null;
+export declare function containAsync<T>(site: string, run: () => Promise<T>): Promise<T | null>;

package/dist/contain.mjs

@@ -0,0 +1 @@
+const reported=/* @__PURE__ */ new Set;function reportContainedFailure(site,error){if(!reported.has(site)){reported.add(site);try{console.warn(`[interfere] ${site} failed inside the Interfere SDK. Your app keeps running; Interfere skipped this step and may send less telemetry.`,error)}catch{return}}}function contain(site,run){try{return run()}catch(error){return reportContainedFailure(site,error),null}}async function containAsync(site,run){try{return await run()}catch(error){return reportContainedFailure(site,error),null}}export{contain,containAsync};

package/dist/contained-span-processor.d.mts

@@ -0,0 +1,8 @@
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export declare function containSpanProcessor(processor: SpanProcessor): {
+  forceFlush: () => Promise<void>;
+  onEnd: (span: import("@opentelemetry/sdk-trace-base").ReadableSpan) => void | null;
+  onEnding: (span: import("@opentelemetry/sdk-trace-base").Span) => void | null | undefined;
+  onStart: (span: import("@opentelemetry/sdk-trace-base").Span, parentContext: import("@opentelemetry/api").Context) => void | null;
+  shutdown: () => Promise<void>;
+};

package/dist/contained-span-processor.mjs

@@ -0,0 +1 @@
+import{contain}from"./contain.mjs";const SITE=`Span processor`;function containSpanProcessor(processor){return{forceFlush:async()=>processor.forceFlush(),onEnd:span=>contain(SITE,()=>processor.onEnd(span)),onEnding:span=>contain(SITE,()=>processor.onEnding?.(span)),onStart:(span,parentContext)=>contain(SITE,()=>processor.onStart(span,parentContext)),shutdown:async()=>processor.shutdown()}}export{containSpanProcessor};

package/dist/node.d.mts

@@ -0,0 +1,61 @@
+import { ServerPipeline } from "./runtime.mjs";
+import { Attributes, TextMapPropagator, TracerProvider } from "@opentelemetry/api";
+import { UrlRedactionOption } from "@interfere/types/sdk/url-redaction";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { IdGenerator, Sampler, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { TracingOwnership } from "@interfere/types/sdk/remote-config/tracing-ownership";
+export interface ServerOptions {
+  /** Forward console calls at or above the selected level. Defaults to debug. */
+  consoleBridge?: boolean | {
+    level?: "debug" | "info" | "warn" | "error";
+  };
+  /** Deliver exceptions through Interfere or the application provider. Defaults to Interfere. */
+  errors?: "interfere" | "host";
+  /** URL redaction policy applied before telemetry export. */
+  privacy?: {
+    urls?: UrlRedactionOption;
+  };
+  /** Adopt an existing application provider by default; otherwise manage one. */
+  tracing?: TracingOwnership | "auto";
+  /** OTLP compression. Defaults to none. */
+  compression?: "gzip" | "none";
+  _internalAdditionalSpanProcessors?: SpanProcessor[];
+  _internalAdditionalLogRecordProcessors?: LogRecordProcessor[];
+}
+export interface ManagedTracingInput {
+  resourceAttributes: Attributes;
+  spanProcessors: SpanProcessor[];
+  sampler: Sampler | undefined;
+}
+export interface NodeRuntimeInput {
+  name: string;
+  version: string;
+  apiUrl: string;
+  publicKey: string;
+  resourceAttributes: Attributes;
+  options: ServerOptions;
+  drain: boolean;
+  logDrain: boolean;
+  vercel: boolean;
+  propagator: TextMapPropagator;
+  idGenerator?: IdGenerator;
+  registerPlatform?: (input: ManagedTracingInput) => Promise<TracerProvider>;
+  instrument?: (provider: TracerProvider, resource: ReturnType<typeof resourceFromAttributes>, requests: boolean) => Pick<ServerPipeline, "flush" | "shutdown">;
+}
+/** Builds the owned server pipeline; framework hooks supply only platform registration and request instrumentation. */
+export declare function startNodeRuntime(input: NodeRuntimeInput): Promise<{
+  mode: "application" | "managed";
+  provider: TracerProvider;
+  isolated: boolean;
+  capture: {
+    errors: "host" | "interfere";
+    recordOnHostSpan: boolean;
+    urlRedaction: {
+      fragment: boolean;
+      redactsValue: (name: string) => boolean;
+    };
+  };
+  flush: () => Promise<void>;
+  shutdown: () => Promise<void>;
+}>;

package/dist/node.mjs

@@ -0,0 +1 @@
+import{bridgeConsoleToOtel}from"./console-bridge.mjs";import{containSpanProcessor}from"./contained-span-processor.mjs";import{EXISTING_PROPAGATOR_WARNING,EXISTING_PROVIDER_WARNING,registeredLoggerProvider,registeredTracerProvider,resolveTracingMode}from"./ownership.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{context,propagation,trace}from"@opentelemetry/api";import{SeverityNumber,logs}from"@opentelemetry/api-logs";import{drainUrl}from"@interfere/constants/api";import{correlationBaggageSpanProcessor}from"@interfere/types/sdk/correlation-span-processor";import{VERCEL_EXPORT_TIMEOUT_MS}from"@interfere/types/sdk/server-tracing";import{createUrlRedactionSpanProcessor,resolveUrlRedaction}from"@interfere/types/sdk/url-redaction";import{AsyncLocalStorageContextManager}from"@opentelemetry/context-async-hooks";import{getStringFromEnv}from"@opentelemetry/core";import{OTLPTraceExporter}from"@opentelemetry/exporter-trace-otlp-http";import{OTLPLogExporter}from"@opentelemetry/exporter-logs-otlp-http";import{CompressionAlgorithm}from"@opentelemetry/otlp-exporter-base";import{resourceFromAttributes}from"@opentelemetry/resources";import{BatchLogRecordProcessor,LoggerProvider as LoggerProvider$1}from"@opentelemetry/sdk-logs";import{AlwaysOnSampler,BasicTracerProvider,BatchSpanProcessor,ParentBasedSampler}from"@opentelemetry/sdk-trace-base";import{NodeTracerProvider}from"@opentelemetry/sdk-trace-node";function canFlush(provider){return`forceFlush`in provider&&typeof provider.forceFlush==`function`}async function startNodeRuntime(input){let{options,resourceAttributes}=input,mode=resolveTracingMode(options.tracing),existing=mode===`managed`?registeredTracerProvider():null,ownsTracing=mode===`managed`&&existing===null,drain=input.drain&&ownsTracing,resource=resourceFromAttributes(resourceAttributes),urlRedaction=resolveUrlRedaction(options.privacy?.urls),attemptTimeout=input.vercel?VERCEL_EXPORT_TIMEOUT_MS:65e3,batchTimeout=input.vercel?VERCEL_EXPORT_TIMEOUT_MS:7e4,flushTimeout=input.vercel?VERCEL_EXPORT_TIMEOUT_MS:75e3,headers={"x-interfere-producer-version":input.version},compression=options.compression===`gzip`?CompressionAlgorithm.GZIP:CompressionAlgorithm.NONE,spanProcessors=[containSpanProcessor(createUrlRedactionSpanProcessor(urlRedaction)),correlationBaggageSpanProcessor,...drain?[]:[new BatchSpanProcessor(new OTLPTraceExporter({headers,compression,timeoutMillis:attemptTimeout,url:drainUrl(input.apiUrl,`traces`,input.publicKey)}),{exportTimeoutMillis:batchTimeout})],...options._internalAdditionalSpanProcessors??[]],sampler=getStringFromEnv(`OTEL_TRACES_SAMPLER`)?void 0:new ParentBasedSampler({root:new AlwaysOnSampler}),provider,ownedProvider,loggerProvider,ownsPropagator=!1,contextManager,instrumentation,restoreConsole;async function shutdown(){restoreConsole?.(),await instrumentation?.shutdown(),ownedProvider&&registeredTracerProvider()===ownedProvider&&trace.disable(),ownsPropagator&&propagation.disable(),contextManager&&(context.disable(),contextManager.disable()),loggerProvider&&logs.getLoggerProvider()===loggerProvider&&logs.disable(),await Promise.all([ownedProvider?.shutdown(),loggerProvider?.shutdown()])}try{if(!ownsTracing)existing&&console.warn(EXISTING_PROVIDER_WARNING),ownedProvider=new BasicTracerProvider(omitUndefined({resource,idGenerator:input.idGenerator,sampler:new AlwaysOnSampler,spanProcessors})),provider=ownedProvider;else if(drain&&input.registerPlatform)provider=await input.registerPlatform({resourceAttributes,spanProcessors,sampler}),ownsPropagator=!1;else{let nodeProvider=new NodeTracerProvider(omitUndefined({resource,idGenerator:input.idGenerator,sampler,spanProcessors}));ownedProvider=nodeProvider,provider=nodeProvider,ownsPropagator=propagation.setGlobalPropagator(input.propagator),ownsPropagator||console.warn(EXISTING_PROPAGATOR_WARNING);let manager=new AsyncLocalStorageContextManager().enable();context.setGlobalContextManager(manager)?contextManager=manager:manager.disable(),nodeProvider.register({contextManager:null,propagator:null})}let hostLogger=!ownsTracing&&mode===`application`?registeredLoggerProvider():null,bridgeTarget=input.logDrain?logs:hostLogger??(loggerProvider=new LoggerProvider$1({resource,processors:[new BatchLogRecordProcessor({exportTimeoutMillis:batchTimeout,exporter:new OTLPLogExporter({headers,compression,timeoutMillis:attemptTimeout,url:drainUrl(input.apiUrl,`logs`,input.publicKey)})}),...options._internalAdditionalLogRecordProcessors??[]]}));if(ownsTracing&&loggerProvider&&logs.setGlobalLoggerProvider(loggerProvider),ownsTracing&&(instrumentation=input.instrument?.(provider,resource,ownsPropagator&&!drain)),!input.logDrain&&options.consoleBridge!==!1){let level=options.consoleBridge!==void 0&&options.consoleBridge!==!0?options.consoleBridge.level??`debug`:`debug`;restoreConsole=bridgeConsoleToOtel(bridgeTarget,{debug:SeverityNumber.DEBUG,info:SeverityNumber.INFO,warn:SeverityNumber.WARN,error:SeverityNumber.ERROR}[level],`${input.name}/console`)}return{mode,provider,isolated:!ownsTracing,capture:{errors:options.errors??`interfere`,recordOnHostSpan:mode===`application`,urlRedaction},flush:async()=>{await Promise.all([canFlush(provider)?provider.forceFlush({timeoutMillis:flushTimeout}):void 0,loggerProvider?.forceFlush({timeoutMillis:flushTimeout}),instrumentation?.flush()])},shutdown}}catch(error){throw await shutdown(),error}}export{startNodeRuntime};

package/dist/ownership.d.mts

@@ -0,0 +1,24 @@
+import { TracerProvider } from "@opentelemetry/api";
+import { LoggerProvider } from "@opentelemetry/api-logs";
+import { TracingOwnership } from "@interfere/types/sdk/remote-config/tracing-ownership";
+/** Logged once when managed `register()` finds a tracer provider another owner registered first. */
+export declare const EXISTING_PROVIDER_WARNING = "[interfere] Another OpenTelemetry tracer provider is already registered (for example by Sentry or @vercel/otel), so Interfere captures server errors through its own exporter and does not own request tracing. If that provider is yours, call register({ tracing: \"application\" }) and export its traces to Interfere over standard OTLP.";
+/** Logged once when managed `register()` owns the tracer provider but another owner registered the propagator first. */
+export declare const EXISTING_PROPAGATOR_WARNING = "[interfere] Another OpenTelemetry propagator already owns trace headers, so Interfere will not inject its own. If that propagator is yours, call register({ tracing: \"application\" }).";
+/** The tracer provider another owner registered globally, or `null` while the API still serves its no-op delegate. */
+export declare function registeredTracerProvider(): TracerProvider | null;
+/**
+ * The tracing owner for this process: the explicit `register({ tracing })`
+ * option, else auto, which adopts an already registered provider and
+ * otherwise manages tracing.
+ */
+export declare function resolveTracingMode(requested?: TracingOwnership | "auto"): "application" | "managed";
+/**
+ * The logger provider another owner registered globally, or `null` while the
+ * logs API still serves its proxy. The API exposes no public query for this.
+ *
+ * WARNING: `_getDelegate` is the proxy's internal marker; a registered
+ * provider is returned directly and has no such method. Re-check when
+ * `@opentelemetry/api-logs` changes its proxy shape.
+ */
+export declare function registeredLoggerProvider(): LoggerProvider | null;

package/dist/ownership.mjs

@@ -0,0 +1 @@
+import{ProxyTracerProvider,diag,trace}from"@opentelemetry/api";import{logs}from"@opentelemetry/api-logs";const EXISTING_PROVIDER_WARNING=`[interfere] Another OpenTelemetry tracer provider is already registered (for example by Sentry or @vercel/otel), so Interfere captures server errors through its own exporter and does not own request tracing. If that provider is yours, call register({ tracing: "application" }) and export its traces to Interfere over standard OTLP.`,EXISTING_PROPAGATOR_WARNING=`[interfere] Another OpenTelemetry propagator already owns trace headers, so Interfere will not inject its own. If that propagator is yours, call register({ tracing: "application" }).`,UNREGISTERED_TRACER_PROVIDER=new ProxyTracerProvider().getDelegate();function registeredTracerProvider(){let provider=trace.getTracerProvider(),delegate=provider instanceof ProxyTracerProvider?provider.getDelegate():provider;return delegate===UNREGISTERED_TRACER_PROVIDER?null:delegate}let adoptionLogged=!1;function resolveTracingMode(requested=`auto`){let mode;return mode=requested===`auto`?registeredTracerProvider()===null?`managed`:`application`:requested,requested===`auto`&&mode===`application`&&!adoptionLogged&&(adoptionLogged=!0,diag.debug(`[interfere] Adopting the application's registered OpenTelemetry tracer provider.`)),mode}function registeredLoggerProvider(){let provider=logs.getLoggerProvider();return`_getDelegate`in provider?null:provider}export{EXISTING_PROPAGATOR_WARNING,EXISTING_PROVIDER_WARNING,registeredLoggerProvider,registeredTracerProvider,resolveTracingMode};

package/dist/runtime.d.mts

@@ -0,0 +1,33 @@
+import { Attributes, TracerProvider } from "@opentelemetry/api";
+import { UrlRedactionPolicy } from "@interfere/types/sdk/url-redaction";
+import { NonErrorException } from "@interfere/types/sdk/errors";
+import { TracingOwnership } from "@interfere/types/sdk/remote-config/tracing-ownership";
+import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
+export interface CapturePolicy {
+  errors: "host" | "interfere";
+  recordOnHostSpan: boolean;
+  urlRedaction: UrlRedactionPolicy;
+}
+export interface ServerPipeline {
+  mode: TracingOwnership;
+  provider: TracerProvider;
+  isolated: boolean;
+  capture: CapturePolicy;
+  flush: () => Promise<void>;
+  shutdown: () => Promise<void>;
+}
+/** Owns one adapter's initialization, error delivery and provider lifetime. */
+export declare class ServerRuntime {
+  private readonly name;
+  private pending;
+  private pipeline;
+  private isolatedProvider;
+  private policy;
+  constructor(name: string);
+  get mode(): "application" | "managed";
+  register(start: () => Promise<ServerPipeline | null>): Promise<void>;
+  configureCapture(provider: TracerProvider, policy: CapturePolicy): void;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+  recordException(value: Error | NonErrorException, mechanism: ErrorMechanism, attributes?: Attributes): void;
+}

package/dist/runtime.mjs

@@ -0,0 +1 @@
+import{contain,containAsync}from"./contain.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{ROOT_CONTEXT,SpanKind,SpanStatusCode,isSpanContextValid,trace}from"@opentelemetry/api";import{createUrlRedactionSpanProcessor,resolveUrlRedaction}from"@interfere/types/sdk/url-redaction";import{isNonErrorException,toExceptions}from"@interfere/types/sdk/errors";import{EXCEPTION_DELIVERY,EXCEPTION_DELIVERY_ATTRIBUTE}from"@interfere/types/sdk/exception-delivery";import{exceptionSpanName}from"@interfere/types/sdk/throw-site";var ServerRuntime=class{name;pending=null;pipeline=null;isolatedProvider=null;policy={errors:`interfere`,recordOnHostSpan:!0,urlRedaction:resolveUrlRedaction()};constructor(name){this.name=name}get mode(){return this.pipeline?.mode??`managed`}async register(start){if(this.pending)return this.pending;if(!this.pipeline)return this.pending=(async()=>{await containAsync(`register()`,async()=>{let pipeline=await start();this.pipeline=pipeline,pipeline&&(this.policy=pipeline.capture,this.isolatedProvider=pipeline.isolated?pipeline.provider:null)}),this.pending=null})(),this.pending}configureCapture(provider,policy){this.isolatedProvider=provider,this.policy=policy}async flush(){await this.pending,await containAsync(`flush()`,async()=>this.pipeline?.flush())}async shutdown(){await this.pending;let{pipeline}=this;this.pipeline=null,this.isolatedProvider=null,await containAsync(`shutdown()`,async()=>pipeline?.shutdown())}recordException(value,mechanism,attributes={}){contain(`captureError()`,()=>{let attrs={...attributes,"interfere.exception.handled":mechanism.handled,"interfere.exception.mechanism":mechanism.type,"exception.type":isNonErrorException(value)?value.type:value.name,"exception.message":isNonErrorException(value)?value.value:value.message,"interfere.exception.kind":isNonErrorException(value)?`non-error`:`error`};if(isNonErrorException(value)){let serialized=value.serialized===void 0?`undefined`:JSON.stringify(value.serialized);attrs[`interfere.exception.serialized`]=typeof value.serialized==`string`?value.serialized:serialized}else attrs[`interfere.exception.chain`]=JSON.stringify(toExceptions(value,mechanism)),value.stack&&(attrs[`exception.stacktrace`]=value.stack);createUrlRedactionSpanProcessor(this.policy.urlRedaction).onEnd({attributes:{},events:[{name:`exception`,attributes:attrs}]});let host=trace.getActiveSpan(),active=this.isolatedProvider&&!this.policy.recordOnHostSpan?void 0:host,timestamp=Date.now(),separate=this.isolatedProvider!==null&&this.policy.errors===`interfere`;if(active?.isRecording()&&(active.addEvent(`exception`,separate?{...attrs,[EXCEPTION_DELIVERY_ATTRIBUTE]:EXCEPTION_DELIVERY.interfere}:attrs,timestamp),mechanism.handled||active.setStatus({code:SpanStatusCode.ERROR,message:String(attrs[`exception.message`])}),!separate))return;let tracer=(this.isolatedProvider??trace.getTracerProvider()).getTracer(this.name),parent=host?.spanContext(),span=tracer.startSpan(exceptionSpanName(value),omitUndefined({attributes:{"interfere.capture.kind":`exception`},kind:SpanKind.INTERNAL,links:this.isolatedProvider&&parent&&isSpanContextValid(parent)?[{context:parent}]:void 0}),this.isolatedProvider?ROOT_CONTEXT:void 0);span.addEvent(`exception`,attrs,timestamp),mechanism.handled||span.setStatus({code:SpanStatusCode.ERROR,message:String(attrs[`exception.message`])}),span.end()})}};export{ServerRuntime};

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@interfere/server-core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Shared telemetry runtime for Interfere server adapters.",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./runtime": {
+      "monorepo": "./src/runtime.ts",
+      "types": "./dist/runtime.d.mts",
+      "default": "./dist/runtime.mjs"
+    },
+    "./node": {
+      "monorepo": "./src/node.ts",
+      "types": "./dist/node.d.mts",
+      "default": "./dist/node.mjs"
+    },
+    "./ownership": {
+      "monorepo": "./src/ownership.ts",
+      "types": "./dist/ownership.d.mts",
+      "default": "./dist/ownership.mjs"
+    },
+    "./console-bridge": {
+      "monorepo": "./src/console-bridge.ts",
+      "types": "./dist/console-bridge.d.mts",
+      "default": "./dist/console-bridge.mjs"
+    },
+    "./contain": {
+      "monorepo": "./src/contain.ts",
+      "types": "./dist/contain.d.mts",
+      "default": "./dist/contain.mjs"
+    },
+    "./contained-span-processor": {
+      "monorepo": "./src/contained-span-processor.ts",
+      "types": "./dist/contained-span-processor.d.mts",
+      "default": "./dist/contained-span-processor.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint:oxlint": "cd ../../../.. && GOMAXPROCS=2 oxlint --max-warnings=0 --report-unused-disable-directives-severity=error --threads=2 src/packages/public/server-core",
+    "test": "node ../../private/vitest-config/src/cli.ts run --config ../../../../vitest.config.ts",
+    "typecheck": "bun check"
+  },
+  "dependencies": {
+    "@interfere/constants": "^9.3.2",
+    "@interfere/helpers": "^9.3.2",
+    "@interfere/types": "^11.0.0",
+    "@opentelemetry/api": "1.9.1",
+    "@opentelemetry/api-logs": "0.222.0",
+    "@opentelemetry/context-async-hooks": "2.11.0",
+    "@opentelemetry/core": "2.11.0",
+    "@opentelemetry/exporter-logs-otlp-http": "0.223.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.223.0",
+    "@opentelemetry/otlp-exporter-base": "0.223.0",
+    "@opentelemetry/resources": "2.11.0",
+    "@opentelemetry/sdk-logs": "0.222.0",
+    "@opentelemetry/sdk-trace-base": "2.11.0",
+    "@opentelemetry/sdk-trace-node": "2.11.0"
+  },
+  "devDependencies": {
+    "@interfere/test-utils": "^10.1.0",
+    "@interfere/typescript-config": "^9.0.3",
+    "@interfere/vitest-config": "0.0.0",
+    "@types/node": "26.6.6",
+    "tsdown": "0.23.4",
+    "typescript": "7.0.2",
+    "vitest": "5.1.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.