@descryy/runtime-adapter-python 0.1.0 → 0.4.0

package/dist/python-log-envelopes.d.ts

@@ -1,97 +1,48 @@
 /**
- * Python's `LogEnvelope`s. Currently one: **uvicorn** (RT-106).
- *
- * ## This file exists because an earlier claim of mine was too broad
- *
- * RT-103 measured Flask, Django and FastAPI all printing
- * `Traceback (most recent call last):` at column 0 with CPython's own
- * two-space frame indent, because `logging` appends `exc_info` unindented,
- * and concluded **"Python needs no envelope at all and never will."**
- *
- * That is right about *unwrapping* and wrong about *record boundaries*, and
- * the two are different jobs behind one interface. Nothing needs stripping
- * from a Python traceback line. But `UnwrappedLine.startsRecord` is the
- * only mechanism by which a collector can know that a line **ends the
- * previous record**, and Python is the language where that matters most:
- *
- * ```
- * Traceback (most recent call last):
- * INFO:     127.0.0.1:50002 - "GET /health HTTP/1.1" 200 OK
- *   File "/app/service.py", line 18, in charge_invoice
- * ```
- *
- * A traceback is written one `write()` per line, so any other thread
- * logging to the same stream interleaves between them. Measured on real
- * threaded CPython 3.12, three runs of 25 failures: 7, 8 and 7 of them were
- * reported as an EXCEPTION whose entire identity was an access-log line for
- * a **successful** request — see `TRAILER_PATTERN` in
- * `python-frame-parsing.ts` for the full measurement and for the heuristic
- * that an un-enveloped stream falls back on.
- *
- * This envelope makes that case structural rather than guessed. uvicorn
- * *states* where a record begins; the trailer pattern can only infer it.
- *
- * ## Nothing is stripped from a traceback, and that is the whole design
- *
- * uvicorn formats with `"%(levelprefix)s %(message)s"`, where `levelprefix`
- * is `f"{levelname}:".ljust(9)`. That prefix goes on the record's **first**
- * line only. The `exc_info` traceback `logging` appends afterwards is
- * written through untouched, at column 0, with CPython's own indentation.
- *
- * Measured against real `uvicorn 0.41.0` / `fastapi 0.141.1` output
- * (`test/fixtures/uvicorn-asgi-failure.txt`): `ERROR:    Exception in ASGI
- * application` is the header, and all 28 traceback lines beneath it are
- * continuations returned byte-identical. So `unwrap` is the identity
- * function for every line that carries evidence, and the envelope's entire
- * contribution is `startsRecord` — the opposite balance to Ruby's, where
+ * Python's LogEnvelopes. Currently one: uvicorn (RT-106).
+ *
+ * RT-103 measured Flask/Django/FastAPI all printing tracebacks at column 0
+ * with CPython's own indent (logging appends exc_info unindented) and
+ * concluded Python needs no envelope. Right about unwrapping, wrong about
+ * record boundaries — different jobs behind one interface.
+ * UnwrappedLine.startsRecord is the only way a collector knows a line ends
+ * the previous record, and interleaved logging threads make that matter: a
+ * traceback is written one write() per line, so another thread's logging
+ * can land between them. Measured on real threaded CPython 3.12, three runs
+ * of 25 failures: 7, 8, 7 reported as an EXCEPTION whose entire identity was
+ * an access-log line for a successful request (see TRAILER_PATTERN in
+ * python-frame-parsing.ts for the full measurement). This envelope makes
+ * uvicorn's record boundary structural instead of inferred.
+ *
+ * Nothing is stripped from a traceback: uvicorn's `levelprefix` only prefixes
+ * the record's first line; the exc_info traceback logging appends afterwards
+ * passes through untouched. Measured against real uvicorn 0.41.0/fastapi
+ * 0.141.1 output: all 28 traceback lines are continuations returned
+ * byte-identical, so unwrap is identity and the envelope's whole
+ * contribution is startsRecord — opposite of Ruby's envelope, where
  * unwrapping is the load-bearing half.
  *
- * ## Why the level set is closed rather than `\w+`
- *
- * `^(\w+): +` would match `TypeError:    ...` — a real trailer, wrongly
- * read as a record boundary, closing a block one line before its identity
- * arrives. That is the same class of over-matching this envelope exists to
- * fix, introduced from the other side. So the set is exactly the six level
- * names `logging` and uvicorn can produce, and a seventh would be a
- * measured addition rather than a widened pattern.
- *
- * ## Two disclosed limits
+ * Level set is closed, not `\w+`: `^(\w+): +` would match `TypeError:    ...`,
+ * a real trailer wrongly read as a record boundary. Set is exactly the six
+ * level names logging/uvicorn can produce.
  *
- * **Colour.** uvicorn wraps `levelprefix` in ANSI when its output is a TTY.
- * Descry pipes, so the measured stream has none, and this pattern would not
- * match a colourised one. Stated rather than handled: adding an optional
- * escape-sequence prefix on an unmeasured shape is the guess this file's
- * own argument rejects.
- *
- * **Application loggers are not covered.** uvicorn configures only its own
- * `uvicorn`/`uvicorn.error`/`uvicorn.access` loggers. An application's own
- * `logging.getLogger(__name__).info(...)` goes through the root config and
- * usually carries no prefix at all, so it comes back from `unwrap`
- * untouched with `startsRecord: false` — correct, because this envelope has
- * no idea whether that line began a record, and saying so would be the
- * inference `fields()` exists to refuse.
+ * Two disclosed limits: uvicorn wraps levelprefix in ANSI on a TTY (Descry
+ * pipes, so unmeasured, unmatched); and application loggers via
+ * `logging.getLogger(__name__)` carry no prefix, so they come back
+ * untouched with startsRecord: false — correct, since this envelope has no
+ * way to know whether such a line began a record.
  */
 import { type LogEnvelope, type LogPattern, type LogPatternRegistry } from "@descryy/runtime-backend-observation";
 /**
- * uvicorn's wrapper, expressed as a registry entry rather than as a private
- * constant inside one envelope factory.
- *
- * The regexes and the fields are unchanged — this is the same measurement
- * against the same real `uvicorn 0.41.0` output, moved to where a caller can
- * name it and compose it with another format. What changed is that
- * `PythonRuntimeAdapterOptions.server` is no longer the entire Python
- * vocabulary: a process that prints uvicorn's access lines AND formatted
- * console output can now be given both, which is what UAT phase 2's Phase 9
- * asked for and what a closed union of framework names structurally cannot do.
+ * uvicorn's wrapper, as a registry entry rather than a private constant, so a
+ * process printing uvicorn's access lines AND formatted console output can
+ * be given both — a closed union of framework names couldn't do that.
  */
 export declare const UVICORN_LOG_PATTERN: LogPattern;
 /**
- * The patterns a Python process can be declared to use: the framework-agnostic
- * built-ins (the bracket-tag consoles — `rich`, and anything else that prints
- * `[TAG] message`) plus uvicorn's own.
- *
- * A fresh registry per call, so a caller registering its own pattern cannot
- * change what another caller resolves a name to.
+ * The patterns a Python process can be declared to use: bracket-tag consoles
+ * (rich, `[TAG] message`) plus uvicorn's own. Fresh registry per call, so
+ * one caller's registered pattern can't change another's resolution.
  */
 export declare function pythonLogPatternRegistry(): LogPatternRegistry;
 /** Unchanged in behaviour and in name: exactly `pythonLogPatternRegistry().envelope(["uvicorn"])`, kept because it is the spelling every existing caller and test uses. */

