@fuzdev/fuz_app 0.135.0 → 0.137.0

package/dist/testing/CLAUDE.md

@@ -99,7 +99,8 @@ mismatch.
 
 ### `audit_drift_guard.ts` — audit-emission validation
 
-- `install_audit_drift_guard()` — `beforeEach` resets + `afterEach` zero-checks `audit_metadata_validation_failures` + `audit_unknown_event_type_failures` counters from `auth/audit_log_queries.ts`. Call once at the top of any `describe_db` block firing audit emits — production validation is fail-open, so without this any regression shipping a typo'd `event_type` or undeclared metadata field is silent. Pair with `await_pending_effects: true` (the `create_test_app` default) so fire-and-forget audit writes complete by response time.
+- `install_audit_drift_guard()` — `beforeEach` resets + `afterEach` zero-checks the `audit_metadata_validation_failures` + `audit_unknown_event_type_failures` counters from `auth/audit_log_queries.ts` and the emitter's write-failure counter (`get_audit_write_failures` in `auth/audit_emitter.ts`). Call once at the top of any `describe_db` block firing audit emits — production validation and the emitter's write are fail-open, so without this any regression shipping a typo'd `event_type` or undeclared metadata field, or losing a row the database refused, is silent. A test that fails a write on purpose resets the counter (`reset_audit_write_failures`) once it has asserted it.
+- `assert_no_audit_drift()` — the zero-check itself, for a test that manages the counters. Pair with `await_pending_effects: true` (the `create_test_app` default) so fire-and-forget audit writes complete by response time.
 - `create_recording_audit_emitter(calls_ref?)` — no-op `AuditEmitter` pushing every `emit` and `emit_pool` call into `calls`. Pass `calls_ref` to write into a caller-owned array; omit to let the helper allocate. Returns `{emitter, calls}` — destructure `emitter` as the `audit` dep and read `calls` to assert. `add_listener` records (never fires) and returns a remover with the production semantics, so `listener_count` tracks what a server registered and released. Replaces per-file capturing emitters previously duplicated across `password_change.test.ts`, `audit_log.test.ts`, etc.
 - `RecordingAuditEmitter` — `{emitter: AuditEmitter; calls: Array<AuditLogInput>}`.
 
@@ -223,7 +224,7 @@ test-only by construction.
 
 ### `schema_introspect.ts` — `query_schema_snapshot`
 
