@descryy/runtime-adapter-swift 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { RawSwiftFrame } from "./swift-frame-parsing.ts";
+export { createSwiftLineClassifier, isSwiftCrashedThreadLine, isSwiftFrameLine, isSwiftHeaderLine, isSwiftThreadLine, isSwiftUnsymbolicatedFrameLine, parseSwiftFrame, parseSwiftHeaderPosition, } from "./swift-frame-parsing.ts";
+export { createSwiftSourceLocationResolver } from "./swift-source-location-resolver.ts";
+export { createSwiftStackTraceParser } from "./swift-stack-trace-parser.ts";
+export type { SwiftRuntimeAdapterOptions } from "./swift-runtime-adapter.ts";
+export { createSwiftRuntimeAdapter } from "./swift-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,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,8BAA8B,EAC9B,eAAe,EACf,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,YAAY,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createSwiftLineClassifier, isSwiftCrashedThreadLine, isSwiftFrameLine, isSwiftHeaderLine, isSwiftThreadLine, isSwiftUnsymbolicatedFrameLine, parseSwiftFrame, parseSwiftHeaderPosition, } from "./swift-frame-parsing.js";
+export { createSwiftSourceLocationResolver } from "./swift-source-location-resolver.js";
+export { createSwiftStackTraceParser } from "./swift-stack-trace-parser.js";
+export { createSwiftRuntimeAdapter } from "./swift-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,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,8BAA8B,EAC9B,eAAe,EACf,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC"}

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

@@ -0,0 +1,126 @@
+/**
+ * Swift crash-handler trace line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction
+ * that feeds `SourceLocationResolver`.
+ *
+ * Grammar verified against two things in `swiftlang/swift` itself, not
+ * memory or a blog post:
+ *
+ * - `test/Backtracing/FatalError.swift` — a real `FileCheck` test the
+ *   Swift project's own CI compiles, runs, and crashes on purpose,
+ *   asserting the exact backtrace text against the real interpreter's
+ *   output. This is the same category of source `ruby/spec` was for
+ *   RT-038 and `php-src`'s `.phpt` suite was for RT-040: interpreter-
+ *   verified, not merely documented.
+ * - `stdlib/public/runtime/RuntimeErrorReporting.cpp` — confirms frame
+ *   symbols are demangled by the runtime's own embedded demangler
+ *   (`demangleSymbolAsString`) before being printed, which matters for
+ *   what "mangled names" turns out to mean here — see point 4.
+ *
+ * No `swift` toolchain ran here; see `test/fixtures/PROVENANCE.md`.
+ *
+ * 1. **Header and first frame are separated by TWO fixed bridging lines,
+ *    not one** — a shape none of this seam's other languages have had.
+ *    `Fatal error: <message>` is followed by `*** Program crashed: <reason>
+ *    at 0x<addr> ***`, then `Thread N [...] crashed:`, then (per the
+ *    `FileCheck` test's plain `CHECK` rather than `CHECK-NEXT` between
+ *    the thread line and frame 0) a blank line, before real frames start.
+ *    PHP needed one bridging line (`Stack trace:`); C#'s `InnerException`
+ *    case needed one (` ---> `). Swift needs two, plus tolerating a blank
+ *    line — the same family of gap, escalated. Reported via
+ *    `LineClassifier.isBridge` (RT-048), which `ExceptionBlockDetector`
+ *    only ever consults while a header is already being held, so neither
+ *    bridging line can open a block from idle on its own —
+ *    `createSwiftLineClassifier` tracks a small stage counter (which of
+ *    the two bridge lines is next) rather than a single boolean, since
+ *    "confirm bridge line 1, then bridge line 2" is a short sequence, not
+ *    a single yes/no; `isFrame` itself stays a plain, stateless check for
+ *    the real frame shape.
+ * 2. **A frame is `<index> [flags]* 0x<addr> <symbol> + <offset> in
+ *    <image>`, optionally ` at <file>:<line>:<col>`.** Index 0 is the
+ *    innermost frame (the trap site itself) and the sequence counts
+ *    upward to the process entry point — most-recent-first already, the
+ *    same convention as V8/JVM/Go/Rust/C#; CPython remains the only
+ *    reversing outlier in this codebase. `[ra]` and `[system]` are real,
+ *    disclosed flags (a return-address frame; a Swift-runtime-internal
+ *    frame) and are not stripped — they stay in `raw`, and are not
+ *    parsed into anything structured because nothing in this contract
+ *    has a field for them.
+ * 3. **The location suffix can be a real `file:line:col`, or a pseudo-path
+ *    with neither** — `<compiler-generated>` for a compiler-synthesized
+ *    frame (confirmed verbatim in the cited test: `static
+ *    FatalError.$main() ... at {{.*}}/<compiler-generated>`), the same
+ *    "real text, not a real source position" case CPython's pseudo-files
+ *    already established a precedent for. Both shapes are handled: a
+ *    `file:line:col` suffix is parsed into real fields; anything else
+ *    after `at ` is kept as `file` verbatim with `line`/`column` null,
+ *    never a fabricated position.
+ * 4. **"Mangled symbol names" turns out to mean something narrower than
+ *    it sounds, verified rather than assumed from the lane brief.**
+ *    `RuntimeErrorReporting.cpp`'s `dumpStackTraceEntry` demangles via
+ *    `__cxa_demangle`/Swift's own `demangleSymbolAsString` automatically
+ *    whenever symbol lookup succeeds — no external `swift-demangle`
+ *    binary is needed, and the cited test's own frames are all
+ *    already-demangled (`level5()`, `static FatalError.main()`). A raw
+ *    `$s...`-prefixed name surviving into this text specifically means
+ *    the runtime's own demangler failed on it, not that demangling was
+ *    skipped. This parser does not attempt demangling itself either way
+ *    — whatever text is there, verbatim, is `functionName`.
+ */
+export interface RawSwiftFrame {
+    /** Whatever text the runtime printed for this frame — demangled, a fallback token, or (rarely) still mangled. Never rewritten. */
+    readonly functionName: string | null;
+    /** Null for a frame with no `at ...` location suffix at all (no debug info available for that image). */
+    readonly file: string | null;
+    /** Null when `file` is null, OR when `file` is a pseudo-path like `<compiler-generated>` with no real line. */
+    readonly line: number | null;
+    readonly column: number | null;
+}
+export declare function isSwiftHeaderLine(line: string): boolean;
+export declare function isSwiftFrameLine(line: string): boolean;
+/** True for a frame the backtracer printed but could not name — a real frame of a real stack, carrying only its address. */
+export declare function isSwiftUnsymbolicatedFrameLine(line: string): boolean;
+/** Any thread block header, `crashed` or not — what separates one thread's stack from another's. */
+export declare function isSwiftThreadLine(line: string): boolean;
+/** Only the thread that actually trapped. In a multi-thread dump the others precede it. */
+export declare function isSwiftCrashedThreadLine(line: string): boolean;
+/** The `file:line` the `Fatal error:` line declares, or null when it declares none. Never fabricated. */
+export declare function parseSwiftHeaderPosition(line: string): {
+    readonly file: string;
+    readonly line: number;
+} | null;
+/**
+ * Stateful for the bridge between header and first frame (point 1 above),
+ * reported via `LineClassifier.isBridge` (RT-048).
+ *
+ * **RT-122 measured a real Swift 6.1.2 crash on Linux and the bridge is
+ * three lines, not two.** `*** Signal 4: Backtracing from 0x…... done ***`
+ * comes first, and the `FileCheck` test this was transcribed from does not
+ * contain it. Missing it was total rather than partial: the block closed
+ * before the first frame and a real Swift crash produced no evidence at
+ * all. The signal line is accepted as optional so both shapes work.
+ * `ExceptionBlockDetector` only ever consults `isBridge` while a header is
+ * already being held, so `*** Program crashed...` and `Thread N ...
+ * crashed:` cannot open a block on their own from idle — that guarantee is
+ * now the state machine's, not this classifier's to re-derive, which is
+ * what let `isFrame` shrink back to a plain, stateless check for the real
+ * frame shape: it no longer has to also recognise the bridge, only the
+ * thing that ends it.
+ *
+ * **Blank lines are tolerated at any point in the bridge, not just one.**
+ * The cited `FileCheck` test uses plain `CHECK:` (not `CHECK-NEXT:`)
+ * between the header, the two bridging lines, and frame 0, which permits
+ * — but does not confirm — a blank line at each gap; the test's own
+ * comment formatting cannot be trusted to mirror the real output's
+ * spacing. Rather than guess a specific count and position, every stage
+ * of the bridge accepts an arbitrary run of blank lines before the
+ * pattern it expects.
+ */
+export declare function createSwiftLineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+    isBridge(line: string): boolean;
+};
+/** `null` for anything not shaped like a real crash-handler frame — never fabricated. */
+export declare function parseSwiftFrame(line: string): RawSwiftFrame | null;
+//# sourceMappingURL=swift-frame-parsing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-frame-parsing.d.ts","sourceRoot":"","sources":["../src/swift-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAEH,MAAM,WAAW,aAAa;IAC5B,kIAAkI;IAClI,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,yGAAyG;IACzG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,+GAA+G;IAC/G,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAsGD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,4HAA4H;AAC5H,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,2FAA2F;AAC3F,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,yGAAyG;AACzG,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO9G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,IAAI;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAyEA;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAqClE"}

