@mnemonica/otel 0.1.0

package/build/thunderstruck/pre-root.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+export interface RawPreRootPayload {
+    method: string;
+    url: string;
+    params?: unknown;
+    query?: unknown;
+    body?: unknown;
+    headers?: unknown;
+    /**
+     * Optional link to the raw request object (storeRequest flag). When
+     * present it is stamped as a correlation key too, so getPreRoot(req)
+     * resolves — e.g. from an exception filter holding only the request.
+     */
+    request?: unknown;
+}
+export interface PreRootRecord {
+    raw: unknown;
+    validated?: unknown;
+}
+export interface PreRootData {
+    raw?: unknown;
+    validated?: unknown;
+}
+/**
+ * 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.
+ */
+export declare function feedPreRoot(raw: RawPreRootPayload): void;
+/**
+ * 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).
+ */
+export declare function feedValidatedPreRoot(forValue: unknown, validated: unknown): void;
+/**
+ * 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.
+ */
+export declare function getPreRoot(value: unknown): PreRootData | undefined;
+//# sourceMappingURL=pre-root.d.ts.map

package/build/thunderstruck/pre-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-root.d.ts","sourceRoot":"","sources":["../../src/thunderstruck/pre-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAI,MAAM,CAAC;IACjB,GAAG,EAAO,MAAM,CAAC;IACjB,MAAM,CAAC,EAAG,OAAO,CAAC;IAClB,KAAK,CAAC,EAAI,OAAO,CAAC;IAClB,IAAI,CAAC,EAAK,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAS,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC3B,GAAG,CAAC,EAAQ,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAQD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAE,GAAG,EAAE,iBAAiB,GAAG,IAAI,CAOzD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CASjF;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAE,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CAanE"}

package/build/thunderstruck/pre-root.js

@@ -0,0 +1,78 @@
+/**
+ * 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.
+ */
+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.
+ */
+export 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).
+ */
+export 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.
+ */
+export 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/unblind.d.ts

@@ -0,0 +1,46 @@
+export interface UnblindReport {
+    kind: string;
+    message: string;
+    branch: string[];
+    erroredType: string | null;
+    erroredInstance: unknown;
+    attemptedArgs: unknown;
+}
+/**
+ * extract() that cannot throw inside an error path — non-mnemonica
+ * values degrade to their key list.
+ */
+export declare function extractSafe(instance: object): unknown;
+/**
+ * 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.
+ */
+export declare function erroredArgsSafe(error: Error): unknown;
+/**
+ * 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).
+ */
+export declare function stringifySafe(value: unknown): string;
+/**
+ * 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.
+ */
+export declare function buildUnblindReport(error: unknown): UnblindReport;
+/**
+ * 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.
+ */
+export declare function recordUnblindTelemetry(report: UnblindReport, error: unknown): void;
+//# sourceMappingURL=unblind.d.ts.map

package/build/unblind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unblind.d.ts","sourceRoot":"","sources":["../src/unblind.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAc,MAAM,CAAC;IACzB,OAAO,EAAW,MAAM,CAAC;IACzB,MAAM,EAAY,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAO,MAAM,GAAG,IAAI,CAAC;IAChC,eAAe,EAAG,OAAO,CAAC;IAC1B,aAAa,EAAK,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAStD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAQrD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAqBjE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAkBnF"}

package/build/unblind.js