package/dist/python-log-envelopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"python-log-envelopes.d.ts","sourceRoot":"","sources":["../src/python-log-envelopes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAEH,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,sCAAsC,CAAC;AAqB9C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,UA4BjC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAI7D;AAED,2KAA2K;AAC3K,wBAAgB,wBAAwB,IAAI,WAAW,CAEtD"}
+{"version":3,"file":"python-log-envelopes.d.ts","sourceRoot":"","sources":["../src/python-log-envelopes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,sCAAsC,CAAC;AAiB9C;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAqBjC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAI7D;AAED,2KAA2K;AAC3K,wBAAgB,wBAAwB,IAAI,WAAW,CAEtD"}

package/dist/python-log-envelopes.js

@@ -1,86 +1,43 @@
 /**
- * Python's `LogEnvelope`s. Currently one: **uvicorn** (RT-106).
- *
- * ## This file exists because an earlier claim of mine was too broad
- *
- * RT-103 measured Flask, Django and FastAPI all printing
- * `Traceback (most recent call last):` at column 0 with CPython's own
- * two-space frame indent, because `logging` appends `exc_info` unindented,
- * and concluded **"Python needs no envelope at all and never will."**
- *
- * That is right about *unwrapping* and wrong about *record boundaries*, and
- * the two are different jobs behind one interface. Nothing needs stripping
- * from a Python traceback line. But `UnwrappedLine.startsRecord` is the
- * only mechanism by which a collector can know that a line **ends the
- * previous record**, and Python is the language where that matters most:
- *
- * ```
- * Traceback (most recent call last):
- * INFO:     127.0.0.1:50002 - "GET /health HTTP/1.1" 200 OK
- *   File "/app/service.py", line 18, in charge_invoice
- * ```
- *
- * A traceback is written one `write()` per line, so any other thread
- * logging to the same stream interleaves between them. Measured on real
- * threaded CPython 3.12, three runs of 25 failures: 7, 8 and 7 of them were
- * reported as an EXCEPTION whose entire identity was an access-log line for
- * a **successful** request — see `TRAILER_PATTERN` in
- * `python-frame-parsing.ts` for the full measurement and for the heuristic
- * that an un-enveloped stream falls back on.
- *
- * This envelope makes that case structural rather than guessed. uvicorn
- * *states* where a record begins; the trailer pattern can only infer it.
- *
- * ## Nothing is stripped from a traceback, and that is the whole design
- *
- * uvicorn formats with `"%(levelprefix)s %(message)s"`, where `levelprefix`
- * is `f"{levelname}:".ljust(9)`. That prefix goes on the record's **first**
- * line only. The `exc_info` traceback `logging` appends afterwards is
- * written through untouched, at column 0, with CPython's own indentation.
- *
- * Measured against real `uvicorn 0.41.0` / `fastapi 0.141.1` output
- * (`test/fixtures/uvicorn-asgi-failure.txt`): `ERROR:    Exception in ASGI
- * application` is the header, and all 28 traceback lines beneath it are
- * continuations returned byte-identical. So `unwrap` is the identity
- * function for every line that carries evidence, and the envelope's entire
- * contribution is `startsRecord` — the opposite balance to Ruby's, where
+ * Python's LogEnvelopes. Currently one: uvicorn (RT-106).
+ *
+ * RT-103 measured Flask/Django/FastAPI all printing tracebacks at column 0
+ * with CPython's own indent (logging appends exc_info unindented) and
+ * concluded Python needs no envelope. Right about unwrapping, wrong about
+ * record boundaries — different jobs behind one interface.
+ * UnwrappedLine.startsRecord is the only way a collector knows a line ends
+ * the previous record, and interleaved logging threads make that matter: a
+ * traceback is written one write() per line, so another thread's logging
+ * can land between them. Measured on real threaded CPython 3.12, three runs
+ * of 25 failures: 7, 8, 7 reported as an EXCEPTION whose entire identity was
+ * an access-log line for a successful request (see TRAILER_PATTERN in
+ * python-frame-parsing.ts for the full measurement). This envelope makes
+ * uvicorn's record boundary structural instead of inferred.
+ *
+ * Nothing is stripped from a traceback: uvicorn's `levelprefix` only prefixes
+ * the record's first line; the exc_info traceback logging appends afterwards
+ * passes through untouched. Measured against real uvicorn 0.41.0/fastapi
+ * 0.141.1 output: all 28 traceback lines are continuations returned
+ * byte-identical, so unwrap is identity and the envelope's whole
+ * contribution is startsRecord — opposite of Ruby's envelope, where
  * unwrapping is the load-bearing half.
  *
- * ## Why the level set is closed rather than `\w+`
- *
- * `^(\w+): +` would match `TypeError:    ...` — a real trailer, wrongly
- * read as a record boundary, closing a block one line before its identity
- * arrives. That is the same class of over-matching this envelope exists to
- * fix, introduced from the other side. So the set is exactly the six level
- * names `logging` and uvicorn can produce, and a seventh would be a
- * measured addition rather than a widened pattern.
- *
- * ## Two disclosed limits
- *
- * **Colour.** uvicorn wraps `levelprefix` in ANSI when its output is a TTY.
- * Descry pipes, so the measured stream has none, and this pattern would not
- * match a colourised one. Stated rather than handled: adding an optional
- * escape-sequence prefix on an unmeasured shape is the guess this file's
- * own argument rejects.
+ * Level set is closed, not `\w+`: `^(\w+): +` would match `TypeError:    ...`,
+ * a real trailer wrongly read as a record boundary. Set is exactly the six
+ * level names logging/uvicorn can produce.
  *
- * **Application loggers are not covered.** uvicorn configures only its own
- * `uvicorn`/`uvicorn.error`/`uvicorn.access` loggers. An application's own
- * `logging.getLogger(__name__).info(...)` goes through the root config and
- * usually carries no prefix at all, so it comes back from `unwrap`
- * untouched with `startsRecord: false` — correct, because this envelope has
- * no idea whether that line began a record, and saying so would be the
- * inference `fields()` exists to refuse.
+ * Two disclosed limits: uvicorn wraps levelprefix in ANSI on a TTY (Descry
+ * pipes, so unmeasured, unmatched); and application loggers via
+ * `logging.getLogger(__name__)` carry no prefix, so they come back
+ * untouched with startsRecord: false — correct, since this envelope has no
+ * way to know whether such a line began a record.
  */
 import { createLogPatternRegistry, createPatternLogEnvelope, } from "@descryy/runtime-backend-observation";
 /**
  * `INFO:     127.0.0.1:39334 - "GET /health HTTP/1.1" 200 OK`
- *
- * uvicorn's `DefaultFormatter`/`AccessFormatter` both use
- * `"%(levelprefix)s %(message)s"` with `levelprefix = f"{levelname}:".ljust(9)`,
- * so the separator is between 1 and 5 spaces depending on the level's own
- * length — `CRITICAL:` needs no padding, `INFO:` needs four. Anchored at
- * column zero: a traceback's frame lines are indented and its trailer is
- * not level-shaped, so neither can reach this.
+ * uvicorn's formatters use `levelprefix = f"{levelname}:".ljust(9)`, so 1-5
+ * spaces depending on level length. Anchored at column zero: traceback frame
+ * lines are indented, its trailer isn't level-shaped.
  */
 const UVICORN_HEADER = /^(CRITICAL|ERROR|WARNING|INFO|DEBUG|TRACE): +/;
 /**
@@ -90,16 +47,9 @@ const UVICORN_HEADER = /^(CRITICAL|ERROR|WARNING|INFO|DEBUG|TRACE): +/;
  */
 const ACCESS_MESSAGE = /^(?<client>\S+) - "(?<method>[A-Z]+) (?<path>\S+) (?<protocol>\S+)" (?<status>\d{3})\b/;
 /**
- * uvicorn's wrapper, expressed as a registry entry rather than as a private
- * constant inside one envelope factory.
- *
- * The regexes and the fields are unchanged — this is the same measurement
- * against the same real `uvicorn 0.41.0` output, moved to where a caller can
- * name it and compose it with another format. What changed is that
- * `PythonRuntimeAdapterOptions.server` is no longer the entire Python
- * vocabulary: a process that prints uvicorn's access lines AND formatted
- * console output can now be given both, which is what UAT phase 2's Phase 9
- * asked for and what a closed union of framework names structurally cannot do.
+ * uvicorn's wrapper, as a registry entry rather than a private constant, so a
+ * process printing uvicorn's access lines AND formatted console output can
+ * be given both — a closed union of framework names couldn't do that.
  */
 export const UVICORN_LOG_PATTERN = {
     name: "uvicorn",
@@ -108,16 +58,9 @@ export const UVICORN_LOG_PATTERN = {
     fields(match) {
         const access = ACCESS_MESSAGE.exec(match.input.slice(match[0].length));
         return {
-            // uvicorn's own word, never normalised to a shared vocabulary.
-            level: match[1] ?? null,
-            // uvicorn's formatter discards the logger name — `uvicorn.access`
-            // and `uvicorn.error` are indistinguishable in the printed stream.
-            // Null because it is genuinely absent, not merely unparsed.
-            category: null,
-            // uvicorn has no request-id concept and prints none. Unlike
-            // Kestrel's `Request id "..."`, there is nothing here to read, and
-            // deriving one from the client port would be an invention.
-            requestId: null,
+            level: match[1] ?? null, // uvicorn's own word, not normalised
+            category: null, // uvicorn's formatter discards the logger name; genuinely absent, not unparsed
+            requestId: null, // uvicorn has no request-id concept; deriving one would be invention
             attrs: access?.groups === undefined
                 ? {}
                 : {
@@ -130,12 +73,9 @@ export const UVICORN_LOG_PATTERN = {
     },
 };
 /**
- * The patterns a Python process can be declared to use: the framework-agnostic
- * built-ins (the bracket-tag consoles — `rich`, and anything else that prints
- * `[TAG] message`) plus uvicorn's own.
- *
- * A fresh registry per call, so a caller registering its own pattern cannot
- * change what another caller resolves a name to.
+ * The patterns a Python process can be declared to use: bracket-tag consoles
+ * (rich, `[TAG] message`) plus uvicorn's own. Fresh registry per call, so
+ * one caller's registered pattern can't change another's resolution.
  */
 export function pythonLogPatternRegistry() {
     const registry = createLogPatternRegistry();

package/dist/python-log-envelopes.js.map

@@ -1 +1 @@
-{"version":3,"file":"python-log-envelopes.js","sourceRoot":"","sources":["../src/python-log-envelopes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAEH,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GAKzB,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,cAAc,GAAG,+CAA+C,CAAC;AAEvE;;;;GAIG;AACH,MAAM,cAAc,GAAG,wFAAwF,CAAC;AAEhH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAe;IAC7C,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,cAAc;IACtB,kBAAkB,EAAE,IAAI;IACxB,MAAM,CAAC,KAAsB;QAC3B,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACvE,OAAO;YACL,+DAA+D;YAC/D,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI;YACvB,kEAAkE;YAClE,mEAAmE;YACnE,4DAA4D;YAC5D,QAAQ,EAAE,IAAI;YACd,4DAA4D;YAC5D,mEAAmE;YACnE,2DAA2D;YAC3D,SAAS,EAAE,IAAI;YACf,KAAK,EACH,MAAM,EAAE,MAAM,KAAK,SAAS;gBAC1B,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC;oBACE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;oBACrC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;oBACrC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;oBACjC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;iBACtC;SACR,CAAC;IACJ,CAAC;CACF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB;IACtC,MAAM,QAAQ,GAAG,wBAAwB,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACvC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,2KAA2K;AAC3K,MAAM,UAAU,wBAAwB;IACtC,OAAO,wBAAwB,CAAC,SAAS,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;AACpE,CAAC"}
+{"version":3,"file":"python-log-envelopes.js","sourceRoot":"","sources":["../src/python-log-envelopes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GAKzB,MAAM,sCAAsC,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,cAAc,GAAG,+CAA+C,CAAC;AAEvE;;;;GAIG;AACH,MAAM,cAAc,GAAG,wFAAwF,CAAC;AAEhH;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAe;IAC7C,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,cAAc;IACtB,kBAAkB,EAAE,IAAI;IACxB,MAAM,CAAC,KAAsB;QAC3B,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACvE,OAAO;YACL,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,qCAAqC;YAC9D,QAAQ,EAAE,IAAI,EAAE,+EAA+E;YAC/F,SAAS,EAAE,IAAI,EAAE,qEAAqE;YACtF,KAAK,EACH,MAAM,EAAE,MAAM,KAAK,SAAS;gBAC1B,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC;oBACE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;oBACrC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;oBACrC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;oBACjC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;iBACtC;SACR,CAAC;IACJ,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,wBAAwB;IACtC,MAAM,QAAQ,GAAG,wBAAwB,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACvC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,2KAA2K;AAC3K,MAAM,UAAU,wBAAwB;IACtC,OAAO,wBAAwB,CAAC,SAAS,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;AACpE,CAAC"}

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

@@ -1,66 +1,41 @@
 /**
- * The concrete `RuntimeAdapter` for Python — the second language, and the
- * first one to test whether the seam `@descryy/runtime-backend-observation`
- * defines is genuinely language-neutral or merely V8-shaped.
- *
- * It was not, in two places, and both were fixed in the seam rather than
- * worked around here:
- *
- * - `LineClassifier` had no notion of a line that ends a block and belongs
- *   to it, because a V8 header names its exception up front. A CPython
- *   traceback names it last. `isTrailer` is that concept, added
- *   language-neutrally.
- * - `StackTrace.frames` had no documented order, because with one language
- *   nothing ever had to convert. Python prints the opposite of V8. The
- *   contract now states most-recent-first and this adapter reverses.
- *
- * Both are recorded because they are the general lesson of adding a second
- * anything: a seam with one implementation is a seam in name only, and the
- * defects it hides are silent ones — a truncated traceback and a
- * backwards frame list both look like well-formed output.
+ * The concrete RuntimeAdapter for Python — the second language, first to
+ * test whether @descryy/runtime-backend-observation's seam is genuinely
+ * language-neutral or merely V8-shaped. It wasn't, in two places, fixed in
+ * the seam rather than worked around here:
+ * - LineClassifier had no `isTrailer` concept (a V8 header names its
+ *   exception up front; CPython names it last) — added language-neutrally.
+ * - StackTrace.frames had no documented order (Python prints the opposite
+ *   of V8) — contract now states most-recent-first, this adapter reverses.
  */
 import type { RuntimeAdapter } from "@descryy/runtime-backend-observation";
 export interface PythonRuntimeAdapterOptions {
     /** Attributed on every emitted Evidence's `service` field (plan §16.7). Omit when not applicable. */
     readonly service?: string;
     /**
-     * The server whose logging layer wraps this process's output (§16).
+     * The server whose logging layer wraps this process's output.
+     * Declared, never sniffed — uvicorn's `LEVEL:` format is `logging`'s own
+     * default shape, so sniffing it would enable record-boundary flushing for
+     * any process that ever printed `INFO: ...`, and a wrong boundary
+     * truncates an exception block. Only uvicorn, because only it was
+     * measured (RT-106) — Gunicorn's and Django runserver's formats differ
+     * and get no envelope until measured.
      *
-     * **Declared, never sniffed** — the same rule ASP.NET's option follows,
-     * and for a sharper reason here. uvicorn's format is `LEVEL:` plus
-     * padding, which is `logging`'s own default shape; detecting it from a
-     * line that looks like one would enable record-boundary flushing for any
-     * Python process that ever printed `INFO: ...`, and the cost of a wrong
-     * boundary is a truncated exception block. A caller that knows it
-     * launched uvicorn says so.
-     *
-     * Only uvicorn, and only because it was measured (RT-106). Gunicorn's
-     * default `[%(asctime)s] [%(process)d] [%(levelname)s]` and Django's
-     * `runserver` output are different formats and get no envelope until one
-     * of them is run and read.
-     *
-     * **Superseded in reach, not in rule, by `logPatterns`.** This option is
-     * exactly `logPatterns: ["uvicorn"]` and is kept because it is the spelling
-     * every existing caller uses. Declaring both is refused rather than merged.
+     * Superseded in reach, not in rule, by `logPatterns` (exactly
+     * `logPatterns: ["uvicorn"]`); kept for existing callers. Declaring both is refused, not merged.
      */
     readonly server?: "uvicorn";
     /**
-     * Log patterns this process's output is declared to use, by name, from
-     * `pythonLogPatternRegistry()` — composed into one envelope in the order
-     * given, first match per line winning.
+     * Log patterns this process declares, by name from pythonLogPatternRegistry(),
+     * composed into one envelope, first match per line winning.
      *
-     * **This is UAT phase 2's Phase 9.** `server` was the entire Python
-     * vocabulary and it named one framework, so a process printing formatted
-     * console output — `[POSTGRES] Creating and opening a Postgres connection
-     * pool`, through `rich.console.Console().print()` — had no envelope that
-     * could see it, and those were the most operationally interesting lines of
-     * the run that found this. `["uvicorn", "bracket-tag-console"]` covers both
-     * halves of exactly that process.
+     * `server` named only one framework, so a process also printing formatted
+     * console output (rich.console.Console().print()) had no envelope for it —
+     * `["uvicorn", "bracket-tag-console"]` covers both.
      *
-     * Still declared, never sniffed, and now for a sharper reason than before:
-     * `bracket-tag-console` and Ruby's `rails-tagged-logging` are the same
-     * regex with opposite record semantics, so no line can be inspected to
-     * decide which applies. An unknown name is refused, not skipped.
+     * Still declared, never sniffed: `bracket-tag-console` and Ruby's
+     * `rails-tagged-logging` are the same regex with opposite record
+     * semantics, so no line can decide which applies. Unknown name is refused, not skipped.
      */
     readonly logPatterns?: readonly string[];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"python-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/python-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAA2C,MAAM,sCAAsC,CAAC;AAUpH,MAAM,WAAW,2BAA2B;IAC1C,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,2BAAgC,GAAG,cAAc,CA6DpG"}
+{"version":3,"file":"python-runtime-adapter.d.ts","sourceRoot":"","sources":["../src/python-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAA2C,MAAM,sCAAsC,CAAC;AAUpH,MAAM,WAAW,2BAA2B;IAC1C,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,2BAAgC,GAAG,cAAc,CAiDpG"}

package/dist/python-runtime-adapter.js

@@ -1,23 +1,12 @@
 /**
- * The concrete `RuntimeAdapter` for Python — the second language, and the
- * first one to test whether the seam `@descryy/runtime-backend-observation`
- * defines is genuinely language-neutral or merely V8-shaped.
- *
- * It was not, in two places, and both were fixed in the seam rather than
- * worked around here:
- *
- * - `LineClassifier` had no notion of a line that ends a block and belongs
- *   to it, because a V8 header names its exception up front. A CPython
- *   traceback names it last. `isTrailer` is that concept, added
- *   language-neutrally.
- * - `StackTrace.frames` had no documented order, because with one language
- *   nothing ever had to convert. Python prints the opposite of V8. The
- *   contract now states most-recent-first and this adapter reverses.
- *
- * Both are recorded because they are the general lesson of adding a second
- * anything: a seam with one implementation is a seam in name only, and the
- * defects it hides are silent ones — a truncated traceback and a
- * backwards frame list both look like well-formed output.
+ * The concrete RuntimeAdapter for Python — the second language, first to
+ * test whether @descryy/runtime-backend-observation's seam is genuinely
+ * language-neutral or merely V8-shaped. It wasn't, in two places, fixed in
+ * the seam rather than worked around here:
+ * - LineClassifier had no `isTrailer` concept (a V8 header names its
+ *   exception up front; CPython names it last) — added language-neutrally.
+ * - StackTrace.frames had no documented order (Python prints the opposite
+ *   of V8) — contract now states most-recent-first, this adapter reverses.
  */
 import { createLogCollector } from "@descryy/runtime-backend-observation";
 import { createPythonLineClassifier } from "./python-frame-parsing.js";
@@ -34,37 +23,25 @@ export function createPythonRuntimeAdapter(options = {}) {
     }
     const patternNames = options.logPatterns ?? (options.server === undefined ? null : [options.server]);
     const registry = patternNames === null ? null : pythonLogPatternRegistry();
-    // Names are checked HERE, not inside `createBackendCollectors`. An unknown
-    // pattern name has to fail where the caller declared it: a misspelling that
-    // only threw once a process was already spawned, or -- worse -- that
-    // resolved to no envelope at all, would be silence exactly where this
-    // option exists to remove it. The envelope itself is still built per
-    // collector below, because it is stateful.
+    // Checked HERE, not inside createBackendCollectors: an unknown pattern name
+    // must fail where the caller declared it, not silently once a process is spawned.
     if (registry !== null && patternNames !== null)
         registry.envelope(patternNames);
     function createBackendCollectors(sources) {
         return sources.map((source) => createLogCollector({
             source,
-            // One classifier per collector, never shared: it carries per-stream
-            // state, and two processes' output must not prime each other.
+            // One classifier per collector: carries per-stream state, must not be shared.
             classifier: createPythonLineClassifier(),
             stackTraceParser,
-            // One envelope per collector, never shared: it holds the current
-            // record's fields, and two processes' output must not attribute
-            // each other's. For uvicorn its whole contribution is `startsRecord`
-            // — nothing is stripped from a Python traceback (RT-106); for the
-            // console patterns it also strips the tag run.
+            // One envelope per collector: holds current record's fields, must not be shared.
             ...(registry === null || patternNames === null ? {} : { envelope: registry.envelope(patternNames) }),
             ...(options.service !== undefined ? { service: options.service } : {}),
         }));
     }
     /**
-     * CPython has no `--import`. It runs `sitecustomize.py` from anywhere on
-     * `PYTHONPATH` at startup, which is the earliest application-independent
-     * hook available, so the preload directory goes on `PYTHONPATH` --
-     * *prepended*, never replacing: a target whose own `PYTHONPATH` matters
-     * would otherwise stop finding its own modules, which is breaking the
-     * application in order to watch it.
+     * CPython has no `--import`; it runs `sitecustomize.py` from anywhere on
+     * PYTHONPATH at startup, the earliest hook available. Prepended, never
+     * replacing — a target's own PYTHONPATH must still resolve its own modules.
      */
     function outboundHttpLaunch() {
         return {

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

@@ -1 +1 @@
-{"version":3,"file":"python-runtime-adapter.js","sourceRoot":"","sources":["../src/python-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,kCAAkC,EAAE,MAAM,sCAAsC,CAAC;AAC1F,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AA+CtF,MAAM,UAAU,0BAA0B,CAAC,UAAuC,EAAE;IAClF,MAAM,sBAAsB,GAAG,kCAAkC,EAAE,CAAC;IACpE,MAAM,gBAAgB,GAAG,4BAA4B,CAAC,sBAAsB,CAAC,CAAC;IAE9E,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACtE,MAAM,IAAI,KAAK,CACb,+GAA+G;YAC7G,gGAAgG,CACnG,CAAC;IACJ,CAAC;IACD,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACrG,MAAM,QAAQ,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,wBAAwB,EAAE,CAAC;IAC3E,2EAA2E;IAC3E,4EAA4E;IAC5E,qEAAqE;IACrE,sEAAsE;IACtE,qEAAqE;IACrE,2CAA2C;IAC3C,IAAI,QAAQ,KAAK,IAAI,IAAI,YAAY,KAAK,IAAI;QAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAEhF,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,oEAAoE;YACpE,8DAA8D;YAC9D,UAAU,EAAE,0BAA0B,EAAE;YACxC,gBAAgB;YAChB,iEAAiE;YACjE,gEAAgE;YAChE,qEAAqE;YACrE,kEAAkE;YAClE,+CAA+C;YAC/C,GAAG,CAAC,QAAQ,KAAK,IAAI,IAAI,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YACpG,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;;;;;;;OAOG;IACH,SAAS,kBAAkB;QACzB,OAAO;YACL,GAAG,EAAE,EAAE,UAAU,EAAE,gCAAgC,EAAE;YACrD,iBAAiB,EAAE,CAAC,YAAY,CAAC;SAClC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,QAAQ;QAClB,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;QACvB,kBAAkB;KACnB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"python-runtime-adapter.js","sourceRoot":"","sources":["../src/python-runtime-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,kCAAkC,EAAE,MAAM,sCAAsC,CAAC;AAC1F,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AAiCtF,MAAM,UAAU,0BAA0B,CAAC,UAAuC,EAAE;IAClF,MAAM,sBAAsB,GAAG,kCAAkC,EAAE,CAAC;IACpE,MAAM,gBAAgB,GAAG,4BAA4B,CAAC,sBAAsB,CAAC,CAAC;IAE9E,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACtE,MAAM,IAAI,KAAK,CACb,+GAA+G;YAC7G,gGAAgG,CACnG,CAAC;IACJ,CAAC;IACD,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACrG,MAAM,QAAQ,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,wBAAwB,EAAE,CAAC;IAC3E,4EAA4E;IAC5E,kFAAkF;IAClF,IAAI,QAAQ,KAAK,IAAI,IAAI,YAAY,KAAK,IAAI;QAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAEhF,SAAS,uBAAuB,CAAC,OAAuC;QACtE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,kBAAkB,CAAC;YACjB,MAAM;YACN,8EAA8E;YAC9E,UAAU,EAAE,0BAA0B,EAAE;YACxC,gBAAgB;YAChB,iFAAiF;YACjF,GAAG,CAAC,QAAQ,KAAK,IAAI,IAAI,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YACpG,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;;;;OAIG;IACH,SAAS,kBAAkB;QACzB,OAAO;YACL,GAAG,EAAE,EAAE,UAAU,EAAE,gCAAgC,EAAE;YACrD,iBAAiB,EAAE,CAAC,YAAY,CAAC;SAClC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,QAAQ;QAClB,gBAAgB;QAChB,sBAAsB;QACtB,uBAAuB;QACvB,kBAAkB;KACnB,CAAC;AACJ,CAAC"}

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

@@ -1,32 +1,19 @@
 /**
- * Python `SourceLocationResolver`.
+ * Python SourceLocationResolver.
  *
- * **Every location is `self-contained`, and that is a positive claim rather
- * than a fallback.** CPython captures the path and line of the `.py` file it
- * is actually executing; there is no compilation step, no separate map, and
- * therefore nothing that can drift or go missing. The frame IS the answer.
- * Contrast the Node resolver, which must decide between four values because
- * a source map is a second file that can be absent, stale, or wrong.
+ * Every location is `self-contained` (a positive claim, not a fallback):
+ * CPython captures the path/line of the .py file it's actually executing,
+ * no compile step or map to drift. Contrast the Node resolver, which must
+ * choose between four values because a source map can be absent/stale/wrong.
  *
- * This is the first resolver in the codebase for which the reliability
- * decision is genuinely trivial, and the RT-003 enum already anticipates it:
- * `self-contained` means "nothing was lost", not "we didn't look".
+ * 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, and a stat call per frame buys only latency. Pseudo-files
+ * (`<string>`, `<stdin>`, `<frozen importlib._bootstrap>`) pass through verbatim.
  *
- * **What this deliberately does not do:** check that the file exists on
- * disk, or that its current contents still match what ran. Neither would
- * change the reliability value — `self-contained` is a statement about the
- * *mechanism*, not about whether the working tree has since been edited —
- * and a stat call per frame would buy nothing but latency. CPython's
- * pseudo-files (`<string>`, `<stdin>`, `<frozen importlib._bootstrap>`) are
- * passed through verbatim for the same reason: they are the honest location,
- * and rewriting them to null would discard real information.
- *
- * `column` is always null. CPython does not print columns; 3.11+ prints a
- * caret line under the failing expression, from which a column *could* be
- * inferred by counting characters. That inference is not made here — it
- * would be a derived guess presented in a field callers read as captured
- * fact, and the caret line is preserved verbatim in `StackFrame.raw`
- * regardless.
+ * `column` is always null — CPython doesn't print one. 3.11+'s caret line
+ * could be used to infer a column by counting characters, but that would be
+ * a derived guess in a field callers read as fact; the caret line stays verbatim in `StackFrame.raw`.
  */
 import type { SourceLocationResolver } from "@descryy/runtime-backend-observation";
 export declare function createPythonSourceLocationResolver(): SourceLocationResolver;

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

@@ -1 +1 @@
-{"version":3,"file":"python-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/python-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAErG,wBAAgB,kCAAkC,IAAI,sBAAsB,CAiB3E"}
+{"version":3,"file":"python-source-location-resolver.d.ts","sourceRoot":"","sources":["../src/python-source-location-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAErG,wBAAgB,kCAAkC,IAAI,sBAAsB,CAc3E"}