package/dist/swift-frame-parsing.js

@@ -0,0 +1,330 @@
+/**
+ * Swift crash-handler trace line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction
+ * that feeds `SourceLocationResolver`.
+ *
+ * Grammar verified against two things in `swiftlang/swift` itself, not
+ * memory or a blog post:
+ *
+ * - `test/Backtracing/FatalError.swift` — a real `FileCheck` test the
+ *   Swift project's own CI compiles, runs, and crashes on purpose,
+ *   asserting the exact backtrace text against the real interpreter's
+ *   output. This is the same category of source `ruby/spec` was for
+ *   RT-038 and `php-src`'s `.phpt` suite was for RT-040: interpreter-
+ *   verified, not merely documented.
+ * - `stdlib/public/runtime/RuntimeErrorReporting.cpp` — confirms frame
+ *   symbols are demangled by the runtime's own embedded demangler
+ *   (`demangleSymbolAsString`) before being printed, which matters for
+ *   what "mangled names" turns out to mean here — see point 4.
+ *
+ * No `swift` toolchain ran here; see `test/fixtures/PROVENANCE.md`.
+ *
+ * 1. **Header and first frame are separated by TWO fixed bridging lines,
+ *    not one** — a shape none of this seam's other languages have had.
+ *    `Fatal error: <message>` is followed by `*** Program crashed: <reason>
+ *    at 0x<addr> ***`, then `Thread N [...] crashed:`, then (per the
+ *    `FileCheck` test's plain `CHECK` rather than `CHECK-NEXT` between
+ *    the thread line and frame 0) a blank line, before real frames start.
+ *    PHP needed one bridging line (`Stack trace:`); C#'s `InnerException`
+ *    case needed one (` ---> `). Swift needs two, plus tolerating a blank
+ *    line — the same family of gap, escalated. Reported via
+ *    `LineClassifier.isBridge` (RT-048), which `ExceptionBlockDetector`
+ *    only ever consults while a header is already being held, so neither
+ *    bridging line can open a block from idle on its own —
+ *    `createSwiftLineClassifier` tracks a small stage counter (which of
+ *    the two bridge lines is next) rather than a single boolean, since
+ *    "confirm bridge line 1, then bridge line 2" is a short sequence, not
+ *    a single yes/no; `isFrame` itself stays a plain, stateless check for
+ *    the real frame shape.
+ * 2. **A frame is `<index> [flags]* 0x<addr> <symbol> + <offset> in
+ *    <image>`, optionally ` at <file>:<line>:<col>`.** Index 0 is the
+ *    innermost frame (the trap site itself) and the sequence counts
+ *    upward to the process entry point — most-recent-first already, the
+ *    same convention as V8/JVM/Go/Rust/C#; CPython remains the only
+ *    reversing outlier in this codebase. `[ra]` and `[system]` are real,
+ *    disclosed flags (a return-address frame; a Swift-runtime-internal
+ *    frame) and are not stripped — they stay in `raw`, and are not
+ *    parsed into anything structured because nothing in this contract
+ *    has a field for them.
+ * 3. **The location suffix can be a real `file:line:col`, or a pseudo-path
+ *    with neither** — `<compiler-generated>` for a compiler-synthesized
+ *    frame (confirmed verbatim in the cited test: `static
+ *    FatalError.$main() ... at {{.*}}/<compiler-generated>`), the same
+ *    "real text, not a real source position" case CPython's pseudo-files
+ *    already established a precedent for. Both shapes are handled: a
+ *    `file:line:col` suffix is parsed into real fields; anything else
+ *    after `at ` is kept as `file` verbatim with `line`/`column` null,
+ *    never a fabricated position.
+ * 4. **"Mangled symbol names" turns out to mean something narrower than
+ *    it sounds, verified rather than assumed from the lane brief.**
+ *    `RuntimeErrorReporting.cpp`'s `dumpStackTraceEntry` demangles via
+ *    `__cxa_demangle`/Swift's own `demangleSymbolAsString` automatically
+ *    whenever symbol lookup succeeds — no external `swift-demangle`
+ *    binary is needed, and the cited test's own frames are all
+ *    already-demangled (`level5()`, `static FatalError.main()`). A raw
+ *    `$s...`-prefixed name surviving into this text specifically means
+ *    the runtime's own demangler failed on it, not that demangling was
+ *    skipped. This parser does not attempt demangling itself either way
+ *    — whatever text is there, verbatim, is `functionName`.
+ */
+/** Not anchored to the start of the line, same reasoning as every other adapter's header pattern: a logger prefix may precede it. */
+const HEADER_PATTERN = /Fatal error: (?<message>.+)$/;
+const PROGRAM_CRASHED_PATTERN = /^\*\*\* Program crashed: .+ \*\*\*$/;
+/**
+ * `*** Signal 4: Backtracing from 0x787be4d66895... done ***` — the
+ * backtracer announcing itself, printed BEFORE `*** Program crashed ***`.
+ *
+ * **Measured on a real Swift 6.1.2 crash on Linux (RT-122); it is not in
+ * the `FileCheck` test this adapter was transcribed from.** Its absence
+ * from the bridge was total: the held header met a line matching nothing,
+ * the block closed before a single frame, and a real Swift crash produced
+ * no evidence at all — not an error, no evidence.
+ *
+ * Optional rather than required, because the transcribed fixtures (and
+ * whatever produced them) do not have it, and a bridge that demands it
+ * would trade one silence for another.
+ */
+const SIGNAL_BACKTRACING_PATTERN = /^\*\*\* Signal \d+: Backtracing from 0x[0-9a-fA-F]+\.\.\. done \*\*\*$/;
+/**
+ * A thread block's own header: `Thread 1 crashed:`, `Thread 0 "server"
+ * crashed:`, or — **measured, and the transcribed fixtures have no such
+ * case** — `Thread 0 "server":` with no `crashed` at all.
+ *
+ * When the trap happens off the main thread, Swift dumps *every* thread and
+ * only one carries `crashed`. The uncrashed ones come first. So the two
+ * spellings are different facts, not formatting: `isSwiftCrashedThreadLine`
+ * is what says which stack actually trapped.
+ */
+const THREAD_PATTERN = /^Thread \d+(?:\s+"[^"]*")?(?:\s+crashed)?:\s*$/;
+const THREAD_CRASHED_PATTERN = /^Thread \d+.*crashed:\s*$/;
+/**
+ * The position Swift's own `Fatal error:` line declares:
+ * `server/server.swift:10: Fatal error: Unexpectedly found nil …`.
+ *
+ * `#file` defaults to `Module/File.swift`, so requiring the `.swift`
+ * extension keeps this from matching a `log`-style `02:11:06` timestamp.
+ * The transcribed fixtures carry no position at all — that is a real
+ * difference between the two shapes, and it degrades to "no declared
+ * position" rather than to a guess.
+ */
+const HEADER_POSITION_PATTERN = /(?<file>\S+\.swift):(?<line>\d+):\s+Fatal error:/;
+/**
+ * `<index> [flag]* 0x<hex> <symbol> + <offset> in <image>[ at <location>]`.
+ * The mandatory `0x<hex address>` in the middle is what makes this safe
+ * against the numbered-log-line hazard the rest of this lane's adapters
+ * were warned about (PHP's `#N`, C#'s bare `at`): an ordinary numbered
+ * status line never contains a hex address in this exact position.
+ * `symbol` is greedy — correct because the ` + <offset> in <image>`
+ * suffix is anchored and unique per line, so backtracking finds it
+ * regardless of what the symbol text itself contains.
+ */
+const FRAME_PATTERN = /^\d+\s+(?:\[[\w-]+\]\s+)*0x[0-9a-fA-F]+\s+(?<symbol>.+?)(?:\s\+\s\d+)?\s+in\s+(?<image>\S+)(?:\s+at\s+(?<location>.+))?\s*$/;
+/**
+ * **`+ <offset>` is optional, and requiring it took CI red (RT-133).**
+ *
+ * Swift prints `<symbol> + <offset> in <image>` for a frame it can name and
+ * `<unknown> in <image>` — no offset — for one it cannot. Every frame in the
+ * 6.1.2 dump this parser was built against had an offset, because this
+ * machine has libc symbols; the CI runner does not, so `Thread 0`'s first
+ * frame is `<unknown> in libc.so.6`. `isSwiftFrameLine` gates
+ * `LineClassifier.isFrame`, so the block closed on that line, at 247
+ * characters, and the crashed thread three blocks below was never captured.
+ *
+ * `symbol` became lazy (`.+?`) with the offset optional. Greedy plus
+ * optional would let `.+` swallow ` + 309` and report the offset as part of
+ * the function name.
+ */
+const UNNAMED_SYMBOL = "<unknown>";
+/**
+ * The same line with **no symbol at all**: `4 [ra] 0x00005b3df1642b54`.
+ *
+ * **Measured, and it is what took CI red (RT-126).** Swift's backtracer
+ * symbolicates against the binary's debug info while printing; when it
+ * cannot — `symbolicate=off`, or an environment where the images are not
+ * readable — it still unwinds correctly and prints every frame as an
+ * address. The GitHub runner's first-ever Swift run produced exactly this
+ * and `FRAME_PATTERN` matched none of it.
+ *
+ * The cost was **not** just unparsed frames. `isSwiftFrameLine` gates
+ * `LineClassifier.isFrame`, so the exception block closed at the thread
+ * header and `payload.raw` was **247 characters** — the addresses were
+ * never captured either, so nothing downstream could resolve them offline.
+ * A degradation that also destroys the evidence of itself.
+ *
+ * Safe against the numbered-log-line hazard for the same reason
+ * `FRAME_PATTERN` is, and anchored at both ends so it cannot swallow the
+ * `Registers:` and `Images:` sections that follow the crashed thread in the
+ * same slice: register lines begin with a register name (`rax`, ` r8`) and
+ * image lines with `0x`, so neither can present a leading frame index.
+ * Asserted, not assumed — see this package's unsymbolicated-dump test.
+ */
+const UNSYMBOLICATED_FRAME_PATTERN = /^\d+\s+(?:\[[\w-]+\]\s+)*0x[0-9a-fA-F]+\s*$/;
+/** A real source position: `file:line:col`. Anchored at both ends so a bare pseudo-path like `<compiler-generated>` never matches. */
+const FILE_LINE_COL_PATTERN = /^(?<file>.+):(?<line>\d+):(?<col>\d+)$/;
+export function isSwiftHeaderLine(line) {
+    return HEADER_PATTERN.test(line);
+}
+export function isSwiftFrameLine(line) {
+    return FRAME_PATTERN.test(line) || UNSYMBOLICATED_FRAME_PATTERN.test(line);
+}
+/** True for a frame the backtracer printed but could not name — a real frame of a real stack, carrying only its address. */
+export function isSwiftUnsymbolicatedFrameLine(line) {
+    return !FRAME_PATTERN.test(line) && UNSYMBOLICATED_FRAME_PATTERN.test(line);
+}
+/** Any thread block header, `crashed` or not — what separates one thread's stack from another's. */
+export function isSwiftThreadLine(line) {
+    return THREAD_PATTERN.test(line);
+}
+/** Only the thread that actually trapped. In a multi-thread dump the others precede it. */
+export function isSwiftCrashedThreadLine(line) {
+    return THREAD_CRASHED_PATTERN.test(line);
+}
+/** The `file:line` the `Fatal error:` line declares, or null when it declares none. Never fabricated. */
+export function parseSwiftHeaderPosition(line) {
+    const match = HEADER_POSITION_PATTERN.exec(line);
+    if (!match?.groups)
+        return null;
+    const file = match.groups["file"];
+    const lineNumber = Number(match.groups["line"]);
+    if (file === undefined || !Number.isInteger(lineNumber))
+        return null;
+    return { file, line: lineNumber };
+}
+/**
+ * Stateful for the bridge between header and first frame (point 1 above),
+ * reported via `LineClassifier.isBridge` (RT-048).
+ *
+ * **RT-122 measured a real Swift 6.1.2 crash on Linux and the bridge is
+ * three lines, not two.** `*** Signal 4: Backtracing from 0x…... done ***`
+ * comes first, and the `FileCheck` test this was transcribed from does not
+ * contain it. Missing it was total rather than partial: the block closed
+ * before the first frame and a real Swift crash produced no evidence at
+ * all. The signal line is accepted as optional so both shapes work.
+ * `ExceptionBlockDetector` only ever consults `isBridge` while a header is
+ * already being held, so `*** Program crashed...` and `Thread N ...
+ * crashed:` cannot open a block on their own from idle — that guarantee is
+ * now the state machine's, not this classifier's to re-derive, which is
+ * what let `isFrame` shrink back to a plain, stateless check for the real
+ * frame shape: it no longer has to also recognise the bridge, only the
+ * thing that ends it.
+ *
+ * **Blank lines are tolerated at any point in the bridge, not just one.**
+ * The cited `FileCheck` test uses plain `CHECK:` (not `CHECK-NEXT:`)
+ * between the header, the two bridging lines, and frame 0, which permits
+ * — but does not confirm — a blank line at each gap; the test's own
+ * comment formatting cannot be trusted to mirror the real output's
+ * spacing. Rather than guess a specific count and position, every stage
+ * of the bridge accepts an arbitrary run of blank lines before the
+ * pattern it expects.
+ */
+export function createSwiftLineClassifier() {
+    /**
+     * 0 = not bridging; 1 = expecting the signal line OR "*** Program
+     * crashed"; 2 = signal seen, expecting "*** Program crashed"; 3 =
+     * expecting the first "Thread N ...:" line.
+     *
+     * Three stages rather than RT-048's two, because the real backtracer
+     * prints one more line than the transcribed fixtures do. Stage 1 accepts
+     * either, which is what makes the signal line optional without a
+     * separate code path.
+     */
+    let stage = 0;
+    /**
+     * Whether a thread stack is currently open.
+     *
+     * **`isFrame` is consulted from `idle` too** (`ExceptionBlockDetector`
+     * opens a bare `stack-trace` block on one), so the blank-line and
+     * thread-header tolerance below MUST be gated on having already seen a
+     * real frame or a bridged thread line. Ungated, every blank line in
+     * ordinary output would open a block.
+     */
+    let inStack = false;
+    return {
+        isHeader(line) {
+            if (isSwiftHeaderLine(line)) {
+                stage = 1;
+                inStack = false;
+                return true;
+            }
+            return false;
+        },
+        isFrame(line) {
+            // A real frame always ends the bridge, wherever it currently stands.
+            if (isSwiftFrameLine(line)) {
+                stage = 0;
+                inStack = true;
+                return true;
+            }
+            // **A crash off the main thread dumps every thread**, and the one
+            // that trapped is not first — measured (RT-122). Without accepting
+            // the intervening blank and `Thread N ...:` lines, the block ends at
+            // the first thread boundary and keeps only the stack of a thread that
+            // did not crash. Which thread's frames are then USED is the parser's
+            // decision, not this one's; this only keeps them in the block.
+            if (inStack && (line.trim() === "" || isSwiftThreadLine(line)))
+                return true;
+            inStack = false;
+            return false;
+        },
+        isBridge(line) {
+            if (line.trim() === "")
+                return true; // blank lines never advance or reset the stage
+            if (stage === 1 && SIGNAL_BACKTRACING_PATTERN.test(line)) {
+                stage = 2;
+                return true;
+            }
+            if ((stage === 1 || stage === 2) && PROGRAM_CRASHED_PATTERN.test(line)) {
+                stage = 3;
+                return true;
+            }
+            if (stage === 3 && isSwiftThreadLine(line)) {
+                stage = 0;
+                // The block has not opened yet — the next line is a blank, then
+                // frame 0 — so the stack is already "open" as far as isFrame is
+                // concerned, or that blank would close what the bridge just built.
+                inStack = true;
+                return true;
+            }
+            stage = 0;
+            return false;
+        },
+    };
+}
+/** `null` for anything not shaped like a real crash-handler frame — never fabricated. */
+export function parseSwiftFrame(line) {
+    const match = FRAME_PATTERN.exec(line);
+    if (!match?.groups) {
+        // An unsymbolicated frame names nothing, and every field says so
+        // rather than one of them carrying the address as a stand-in. The
+        // frame's own text is kept verbatim as `StackFrame.raw` by the caller,
+        // which is where an address belongs — it is evidence, not a location.
+        return UNSYMBOLICATED_FRAME_PATTERN.test(line) ? { functionName: null, file: null, line: null, column: null } : null;
+    }
+    const symbol = match.groups["symbol"];
+    if (symbol === undefined)
+        return null;
+    // **`<unknown>` is the backtracer saying it has no name, so neither do
+    // we.** Passing the literal through would put a symbol into evidence that
+    // resolves against no graph node and reads, to anything downstream, like
+    // a function actually called that. `SourceLocation.functionName` is
+    // nullable for exactly this.
+    const named = symbol === UNNAMED_SYMBOL ? null : symbol;
+    const location = match.groups["location"];
+    if (location === undefined) {
+        // No `at ...` suffix at all — this image had no debug info to offer.
+        return { functionName: named, file: null, line: null, column: null };
+    }
+    const withLineCol = FILE_LINE_COL_PATTERN.exec(location);
+    if (withLineCol?.groups) {
+        const file = withLineCol.groups["file"];
+        const lineNumber = Number(withLineCol.groups["line"]);
+        const columnNumber = Number(withLineCol.groups["col"]);
+        if (file !== undefined && Number.isInteger(lineNumber) && Number.isInteger(columnNumber)) {
+            return { functionName: named, file, line: lineNumber, column: columnNumber };
+        }
+    }
+    // A pseudo-path (`<compiler-generated>`) or an otherwise unparseable
+    // location — real text, kept verbatim as `file`, never a fabricated line.
+    return { functionName: named, file: location, line: null, column: null };
+}
+//# sourceMappingURL=swift-frame-parsing.js.map

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * The concrete `RuntimeAdapter` for Swift.
+ *
+ * Needed no seam change: RT-037's already-nullable `SourceLocation`/
+ * `RawFrameLocation` fields are what let a no-debug-info frame attach to
+ * a real `null` location instead of a fabricated one. See
+ * `swift-frame-parsing.ts` for the two-line header/first-frame bridge
+ * this language needed from the classifier — the longest such bridge in
+ * this seam so far (PHP needed one line, C#'s `InnerException` needed
+ * one; Swift needs two, plus a tolerated blank line).
+ */
+import type { RuntimeAdapter } from "@descryy/runtime-backend-observation";
+export interface SwiftRuntimeAdapterOptions {
+    /** Attributed on every emitted Evidence's `service` field (plan §16.7). Omit when not applicable. */
+    readonly service?: string;
+}
+export declare function createSwiftRuntimeAdapter(options?: SwiftRuntimeAdapterOptions): RuntimeAdapter;
+//# sourceMappingURL=swift-runtime-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/swift-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,sCAAsC,CAAC;AAQhG,MAAM,WAAW,0BAA0B;IACzC,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,cAAc,CAwBlG"}