-- `query_schema_snapshot(db, options?)` — introspects a live DB into a deterministic `SchemaSnapshot` via `pg_catalog` + `information_schema`. Captures tables, columns (with `udt_name` to distinguish int4/int8), indexes (`indexdef`), constraints (`pg_get_constraintdef`), sequences, and enum types (`pg_enum` labels in declared `enumsortorder`, so a `cell_visibility` label-set/order drift is gated). The `schema_version` migration tracker is always excluded — it's framework bookkeeping, not domain schema; twin impls keep it identical (same namespaces, names and partitioning), which `query_migration_tracker` + `assert_migration_trackers_equal` gate separately. Twinned by `fuz_db::query_schema_snapshot` (Rust); the `_testing_schema_snapshot` RPC's wire validator is the shared `SchemaSnapshot`, so the enum field must serialize on both sides.
+- `query_schema_snapshot(db, options?)` — introspects a live DB into a deterministic `SchemaSnapshot` via `pg_catalog` + `information_schema`. Throws on pglet when the snapshot holds an index, unless `accept_pglet_index_definitions` is passed: pglet's `indexdef` omits index modifiers, so its index definitions read as false differences against PostgreSQL and false agreement between two pglet schemas. Captures tables, columns (with `udt_name` to distinguish int4/int8), indexes (`indexdef`), constraints (`pg_get_constraintdef`), sequences, and enum types (`pg_enum` labels in declared `enumsortorder`, so a `cell_visibility` label-set/order drift is gated). The `schema_version` migration tracker is always excluded — it's framework bookkeeping, not domain schema; twin impls keep it identical (same namespaces, names and partitioning), which `query_migration_tracker` + `assert_migration_trackers_equal` gate separately. Twinned by `fuz_db::query_schema_snapshot` (Rust); the `_testing_schema_snapshot` RPC's wire validator is the shared `SchemaSnapshot`, so the enum field must serialize on both sides.
 - `SchemaSnapshot` — the Zod schema is canonical (co-located in `schema_introspect.ts`; the cross-impl `_testing_schema_snapshot` RPC action reuses it as its wire validator, and the type is `z.infer`'d from it). Fully JSON-serializable; every collection deterministically sorted on capture so structural equality is stable across runs.
 - `query_migration_tracker(db)` / `MigrationTracker` — the migration-_identity_ twin of the snapshot: reads the `schema_version` tracker rows (`[{namespace, name, sequence}]`) the snapshot deliberately _excludes_. `MigrationTracker` is the `_testing_migration_tracker` RPC's wire validator; pairs with `assert_migration_trackers_equal` to gate that the two spines record byte-identical migration identity (the swap-freely invariant), catching a migration-name or namespace-partitioning drift the provenance-agnostic schema snapshot can't see.
 
@@ -927,7 +928,7 @@ source of truth for wire-shape conformance.
 - `testing/cross_backend/capabilities.ts` — `BackendCapabilities` vocabulary
   (the **gating** flags `ws` / `sse` / `cell_crud` / `cell_relations` /
   `cell_gated_create` / `account_lifecycle` / `fact_serving` / `ready` /
-  `account_status` / `oversized_reject_closes_connection` / `peer_request` /
+  `account_status` / `peer_request` /
   `ws_handshake_pipelining` / `ws_account_actions` / `ws_self_revocation_reply` —
   each has a `test_if`
   reader (`ws_self_revocation_reply` forks one case's assertion instead); `peer_request` (server-initiated requests — the ActionPeer
@@ -971,18 +972,17 @@ source of truth for wire-shape conformance.
   case — `GET /api/account/status` is bundled into `create_account_route_specs`,
   so every spine serves it (`true`); the gate fails loud if a declaring backend
   doesn't mount it (replacing the old runtime 404-sniff-skip).
-  `oversized_reject_closes_connection` picks the arm of the body-size
-  smuggling probe (`true` Node/Deno/Rust — the connection closes after an
-  oversized-body 413, at once on Node and once the declared body has arrived
-  on Deno, so the pipelined request goes unanswered; `false` Bun —
-  `Bun.serve` keeps the connection and serves the next request, correctly
-  framed, so the suite requires no desync there instead: exactly the 413 and
-  the reply to the pipelined request, which a backend that closes fails).
+  No flag covers the body-size smuggling probe: every backend closes the
+  connection after an oversized-body 413 (at once on Node, Bun and the Rust
+  spine, once the declared body has arrived on Deno), so the pipelined request
+  goes unanswered. Bun 1.4.3 is the tested floor — an older Bun kept the
+  connection and served the next request, correctly framed, and fails the probe.
   `ws_handshake_pipelining` gates the WS round-trip suite's
   frames-with-the-handshake case (`true` Node/Deno/Rust — frames written in the
-  same TCP write as the upgrade request reach the socket; `false` Bun, whose
-  HTTP parser answers such a request `400`, and `false` in-process, where there
-  is no socket to write raw bytes to).
+  same TCP write as the upgrade request reach the socket; `false` Bun, which
+  answers such a request `400` when the upgrade follows an asynchronous check,
+  as it does behind auth, and `false` in-process, where there is no socket to
+  write raw bytes to).
   `ws_account_actions` (the WS endpoint mounts the account actions — `true` on
   fuz_app's own spine presets, `false` in the family defaults) gates the WS
   round-trip suite's self-revocation case and, with `rpc_path`, its
@@ -1345,7 +1345,7 @@ an audit row, an admin account listing, and an offer's `created_at` /
 `expires_at`. `cross_backend/setup.ts` carries the four bases every
 imperative cross suite aliases: `CrossSuiteOptions` (`setup_test` alone),
 `CapabilityGatedCrossSuiteOptions` (+ `capabilities` — `ready`),
-`RpcPathCrossSuiteOptions` (+ `rpc_path?` — origin, body-size, actor
+`RpcPathCrossSuiteOptions` (+ `rpc_path?` — origin, body-size (which adds `base_url`), actor
 lookup/search, app settings, testing backdoor), and the intersection
 `RpcPathCapabilityGatedCrossSuiteOptions` (every `cell_*` suite, query-shape,
 token-scope surface, fact-serving, account lifecycle). A suite takes the
@@ -1358,7 +1358,8 @@ the option type states whether the bundle is read.
   edit/read/delete → 404 IDOR mask; admin reaches any; dup active `path` → 409;
   `path` write by non-admin → 403 on create + update; `cell_get` with no
   id/path → `invalid_params`; null-auth `cell_list` `created_by` →
-  `invalid_params`).
+  `invalid_params`; a `kind` at `CELL_KIND_LENGTH_MAX` stored whole, one
+  UTF-16 code unit past it → `invalid_params` on create and as a list filter).
 - **`describe_cell_relations_cross_tests`** (gates on
   `capabilities.cell_relations`) — the verbs beyond CRUD: grant lifecycle
   (actor-shaped editor grant enables edit, manage-tier `cell_grant_list`,
@@ -1463,6 +1464,21 @@ are `src/test/auth/cell_crud_parity.db.test.ts`
   write as the upgrade request, so before the connection can have been
   admitted). Small unfragmented text frames only. Helpers `is_raw_ws_close`,
   `raw_ws_close_code`, `RAW_WS_OPCODE_TEXT` / `_CLOSE`.
+- `testing/transports/raw_http.ts` — `raw_http_exchange(base_url, request_bytes, {read_timeout_ms, until?})`
+  → `RawHttpExchange` (`{received, closed_by_server}`): writes caller-built
+  HTTP/1.1 bytes to a raw `node:net` socket once and reads what the server
+  sends until it closes (`until: 'close'`, the default), until one whole
+  response has arrived (`until: 'response'` — for a server that answers and
+  keeps the connection), or until the read timeout. For what `fetch` can't
+  send: two requests in one write, duplicate or malformed headers, a request
+  head whose body never follows, an unterminated chunked body. Write errors are
+  swallowed, and a write error ends the socket — so a caller that must read a
+  refusal reliably sends nothing the server will leave unread. Helpers
+  `raw_http_parse_response` (the first response, `null` until its head and
+  framed body are whole), `raw_http_count_responses` (unanchored status-line
+  count, so a response concatenated after a body is seen),
+  `raw_http_first_status`. Shared by the body-size, body-size smuggling, and
+  credential-header suites.
 - `testing/transports/sse_frame_reader.ts` — `create_sse_frame_reader(reader, default_timeout_ms?)`,
   the transport-agnostic SSE framing core over a
   `ReadableStreamDefaultReader<Uint8Array>`: `\n\n` framing, per-read timeout,
@@ -1667,8 +1683,9 @@ reads the audit log behind `_testing_drain_effects`). fuz_app's own wiring is
 imperative round-trip on `account_token_create`'s required `lifetime` union:
 a `{kind:'ttl', days}` mint returns and stores a bounded `expires_at`
 (create output + `account_token_list` read-back), `{kind:'eternal'}` stores
-NULL, and an omitted or out-of-range lifetime 400s identically on both
-spines. Exists because the action-manifest parity gate captures no param
+NULL, an omitted or out-of-range lifetime 400s identically on both
+spines, and a `name` at `API_TOKEN_NAME_LENGTH_MAX` mints and reads back whole
+while one UTF-16 code unit past it is `invalid_params`. Exists because the action-manifest parity gate captures no param
 schemas while the Rust spine hand-parses params — a spine that silently
 dropped the field would answer the same mint with a 200 and an eternal
 token; only the stored-state read-back catches it. Ungated (mint + list are
@@ -1705,8 +1722,8 @@ drift-guarded by `src/test/cross_backend/spine_expected_schema.db.test.ts`
 
 `describe_testing_backdoor_cross_tests({setup_test, rpc_path?, ws?})` —
 the negative-credential parity suite for the `_testing_*` backdoor actions.
-For each `_testing_*` action except `_testing_drain_effects` (the privileged
-writes, the connection flood, and the introspection reads) it fires three principals over real HTTP: **anonymous** →
+For each `_testing_*` action (the privileged writes, the audit barrier, the
+connection flood, and the introspection reads) it fires three principals over real HTTP: **anonymous** →
 401 `unauthenticated`, **session** → 403 `forbidden` `credential_type_required`,
 **bearer** → 403 `forbidden` `credential_type_required` — and, when `ws`
 (`{base_url, ws_path, origin?}`) is passed, sends each on a socket opened with

package/dist/testing/audit_drift_guard.d.ts

@@ -1,26 +1,39 @@
 import './assert_dev_env.js';
-import type { AuditEmitter } from '../auth/audit_emitter.js';
+import { type AuditEmitter } from '../auth/audit_emitter.js';
 import type { AuditLogInput } from '../auth/audit_log_schema.js';
 /**
  * Register per-test `beforeEach` + `afterEach` hooks that catch any audit
  * emission with a metadata shape that fails its `audit_metadata_schemas`
- * entry, or an `event_type` not present in the active `AuditLogConfig`.
+ * entry, an `event_type` not present in the active `AuditLogConfig`, or a
+ * row the emitter failed to write.
  *
  * The production validation in `query_audit_log` is fail-open — it bumps
  * process-wide counters and proceeds, so a regression that emits an
  * undeclared metadata field or a typo'd event-type lands a row that
- * passes downstream queries but breaks forensics. Tests that exercise
- * audit emits should fail loudly when this happens.
+ * passes downstream queries but breaks forensics. The emitter's pool write
+ * is fail-open too: a refused `INSERT` is logged and counted, the request
+ * succeeds, and the row is gone. Tests that exercise audit emits should fail
+ * loudly when either happens.
  *
  * Call at the top of every `describe` / `describe_db` block that fires
  * audit writes through `deps.audit.emit`. Resets counters before each
- * test and asserts zero on completion.
+ * test and asserts zero on completion. A test that makes a write fail on
+ * purpose calls `reset_audit_write_failures` (`auth/audit_emitter.ts`) once
+ * it has asserted the count.
  *
  * Pair with `await_pending_effects: true` (the default for
  * `create_test_app`) so fire-and-forget audit writes have completed by
  * the time the after-each check observes counter state.
  */
 export declare const install_audit_drift_guard: () => void;
+/**
+ * Assert the process-wide audit counters are zero — the check
+ * `install_audit_drift_guard` runs after each test. Exported for a test that
+ * manages the counters itself.
+ *
+ * @throws AssertionError naming the first counter that is not zero
+ */
+export declare const assert_no_audit_drift: () => void;
 /**
  * Pair returned by `create_recording_audit_emitter` — the
  * `AuditEmitter` to inject as `deps.audit`, plus the shared `calls`

package/dist/testing/audit_drift_guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit_drift_guard.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/audit_drift_guard.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAU7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,QAAO,IAiB5C,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,8BAA8B,GAC1C,YAAY,KAAK,CAAC,aAAa,CAAC,KAC9B,qBAqCF,CAAC"}
+{"version":3,"file":"audit_drift_guard.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/audit_drift_guard.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAU7B,OAAO,EAGN,KAAK,YAAY,EACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,yBAAyB,QAAO,IAO5C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAO,IAgBxC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,8BAA8B,GAC1C,YAAY,KAAK,CAAC,aAAa,CAAC,KAC9B,qBAqCF,CAAC"}

package/dist/testing/audit_drift_guard.js

@@ -1,20 +1,26 @@
 import './assert_dev_env.js';
 import { assert, beforeEach, afterEach } from 'vitest';
 import { get_audit_metadata_validation_failures, get_audit_unknown_event_type_failures, reset_audit_metadata_validation_failures, reset_audit_unknown_event_type_failures } from '../auth/audit_log_queries.js';
+import { get_audit_write_failures, reset_audit_write_failures } from '../auth/audit_emitter.js';
 /**
  * Register per-test `beforeEach` + `afterEach` hooks that catch any audit
  * emission with a metadata shape that fails its `audit_metadata_schemas`
- * entry, or an `event_type` not present in the active `AuditLogConfig`.
+ * entry, an `event_type` not present in the active `AuditLogConfig`, or a
+ * row the emitter failed to write.
  *
  * The production validation in `query_audit_log` is fail-open — it bumps
  * process-wide counters and proceeds, so a regression that emits an
  * undeclared metadata field or a typo'd event-type lands a row that
- * passes downstream queries but breaks forensics. Tests that exercise
- * audit emits should fail loudly when this happens.
+ * passes downstream queries but breaks forensics. The emitter's pool write
+ * is fail-open too: a refused `INSERT` is logged and counted, the request
+ * succeeds, and the row is gone. Tests that exercise audit emits should fail
+ * loudly when either happens.
  *
  * Call at the top of every `describe` / `describe_db` block that fires
  * audit writes through `deps.audit.emit`. Resets counters before each
- * test and asserts zero on completion.
+ * test and asserts zero on completion. A test that makes a write fail on
+ * purpose calls `reset_audit_write_failures` (`auth/audit_emitter.ts`) once
+ * it has asserted the count.
  *
  * Pair with `await_pending_effects: true` (the default for
  * `create_test_app`) so fire-and-forget audit writes have completed by
@@ -24,11 +30,21 @@ export const install_audit_drift_guard = () => {
     beforeEach(() => {
         reset_audit_metadata_validation_failures();
         reset_audit_unknown_event_type_failures();
+        reset_audit_write_failures();
     });
-    afterEach(() => {
-        assert.strictEqual(get_audit_metadata_validation_failures(), 0, 'audit metadata failed schema validation — see audit_log_schema.audit_metadata_schemas');
-        assert.strictEqual(get_audit_unknown_event_type_failures(), 0, 'audit emitted an unknown event_type — see AUDIT_EVENT_TYPES');
-    });
+    afterEach(assert_no_audit_drift);
+};
+/**
+ * Assert the process-wide audit counters are zero — the check
+ * `install_audit_drift_guard` runs after each test. Exported for a test that
+ * manages the counters itself.
+ *
+ * @throws AssertionError naming the first counter that is not zero
+ */
+export const assert_no_audit_drift = () => {
+    assert.strictEqual(get_audit_metadata_validation_failures(), 0, 'audit metadata failed schema validation — see audit_log_schema.audit_metadata_schemas');
+    assert.strictEqual(get_audit_unknown_event_type_failures(), 0, 'audit emitted an unknown event_type — see AUDIT_EVENT_TYPES');
+    assert.strictEqual(get_audit_write_failures(), 0, 'an audit row failed to write and was lost — the emitter logged the database error');
 };
 /**
  * Build a no-op `AuditEmitter` that records every `emit`, `emit_pool`, and

package/dist/testing/cross_backend/action_manifest.d.ts

@@ -43,27 +43,20 @@ import type { RequestResponseActionSpec } from '../../actions/action_spec.js';
  * serializes an explicit `null`, so a missing key is drift, not a default.
  */
 export declare const ActionManifestEntry: z.ZodObject<{
-    /** RPC method name (`spec.method`). */
     method: z.ZodString;
-    /** `true` when the action declares `side_effects` (mutation; POST-only on the RPC transport). */
     side_effects: z.ZodBoolean;
-    /** The `account` auth axis. */
     account: z.ZodEnum<{
         optional: "optional";
         none: "none";
         required: "required";
     }>;
-    /** The `actor` auth axis. */
     actor: z.ZodEnum<{
         optional: "optional";
         none: "none";
         required: "required";
     }>;
-    /** Required roles (any-of), sorted; `[]` when the action declares no role gate. */
     roles: z.ZodArray<z.ZodString>;
-    /** Permitted credential channels, sorted; `[]` when ungated (any credential). */
     credential_types: z.ZodArray<z.ZodString>;
-    /** Per-action rate-limit class, or `null` when the action declares none. */
     rate_limit: z.ZodNullable<z.ZodEnum<{
         account: "account";
         ip: "ip";
@@ -74,27 +67,20 @@ export type ActionManifestEntry = z.infer<typeof ActionManifestEntry>;
 /** The full action manifest — every entry, sorted by `method`. */
 export declare const ActionManifest: z.ZodObject<{
     methods: z.ZodArray<z.ZodObject<{
-        /** RPC method name (`spec.method`). */
         method: z.ZodString;
-        /** `true` when the action declares `side_effects` (mutation; POST-only on the RPC transport). */
         side_effects: z.ZodBoolean;
-        /** The `account` auth axis. */
         account: z.ZodEnum<{
             optional: "optional";
             none: "none";
             required: "required";
         }>;
-        /** The `actor` auth axis. */
         actor: z.ZodEnum<{
             optional: "optional";
             none: "none";
             required: "required";
         }>;
-        /** Required roles (any-of), sorted; `[]` when the action declares no role gate. */
         roles: z.ZodArray<z.ZodString>;
-        /** Permitted credential channels, sorted; `[]` when ungated (any credential). */
         credential_types: z.ZodArray<z.ZodString>;
-        /** Per-action rate-limit class, or `null` when the action declares none. */
         rate_limit: z.ZodNullable<z.ZodEnum<{
             account: "account";
             ip: "ip";

package/dist/testing/cross_backend/action_manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action_manifest.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/action_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;IAC/B,uCAAuC;;IAEvC,iGAAiG;;IAEjG,+BAA+B;;;;;;IAE/B,6BAA6B;;;;;;IAE7B,mFAAmF;;IAEnF,iFAAiF;;IAEjF,4EAA4E;;;;;;kBAE3E,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,kEAAkE;AAClE,eAAO,MAAM,cAAc;;QAlB1B,uCAAuC;;QAEvC,iGAAiG;;QAEjG,+BAA+B;;;;;;QAE/B,6BAA6B;;;;;;QAE7B,mFAAmF;;QAEnF,iFAAiF;;QAEjF,4EAA4E;;;;;;;kBAQ3E,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAM5D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACnC,KAAG,mBAQF,CAAC;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,aAAa,CACnB,IAAI,CAAC,yBAAyB,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,YAAY,CAAC,CAClF,KACC,cAED,CAAC"}
+{"version":3,"file":"action_manifest.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/action_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;kBAe9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,kEAAkE;AAClE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;kBAEzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAM5D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACnC,KAAG,mBAQF,CAAC;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,aAAa,CACnB,IAAI,CAAC,yBAAyB,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,YAAY,CAAC,CAClF,KACC,cAED,CAAC"}

package/dist/testing/cross_backend/body_size.d.ts

@@ -2,11 +2,24 @@ import '../assert_dev_env.js';
 import type { RpcPathCrossSuiteOptions } from './setup.js';
 /**
  * Options for the body-size parity suite — the standard RPC-dispatched
- * cross-suite shape (`setup_test` / `rpc_path`); aliases the shared
- * `RpcPathCrossSuiteOptions` rather than minting a duplicate. The limit is
- * on every spine, so no case is capability-gated and the flag bundle is not
- * on the shape.
+ * cross-suite shape (`setup_test` / `rpc_path`) plus where the backend's
+ * socket is. The limit is on every spine, so no case is capability-gated and
+ * the flag bundle is not on the shape.
  */
-export type BodySizeCrossTestOptions = RpcPathCrossSuiteOptions;
+export interface BodySizeCrossTestOptions extends RpcPathCrossSuiteOptions {
+    /**
+     * Base URL the spawned backend is reachable at (e.g. `http://localhost:1178`),
+     * or `null` for an in-process run, which has no socket. Given a URL, the
+     * over-cap cases write to the socket directly and send only the bytes the
+     * refusal needs; with `null` they send whole bodies through the fixture's
+     * transport.
+     *
+     * Pass the URL whenever the fixture's transport reaches a real socket.
+     * `null` there uploads each whole over-cap body through `fetch`, where the
+     * write races the close that follows the 413 and the case fails some of the
+     * time.
+     */
+    readonly base_url: string | null;
+}
 export declare const describe_body_size_cross_tests: (options: BodySizeCrossTestOptions) => void;
 //# sourceMappingURL=body_size.d.ts.map

package/dist/testing/cross_backend/body_size.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"body_size.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/body_size.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA0D9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG3D;;;;;;GAMG;AACH,MAAM,MAAM,wBAAwB,GAAG,wBAAwB,CAAC;AAmDhE,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IA0ClF,CAAC"}
+{"version":3,"file":"body_size.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/body_size.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8F9B,OAAO,KAAK,EAAE,wBAAwB,EAAe,MAAM,YAAY,CAAC;AAGxE;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,wBAAwB;IACzE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AA2HD,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IAyLlF,CAAC"}