@descryy/runtime-adapter-php 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createLaravelLineClassifier, decodeLaravelCallee, isLaravelHeaderLine, parseLaravelHeader, } from "./laravel-frame-parsing.ts";
+export { createLaravelStackTraceParser } from "./laravel-stack-trace-parser.ts";
+export type { RawPhpFrame } from "./php-frame-parsing.ts";
+export { createPhpLineClassifier, isPhpHeaderLine, isPhpFrameLine, isPhpTrailerLine, parsePhpHeaderFrame, parsePhpFrame, } from "./php-frame-parsing.ts";
+export { createPhpSourceLocationResolver } from "./php-source-location-resolver.ts";
+export { createPhpStackTraceParser } from "./php-stack-trace-parser.ts";
+export type { PhpRuntimeAdapterOptions } from "./php-runtime-adapter.ts";
+export { createPhpRuntimeAdapter } from "./php-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,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,YAAY,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,YAAY,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createLaravelLineClassifier, decodeLaravelCallee, isLaravelHeaderLine, parseLaravelHeader, } from "./laravel-frame-parsing.js";
+export { createLaravelStackTraceParser } from "./laravel-stack-trace-parser.js";
+export { createPhpLineClassifier, isPhpHeaderLine, isPhpFrameLine, isPhpTrailerLine, parsePhpHeaderFrame, parsePhpFrame, } from "./php-frame-parsing.js";
+export { createPhpSourceLocationResolver } from "./php-source-location-resolver.js";
+export { createPhpStackTraceParser } from "./php-stack-trace-parser.js";
+export { createPhpRuntimeAdapter } from "./php-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":"AAAA,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC"}

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

@@ -0,0 +1,114 @@
+/**
+ * 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.
+ */
+/**
+ * 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.
+ */
+export declare function decodeLaravelCallee(callee: string): string;
+export declare function isLaravelHeaderLine(line: string): boolean;
+/** `null` when the line is not Laravel's `(Class(code: N): message at file:line)` shape — never fabricated. */
+export declare function parseLaravelHeader(line: string): {
+    readonly exceptionClass: string;
+    readonly message: string;
+    readonly file: 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.
+ */
+export declare function createLaravelLineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+    isBridge(line: string): boolean;
+    isTrailer(line: string): boolean;
+};
+//# sourceMappingURL=laravel-frame-parsing.d.ts.map

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

@@ -0,0 +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"}

package/dist/laravel-frame-parsing.js