package/dist/swift-runtime-adapter.js

@@ -0,0 +1,37 @@
+/**
+ * The concrete `RuntimeAdapter` for Swift.
+ *
+ * Needed no seam change: RT-037's already-nullable `SourceLocation`/
+ * `RawFrameLocation` fields are what let a no-debug-info frame attach to
+ * a real `null` location instead of a fabricated one. See
+ * `swift-frame-parsing.ts` for the two-line header/first-frame bridge
+ * this language needed from the classifier — the longest such bridge in
+ * this seam so far (PHP needed one line, C#'s `InnerException` needed
+ * one; Swift needs two, plus a tolerated blank line).
+ */
+import { createLogCollector } from "@descryy/runtime-backend-observation";
+import { createSwiftLineClassifier } from "./swift-frame-parsing.js";
+import { createSwiftSourceLocationResolver } from "./swift-source-location-resolver.js";
+import { createSwiftStackTraceParser } from "./swift-stack-trace-parser.js";
+export function createSwiftRuntimeAdapter(options = {}) {
+    const sourceLocationResolver = createSwiftSourceLocationResolver();
+    const stackTraceParser = createSwiftStackTraceParser(sourceLocationResolver);
+    function createBackendCollectors(sources) {
+        return sources.map((source) => createLogCollector({
+            source,
+            // One classifier per collector, never shared: it carries the
+            // "which bridging line are we expecting next" stage, and two
+            // processes' output must not prime each other.
+            classifier: createSwiftLineClassifier(),
+            stackTraceParser,
+            ...(options.service !== undefined ? { service: options.service } : {}),
+        }));
+    }
+    return {
+        language: "swift",
+        stackTraceParser,
+        sourceLocationResolver,
+        createBackendCollectors,
+    };
+}
+//# sourceMappingURL=swift-runtime-adapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-runtime-adapter.js","sourceRoot":"","sources":["../src/swift-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAO5E,MAAM,UAAU,yBAAyB,CAAC,UAAsC,EAAE;IAChF,MAAM,sBAAsB,GAAG,iCAAiC,EAAE,CAAC;IACnE,MAAM,gBAAgB,GAAG,2BAA2B,CAAC,sBAAsB,CAAC,CAAC;IAE7E,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,6DAA6D;YAC7D,6DAA6D;YAC7D,+CAA+C;YAC/C,UAAU,EAAE,yBAAyB,EAAE;YACvC,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,OAAO;QACjB,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;KACxB,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,54 @@
+/**
+ * Swift `SourceLocationResolver` — the second adapter in this codebase to
+ * use `side-artifact-resolved`/`-missing` (RT-041's C# was the first),
+ * and the same underlying reason: **resolving means reading a verdict the
+ * runtime already reached, not performing one.** The crash handler
+ * symbolicates each frame against the binary's own debug info (embedded
+ * DWARF on Linux, a paired `.dSYM` on Apple platforms) while building this
+ * text, before it is ever captured here — confirmed against
+ * `RuntimeErrorReporting.cpp`'s `dumpStackTraceEntry`, which looks the
+ * frame up and either finds a location or doesn't, before this adapter's
+ * code runs at all.
+ *
+ * - `file`/`line` present → debug info was available and matched →
+ *   `side-artifact-resolved`.
+ * - `file`/`line` absent → no debug info was available for that image →
+ *   `side-artifact-missing`, **not** `self-contained` — a compiled Swift
+ *   frame always COULD have carried a location if debug info had been
+ *   present for its image, unlike a language with no such mechanism at
+ *   all. This is RT-041's own distinction (a managed C# frame vs. a PHP
+ *   `[internal function]` frame), carried over rather than re-derived,
+ *   because the underlying shape — a runtime that resolves against debug
+ *   info before printing, rather than always capturing a location or
+ *   never capturing one — is the same.
+ *
+ * **`side-artifact-stale` is not detected**, for the same reason as
+ * RT-041's C# resolver: verifying a `.dSYM`'s UUID against the running
+ * binary's `LC_UUID` load command (or comparing embedded DWARF checksums)
+ * is real, scoped work this adapter does not attempt without a `swift`
+ * toolchain to build and verify it against.
+ *
+ * **`resolvedVia` stays `null`.** The crash-handler text names the
+ * *image* a frame belongs to (`in libswiftCore.dylib`, `in InvoiceApp`)
+ * but never the specific `.dSYM` bundle or debug-info path that resolved
+ * it, so there is nothing to name without guessing one — the same
+ * reasoning as C#'s resolver, which cannot name a `.pdb` for the same
+ * kind of reason.
+ *
+ * `column` **is** populated, unlike every prior adapter's resolver in
+ * this codebase. Swift's `file:line:col` location is a real, captured
+ * fact — `RawFrameLocation.column` is passed straight through rather than
+ * discarded, because nothing here needs to derive or guess it the way a
+ * V8 source map's column sometimes does.
+ *
+ * **A `<compiler-generated>` pseudo-path (see `swift-frame-parsing.ts`
+ * point 3) reports `side-artifact-resolved`, not `-missing`**, even
+ * though `line`/`column` are null for it. The crash handler DID have
+ * enough information to name an origin for that frame — it simply isn't
+ * a source line — which is a different claim from "no debug info was
+ * available at all" and this resolver treats it that way rather than
+ * conflating the two.
+ */
+import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
+export declare function createSwiftSourceLocationResolver(): SourceLocationResolver;
+//# sourceMappingURL=swift-source-location-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/swift-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAErG,wBAAgB,iCAAiC,IAAI,sBAAsB,CAgB1E"}

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

