@descryy/runtime-adapter-php 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) Descry
+
+All rights reserved. This software is proprietary and confidential.
+No license, express or implied, to reproduce, distribute, modify, or
+create derivative works is granted except as explicitly agreed in
+writing.

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

@@ -1,76 +1,35 @@
 /**
- * Laravel's exception-log grammar, which is **not PHP's** (RT-112).
- *
- * ## The measurement
- *
- * A real Laravel 12.67.0 application on PHP 8.4.4, spawned through the
- * managed lifecycle, failing through its own request pipeline with
- * `LOG_CHANNEL=stderr`:
- *
- * ```
- * 64 lines in -> 0 exceptions, 53 lines in a bare STACK_TRACE, 11 logs
- * ```
- *
- * The **mirror image of Rails' defect** (RT-111), which lost everything.
- * Laravel loses only the identity — and that is arguably worse to receive,
- * because the result looks like working evidence: fifty correct frames with
- * no exception class and no message attached to them.
- *
- * ## Why PHP's classifier half-sees it
- *
- * Laravel logs through Monolog, not through PHP's own
- * `Throwable::__toString()`:
- *
- * ```
- * [2026-08-19 03:45:19] production.ERROR: Trying to access array offset on null {"exception":"[object] (ErrorException(code: 0): Trying to access array offset on null at /app/routes/web.php:9)
- * [stacktrace]
- * #0 /app/vendor/.../HandleExceptions.php(262): Illuminate\\Foundation\\Bootstrap\\HandleExceptions->handleError(2, '...')
- * #1 /app/routes/web.php(9): ...
- * #11 {main}
- * "}
- * ```
- *
- * Three differences, of which two are fatal and one is silent:
- *
- * 1. **The header says `at file:line)` where PHP says `in file:line`.**
- *    PHP's `HEADER_PATTERN` is `$`-anchored on ` in <file>:<line>`, so
- *    Laravel's — with the word `at` and a trailing `)` — matches nothing.
- * 2. **The bridge is `[stacktrace]`, not `Stack trace:`.**
- * 3. **Class names are JSON-escaped.** The trace is written inside a JSON
- *    string, so `Illuminate\Routing\Router` arrives as
- *    `Illuminate\\Routing\\Router`. The frames still match PHP's
- *    `FRAME_PATTERN` — which is why the evidence is not lost — and every
- *    class name in them is wrong by a backslash, which resolves to no graph
- *    node while looking entirely correct. RT-103's file-path corruption,
- *    one field over.
- *
- * ## Decoding, not rewriting
- *
- * `\\` is recovered to `\` because the text **is** JSON-escaped and decoding
- * it recovers what the process meant. That is the opposite of RT-105's
- * decision to leave an `eval` frame's synthetic path alone: there, no
- * decoding exists and any "fix" would invent a location; here, the encoding
- * is documented and reversible.
- *
- * Only the callee is decoded. POSIX file paths carry no backslashes, so
- * decoding them would be a no-op with a Windows-shaped hazard attached.
- *
- * ## Laravel's default is worse than any of this, and no parser can fix it
- *
- * `LOG_CHANNEL` defaults to `stack` -> `single`, which writes
- * `storage/logs/laravel.log`. **A collector watching process output sees
- * nothing at all** — not a parse failure, no evidence. Setting
- * `LOG_CHANNEL=stderr` is a first-class Laravel option and it is a
- * *configuration requirement this adapter cannot satisfy on the
- * application's behalf*. It belongs in the disclosure to the user, not in a
- * pattern.
+ * Laravel's exception-log grammar is not PHP's (RT-112).
+ *
+ * Measured on real Laravel 12.67.0 / PHP 8.4.4 with LOG_CHANNEL=stderr:
+ * 64 lines in -> 0 exceptions, 53 lines in a bare STACK_TRACE, 11 logs.
+ * Mirror image of Rails' defect (RT-111, which lost everything) — Laravel
+ * loses only the identity, arguably worse: fifty correct frames with no
+ * exception class or message attached.
+ *
+ * Laravel logs through Monolog, not Throwable::__toString(). Three
+ * differences, two fatal and one silent:
+ * 1. Header says `at file:line)` where PHP says `in file:line)` — PHP's
+ *    `$`-anchored HEADER_PATTERN matches nothing.
+ * 2. Bridge is `[stacktrace]`, not `Stack trace:`.
+ * 3. Class names are JSON-escaped (`Illuminate\\Routing\\Router`). Frames
+ *    still match PHP's FRAME_PATTERN so evidence isn't lost, but every
+ *    class name is wrong by a backslash — resolves to no graph node while
+ *    looking correct (RT-103's file-path corruption, one field over).
+ *
+ * `\\` is decoded to `\` because the text is JSON-escaped and decoding
+ * recovers what the process meant — opposite of RT-105's eval-frame
+ * decision, where no decoding exists and any "fix" would invent a location.
+ * Only the callee is decoded; POSIX file paths carry no backslashes.
+ *
+ * LOG_CHANNEL defaults to stack -> single (storage/logs/laravel.log): a
+ * collector watching process output sees nothing at all, not a parse
+ * failure. LOG_CHANNEL=stderr is a configuration requirement this adapter
+ * can't satisfy for the app — belongs in disclosure, not in a pattern.
  */
 /**
- * Recovers a JSON-escaped backslash.
- *
- * `Illuminate\\Routing\\Router` -> `Illuminate\Routing\Router`. Applied only
- * to a callee: this is a decode of a known encoding, not a guess, and the
- * file paths in the same line are not escaped.
+ * Recovers a JSON-escaped backslash: `Illuminate\\Routing\\Router` -> `Illuminate\Routing\Router`.
+ * Applied only to a callee — file paths in the same line are not escaped.
  */
 export declare function decodeLaravelCallee(callee: string): string;
 export declare function isLaravelHeaderLine(line: string): boolean;
