@glasstrace/sdk 1.7.0 → 1.9.0

package/dist/{chunk-UQKI476D.js → chunk-M6EWJCAT.js}

@@ -5,7 +5,7 @@ import {
   PresignedUploadResponseSchema,
   SourceMapManifestResponseSchema,
   SourceMapUploadResponseSchema
-} from "./chunk-P45NZR4J.js";
+} from "./chunk-JHUNLPSS.js";
 
 // src/source-map-uploader.ts
 import * as fs from "node:fs/promises";
@@ -331,4 +331,4 @@ export {
   uploadSourceMapsPresigned,
   uploadSourceMapsAuto
 };
-//# sourceMappingURL=chunk-UQKI476D.js.map
+//# sourceMappingURL=chunk-M6EWJCAT.js.map

package/dist/chunk-QHV7NFON.js

@@ -0,0 +1,130 @@
+import {
+  tryEmitLifecycleEvent
+} from "./chunk-CL3OVHPO.js";
+import {
+  SpanStatusCode,
+  trace
+} from "./chunk-DQ25VOKK.js";
+import {
+  GLASSTRACE_ATTRIBUTE_NAMES
+} from "./chunk-JHUNLPSS.js";
+
+// src/middleware/index.ts
+var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
+var TRACER_NAME = "@glasstrace/sdk/middleware";
+var _skippedUninstalledEmitted = false;
+function _resetForTesting() {
+  _skippedUninstalledEmitted = false;
+}
+function extractRequestPath(req) {
+  if (req === null || typeof req !== "object") return void 0;
+  try {
+    const nextUrl = req.nextUrl;
+    if (nextUrl !== null && typeof nextUrl === "object") {
+      const pathname = nextUrl.pathname;
+      if (typeof pathname === "string" && pathname.length > 0) {
+        return pathname;
+      }
+    }
+    const url = req.url;
+    if (typeof url === "string" && url.length > 0) {
+      try {
+        return new URL(url).pathname;
+      } catch {
+        try {
+          return new URL(url, "http://localhost").pathname;
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+function isNoopSpan(span) {
+  try {
+    return span.spanContext().traceId === INVALID_TRACE_ID;
+  } catch {
+    return false;
+  }
+}
+function tracedRequestMiddleware(options, handler) {
+  if (typeof options.name !== "string" || options.name.length === 0) {
+    throw new TypeError(
+      "tracedRequestMiddleware: options.name must be a non-empty string"
+    );
+  }
+  const wrapped = ((req, ...rest) => {
+    const tracer = trace.getTracer(TRACER_NAME);
+    return tracer.startActiveSpan(options.name, (span) => {
+      if (isNoopSpan(span)) {
+        if (!_skippedUninstalledEmitted) {
+          _skippedUninstalledEmitted = true;
+          tryEmitLifecycleEvent("middleware:skipped_uninstalled", {});
+        }
+        endSpanSafely(span);
+        return handler(req, ...rest);
+      }
+      try {
+        if (options.attributes) {
+          span.setAttributes(options.attributes);
+        }
+        const path = extractRequestPath(req);
+        if (path !== void 0) {
+          span.setAttribute(ATTR.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);
+        }
+      } catch {
+      }
+      let result;
+      try {
+        result = handler(req, ...rest);
+      } catch (error) {
+        recordSpanError(span, error);
+        endSpanSafely(span);
+        throw error;
+      }
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        return result.then(
+          (value) => {
+            endSpanSafely(span);
+            return value;
+          },
+          (error) => {
+            recordSpanError(span, error);
+            endSpanSafely(span);
+            throw error;
+          }
+        );
+      }
+      endSpanSafely(span);
+      return result;
+    });
+  });
+  return wrapped;
+}
+function recordSpanError(span, error) {
+  const normalized = error instanceof Error ? error : typeof error === "string" ? error : new Error(String(error));
+  const statusMessage = normalized instanceof Error ? normalized.message : normalized;
+  try {
+    span.recordException(normalized);
+  } catch {
+  }
+  try {
+    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });
+  } catch {
+  }
+}
+function endSpanSafely(span) {
+  try {
+    span.end();
+  } catch {
+  }
+}
+
+export {
+  _resetForTesting,
+  tracedRequestMiddleware
+};
+//# sourceMappingURL=chunk-QHV7NFON.js.map

package/dist/chunk-QHV7NFON.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/index.ts"],"sourcesContent":["/**\n * Request-middleware-ownership instrumentation for Glasstrace.\n *\n * Subpath: `@glasstrace/sdk/middleware`\n *\n * This module exposes {@link tracedRequestMiddleware}, a wrapper that\n * turns a Next.js `middleware.ts` function (or any generic\n * `Request → Response`-shaped handler) into a span-emitting middleware\n * function. Each invocation opens a child span and tags it with the\n * `glasstrace.causal.middleware_for_request` causal-evidence attribute\n * carrying the originating request's normalized path so the\n * product-side trace-summary transform can link the middleware span\n * to the owning HTTP request trace (DISC-1537 / SDK-046).\n *\n * Edge-runtime safety\n * -------------------\n * The wrapper is included in the SDK's edge bundle\n * (`packages/sdk/src/edge-entry.ts`). Its closure imports only the\n * OTel API, the protocol constants, and the\n * `./optional-lifecycle.js` bridge — none of which reach into\n * `node:*` built-ins or the `process` global. The F003 closure scan\n * (`packages/sdk/scripts/check-edge-bundle.mjs`) enforces this on\n * every build.\n *\n * Causal-evidence form\n * --------------------\n * The wrapper attaches the originating request path as a span\n * attribute (`glasstrace.causal.middleware_for_request`). It does NOT\n * emit an OTel `Link`. Reasons:\n *\n *   1. The Next.js Edge runtime does not propagate AsyncLocalStorage\n *      into `middleware.ts`, so there is no in-process\n *      `SpanContext` to link to in that environment. Attribute-only\n *      causality works in both Node and Edge runtimes; a Link would\n *      degrade to a no-op (no parent context) on Edge.\n *   2. The product-side trace-summary transform reconstructs\n *      ownership from `glasstrace.causal.*` attributes per\n *      DISC-1539 §51-58; it does not require a Link.\n *\n * Invariants\n * ----------\n *\n *   - The wrapped function preserves the user's call-site type so\n *     Next.js's `middleware` export contract (`(req: NextRequest) =>\n *     NextResponse | Response`) flows through unchanged.\n *   - The middleware span MUST NOT overwrite `glasstrace.route`,\n *     `glasstrace.http.status_code`, or `glasstrace.http.duration_ms`\n *     on the parent HTTP span — root-request semantics are owned by\n *     the enriching exporter (`packages/sdk/src/enriching-exporter.ts`).\n *   - On a thrown handler error: span ends with `ERROR` status +\n *     `recordException`; rethrows. The exception is normalized to\n *     `Error | string` first so non-Error throwables (number, plain\n *     object) do not crash `recordException`.\n *   - Always ends the span (`finally`), even on `throw`.\n *\n * @module @glasstrace/sdk/middleware\n */\n\nimport {\n  trace,\n  SpanStatusCode,\n  type AttributeValue,\n} from \"@opentelemetry/api\";\nimport { GLASSTRACE_ATTRIBUTE_NAMES } from \"@glasstrace/protocol\";\nimport { tryEmitLifecycleEvent } from \"../optional-lifecycle.js\";\n\nconst ATTR = GLASSTRACE_ATTRIBUTE_NAMES;\n\n/**\n * Module-level OTel tracer name for the middleware subpath. Resolves\n * through the global `ProxyTracerProvider` so the wrapper picks up\n * whatever provider the SDK has detected or registered (the SDK's\n * own enriching exporter, Sentry's processor in coexistence mode,\n * etc.). Re-resolved on every call site rather than cached at module\n * top level so test harnesses can install a provider after this\n * module is imported. This mirrors the tRPC subpath at\n * `packages/sdk/src/trpc/index.ts:128`.\n */\nconst TRACER_NAME = \"@glasstrace/sdk/middleware\";\n\n/**\n * Module-level once-flag for the\n * `middleware:skipped_uninstalled` lifecycle event. The flag is\n * exported via {@link _resetForTesting} so unit tests can re-arm it\n * between scenarios.\n */\nlet _skippedUninstalledEmitted = false;\n\n/**\n * INTERNAL — clears the once-flag for the\n * `middleware:skipped_uninstalled` lifecycle event. Invoked by\n * Vitest fixtures only; not part of the public surface.\n */\nexport function _resetForTesting(): void {\n  _skippedUninstalledEmitted = false;\n}\n\n/**\n * Permissive structural bound for a request-middleware function. The\n * shape is the intersection of Next.js's `middleware.ts` export\n * (`(req: NextRequest, event?: NextFetchEvent) => NextResponse |\n * Response | Promise<NextResponse | Response> | undefined`) and the\n * generic Web Fetch API (`(req: Request, ...rest: any[]) => Response\n * | Promise<Response>`). The parameter list is typed with `any[]` for\n * the rest position so any caller-narrowed signature is assignable\n * without the wrapper having to import `next/server` types.\n *\n * Exported so consumers can reference it for type-inference assertions\n * (e.g., proving a strongly-typed handler fits the bound). The\n * runtime contract is fixed by the Web Fetch API: the first argument\n * is a `Request`-shaped object and the return is a `Response`-shaped\n * value (or a Promise of one).\n */\n// The `any[]` in the rest position is load-bearing: a tighter bound\n// (e.g. `unknown[]`) would reject `(req, event?) => ...` because\n// `unknown` cannot be passed in the contravariant parameter position\n// without an explicit cast at every call site. Capturing\n// `H extends RequestMiddlewareFunction` preserves caller types\n// through the wrapper's `: H` return.\n//\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequestMiddlewareFunction = (req: any, ...rest: any[]) => unknown;\n\n/**\n * Options for {@link tracedRequestMiddleware}.\n *\n * @example\n * ```ts\n * import { tracedRequestMiddleware } from \"@glasstrace/sdk/middleware\";\n * import type { NextRequest } from \"next/server\";\n *\n * export const middleware = tracedRequestMiddleware(\n *   { name: \"auth-middleware\", attributes: { \"auth.required\": true } },\n *   async (req: NextRequest) => {\n *     // … your auth logic here …\n *     return NextResponse.next();\n *   },\n * );\n * ```\n */\nexport interface TracedRequestMiddlewareOptions {\n  /**\n   * Span name. Required, non-empty string. Used as the OTel span name\n   * and appears in trace timelines. Names should be stable across\n   * runs so the product-side transform can reason about middleware\n   * identity (e.g., \"auth-middleware\", \"rate-limiter\"); avoid\n   * embedding request data in the name.\n   */\n  name: string;\n  /**\n   * Optional attributes attached to the span before the wrapped\n   * handler runs. Forwarded to OTel as-is via `span.setAttributes()`.\n   * The SDK does not redact, sanitize, or scan values here — callers\n   * MUST avoid placing tokens, credentials, or other sensitive data\n   * in `attributes`.\n   *\n   * Sensitive request/response data is captured through gated SDK\n   * paths (e.g., `glasstrace.error.response_body`), not through this\n   * surface.\n   */\n  attributes?: Record<string, AttributeValue>;\n}\n\n/**\n * Extract the originating request path from a Fetch-API `Request` or\n * `NextRequest`-shaped object. Preference order:\n *\n *   1. `req.nextUrl.pathname` — present on `NextRequest`. This is\n *      Next.js's parsed URL and is the most reliable source on the\n *      Next.js Edge runtime, where `req.url` may be a relative form\n *      depending on framework-internal rewrites.\n *   2. `new URL(req.url).pathname` — present on the generic Fetch\n *      `Request`. The URL constructor accepts an absolute URL; if\n *      `req.url` is relative we synthesize a base of\n *      `http://localhost` to make parsing succeed (the host is\n *      discarded — only the path is used).\n *   3. `undefined` — when neither field exists or both fail to\n *      parse, the wrapper omits the causal attribute rather than\n *      emitting a guessed value, per the SDK-046 product brief's\n *      \"missing or unknown evidence is preferable to guessed\n *      evidence\" rule (DISC-1537 / DISC-1539 product handoff).\n *\n * This function never throws.\n */\nfunction extractRequestPath(req: unknown): string | undefined {\n  if (req === null || typeof req !== \"object\") return undefined;\n  try {\n    // NextRequest.nextUrl — already a URL-like object with .pathname.\n    const nextUrl = (req as { nextUrl?: unknown }).nextUrl;\n    if (nextUrl !== null && typeof nextUrl === \"object\") {\n      const pathname = (nextUrl as { pathname?: unknown }).pathname;\n      if (typeof pathname === \"string\" && pathname.length > 0) {\n        return pathname;\n      }\n    }\n    // Fall back to req.url. On Edge / Web Fetch this is always\n    // absolute; on some Node frameworks it can be relative\n    // (`/api/foo?x=1`), so synthesize a base if the URL constructor\n    // throws on the absolute parse.\n    const url = (req as { url?: unknown }).url;\n    if (typeof url === \"string\" && url.length > 0) {\n      try {\n        return new URL(url).pathname;\n      } catch {\n        try {\n          return new URL(url, \"http://localhost\").pathname;\n        } catch {\n          return undefined;\n        }\n      }\n    }\n  } catch {\n    // Defensive: any unexpected shape failure returns undefined.\n  }\n  return undefined;\n}\n\n/**\n * Sentinel trace ID returned by the OTel API's noop tracer\n * (`@opentelemetry/api`'s `NonRecordingSpan`). Per the OTel\n * specification's noop semantics, the noop SpanContext exposes\n * `traceId === \"00000000000000000000000000000000\"`. Used by\n * {@link isNoopSpan} below to discriminate \"no provider registered\"\n * from \"real provider whose sampler dropped this span\" — the latter\n * also returns `isRecording() === false` but produces a valid\n * 32-char hex trace ID because the SDK assigns one before sampler\n * invocation for propagation purposes.\n */\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\n\n/**\n * Type guard for OTel spans created by the noop tracer. The OTel\n * API's noop SpanContext returns the all-zeros sentinel for\n * `traceId`; real SDK-emitted spans always have a valid 32-char hex\n * trace ID (even when a sampler decided to DROP the span). Using\n * the SpanContext discriminator keeps the SDK-not-registered fast\n * path from misfiring under normal head sampling configurations\n * (Copilot review 2026-05-08).\n *\n * Returning `true` here means the caller should NOT proceed with\n * span enrichment; the noop tracer would discard everything anyway.\n */\nfunction isNoopSpan(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): boolean {\n  try {\n    return span.spanContext().traceId === INVALID_TRACE_ID;\n  } catch {\n    // Defensive: treat \"could not determine\" as not-noop so we\n    // continue down the enrichment path. The noop tracer itself\n    // never throws from `spanContext()`.\n    return false;\n  }\n}\n\n/**\n * Wrap a Next.js / generic-fetch request-middleware function in an\n * OTel span tagged with `glasstrace.causal.middleware_for_request`.\n *\n * Each call to the returned function:\n *\n *   1. Detects the SDK's registration state. When the OTel API is\n *      still on the noop tracer (SDK not registered, or\n *      `OtelState.UNCONFIGURED`), runs the wrapped handler directly\n *      and emits a `middleware:skipped_uninstalled` lifecycle event\n *      (at most once per process). No span is opened.\n *   2. Otherwise opens a span named `options.name` under the active\n *      OTel context (typically the HTTP server span on Node;\n *      detached on Edge where AsyncLocalStorage is not available).\n *      Sets `options.attributes` first, then attaches the originating\n *      request's path (via {@link extractRequestPath}) as\n *      `glasstrace.causal.middleware_for_request`. The path is\n *      omitted when extraction returns `undefined` so absent evidence\n *      is preferred over guessed evidence.\n *   3. Awaits the wrapped handler.\n *   4. On a thrown error: normalizes the throwable to `Error | string`\n *      so `recordException` does not throw on non-Error values; sets\n *      `span.status` to `ERROR` with the error's message; rethrows the\n *      original (un-normalized) error verbatim.\n *   5. On a successful return: leaves the span status `UNSET` per OTel\n *      instrumentation-library guidance (explicit `OK` would shadow\n *      downstream consumers' error transitions).\n *   6. Always ends the span, even on `throw` or `return`.\n *\n * Type-inference: the returned function preserves the input function's\n * type `H`, so caller-narrowed signatures (e.g., `(req: NextRequest)\n * => NextResponse`) flow through unchanged.\n *\n * @param options - Span name and optional pre-start attributes.\n * @param handler - The user's middleware handler. Must accept a\n *   request-shaped object as its first argument and return (or\n *   resolve to) a response-shaped value.\n * @returns The wrapped handler with the same call signature and\n *   return type as `handler`.\n *\n * @example Next.js middleware.ts\n * ```ts\n * import { tracedRequestMiddleware } from \"@glasstrace/sdk/middleware\";\n * import { NextResponse, type NextRequest } from \"next/server\";\n *\n * export const middleware = tracedRequestMiddleware(\n *   { name: \"auth-middleware\" },\n *   async (req: NextRequest) => {\n *     if (!req.cookies.get(\"session\")) {\n *       return NextResponse.redirect(new URL(\"/login\", req.url));\n *     }\n *     return NextResponse.next();\n *   },\n * );\n *\n * export const config = { matcher: [\"/dashboard/:path*\"] };\n * ```\n */\nexport function tracedRequestMiddleware<H extends RequestMiddlewareFunction>(\n  options: TracedRequestMiddlewareOptions,\n  handler: H,\n): H {\n  // Eager validation: a mis-typed call site fails at wrapper-\n  // construction time (typically at module load) rather than at\n  // first request, when the failure is harder to diagnose.\n  if (typeof options.name !== \"string\" || options.name.length === 0) {\n    throw new TypeError(\n      \"tracedRequestMiddleware: options.name must be a non-empty string\",\n    );\n  }\n\n  // Capture options + handler lexically. Do not read from `this` —\n  // Next.js's middleware loader invokes this as a plain function, not\n  // a method, so `this` is undefined.\n  const wrapped = ((req: Parameters<H>[0], ...rest: unknown[]): unknown => {\n    const tracer = trace.getTracer(TRACER_NAME);\n    return tracer.startActiveSpan(options.name, (span) => {\n      // SDK-not-registered fast path. Detecting via the public\n      // `isRecording()` method on the started span is the canonical\n      // OTel-API-only probe — the noop tracer's `NonRecordingSpan`\n      // returns `false`, real SDK-emitted spans return `true`. This\n      // avoids the more expensive workaround of opening a probe span\n      // ahead of time, which would emit a useless span on every\n      // request when a real provider is registered.\n      if (isNoopSpan(span)) {\n        if (!_skippedUninstalledEmitted) {\n          _skippedUninstalledEmitted = true;\n          tryEmitLifecycleEvent(\"middleware:skipped_uninstalled\", {});\n        }\n        // The noop span needs no enrichment and no end() because the\n        // noop implementation is a no-op for both, but call end()\n        // anyway for symmetry with the real-span path.\n        endSpanSafely(span);\n        return (handler as (...args: unknown[]) => unknown)(req, ...rest);\n      }\n\n      // Set caller-supplied attributes first so they appear on the\n      // span before any internal attribute we add below.\n      try {\n        if (options.attributes) {\n          span.setAttributes(options.attributes);\n        }\n        const path = extractRequestPath(req);\n        if (path !== undefined) {\n          span.setAttribute(ATTR.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);\n        }\n      } catch {\n        // Attribute-setting failures are advisory; never block the\n        // wrapped handler from running.\n      }\n\n      let result: unknown;\n      try {\n        result = (handler as (...args: unknown[]) => unknown)(req, ...rest);\n      } catch (error) {\n        recordSpanError(span, error);\n        endSpanSafely(span);\n        throw error;\n      }\n\n      // The handler may be sync or async. If async, attach the\n      // span-end + error-recording on the promise chain; otherwise\n      // end the span synchronously and return the value.\n      if (\n        result !== null &&\n        typeof result === \"object\" &&\n        typeof (result as Promise<unknown>).then === \"function\"\n      ) {\n        return (result as Promise<unknown>).then(\n          (value) => {\n            endSpanSafely(span);\n            return value;\n          },\n          (error: unknown) => {\n            recordSpanError(span, error);\n            endSpanSafely(span);\n            throw error;\n          },\n        );\n      }\n\n      endSpanSafely(span);\n      return result;\n    });\n  }) as H;\n\n  return wrapped;\n}\n\n/**\n * Records an exception on a span and sets the span status to `ERROR`.\n * Both calls are independently guarded so a failing `recordException`\n * cannot prevent the status transition, and vice versa. The user's\n * original error value is preserved verbatim — wrapping is purely a\n * span-side normalization.\n */\nfunction recordSpanError(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n  error: unknown,\n): void {\n  const normalized: Error | string =\n    error instanceof Error\n      ? error\n      : typeof error === \"string\"\n        ? error\n        : new Error(String(error));\n  const statusMessage =\n    normalized instanceof Error ? normalized.message : normalized;\n  try {\n    span.recordException(normalized);\n  } catch {\n    // Swallow: instrumentation must never replace the user's error.\n  }\n  try {\n    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });\n  } catch {\n    // Swallow: independent from recordException so a failing\n    // recordException does not prevent the ERROR status.\n  }\n}\n\n/**\n * Ends a span, swallowing any throw from the OTel implementation. A\n * misbehaving `span.end()` must not replace the wrapped handler's\n * return value or thrown error with an unrelated one.\n */\nfunction endSpanSafely(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): void {\n  try {\n    span.end();\n  } catch {\n    // Span lifecycle errors are always non-fatal at this layer.\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-M2TLX6NM.js → chunk-QXITSNYM.js}

@@ -2,12 +2,12 @@ import {
   atomicWriteFile,
   refreshGenericMcpConfigAtRuntime,
   resolveEffectiveMcpCredential
-} from "./chunk-WL6BXEJ5.js";
+} from "./chunk-DKV53A2C.js";
 import {
   DEFAULT_CAPTURE_CONFIG,
   SdkCachedConfigSchema,
   SdkInitResponseSchema
-} from "./chunk-P45NZR4J.js";
+} from "./chunk-JHUNLPSS.js";
 import {
   __require
 } from "./chunk-NSBPE2FW.js";
