@descryy/runtime-adapter-rust 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { RawRustFrame, RustPanicHeader } from "./rust-frame-parsing.ts";
+export { createRustLineClassifier, isRustBacktraceStartLine, isRustFrameLocationLine, isRustFrameSymbolLine, isRustHeaderLine, isRustNoteLine, parseRustFrameLocation, parseRustFrameSymbol, parseRustPanicHeader, } from "./rust-frame-parsing.ts";
+export { createRustStackTraceParser } from "./rust-stack-trace-parser.ts";
+export type { RustRuntimeAdapterOptions } from "./rust-runtime-adapter.ts";
+export { createRustRuntimeAdapter, createRustSourceLocationResolver } from "./rust-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,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,YAAY,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createRustLineClassifier, isRustBacktraceStartLine, isRustFrameLocationLine, isRustFrameSymbolLine, isRustHeaderLine, isRustNoteLine, parseRustFrameLocation, parseRustFrameSymbol, parseRustPanicHeader, } from "./rust-frame-parsing.js";
+export { createRustStackTraceParser } from "./rust-stack-trace-parser.js";
+export { createRustRuntimeAdapter, createRustSourceLocationResolver } from "./rust-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,EACL,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,OAAO,EAAE,wBAAwB,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAC"}

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

@@ -0,0 +1,82 @@
+/**
+ * Rust panic and backtrace line shapes.
+ *
+ * **Verified against a real toolchain** (`rustc 1.91.1`), by compiling and
+ * running a fixture rather than transcribing the format:
+ *
+ * ```
+ * thread 'main' (468745) panicked at thrower.rs:3:13:
+ * invoice 3 is corrupt
+ * stack backtrace:
+ *    0: __rustc::rust_begin_unwind
+ *              at /rustc/ed61e7d.../library/std/src/panicking.rs:698:5
+ *    5: thrower::delete_invoice
+ *              at ./thrower.rs:3:13
+ *    7: thrower::main
+ *              at ./thrower.rs:11:20
+ * ```
+ *
+ * Rust is unlike every other runtime here in one important way: **the panic
+ * header itself carries a source location** — `panicked at thrower.rs:3:13`
+ * — with a line *and a column*. That matters because `RUST_BACKTRACE` is
+ * **off by default**, so in ordinary production output the header is the
+ * only location there is. A parser that required a backtrace would return
+ * nothing for the common case while the precise answer sat in line one.
+ *
+ * Two header shapes exist and both are supported. The modern one above was
+ * verified here. The pre-1.65 form put the message inside the header —
+ * `thread 'main' panicked at 'invoice 3 is corrupt', src/main.rs:3:13` —
+ * and is supported from its documented shape, **not** verified on this
+ * machine; it is still common in deployed toolchains, which is why it is
+ * handled rather than refused.
+ *
+ * Frames are two lines: `   N: symbol`, then a deeply-indented
+ * `at path:line:col`. The `at` line is **optional** — a build without debug
+ * info prints the symbol alone, which is what separates
+ * `debug-info-present` from `debug-info-stripped` here.
+ */
+export interface RawRustFrame {
+    readonly functionName: string;
+    /** Null when the frame printed no `at` line — a build with no debug info. Never fabricated. */
+    readonly file: string | null;
+    readonly line: number | null;
+    readonly column: number | null;
+}
+export interface RustPanicHeader {
+    readonly thread: string;
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    /** Present only in the legacy shape, where the message is inside the header line. */
+    readonly message: string | null;
+}
+export declare function parseRustPanicHeader(line: string): RustPanicHeader | null;
+export declare function isRustHeaderLine(line: string): boolean;
+export declare function isRustBacktraceStartLine(line: string): boolean;
+export declare function isRustFrameSymbolLine(line: string): boolean;
+export declare function isRustFrameLocationLine(line: string): boolean;
+export declare function isRustNoteLine(line: string): boolean;
+/** The symbol half of a frame; the location half is optional and supplied separately. */
+export declare function parseRustFrameSymbol(line: string): string | null;
+export declare function parseRustFrameLocation(line: string): {
+    file: string;
+    line: number;
+    column: number;
+} | null;
+/**
+ * A stateful `LineClassifier`, for RT-035's reason.
+ *
+ * Rust's specific hazard is `   0: something` — a numbered list item is an
+ * ordinary thing to print, and a stateless rule accepting it would turn any
+ * enumerated log output into a stack-trace block. A numbered symbol line
+ * therefore only counts as block content **after `stack backtrace:`**.
+ *
+ * The panic message line, which follows the header and is arbitrary text,
+ * is accepted as block content only in the single position where Rust puts
+ * it: immediately after a modern header.
+ */
+export declare function createRustLineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+};
+//# sourceMappingURL=rust-frame-parsing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust-frame-parsing.d.ts","sourceRoot":"","sources":["../src/rust-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAeD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAsBzE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,yFAAyF;AACzF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQ1G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,IAAI;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CA+BA"}