@@ -82,28 +41,15 @@ export declare function parseLaravelHeader(line: string): {
     readonly line: number;
 } | null;
 /**
- * Laravel's classifier: its own header and bridge, PHP's own frames and
- * trailer.
- *
- * The frame and trailer halves are imported rather than restated, because
- * the `#N file(line): callee(args)` shape genuinely is PHP's — Monolog
- * writes `Throwable::getTraceAsString()` verbatim. Only the framing around
- * it is Laravel's. Restating them would be a second copy to keep in step
- * with RT-105's closure-name fix.
- *
- * `isTrailer` is PHP's `#N {main}`, which closes the block and leaves
- * Monolog's own `"}` terminator to fall through as a log line — the same
- * choice PHP's grammar already makes for its `thrown in ...` trailer, and
- * for the same reason: attach what identifies the exception, not everything
- * printed after it.
- *
- * **`isBridge` is mutation-inert, and that is recorded rather than hidden.**
- * Replacing `[stacktrace]` with PHP's `Stack trace:` kills no test: RT-082's
- * held-message absorption picks the line up instead, and the block still
- * forms. It is kept because the line genuinely *is* a bridge and absorbing
- * it spends one of `MAX_HELD_LINES` on transport punctuation — but no test
- * distinguishes the two, so "every guard is mutation-tested" would be the
- * wrong summary of this file.
+ * Laravel's classifier: its own header and bridge, PHP's own frames and trailer.
+ * Frame/trailer are imported rather than restated — Monolog writes
+ * Throwable::getTraceAsString() verbatim, only the framing is Laravel's.
+ * `isTrailer` is PHP's `#N {main}`; Monolog's `"}` terminator falls through as a log line.
+ *
+ * `isBridge` is mutation-inert (recorded, not hidden): replacing `[stacktrace]`
+ * with PHP's `Stack trace:` kills no test, since RT-082's held-message
+ * absorption picks it up instead. Kept anyway because the line genuinely is
+ * a bridge and absorbing it spends a `MAX_HELD_LINES` slot on punctuation.
  */
 export declare function createLaravelLineClassifier(): {
     isHeader(line: string): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"laravel-frame-parsing.d.ts","sourceRoot":"","sources":["../src/laravel-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAqBH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,+GAA+G;AAC/G,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAapH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,2BAA2B,IAAI;IAC7C,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;IAChC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC,CAOA"}
+{"version":3,"file":"laravel-frame-parsing.d.ts","sourceRoot":"","sources":["../src/laravel-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAgBH;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,+GAA+G;AAC/G,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAapH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,IAAI;IAC7C,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;IAChC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC,CAOA"}

package/dist/laravel-frame-parsing.js

@@ -1,91 +1,45 @@
 /**
- * Laravel's exception-log grammar, which is **not PHP's** (RT-112).
- *
- * ## The measurement
- *
- * A real Laravel 12.67.0 application on PHP 8.4.4, spawned through the
- * managed lifecycle, failing through its own request pipeline with
- * `LOG_CHANNEL=stderr`:
- *
- * ```
- * 64 lines in -> 0 exceptions, 53 lines in a bare STACK_TRACE, 11 logs
- * ```
- *
- * The **mirror image of Rails' defect** (RT-111), which lost everything.
- * Laravel loses only the identity — and that is arguably worse to receive,
- * because the result looks like working evidence: fifty correct frames with
- * no exception class and no message attached to them.
- *
- * ## Why PHP's classifier half-sees it
- *
- * Laravel logs through Monolog, not through PHP's own
- * `Throwable::__toString()`:
- *
- * ```
- * [2026-08-19 03:45:19] production.ERROR: Trying to access array offset on null {"exception":"[object] (ErrorException(code: 0): Trying to access array offset on null at /app/routes/web.php:9)
- * [stacktrace]
- * #0 /app/vendor/.../HandleExceptions.php(262): Illuminate\\Foundation\\Bootstrap\\HandleExceptions->handleError(2, '...')
- * #1 /app/routes/web.php(9): ...
- * #11 {main}
- * "}
- * ```
- *
- * Three differences, of which two are fatal and one is silent:
- *
- * 1. **The header says `at file:line)` where PHP says `in file:line`.**
- *    PHP's `HEADER_PATTERN` is `$`-anchored on ` in <file>:<line>`, so
- *    Laravel's — with the word `at` and a trailing `)` — matches nothing.
- * 2. **The bridge is `[stacktrace]`, not `Stack trace:`.**
- * 3. **Class names are JSON-escaped.** The trace is written inside a JSON
- *    string, so `Illuminate\Routing\Router` arrives as
- *    `Illuminate\\Routing\\Router`. The frames still match PHP's
- *    `FRAME_PATTERN` — which is why the evidence is not lost — and every
- *    class name in them is wrong by a backslash, which resolves to no graph
- *    node while looking entirely correct. RT-103's file-path corruption,
- *    one field over.
- *
- * ## Decoding, not rewriting
- *
- * `\\` is recovered to `\` because the text **is** JSON-escaped and decoding
- * it recovers what the process meant. That is the opposite of RT-105's
- * decision to leave an `eval` frame's synthetic path alone: there, no
- * decoding exists and any "fix" would invent a location; here, the encoding
- * is documented and reversible.
- *
- * Only the callee is decoded. POSIX file paths carry no backslashes, so
- * decoding them would be a no-op with a Windows-shaped hazard attached.
- *
- * ## Laravel's default is worse than any of this, and no parser can fix it
- *
- * `LOG_CHANNEL` defaults to `stack` -> `single`, which writes
- * `storage/logs/laravel.log`. **A collector watching process output sees
- * nothing at all** — not a parse failure, no evidence. Setting
- * `LOG_CHANNEL=stderr` is a first-class Laravel option and it is a
- * *configuration requirement this adapter cannot satisfy on the
- * application's behalf*. It belongs in the disclosure to the user, not in a
- * pattern.
+ * Laravel's exception-log grammar is not PHP's (RT-112).
+ *
+ * Measured on real Laravel 12.67.0 / PHP 8.4.4 with LOG_CHANNEL=stderr:
+ * 64 lines in -> 0 exceptions, 53 lines in a bare STACK_TRACE, 11 logs.
+ * Mirror image of Rails' defect (RT-111, which lost everything) — Laravel
+ * loses only the identity, arguably worse: fifty correct frames with no
+ * exception class or message attached.
+ *
+ * Laravel logs through Monolog, not Throwable::__toString(). Three
+ * differences, two fatal and one silent:
+ * 1. Header says `at file:line)` where PHP says `in file:line)` — PHP's
+ *    `$`-anchored HEADER_PATTERN matches nothing.
+ * 2. Bridge is `[stacktrace]`, not `Stack trace:`.
+ * 3. Class names are JSON-escaped (`Illuminate\\Routing\\Router`). Frames
+ *    still match PHP's FRAME_PATTERN so evidence isn't lost, but every
+ *    class name is wrong by a backslash — resolves to no graph node while
+ *    looking correct (RT-103's file-path corruption, one field over).
+ *
+ * `\\` is decoded to `\` because the text is JSON-escaped and decoding
+ * recovers what the process meant — opposite of RT-105's eval-frame
+ * decision, where no decoding exists and any "fix" would invent a location.
+ * Only the callee is decoded; POSIX file paths carry no backslashes.
+ *
+ * LOG_CHANNEL defaults to stack -> single (storage/logs/laravel.log): a
+ * collector watching process output sees nothing at all, not a parse
+ * failure. LOG_CHANNEL=stderr is a configuration requirement this adapter
+ * can't satisfy for the app — belongs in disclosure, not in a pattern.
  */
 import { isPhpFrameLine, isPhpTrailerLine } from "./php-frame-parsing.js";
 /**
  * `(ErrorException(code: 0): Trying to access array offset on null at /app/routes/web.php:9)`
- *
- * Composed by `Illuminate\Log\Logger`'s exception context. The class group
- * accepts a namespaced name (`Illuminate\Database\QueryException`) in either
- * escaping, since the same shape appears outside a JSON string in some
- * channels.
- *
- * Not anchored at the start: the Monolog line prefix (`[timestamp]
- * env.LEVEL: message `) always precedes it, and matching from anywhere is
- * how PHP's own header pattern already handles its SAPI prefix.
+ * Composed by Illuminate\Log\Logger's exception context. Class group accepts
+ * either escaping since the shape appears outside JSON in some channels.
+ * Not anchored at the start — the Monolog prefix (`[timestamp] env.LEVEL: message `)
+ * always precedes it, same as PHP's own header pattern handling its SAPI prefix.
  */
 const LARAVEL_HEADER = /\((?<class>[A-Za-z_\x7f-\xff][\w\\]*)\(code: -?\d+\): (?<message>.*?) at (?<file>[^\s]+):(?<line>\d+)\)/;
 const LARAVEL_BRIDGE = "[stacktrace]";
 /**
- * Recovers a JSON-escaped backslash.
- *
- * `Illuminate\\Routing\\Router` -> `Illuminate\Routing\Router`. Applied only
- * to a callee: this is a decode of a known encoding, not a guess, and the
- * file paths in the same line are not escaped.
+ * Recovers a JSON-escaped backslash: `Illuminate\\Routing\\Router` -> `Illuminate\Routing\Router`.
+ * Applied only to a callee — file paths in the same line are not escaped.
  */
 export function decodeLaravelCallee(callee) {
     return callee.replace(/\\\\/g, "\\");
@@ -111,28 +65,15 @@ export function parseLaravelHeader(line) {
     };
 }
 /**
- * Laravel's classifier: its own header and bridge, PHP's own frames and
- * trailer.
- *
- * The frame and trailer halves are imported rather than restated, because
- * the `#N file(line): callee(args)` shape genuinely is PHP's — Monolog
- * writes `Throwable::getTraceAsString()` verbatim. Only the framing around
- * it is Laravel's. Restating them would be a second copy to keep in step
- * with RT-105's closure-name fix.
- *
- * `isTrailer` is PHP's `#N {main}`, which closes the block and leaves
- * Monolog's own `"}` terminator to fall through as a log line — the same
- * choice PHP's grammar already makes for its `thrown in ...` trailer, and
- * for the same reason: attach what identifies the exception, not everything
- * printed after it.
- *
- * **`isBridge` is mutation-inert, and that is recorded rather than hidden.**
- * Replacing `[stacktrace]` with PHP's `Stack trace:` kills no test: RT-082's
- * held-message absorption picks the line up instead, and the block still
- * forms. It is kept because the line genuinely *is* a bridge and absorbing
- * it spends one of `MAX_HELD_LINES` on transport punctuation — but no test
- * distinguishes the two, so "every guard is mutation-tested" would be the
- * wrong summary of this file.
+ * Laravel's classifier: its own header and bridge, PHP's own frames and trailer.
+ * Frame/trailer are imported rather than restated — Monolog writes
+ * Throwable::getTraceAsString() verbatim, only the framing is Laravel's.
+ * `isTrailer` is PHP's `#N {main}`; Monolog's `"}` terminator falls through as a log line.
+ *
+ * `isBridge` is mutation-inert (recorded, not hidden): replacing `[stacktrace]`
+ * with PHP's `Stack trace:` kills no test, since RT-082's held-message
+ * absorption picks it up instead. Kept anyway because the line genuinely is
+ * a bridge and absorbing it spends a `MAX_HELD_LINES` slot on punctuation.
  */
 export function createLaravelLineClassifier() {
     return {

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

@@ -1 +1 @@
-{"version":3,"file":"laravel-frame-parsing.js","sourceRoot":"","sources":["../src/laravel-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAEH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,MAAM,cAAc,GAClB,yGAAyG,CAAC;AAE5G,MAAM,cAAc,GAAG,cAAc,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,+GAA+G;AAC/G,MAAM,UAAU,kBAAkB,CAChC,IAAY;IAEZ,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7C,IAAI,IAAI,KAAK,SAAS,IAAI,cAAc,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IACrG,OAAO;QACL,cAAc,EAAE,mBAAmB,CAAC,cAAc,CAAC;QACnD,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE;QACtC,IAAI;QACJ,IAAI,EAAE,UAAU;KACjB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,2BAA2B;IAMzC,OAAO;QACL,QAAQ,EAAE,mBAAmB;QAC7B,OAAO,EAAE,cAAc;QACvB,QAAQ,EAAE,CAAC,IAAY,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,cAAc;QACnE,SAAS,EAAE,gBAAgB;KAC5B,CAAC;AACJ,CAAC"}
+{"version":3,"file":"laravel-frame-parsing.js","sourceRoot":"","sources":["../src/laravel-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,cAAc,GAClB,yGAAyG,CAAC;AAE5G,MAAM,cAAc,GAAG,cAAc,CAAC;AAEtC;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,+GAA+G;AAC/G,MAAM,UAAU,kBAAkB,CAChC,IAAY;IAEZ,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7C,IAAI,IAAI,KAAK,SAAS,IAAI,cAAc,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IACrG,OAAO;QACL,cAAc,EAAE,mBAAmB,CAAC,cAAc,CAAC;QACnD,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE;QACtC,IAAI;QACJ,IAAI,EAAE,UAAU;KACjB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B;IAMzC,OAAO;QACL,QAAQ,EAAE,mBAAmB;QAC7B,OAAO,EAAE,cAAc;QACvB,QAAQ,EAAE,CAAC,IAAY,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,cAAc;QACnE,SAAS,EAAE,gBAAgB;KAC5B,CAAC;AACJ,CAAC"}

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

@@ -1,18 +1,13 @@
 /**
  * Composes Laravel's header with PHP's own frames (RT-112).
  *
- * ## Why this is a second parser and not a branch in the PHP one
+ * A second parser, not a branch in PHP's one — same reason as RT-111's Rails:
+ * the two grammars disagree about what `primaryFrameIndex` indexes, and
+ * happening to agree on the answer (both index 0 at the header-derived
+ * frame) is coincidence, which is exactly what RT-083 exists to not rely on.
  *
- * Same reason RT-111 gave for Rails: the two grammars disagree about the
- * shape of the thing `primaryFrameIndex` indexes. They happen to agree on
- * the *answer* — Laravel's header carries `at file:line`, the exception's
- * construction site, exactly as PHP's `in file:line` does, so index 0 is the
- * header-derived frame in both — and agreeing by coincidence is precisely
- * what RT-083 was about. Two parsers each state one answer.
- *
- * The frames themselves are PHP's, parsed by PHP's parser, because Monolog
- * writes `Throwable::getTraceAsString()` verbatim. What differs is the
- * framing and the JSON escaping of class names, and both are handled here.
+ * Frames themselves are PHP's, parsed by PHP's parser — Monolog writes
+ * Throwable::getTraceAsString() verbatim; only framing and JSON-escaping differ.
  */
 import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
 export declare function createLaravelStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;

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

@@ -1 +1 @@
-{"version":3,"file":"laravel-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/laravel-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAKrG,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAqChG"}
+{"version":3,"file":"laravel-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/laravel-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAKrG,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAgChG"}

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

@@ -1,18 +1,13 @@
 /**
  * Composes Laravel's header with PHP's own frames (RT-112).
  *
- * ## Why this is a second parser and not a branch in the PHP one
+ * A second parser, not a branch in PHP's one — same reason as RT-111's Rails:
+ * the two grammars disagree about what `primaryFrameIndex` indexes, and
+ * happening to agree on the answer (both index 0 at the header-derived
+ * frame) is coincidence, which is exactly what RT-083 exists to not rely on.
  *
- * Same reason RT-111 gave for Rails: the two grammars disagree about the
- * shape of the thing `primaryFrameIndex` indexes. They happen to agree on
- * the *answer* — Laravel's header carries `at file:line`, the exception's
- * construction site, exactly as PHP's `in file:line` does, so index 0 is the
- * header-derived frame in both — and agreeing by coincidence is precisely
- * what RT-083 was about. Two parsers each state one answer.
- *
- * The frames themselves are PHP's, parsed by PHP's parser, because Monolog
- * writes `Throwable::getTraceAsString()` verbatim. What differs is the
- * framing and the JSON escaping of class names, and both are handled here.
+ * Frames themselves are PHP's, parsed by PHP's parser — Monolog writes
+ * Throwable::getTraceAsString() verbatim; only framing and JSON-escaping differ.
  */
 import { decodeLaravelCallee, parseLaravelHeader } from "./laravel-frame-parsing.js";
 import { parsePhpFrame } from "./php-frame-parsing.js";
@@ -24,9 +19,7 @@ export function createLaravelStackTraceParser(resolver) {
             for (const line of lines) {
                 const header = parseLaravelHeader(line);
                 if (header !== null) {
-                    // The construction site. `functionName` is null because Laravel,
-                    // like PHP itself, names no function for it — not because it could
-                    // not be parsed.
+                    // functionName null: Laravel, like PHP, names no function for the construction site.
                     const location = await resolver.resolve({ file: header.file, line: header.line, column: null, functionName: null });
                     frames.push({ location, raw: line });
                     continue;
@@ -38,10 +31,7 @@ export function createLaravelStackTraceParser(resolver) {
                     file: raw.file,
                     line: raw.line,
                     column: null,
-                    // Decoded, not rewritten: the trace lives inside a JSON string, so
-                    // `Illuminate\\Routing\\Router` IS `Illuminate\Routing\Router` and
-                    // recovering it is reading rather than guessing. Left encoded it
-                    // resolves to no graph node while looking correct.
+                    // Decoded not rewritten: left JSON-escaped it resolves to no graph node while looking correct.
                     functionName: raw.functionName === null ? null : decodeLaravelCallee(raw.functionName),
                 });
                 frames.push({ location, raw: line });

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

@@ -1 +1 @@
-{"version":3,"file":"laravel-stack-trace-parser.js","sourceRoot":"","sources":["../src/laravel-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAe;YACzB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC1C,MAAM,MAAM,GAAiB,EAAE,CAAC;YAEhC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBACxC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;oBACpB,iEAAiE;oBACjE,mEAAmE;oBACnE,iBAAiB;oBACjB,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;oBACpH,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;oBACrC,SAAS;gBACX,CAAC;gBAED,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;gBAChC,IAAI,GAAG,KAAK,IAAI;oBAAE,SAAS;gBAE3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC;oBACtC,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,MAAM,EAAE,IAAI;oBACZ,mEAAmE;oBACnE,mEAAmE;oBACnE,iEAAiE;oBACjE,mDAAmD;oBACnD,YAAY,EAAE,GAAG,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC;iBACvF,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;gBAAE,OAAO,IAAI,CAAC;YACrC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"laravel-stack-trace-parser.js","sourceRoot":"","sources":["../src/laravel-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAe;YACzB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC1C,MAAM,MAAM,GAAiB,EAAE,CAAC;YAEhC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBACxC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;oBACpB,qFAAqF;oBACrF,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;oBACpH,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;oBACrC,SAAS;gBACX,CAAC;gBAED,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;gBAChC,IAAI,GAAG,KAAK,IAAI;oBAAE,SAAS;gBAE3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC;oBACtC,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,MAAM,EAAE,IAAI;oBACZ,+FAA+F;oBAC/F,YAAY,EAAE,GAAG,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC;iBACvF,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;gBAAE,OAAO,IAAI,CAAC;YACrC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -1,74 +1,37 @@
 /**
- * PHP uncaught-`Throwable` trace line shapes — the `LineClassifier` for
- * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
- * feeds `SourceLocationResolver`.
+ * PHP uncaught-Throwable trace line shapes — LineClassifier for
+ * ExceptionBlockDetector plus raw-text-to-frame-parts extraction feeding
+ * SourceLocationResolver.
  *
- * Grammar verified against `php-src`'s own `Zend/zend_exceptions.c` — the C
- * source that generates this text (`build_trace_string`,
- * `zend_trace_to_string`, and the default `Throwable::__toString`
- * composition around line 780) — and against `php-src`'s own `.phpt`
- * conformance suite, the same category of interpreter-verified source
- * `ruby/spec` was for RT-038. See `test/fixtures/PROVENANCE.md` for the
- * specific citations.
+ * Grammar verified against php-src's Zend/zend_exceptions.c (build_trace_string,
+ * zend_trace_to_string, Throwable::__toString) and its .phpt conformance suite.
+ * `php-call-shapes.test.ts` also spawns real php 8.4.4 and asserts against its
+ * stdout — that upgrade is what found RT-105 (older-grammar assumption below).
  *
- * **A real `php` runs against this now** — `php-call-shapes.test.ts` spawns
- * 8.4.4 and asserts against its stdout. That upgrade is what found RT-105:
- * the engine-source reading above was correct about the grammar it read and
- * was reading the *older* grammar, and PHP 8.4 had since put parentheses
- * inside a function name. A format read from the generator is only as
- * current as the generator you read.
+ * PHP's shape is distinct from V8/CPython/Ruby:
  *
- * PHP's shape is its own, distinct from V8, CPython and Ruby alike:
- *
- * 1. **The header carries a real location, but it is a separate line from
- *    the first frame, with `Stack trace:` sitting between them.**
- *    `Fatal error: Uncaught RuntimeException: invoice 3 is corrupt in
- *    /app/InvoiceService.php:15` names the exception AND its construction
- *    site (`Throwable::getFile()`/`getLine()` — the near-universal `throw
- *    new X(...)` pattern makes this the throw site, though strictly it is
- *    where the exception object was `new`-ed, which can differ if a caller
- *    holds a `Throwable` across lines before throwing it). That makes it a
- *    genuine, un-fabricated frame — same reasoning as RT-037's header-only
- *    Rust panic, `functionName: null` because PHP names no function for
- *    this specific location — but the literal `Stack trace:` line always
- *    sits between the header and the first real `#N` frame.
- *    `createPhpLineClassifier` reports this via `LineClassifier.isBridge`
- *    (RT-048): a lone `Stack trace:` line is never even offered to
- *    `isBridge` — `ExceptionBlockDetector` only consults it while a header
- *    is already being held — so an application log line that happens to
- *    print the same phrase for an unrelated reason cannot open anything on
- *    its own, and this classifier no longer needs to track that itself.
- * 2. **A real frame carries a call-type marker PHP itself distinguishes:**
- *    `Class->method()` for an instance call, `Class::method()` for a
- *    static one (verified verbatim against `Zend/tests/bug65911.phpt`'s
- *    `B->go()` and `Zend/tests/inheritance/bug44141.phpt`'s `Y::cheat(5)`).
- *    Both are kept exactly as printed, never normalised to one form.
- * 3. **A frame can have no location at all.** `#N [internal function]:
- *    Class::method(args)` — a call made through `array_map`,
- *    `call_user_func` or similar, where PHP genuinely has no file/line to
- *    report — confirmed against `Zend/tests/bug74164.phpt`. This is exactly
- *    the case RT-037 widened `RawFrameLocation.file`/`.line` to `| null`
- *    for; both are `null` here rather than a fabricated location.
- * 4. **`#N {main}` ends the trace and is a trailer, not a frame** — it has
- *    no trailing `(args)`, so `FRAME_PATTERN` never matches it, and
- *    `isTrailer` closes the block on it. What follows (`  thrown in FILE
- *    on line N`, present on the CLI/log-formatted output) is real but
- *    entirely redundant with the header's own file:line, so it is left to
- *    fall through as a plain log line rather than special-cased into the
- *    block — same choice CPython's `isTrailer` design already established
- *    for "attach only what identifies the exception, not everything after
- *    it."
- * 5. **Chained exceptions (`Throwable::getPrevious()`) need no
- *    connective-exclusion logic**, unlike CPython's. `#N {main}` closes the
- *    first block cleanly; the next line is a blank line (an honest, empty
- *    log event) and then `Next Class: message in file:line` — which
- *    `HEADER_PATTERN`'s lack of start-of-line anchoring matches without
- *    the literal word `Next` needing any special handling at all, the same
- *    way V8's and Ruby's non-anchored header patterns handle a prefix they
- *    were never written to expect. Verified against
- *    `Zend/tests/throwable_001.phpt`, including the detail that only the
- *    **outermost** exception's `thrown in ... on line N` trailer appears —
- *    once, at the very end, not once per link.
+ * 1. Header carries a real location, but on a separate line from the first
+ *    frame with `Stack trace:` between them: `Fatal error: Uncaught
+ *    RuntimeException: ... in /app/InvoiceService.php:15` names the exception's
+ *    construction site (functionName null, since PHP names no function there).
+ *    `Stack trace:` is reported via LineClassifier.isBridge (RT-048), only
+ *    consulted while a header is held — an unrelated log line printing the
+ *    same phrase can't open anything on its own.
+ * 2. A real frame carries `Class->method()` (instance) or `Class::method()`
+ *    (static), verified against Zend/tests/bug65911.phpt and
+ *    inheritance/bug44141.phpt — kept exactly as printed, never normalised.
+ * 3. A frame can have no location: `#N [internal function]: Class::method(args)`
+ *    (call through array_map/call_user_func), confirmed against
+ *    Zend/tests/bug74164.phpt. file/line both null, never fabricated.
+ * 4. `#N {main}` ends the trace as a trailer, not a frame — no trailing `(args)`,
+ *    so FRAME_PATTERN never matches it and isTrailer closes the block. The
+ *    following `thrown in FILE on line N` is redundant with the header and
+ *    left as a plain log line.
+ * 5. Chained exceptions need no connective-exclusion logic, unlike CPython's:
+ *    `#N {main}` closes the block, then a blank line, then `Next Class: message
+ *    in file:line` — matched by HEADER_PATTERN's lack of start-of-line
+ *    anchoring with no special handling for `Next`. Verified against
+ *    Zend/tests/throwable_001.phpt: only the outermost exception's trailer appears, once.
  */
 export interface RawPhpFrame {
     /** `Class->method`, `Class::method`, a bare function name, or `{closure:file:line}` — kept verbatim, never rewritten. */
@@ -82,19 +45,10 @@ export declare function isPhpHeaderLine(line: string): boolean;
 export declare function isPhpFrameLine(line: string): boolean;
 export declare function isPhpTrailerLine(line: string): boolean;
 /**
- * Stateless (RT-048): the single `Stack trace:` line that separates a
- * header from its first real frame is reported via `isBridge`, which
- * `ExceptionBlockDetector` only ever consults while a header is already
- * being held — never from idle. A `Stack trace:` line with no preceding
- * held header therefore can't reach this method at all, so recognising it
- * unconditionally here is exactly as safe as PHP's previous hand-gated
- * boolean, without the classifier having to track "did I just hold a
- * header" itself.
- *
- * Before RT-048, this correctness property depended on a boolean this
- * classifier tracked and reset itself (`awaitingStackTraceMarker`); it is
- * now a structural property of `ExceptionBlockDetector`'s own state
- * machine instead — see `LineClassifier.isBridge`'s doc comment.
+ * Stateless (RT-048): `isBridge` is only ever consulted while a header is
+ * already held, so an unrelated `Stack trace:` line can't reach this method —
+ * recognising it unconditionally here is as safe as PHP's previous hand-gated
+ * boolean, without the classifier tracking that state itself.
  */
 export declare function createPhpLineClassifier(): {
     isHeader(line: string): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"php-frame-parsing.d.ts","sourceRoot":"","sources":["../src/php-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,MAAM,WAAW,WAAW;IAC1B,yHAAyH;IACzH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AA+DD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,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;IAChC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC,CAkBA;AAED,gHAAgH;AAChH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAQpE;AAED,yHAAyH;AACzH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAe9D"}
+{"version":3,"file":"php-frame-parsing.d.ts","sourceRoot":"","sources":["../src/php-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,MAAM,WAAW,WAAW;IAC1B,yHAAyH;IACzH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAoCD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,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;IAChC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC,CAkBA;AAED,gHAAgH;AAChH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAQpE;AAED,yHAAyH;AACzH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAe9D"}

package/dist/php-frame-parsing.js

@@ -1,128 +1,64 @@
 /**
- * PHP uncaught-`Throwable` trace line shapes — the `LineClassifier` for
- * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
- * feeds `SourceLocationResolver`.
+ * PHP uncaught-Throwable trace line shapes — LineClassifier for
+ * ExceptionBlockDetector plus raw-text-to-frame-parts extraction feeding
+ * SourceLocationResolver.
  *
- * Grammar verified against `php-src`'s own `Zend/zend_exceptions.c` — the C
- * source that generates this text (`build_trace_string`,
- * `zend_trace_to_string`, and the default `Throwable::__toString`
- * composition around line 780) — and against `php-src`'s own `.phpt`
- * conformance suite, the same category of interpreter-verified source
- * `ruby/spec` was for RT-038. See `test/fixtures/PROVENANCE.md` for the
- * specific citations.
+ * Grammar verified against php-src's Zend/zend_exceptions.c (build_trace_string,
+ * zend_trace_to_string, Throwable::__toString) and its .phpt conformance suite.
+ * `php-call-shapes.test.ts` also spawns real php 8.4.4 and asserts against its
+ * stdout — that upgrade is what found RT-105 (older-grammar assumption below).
  *
- * **A real `php` runs against this now** — `php-call-shapes.test.ts` spawns
- * 8.4.4 and asserts against its stdout. That upgrade is what found RT-105:
- * the engine-source reading above was correct about the grammar it read and
- * was reading the *older* grammar, and PHP 8.4 had since put parentheses
- * inside a function name. A format read from the generator is only as
- * current as the generator you read.
+ * PHP's shape is distinct from V8/CPython/Ruby:
  *
- * PHP's shape is its own, distinct from V8, CPython and Ruby alike:
- *
- * 1. **The header carries a real location, but it is a separate line from
- *    the first frame, with `Stack trace:` sitting between them.**
- *    `Fatal error: Uncaught RuntimeException: invoice 3 is corrupt in
- *    /app/InvoiceService.php:15` names the exception AND its construction
- *    site (`Throwable::getFile()`/`getLine()` — the near-universal `throw
- *    new X(...)` pattern makes this the throw site, though strictly it is
- *    where the exception object was `new`-ed, which can differ if a caller
- *    holds a `Throwable` across lines before throwing it). That makes it a
- *    genuine, un-fabricated frame — same reasoning as RT-037's header-only
- *    Rust panic, `functionName: null` because PHP names no function for
- *    this specific location — but the literal `Stack trace:` line always
- *    sits between the header and the first real `#N` frame.
- *    `createPhpLineClassifier` reports this via `LineClassifier.isBridge`
- *    (RT-048): a lone `Stack trace:` line is never even offered to
- *    `isBridge` — `ExceptionBlockDetector` only consults it while a header
- *    is already being held — so an application log line that happens to
- *    print the same phrase for an unrelated reason cannot open anything on
- *    its own, and this classifier no longer needs to track that itself.
- * 2. **A real frame carries a call-type marker PHP itself distinguishes:**
- *    `Class->method()` for an instance call, `Class::method()` for a
- *    static one (verified verbatim against `Zend/tests/bug65911.phpt`'s
- *    `B->go()` and `Zend/tests/inheritance/bug44141.phpt`'s `Y::cheat(5)`).
- *    Both are kept exactly as printed, never normalised to one form.
- * 3. **A frame can have no location at all.** `#N [internal function]:
- *    Class::method(args)` — a call made through `array_map`,
- *    `call_user_func` or similar, where PHP genuinely has no file/line to
- *    report — confirmed against `Zend/tests/bug74164.phpt`. This is exactly
- *    the case RT-037 widened `RawFrameLocation.file`/`.line` to `| null`
- *    for; both are `null` here rather than a fabricated location.
- * 4. **`#N {main}` ends the trace and is a trailer, not a frame** — it has
- *    no trailing `(args)`, so `FRAME_PATTERN` never matches it, and
- *    `isTrailer` closes the block on it. What follows (`  thrown in FILE
- *    on line N`, present on the CLI/log-formatted output) is real but
- *    entirely redundant with the header's own file:line, so it is left to
- *    fall through as a plain log line rather than special-cased into the
- *    block — same choice CPython's `isTrailer` design already established
- *    for "attach only what identifies the exception, not everything after
- *    it."
- * 5. **Chained exceptions (`Throwable::getPrevious()`) need no
- *    connective-exclusion logic**, unlike CPython's. `#N {main}` closes the
- *    first block cleanly; the next line is a blank line (an honest, empty
- *    log event) and then `Next Class: message in file:line` — which
- *    `HEADER_PATTERN`'s lack of start-of-line anchoring matches without
- *    the literal word `Next` needing any special handling at all, the same
- *    way V8's and Ruby's non-anchored header patterns handle a prefix they
- *    were never written to expect. Verified against
- *    `Zend/tests/throwable_001.phpt`, including the detail that only the
- *    **outermost** exception's `thrown in ... on line N` trailer appears —
- *    once, at the very end, not once per link.
+ * 1. Header carries a real location, but on a separate line from the first
+ *    frame with `Stack trace:` between them: `Fatal error: Uncaught
+ *    RuntimeException: ... in /app/InvoiceService.php:15` names the exception's
+ *    construction site (functionName null, since PHP names no function there).
+ *    `Stack trace:` is reported via LineClassifier.isBridge (RT-048), only
+ *    consulted while a header is held — an unrelated log line printing the
+ *    same phrase can't open anything on its own.
+ * 2. A real frame carries `Class->method()` (instance) or `Class::method()`
+ *    (static), verified against Zend/tests/bug65911.phpt and
+ *    inheritance/bug44141.phpt — kept exactly as printed, never normalised.
+ * 3. A frame can have no location: `#N [internal function]: Class::method(args)`
+ *    (call through array_map/call_user_func), confirmed against
+ *    Zend/tests/bug74164.phpt. file/line both null, never fabricated.
+ * 4. `#N {main}` ends the trace as a trailer, not a frame — no trailing `(args)`,
+ *    so FRAME_PATTERN never matches it and isTrailer closes the block. The
+ *    following `thrown in FILE on line N` is redundant with the header and
+ *    left as a plain log line.
+ * 5. Chained exceptions need no connective-exclusion logic, unlike CPython's:
+ *    `#N {main}` closes the block, then a blank line, then `Next Class: message
+ *    in file:line` — matched by HEADER_PATTERN's lack of start-of-line
+ *    anchoring with no special handling for `Next`. Verified against
+ *    Zend/tests/throwable_001.phpt: only the outermost exception's trailer appears, once.
  */
 const STACK_TRACE_MARKER = "Stack trace:";
 /**
- * Not anchored to the start of the line, for the same reason V8's and
- * Ruby's header patterns aren't: PHP's own "Fatal error: " / "PHP Fatal
- * error: " SAPI prefix, an application logger's own prefix, and the
- * chained-exception "Next " marker are all real prefixes this must see
- * through. The greedy `message` group combined with the `$`-anchored
- * `in file:line` suffix correctly resolves to the LAST such suffix on the
- * line even when the message text itself contains the substring " in ".
+ * Not anchored to the start of the line: PHP's "Fatal error: " SAPI prefix,
+ * a logger's own prefix, and the chained-exception "Next " marker must all
+ * be seen through. Greedy `message` plus the `$`-anchored `in file:line`
+ * suffix resolves to the LAST such suffix even if the message contains " in ".
  */
 const HEADER_PATTERN = /(?<class>[A-Za-z_\x7f-\xff][\w\\]*)(?::\s(?<message>.*))?\s+in\s+(?<file>.+):(?<line>\d+)$/;
 /**
  * `#N file(line): [Class-><or::>]function(args)` or
  * `#N [internal function]: [Class-><or::>]function(args)`. Requiring a
- * trailing `(...)` is what excludes `#N {main}` from this pattern, so no
- * separate exclusion is needed. Args can themselves contain parens
- * (`Object(Closure)`, a nested call's own printed form) and are not
- * otherwise parsed; they stay in `raw` for audit.
- *
- * ## Why the callee is not simply `[^(]+` (RT-105)
- *
- * It was, and **PHP 8.4 put parentheses inside a function name.** The
- * "Closures in stack traces" change (php-src #12178, shipped 2024-11-21)
- * renamed a closure declared inside a method from `{closure}` to
- * `{closure:Class::method():LINE}`. Measured against real `php 8.4.4`:
- *
- * ```
- * #0 /app/Repo.php(2): Repo->{closure:Repo::load():5}()
- * ```
+ * trailing `(...)` excludes `#N {main}` from this pattern. Args can contain
+ * parens (`Object(Closure)`) and are kept in `raw`, not parsed.
  *
- * `[^(]+` stops at the `(` in `load()`, so the callee parsed as
- * `Repo->{closure:Repo::load` — the line still matched `isFrame`, still
- * carried the right file and line, and reported a **truncated, malformed
- * function name with full confidence.** Not lost evidence: wrong evidence,
- * which is the class this adapter's cross-language controls exist to ban.
- * PHP < 8.4 printed a bare `{closure}` and could not reach it.
+ * Callee is not simply `[^(]+` (RT-105): PHP 8.4's closures-in-stack-traces
+ * change (php-src #12178) renamed `{closure}` to `{closure:Class::method():LINE}`,
+ * e.g. `Repo->{closure:Repo::load():5}()`. `[^(]+` stopped at `load()`'s paren
+ * and silently produced a truncated, malformed name with full confidence —
+ * wrong evidence, not lost evidence. Fix: `{closure:...}` is matched whole
+ * first in the alternation (must come first, or `[^(]` would consume the `{`).
+ * Greedy `.+` was rejected too — measured on `handler(Object(Closure))`, it
+ * backtracks to the last `(` and breaks the nested-args case.
  *
- * The fix is a grammar, not a looser pattern. A `{closure:...}` block is
- * the one place a *name* may legitimately contain a paren, so it is matched
- * whole and everything else stays `[^(]`. It must come first in the
- * alternation: `[^(]` would otherwise consume the `{` and leave the engine
- * mid-token when it reached the inner paren.
- *
- * Greedy `.+` was the obvious alternative and is wrong — measured, not
- * assumed: on `handler(Object(Closure))` it backtracks to the *last* `(`
- * and yields the callee `handler(Object`, breaking the nested-args case
- * `[^(]+` was written for in the first place.
- *
- * **Not changed, because it was measured and holds:** the greedy `file`
- * group looks like it should mis-split on a string argument containing
- * `(N): ` — `audit('order(12): x')` — and does not. The engine tries that
- * split first, fails to satisfy the callee-plus-args tail, and backtracks
- * to the real one. Recorded because the next reader will suspect it too.
+ * The greedy `file` group looks like it should mis-split on a string argument
+ * containing `(N): ` (`audit('order(12): x')`) — measured, it doesn't: the
+ * engine backtracks to the real split after failing the callee-plus-args tail.
  */
 const FRAME_PATTERN = /^#\d+\s+(?:(?<file>.+)\((?<line>\d+)\):\s|\[internal function\]:\s)(?<callee>(?:\{closure:[^}]*\}|[^(])+)\(.*\)\s*$/;
 const TRAILER_PATTERN = /^#\d+\s+\{main\}\s*$/;
@@ -136,19 +72,10 @@ export function isPhpTrailerLine(line) {
     return TRAILER_PATTERN.test(line);
 }
 /**
- * Stateless (RT-048): the single `Stack trace:` line that separates a
- * header from its first real frame is reported via `isBridge`, which
- * `ExceptionBlockDetector` only ever consults while a header is already
- * being held — never from idle. A `Stack trace:` line with no preceding
- * held header therefore can't reach this method at all, so recognising it
- * unconditionally here is exactly as safe as PHP's previous hand-gated
- * boolean, without the classifier having to track "did I just hold a
- * header" itself.
- *
- * Before RT-048, this correctness property depended on a boolean this
- * classifier tracked and reset itself (`awaitingStackTraceMarker`); it is
- * now a structural property of `ExceptionBlockDetector`'s own state
- * machine instead — see `LineClassifier.isBridge`'s doc comment.
+ * Stateless (RT-048): `isBridge` is only ever consulted while a header is
+ * already held, so an unrelated `Stack trace:` line can't reach this method —
+ * recognising it unconditionally here is as safe as PHP's previous hand-gated
+ * boolean, without the classifier tracking that state itself.
  */
 export function createPhpLineClassifier() {
     return {

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

@@ -1 +1 @@
-{"version":3,"file":"php-frame-parsing.js","sourceRoot":"","sources":["../src/php-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAWH,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAG,4FAA4F,CAAC;AAEpH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,aAAa,GACjB,qHAAqH,CAAC;AAExH,MAAM,eAAe,GAAG,sBAAsB,CAAC;AAE/C,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB;IAMrC,OAAO;QACL,QAAQ,CAAC,IAAY;YACnB,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,CAAC,IAAY;YAClB,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,QAAQ,CAAC,IAAY;YACnB,OAAO,IAAI,CAAC,IAAI,EAAE,KAAK,kBAAkB,CAAC;QAC5C,CAAC;QAED,SAAS,CAAC,IAAY;YACpB,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,gHAAgH;AAChH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IACrE,mEAAmE;IACnE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACxD,CAAC;AAED,yHAAyH;AACzH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACtC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAEnC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,4EAA4E;QAC5E,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAClD,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAClD,CAAC"}
+{"version":3,"file":"php-frame-parsing.js","sourceRoot":"","sources":["../src/php-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAWH,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,cAAc,GAAG,4FAA4F,CAAC;AAEpH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,aAAa,GACjB,qHAAqH,CAAC;AAExH,MAAM,eAAe,GAAG,sBAAsB,CAAC;AAE/C,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB;IAMrC,OAAO;QACL,QAAQ,CAAC,IAAY;YACnB,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,CAAC,IAAY;YAClB,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,QAAQ,CAAC,IAAY;YACnB,OAAO,IAAI,CAAC,IAAI,EAAE,KAAK,kBAAkB,CAAC;QAC5C,CAAC;QAED,SAAS,CAAC,IAAY;YACpB,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,gHAAgH;AAChH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IACrE,mEAAmE;IACnE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACxD,CAAC;AAED,yHAAyH;AACzH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACtC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAEnC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,4EAA4E;QAC5E,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAClD,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAClD,CAAC"}

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

@@ -1,33 +1,24 @@
 /**
- * The concrete `RuntimeAdapter` for PHP.
+ * The concrete RuntimeAdapter for PHP.
  *
- * PHP's grammar needed no seam changes beyond RT-037's already-nullable
- * `SourceLocation`/`RawFrameLocation` fields, which an `[internal function]`
- * frame needs but did not itself force — that widening already existed by
- * the time this adapter was built. See `php-frame-parsing.ts` for the one
- * behaviour this language DID need from the classifier: recognising the
- * single `Stack trace:` line that separates PHP's header from its first
- * real frame, and only the one that follows a header just held.
+ * Needed no seam changes beyond RT-037's already-nullable SourceLocation/
+ * RawFrameLocation fields (needed for `[internal function]` frames). See
+ * php-frame-parsing.ts for the one classifier behavior PHP does need:
+ * recognising the `Stack trace:` line that follows a just-held header.
  */
 import type { RuntimeAdapter } from "@descryy/runtime-backend-observation";
 export interface PhpRuntimeAdapterOptions {
     /** Attributed on every emitted Evidence's `service` field (plan §16.7). Omit when not applicable. */
     readonly service?: string;
     /**
-     * The framework whose exception logging this process uses (§16, RT-112).
+     * The framework whose exception logging this process uses (RT-112).
+     * Declared, never sniffed, same rule as ASP.NET's/Rails' options. Laravel
+     * logs through Monolog, not Throwable::__toString() — different header,
+     * bridge (`[stacktrace]`), and JSON-escaped class names. Measured live:
+     * 0 exceptions, a bare 53-line STACK_TRACE with no identity attached.
      *
-     * **Declared, never sniffed**, the same rule ASP.NET's and Rails' options
-     * follow. Laravel logs through Monolog rather than through PHP's own
-     * `Throwable::__toString()`: the header reads `(Class(code: 0): message at
-     * file:line)` where PHP's reads `... in file:line`, the bridge is
-     * `[stacktrace]` rather than `Stack trace:`, and class names arrive
-     * JSON-escaped. Measured live: **0 exceptions, and a bare 53-line
-     * STACK_TRACE with no identity attached to it.**
-     *
-     * **This option cannot fix Laravel's default log destination**, which is a
-     * file (`storage/logs/laravel.log`). A collector watching process output
-     * sees nothing at all unless the application sets `LOG_CHANNEL=stderr`.
-     * That is a disclosure to the user, not something an adapter can decide.
+     * Cannot fix Laravel's default log destination (a file); the app must set
+     * LOG_CHANNEL=stderr or a collector sees nothing at all — disclosed to the user.
      */
     readonly framework?: "laravel";
 }

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

@@ -1 +1 @@
-{"version":3,"file":"php-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/php-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,sCAAsC,CAAC;AAUhG,MAAM,WAAW,wBAAwB;IACvC,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,cAAc,CA2B9F"}
+{"version":3,"file":"php-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/php-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,sCAAsC,CAAC;AAUhG,MAAM,WAAW,wBAAwB;IACvC,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,cAAc,CAyB9F"}

package/dist/php-runtime-adapter.js

@@ -1,13 +1,10 @@
 /**
- * The concrete `RuntimeAdapter` for PHP.
+ * The concrete RuntimeAdapter for PHP.
  *
- * PHP's grammar needed no seam changes beyond RT-037's already-nullable
- * `SourceLocation`/`RawFrameLocation` fields, which an `[internal function]`
- * frame needs but did not itself force — that widening already existed by
- * the time this adapter was built. See `php-frame-parsing.ts` for the one
- * behaviour this language DID need from the classifier: recognising the
- * single `Stack trace:` line that separates PHP's header from its first
- * real frame, and only the one that follows a header just held.
+ * Needed no seam changes beyond RT-037's already-nullable SourceLocation/
+ * RawFrameLocation fields (needed for `[internal function]` frames). See
+ * php-frame-parsing.ts for the one classifier behavior PHP does need:
+ * recognising the `Stack trace:` line that follows a just-held header.
  */
 import { createLogCollector } from "@descryy/runtime-backend-observation";
 import { createLaravelLineClassifier } from "./laravel-frame-parsing.js";
@@ -24,9 +21,7 @@ export function createPhpRuntimeAdapter(options = {}) {
     function createBackendCollectors(sources) {
         return sources.map((source) => createLogCollector({
             source,
-            // One classifier per collector, never shared: it carries the
-            // "just saw a header, expecting Stack trace: next" bit, and two
-            // processes' output must not prime each other.
+            // One classifier per collector: carries per-process state, must not be shared.
             classifier: isLaravel ? createLaravelLineClassifier() : createPhpLineClassifier(),
             stackTraceParser,
             ...(options.service !== undefined ? { service: options.service } : {}),

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

@@ -1 +1 @@
-{"version":3,"file":"php-runtime-adapter.js","sourceRoot":"","sources":["../src/php-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAwBxE,MAAM,UAAU,uBAAuB,CAAC,UAAoC,EAAE;IAC5E,MAAM,sBAAsB,GAAG,+BAA+B,EAAE,CAAC;IACjE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;IAClD,MAAM,gBAAgB,GAAG,SAAS;QAChC,CAAC,CAAC,6BAA6B,CAAC,sBAAsB,CAAC;QACvD,CAAC,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,CAAC;IAEtD,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,6DAA6D;YAC7D,gEAAgE;YAChE,+CAA+C;YAC/C,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,2BAA2B,EAAE,CAAC,CAAC,CAAC,uBAAuB,EAAE;YACjF,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,KAAK;QACf,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;KACxB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"php-runtime-adapter.js","sourceRoot":"","sources":["../src/php-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAkBxE,MAAM,UAAU,uBAAuB,CAAC,UAAoC,EAAE;IAC5E,MAAM,sBAAsB,GAAG,+BAA+B,EAAE,CAAC;IACjE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;IAClD,MAAM,gBAAgB,GAAG,SAAS;QAChC,CAAC,CAAC,6BAA6B,CAAC,sBAAsB,CAAC;QACvD,CAAC,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,CAAC;IAEtD,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,+EAA+E;YAC/E,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,2BAA2B,EAAE,CAAC,CAAC,CAAC,uBAAuB,EAAE;YACjF,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,KAAK;QACf,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;KACxB,CAAC;AACJ,CAAC"}

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

@@ -1,29 +1,19 @@
 /**
- * PHP `SourceLocationResolver`.
+ * PHP SourceLocationResolver.
  *
- * **Every location is `self-contained`, and that is a positive claim rather
- * than a fallback** — the same category RT-003 already assigns PHP traces
- * alongside Python tracebacks and Ruby backtraces. A real frame names the
- * `.php` file the engine was actually executing; there is no compilation
- * step and no separate map that can drift or go missing. The frame IS the
- * answer, when the engine printed one at all.
+ * Every location is `self-contained` (RT-003, same category as Python/Ruby):
+ * a real frame names the `.php` file the engine actually executed, no
+ * compile step or map to drift.
  *
- * **A frame can have no location.** `#N [internal function]: ...` means
- * PHP genuinely captured no file or line for that call — not that this
- * resolver failed to look. `reliability` stays `self-contained` even then:
- * this is not a side artifact that went missing (there was never a PDB or
- * source map to lose), it is the engine's own honest report that it has
- * nothing to offer for that frame. `file`/`line` pass through as the `null`
- * they arrived as, per RT-037's widening of `SourceLocation` for exactly
- * this shape (a stripped JVM frame first forced it; a PHP internal-function
- * frame is the same shape for a different reason).
+ * `#N [internal function]: ...` means PHP captured no file/line for that
+ * call — not that this resolver failed. `reliability` stays `self-contained`
+ * even then (no PDB/source map was ever there to go missing); file/line
+ * pass through as the null they arrived as (RT-037's SourceLocation widening).
  *
- * **What this deliberately does not do:** check that the file exists on
- * disk, or that its contents still match what ran. `self-contained` is a
- * statement about the mechanism, not about whether the working tree has
- * since been edited.
+ * Deliberately does not check the file exists on disk or still matches what
+ * ran — `self-contained` is a statement about mechanism, not the working tree.
  *
- * `column` is always null. PHP traces never print one.
+ * `column` is always null — PHP traces never print one.
  */
 import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
 export declare function createPhpSourceLocationResolver(): SourceLocationResolver;

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

@@ -1 +1 @@
-{"version":3,"file":"php-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/php-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAErG,wBAAgB,+BAA+B,IAAI,sBAAsB,CAgBxE"}
+{"version":3,"file":"php-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/php-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAErG,wBAAgB,+BAA+B,IAAI,sBAAsB,CAcxE"}

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

@@ -1,35 +1,23 @@
 /**
- * PHP `SourceLocationResolver`.
+ * PHP SourceLocationResolver.
  *
- * **Every location is `self-contained`, and that is a positive claim rather
- * than a fallback** — the same category RT-003 already assigns PHP traces
- * alongside Python tracebacks and Ruby backtraces. A real frame names the
- * `.php` file the engine was actually executing; there is no compilation
- * step and no separate map that can drift or go missing. The frame IS the
- * answer, when the engine printed one at all.
+ * Every location is `self-contained` (RT-003, same category as Python/Ruby):
+ * a real frame names the `.php` file the engine actually executed, no
+ * compile step or map to drift.
  *
- * **A frame can have no location.** `#N [internal function]: ...` means
- * PHP genuinely captured no file or line for that call — not that this
- * resolver failed to look. `reliability` stays `self-contained` even then:
- * this is not a side artifact that went missing (there was never a PDB or
- * source map to lose), it is the engine's own honest report that it has
- * nothing to offer for that frame. `file`/`line` pass through as the `null`
- * they arrived as, per RT-037's widening of `SourceLocation` for exactly
- * this shape (a stripped JVM frame first forced it; a PHP internal-function
- * frame is the same shape for a different reason).
+ * `#N [internal function]: ...` means PHP captured no file/line for that
+ * call — not that this resolver failed. `reliability` stays `self-contained`
+ * even then (no PDB/source map was ever there to go missing); file/line
+ * pass through as the null they arrived as (RT-037's SourceLocation widening).
  *
- * **What this deliberately does not do:** check that the file exists on
- * disk, or that its contents still match what ran. `self-contained` is a
- * statement about the mechanism, not about whether the working tree has
- * since been edited.
+ * Deliberately does not check the file exists on disk or still matches what
+ * ran — `self-contained` is a statement about mechanism, not the working tree.
  *
- * `column` is always null. PHP traces never print one.
+ * `column` is always null — PHP traces never print one.
  */
 export function createPhpSourceLocationResolver() {
     return {
-        // Async to satisfy the interface; PHP needs no I/O to answer, so this
-        // never awaits — same as the Python and Ruby resolvers, for the same
-        // reason.
+        // Async to satisfy the interface; PHP needs no I/O so this never awaits.
         resolve(frame) {
             return Promise.resolve({
                 file: frame.file,

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

@@ -1 +1 @@
-{"version":3,"file":"php-source-location-resolver.js","sourceRoot":"","sources":["../src/php-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,MAAM,UAAU,+BAA+B;IAC7C,OAAO;QACL,sEAAsE;QACtE,qEAAqE;QACrE,UAAU;QACV,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,gBAAgB;gBAC7B,WAAW,EAAE,IAAI;aAClB,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"php-source-location-resolver.js","sourceRoot":"","sources":["../src/php-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,UAAU,+BAA+B;IAC7C,OAAO;QACL,yEAAyE;QACzE,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,gBAAgB;gBAC7B,WAAW,EAAE,IAAI;aAClB,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -1,19 +1,14 @@
 /**
- * Composes the pure PHP line-recognition functions (`php-frame-parsing.ts`)
- * with a `SourceLocationResolver` to implement the full async
- * `StackTraceParser` contract.
+ * Composes the pure PHP line-recognition functions (php-frame-parsing.ts)
+ * with a SourceLocationResolver to implement the async StackTraceParser contract.
  *
- * **No reversal.** The header's own file:line is the exception's
- * construction site — the innermost real location — and each `#N` frame
- * walks outward toward `{main}`. `StackTrace.frames` is contractually
- * most-recent-first, and that is the order this text already prints in.
+ * No reversal — the header's file:line is the construction site (innermost),
+ * each `#N` frame walks outward toward `{main}`, and that's the order the
+ * text already prints in.
  *
- * `fidelity` is always reported `"synchronous"`. A PHP trace is built by
- * walking the actual call frames live at the moment the `Throwable` was
- * constructed — every location shown is a genuine link in the chain that
- * was executing. It cannot show a logical caller across a `Fiber` (PHP
- * 8.1+) suspension boundary, the same class of limit every other adapter
- * in this codebase shares and none claims to see through by text alone.
+ * `fidelity` is always `"synchronous"` — walks actual live call frames at
+ * construction time, but cannot show a caller across a Fiber (PHP 8.1+)
+ * suspension boundary, same limit every adapter here shares.
  */
 import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
 export declare function createPhpStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;

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

@@ -1 +1 @@
-{"version":3,"file":"php-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/php-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAIrG,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAiD5F"}
+{"version":3,"file":"php-stack-trace-parser.d.ts","sourceRoot":"","sources":["../src/php-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAIrG,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,CAkC5F"}

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

@@ -1,19 +1,14 @@
 /**
- * Composes the pure PHP line-recognition functions (`php-frame-parsing.ts`)
- * with a `SourceLocationResolver` to implement the full async
- * `StackTraceParser` contract.
+ * Composes the pure PHP line-recognition functions (php-frame-parsing.ts)
+ * with a SourceLocationResolver to implement the async StackTraceParser contract.
  *
- * **No reversal.** The header's own file:line is the exception's
- * construction site — the innermost real location — and each `#N` frame
- * walks outward toward `{main}`. `StackTrace.frames` is contractually
- * most-recent-first, and that is the order this text already prints in.
+ * No reversal — the header's file:line is the construction site (innermost),
+ * each `#N` frame walks outward toward `{main}`, and that's the order the
+ * text already prints in.
  *
- * `fidelity` is always reported `"synchronous"`. A PHP trace is built by
- * walking the actual call frames live at the moment the `Throwable` was
- * constructed — every location shown is a genuine link in the chain that
- * was executing. It cannot show a logical caller across a `Fiber` (PHP
- * 8.1+) suspension boundary, the same class of limit every other adapter
- * in this codebase shares and none claims to see through by text alone.
+ * `fidelity` is always `"synchronous"` — walks actual live call frames at
+ * construction time, but cannot show a caller across a Fiber (PHP 8.1+)
+ * suspension boundary, same limit every adapter here shares.
  */
 import { parsePhpHeaderFrame, parsePhpFrame } from "./php-frame-parsing.js";
 export function createPhpStackTraceParser(resolver) {
@@ -22,11 +17,7 @@ export function createPhpStackTraceParser(resolver) {
             const lines = rawText.split(/\r\n|\r|\n/);
             const frames = [];
             for (const line of lines) {
-                // Structurally disjoint: a real frame line always starts with `#N`,
-                // the header never does, so at most one of these ever matches a
-                // given line. `Stack trace:` and the `#N {main}` trailer match
-                // neither and are real parts of the block that are simply not
-                // frames — nothing is fabricated for them.
+                // Structurally disjoint: frame lines start with `#N`, header never does, so at most one matches.
                 const raw = parsePhpFrame(line) ?? parsePhpHeaderFrame(line);
                 if (raw === null)
                     continue;
@@ -39,26 +30,15 @@ export function createPhpStackTraceParser(resolver) {
                 frames.push({ location, raw: line });
             }
             if (frames.length === 0) {
-                // Nothing frame-shaped at all — not recognisable as a PHP
-                // uncaught-Throwable trace, per this interface's contract: null,
-                // never an empty-but-structured StackTrace standing in for
-                // "couldn't parse".
+                // Nothing frame-shaped — null, never an empty 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). PHP's is 0 because the
-            // **header carries a location no `#N` frame does** — `getFile()` /
-            // `getLine()`, the site where the `Throwable` was constructed — and
-            // it is the first line of the block, so it parses to frame 0.
-            //
-            // This is emphatically not "index 0 happens to work". PHP's `#N`
-            // frames name the **callee at the caller's location**, so `#0` is the
-            // call site one level out; an adapter that pointed at `#0` would
-            // report the caller's line as the failure site and look correct doing
-            // it. See `php-frame-parsing.ts` for the one caveat this inherits:
-            // strictly the header is where the exception was `new`-ed, which
-            // differs from the throw site only if a caller holds a `Throwable`
-            // across lines before throwing it.
+            // primaryFrameIndex 0 (RT-083): the header (getFile()/getLine(), the
+            // Throwable's construction site) is frame 0. Not "0 happens to work" —
+            // PHP's `#N` frames name the callee at the CALLER's location, so `#0`
+            // would report the caller's line as the failure site. See
+            // php-frame-parsing.ts for the one caveat: strictly this is where the
+            // exception was `new`-ed, which can differ from the throw site.
             return { fidelity: "synchronous", frames, primaryFrameIndex: 0 };
         },
     };

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

@@ -1 +1 @@
-{"version":3,"file":"php-stack-trace-parser.js","sourceRoot":"","sources":["../src/php-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5E,MAAM,UAAU,yBAAyB,CAAC,QAAgC;IACxE,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAe;YACzB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAE1C,MAAM,MAAM,GAAiB,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,oEAAoE;gBACpE,gEAAgE;gBAChE,+DAA+D;gBAC/D,8DAA8D;gBAC9D,2CAA2C;gBAC3C,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBAC7D,IAAI,GAAG,KAAK,IAAI;oBAAE,SAAS;gBAE3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC;oBACtC,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,MAAM,EAAE,IAAI;oBACZ,YAAY,EAAE,GAAG,CAAC,YAAY;iBAC/B,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,0DAA0D;gBAC1D,iEAAiE;gBACjE,2DAA2D;gBAC3D,oBAAoB;gBACpB,OAAO,IAAI,CAAC;YACd,CAAC;YAED,kEAAkE;YAClE,qEAAqE;YACrE,mEAAmE;YACnE,oEAAoE;YACpE,8DAA8D;YAC9D,EAAE;YACF,iEAAiE;YACjE,sEAAsE;YACtE,iEAAiE;YACjE,sEAAsE;YACtE,mEAAmE;YACnE,iEAAiE;YACjE,mEAAmE;YACnE,mCAAmC;YACnC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"php-stack-trace-parser.js","sourceRoot":"","sources":["../src/php-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5E,MAAM,UAAU,yBAAyB,CAAC,QAAgC;IACxE,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAe;YACzB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAE1C,MAAM,MAAM,GAAiB,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,iGAAiG;gBACjG,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBAC7D,IAAI,GAAG,KAAK,IAAI;oBAAE,SAAS;gBAE3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC;oBACtC,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,IAAI,EAAE,GAAG,CAAC,IAAI;oBACd,MAAM,EAAE,IAAI;oBACZ,YAAY,EAAE,GAAG,CAAC,YAAY;iBAC/B,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,2FAA2F;gBAC3F,OAAO,IAAI,CAAC;YACd,CAAC;YAED,qEAAqE;YACrE,uEAAuE;YACvE,sEAAsE;YACtE,0DAA0D;YAC1D,sEAAsE;YACtE,gEAAgE;YAChE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@descryy/runtime-adapter-php",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "type": "module",
   "description": "PHP runtime adapter: uncaught-Throwable trace parsing, self-contained source locations, the concrete RuntimeAdapter for PHP.",
   "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/descryhq-wq/descry-runtime.git",
+    "directory": "packages/adapter-php"
+  },
   "engines": {
     "node": ">=22.5"
   },
@@ -24,7 +29,7 @@
     "build": "tsc -b"
   },
   "dependencies": {
-    "@descryy/runtime-contracts": "*",
-    "@descryy/runtime-backend-observation": "*"
+    "@descryy/runtime-contracts": "0.3.0",
+    "@descryy/runtime-backend-observation": "0.3.0"
   }
 }