@@ -0,0 +1,145 @@
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+export function decodeLaravelCallee(callee) {
+    return callee.replace(/\\\\/g, "\\");
+}
+export function isLaravelHeaderLine(line) {
+    return LARAVEL_HEADER.test(line);
+}
+/** `null` when the line is not Laravel's `(Class(code: N): message at file:line)` shape — never fabricated. */
+export function parseLaravelHeader(line) {
+    const match = LARAVEL_HEADER.exec(line);
+    if (!match?.groups)
+        return null;
+    const file = match.groups["file"];
+    const lineNumber = Number(match.groups["line"]);
+    const exceptionClass = match.groups["class"];
+    if (file === undefined || exceptionClass === undefined || !Number.isInteger(lineNumber))
+        return null;
+    return {
+        exceptionClass: decodeLaravelCallee(exceptionClass),
+        message: match.groups["message"] ?? "",
+        file,
+        line: lineNumber,
+    };
+}
+/**
+ * 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.
+ */
+export function createLaravelLineClassifier() {
+    return {
+        isHeader: isLaravelHeaderLine,
+        isFrame: isPhpFrameLine,
+        isBridge: (line) => line.trim() === LARAVEL_BRIDGE,
+        isTrailer: isPhpTrailerLine,
+    };
+}
+//# sourceMappingURL=laravel-frame-parsing.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,19 @@
+/**
+ * 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
+ *
+ * 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.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createLaravelStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=laravel-stack-trace-parser.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,55 @@
+/**
+ * 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
+ *
+ * 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.
+ */
+import { decodeLaravelCallee, parseLaravelHeader } from "./laravel-frame-parsing.js";
+import { parsePhpFrame } from "./php-frame-parsing.js";
+export function createLaravelStackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            const lines = rawText.split(/\r\n|\r|\n/);
+            const frames = [];
+            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.
+                    const location = await resolver.resolve({ file: header.file, line: header.line, column: null, functionName: null });
+                    frames.push({ location, raw: line });
+                    continue;
+                }
+                const raw = parsePhpFrame(line);
+                if (raw === null)
+                    continue;
+                const location = await resolver.resolve({
+                    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.
+                    functionName: raw.functionName === null ? null : decodeLaravelCallee(raw.functionName),
+                });
+                frames.push({ location, raw: line });
+            }
+            if (frames.length === 0)
+                return null;
+            return { fidelity: "synchronous", frames, primaryFrameIndex: 0 };
+        },
+    };
+}
+//# sourceMappingURL=laravel-stack-trace-parser.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,109 @@
+/**
+ * PHP uncaught-`Throwable` trace line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
+ * feeds `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.
+ *
+ * **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 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.
+ */
+export interface RawPhpFrame {
+    /** `Class->method`, `Class::method`, a bare function name, or `{closure:file:line}` — kept verbatim, never rewritten. */
+    readonly functionName: string | null;
+    /** Null for an `[internal function]` frame — no file was ever printed, never fabricated. */
+    readonly file: string | null;
+    /** Null exactly when `file` is — the two are only ever known or unknown together in this grammar. */
+    readonly line: number | null;
+}
+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.
+ */
+export declare function createPhpLineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+    isBridge(line: string): boolean;
+    isTrailer(line: string): boolean;
+};
+/** `null` when the line doesn't match PHP's `Class[: message] in file:line` header shape — never fabricated. */
+export declare function parsePhpHeaderFrame(line: string): RawPhpFrame | null;
+/** `null` for anything not shaped like a `#N (file(line)|[internal function]): callee(...)` frame — never fabricated. */
+export declare function parsePhpFrame(line: string): RawPhpFrame | null;
+//# sourceMappingURL=php-frame-parsing.d.ts.map

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

@@ -0,0 +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"}

package/dist/php-frame-parsing.js

@@ -0,0 +1,200 @@
+/**
+ * PHP uncaught-`Throwable` trace line shapes — the `LineClassifier` for
+ * `ExceptionBlockDetector` plus the raw-text-to-frame-parts extraction that
+ * feeds `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.
+ *
+ * **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 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.
+ */
+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 ".
+ */
+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}()
+ * ```
+ *
+ * `[^(]+` 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.
+ *
+ * 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.
+ */
+const FRAME_PATTERN = /^#\d+\s+(?:(?<file>.+)\((?<line>\d+)\):\s|\[internal function\]:\s)(?<callee>(?:\{closure:[^}]*\}|[^(])+)\(.*\)\s*$/;
+const TRAILER_PATTERN = /^#\d+\s+\{main\}\s*$/;
+export function isPhpHeaderLine(line) {
+    return HEADER_PATTERN.test(line);
+}
+export function isPhpFrameLine(line) {
+    return FRAME_PATTERN.test(line);
+}
+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.
+ */
+export function createPhpLineClassifier() {
+    return {
+        isHeader(line) {
+            return isPhpHeaderLine(line);
+        },
+        isFrame(line) {
+            return isPhpFrameLine(line);
+        },
+        isBridge(line) {
+            return line.trim() === STACK_TRACE_MARKER;
+        },
+        isTrailer(line) {
+            return isPhpTrailerLine(line);
+        },
+    };
+}
+/** `null` when the line doesn't match PHP's `Class[: message] in file:line` header shape — never fabricated. */
+export function parsePhpHeaderFrame(line) {
+    const match = HEADER_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;
+    // PHP names no function for the exception's own construction site.
+    return { functionName: null, file, line: lineNumber };
+}
+/** `null` for anything not shaped like a `#N (file(line)|[internal function]): callee(...)` frame — never fabricated. */
+export function parsePhpFrame(line) {
+    const match = FRAME_PATTERN.exec(line);
+    if (!match?.groups)
+        return null;
+    const callee = match.groups["callee"];
+    if (callee === undefined)
+        return null;
+    const functionName = callee.trim();
+    const file = match.groups["file"];
+    if (file === undefined) {
+        // The `[internal function]:` branch matched — no location was ever printed.
+        return { functionName, file: null, line: null };
+    }
+    const lineNumber = Number(match.groups["line"]);
+    if (!Number.isInteger(lineNumber))
+        return null;
+    return { functionName, file, line: lineNumber };
+}
+//# sourceMappingURL=php-frame-parsing.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+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).
+     *
+     * **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.
+     */
+    readonly framework?: "laravel";
+}
+export declare function createPhpRuntimeAdapter(options?: PhpRuntimeAdapterOptions): RuntimeAdapter;
+//# sourceMappingURL=php-runtime-adapter.d.ts.map

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

