@descryy/runtime-adapter-typescript 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { RawStackFrame, ParsedLocation } from "./v8-frame-parsing.ts";
+export { isV8HeaderLine, isV8FrameLine, isV8NamedFrameLine, parseV8Frame, parseLocation, createV8LineClassifier } from "./v8-frame-parsing.ts";
+export { createNodeSourceLocationResolver } from "./node-source-location-resolver.ts";
+export { createV8StackTraceParser } from "./v8-stack-trace-parser.ts";
+export type { TypeScriptRuntimeAdapterOptions } from "./typescript-runtime-adapter.ts";
+export { createTypeScriptRuntimeAdapter } from "./typescript-runtime-adapter.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/I,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,YAAY,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { isV8HeaderLine, isV8FrameLine, isV8NamedFrameLine, parseV8Frame, parseLocation, createV8LineClassifier } from "./v8-frame-parsing.js";
+export { createNodeSourceLocationResolver } from "./node-source-location-resolver.js";
+export { createV8StackTraceParser } from "./v8-stack-trace-parser.js";
+export { createTypeScriptRuntimeAdapter } from "./typescript-runtime-adapter.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/I,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/node-source-location-resolver.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Node/TypeScript `SourceLocationResolver` — resolves a V8-captured
+ * compiled-code location back to authored source through a `//# sourceMappingURL`
+ * source map, when one exists, and classifies `SourceLocation.reliability`
+ * (RT-003) honestly rather than defaulting.
+ *
+ * - No `sourceMappingURL` reference at all → `self-contained`. Nothing was
+ *   lost — the V8-captured compiled location IS the accurate answer, same
+ *   category as a Python traceback's self-captured frame. This is NOT
+ *   `side-artifact-missing`, which means "we expected a map and couldn't
+ *   get it."
+ * - A reference exists but the map file can't be found or parsed, or has
+ *   no entry for this exact line:column → `side-artifact-missing`.
+ * - A reference exists, the map resolves this position, and either
+ *   `sourcesContent` is absent for that source or the on-disk file matches
+ *   it → `side-artifact-resolved`.
+ * - A reference exists, the map resolves this position, `sourcesContent`
+ *   is present for that source, AND the on-disk file's content differs
+ *   → `side-artifact-stale`. This is the one value nothing else in this
+ *   build exercises without this check actually running — comparing
+ *   `sourcesContent` against disk rather than punting on staleness
+ *   detection entirely.
+ * - A location with no file on disk at all (`node:events`, a stdlib
+ *   internal) → `self-contained`. There was never an artifact to lose;
+ *   the captured location is the accurate answer.
+ */
+import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
+export declare function createNodeSourceLocationResolver(): SourceLocationResolver;
+//# sourceMappingURL=node-source-location-resolver.d.ts.map

package/dist/node-source-location-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/node-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AA6IrG,wBAAgB,gCAAgC,IAAI,sBAAsB,CAMzE"}

package/dist/node-source-location-resolver.js

