@mnemonica/otel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 https://github.com/wentout
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# @mnemonica/otel
+
+The framework-free Node.js core of the mnemonica observability stack.
+
+This package is everything a framework adapter needs that has nothing to
+do with any framework: the dive hook wiring, the OpenTelemetry providers,
+the ALS async-flow backbone, the thunderstruck pre-root forensics store,
+and the Unblinder error reports — all against plain structural types, so
+they run in Express, Fastify, raw `http`, queue consumers, and CLIs
+unchanged.
+
+- [`mnemonica`](https://www.npmjs.com/package/mnemonica) — instance
+  inheritance; lineage carried in the prototype chain.
+- [`@mnemonica/dive`](https://www.npmjs.com/package/@mnemonica/dive) —
+  execution-flow tracing engine (no ALS, no async_hooks).
+- **this package** — the Node boundary: dive wiring + telemetry + the ALS
+  backbone (Node-only by design — dive stays engine-only for Deno/Bun,
+  ALS lives here where it is free).
+
+Framework wiring is layered on top, never inside: frameworks with their
+own DI container, pipes, interceptors and decorator lifecycles get a
+dedicated first-party adapter package in the `@mnemonica` org — that
+wiring is genuinely complicated and must be packaged and tested as such.
+For simple frameworks the recipes below are all you need.
+
+## Install
+
+```bash
+npm install @mnemonica/otel mnemonica @mnemonica/dive @opentelemetry/api
+```
+
+`mnemonica`, `@mnemonica/dive` and `@opentelemetry/api` are peer
+dependencies — they are process singletons (the type registry, the edge
+ring, the OTel API), so the app must own exactly one copy of each.
+
+Dual build: ESM (`import`) and CommonJS (`require`) both work. The CJS
+flavor loads `@mnemonica/dive` through `require(esm)`, so `require()`
+consumers need Node ≥ 20.19 / 22.
+
+## What's inside
+
+| Export | Role |
+|---|---|
+| `attachHooks(collection)` | wires a mnemonica TypesCollection to dive's lifecycle tracing (create edges + wrapped methods + context-carrying constructor args) |
+| `MnemonicaOtelProvider` | OTel spans for mnemonica constructions (pre/post/error), parented by lineage, ALS-propagated |
+| `DiveOtelProvider` | OTel spans for EVERY dive-wrapped call, parented on dive's own trace; async spans close at settle |
+| `AsyncFlowProvider` | the ALS backbone: attributes UNWRAPPED async hops (timers, promise continuations, generator suspensions) to the parental dive edge; pins context instances for the scope's lifetime |
+| `runInRequestScope(req, res, deps, fn)` | one OTel span per HTTP request + the triple async scope (provider ALS, OTEL global context, async-flow root frame) |
+| `feedPreRoot` / `feedValidatedPreRoot` / `getPreRoot` | thunderstruck pre-root store: request payloads correlated by OBJECT IDENTITY (WeakMap), retention = the request's lifetime |
+| `feedPreRootFromRequest(req, opts?)` | the boundary helper: shapes any framework's request into the pre-root feed |
+| `buildUnblindReport(error)` / `recordUnblindTelemetry(report, error)` | the Unblinder core: the dive branch + errored construction + attempted args, plus the unconditional span and stdout marker |
+| `isMnemonicaInstance(value)` | realm-safe type guard via `getProps()` |
+| `formatFlow(target?)` / `errorContext(error)` | read-side helpers over dive's trace |
+
+## Use it from your own boundary
+
+### Express
+
+```typescript
+import { runInRequestScope, feedPreRootFromRequest } from '@mnemonica/otel';
+
+app.use((req, res, next) => {
+  feedPreRootFromRequest(req);                 // thunderstruck boundary
+  runInRequestScope(req, res, { tracer, otel, asyncFlow }, () => next());
+});
+```
+
+### Fastify
+
+```typescript
+fastify.addHook('onRequest', (request, reply, done) => {
+  feedPreRootFromRequest(request);             // params/query/body/headers
+  runInRequestScope(request.raw, reply.raw, { tracer, otel, asyncFlow }, () => done());
+});
+```
+
+### Error boundary (any framework)
+
+```typescript
+import { buildUnblindReport, recordUnblindTelemetry } from '@mnemonica/otel';
+
+// Express error middleware / Fastify setErrorHandler / process handler:
+const report = buildUnblindReport(error);      // branch + errored type + args
+recordUnblindTelemetry(report, error);         // span + [unblind] stdout line
+if (!res.headersSent) res.status(500).json(report);
+```
+
+`report.kind` (`'caught-unblinded'`), the span name
+(`'mnemonica.caught-exception'`) and the `[unblind]` stdout marker are
+pinned by downstream consumers — keep them stable.
+
+### Non-HTTP scopes (queues, CLI, tests)
+
+```typescript
+import { AsyncFlowProvider } from '@mnemonica/otel';
+
+const asyncFlow = new AsyncFlowProvider();
+asyncFlow.attach();
+asyncFlow.runInScope(() => consume(message));  // root frame per job
+```
+
+## For AI agents
+
+The contributor contract — file map, invariants, the testing gate — lives
+in [`AGENTS.md`](./AGENTS.md).
+
+## License
+
+MIT

package/build/hooks/attach-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { TypesCollection } from 'mnemonica/module';
+export declare function attachHooks(collection: TypesCollection): void;
+//# sourceMappingURL=attach-hooks.d.ts.map

package/build/hooks/attach-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach-hooks.d.ts","sourceRoot":"","sources":["../../src/hooks/attach-hooks.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,wBAAgB,WAAW,CAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAsC9D"}

package/build/hooks/attach-hooks.js

@@ -0,0 +1,52 @@
+/**
+ * attachHooks — the mnemonica lifecycle wiring for @mnemonica/dive.
+ *
+ * This lived inside dive itself until dive became engine-only: dive imports
+ * nothing but node:crypto and exposes primitives (wrap, recordCreation, …);
+ * the knowledge of mnemonica's hook contract — hook names, hooksOpts fields,
+ * and what a ROOT construction is — belongs here at adapter level.
+ *
+ * preCreation  → enter the parent (existentInstance) context BEFORE the
+ *                constructor runs, and wrap any function arguments so
+ *                callbacks handed to the constructor carry that context.
+ * postCreation → record the instance's 'create' edge via recordCreation,
+ *                then wrap the instance's methods.
+ * creationError→ record a failed 'create' edge (status: 'error') under the
+ *                surviving parent and pin the error to it: the failure is
+ *                recoverable off the error object itself.
+ */
+import { enterContext, wrapConstructorArg, upgradeConstructorArg, wrapInstanceMethods, recordCreation, recordCreationError, isWrappedFunction, } from '@mnemonica/dive';
+export function attachHooks(collection) {
+    collection.registerHook('preCreation', (hookData) => {
+        const parent = hookData.existentInstance;
+        if (parent) {
+            enterContext(parent);
+        }
+        const args = hookData.args;
+        if (Array.isArray(args)) {
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                if (typeof arg === 'function' && !isWrappedFunction(arg)) {
+                    args[i] = wrapConstructorArg(arg, parent);
+                }
+            }
+        }
+    });
+    collection.registerHook('postCreation', (hookData) => {
+        const instance = hookData.inheritedInstance;
+        if (!instance) {
+            return;
+        }
+        if (Array.isArray(hookData.args)) {
+            for (const arg of hookData.args) {
+                upgradeConstructorArg(arg, instance);
+            }
+        }
+        recordCreation(hookData.TypeName || 'anonymous', instance, hookData.existentInstance);
+        wrapInstanceMethods(instance);
+    });
+    collection.registerHook('creationError', (hookData) => {
+        recordCreationError(hookData.TypeName || 'anonymous', hookData.inheritedInstance, hookData.existentInstance);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @mnemonica/otel — the framework-free Node.js core of the mnemonica
+ * observability stack.
+ *
+ * Everything here works in ANY Node.js runtime (Express, Fastify, raw
+ * http, queue consumers, CLI); framework wiring lives in dedicated
+ * adapter packages built on these primitives.
+ *
+ * Provides:
+ *   - attachHooks() — mnemonica lifecycle → dive edge wiring
+ *   - MnemonicaOtelProvider — OTel spans for constructions
+ *   - DiveOtelProvider — OTel spans for every dive-wrapped call
+ *   - AsyncFlowProvider — ALS backbone attributing unwrapped async hops
+ *   - runInRequestScope() — one request span + triple async scope
+ *   - feedPreRoot()/feedValidatedPreRoot()/getPreRoot() — thunderstruck
+ *     pre-root forensics store (identity-correlated, request-lifetime)
+ *   - feedPreRootFromRequest() — boundary helper over any HTTP request
+ *   - buildUnblindReport()/recordUnblindTelemetry() — the Unblinder core
+ *   - isMnemonicaInstance() — realm-safe type guard
+ *   - formatFlow()/errorContext() — read-side helpers over dive's trace
+ */
+export { attachHooks } from './hooks/attach-hooks.js';
+export { MnemonicaOtelProvider } from './providers/mnemonica-otel.provider.js';
+export { DiveOtelProvider } from './providers/dive-otel.provider.js';
+export { AsyncFlowProvider, type FlowFrame, type CrashContext } from './providers/async-flow.provider.js';
+export { runInRequestScope, type HttpRequestLike, type HttpResponseLike, type RequestScopeDeps } from './request-scope.js';
+export { feedPreRoot, feedValidatedPreRoot, getPreRoot, type RawPreRootPayload, type PreRootRecord, type PreRootData, } from './thunderstruck/pre-root.js';
+export { feedPreRootFromRequest, type RequestLike, type FeedPreRootOptions } from './thunderstruck/feed-from-request.js';
+export { buildUnblindReport, recordUnblindTelemetry, extractSafe, erroredArgsSafe, stringifySafe, type UnblindReport, } from './unblind.js';
+export { isMnemonicaInstance } from './utils/is-mnemonica-instance.js';
+export { formatFlow, errorContext, type FormattedFlowEdge } from './utils/dive-flow.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3H,OAAO,EACN,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,WAAW,GAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,KAAK,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AACzH,OAAO,EACN,kBAAkB,EAClB,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,aAAa,EACb,KAAK,aAAa,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/build/index.js

@@ -0,0 +1,32 @@
+/**
+ * @mnemonica/otel — the framework-free Node.js core of the mnemonica
+ * observability stack.
+ *
+ * Everything here works in ANY Node.js runtime (Express, Fastify, raw
+ * http, queue consumers, CLI); framework wiring lives in dedicated
+ * adapter packages built on these primitives.
+ *
+ * Provides:
+ *   - attachHooks() — mnemonica lifecycle → dive edge wiring
+ *   - MnemonicaOtelProvider — OTel spans for constructions
+ *   - DiveOtelProvider — OTel spans for every dive-wrapped call
+ *   - AsyncFlowProvider — ALS backbone attributing unwrapped async hops
+ *   - runInRequestScope() — one request span + triple async scope
+ *   - feedPreRoot()/feedValidatedPreRoot()/getPreRoot() — thunderstruck
+ *     pre-root forensics store (identity-correlated, request-lifetime)
+ *   - feedPreRootFromRequest() — boundary helper over any HTTP request
+ *   - buildUnblindReport()/recordUnblindTelemetry() — the Unblinder core
+ *   - isMnemonicaInstance() — realm-safe type guard
+ *   - formatFlow()/errorContext() — read-side helpers over dive's trace
+ */
+export { attachHooks } from './hooks/attach-hooks.js';
+export { MnemonicaOtelProvider } from './providers/mnemonica-otel.provider.js';
+export { DiveOtelProvider } from './providers/dive-otel.provider.js';
+export { AsyncFlowProvider } from './providers/async-flow.provider.js';
+export { runInRequestScope } from './request-scope.js';
+export { feedPreRoot, feedValidatedPreRoot, getPreRoot, } from './thunderstruck/pre-root.js';
+export { feedPreRootFromRequest } from './thunderstruck/feed-from-request.js';
+export { buildUnblindReport, recordUnblindTelemetry, extractSafe, erroredArgsSafe, stringifySafe, } from './unblind.js';
+export { isMnemonicaInstance } from './utils/is-mnemonica-instance.js';
+export { formatFlow, errorContext } from './utils/dive-flow.js';
+//# sourceMappingURL=data:application/json;base64,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

package/build/providers/async-flow.provider.d.ts

@@ -0,0 +1,40 @@
+export type FlowFrame = {
+    /** the dive edge this frame belongs to (null on the root frame) */
+    edgeId: number | null;
+    /** the frame active when this one was entered */
+    parent: FlowFrame | null;
+    /** strong pins of context instances — ONE set per scope, shared down
+     *  the chain by reference; dies with the scope's async executions */
+    pinSet: Set<object>;
+};
+/** Read-only crash-time view of the active frame. */
+export type CrashContext = {
+    edgeId: number | null;
+    instances: object[];
+};
+export declare class AsyncFlowProvider {
+    private frames;
+    private detachers;
+    /**
+     * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would
+     * double every frame push. Dive's clear() wipes subscribers — re-attach
+     * after it.
+     */
+    attach(): void;
+    detach(): void;
+    /**
+     * Establish a root frame for non-HTTP scopes (queue consumers, CLI,
+     * tests). The middleware is the HTTP root.
+     */
+    runInScope<T>(fn: () => T): T;
+    /**
+     * The frame active RIGHT NOW — in an uncaughtException handler this is
+     * the failing execution's frame: the parental edge id plus every
+     * context instance pinned by the scope. Undefined outside any scope.
+     */
+    currentFrame(): CrashContext | undefined;
+    private onEnter;
+    private onLeave;
+    private onCreate;
+}
+//# sourceMappingURL=async-flow.provider.d.ts.map

package/build/providers/async-flow.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-flow.provider.d.ts","sourceRoot":"","sources":["../../src/providers/async-flow.provider.ts"],"names":[],"mappings":"AA8BA,MAAM,MAAM,SAAS,GAAG;IACvB,mEAAmE;IACnE,MAAM,EAAK,MAAM,GAAG,IAAI,CAAC;IACzB,iDAAiD;IACjD,MAAM,EAAK,SAAS,GAAG,IAAI,CAAC;IAC5B;yEACqE;IACrE,MAAM,EAAK,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,YAAY,GAAG;IAC1B,MAAM,EAAM,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAG,MAAM,EAAE,CAAC;CACrB,CAAC;AAIF,qBAAa,iBAAiB;IAE7B,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,SAAS,CAAyB;IAE1C;;;;OAIG;IACH,MAAM,IAAK,IAAI;IAwBf,MAAM,IAAK,IAAI;IAQf;;;OAGG;IACH,UAAU,CAAC,CAAC,EAAG,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAU9B;;;;OAIG;IACH,YAAY,IAAK,YAAY,GAAG,SAAS;IAYzC,OAAO,CAAC,OAAO;IAiBf,OAAO,CAAC,OAAO;IAWf,OAAO,CAAC,QAAQ;CAWhB"}

package/build/providers/async-flow.provider.js

@@ -0,0 +1,128 @@
+/**
+ * Async-flow provider — the ALS backbone for dive attribution.
+ *
+ * Design: reports/async-flow-tracking-design.md (2026-09-02).
+ *
+ * One AsyncLocalStorage carrying a linked list of FlowFrames. The root
+ * frame is created per HTTP request by MnemonicaTraceMiddleware (or
+ * manually via runInScope). Every dive 'enter' hook pushes a child frame
+ * (edgeId = the entering edge); 'leave' restores the parent. ALS
+ * propagation then does the tracking for free: an UNWRAPPED async hop
+ * (setTimeout, promise continuation, async-generator suspension) fires
+ * with the scheduling frame in als.getStore() — the parental dive edge
+ * is known without wrapping anything.
+ *
+ * The scoped pin: the root frame owns a pinSet of context instances
+ * (strong refs), filled on enter/create from edge.instance. Lifetime is
+ * the request's async executions — when they die, the store and pinSet
+ * die with them. edge.instance never derefs to undefined mid-request.
+ *
+ * Node-only by design: dive imports no async_hooks (Deno/Bun), the
+ * adapter is the Node boundary where ALS is free.
+ */
+import { AsyncLocalStorage } from 'async_hooks';
+import { registerHook } from '@mnemonica/dive';
+const als = new AsyncLocalStorage();
+export class AsyncFlowProvider {
+    // edgeId → the frame entered for it, so leave restores the exact parent
+    frames = new Map();
+    detachers = [];
+    /**
+     * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would
+     * double every frame push. Dive's clear() wipes subscribers — re-attach
+     * after it.
+     */
+    attach() {
+        if (this.detachers.length > 0) {
+            return;
+        }
+        this.detachers.push(registerHook('enter', (payload) => {
+            this.onEnter(payload);
+        }), registerHook('leave', (payload) => {
+            this.onLeave(payload);
+        }));
+        try {
+            this.detachers.push(registerHook('create', (payload) => {
+                this.onCreate(payload);
+            }));
+        }
+        catch {
+            // 'create' exists since dive 0.8.0; on 0.7.x registerHook throws —
+            // skipping preserves exactly the pre-subscription behavior.
+        }
+    }
+    detach() {
+        for (const detach of this.detachers) {
+            detach();
+        }
+        this.detachers = [];
+        this.frames.clear();
+    }
+    /**
+     * Establish a root frame for non-HTTP scopes (queue consumers, CLI,
+     * tests). The middleware is the HTTP root.
+     */
+    runInScope(fn) {
+        const root = {
+            edgeId: null,
+            parent: null,
+            pinSet: new Set(),
+        };
+        const result = als.run(root, fn);
+        return result;
+    }
+    /**
+     * The frame active RIGHT NOW — in an uncaughtException handler this is
+     * the failing execution's frame: the parental edge id plus every
+     * context instance pinned by the scope. Undefined outside any scope.
+     */
+    currentFrame() {
+        const frame = als.getStore();
+        if (!frame) {
+            return undefined;
+        }
+        const result = {
+            edgeId: frame.edgeId,
+            instances: [...frame.pinSet],
+        };
+        return result;
+    }
+    onEnter({ edge }) {
+        const current = als.getStore();
+        if (!current) {
+            return;
+        }
+        const frame = {
+            edgeId: edge.id,
+            parent: current,
+            pinSet: current.pinSet,
+        };
+        if (edge.instance !== undefined) {
+            frame.pinSet.add(edge.instance);
+        }
+        this.frames.set(edge.id, frame);
+        als.enterWith(frame);
+    }
+    onLeave({ edge }) {
+        const frame = this.frames.get(edge.id);
+        if (!frame) {
+            return;
+        }
+        this.frames.delete(edge.id);
+        if (frame.parent) {
+            als.enterWith(frame.parent);
+        }
+    }
+    onCreate({ edge }) {
+        const current = als.getStore();
+        if (!current) {
+            return;
+        }
+        // Constructions are one-shot edges (no leave) — no frame of their
+        // own, but the constructed instance is DATA: pin it into the scope.
+        if (edge.instance !== undefined) {
+            current.pinSet.add(edge.instance);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-flow.provider.js","sourceRoot":"","sources":["../../src/providers/async-flow.provider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Async-flow provider — the ALS backbone for dive attribution.\n *\n * Design: reports/async-flow-tracking-design.md (2026-09-02).\n *\n * One AsyncLocalStorage carrying a linked list of FlowFrames. The root\n * frame is created per HTTP request by MnemonicaTraceMiddleware (or\n * manually via runInScope). Every dive 'enter' hook pushes a child frame\n * (edgeId = the entering edge); 'leave' restores the parent. ALS\n * propagation then does the tracking for free: an UNWRAPPED async hop\n * (setTimeout, promise continuation, async-generator suspension) fires\n * with the scheduling frame in als.getStore() — the parental dive edge\n * is known without wrapping anything.\n *\n * The scoped pin: the root frame owns a pinSet of context instances\n * (strong refs), filled on enter/create from edge.instance. Lifetime is\n * the request's async executions — when they die, the store and pinSet\n * die with them. edge.instance never derefs to undefined mid-request.\n *\n * Node-only by design: dive imports no async_hooks (Deno/Bun), the\n * adapter is the Node boundary where ALS is free.\n */\nimport { AsyncLocalStorage } from 'async_hooks';\nimport { registerHook } from '@mnemonica/dive';\nimport type {\n\tDiveCreatePayload,\n\tDiveEnterPayload,\n\tDiveLeavePayload,\n} from '@mnemonica/dive';\n\nexport type FlowFrame = {\n\t/** the dive edge this frame belongs to (null on the root frame) */\n\tedgeId   : number | null;\n\t/** the frame active when this one was entered */\n\tparent   : FlowFrame | null;\n\t/** strong pins of context instances — ONE set per scope, shared down\n\t *  the chain by reference; dies with the scope's async executions */\n\tpinSet   : Set<object>;\n};\n\n/** Read-only crash-time view of the active frame. */\nexport type CrashContext = {\n\tedgeId    : number | null;\n\tinstances : object[];\n};\n\nconst als = new AsyncLocalStorage<FlowFrame>();\n\nexport class AsyncFlowProvider {\n\t// edgeId → the frame entered for it, so leave restores the exact parent\n\tprivate frames = new Map<number, FlowFrame>();\n\tprivate detachers: Array<() => void> = [];\n\n\t/**\n\t * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would\n\t * double every frame push. Dive's clear() wipes subscribers — re-attach\n\t * after it.\n\t */\n\tattach (): void {\n\t\tif (this.detachers.length > 0) {\n\t\t\treturn;\n\t\t}\n\t\tthis.detachers.push(\n\t\t\tregisterHook('enter', (payload) => {\n\t\t\t\tthis.onEnter(payload);\n\t\t\t}),\n\t\t\tregisterHook('leave', (payload) => {\n\t\t\t\tthis.onLeave(payload);\n\t\t\t}),\n\t\t);\n\t\ttry {\n\t\t\tthis.detachers.push(\n\t\t\t\tregisterHook('create', (payload) => {\n\t\t\t\t\tthis.onCreate(payload);\n\t\t\t\t}),\n\t\t\t);\n\t\t} catch {\n\t\t\t// 'create' exists since dive 0.8.0; on 0.7.x registerHook throws —\n\t\t\t// skipping preserves exactly the pre-subscription behavior.\n\t\t}\n\t}\n\n\tdetach (): void {\n\t\tfor (const detach of this.detachers) {\n\t\t\tdetach();\n\t\t}\n\t\tthis.detachers = [];\n\t\tthis.frames.clear();\n\t}\n\n\t/**\n\t * Establish a root frame for non-HTTP scopes (queue consumers, CLI,\n\t * tests). The middleware is the HTTP root.\n\t */\n\trunInScope<T> (fn: () => T): T {\n\t\tconst root: FlowFrame = {\n\t\t\tedgeId : null,\n\t\t\tparent : null,\n\t\t\tpinSet : new Set<object>(),\n\t\t};\n\t\tconst result = als.run(root, fn);\n\t\treturn result;\n\t}\n\n\t/**\n\t * The frame active RIGHT NOW — in an uncaughtException handler this is\n\t * the failing execution's frame: the parental edge id plus every\n\t * context instance pinned by the scope. Undefined outside any scope.\n\t */\n\tcurrentFrame (): CrashContext | undefined {\n\t\tconst frame = als.getStore();\n\t\tif (!frame) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst result: CrashContext = {\n\t\t\tedgeId    : frame.edgeId,\n\t\t\tinstances : [...frame.pinSet],\n\t\t};\n\t\treturn result;\n\t}\n\n\tprivate onEnter ({ edge }: DiveEnterPayload): void {\n\t\tconst current = als.getStore();\n\t\tif (!current) {\n\t\t\treturn;\n\t\t}\n\t\tconst frame: FlowFrame = {\n\t\t\tedgeId : edge.id,\n\t\t\tparent : current,\n\t\t\tpinSet : current.pinSet,\n\t\t};\n\t\tif (edge.instance !== undefined) {\n\t\t\tframe.pinSet.add(edge.instance);\n\t\t}\n\t\tthis.frames.set(edge.id, frame);\n\t\tals.enterWith(frame);\n\t}\n\n\tprivate onLeave ({ edge }: DiveLeavePayload): void {\n\t\tconst frame = this.frames.get(edge.id);\n\t\tif (!frame) {\n\t\t\treturn;\n\t\t}\n\t\tthis.frames.delete(edge.id);\n\t\tif (frame.parent) {\n\t\t\tals.enterWith(frame.parent);\n\t\t}\n\t}\n\n\tprivate onCreate ({ edge }: DiveCreatePayload): void {\n\t\tconst current = als.getStore();\n\t\tif (!current) {\n\t\t\treturn;\n\t\t}\n\t\t// Constructions are one-shot edges (no leave) — no frame of their\n\t\t// own, but the constructed instance is DATA: pin it into the scope.\n\t\tif (edge.instance !== undefined) {\n\t\t\tcurrent.pinSet.add(edge.instance);\n\t\t}\n\t}\n}\n"]}

package/build/providers/dive-otel.provider.d.ts

@@ -0,0 +1,51 @@
+/**
+ * OpenTelemetry provider for dive's edge lifecycle hooks.
+ *
+ * Where MnemonicaOtelProvider spans CONSTRUCTIONS (mnemonica hooks), this
+ * provider spans EVERY WRAPPED CALL (dive hooks): call / construct / method /
+ * recontext edges each become a span, parented on the span of the edge's
+ * parentId — dive's own trace parentage, not ALS. At unwrapped boundaries
+ * (parentId null) the span adopts the currently ACTIVE OTel span as parent,
+ * so an
+ * HTTP request span adopts the whole dive branch. 'create' edges (mnemonica
+ * constructions recorded via recordCreation/recordCreationError) become
+ * one-shot spans on the same parentage — the construction HAS completed when
+ * the hook fires, so the span starts and ends inside the handler.
+ *
+ * Async truthfulness: a span does NOT end at the sync close when the wrap
+ * produced a tapped promise — it ends at settle, with the chain's outcome.
+ * Spans are keyed on edge id; every recorded edge fires leave (and, when
+ * async, settle), so the map always drains.
+ */
+import type { Tracer } from '@opentelemetry/api';
+export declare class DiveOtelProvider {
+    private tracer;
+    private spans;
+    private edgeParents;
+    private static readonly EDGE_PARENTS_LIMIT;
+    private detachers;
+    constructor(tracer?: Tracer);
+    /**
+     * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would
+     * double every span. Dive's clear() wipes subscribers — re-attach after it.
+     */
+    attach(): void;
+    detach(): void;
+    private onEnter;
+    private onLeave;
+    private onSettle;
+    private onRecontext;
+    private onCreate;
+    private findParentSpan;
+    private closeSpan;
+    /**
+     * Cross-surface attributes every span gets, on every hook path:
+     * the edge's trace root id (Jaeger link → mnemographica's Live Trace,
+     * Wanted #1), the edgeId→traceId publication for the strategy push
+     * channel (Wanted #2), and code.filepath/line/column parsed from the
+     * callsite name (Wanted #4).
+     */
+    private decorateSpan;
+    private rootEdgeIdOf;
+}
+//# sourceMappingURL=dive-otel.provider.d.ts.map

package/build/providers/dive-otel.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dive-otel.provider.d.ts","sourceRoot":"","sources":["../../src/providers/dive-otel.provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAQ,MAAM,EAAE,MAAM,oBAAoB,CAAC;AA+CvD,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,KAAK,CAA2B;IAKxC,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IACnD,OAAO,CAAC,SAAS,CAAyB;gBAE7B,MAAM,CAAC,EAAE,MAAM;IAI5B;;;OAGG;IACH,MAAM,IAAK,IAAI;IAgCf,MAAM,IAAK,IAAI;IAOf,OAAO,CAAC,OAAO;IAkBf,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAuBnB,OAAO,CAAC,QAAQ;IAiChB,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,SAAS;IAuBjB;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,YAAY;CAgBpB"}