@@ -0,0 +1,69 @@
+/**
+ * Swift `SourceLocationResolver` — the second adapter in this codebase to
+ * use `side-artifact-resolved`/`-missing` (RT-041's C# was the first),
+ * and the same underlying reason: **resolving means reading a verdict the
+ * runtime already reached, not performing one.** The crash handler
+ * symbolicates each frame against the binary's own debug info (embedded
+ * DWARF on Linux, a paired `.dSYM` on Apple platforms) while building this
+ * text, before it is ever captured here — confirmed against
+ * `RuntimeErrorReporting.cpp`'s `dumpStackTraceEntry`, which looks the
+ * frame up and either finds a location or doesn't, before this adapter's
+ * code runs at all.
+ *
+ * - `file`/`line` present → debug info was available and matched →
+ *   `side-artifact-resolved`.
+ * - `file`/`line` absent → no debug info was available for that image →
+ *   `side-artifact-missing`, **not** `self-contained` — a compiled Swift
+ *   frame always COULD have carried a location if debug info had been
+ *   present for its image, unlike a language with no such mechanism at
+ *   all. This is RT-041's own distinction (a managed C# frame vs. a PHP
+ *   `[internal function]` frame), carried over rather than re-derived,
+ *   because the underlying shape — a runtime that resolves against debug
+ *   info before printing, rather than always capturing a location or
+ *   never capturing one — is the same.
+ *
+ * **`side-artifact-stale` is not detected**, for the same reason as
+ * RT-041's C# resolver: verifying a `.dSYM`'s UUID against the running
+ * binary's `LC_UUID` load command (or comparing embedded DWARF checksums)
+ * is real, scoped work this adapter does not attempt without a `swift`
+ * toolchain to build and verify it against.
+ *
+ * **`resolvedVia` stays `null`.** The crash-handler text names the
+ * *image* a frame belongs to (`in libswiftCore.dylib`, `in InvoiceApp`)
+ * but never the specific `.dSYM` bundle or debug-info path that resolved
+ * it, so there is nothing to name without guessing one — the same
+ * reasoning as C#'s resolver, which cannot name a `.pdb` for the same
+ * kind of reason.
+ *
+ * `column` **is** populated, unlike every prior adapter's resolver in
+ * this codebase. Swift's `file:line:col` location is a real, captured
+ * fact — `RawFrameLocation.column` is passed straight through rather than
+ * discarded, because nothing here needs to derive or guess it the way a
+ * V8 source map's column sometimes does.
+ *
+ * **A `<compiler-generated>` pseudo-path (see `swift-frame-parsing.ts`
+ * point 3) reports `side-artifact-resolved`, not `-missing`**, even
+ * though `line`/`column` are null for it. The crash handler DID have
+ * enough information to name an origin for that frame — it simply isn't
+ * a source line — which is a different claim from "no debug info was
+ * available at all" and this resolver treats it that way rather than
+ * conflating the two.
+ */
+export function createSwiftSourceLocationResolver() {
+    return {
+        // Async to satisfy the interface; there is no I/O to do here, since
+        // the crash handler already did (or didn't) resolve this frame before
+        // the text was captured.
+        resolve(frame) {
+            return Promise.resolve({
+                file: frame.file,
+                line: frame.line,
+                column: frame.column,
+                functionName: frame.functionName,
+                reliability: frame.file === null ? "side-artifact-missing" : "side-artifact-resolved",
+                resolvedVia: null,
+            });
+        },
+    };
+}
+//# sourceMappingURL=swift-source-location-resolver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-source-location-resolver.js","sourceRoot":"","sources":["../src/swift-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAKH,MAAM,UAAU,iCAAiC;IAC/C,OAAO;QACL,oEAAoE;QACpE,sEAAsE;QACtE,yBAAyB;QACzB,OAAO,CAAC,KAAuB;YAC7B,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,WAAW,EAAE,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,wBAAwB;gBACrF,WAAW,EAAE,IAAI;aAClB,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,88 @@
+/**
+ * Composes the pure Swift line-recognition functions
+ * (`swift-frame-parsing.ts`) with a `SourceLocationResolver` to implement
+ * the full async `StackTraceParser` contract.
+ *
+ * **No reversal.** The cited `FileCheck` test numbers frame 0 as the trap
+ * site itself (`_assertionFailure`) and counts upward to `main` — most-
+ * recent-first already, the same convention as V8, the JVM, Go, Rust and
+ * C#; CPython remains the only reversing outlier in this codebase.
+ *
+ * `fidelity` is always reported `"synchronous"`. The crash-handler walks
+ * the actual thread that trapped; it cannot show a logical caller across
+ * a Swift `Task`/actor hop the runtime itself didn't preserve, the same
+ * hard limit every other adapter in this codebase shares. Claiming
+ * `"concurrency-fragmented"` without an explicit marker for it would be a
+ * guess this project refuses to make.
+ *
+ * ## Two things a real Swift crash added that the transcript could not
+ *
+ * Both measured against Swift 6.1.2 on Linux (RT-122), and neither is
+ * visible in a single-threaded fixture:
+ *
+ * **1. Only the thread marked `crashed:` becomes frames.** When the trap
+ * happens off the main thread, Swift dumps *every* thread, and the
+ * uncrashed ones are printed **first**:
+ *
+ * ```
+ * Thread 0 "server":          <- still sitting in accept(); did not crash
+ * 0  … accept + 77 in libc.so.6
+ * …
+ * Thread 1 crashed:           <- the one that trapped
+ * 0  … _assertionFailure … in libswiftCore.so
+ * 4  … readCustomerName(_:) … at …/server.swift:10:28
+ * ```
+ *
+ * Reading every frame-shaped line, as this parser used to, concatenates
+ * two unrelated call chains into one — the identical fabricated-call-
+ * relationship error `adapter-go` refuses for goroutines — and, worse,
+ * puts a thread that did not crash at the head of the list, so
+ * `Evidence.sourceLocation` names `accept` in libc. The other threads stay
+ * in the block's raw text, disclosed rather than merged or discarded.
+ *
+ * **2. `primaryFrameIndex` points at the position the header declares.**
+ * Swift's `Fatal error:` line on Linux carries one —
+ * `server/server.swift:10: Fatal error: …` — and frames 0..3 above the
+ * application frame are `_assertionFailure` closures inside
+ * `libswiftCore.so`. `collector.ts` reports `frames[0]` as
+ * `Evidence.sourceLocation`, so unrooted this names a Swift-runtime
+ * closure with no source location at all.
+ *
+ * This is an exact join on a position the runtime printed, not a
+ * classification of images as "runtime" or "application": nothing here
+ * looks at `libswiftCore.so`. It matches on **basename and line** — the
+ * header's `#file` is `Module/File.swift` while a frame carries the
+ * absolute path, so neither is a prefix of the other, and Swift's header
+ * (unlike Rust's) has no column to tighten it with. That is a weaker join
+ * than Rust's and is stated as such. The transcribed fixtures declare no
+ * position at all, so the index stays `0` for them — the honest outcome,
+ * not a fallback.
+ *
+ * ## An unsymbolicated dump is a stack, not the absence of one (RT-126/128)
+ *
+ * When the backtracer cannot symbolicate it still unwinds correctly and
+ * prints every frame as a bare address. Those frames are parsed and kept,
+ * with `file`, `line`, `functionName` and `column` all null and the address
+ * preserved in `StackFrame.raw`. `fidelity` stays `"synchronous"` — the
+ * chain is entirely accurate, only its names are missing, and
+ * `"unavailable"` describes a different axis (whether the stack reflects
+ * the logical call chain) that this does not touch.
+ *
+ * The alternative — returning `null`, as this parser did — made "a Swift
+ * crash we could not name" indistinguishable from "not a Swift crash",
+ * which is the disclosure failure §38 exists to ban. `primaryFrameIndex`
+ * stays `0`: no rooting is possible without names, and Lane A's
+ * `primaryFrameLocation` (RT-087) turns that frame into a null
+ * `Evidence.sourceLocation` rather than a location naming nothing.
+ *
+ * **Selecting a thread is not the same as choosing an index, and only one
+ * of the two became a view.** `primaryFrameIndex` (RT-083) keeps every
+ * frame of the crashed thread and points at the failure site. The
+ * *uncrashed* threads are still excluded from `frames` entirely, because
+ * they are not frames of this stack at all — including them would assert a
+ * call relationship between independent threads, which no index can undo.
+ * They remain in `payload.raw`.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createSwiftStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=swift-stack-trace-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swift-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/swift-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAmCrG,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CA+C9F"}

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

@@ -0,0 +1,152 @@
+/**
+ * Composes the pure Swift line-recognition functions
+ * (`swift-frame-parsing.ts`) with a `SourceLocationResolver` to implement
+ * the full async `StackTraceParser` contract.
+ *
+ * **No reversal.** The cited `FileCheck` test numbers frame 0 as the trap
+ * site itself (`_assertionFailure`) and counts upward to `main` — most-
+ * recent-first already, the same convention as V8, the JVM, Go, Rust and
+ * C#; CPython remains the only reversing outlier in this codebase.
+ *
+ * `fidelity` is always reported `"synchronous"`. The crash-handler walks
+ * the actual thread that trapped; it cannot show a logical caller across
+ * a Swift `Task`/actor hop the runtime itself didn't preserve, the same
+ * hard limit every other adapter in this codebase shares. Claiming
+ * `"concurrency-fragmented"` without an explicit marker for it would be a
+ * guess this project refuses to make.
+ *
+ * ## Two things a real Swift crash added that the transcript could not
+ *
+ * Both measured against Swift 6.1.2 on Linux (RT-122), and neither is
+ * visible in a single-threaded fixture:
+ *
+ * **1. Only the thread marked `crashed:` becomes frames.** When the trap
+ * happens off the main thread, Swift dumps *every* thread, and the
+ * uncrashed ones are printed **first**:
+ *
+ * ```
+ * Thread 0 "server":          <- still sitting in accept(); did not crash
+ * 0  … accept + 77 in libc.so.6
+ * …
+ * Thread 1 crashed:           <- the one that trapped
+ * 0  … _assertionFailure … in libswiftCore.so
+ * 4  … readCustomerName(_:) … at …/server.swift:10:28
+ * ```
+ *
+ * Reading every frame-shaped line, as this parser used to, concatenates
+ * two unrelated call chains into one — the identical fabricated-call-
+ * relationship error `adapter-go` refuses for goroutines — and, worse,
+ * puts a thread that did not crash at the head of the list, so
+ * `Evidence.sourceLocation` names `accept` in libc. The other threads stay
+ * in the block's raw text, disclosed rather than merged or discarded.
+ *
+ * **2. `primaryFrameIndex` points at the position the header declares.**
+ * Swift's `Fatal error:` line on Linux carries one —
+ * `server/server.swift:10: Fatal error: …` — and frames 0..3 above the
+ * application frame are `_assertionFailure` closures inside
+ * `libswiftCore.so`. `collector.ts` reports `frames[0]` as
+ * `Evidence.sourceLocation`, so unrooted this names a Swift-runtime
+ * closure with no source location at all.
+ *
+ * This is an exact join on a position the runtime printed, not a
+ * classification of images as "runtime" or "application": nothing here
+ * looks at `libswiftCore.so`. It matches on **basename and line** — the
+ * header's `#file` is `Module/File.swift` while a frame carries the
+ * absolute path, so neither is a prefix of the other, and Swift's header
+ * (unlike Rust's) has no column to tighten it with. That is a weaker join
+ * than Rust's and is stated as such. The transcribed fixtures declare no
+ * position at all, so the index stays `0` for them — the honest outcome,
+ * not a fallback.
+ *
+ * ## An unsymbolicated dump is a stack, not the absence of one (RT-126/128)
+ *
+ * When the backtracer cannot symbolicate it still unwinds correctly and
+ * prints every frame as a bare address. Those frames are parsed and kept,
+ * with `file`, `line`, `functionName` and `column` all null and the address
+ * preserved in `StackFrame.raw`. `fidelity` stays `"synchronous"` — the
+ * chain is entirely accurate, only its names are missing, and
+ * `"unavailable"` describes a different axis (whether the stack reflects
+ * the logical call chain) that this does not touch.
+ *
+ * The alternative — returning `null`, as this parser did — made "a Swift
+ * crash we could not name" indistinguishable from "not a Swift crash",
+ * which is the disclosure failure §38 exists to ban. `primaryFrameIndex`
+ * stays `0`: no rooting is possible without names, and Lane A's
+ * `primaryFrameLocation` (RT-087) turns that frame into a null
+ * `Evidence.sourceLocation` rather than a location naming nothing.
+ *
+ * **Selecting a thread is not the same as choosing an index, and only one
+ * of the two became a view.** `primaryFrameIndex` (RT-083) keeps every
+ * frame of the crashed thread and points at the failure site. The
+ * *uncrashed* threads are still excluded from `frames` entirely, because
+ * they are not frames of this stack at all — including them would assert a
+ * call relationship between independent threads, which no index can undo.
+ * They remain in `payload.raw`.
+ */
+import { isSwiftCrashedThreadLine, isSwiftThreadLine, parseSwiftFrame, parseSwiftHeaderPosition, } from "./swift-frame-parsing.js";
+const basename = (path) => path.split("/").pop() ?? path;
+/**
+ * The lines belonging to the thread that actually trapped.
+ *
+ * A dump with no thread headers at all (the transcribed fixtures) is one
+ * implicit block and every line is returned. A dump with thread headers
+ * but none marked `crashed` is refused a choice: every line is returned,
+ * which keeps the pre-existing behaviour rather than picking a thread on
+ * no evidence. Swift has always marked one in every shape observed, so
+ * that branch is a guard, not a supported case.
+ */
+function crashedThreadLines(lines) {
+    const start = lines.findIndex(isSwiftCrashedThreadLine);
+    if (start === -1)
+        return lines;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (isSwiftThreadLine(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start + 1, end);
+}
+export function createSwiftStackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            const lines = rawText.split(/\r\n|\r|\n/);
+            const declared = lines.map(parseSwiftHeaderPosition).find((p) => p !== null) ?? null;
+            const frames = [];
+            /** Index of the frame at the header's own declared position, or -1 when nothing declares or matches one — reported as `primaryFrameIndex: 0`, stated rather than defaulted. */
+            let declaredSite = -1;
+            for (const line of crashedThreadLines(lines)) {
+                // The header and the bridging lines all parse to null here — real
+                // parts of the block, none fabricated into a frame.
+                const raw = parseSwiftFrame(line);
+                if (raw === null)
+                    continue;
+                const location = await resolver.resolve({
+                    file: raw.file,
+                    line: raw.line,
+                    column: raw.column,
+                    functionName: raw.functionName,
+                });
+                frames.push({ location, raw: line });
+                // First match only: recursion would repeat the position further
+                // down, and the outermost repetition is not where execution was.
+                if (declaredSite === -1 &&
+                    declared !== null &&
+                    raw.file !== null &&
+                    raw.line === declared.line &&
+                    basename(raw.file) === basename(declared.file)) {
+                    declaredSite = frames.length - 1;
+                }
+            }
+            if (frames.length === 0) {
+                // Nothing frame-shaped at all — not recognisable as a Swift crash
+                // trace, per this interface's contract: null, never an empty-but-
+                // structured StackTrace standing in for "couldn't parse".
+                return null;
+            }
+            return { fidelity: "synchronous", frames, primaryFrameIndex: declaredSite > 0 ? declaredSite : 0 };
+        },
+    };
+}
+//# sourceMappingURL=swift-stack-trace-parser.js.map

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

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

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@descryy/runtime-adapter-swift",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "Swift runtime adapter: crash-handler trace parsing, side-artifact-aware source locations, the concrete RuntimeAdapter for Swift.",
+  "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": "*"
+  }
+}