@descryy/runtime-adapter-ruby 0.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"ruby-stack-trace-parser.js","sourceRoot":"","sources":["../src/ruby-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAEnF,MAAM,UAAU,0BAA0B,CAAC,QAAgC;IACzE,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,mEAAmE;gBACnE,kEAAkE;gBAClE,6DAA6D;gBAC7D,4DAA4D;gBAC5D,MAAM,GAAG,GAAG,oBAAoB,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBACnE,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,2DAA2D;gBAC3D,2DAA2D;gBAC3D,oEAAoE;gBACpE,OAAO,IAAI,CAAC;YACd,CAAC;YAED,kEAAkE;YAClE,mEAAmE;YACnE,oEAAoE;YACpE,qEAAqE;YACrE,sEAAsE;YACtE,mEAAmE;YACnE,oCAAoC;YACpC,EAAE;YACF,gEAAgE;YAChE,kEAAkE;YAClE,oBAAoB;YACpB,oEAAoE;YACpE,sEAAsE;YACtE,mEAAmE;YACnE,iEAAiE;YACjE,mEAAmE;YACnE,mEAAmE;YACnE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,92 @@
+/**
+ * Sinatra's production-mode backtrace grammar, which is **not Ruby's** —
+ * the plan's 1C measurement, and Sinatra's own answer to the question
+ * `rails-frame-parsing.ts` asked of Rails.
+ *
+ * ## The measurement
+ *
+ * A real Sinatra 4.1.1 app, `set :environment, :production`, spawned
+ * through the managed lifecycle, failing through its own request pipeline:
+ *
+ * ```
+ * 2026-08-21 00:27:09 - RuntimeError - invoice 3 is corrupt (RuntimeError):
+ * 	sinatra_service.rb:44:in 'Object#charge_invoice'
+ * 	sinatra_service.rb:51:in 'Object#delete_invoice'
+ * 	...
+ * ```
+ *
+ * against Ruby's own printer, which the plain `ruby-frame-parsing.ts`
+ * classifier expects:
+ *
+ * ```
+ * sinatra_service.rb:44:in 'Object#charge_invoice': invoice 3 is corrupt (RuntimeError)
+ * 	from sinatra_service.rb:51:in 'Object#delete_invoice'
+ * ```
+ *
+ * Read off `Sinatra::Base#dump_errors!` (`sinatra/base.rb`) before this was
+ * run, then confirmed against the live process, matching exactly:
+ *
+ * ```ruby
+ * msg = ["#{Time.now...} - #{boom.class} - #{msg}:", *additional_msg, *boom.backtrace].join("\n\t")
+ * @env['rack.errors'].puts(msg)
+ * ```
+ *
+ * - **The header carries no location.** It is
+ *   `TIMESTAMP - ClassName - message:`, never `file:line:in 'name': message`,
+ *   so `HEADER_PATTERN` never matches it.
+ * - **The frames have no `from` prefix.** `boom.backtrace` is the raw
+ *   `Exception#backtrace` array — Ruby's own top-level printer is what adds
+ *   `from `, not `Exception#backtrace` itself — so `FROM_FRAME_PATTERN`
+ *   never matches them either.
+ *
+ * Result, measured against the live process rather than assumed:
+ * **0 headers, 0 frames** — RT-111's exact signature, on the framework
+ * built directly on Rack rather than on Rack itself. (Bare Rack — no
+ * framework at all — was also measured, in `rack-framework-lifecycle.test.ts`,
+ * and needed no new grammar: its dispatch frames print in Ruby's own
+ * `file:line:in 'name'` / `from ...` shape and the existing classifier
+ * reads them unchanged.)
+ *
+ * ## Why this is a third classifier, not a widened Rails one
+ *
+ * Sinatra's header shape (`TIMESTAMP - Class - message:`) and Rails'
+ * (`Class (message):`) are different enough that one pattern covering both
+ * would have to be loose enough to risk matching an application's own log
+ * line — the same rule that ruled out widening Ruby's `isFrame` for Rails
+ * (see `rails-frame-parsing.ts`). The bare `file:line:in 'name'` frame shape
+ * *is* identical to Rails' — both are literally `Exception#backtrace`
+ * entries with no `from` — but is kept as its own pattern here rather than
+ * imported from `rails-frame-parsing.ts`, so a change scoped to one
+ * framework's grammar can never silently reach the other's.
+ *
+ * `isFrame` is stateful for the same reason Rails' is: a bare
+ * `file:line:in 'name'` is confined to "after a header has been seen" so it
+ * can never open a block from idle on its own.
+ */
+export interface RawSinatraFrame {
+    /** `Object#charge_invoice`, `block in Sinatra::Base#dispatch!` — kept verbatim, never rewritten. */
+    readonly functionName: string | null;
+    readonly file: string;
+    readonly line: number;
+}
+export declare function isSinatraHeaderLine(line: string): boolean;
+export declare function isSinatraFrameLine(line: string): boolean;
+/** `null` when the line is not `TIMESTAMP - Class - message:` shaped — never fabricated. */
+export declare function parseSinatraHeader(line: string): {
+    readonly exceptionClass: string;
+    readonly message: string;
+} | null;
+/** `null` for anything not shaped like a bare `file:line:in 'name'` frame — never fabricated. */
+export declare function parseSinatraFrame(line: string): RawSinatraFrame | null;
+/**
+ * A stateful `LineClassifier` — see this file's header for why the loose
+ * frame pattern is safe only inside that state.
+ *
+ * A fresh classifier per collector keeps two processes' output from priming
+ * each other, the same construction rule every other adapter here follows.
+ */
+export declare function createSinatraLineClassifier(): {
+    isHeader(line: string): boolean;
+    isFrame(line: string): boolean;
+};
+//# sourceMappingURL=sinatra-frame-parsing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sinatra-frame-parsing.d.ts","sourceRoot":"","sources":["../src/sinatra-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH,MAAM,WAAW,eAAe;IAC9B,oGAAoG;IACpG,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAwBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMrH;AAED,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAOtE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAqBA"}

package/dist/sinatra-frame-parsing.js

@@ -0,0 +1,142 @@
+/**
+ * Sinatra's production-mode backtrace grammar, which is **not Ruby's** —
+ * the plan's 1C measurement, and Sinatra's own answer to the question
+ * `rails-frame-parsing.ts` asked of Rails.
+ *
+ * ## The measurement
+ *
+ * A real Sinatra 4.1.1 app, `set :environment, :production`, spawned
+ * through the managed lifecycle, failing through its own request pipeline:
+ *
+ * ```
+ * 2026-08-21 00:27:09 - RuntimeError - invoice 3 is corrupt (RuntimeError):
+ * 	sinatra_service.rb:44:in 'Object#charge_invoice'
+ * 	sinatra_service.rb:51:in 'Object#delete_invoice'
+ * 	...
+ * ```
+ *
+ * against Ruby's own printer, which the plain `ruby-frame-parsing.ts`
+ * classifier expects:
+ *
+ * ```
+ * sinatra_service.rb:44:in 'Object#charge_invoice': invoice 3 is corrupt (RuntimeError)
+ * 	from sinatra_service.rb:51:in 'Object#delete_invoice'
+ * ```
+ *
+ * Read off `Sinatra::Base#dump_errors!` (`sinatra/base.rb`) before this was
+ * run, then confirmed against the live process, matching exactly:
+ *
+ * ```ruby
+ * msg = ["#{Time.now...} - #{boom.class} - #{msg}:", *additional_msg, *boom.backtrace].join("\n\t")
+ * @env['rack.errors'].puts(msg)
+ * ```
+ *
+ * - **The header carries no location.** It is
+ *   `TIMESTAMP - ClassName - message:`, never `file:line:in 'name': message`,
+ *   so `HEADER_PATTERN` never matches it.
+ * - **The frames have no `from` prefix.** `boom.backtrace` is the raw
+ *   `Exception#backtrace` array — Ruby's own top-level printer is what adds
+ *   `from `, not `Exception#backtrace` itself — so `FROM_FRAME_PATTERN`
+ *   never matches them either.
+ *
+ * Result, measured against the live process rather than assumed:
+ * **0 headers, 0 frames** — RT-111's exact signature, on the framework
+ * built directly on Rack rather than on Rack itself. (Bare Rack — no
+ * framework at all — was also measured, in `rack-framework-lifecycle.test.ts`,
+ * and needed no new grammar: its dispatch frames print in Ruby's own
+ * `file:line:in 'name'` / `from ...` shape and the existing classifier
+ * reads them unchanged.)
+ *
+ * ## Why this is a third classifier, not a widened Rails one
+ *
+ * Sinatra's header shape (`TIMESTAMP - Class - message:`) and Rails'
+ * (`Class (message):`) are different enough that one pattern covering both
+ * would have to be loose enough to risk matching an application's own log
+ * line — the same rule that ruled out widening Ruby's `isFrame` for Rails
+ * (see `rails-frame-parsing.ts`). The bare `file:line:in 'name'` frame shape
+ * *is* identical to Rails' — both are literally `Exception#backtrace`
+ * entries with no `from` — but is kept as its own pattern here rather than
+ * imported from `rails-frame-parsing.ts`, so a change scoped to one
+ * framework's grammar can never silently reach the other's.
+ *
+ * `isFrame` is stateful for the same reason Rails' is: a bare
+ * `file:line:in 'name'` is confined to "after a header has been seen" so it
+ * can never open a block from idle on its own.
+ */
+/**
+ * `2026-08-21 00:27:09 - RuntimeError - invoice 3 is corrupt (RuntimeError):`
+ *
+ * `Sinatra::Base#dump_errors!` composes
+ * `"#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} - #{boom.class} - #{msg}:"`.
+ * Anchored at the start (the timestamp is always first — Sinatra never
+ * prefixes it, unlike Ruby's own header pattern which allows a leading
+ * logger prefix) and requiring the trailing `:`, because a partial match is
+ * evidence the line is not a header rather than a reason to guess at one.
+ * The class group allows `::` so a namespaced error class matches.
+ */
+const SINATRA_HEADER = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} - (?<class>[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*) - (?<message>.*):\s*$/;
+/**
+ * `sinatra_service.rb:44:in 'Object#charge_invoice'` — a raw
+ * `Exception#backtrace` entry, tab-indented by `dump_errors!`'s own
+ * `join("\n\t")`, no `from` prefix. The closing quote is always `'`; only
+ * the opening one varies by Ruby version (Feature #16495), matched the same
+ * way Ruby's and Rails' own patterns do.
+ */
+const SINATRA_FRAME = /^\s*(?<file>.+):(?<line>\d+):in\s+[`'](?<fn>[^']*)'\s*$/;
+export function isSinatraHeaderLine(line) {
+    return SINATRA_HEADER.test(line);
+}
+export function isSinatraFrameLine(line) {
+    return SINATRA_FRAME.test(line);
+}
+/** `null` when the line is not `TIMESTAMP - Class - message:` shaped — never fabricated. */
+export function parseSinatraHeader(line) {
+    const match = SINATRA_HEADER.exec(line);
+    if (!match?.groups)
+        return null;
+    const exceptionClass = match.groups["class"];
+    if (exceptionClass === undefined)
+        return null;
+    return { exceptionClass, message: match.groups["message"] ?? "" };
+}
+/** `null` for anything not shaped like a bare `file:line:in 'name'` frame — never fabricated. */
+export function parseSinatraFrame(line) {
+    const match = SINATRA_FRAME.exec(line);
+    if (!match?.groups)
+        return null;
+    const file = match.groups["file"];
+    const lineNumber = Number(match.groups["line"]);
+    if (file === undefined || !Number.isInteger(lineNumber))
+        return null;
+    return { functionName: match.groups["fn"] ?? null, file, line: lineNumber };
+}
+/**
+ * A stateful `LineClassifier` — see this file's header for why the loose
+ * frame pattern is safe only inside that state.
+ *
+ * A fresh classifier per collector keeps two processes' output from priming
+ * each other, the same construction rule every other adapter here follows.
+ */
+export function createSinatraLineClassifier() {
+    let sawHeader = false;
+    return {
+        isHeader(line) {
+            if (isSinatraHeaderLine(line)) {
+                sawHeader = true;
+                return true;
+            }
+            return false;
+        },
+        isFrame(line) {
+            // Never from idle. A bare `x.rb:12:in 'foo'` is frame-shaped and is
+            // also an entirely ordinary thing for an application to log.
+            if (!sawHeader)
+                return false;
+            if (isSinatraFrameLine(line))
+                return true;
+            sawHeader = false;
+            return false;
+        },
+    };
+}
+//# sourceMappingURL=sinatra-frame-parsing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sinatra-frame-parsing.js","sourceRoot":"","sources":["../src/sinatra-frame-parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AASH;;;;;;;;;;GAUG;AACH,MAAM,cAAc,GAAG,oHAAoH,CAAC;AAE5I;;;;;;GAMG;AACH,MAAM,aAAa,GAAG,yDAAyD,CAAC;AAEhF,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7C,IAAI,cAAc,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC9C,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC;AACpE,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,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,OAAO,EAAE,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B;IAIzC,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACL,QAAQ,CAAC,IAAY;YACnB,IAAI,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,SAAS,GAAG,IAAI,CAAC;gBACjB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CAAC,IAAY;YAClB,oEAAoE;YACpE,6DAA6D;YAC7D,IAAI,CAAC,SAAS;gBAAE,OAAO,KAAK,CAAC;YAC7B,IAAI,kBAAkB,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC1C,SAAS,GAAG,KAAK,CAAC;YAClB,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * Composes Sinatra's line-recognition functions with a
+ * `SourceLocationResolver` (plan 1C, mirroring `rails-stack-trace-parser.ts`).
+ *
+ * Sinatra's header carries **no location at all** —
+ * `TIMESTAMP - Class - message:` — so, exactly as for Rails, the raise site
+ * is the first backtrace line beneath the header rather than the header
+ * itself. `primaryFrameIndex` is `0` for the same reason Rails' is: the
+ * header contributes no frame, so index 0 is the first line Sinatra
+ * printed, and `Exception#backtrace` is innermost-first.
+ *
+ * `fidelity` is `"synchronous"` for the same reason every other Ruby
+ * parser's is: every frame is a genuine link in the call chain that was
+ * executing.
+ */
+import type { SourceLocationResolver, StackTraceParser } from "@descryy/runtime-backend-observation";
+export declare function createSinatraStackTraceParser(resolver: SourceLocationResolver): StackTraceParser;
+//# sourceMappingURL=sinatra-stack-trace-parser.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * Composes Sinatra's line-recognition functions with a
+ * `SourceLocationResolver` (plan 1C, mirroring `rails-stack-trace-parser.ts`).
+ *
+ * Sinatra's header carries **no location at all** —
+ * `TIMESTAMP - Class - message:` — so, exactly as for Rails, the raise site
+ * is the first backtrace line beneath the header rather than the header
+ * itself. `primaryFrameIndex` is `0` for the same reason Rails' is: the
+ * header contributes no frame, so index 0 is the first line Sinatra
+ * printed, and `Exception#backtrace` is innermost-first.
+ *
+ * `fidelity` is `"synchronous"` for the same reason every other Ruby
+ * parser's is: every frame is a genuine link in the call chain that was
+ * executing.
+ */
+import { parseSinatraFrame, parseSinatraHeader } from "./sinatra-frame-parsing.js";
+export function createSinatraStackTraceParser(resolver) {
+    return {
+        async parse(rawText) {
+            const lines = rawText.split(/\r\n|\r|\n/);
+            const frames = [];
+            for (const line of lines) {
+                // The header is tried first and produces no frame — it has no
+                // location to produce one from. Skipped explicitly rather than
+                // falling through, because `TIMESTAMP - Class - message:` can
+                // itself contain a colon-and-number substring that would otherwise
+                // be worth checking against the frame pattern.
+                if (parseSinatraHeader(line) !== null)
+                    continue;
+                const raw = parseSinatraFrame(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 });
+            }
+            // Null, never an empty-but-structured StackTrace standing in for
+            // "couldn't parse" — this interface's contract, and the reason a
+            // header-only block does not become a zero-frame trace.
+            if (frames.length === 0)
+                return null;
+            return { fidelity: "synchronous", frames, primaryFrameIndex: 0 };
+        },
+    };
+}
+//# sourceMappingURL=sinatra-stack-trace-parser.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sinatra-stack-trace-parser.js","sourceRoot":"","sources":["../src/sinatra-stack-trace-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEnF,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,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,8DAA8D;gBAC9D,+DAA+D;gBAC/D,8DAA8D;gBAC9D,mEAAmE;gBACnE,+CAA+C;gBAC/C,IAAI,kBAAkB,CAAC,IAAI,CAAC,KAAK,IAAI;oBAAE,SAAS;gBAEhD,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;gBACpC,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,iEAAiE;YACjE,iEAAiE;YACjE,wDAAwD;YACxD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAErC,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-ruby",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "Ruby runtime adapter: backtrace parsing, self-contained source locations, the concrete RuntimeAdapter for Ruby.",
+  "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": "*"
+  }
+}