@mnemonica/otel 0.1.0

package/build-cjs/thunderstruck/feed-from-request.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedPreRootFromRequest = feedPreRootFromRequest;
+/**
+ * Thunderstruck boundary helper — the framework-free half of what a
+ * framework's interceptor/middleware does: shape any HTTP framework's
+ * request into the
+ * raw pre-root payload and stamp its part objects, so pipes and construct
+ * handlers correlate the payload by OBJECT IDENTITY (see pre-root.ts for
+ * the store's lifetime and correlation semantics).
+ *
+ * Framework mapping notes:
+ *  - Express: pass `req` directly — method/url/params(→req.params)/
+ *    query/body/headers all sit on it.
+ *  - Fastify: pass the FastifyRequest — it exposes params/query/body/
+ *    headers; `method`/`url` exist on it since Fastify v4 (fall back to
+ *    `req.raw` if you target older majors).
+ *  - raw http: `url`/`method` are on IncomingMessage; body/query/params
+ *    are yours to parse first (or omit — primitives and missing parts
+ *    simply don't correlate, the feed still records).
+ */
+const pre_root_js_1 = require("./pre-root.js");
+function feedPreRootFromRequest(req, options) {
+    const raw = {
+        method: req.method,
+        url: req.url,
+        params: req.params,
+        query: req.query,
+        body: req.body,
+        headers: req.headers,
+    };
+    if (options?.storeRequest === true) {
+        raw.request = req;
+    }
+    (0, pre_root_js_1.feedPreRoot)(raw);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build-cjs/thunderstruck/pre-root.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Thunderstruck pre-root correlation store (adapter side).
+ *
+ * The correlation key is OBJECT IDENTITY: the very body / query / params
+ * object the interceptor saw at the boundary is the same reference pipes and
+ * construct handlers receive later. A WeakMap<object, payloads> therefore
+ * correlates without AsyncLocalStorage and without races — concurrent
+ * requests can never read each other's payloads because each holds only its
+ * own objects.
+ *
+ * The payloads live INSIDE the WeakMap record: there is no other store and
+ * no release step. When the request objects are garbage-collected, the
+ * payloads go with them — retention is exactly the request's lifetime.
+ * Dive stays free of framework-specifics and of storage entirely: it is
+ * the tracing engine, not a warehouse.
+ *
+ * The optional `request` link (RawPreRootPayload.request) puts the raw
+ * request object inside its own record and stamps it as a key too, so
+ * getPreRoot(req) resolves from anywhere the request is reachable. The
+ * WeakMap's ephemeron semantics keep this value→key cycle collectable:
+ * retention stays exactly the request's lifetime.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedPreRoot = feedPreRoot;
+exports.feedValidatedPreRoot = feedValidatedPreRoot;
+exports.getPreRoot = getPreRoot;
+function isObjectKey(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+const preRootRecords = new WeakMap();
+/**
+ * Stash the raw boundary payload and stamp every request-part object
+ * (params / query / body / headers / request) so later stages correlate
+ * by the object they already hold. Primitive bodies are not correlatable —
+ * they are still inside the raw payload, just not resolvable via
+ * getPreRoot.
+ */
+function feedPreRoot(raw) {
+    const record = { raw };
+    for (const part of [raw.params, raw.query, raw.body, raw.headers, raw.request]) {
+        if (isObjectKey(part)) {
+            preRootRecords.set(part, record);
+        }
+    }
+}
+/**
+ * Attach the validated DTO to the record of the boundary object it came
+ * from. Called by MnemonicaValidationPipe after class-validator passes.
+ * No-op when the object was never stamped (the interceptor is not active).
+ */
+function feedValidatedPreRoot(forValue, validated) {
+    if (!isObjectKey(forValue)) {
+        return;
+    }
+    const record = preRootRecords.get(forValue);
+    if (!record) {
+        return;
+    }
+    record.validated = validated;
+}
+/**
+ * Resolve the pre-root payloads for a boundary object — the same body /
+ * query / params reference the interceptor stamped. Payloads live as long
+ * as the request objects do (WeakMap), so this resolves during construction
+ * AND afterwards — e.g. from an exception filter reporting which data
+ * caused the failure.
+ */
+function getPreRoot(value) {
+    if (!isObjectKey(value)) {
+        return undefined;
+    }
+    const record = preRootRecords.get(value);
+    if (!record) {
+        return undefined;
+    }
+    const result = {
+        raw: record.raw,
+        validated: record.validated,
+    };
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build-cjs/unblind.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSafe = extractSafe;
+exports.erroredArgsSafe = erroredArgsSafe;
+exports.stringifySafe = stringifySafe;
+exports.buildUnblindReport = buildUnblindReport;
+exports.recordUnblindTelemetry = recordUnblindTelemetry;
+/**
+ * The Unblinder core (2026-09-03, Viktor) — framework-free error-boundary
+ * reporting: build the report from dive's trace + core's getProps, then
+ * record the telemetry. The framework wrapper owns the body discipline
+ * (status code, the headers-sent check, expected-client-error passthrough);
+ * this core owns the report and the UNCONDITIONAL telemetry.
+ *
+ * CONTRACT: report.kind ('caught-unblinded'), the span name
+ * ('mnemonica.caught-exception') and the [unblind] stdout marker are
+ * pinned by downstream consumers (runbooks grep the marker; framework
+ * adapters pin the report shape). Keep them stable.
+ */
+const dive_1 = require("@mnemonica/dive");
+const mnemonica_1 = require("mnemonica");
+const api_1 = require("@opentelemetry/api");
+/**
+ * extract() that cannot throw inside an error path — non-mnemonica
+ * values degrade to their key list.
+ */
+function extractSafe(instance) {
+    try {
+        const result = mnemonica_1.utils.extract(instance);
+        return result;
+    }
+    catch {
+        const result = Object.keys(instance);
+        return result;
+    }
+}
+/**
+ * The attempted constructor args of a FAILED mnemonica construction ride
+ * the errored instance itself: the caught object IS the errored shell
+ * (probed 2026-09-03: caught === creationError's inheritedInstance,
+ * instanceof Error via the spliced prototype chain), and core's own
+ * getProps exposes { args, originalError, … } off the props WeakMap.
+ * Plain errors yield undefined; anything unexpected degrades, never
+ * throws inside a filter.
+ */
+function erroredArgsSafe(error) {
+    try {
+        const props = (0, mnemonica_1.getProps)(error);
+        const result = props?.args;
+        return result;
+    }
+    catch {
+        const result = undefined;
+        return result;
+    }
+}
+/**
+ * JSON.stringify that cannot throw inside an error path — circular or
+ * hostile values degrade to a marker instead of crashing the boundary
+ * (a throwing boundary is exactly the cascade this fights).
+ */
+function stringifySafe(value) {
+    try {
+        const result = JSON.stringify(value);
+        return result;
+    }
+    catch {
+        const result = '"[unserializable report payload]"';
+        return result;
+    }
+}
+/**
+ * Build the unblinded report for a caught failure: the dive branch, the
+ * errored construction edge, the attempted constructor args, the actual
+ * message. Non-Error throws are reported truthfully as such, never
+ * dressed up as Errors.
+ */
+function buildUnblindReport(error) {
+    const isError = error instanceof Error;
+    const message = isError ? error.message : `non-Error thrown (${typeof error})`;
+    const flow = isError ? (0, dive_1.getFlow)(error) : [];
+    // The errored create edge attributes the construction's PARENT
+    // instance (probed 2026-09-03: edge.instance === existentInstance).
+    // The attempted constructor ARGS ride the caught error itself — it
+    // IS the errored shell, and getProps exposes its args (see
+    // erroredArgsSafe above).
+    const erroredEdge = [...flow].reverse().find((edge) => edge.kind === 'create' && edge.status === 'error');
+    const erroredInstance = erroredEdge?.instance;
+    const attemptedArgs = isError ? erroredArgsSafe(error) : undefined;
+    const report = {
+        kind: 'caught-unblinded',
+        message,
+        branch: flow.map((edge) => `${edge.kind}:${edge.name}`),
+        erroredType: erroredEdge?.name ?? null,
+        erroredInstance: erroredInstance ? extractSafe(erroredInstance) : null,
+        attemptedArgs: attemptedArgs ?? null,
+    };
+    return report;
+}
+/**
+ * The unconditional half: an ERROR span with the recorded exception + the
+ * dive branch — inside the request's async context, so the ALS context
+ * manager parents it under the request span on its own — and the stdout
+ * marker line. A non-Error throw is recorded as an attribute:
+ * recordException on a circular object could break exporter
+ * serialization.
+ */
+function recordUnblindTelemetry(report, error) {
+    const span = api_1.trace.getTracer('@mnemonica/otel').startSpan('mnemonica.caught-exception');
+    span.setAttribute('dive.branch', report.branch.join(' → '));
+    if (report.erroredType) {
+        span.setAttribute('mnemonica.errored_type', report.erroredType);
+    }
+    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: report.message });
+    if (error instanceof Error) {
+        span.recordException(error);
+    }
+    else {
+        span.setAttribute('exception.type', 'non-Error-throw');
+    }
+    span.end();
+    // The [unblind] prefix is a downstream contract — runbooks grep for
+    // exactly this marker.
+    // eslint-disable-next-line no-console
+    console.log(`[unblind] ${stringifySafe(report)}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unblind.js","sourceRoot":"","sources":["../src/unblind.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Unblinder core (2026-09-03, Viktor) — framework-free error-boundary\n * reporting: build the report from dive's trace + core's getProps, then\n * record the telemetry. The framework wrapper owns the body discipline\n * (status code, the headers-sent check, expected-client-error passthrough);\n * this core owns the report and the UNCONDITIONAL telemetry.\n *\n * CONTRACT: report.kind ('caught-unblinded'), the span name\n * ('mnemonica.caught-exception') and the [unblind] stdout marker are\n * pinned by downstream consumers (runbooks grep the marker; framework\n * adapters pin the report shape). Keep them stable.\n */\nimport { getFlow } from '@mnemonica/dive';\nimport { utils, getProps } from 'mnemonica';\nimport { trace, SpanStatusCode } from '@opentelemetry/api';\n\nexport interface UnblindReport {\n\tkind            : string;\n\tmessage         : string;\n\tbranch          : string[];\n\terroredType     : string | null;\n\terroredInstance : unknown;\n\tattemptedArgs   : unknown;\n}\n\n/**\n * extract() that cannot throw inside an error path — non-mnemonica\n * values degrade to their key list.\n */\nexport function extractSafe (instance: object): unknown {\n\ttry {\n\t\tconst result = utils.extract(instance);\n\t\treturn result;\n\t} catch {\n\t\tconst result = Object.keys(instance);\n\t\treturn result;\n\t}\n}\n\n/**\n * The attempted constructor args of a FAILED mnemonica construction ride\n * the errored instance itself: the caught object IS the errored shell\n * (probed 2026-09-03: caught === creationError's inheritedInstance,\n * instanceof Error via the spliced prototype chain), and core's own\n * getProps exposes { args, originalError, … } off the props WeakMap.\n * Plain errors yield undefined; anything unexpected degrades, never\n * throws inside a filter.\n */\nexport function erroredArgsSafe (error: Error): unknown {\n\ttry {\n\t\tconst props = getProps(error) as { args?: unknown } | undefined;\n\t\tconst result = props?.args;\n\t\treturn result;\n\t} catch {\n\t\tconst result = undefined;\n\t\treturn result;\n\t}\n}\n\n/**\n * JSON.stringify that cannot throw inside an error path — circular or\n * hostile values degrade to a marker instead of crashing the boundary\n * (a throwing boundary is exactly the cascade this fights).\n */\nexport function stringifySafe (value: unknown): string {\n\ttry {\n\t\tconst result = JSON.stringify(value);\n\t\treturn result;\n\t} catch {\n\t\tconst result = '\"[unserializable report payload]\"';\n\t\treturn result;\n\t}\n}\n\n/**\n * Build the unblinded report for a caught failure: the dive branch, the\n * errored construction edge, the attempted constructor args, the actual\n * message. Non-Error throws are reported truthfully as such, never\n * dressed up as Errors.\n */\nexport function buildUnblindReport (error: unknown): UnblindReport {\n\tconst isError = error instanceof Error;\n\tconst message = isError ? error.message : `non-Error thrown (${typeof error})`;\n\tconst flow = isError ? getFlow(error as Error) : [];\n\t// The errored create edge attributes the construction's PARENT\n\t// instance (probed 2026-09-03: edge.instance === existentInstance).\n\t// The attempted constructor ARGS ride the caught error itself — it\n\t// IS the errored shell, and getProps exposes its args (see\n\t// erroredArgsSafe above).\n\tconst erroredEdge = [...flow].reverse().find((edge) => edge.kind === 'create' && edge.status === 'error');\n\tconst erroredInstance = erroredEdge?.instance;\n\tconst attemptedArgs = isError ? erroredArgsSafe(error as Error) : undefined;\n\tconst report: UnblindReport = {\n\t\tkind            : 'caught-unblinded',\n\t\tmessage,\n\t\tbranch          : flow.map((edge) => `${edge.kind}:${edge.name}`),\n\t\terroredType     : erroredEdge?.name ?? null,\n\t\terroredInstance : erroredInstance ? extractSafe(erroredInstance) : null,\n\t\tattemptedArgs   : attemptedArgs ?? null,\n\t};\n\treturn report;\n}\n\n/**\n * The unconditional half: an ERROR span with the recorded exception + the\n * dive branch — inside the request's async context, so the ALS context\n * manager parents it under the request span on its own — and the stdout\n * marker line. A non-Error throw is recorded as an attribute:\n * recordException on a circular object could break exporter\n * serialization.\n */\nexport function recordUnblindTelemetry (report: UnblindReport, error: unknown): void {\n\tconst span = trace.getTracer('@mnemonica/otel').startSpan('mnemonica.caught-exception');\n\tspan.setAttribute('dive.branch', report.branch.join(' → '));\n\tif (report.erroredType) {\n\t\tspan.setAttribute('mnemonica.errored_type', report.erroredType);\n\t}\n\tspan.setStatus({ code: SpanStatusCode.ERROR, message: report.message });\n\tif (error instanceof Error) {\n\t\tspan.recordException(error);\n\t} else {\n\t\tspan.setAttribute('exception.type', 'non-Error-throw');\n\t}\n\tspan.end();\n\n\t// The [unblind] prefix is a downstream contract — runbooks grep for\n\t// exactly this marker.\n\t// eslint-disable-next-line no-console\n\tconsole.log(`[unblind] ${stringifySafe(report)}`);\n}\n"]}

package/build-cjs/utils/dive-flow.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFlow = formatFlow;
+exports.errorContext = errorContext;
+/**
+ * Read-side helpers over @mnemonica/dive's trace — the two idioms error
+ * boundaries kept re-deriving by hand (four formatter copies and two
+ * fallback copies in finecut before these existed).
+ */
+const dive_1 = require("@mnemonica/dive");
+/**
+ * Canonical edge → plain-JSON shaping for reports, filters and logs.
+ * Same target semantics as getFlow: Error | instance | current cursor.
+ */
+function formatFlow(target) {
+    const result = (0, dive_1.getFlow)(target).map((edge) => {
+        const formatted = {
+            name: edge.name,
+            kind: edge.kind,
+            status: edge.status,
+            duration: edge.duration ?? null,
+        };
+        return formatted;
+    });
+    return result;
+}
+/**
+ * The "who failed" fallback: the instance pinned to the error at its
+ * deepest wrapped boundary, or the current ambient context when the error
+ * never crossed one.
+ */
+function errorContext(error) {
+    const pinned = (0, dive_1.getErrorInstance)(error);
+    const result = pinned ?? (0, dive_1.current)();
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build-cjs/utils/is-mnemonica-instance.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMnemonicaInstance = isMnemonicaInstance;
+/**
+ * Runtime type guard for mnemonica instances.
+ * Uses mnemonica's getProps() — no instanceof hacks, works across realms.
+ */
+const module_1 = require("mnemonica/module");
+function isMnemonicaInstance(value) {
+    return value != null && typeof value === 'object' && (0, module_1.getProps)(value) !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbW5lbW9uaWNhLWluc3RhbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2lzLW1uZW1vbmljYS1pbnN0YW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLGtEQUVDO0FBUkQ7OztHQUdHO0FBQ0gsNkNBQTRDO0FBRTVDLFNBQWdCLG1CQUFtQixDQUFFLEtBQWM7SUFDbEQsT0FBTyxLQUFLLElBQUksSUFBSSxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxJQUFBLGlCQUFRLEVBQUMsS0FBSyxDQUFDLEtBQUssU0FBUyxDQUFDO0FBQ3BGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJ1bnRpbWUgdHlwZSBndWFyZCBmb3IgbW5lbW9uaWNhIGluc3RhbmNlcy5cbiAqIFVzZXMgbW5lbW9uaWNhJ3MgZ2V0UHJvcHMoKSDigJQgbm8gaW5zdGFuY2VvZiBoYWNrcywgd29ya3MgYWNyb3NzIHJlYWxtcy5cbiAqL1xuaW1wb3J0IHsgZ2V0UHJvcHMgfSBmcm9tICdtbmVtb25pY2EvbW9kdWxlJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzTW5lbW9uaWNhSW5zdGFuY2UgKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4ge1xuXHRyZXR1cm4gdmFsdWUgIT0gbnVsbCAmJiB0eXBlb2YgdmFsdWUgPT09ICdvYmplY3QnICYmIGdldFByb3BzKHZhbHVlKSAhPT0gdW5kZWZpbmVkO1xufVxuIl19

package/package.json

@@ -0,0 +1,69 @@
+{
+	"name": "@mnemonica/otel",
+	"version": "0.1.0",
+	"description": "Framework-free Node.js core of the mnemonica observability stack — dive hook wiring, OpenTelemetry providers, ALS async-flow tracking, thunderstruck pre-root forensics, unblind error reports",
+	"type": "module",
+	"main": "./build/index.js",
+	"types": "./build/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./build/index.d.ts",
+			"require": "./build-cjs/index.js",
+			"default": "./build/index.js"
+		}
+	},
+	"files": [
+		"build/",
+		"build-cjs/",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc && tsc -p tsconfig.cjs.json && node scripts/write-cjs-marker.js",
+		"build:watch": "tsc --watch",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"prepublishOnly": "npm run build && npm test && node scripts/assert-clean-build.js"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"@mnemonica/dive": "^0.7.0 || ^0.8.0",
+		"@opentelemetry/api": "^1.0.0",
+		"mnemonica": ">=1.2.7"
+	},
+	"devDependencies": {
+		"@mnemonica/dive": "^0.8.1",
+		"@opentelemetry/api": "^1.9.1",
+		"@opentelemetry/sdk-trace-node": "^1.30.1",
+		"@types/node": "^20.19.43",
+		"mnemonica": "^1.2.8",
+		"typescript": "^5.9.3",
+		"vitest": "^2.1.9"
+	},
+	"dependencies": {
+		"@mnemonica/dive": "^0.7.0 || ^0.8.0"
+	},
+	"keywords": [
+		"mnemonica",
+		"dive",
+		"opentelemetry",
+		"tracing",
+		"observability",
+		"async-local-storage",
+		"express",
+		"fastify",
+		"nodejs"
+	],
+	"author": "went.out@gmail.com",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/mythographica/otel.git"
+	},
+	"bugs": {
+		"url": "https://github.com/mythographica/otel/issues"
+	},
+	"homepage": "https://github.com/mythographica/otel#readme"
+}