@@ -0,0 +1,120 @@
+/**
+ * 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.
+ */
+import { getFlow } from '@mnemonica/dive';
+import { utils, getProps } from 'mnemonica';
+import { trace, SpanStatusCode } from '@opentelemetry/api';
+/**
+ * extract() that cannot throw inside an error path — non-mnemonica
+ * values degrade to their key list.
+ */
+export function extractSafe(instance) {
+    try {
+        const result = 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.
+ */
+export function erroredArgsSafe(error) {
+    try {
+        const props = 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).
+ */
+export 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.
+ */
+export function buildUnblindReport(error) {
+    const isError = error instanceof Error;
+    const message = isError ? error.message : `non-Error thrown (${typeof error})`;
+    const flow = isError ? 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.
+ */
+export function recordUnblindTelemetry(report, error) {
+    const span = 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: 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/utils/dive-flow.d.ts

@@ -0,0 +1,24 @@
+import type { FlowEdge } from '@mnemonica/dive';
+/**
+ * JSON-safe shape of a trace edge: the FlowEdge without the live instance
+ * reference (mnemonica instances don't survive serialization), duration
+ * normalized to null while unsettled.
+ */
+export interface FormattedFlowEdge {
+    name: string;
+    kind: FlowEdge['kind'];
+    status: FlowEdge['status'];
+    duration: number | null;
+}
+/**
+ * Canonical edge → plain-JSON shaping for reports, filters and logs.
+ * Same target semantics as getFlow: Error | instance | current cursor.
+ */
+export declare function formatFlow(target?: unknown): FormattedFlowEdge[];
+/**
+ * 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.
+ */
+export declare function errorContext(error: Error): object | undefined;
+//# sourceMappingURL=dive-flow.d.ts.map

package/build/utils/dive-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dive-flow.d.ts","sourceRoot":"","sources":["../../src/utils/dive-flow.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAO,MAAM,CAAC;IAClB,IAAI,EAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,EAAK,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC9B,QAAQ,EAAG,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAE,MAAM,CAAC,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAI9D"}

package/build/utils/dive-flow.js

@@ -0,0 +1,33 @@
+/**
+ * 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).
+ */
+import { getFlow, getErrorInstance, current } from '@mnemonica/dive';
+/**
+ * Canonical edge → plain-JSON shaping for reports, filters and logs.
+ * Same target semantics as getFlow: Error | instance | current cursor.
+ */
+export function formatFlow(target) {
+    const result = 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.
+ */
+export function errorContext(error) {
+    const pinned = getErrorInstance(error);
+    const result = pinned ?? current();
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/is-mnemonica-instance.d.ts

@@ -0,0 +1,2 @@
+export declare function isMnemonicaInstance(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=is-mnemonica-instance.d.ts.map

package/build/utils/is-mnemonica-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-mnemonica-instance.d.ts","sourceRoot":"","sources":["../../src/utils/is-mnemonica-instance.ts"],"names":[],"mappings":"AAMA,wBAAgB,mBAAmB,CAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAErF"}

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

@@ -0,0 +1,9 @@
+/**
+ * Runtime type guard for mnemonica instances.
+ * Uses mnemonica's getProps() — no instanceof hacks, works across realms.
+ */
+import { getProps } from 'mnemonica/module';
+export function isMnemonicaInstance(value) {
+    return value != null && typeof value === 'object' && getProps(value) !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbW5lbW9uaWNhLWluc3RhbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2lzLW1uZW1vbmljYS1pbnN0YW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsTUFBTSxVQUFVLG1CQUFtQixDQUFFLEtBQWM7SUFDbEQsT0FBTyxLQUFLLElBQUksSUFBSSxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxRQUFRLENBQUMsS0FBSyxDQUFDLEtBQUssU0FBUyxDQUFDO0FBQ3BGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJ1bnRpbWUgdHlwZSBndWFyZCBmb3IgbW5lbW9uaWNhIGluc3RhbmNlcy5cbiAqIFVzZXMgbW5lbW9uaWNhJ3MgZ2V0UHJvcHMoKSDigJQgbm8gaW5zdGFuY2VvZiBoYWNrcywgd29ya3MgYWNyb3NzIHJlYWxtcy5cbiAqL1xuaW1wb3J0IHsgZ2V0UHJvcHMgfSBmcm9tICdtbmVtb25pY2EvbW9kdWxlJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzTW5lbW9uaWNhSW5zdGFuY2UgKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4ge1xuXHRyZXR1cm4gdmFsdWUgIT0gbnVsbCAmJiB0eXBlb2YgdmFsdWUgPT09ICdvYmplY3QnICYmIGdldFByb3BzKHZhbHVlKSAhPT0gdW5kZWZpbmVkO1xufVxuIl19

package/build-cjs/hooks/attach-hooks.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachHooks = attachHooks;
+/**
+ * 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.
+ */
+const dive_1 = require("@mnemonica/dive");
+function attachHooks(collection) {
+    collection.registerHook('preCreation', (hookData) => {
+        const parent = hookData.existentInstance;
+        if (parent) {
+            (0, dive_1.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' && !(0, dive_1.isWrappedFunction)(arg)) {
+                    args[i] = (0, dive_1.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) {
+                (0, dive_1.upgradeConstructorArg)(arg, instance);
+            }
+        }
+        (0, dive_1.recordCreation)(hookData.TypeName || 'anonymous', instance, hookData.existentInstance);
+        (0, dive_1.wrapInstanceMethods)(instance);
+    });
+    collection.registerHook('creationError', (hookData) => {
+        (0, dive_1.recordCreationError)(hookData.TypeName || 'anonymous', hookData.inheritedInstance, hookData.existentInstance);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build-cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorContext = exports.formatFlow = exports.isMnemonicaInstance = exports.stringifySafe = exports.erroredArgsSafe = exports.extractSafe = exports.recordUnblindTelemetry = exports.buildUnblindReport = exports.feedPreRootFromRequest = exports.getPreRoot = exports.feedValidatedPreRoot = exports.feedPreRoot = exports.runInRequestScope = exports.AsyncFlowProvider = exports.DiveOtelProvider = exports.MnemonicaOtelProvider = exports.attachHooks = void 0;
+var attach_hooks_js_1 = require("./hooks/attach-hooks.js");
+Object.defineProperty(exports, "attachHooks", { enumerable: true, get: function () { return attach_hooks_js_1.attachHooks; } });
+var mnemonica_otel_provider_js_1 = require("./providers/mnemonica-otel.provider.js");
+Object.defineProperty(exports, "MnemonicaOtelProvider", { enumerable: true, get: function () { return mnemonica_otel_provider_js_1.MnemonicaOtelProvider; } });
+var dive_otel_provider_js_1 = require("./providers/dive-otel.provider.js");
+Object.defineProperty(exports, "DiveOtelProvider", { enumerable: true, get: function () { return dive_otel_provider_js_1.DiveOtelProvider; } });
+var async_flow_provider_js_1 = require("./providers/async-flow.provider.js");
+Object.defineProperty(exports, "AsyncFlowProvider", { enumerable: true, get: function () { return async_flow_provider_js_1.AsyncFlowProvider; } });
+var request_scope_js_1 = require("./request-scope.js");
+Object.defineProperty(exports, "runInRequestScope", { enumerable: true, get: function () { return request_scope_js_1.runInRequestScope; } });
+var pre_root_js_1 = require("./thunderstruck/pre-root.js");
+Object.defineProperty(exports, "feedPreRoot", { enumerable: true, get: function () { return pre_root_js_1.feedPreRoot; } });
+Object.defineProperty(exports, "feedValidatedPreRoot", { enumerable: true, get: function () { return pre_root_js_1.feedValidatedPreRoot; } });
+Object.defineProperty(exports, "getPreRoot", { enumerable: true, get: function () { return pre_root_js_1.getPreRoot; } });
+var feed_from_request_js_1 = require("./thunderstruck/feed-from-request.js");
+Object.defineProperty(exports, "feedPreRootFromRequest", { enumerable: true, get: function () { return feed_from_request_js_1.feedPreRootFromRequest; } });
+var unblind_js_1 = require("./unblind.js");
+Object.defineProperty(exports, "buildUnblindReport", { enumerable: true, get: function () { return unblind_js_1.buildUnblindReport; } });
+Object.defineProperty(exports, "recordUnblindTelemetry", { enumerable: true, get: function () { return unblind_js_1.recordUnblindTelemetry; } });
+Object.defineProperty(exports, "extractSafe", { enumerable: true, get: function () { return unblind_js_1.extractSafe; } });
+Object.defineProperty(exports, "erroredArgsSafe", { enumerable: true, get: function () { return unblind_js_1.erroredArgsSafe; } });
+Object.defineProperty(exports, "stringifySafe", { enumerable: true, get: function () { return unblind_js_1.stringifySafe; } });
+var is_mnemonica_instance_js_1 = require("./utils/is-mnemonica-instance.js");
+Object.defineProperty(exports, "isMnemonicaInstance", { enumerable: true, get: function () { return is_mnemonica_instance_js_1.isMnemonicaInstance; } });
+var dive_flow_js_1 = require("./utils/dive-flow.js");
+Object.defineProperty(exports, "formatFlow", { enumerable: true, get: function () { return dive_flow_js_1.formatFlow; } });
+Object.defineProperty(exports, "errorContext", { enumerable: true, get: function () { return dive_flow_js_1.errorContext; } });
+//# sourceMappingURL=data:application/json;base64,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

package/build-cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}