@@ -0,0 +1,159 @@
+/**
+ * Node/TypeScript `SourceLocationResolver` — resolves a V8-captured
+ * compiled-code location back to authored source through a `//# sourceMappingURL`
+ * source map, when one exists, and classifies `SourceLocation.reliability`
+ * (RT-003) honestly rather than defaulting.
+ *
+ * - No `sourceMappingURL` reference at all → `self-contained`. Nothing was
+ *   lost — the V8-captured compiled location IS the accurate answer, same
+ *   category as a Python traceback's self-captured frame. This is NOT
+ *   `side-artifact-missing`, which means "we expected a map and couldn't
+ *   get it."
+ * - A reference exists but the map file can't be found or parsed, or has
+ *   no entry for this exact line:column → `side-artifact-missing`.
+ * - A reference exists, the map resolves this position, and either
+ *   `sourcesContent` is absent for that source or the on-disk file matches
+ *   it → `side-artifact-resolved`.
+ * - A reference exists, the map resolves this position, `sourcesContent`
+ *   is present for that source, AND the on-disk file's content differs
+ *   → `side-artifact-stale`. This is the one value nothing else in this
+ *   build exercises without this check actually running — comparing
+ *   `sourcesContent` against disk rather than punting on staleness
+ *   detection entirely.
+ * - A location with no file on disk at all (`node:events`, a stdlib
+ *   internal) → `self-contained`. There was never an artifact to lose;
+ *   the captured location is the accurate answer.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, resolve as resolvePath, isAbsolute } from "node:path";
+import { TraceMap, originalPositionFor, sourceContentFor } from "@jridgewell/trace-mapping";
+const SOURCE_MAPPING_URL_PATTERN = /\/\/[#@]\s*sourceMappingURL=(\S+)/g;
+function normalizeCompiledFile(rawFile) {
+    return rawFile.startsWith("file://") ? fileURLToPath(rawFile) : rawFile;
+}
+/** Last match wins, per convention — and a large bundle could contain earlier false-positive-shaped text. */
+function findSourceMappingUrl(compiledText) {
+    let last;
+    for (const match of compiledText.matchAll(SOURCE_MAPPING_URL_PATTERN)) {
+        last = match[1];
+    }
+    return last;
+}
+function loadTraceMap(compiledFilePath, mappingUrl) {
+    if (mappingUrl.startsWith("data:")) {
+        const marker = "base64,";
+        const idx = mappingUrl.indexOf(marker);
+        if (idx === -1)
+            return undefined;
+        try {
+            const json = Buffer.from(mappingUrl.slice(idx + marker.length), "base64").toString("utf8");
+            return { map: new TraceMap(json, pathToFileURL(compiledFilePath).href) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const mapPath = isAbsolute(mappingUrl) ? mappingUrl : resolvePath(dirname(compiledFilePath), mappingUrl);
+    if (!existsSync(mapPath))
+        return undefined;
+    try {
+        const json = readFileSync(mapPath, "utf8");
+        return { map: new TraceMap(json, pathToFileURL(mapPath).href) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+function selfContained(frame, file) {
+    return {
+        file,
+        line: frame.line,
+        column: frame.column,
+        functionName: frame.functionName,
+        reliability: "self-contained",
+        resolvedVia: null,
+    };
+}
+function sideArtifactMissing(frame, file, mappingUrl) {
+    return {
+        file,
+        line: frame.line,
+        column: frame.column,
+        functionName: frame.functionName,
+        reliability: "side-artifact-missing",
+        resolvedVia: mappingUrl,
+    };
+}
+function resolveSync(frame) {
+    // V8 always names a file, so this is unreachable from the V8 parser --
+    // the type admits null because a JVM frame can omit it. Handled rather
+    // than asserted away, since an assertion here would become a crash the
+    // moment some other caller reuses this resolver.
+    if (frame.line === null || frame.file === null) {
+        return selfContained(frame, frame.file);
+    }
+    const file = normalizeCompiledFile(frame.file);
+    if (!existsSync(file)) {
+        // e.g. "node:events" -- a stdlib internal with no file on disk at all.
+        // Nothing was ever there to lose; the captured location is accurate.
+        return selfContained(frame, file);
+    }
+    const compiledText = readFileSync(file, "utf8");
+    const mappingUrl = findSourceMappingUrl(compiledText);
+    if (mappingUrl === undefined) {
+        return selfContained(frame, file);
+    }
+    if (frame.column === null) {
+        // A source map can't be walked to a specific position without a
+        // column — trying anyway would silently substitute a guessed column
+        // and report it as resolved. Report what was actually captured
+        // instead of a fabricated mapping.
+        return selfContained(frame, file);
+    }
+    const loaded = loadTraceMap(file, mappingUrl);
+    if (loaded === undefined) {
+        return sideArtifactMissing(frame, file, mappingUrl);
+    }
+    // Stack frame line is 1-based, matching originalPositionFor's expectation.
+    // Column is 1-based in V8 stacks but 0-based in trace-mapping's needle.
+    const original = originalPositionFor(loaded.map, { line: frame.line, column: Math.max(0, frame.column - 1) });
+    if (original.source === null || original.line === null || original.column === null) {
+        return sideArtifactMissing(frame, file, mappingUrl);
+    }
+    const sourceIndex = loaded.map.sources.indexOf(original.source);
+    const embeddedContent = sourceContentFor(loaded.map, original.source);
+    const resolvedSourcePath = sourceIndex >= 0 ? (loaded.map.resolvedSources[sourceIndex] ?? original.source) : original.source;
+    const onDiskPath = resolvedSourcePath.startsWith("file://") ? fileURLToPath(resolvedSourcePath) : resolvedSourcePath;
+    let reliability = "side-artifact-resolved";
+    if (embeddedContent !== null && existsSync(onDiskPath)) {
+        const onDisk = readFileSync(onDiskPath, "utf8");
+        if (normalizeLineEndings(onDisk) !== normalizeLineEndings(embeddedContent)) {
+            reliability = "side-artifact-stale";
+        }
+    }
+    // embeddedContent === null, or the on-disk file is unreadable: nothing to
+    // compare against, so freshness is simply unverifiable — resolved stays
+    // the honest answer rather than downgrading on the absence of a check.
+    return {
+        file: onDiskPath,
+        line: original.line,
+        // trace-mapping's column is 0-based; SourceLocation.column is reported
+        // 1-based to match how every other frame in this system is stated.
+        column: original.column + 1,
+        functionName: original.name ?? frame.functionName,
+        reliability,
+        resolvedVia: mappingUrl,
+    };
+}
+export function createNodeSourceLocationResolver() {
+    return {
+        resolve(frame) {
+            return Promise.resolve(resolveSync(frame));
+        },
+    };
+}
+//# sourceMappingURL=node-source-location-resolver.js.map

package/dist/node-source-location-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-source-location-resolver.js","sourceRoot":"","sources":["../src/node-source-location-resolver.ts"],"names":[],"mappings":"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"}

package/dist/typescript-runtime-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The concrete `RuntimeAdapter` for TypeScript/Node — V1's only language
+ * (per the explicit vertical-slice scope limit: no second language until
+ * this one closes end to end). Wires this package's V8 stack-trace parser,
+ * Node source-map resolver, and V8 line classifier into the language-
+ * neutral seam `@descryy/runtime-backend-observation` defines.
+ */
+import type { RuntimeAdapter } from "@descryy/runtime-backend-observation";
+export interface TypeScriptRuntimeAdapterOptions {
+    /** Attributed on every emitted Evidence's `service` field (plan §16.7). Omit when not applicable. */
+    readonly service?: string;
+}
+export declare function createTypeScriptRuntimeAdapter(options?: TypeScriptRuntimeAdapterOptions): RuntimeAdapter;
+//# sourceMappingURL=typescript-runtime-adapter.d.ts.map

package/dist/typescript-runtime-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/typescript-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,sCAAsC,CAAC;AAQhG,MAAM,WAAW,+BAA+B;IAC9C,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,+BAAoC,GAAG,cAAc,CAuB5G"}

package/dist/typescript-runtime-adapter.js

@@ -0,0 +1,32 @@
+/**
+ * The concrete `RuntimeAdapter` for TypeScript/Node — V1's only language
+ * (per the explicit vertical-slice scope limit: no second language until
+ * this one closes end to end). Wires this package's V8 stack-trace parser,
+ * Node source-map resolver, and V8 line classifier into the language-
+ * neutral seam `@descryy/runtime-backend-observation` defines.
+ */
+import { createLogCollector } from "@descryy/runtime-backend-observation";
+import { createV8LineClassifier } from "./v8-frame-parsing.js";
+import { createNodeSourceLocationResolver } from "./node-source-location-resolver.js";
+import { createV8StackTraceParser } from "./v8-stack-trace-parser.js";
+export function createTypeScriptRuntimeAdapter(options = {}) {
+    const sourceLocationResolver = createNodeSourceLocationResolver();
+    const stackTraceParser = createV8StackTraceParser(sourceLocationResolver);
+    function createBackendCollectors(sources) {
+        return sources.map((source) => createLogCollector({
+            source,
+            // One classifier per source, never one shared: it is stateful now,
+            // and a shared instance would let one process's trace arm another's.
+            classifier: createV8LineClassifier(),
+            stackTraceParser,
+            ...(options.service !== undefined ? { service: options.service } : {}),
+        }));
+    }
+    return {
+        language: "typescript",
+        stackTraceParser,
+        sourceLocationResolver,
+        createBackendCollectors,
+    };
+}
+//# sourceMappingURL=typescript-runtime-adapter.js.map

package/dist/typescript-runtime-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-runtime-adapter.js","sourceRoot":"","sources":["../src/typescript-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAOtE,MAAM,UAAU,8BAA8B,CAAC,UAA2C,EAAE;IAC1F,MAAM,sBAAsB,GAAG,gCAAgC,EAAE,CAAC;IAClE,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,sBAAsB,CAAC,CAAC;IAE1E,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,mEAAmE;YACnE,qEAAqE;YACrE,UAAU,EAAE,sBAAsB,EAAE;YACpC,gBAAgB;YAChB,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACvE,CAAC,CACH,CAAC;IACJ,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,YAAY;QACtB,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;KACxB,CAAC;AACJ,CAAC"}

package/dist/v8-frame-parsing.d.ts

@@ -0,0 +1,78 @@
+/**
+ * V8's `Error.stack` line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
+ * feeds `SourceLocationResolver`.
+ *
+ * The header pattern is deliberately NOT anchored to the start of the
+ * line. Measured against `broken-invoices-backend`'s own real output
+ * (`console.error` with a custom prefix): `"[broken-invoices] DELETE
+ * /api/invoices/3 failed: TypeError: Cannot read properties of null
+ * (reading 'toUpperCase')"` — the error type sits mid-line behind
+ * application context, which a start-anchored pattern would have missed
+ * entirely, misclassifying a genuine exception as an unattributed
+ * stack-trace block. The block-detector's own "header immediately
+ * followed by a frame line" rule keeps this safe from false positives: a
+ * log line that merely *mentions* an Error-shaped word with nothing
+ * frame-shaped after it never becomes an EXCEPTION.
+ */
+export interface RawStackFrame {
+    readonly functionName: string | null;
+    /** Unparsed location text — `file:///abs/path.js:37:44`, `node:events:519:28`, or `<anonymous>` (no line:col, dropped by the caller rather than fabricated). */
+    readonly location: string;
+}
+export interface ParsedLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+export declare function isV8HeaderLine(line: string): boolean;
+export declare function isV8FrameLine(line: string): boolean;
+/**
+ * The `at fn (loc)` form specifically — a shape no other runtime in this
+ * repo produces, and therefore the anchor `createV8StackTraceParser` uses
+ * to decide that text is V8's at all. See its header for why a bare frame
+ * alone is not enough to make that call.
+ */
+export declare function isV8NamedFrameLine(line: string): boolean;
+export declare function parseV8Frame(line: string): RawStackFrame | null;
+/** `null` for a frame with no parseable line:column (e.g. `<anonymous>`) — never fabricated. */
+export declare function parseLocation(location: string): ParsedLocation | null;
+/**
+ * A **stateful** `LineClassifier`, for RT-035's reason and RT-047's
+ * evidence.
+ *
+ * V8 was the last adapter still handing `ExceptionBlockDetector` a bare
+ * pair of stateless predicates — `{ isHeader: isV8HeaderLine, isFrame:
+ * isV8FrameLine }` — and it was wrong in exactly the way every other
+ * language's had already been found to be.
+ *
+ * **`FRAME_BARE` matches a Rust backtrace's location lines.** `   at
+ * /rustc/<hash>/library/std/src/panicking.rs:698:5` is `at` followed by a
+ * single parenthesis-free token, which is also precisely the shape of a
+ * bare V8 frame. RT-039 found this at the *parser* layer and fixed it there
+ * by requiring the whole text to contain a V8 header or a named `at fn
+ * (loc)` frame — and then reported that the matrix confirmed the classifier
+ * layer too. It had not: the classifier half of that matrix was inspecting
+ * an empty array (see `false-accept-matrix.test.ts`). With the matrix
+ * actually running, the V8 classifier opens **nine** blocks on one Rust
+ * backtrace.
+ *
+ * The rule here is the parser's anchor applied line by line, which is what
+ * a classifier can do that a set of predicates cannot: a **named** frame is
+ * always block content and arms the classifier; a **bare** frame is block
+ * content only once armed. A header arms it too.
+ *
+ * **The cost is the same one RT-039 already took and is restated rather
+ * than rediscovered:** a V8 trace consisting solely of bare frames does not
+ * open a block. Measured against four real V8 traces in RT-039, a bare
+ * frame occurs only where V8 has no function name, and Node's own internal
+ * frames — which follow every such throw — are all named, so the shape is
+ * rare. A disclosed recall loss, taken in the direction this project always
+ * takes it, over nine fabricated frames pointing into another language's
+ * standard library.
+ */
+export declare function createV8LineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+};
+//# sourceMappingURL=v8-frame-parsing.d.ts.map

package/dist/v8-frame-parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-frame-parsing.d.ts","sourceRoot":"","sources":["../src/v8-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,gKAAgK;IAChK,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAyBD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAU/D;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAQrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,sBAAsB,IAAI;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAoBA"}

package/dist/v8-frame-parsing.js

@@ -0,0 +1,130 @@
+/**
+ * V8's `Error.stack` line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
+ * feeds `SourceLocationResolver`.
+ *
+ * The header pattern is deliberately NOT anchored to the start of the
+ * line. Measured against `broken-invoices-backend`'s own real output
+ * (`console.error` with a custom prefix): `"[broken-invoices] DELETE
+ * /api/invoices/3 failed: TypeError: Cannot read properties of null
+ * (reading 'toUpperCase')"` — the error type sits mid-line behind
+ * application context, which a start-anchored pattern would have missed
+ * entirely, misclassifying a genuine exception as an unattributed
+ * stack-trace block. The block-detector's own "header immediately
+ * followed by a frame line" rule keeps this safe from false positives: a
+ * log line that merely *mentions* an Error-shaped word with nothing
+ * frame-shaped after it never becomes an EXCEPTION.
+ */
+const HEADER_PATTERN = /\b(?<type>(?:[A-Z][\w$]*)?Error)(?::\s*(?<message>.*))?$/;
+const FRAME_WITH_PARENS = /^\s*at\s+(?:new\s+)?(?<fn>.+?)\s+\((?<loc>[^()]+)\)\s*$/;
+/**
+ * A location-only frame: `at file:///app/x.js:1:1`, `at <anonymous>`,
+ * `at node:internal/main/run_main_module:23:47`.
+ *
+ * **Parentheses are excluded deliberately, and the JVM adapter's
+ * cross-language control is what found this.** Without the exclusion this
+ * pattern matched `at com.example.Thrower.handler(Thrower.java:12)` — a JVM
+ * frame is `at` followed by a single non-whitespace run, exactly like a
+ * bare V8 frame. A real bare V8 frame never contains parentheses: once
+ * there is a function name, V8 emits the `fn (loc)` form instead. So the
+ * exclusion costs no genuine V8 frame and removes the whole false-accept.
+ *
+ * The parser was already safe here — `parseLocation` requires a trailing
+ * `:line:column` and refuses the JVM shape — but the *classifier* is what
+ * `ExceptionBlockDetector` uses to decide whether a line belongs to a
+ * block at all, so accepting a foreign runtime's frames there is enough for
+ * a mis-wired adapter to half-work rather than fail.
+ */
+const FRAME_BARE = /^\s*at\s+(?<loc>[^\s()]+)\s*$/;
+const LOCATION_WITH_LINE_COL = /^(?<file>.+):(?<line>\d+):(?<col>\d+)$/;
+export function isV8HeaderLine(line) {
+    return HEADER_PATTERN.test(line);
+}
+export function isV8FrameLine(line) {
+    return FRAME_WITH_PARENS.test(line) || FRAME_BARE.test(line);
+}
+/**
+ * The `at fn (loc)` form specifically — a shape no other runtime in this
+ * repo produces, and therefore the anchor `createV8StackTraceParser` uses
+ * to decide that text is V8's at all. See its header for why a bare frame
+ * alone is not enough to make that call.
+ */
+export function isV8NamedFrameLine(line) {
+    return FRAME_WITH_PARENS.test(line);
+}
+export function parseV8Frame(line) {
+    const withParens = FRAME_WITH_PARENS.exec(line);
+    if (withParens?.groups) {
+        return { functionName: withParens.groups["fn"] ?? null, location: withParens.groups["loc"] ?? "" };
+    }
+    const bare = FRAME_BARE.exec(line);
+    if (bare?.groups) {
+        return { functionName: null, location: bare.groups["loc"] ?? "" };
+    }
+    return null;
+}
+/** `null` for a frame with no parseable line:column (e.g. `<anonymous>`) — never fabricated. */
+export function parseLocation(location) {
+    const match = LOCATION_WITH_LINE_COL.exec(location);
+    if (!match?.groups)
+        return null;
+    return {
+        file: match.groups["file"] ?? "",
+        line: Number(match.groups["line"]),
+        column: Number(match.groups["col"]),
+    };
+}
+/**
+ * A **stateful** `LineClassifier`, for RT-035's reason and RT-047's
+ * evidence.
+ *
+ * V8 was the last adapter still handing `ExceptionBlockDetector` a bare
+ * pair of stateless predicates — `{ isHeader: isV8HeaderLine, isFrame:
+ * isV8FrameLine }` — and it was wrong in exactly the way every other
+ * language's had already been found to be.
+ *
+ * **`FRAME_BARE` matches a Rust backtrace's location lines.** `   at
+ * /rustc/<hash>/library/std/src/panicking.rs:698:5` is `at` followed by a
+ * single parenthesis-free token, which is also precisely the shape of a
+ * bare V8 frame. RT-039 found this at the *parser* layer and fixed it there
+ * by requiring the whole text to contain a V8 header or a named `at fn
+ * (loc)` frame — and then reported that the matrix confirmed the classifier
+ * layer too. It had not: the classifier half of that matrix was inspecting
+ * an empty array (see `false-accept-matrix.test.ts`). With the matrix
+ * actually running, the V8 classifier opens **nine** blocks on one Rust
+ * backtrace.
+ *
+ * The rule here is the parser's anchor applied line by line, which is what
+ * a classifier can do that a set of predicates cannot: a **named** frame is
+ * always block content and arms the classifier; a **bare** frame is block
+ * content only once armed. A header arms it too.
+ *
+ * **The cost is the same one RT-039 already took and is restated rather
+ * than rediscovered:** a V8 trace consisting solely of bare frames does not
+ * open a block. Measured against four real V8 traces in RT-039, a bare
+ * frame occurs only where V8 has no function name, and Node's own internal
+ * frames — which follow every such throw — are all named, so the shape is
+ * rare. A disclosed recall loss, taken in the direction this project always
+ * takes it, over nine fabricated frames pointing into another language's
+ * standard library.
+ */
+export function createV8LineClassifier() {
+    let armed = false;
+    return {
+        isHeader(line) {
+            if (isV8HeaderLine(line)) {
+                armed = true;
+                return true;
+            }
+            return false;
+        },
+        isFrame(line) {
+            if (isV8NamedFrameLine(line)) {
+                armed = true;
+                return true;
+            }
+            return armed && FRAME_BARE.test(line);
+        },
+    };
+}
+//# sourceMappingURL=v8-frame-parsing.js.map

package/dist/v8-frame-parsing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-frame-parsing.js","sourceRoot":"","sources":["../src/v8-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAcH,MAAM,cAAc,GAAG,0DAA0D,CAAC;AAClF,MAAM,iBAAiB,GAAG,yDAAyD,CAAC;AACpF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,GAAG,+BAA+B,CAAC;AACnD,MAAM,sBAAsB,GAAG,wCAAwC,CAAC;AAExE,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChD,IAAI,UAAU,EAAE,MAAM,EAAE,CAAC;QACvB,OAAO,EAAE,YAAY,EAAE,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;IACrG,CAAC;IACD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;QACjB,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;IACpE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,gGAAgG;AAChG,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,MAAM,KAAK,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpD,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;QAChC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;KACpC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,sBAAsB;IAIpC,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,OAAO;QACL,QAAQ,CAAC,IAAY;YACnB,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzB,KAAK,GAAG,IAAI,CAAC;gBACb,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CAAC,IAAY;YAClB,IAAI,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,KAAK,GAAG,IAAI,CAAC;gBACb,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/v8-stack-trace-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Composes the pure V8 line-recognition functions (`v8-frame-parsing.ts`)
+ * with a `SourceLocationResolver` to implement the full async
+ * `StackTraceParser` contract.
+ *
+ * fidelity is always reported "synchronous". V8's zero-cost async stack
+ * traces mean every frame this parser sees is a genuine, unbroken link in
+ * the chain — V8 does not fabricate frames. What a single stack capture
+ * can never show is who scheduled a callback across a real event-loop
+ * reentry point (a timer, an emitted event, a fresh microtask): the stack
+ * simply, correctly, ends at that boundary (`node:events`, `node:timers`,
+ * the module loader — see the real broken-invoices-backend and thrower.ts
+ * fixtures, both of which bottom out this way). That is a hard limit of
+ * what V8 stacks can ever contain, not evidence that what IS shown is
+ * fragmented. Detecting a genuinely lost logical caller would need
+ * async_hooks-based correlation across reentry points, not text parsing —
+ * out of scope here, and reporting "concurrency-fragmented" without that
+ * evidence would be a guess this parser has no basis for.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createV8StackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=v8-stack-trace-parser.d.ts.map

package/dist/v8-stack-trace-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/v8-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAIrG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAkE3F"}

package/dist/v8-stack-trace-parser.js

@@ -0,0 +1,83 @@
+/**
+ * Composes the pure V8 line-recognition functions (`v8-frame-parsing.ts`)
+ * with a `SourceLocationResolver` to implement the full async
+ * `StackTraceParser` contract.
+ *
+ * fidelity is always reported "synchronous". V8's zero-cost async stack
+ * traces mean every frame this parser sees is a genuine, unbroken link in
+ * the chain — V8 does not fabricate frames. What a single stack capture
+ * can never show is who scheduled a callback across a real event-loop
+ * reentry point (a timer, an emitted event, a fresh microtask): the stack
+ * simply, correctly, ends at that boundary (`node:events`, `node:timers`,
+ * the module loader — see the real broken-invoices-backend and thrower.ts
+ * fixtures, both of which bottom out this way). That is a hard limit of
+ * what V8 stacks can ever contain, not evidence that what IS shown is
+ * fragmented. Detecting a genuinely lost logical caller would need
+ * async_hooks-based correlation across reentry points, not text parsing —
+ * out of scope here, and reporting "concurrency-fragmented" without that
+ * evidence would be a guess this parser has no basis for.
+ */
+import { parseV8Frame, parseLocation, isV8HeaderLine, isV8NamedFrameLine } from "./v8-frame-parsing.js";
+export function createV8StackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            const lines = rawText.split(/\r\n|\r|\n/);
+            // **Anchor check — the all-pairs matrix is what forced this.** A bare
+            // V8 frame is `at <location>`, and a Rust backtrace's location lines
+            // are `at /rustc/.../panicking.rs:698:5`. Those are the same shape,
+            // and without an anchor this parser accepted a whole Rust backtrace
+            // and produced nine confident, well-formed, wrong frames.
+            //
+            // The `at fn (loc)` form is the anchor because no other runtime here
+            // emits it, and measurement says a real V8 trace effectively always
+            // contains one: bare frames appear only where V8 has no function name
+            // (an ESM top-level throw), and Node's own internal frames — which
+            // follow every such throw — are all named. Verified against real
+            // output for ESM top-level, CJS top-level, an arrow in `Array.map`,
+            // and an unhandled rejection.
+            //
+            // The cost, stated: a trace consisting solely of bare frames is
+            // refused rather than parsed. That is a disclosed recall loss in a
+            // rare shape, taken in the direction this project always takes it —
+            // refusing beats fabricating, and the alternative here was nine
+            // fabricated frames pointing into another language's standard library.
+            if (!lines.some(isV8HeaderLine) && !lines.some(isV8NamedFrameLine)) {
+                return null;
+            }
+            const frames = [];
+            for (const line of lines) {
+                const rawFrame = parseV8Frame(line);
+                if (rawFrame === null)
+                    continue; // a header line, blank line, or anything not frame-shaped
+                const parsedLocation = parseLocation(rawFrame.location);
+                if (parsedLocation === null) {
+                    // A real, if rare, V8 shape: a native built-in call with no JS
+                    // source location at all (e.g. "at Array.map (<anonymous>)").
+                    // There is no line to report and none to fabricate -- omitted
+                    // rather than guessed, same precision-over-recall choice this
+                    // package's block detector already makes for ambiguous headers.
+                    continue;
+                }
+                const location = await resolver.resolve({
+                    file: parsedLocation.file,
+                    line: parsedLocation.line,
+                    column: parsedLocation.column,
+                    functionName: rawFrame.functionName,
+                });
+                frames.push({ location, raw: line });
+            }
+            if (frames.length === 0) {
+                // Nothing frame-shaped in this text at all -- not recognizable as
+                // V8's format, per this interface's own contract: null, never an
+                // empty-but-structured StackTrace standing in for "couldn't parse."
+                return null;
+            }
+            // `primaryFrameIndex` is required so that every adapter states an
+            // answer rather than inheriting one (RT-083). 0 is today's behaviour
+            // and is stated, not defaulted; the real value here is where the
+            // runtime declares its own boundary — V8 puts no frames of its own above the application's. Lane C.
+            return { fidelity: "synchronous", frames, primaryFrameIndex: 0 };
+        },
+    };
+}
+//# sourceMappingURL=v8-stack-trace-parser.js.map

package/dist/v8-stack-trace-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-stack-trace-parser.js","sourceRoot":"","sources":["../src/v8-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAExG,MAAM,UAAU,wBAAwB,CAAC,QAAgC;IACvE,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAe;YACzB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAE1C,sEAAsE;YACtE,qEAAqE;YACrE,oEAAoE;YACpE,oEAAoE;YACpE,0DAA0D;YAC1D,EAAE;YACF,qEAAqE;YACrE,oEAAoE;YACpE,sEAAsE;YACtE,mEAAmE;YACnE,iEAAiE;YACjE,oEAAoE;YACpE,8BAA8B;YAC9B,EAAE;YACF,gEAAgE;YAChE,mEAAmE;YACnE,oEAAoE;YACpE,gEAAgE;YAChE,uEAAuE;YACvE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC;gBACnE,OAAO,IAAI,CAAC;YACd,CAAC;YAED,MAAM,MAAM,GAAiB,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;gBACpC,IAAI,QAAQ,KAAK,IAAI;oBAAE,SAAS,CAAC,0DAA0D;gBAE3F,MAAM,cAAc,GAAG,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBACxD,IAAI,cAAc,KAAK,IAAI,EAAE,CAAC;oBAC5B,+DAA+D;oBAC/D,8DAA8D;oBAC9D,8DAA8D;oBAC9D,8DAA8D;oBAC9D,gEAAgE;oBAChE,SAAS;gBACX,CAAC;gBAED,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC;oBACtC,IAAI,EAAE,cAAc,CAAC,IAAI;oBACzB,IAAI,EAAE,cAAc,CAAC,IAAI;oBACzB,MAAM,EAAE,cAAc,CAAC,MAAM;oBAC7B,YAAY,EAAE,QAAQ,CAAC,YAAY;iBACpC,CAAC,CAAC;gBACH,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;YACvC,CAAC;YAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxB,kEAAkE;gBAClE,iEAAiE;gBACjE,oEAAoE;gBACpE,OAAO,IAAI,CAAC;YACd,CAAC;YAEK,kEAAkE;YACxE,qEAAqE;YACrE,iEAAiE;YACjE,oGAAoG;YACpG,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@descryy/runtime-adapter-typescript",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "TypeScript/Node runtime adapter: V8 stack-trace parsing, Node source-map resolution, the concrete RuntimeAdapter for TS/Node.",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.5"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "dependencies": {
+    "@descryy/runtime-contracts": "0.0.0",
+    "@descryy/runtime-backend-observation": "0.0.0",
+    "@jridgewell/trace-mapping": "^0.3.31"
+  },
+  "devDependencies": {
+    "@descryy/runtime-evidence-store": "*"
+  }
+}