@@ -692,4 +692,4 @@ export {
   didLastInitSucceed,
   verifyInitReachable
 };
-//# sourceMappingURL=chunk-M2TLX6NM.js.map
+//# sourceMappingURL=chunk-QXITSNYM.js.map

package/dist/chunk-RQ5BIWDT.js

@@ -0,0 +1,119 @@
+import {
+  tryEmitLifecycleEvent
+} from "./chunk-CL3OVHPO.js";
+import {
+  SpanStatusCode,
+  context,
+  trace
+} from "./chunk-DQ25VOKK.js";
+import {
+  GLASSTRACE_ATTRIBUTE_NAMES
+} from "./chunk-JHUNLPSS.js";
+
+// src/async-context/index.ts
+var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
+var TRACER_NAME = "@glasstrace/sdk/async-context";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var _skippedUninstalledEmitted = false;
+var _noOriginatingContextEmitted = false;
+function _resetForTesting() {
+  _skippedUninstalledEmitted = false;
+  _noOriginatingContextEmitted = false;
+}
+function withAsyncCausality(options, fn) {
+  if (typeof options.name !== "string" || options.name.length === 0) {
+    throw new TypeError(
+      "withAsyncCausality: options.name must be a non-empty string"
+    );
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError("withAsyncCausality: fn must be a function");
+  }
+  const capturedContext = (() => {
+    try {
+      const active = trace.getActiveSpan();
+      if (!active) return void 0;
+      const ctx = active.spanContext();
+      if (ctx.traceId === INVALID_TRACE_ID) return void 0;
+      return ctx;
+    } catch {
+      return void 0;
+    }
+  })();
+  return async () => {
+    const tracer = trace.getTracer(TRACER_NAME);
+    const span = tracer.startSpan(options.name, {
+      root: true,
+      links: capturedContext !== void 0 ? [{ context: capturedContext }] : void 0
+    });
+    if (isNoopSpan(span)) {
+      if (!_skippedUninstalledEmitted) {
+        _skippedUninstalledEmitted = true;
+        tryEmitLifecycleEvent("async:skipped_uninstalled", {});
+      }
+      endSpanSafely(span);
+      return Promise.resolve(fn());
+    }
+    if (capturedContext === void 0 && !_noOriginatingContextEmitted) {
+      _noOriginatingContextEmitted = true;
+      tryEmitLifecycleEvent("async:no_originating_context", {});
+    }
+    try {
+      if (options.attributes) {
+        span.setAttributes(options.attributes);
+      }
+      if (capturedContext !== void 0) {
+        span.setAttribute(
+          ATTR.CAUSAL_POST_RESPONSE_ASYNC,
+          capturedContext.traceId
+        );
+        span.setAttribute(ATTR.CAUSAL_AFFECTS_HTTP_STATUS, false);
+        span.setAttribute(ATTR.CAUSAL_AFFECTS_HTTP_DURATION, false);
+      }
+    } catch {
+    }
+    try {
+      const value = await context.with(
+        trace.setSpan(context.active(), span),
+        fn
+      );
+      return value;
+    } catch (error) {
+      recordSpanError(span, error);
+      throw error;
+    } finally {
+      endSpanSafely(span);
+    }
+  };
+}
+function isNoopSpan(span) {
+  try {
+    return span.spanContext().traceId === INVALID_TRACE_ID;
+  } catch {
+    return false;
+  }
+}
+function recordSpanError(span, error) {
+  const normalized = error instanceof Error ? error : typeof error === "string" ? error : new Error(String(error));
+  const statusMessage = normalized instanceof Error ? normalized.message : normalized;
+  try {
+    span.recordException(normalized);
+  } catch {
+  }
+  try {
+    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });
+  } catch {
+  }
+}
+function endSpanSafely(span) {
+  try {
+    span.end();
+  } catch {
+  }
+}
+
+export {
+  _resetForTesting,
+  withAsyncCausality
+};
+//# sourceMappingURL=chunk-RQ5BIWDT.js.map