package/dist/rust-frame-parsing.js

@@ -0,0 +1,146 @@
+/**
+ * Rust panic and backtrace line shapes.
+ *
+ * **Verified against a real toolchain** (`rustc 1.91.1`), by compiling and
+ * running a fixture rather than transcribing the format:
+ *
+ * ```
+ * thread 'main' (468745) panicked at thrower.rs:3:13:
+ * invoice 3 is corrupt
+ * stack backtrace:
+ *    0: __rustc::rust_begin_unwind
+ *              at /rustc/ed61e7d.../library/std/src/panicking.rs:698:5
+ *    5: thrower::delete_invoice
+ *              at ./thrower.rs:3:13
+ *    7: thrower::main
+ *              at ./thrower.rs:11:20
+ * ```
+ *
+ * Rust is unlike every other runtime here in one important way: **the panic
+ * header itself carries a source location** — `panicked at thrower.rs:3:13`
+ * — with a line *and a column*. That matters because `RUST_BACKTRACE` is
+ * **off by default**, so in ordinary production output the header is the
+ * only location there is. A parser that required a backtrace would return
+ * nothing for the common case while the precise answer sat in line one.
+ *
+ * Two header shapes exist and both are supported. The modern one above was
+ * verified here. The pre-1.65 form put the message inside the header —
+ * `thread 'main' panicked at 'invoice 3 is corrupt', src/main.rs:3:13` —
+ * and is supported from its documented shape, **not** verified on this
+ * machine; it is still common in deployed toolchains, which is why it is
+ * handled rather than refused.
+ *
+ * Frames are two lines: `   N: symbol`, then a deeply-indented
+ * `at path:line:col`. The `at` line is **optional** — a build without debug
+ * info prints the symbol alone, which is what separates
+ * `debug-info-present` from `debug-info-stripped` here.
+ */
+/** Modern (verified): `thread 'main' (468745) panicked at thrower.rs:3:13:` — the thread id in parens is optional. */
+const HEADER_MODERN = /^thread '(?<thread>[^']*)'(?:\s+\(\d+\))?\s+panicked at (?<file>.+?):(?<line>\d+):(?<col>\d+):\s*$/;
+/** Legacy (documented, not verified here): `thread 'main' panicked at 'message', src/main.rs:3:13` */
+const HEADER_LEGACY = /^thread '(?<thread>[^']*)'\s+panicked at '(?<message>.*)',\s+(?<file>.+?):(?<line>\d+):(?<col>\d+)\s*$/;
+const BACKTRACE_START = /^\s*stack backtrace:\s*$/;
+/** `   0: __rustc::rust_begin_unwind` — the index is what makes this unambiguous. */
+const FRAME_SYMBOL = /^\s*(?<index>\d+):\s+(?<symbol>\S.*?)\s*$/;
+/** `             at /rustc/<hash>/library/std/src/panicking.rs:698:5` */
+const FRAME_LOCATION = /^\s+at\s+(?<file>.+?):(?<line>\d+):(?<col>\d+)\s*$/;
+/** `note: run with `RUST_BACKTRACE=1` ...` / `note: Some details are omitted...` */
+const NOTE = /^note:\s/;
+export function parseRustPanicHeader(line) {
+    const modern = HEADER_MODERN.exec(line);
+    if (modern?.groups) {
+        return {
+            thread: modern.groups["thread"] ?? "",
+            file: modern.groups["file"] ?? "",
+            line: Number(modern.groups["line"]),
+            column: Number(modern.groups["col"]),
+            message: null,
+        };
+    }
+    const legacy = HEADER_LEGACY.exec(line);
+    if (legacy?.groups) {
+        return {
+            thread: legacy.groups["thread"] ?? "",
+            file: legacy.groups["file"] ?? "",
+            line: Number(legacy.groups["line"]),
+            column: Number(legacy.groups["col"]),
+            message: legacy.groups["message"] ?? "",
+        };
+    }
+    return null;
+}
+export function isRustHeaderLine(line) {
+    return parseRustPanicHeader(line) !== null;
+}
+export function isRustBacktraceStartLine(line) {
+    return BACKTRACE_START.test(line);
+}
+export function isRustFrameSymbolLine(line) {
+    return FRAME_SYMBOL.test(line);
+}
+export function isRustFrameLocationLine(line) {
+    return FRAME_LOCATION.test(line);
+}
+export function isRustNoteLine(line) {
+    return NOTE.test(line);
+}
+/** The symbol half of a frame; the location half is optional and supplied separately. */
+export function parseRustFrameSymbol(line) {
+    const match = FRAME_SYMBOL.exec(line);
+    return match?.groups?.["symbol"] ?? null;
+}
+export function parseRustFrameLocation(line) {
+    const match = FRAME_LOCATION.exec(line);
+    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.
+ *
+ * Rust's specific hazard is `   0: something` — a numbered list item is an
+ * ordinary thing to print, and a stateless rule accepting it would turn any
+ * enumerated log output into a stack-trace block. A numbered symbol line
+ * therefore only counts as block content **after `stack backtrace:`**.
+ *
+ * The panic message line, which follows the header and is arbitrary text,
+ * is accepted as block content only in the single position where Rust puts
+ * it: immediately after a modern header.
+ */
+export function createRustLineClassifier() {
+    let justSawHeader = false;
+    let inBacktrace = false;
+    return {
+        isHeader(line) {
+            if (isRustHeaderLine(line)) {
+                justSawHeader = true;
+                inBacktrace = false;
+                return true;
+            }
+            return false;
+        },
+        isFrame(line) {
+            if (justSawHeader) {
+                // The message line, or — for a legacy header, which carries its own
+                // message — whatever comes next. Either way exactly one line.
+                justSawHeader = false;
+                return true;
+            }
+            if (isRustBacktraceStartLine(line)) {
+                inBacktrace = true;
+                return true;
+            }
+            if (isRustNoteLine(line))
+                return true;
+            if (inBacktrace && (isRustFrameSymbolLine(line) || isRustFrameLocationLine(line)))
+                return true;
+            inBacktrace = false;
+            return false;
+        },
+    };
+}
+//# sourceMappingURL=rust-frame-parsing.js.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * The concrete `RuntimeAdapter` for Rust.
+ *
+ * **Reliability is decided per frame, from whether the frame printed an
+ * `at` line at all.** A Rust backtrace in a debug build prints
+ * `symbol` followed by `at path:line:col`; a build without debug info
+ * prints the symbol alone. That is the same binary distinction the JVM
+ * makes between a class with and without a `LineNumberTable`, so it takes
+ * the same two values: `debug-info-present` when a location came back,
+ * `debug-info-stripped` when the symbol is all there is.
+ *
+ * **Not handled, and named rather than left to be discovered:**
+ * `-C split-debuginfo=packed` puts DWARF in a separate `.dwp` file, which
+ * *is* a side artifact and would deserve the `side-artifact-*` values. The
+ * default on Linux embeds it, that is what was verified here, and inferring
+ * which mode a binary was built in from its text output is not possible —
+ * so a split-debuginfo build is currently classified as though it were
+ * embedded. It reports `debug-info-stripped` for frames whose location is
+ * missing, which is true but understates why.
+ */
+import type { RuntimeAdapter } from "@descryy/runtime-backend-observation";
+import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
+export declare function createRustSourceLocationResolver(): SourceLocationResolver;
+export interface RustRuntimeAdapterOptions {
+    /** Attributed on every emitted Evidence's `service` field (plan §16.7). Omit when not applicable. */
+    readonly service?: string;
+}
+export declare function createRustRuntimeAdapter(options?: RustRuntimeAdapterOptions): RuntimeAdapter;
+//# sourceMappingURL=rust-runtime-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/rust-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,sCAAsC,CAAC;AAGhG,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAKrG,wBAAgB,gCAAgC,IAAI,sBAAsB,CAezE;AAED,MAAM,WAAW,yBAAyB;IACxC,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,yBAA8B,GAAG,cAAc,CAgBhG"}

package/dist/rust-runtime-adapter.js

@@ -0,0 +1,53 @@
+/**
+ * The concrete `RuntimeAdapter` for Rust.
+ *
+ * **Reliability is decided per frame, from whether the frame printed an
+ * `at` line at all.** A Rust backtrace in a debug build prints
+ * `symbol` followed by `at path:line:col`; a build without debug info
+ * prints the symbol alone. That is the same binary distinction the JVM
+ * makes between a class with and without a `LineNumberTable`, so it takes
+ * the same two values: `debug-info-present` when a location came back,
+ * `debug-info-stripped` when the symbol is all there is.
+ *
+ * **Not handled, and named rather than left to be discovered:**
+ * `-C split-debuginfo=packed` puts DWARF in a separate `.dwp` file, which
+ * *is* a side artifact and would deserve the `side-artifact-*` values. The
+ * default on Linux embeds it, that is what was verified here, and inferring
+ * which mode a binary was built in from its text output is not possible —
+ * so a split-debuginfo build is currently classified as though it were
+ * embedded. It reports `debug-info-stripped` for frames whose location is
+ * missing, which is true but understates why.
+ */
+import { createLogCollector } from "@descryy/runtime-backend-observation";
+import { createRustLineClassifier } from "./rust-frame-parsing.js";
+import { createRustStackTraceParser } from "./rust-stack-trace-parser.js";
+export function createRustSourceLocationResolver() {
+    return {
+        resolve(frame) {
+            return Promise.resolve({
+                file: frame.file,
+                line: frame.line,
+                // Rust is the only runtime here besides V8 that prints a real
+                // column, and it prints one in the panic header too.
+                column: frame.column,
+                functionName: frame.functionName,
+                reliability: frame.line === null ? "debug-info-stripped" : "debug-info-present",
+                resolvedVia: null,
+            });
+        },
+    };
+}
+export function createRustRuntimeAdapter(options = {}) {
+    const sourceLocationResolver = createRustSourceLocationResolver();
+    const stackTraceParser = createRustStackTraceParser(sourceLocationResolver);
+    function createBackendCollectors(sources) {
+        return sources.map((source) => createLogCollector({
+            source,
+            classifier: createRustLineClassifier(),
+            stackTraceParser,
+            ...(options.service !== undefined ? { service: options.service } : {}),
+        }));
+    }
+    return { language: "rust", stackTraceParser, sourceLocationResolver, createBackendCollectors };
+}
+//# sourceMappingURL=rust-runtime-adapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust-runtime-adapter.js","sourceRoot":"","sources":["../src/rust-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAG1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,MAAM,UAAU,gCAAgC;IAC9C,OAAO;QACL,OAAO,CAAC,KAAuB;YAC7B,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,8DAA8D;gBAC9D,qDAAqD;gBACrD,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,WAAW,EAAE,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,oBAAoB;gBAC/E,WAAW,EAAE,IAAI;aAClB,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC;AAOD,MAAM,UAAU,wBAAwB,CAAC,UAAqC,EAAE;IAC9E,MAAM,sBAAsB,GAAG,gCAAgC,EAAE,CAAC;IAClE,MAAM,gBAAgB,GAAG,0BAA0B,CAAC,sBAAsB,CAAC,CAAC;IAE5E,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,UAAU,EAAE,wBAAwB,EAAE;YACtC,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,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,CAAC;AACjG,CAAC"}

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

@@ -0,0 +1,78 @@
+/**
+ * Composes Rust's line recognition with a `SourceLocationResolver`.
+ *
+ * **A panic with no backtrace still yields a location, and that is the
+ * common case.** `RUST_BACKTRACE` is off by default, so ordinary production
+ * output is three lines: the header, the message, and a note suggesting you
+ * turn the backtrace on. The header carries `file:line:column` for the
+ * panic site itself — more precise than most runtimes manage *with* a
+ * backtrace. Returning null there would discard the best location Rust ever
+ * prints, so a header-only panic produces a single-frame trace whose
+ * `functionName` is null: the position is known, the function is not, and
+ * neither is invented.
+ *
+ * When a backtrace is present, its frames replace that single frame — they
+ * include the panic site and add the chain above it.
+ *
+ * **`std` and `core` frames are kept.** They are real frames and the top of
+ * every Rust backtrace is several of them (`rust_begin_unwind`,
+ * `panic_fmt`, `expect_failed`). Filtering them would be a readability
+ * judgment applied to evidence, and the frame list is not the place for it
+ * — a consumer that wants only application frames can filter on the paths,
+ * which are preserved exactly.
+ *
+ * **But the frames above the panic site are rooted out, and Rust itself
+ * says where that is.** Measured on a live threaded server (RT-121):
+ *
+ * ```
+ * thread '<unnamed>' (531538) panicked at server.rs:10:31:
+ * invoice has no customer
+ * stack backtrace:
+ *    0: __rustc::rust_begin_unwind
+ *    …
+ *    4: core::option::Option<T>::expect
+ *    5: server::read_customer_name
+ *              at ./server.rs:10:31          <- the header's own location
+ *    6: server::delete_invoice
+ * ```
+ *
+ * `frames[0]` becomes `Evidence.sourceLocation` for every language
+ * (`collector.ts`), so untouched this reports
+ * `library/std/src/panicking.rs:698` — inside the Rust standard library —
+ * for every panic.
+ *
+ * **And the runtime turns the backtrace on itself.** `RUST_BACKTRACE` is
+ * off in ordinary Rust, but `withDefaultProcessEnv` sets it to `1` for
+ * every process the controller spawns — a deliberate, separately-reasoned
+ * decision (a panic with no backtrace is a collector-absence masquerading
+ * as application success). So the backtrace shape is not the unusual case
+ * here; inside Descry it is the *only* case, unless a caller opts out
+ * explicitly. Which means without this rooting, the more diagnostics the
+ * platform asks Rust for, the worse the location it reports: the header-only
+ * path below yields the exact panic site, and the enriched path yields
+ * `panicking.rs`. That was measured (RT-121), after being predicted
+ * backwards — this comment first claimed the header-only shape was the
+ * production default *for the managed path*, which the controller had
+ * already made false.
+ *
+ * This is **not** the std/core filter the paragraph above refuses, and
+ * since RT-083 it does not even look like one: **every frame stays in
+ * `frames`** and `primaryFrameIndex` points at the failure site. The
+ * decision above — *"std and core frames are kept; filtering them would be
+ * a readability judgment applied to evidence"* — is honoured rather than
+ * superseded. An earlier version of this parser sliced the list, and the
+ * contract gaining a field for the distinction is what made that
+ * unnecessary.
+ *
+ * The join is exact, on a position the runtime printed itself: the header's
+ * `file:line:column`, matched against a frame's own `at` location, column
+ * included. No name is inspected, no path is classified as "library" or
+ * "application", and a backtrace with no matching frame leaves the index at
+ * `0` rather than guessing — which is why `core::option::Option<T>::expect`
+ * being a `core` frame is irrelevant. It happens to sit above the declared
+ * panic site; a `core` frame *below* it would be pointed at just the same
+ * if that is where the header said the panic was.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createRustStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=rust-stack-trace-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/rust-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AA+BrG,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAgF7F"}

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

@@ -0,0 +1,176 @@
+/**
+ * Composes Rust's line recognition with a `SourceLocationResolver`.
+ *
+ * **A panic with no backtrace still yields a location, and that is the
+ * common case.** `RUST_BACKTRACE` is off by default, so ordinary production
+ * output is three lines: the header, the message, and a note suggesting you
+ * turn the backtrace on. The header carries `file:line:column` for the
+ * panic site itself — more precise than most runtimes manage *with* a
+ * backtrace. Returning null there would discard the best location Rust ever
+ * prints, so a header-only panic produces a single-frame trace whose
+ * `functionName` is null: the position is known, the function is not, and
+ * neither is invented.
+ *
+ * When a backtrace is present, its frames replace that single frame — they
+ * include the panic site and add the chain above it.
+ *
+ * **`std` and `core` frames are kept.** They are real frames and the top of
+ * every Rust backtrace is several of them (`rust_begin_unwind`,
+ * `panic_fmt`, `expect_failed`). Filtering them would be a readability
+ * judgment applied to evidence, and the frame list is not the place for it
+ * — a consumer that wants only application frames can filter on the paths,
+ * which are preserved exactly.
+ *
+ * **But the frames above the panic site are rooted out, and Rust itself
+ * says where that is.** Measured on a live threaded server (RT-121):
+ *
+ * ```
+ * thread '<unnamed>' (531538) panicked at server.rs:10:31:
+ * invoice has no customer
+ * stack backtrace:
+ *    0: __rustc::rust_begin_unwind
+ *    …
+ *    4: core::option::Option<T>::expect
+ *    5: server::read_customer_name
+ *              at ./server.rs:10:31          <- the header's own location
+ *    6: server::delete_invoice
+ * ```
+ *
+ * `frames[0]` becomes `Evidence.sourceLocation` for every language
+ * (`collector.ts`), so untouched this reports
+ * `library/std/src/panicking.rs:698` — inside the Rust standard library —
+ * for every panic.
+ *
+ * **And the runtime turns the backtrace on itself.** `RUST_BACKTRACE` is
+ * off in ordinary Rust, but `withDefaultProcessEnv` sets it to `1` for
+ * every process the controller spawns — a deliberate, separately-reasoned
+ * decision (a panic with no backtrace is a collector-absence masquerading
+ * as application success). So the backtrace shape is not the unusual case
+ * here; inside Descry it is the *only* case, unless a caller opts out
+ * explicitly. Which means without this rooting, the more diagnostics the
+ * platform asks Rust for, the worse the location it reports: the header-only
+ * path below yields the exact panic site, and the enriched path yields
+ * `panicking.rs`. That was measured (RT-121), after being predicted
+ * backwards — this comment first claimed the header-only shape was the
+ * production default *for the managed path*, which the controller had
+ * already made false.
+ *
+ * This is **not** the std/core filter the paragraph above refuses, and
+ * since RT-083 it does not even look like one: **every frame stays in
+ * `frames`** and `primaryFrameIndex` points at the failure site. The
+ * decision above — *"std and core frames are kept; filtering them would be
+ * a readability judgment applied to evidence"* — is honoured rather than
+ * superseded. An earlier version of this parser sliced the list, and the
+ * contract gaining a field for the distinction is what made that
+ * unnecessary.
+ *
+ * The join is exact, on a position the runtime printed itself: the header's
+ * `file:line:column`, matched against a frame's own `at` location, column
+ * included. No name is inspected, no path is classified as "library" or
+ * "application", and a backtrace with no matching frame leaves the index at
+ * `0` rather than guessing — which is why `core::option::Option<T>::expect`
+ * being a `core` frame is irrelevant. It happens to sit above the declared
+ * panic site; a `core` frame *below* it would be pointed at just the same
+ * if that is where the header said the panic was.
+ */
+import { isRustBacktraceStartLine, parseRustFrameLocation, parseRustFrameSymbol, parseRustPanicHeader, } from "./rust-frame-parsing.js";
+/**
+ * Whether a backtrace frame's own `at` location is the position the panic
+ * header declared.
+ *
+ * Line and column must match exactly — a column is precise enough that two
+ * distinct frames sharing one is not a case worth hedging against. The file
+ * comparison is a suffix test in either direction because the two are
+ * printed by different code paths and disagree on prefix: the header says
+ * `server.rs:10:31` where the frame says `at ./server.rs:10:31` (measured),
+ * and under cargo both are relative to different roots. Requiring string
+ * equality would silently never match, which is the failure mode that reads
+ * as "this rule does nothing" while every test still passes.
+ */
+function isDeclaredPanicSite(header, location) {
+    if (location === null)
+        return false;
+    if (location.line !== header.line || location.column !== header.column)
+        return false;
+    const frameFile = location.file.replace(/^\.\//, "");
+    const headerFile = header.file.replace(/^\.\//, "");
+    return frameFile.endsWith(headerFile) || headerFile.endsWith(frameFile);
+}
+export function createRustStackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            const lines = rawText.split(/\r\n|\r|\n/);
+            const header = lines.map(parseRustPanicHeader).find((h) => h !== null) ?? null;
+            const backtraceStart = lines.findIndex(isRustBacktraceStartLine);
+            if (header === null && backtraceStart === -1)
+                return null;
+            const frames = [];
+            /** Index of the frame at the header's own declared position, or -1 if the backtrace never names it. */
+            let declaredPanicSite = -1;
+            if (backtraceStart !== -1) {
+                for (let i = backtraceStart + 1; i < lines.length; i++) {
+                    const symbolLine = lines[i];
+                    if (symbolLine === undefined)
+                        continue;
+                    const symbol = parseRustFrameSymbol(symbolLine);
+                    if (symbol === null)
+                        continue;
+                    // The `at` line is optional: a build without debug info prints
+                    // the symbol alone. Looking ahead one line and accepting its
+                    // absence is what makes debug-info-stripped observable rather
+                    // than a fabricated location.
+                    const next = lines[i + 1];
+                    const location = next === undefined ? null : parseRustFrameLocation(next);
+                    const resolved = await resolver.resolve({
+                        file: location?.file ?? null,
+                        line: location?.line ?? null,
+                        column: location?.column ?? null,
+                        functionName: symbol,
+                    });
+                    frames.push({ location: resolved, raw: location === null ? symbolLine : `${symbolLine}\n${next}` });
+                    // First match only: a recursive panic site would repeat the
+                    // position further down, and the outermost repetition is not
+                    // where execution was.
+                    if (declaredPanicSite === -1 && header !== null && isDeclaredPanicSite(header, location)) {
+                        declaredPanicSite = frames.length - 1;
+                    }
+                    if (location !== null)
+                        i++;
+                }
+            }
+            if (frames.length === 0) {
+                if (header === null)
+                    return null;
+                // Header-only panic: the position is real, the function is not
+                // known, and `functionName: null` says so rather than guessing.
+                const resolved = await resolver.resolve({
+                    file: header.file,
+                    line: header.line,
+                    column: header.column,
+                    functionName: null,
+                });
+                // One frame, and it IS the panic site — the header said so.
+                return { fidelity: "synchronous", frames: [{ location: resolved, raw: rawText.split(/\r\n|\r|\n/)[0] ?? "" }], primaryFrameIndex: 0 };
+            }
+            // Points at the position the header declared, when the backtrace
+            // names it. `declaredPanicSite === -1` means it did not — an inlined
+            // frame, a `RUST_BACKTRACE=full` layout, a header this parser read
+            // from a different panic — and the index stays `0`, because the
+            // alternative is choosing a site on no evidence.
+            const primaryFrameIndex = declaredPanicSite > 0 ? declaredPanicSite : 0;
+            // Rust prints most-recent-first (index 0 is the innermost frame),
+            // like V8 and the JVM and unlike CPython — read off the real
+            // backtrace, where `delete_invoice` precedes `handler` precedes
+            // `main`. No reversal.
+            //
+            // Fidelity is `synchronous`: a Rust backtrace walks the real thread
+            // stack. An async task's stack genuinely ends at the executor's poll
+            // rather than at the logical `.await`er, but nothing in the text says
+            // so — detecting it would need runtime task correlation, and claiming
+            // fragmentation without evidence is the guess this project refuses.
+            // A disclosed under-report, consistent with Kotlin's marker rule.
+            return { fidelity: "synchronous", frames, primaryFrameIndex };
+        },
+    };
+}
+//# sourceMappingURL=rust-stack-trace-parser.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust-stack-trace-parser.js","sourceRoot":"","sources":["../src/rust-stack-trace-parser.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@descryy/runtime-adapter-rust",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "Runtime adapter (rust).",
+  "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": "*",
+    "@descryy/runtime-backend-observation": "*"
+  }
+}