@@ -0,0 +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"}

package/dist/php-runtime-adapter.js

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+import { createLogCollector } from "@descryy/runtime-backend-observation";
+import { createLaravelLineClassifier } from "./laravel-frame-parsing.js";
+import { createLaravelStackTraceParser } from "./laravel-stack-trace-parser.js";
+import { createPhpLineClassifier } from "./php-frame-parsing.js";
+import { createPhpSourceLocationResolver } from "./php-source-location-resolver.js";
+import { createPhpStackTraceParser } from "./php-stack-trace-parser.js";
+export function createPhpRuntimeAdapter(options = {}) {
+    const sourceLocationResolver = createPhpSourceLocationResolver();
+    const isLaravel = options.framework === "laravel";
+    const stackTraceParser = isLaravel
+        ? createLaravelStackTraceParser(sourceLocationResolver)
+        : createPhpStackTraceParser(sourceLocationResolver);
+    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.
+            classifier: isLaravel ? createLaravelLineClassifier() : createPhpLineClassifier(),
+            stackTraceParser,
+            ...(options.service !== undefined ? { service: options.service } : {}),
+        }));
+    }
+    return {
+        language: "php",
+        stackTraceParser,
+        sourceLocationResolver,
+        createBackendCollectors,
+    };
+}
+//# sourceMappingURL=php-runtime-adapter.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ *
+ * **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).
+ *
+ * **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.
+ *
+ * `column` is always null. PHP traces never print one.
+ */
+import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
+export declare function createPhpSourceLocationResolver(): SourceLocationResolver;
+//# sourceMappingURL=php-source-location-resolver.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ *
+ * **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).
+ *
+ * **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.
+ *
+ * `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.
+        resolve(frame) {
+            return Promise.resolve({
+                file: frame.file,
+                line: frame.line,
+                column: frame.column,
+                functionName: frame.functionName,
+                reliability: "self-contained",
+                resolvedVia: null,
+            });
+        },
+    };
+}
+//# sourceMappingURL=php-source-location-resolver.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,20 @@
+/**
+ * Composes the pure PHP line-recognition functions (`php-frame-parsing.ts`)
+ * with a `SourceLocationResolver` to implement the full 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.
+ *
+ * `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.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createPhpStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=php-stack-trace-parser.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,66 @@
+/**
+ * Composes the pure PHP line-recognition functions (`php-frame-parsing.ts`)
+ * with a `SourceLocationResolver` to implement the full 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.
+ *
+ * `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.
+ */
+import { parsePhpHeaderFrame, parsePhpFrame } from "./php-frame-parsing.js";
+export function createPhpStackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            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.
+                const raw = parsePhpFrame(line) ?? parsePhpHeaderFrame(line);
+                if (raw === null)
+                    continue;
+                const location = await resolver.resolve({
+                    file: raw.file,
+                    line: raw.line,
+                    column: null,
+                    functionName: raw.functionName,
+                });
+                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".
+                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.
+            return { fidelity: "synchronous", frames, primaryFrameIndex: 0 };
+        },
+    };
+}
+//# sourceMappingURL=php-stack-trace-parser.js.map

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

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@descryy/runtime-adapter-php",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "PHP runtime adapter: uncaught-Throwable trace parsing, self-contained source locations, the concrete RuntimeAdapter for PHP.",
+  "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": "*"
+  }
+}