package/dist/chunk-RQ5BIWDT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/async-context/index.ts"],"sourcesContent":["/**\n * Post-response async causality instrumentation for Glasstrace.\n *\n * Subpath: `@glasstrace/sdk/async-context`\n *\n * This module exposes {@link withAsyncCausality}, a continuation-\n * passing wrapper that captures the active OTel `SpanContext` at call\n * time and binds it to a callback. When the callback runs later\n * (Next.js `after()`, queue dispatchers, webhook fire-and-forget),\n * the wrapper opens a span linked to the originating trace via two\n * channels:\n *\n *   - An OTel `Link` to the captured `SpanContext` — the OTel-native\n *     pointer between two spans in different traces. Surfaces in\n *     standard OTel-aware UIs (Jaeger, Honeycomb, etc.) as a\n *     \"follows from\" relationship.\n *   - A `glasstrace.causal.post_response_async` attribute carrying\n *     the captured trace ID (32-char hex). Used by the product-side\n *     trace-summary transform (per DISC-1539's product handoff) to\n *     reconstruct ownership without resolving the Link. Two\n *     companion booleans\n *     (`glasstrace.causal.affects_http_status` and\n *     `glasstrace.causal.affects_http_duration`) document that the\n *     async work does NOT participate in the root request's outcome.\n *\n * Both channels are emitted together so the SDK is robust to\n * downstream transforms that resolve causality through either form.\n *\n * Edge-runtime safety\n * -------------------\n * The wrapper is included in the SDK's edge bundle\n * (`packages/sdk/src/edge-entry.ts`). Its closure imports only the\n * OTel API, the protocol constants, and the\n * `./optional-lifecycle.js` bridge — none of which reach into\n * `node:*` built-ins or the `process` global. The F003 closure scan\n * (`packages/sdk/scripts/check-edge-bundle.mjs`) enforces this on\n * every build.\n *\n * Strategy: continuation-passing, NOT global ALS propagation\n * ---------------------------------------------------------\n * Per the SDK-046 brief §2.3: ALS continuity across Next.js `after()`\n * is uncertain (the framework may schedule via `queueMicrotask`\n * (preserves ALS) or via cross-tick scheduling (drops ALS)). Relying\n * on ALS would couple the SDK to Next internals. Continuation-passing\n * makes the causality explicit — the user wraps the callback they\n * pass to `after()` / their queue, and the captured `SpanContext`\n * travels with the closure regardless of how the framework schedules\n * it.\n *\n * @module @glasstrace/sdk/async-context\n */\n\nimport {\n  trace,\n  context,\n  SpanStatusCode,\n  type AttributeValue,\n  type SpanContext,\n} from \"@opentelemetry/api\";\nimport { GLASSTRACE_ATTRIBUTE_NAMES } from \"@glasstrace/protocol\";\nimport { tryEmitLifecycleEvent } from \"../optional-lifecycle.js\";\n\nconst ATTR = GLASSTRACE_ATTRIBUTE_NAMES;\n\n/**\n * Module-level OTel tracer name for the async-context subpath.\n * Resolves through the global `ProxyTracerProvider` so the wrapper\n * picks up whatever provider the SDK has registered. Re-resolved on\n * every call site rather than cached at module top level so test\n * harnesses can install a provider after this module is imported.\n * Mirrors the tRPC subpath at `packages/sdk/src/trpc/index.ts:128`.\n */\nconst TRACER_NAME = \"@glasstrace/sdk/async-context\";\n\n/**\n * The W3C-spec-defined invalid trace ID. The OTel API noop tracer\n * returns this value from `Span.spanContext().traceId`. We use this\n * to detect both (a) the SDK-not-registered case via the\n * noop-tracer probe and (b) the no-active-span case via the\n * captured `SpanContext`.\n */\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\n\n/**\n * Module-level once-flags for lifecycle events. Cleared via\n * {@link _resetForTesting}.\n */\nlet _skippedUninstalledEmitted = false;\nlet _noOriginatingContextEmitted = false;\n\n/**\n * INTERNAL — clears once-flags for unit tests; not part of the\n * public surface.\n */\nexport function _resetForTesting(): void {\n  _skippedUninstalledEmitted = false;\n  _noOriginatingContextEmitted = false;\n}\n\n/**\n * Options for {@link withAsyncCausality}.\n *\n * @example\n * ```ts\n * import { withAsyncCausality } from \"@glasstrace/sdk/async-context\";\n * import { after } from \"next/server\";\n *\n * export async function POST(req: Request) {\n *   const result = await processRequest(req);\n *   after(\n *     withAsyncCausality(\n *       { name: \"send-confirmation-email\" },\n *       async () => sendEmail(result.userId),\n *     ),\n *   );\n *   return Response.json({ ok: true });\n * }\n * ```\n */\nexport interface WithAsyncCausalityOptions {\n  /**\n   * Span name for the async work. Required, non-empty string. Used as\n   * the OTel span name and appears in trace timelines. Names should\n   * be stable across runs (e.g., \"send-confirmation-email\",\n   * \"enqueue-webhook-dispatch\"); avoid embedding payload data in the\n   * name.\n   */\n  name: string;\n  /**\n   * Optional attributes attached to the span before the wrapped\n   * callback runs. Forwarded to OTel as-is via `span.setAttributes()`.\n   * The SDK does not redact, sanitize, or scan values here — callers\n   * MUST avoid placing tokens, credentials, or other sensitive data\n   * in `attributes`.\n   */\n  attributes?: Record<string, AttributeValue>;\n}\n\n/**\n * Capture the active OTel `SpanContext` at call time, bind it to a\n * callback, and return a continuation that will emit a\n * causally-linked span when invoked.\n *\n * The returned continuation:\n *\n *   1. Detects the SDK's registration state. When the OTel API is\n *      still on the noop tracer, runs the wrapped callback directly\n *      and emits an `async:skipped_uninstalled` lifecycle event (at\n *      most once per process). No span is opened.\n *   2. Otherwise opens a span named `options.name` as a NEW root\n *      span (not parented to the captured context — `after()` /\n *      queue dispatchers run outside the originating request's OTel\n *      context, so the async work belongs to a separate trace).\n *   3. When a captured `SpanContext` exists with a valid trace ID,\n *      attaches:\n *        - an OTel `Link` to that `SpanContext` (the OTel-native\n *          form),\n *        - the `glasstrace.causal.post_response_async` attribute\n *          carrying the trace ID (the transform-readable form),\n *        - `glasstrace.causal.affects_http_status = false` and\n *          `glasstrace.causal.affects_http_duration = false`\n *          documenting that the async work does NOT participate in\n *          the root request's outcome.\n *      When no valid `SpanContext` was captured, none of these are\n *      emitted (per SDK-046's \"missing or unknown evidence is\n *      preferable to guessed evidence\" rule) and an\n *      `async:no_originating_context` lifecycle event fires (at\n *      most once per process).\n *   4. Awaits the wrapped callback.\n *   5. On a thrown error: normalizes the throwable; sets `ERROR`\n *      status with `recordException`; rethrows the original error\n *      verbatim.\n *   6. On a successful return: leaves status `UNSET`.\n *   7. Always ends the span.\n *\n * The continuation returns a Promise resolving to the callback's\n * return value (Promise-or-value semantics: a sync callback's value\n * is wrapped in `Promise.resolve()`).\n *\n * @param options - Span name and optional pre-start attributes.\n * @param fn - The async callback to run later. May be sync or async;\n *   the wrapper always returns a Promise to give a consistent\n *   continuation shape regardless of `fn`'s synchronicity.\n * @returns A continuation `() => Promise<T>` that, when invoked,\n *   emits the causally-linked span and runs `fn`.\n *\n * @example Next.js after() — typical use\n * ```ts\n * import { withAsyncCausality } from \"@glasstrace/sdk/async-context\";\n * import { after } from \"next/server\";\n *\n * export async function POST(req: Request) {\n *   const result = await processRequest(req);\n *   after(\n *     withAsyncCausality(\n *       { name: \"send-confirmation-email\" },\n *       async () => sendEmail(result.userId),\n *     ),\n *   );\n *   return Response.json({ ok: true });\n * }\n * ```\n *\n * @example Queue dispatcher — capture before enqueue\n * ```ts\n * const dispatch = withAsyncCausality(\n *   { name: \"process-webhook\" },\n *   async () => handler(payload),\n * );\n * await queue.enqueue(dispatch);\n * ```\n */\nexport function withAsyncCausality<T>(\n  options: WithAsyncCausalityOptions,\n  fn: () => Promise<T> | T,\n): () => Promise<T> {\n  if (typeof options.name !== \"string\" || options.name.length === 0) {\n    throw new TypeError(\n      \"withAsyncCausality: options.name must be a non-empty string\",\n    );\n  }\n  if (typeof fn !== \"function\") {\n    throw new TypeError(\"withAsyncCausality: fn must be a function\");\n  }\n\n  // Capture-time: snapshot the active SpanContext, if any. The\n  // capture happens synchronously in the wrapper-construction call,\n  // BEFORE the user passes the continuation to `after()` /\n  // `queue.enqueue()`. Reading via `trace.getActiveSpan()` rather\n  // than `context.active()` mirrors `captureCorrelationId()` at\n  // `packages/sdk/src/correlation-id.ts:83` — the active-span API is\n  // the public OTel surface for this.\n  const capturedContext: SpanContext | undefined = (() => {\n    try {\n      const active = trace.getActiveSpan();\n      if (!active) return undefined;\n      const ctx = active.spanContext();\n      // Reject the noop-tracer's invalid trace ID. Treating it as\n      // captured would emit a Link to all-zeros, which is misleading.\n      if (ctx.traceId === INVALID_TRACE_ID) return undefined;\n      return ctx;\n    } catch {\n      return undefined;\n    }\n  })();\n\n  return async (): Promise<T> => {\n    const tracer = trace.getTracer(TRACER_NAME);\n    // The async span is a NEW root: post-response work runs outside\n    // the originating request's OTel context, so parenting to the\n    // captured context would put two unrelated runtime executions in\n    // the same trace tree. Causality is communicated via the Link +\n    // attribute pair instead.\n    const span = tracer.startSpan(options.name, {\n      root: true,\n      links:\n        capturedContext !== undefined\n          ? [{ context: capturedContext }]\n          : undefined,\n    });\n\n    // SDK-not-registered fast path. The public `isRecording()` probe\n    // returns `false` on noop spans without producing an exported\n    // span; this avoids emitting a useless probe span on every\n    // continuation when a real provider is registered.\n    if (isNoopSpan(span)) {\n      if (!_skippedUninstalledEmitted) {\n        _skippedUninstalledEmitted = true;\n        tryEmitLifecycleEvent(\"async:skipped_uninstalled\", {});\n      }\n      endSpanSafely(span);\n      return Promise.resolve(fn());\n    }\n\n    if (capturedContext === undefined && !_noOriginatingContextEmitted) {\n      _noOriginatingContextEmitted = true;\n      tryEmitLifecycleEvent(\"async:no_originating_context\", {});\n    }\n\n    try {\n      if (options.attributes) {\n        span.setAttributes(options.attributes);\n      }\n      if (capturedContext !== undefined) {\n        span.setAttribute(\n          ATTR.CAUSAL_POST_RESPONSE_ASYNC,\n          capturedContext.traceId,\n        );\n        span.setAttribute(ATTR.CAUSAL_AFFECTS_HTTP_STATUS, false);\n        span.setAttribute(ATTR.CAUSAL_AFFECTS_HTTP_DURATION, false);\n      }\n    } catch {\n      // Attribute failures are advisory; do not block fn().\n    }\n\n    try {\n      // Activate the span as the current OTel context during fn()\n      // execution so any nested spans (auto-instrumented OR manual)\n      // are parented under this span. Without `context.with`, the\n      // started span exists but is not in the active context, so\n      // child spans become orphan roots (Copilot review 2026-05-08).\n      // We use `context.with` rather than `tracer.startActiveSpan`\n      // so the existing setup (Link/attribute application above)\n      // can run pre-activation; the existing setup is small but\n      // not trivial to reorder.\n      const value = await context.with(\n        trace.setSpan(context.active(), span),\n        fn,\n      );\n      return value;\n    } catch (error) {\n      recordSpanError(span, error);\n      throw error;\n    } finally {\n      endSpanSafely(span);\n    }\n  };\n}\n\n/**\n * Type guard for OTel noop spans. Mirrors the same check in\n * `../middleware/index.ts`. The OTel API's noop tracer\n * (`@opentelemetry/api`'s `NonRecordingSpan`) returns the all-zeros\n * sentinel trace ID `00000000000000000000000000000000` from\n * `Span.spanContext().traceId`. Real SDK-emitted spans — including\n * spans that a sampler chose to DROP (which legitimately return\n * `isRecording() === false`) — return a valid 32-char hex trace ID\n * because the SDK assigns a trace ID before sampler invocation for\n * propagation purposes. Using the SpanContext discriminator keeps\n * the SDK-not-registered fast path from misfiring under normal head\n * sampling configurations (Copilot review 2026-05-08).\n */\nfunction isNoopSpan(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): boolean {\n  try {\n    return span.spanContext().traceId === INVALID_TRACE_ID;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * See {@link ../middleware/index.ts} — duplicated here rather than\n * shared because the OTel `Span` type is structural and importing\n * a helper from a sibling module would force the modules to share a\n * deeper dependency. Both copies are exactly two non-throwing\n * `try`/`catch` blocks; the duplication is intentional and trivial.\n */\nfunction recordSpanError(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n  error: unknown,\n): void {\n  const normalized: Error | string =\n    error instanceof Error\n      ? error\n      : typeof error === \"string\"\n        ? error\n        : new Error(String(error));\n  const statusMessage =\n    normalized instanceof Error ? normalized.message : normalized;\n  try {\n    span.recordException(normalized);\n  } catch {\n    /* swallow */\n  }\n  try {\n    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });\n  } catch {\n    /* swallow */\n  }\n}\n\n/** See {@link ../middleware/index.ts}. */\nfunction endSpanSafely(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): void {\n  try {\n    span.end();\n  } catch {\n    /* swallow */\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA8DA,IAAM,OAAO;AAUb,IAAM,cAAc;AASpB,IAAM,mBAAmB;AAMzB,IAAI,6BAA6B;AACjC,IAAI,+BAA+B;AAM5B,SAAS,mBAAyB;AACvC,+BAA6B;AAC7B,iCAA+B;AACjC;AAmHO,SAAS,mBACd,SACA,IACkB;AAClB,MAAI,OAAO,QAAQ,SAAS,YAAY,QAAQ,KAAK,WAAW,GAAG;AACjE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,MAAI,OAAO,OAAO,YAAY;AAC5B,UAAM,IAAI,UAAU,2CAA2C;AAAA,EACjE;AASA,QAAM,mBAA4C,MAAM;AACtD,QAAI;AACF,YAAM,SAAS,MAAM,cAAc;AACnC,UAAI,CAAC,OAAQ,QAAO;AACpB,YAAM,MAAM,OAAO,YAAY;AAG/B,UAAI,IAAI,YAAY,iBAAkB,QAAO;AAC7C,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF,GAAG;AAEH,SAAO,YAAwB;AAC7B,UAAM,SAAS,MAAM,UAAU,WAAW;AAM1C,UAAM,OAAO,OAAO,UAAU,QAAQ,MAAM;AAAA,MAC1C,MAAM;AAAA,MACN,OACE,oBAAoB,SAChB,CAAC,EAAE,SAAS,gBAAgB,CAAC,IAC7B;AAAA,IACR,CAAC;AAMD,QAAI,WAAW,IAAI,GAAG;AACpB,UAAI,CAAC,4BAA4B;AAC/B,qCAA6B;AAC7B,8BAAsB,6BAA6B,CAAC,CAAC;AAAA,MACvD;AACA,oBAAc,IAAI;AAClB,aAAO,QAAQ,QAAQ,GAAG,CAAC;AAAA,IAC7B;AAEA,QAAI,oBAAoB,UAAa,CAAC,8BAA8B;AAClE,qCAA+B;AAC/B,4BAAsB,gCAAgC,CAAC,CAAC;AAAA,IAC1D;AAEA,QAAI;AACF,UAAI,QAAQ,YAAY;AACtB,aAAK,cAAc,QAAQ,UAAU;AAAA,MACvC;AACA,UAAI,oBAAoB,QAAW;AACjC,aAAK;AAAA,UACH,KAAK;AAAA,UACL,gBAAgB;AAAA,QAClB;AACA,aAAK,aAAa,KAAK,4BAA4B,KAAK;AACxD,aAAK,aAAa,KAAK,8BAA8B,KAAK;AAAA,MAC5D;AAAA,IACF,QAAQ;AAAA,IAER;AAEA,QAAI;AAUF,YAAM,QAAQ,MAAM,QAAQ;AAAA,QAC1B,MAAM,QAAQ,QAAQ,OAAO,GAAG,IAAI;AAAA,QACpC;AAAA,MACF;AACA,aAAO;AAAA,IACT,SAAS,OAAO;AACd,sBAAgB,MAAM,KAAK;AAC3B,YAAM;AAAA,IACR,UAAE;AACA,oBAAc,IAAI;AAAA,IACpB;AAAA,EACF;AACF;AAeA,SAAS,WACP,MACS;AACT,MAAI;AACF,WAAO,KAAK,YAAY,EAAE,YAAY;AAAA,EACxC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AASA,SAAS,gBACP,MACA,OACM;AACN,QAAM,aACJ,iBAAiB,QACb,QACA,OAAO,UAAU,WACf,QACA,IAAI,MAAM,OAAO,KAAK,CAAC;AAC/B,QAAM,gBACJ,sBAAsB,QAAQ,WAAW,UAAU;AACrD,MAAI;AACF,SAAK,gBAAgB,UAAU;AAAA,EACjC,QAAQ;AAAA,EAER;AACA,MAAI;AACF,SAAK,UAAU,EAAE,MAAM,eAAe,OAAO,SAAS,cAAc,CAAC;AAAA,EACvE,QAAQ;AAAA,EAER;AACF;AAGA,SAAS,cACP,MACM;AACN,MAAI;AACF,SAAK,IAAI;AAAA,EACX,QAAQ;AAAA,EAER;AACF;","names":[]}