@fuzdev/fuz_app 0.135.0 → 0.136.0

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

@@ -1 +1 @@
-{"version":3,"file":"testing_backdoor.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_backdoor.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAyE9B,OAAO,KAAK,EAAE,wBAAwB,EAAe,MAAM,YAAY,CAAC;AA6ExE,kEAAkE;AAClE,MAAM,WAAW,+BAAgC,SAAQ,wBAAwB;IAChF;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE;QACb,2EAA2E;QAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,+DAA+D;QAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,sDAAsD;QACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;CACF;AAED,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAyEF,CAAC"}
+{"version":3,"file":"testing_backdoor.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_backdoor.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAyE9B,OAAO,KAAK,EAAE,wBAAwB,EAAe,MAAM,YAAY,CAAC;AA+ExE,kEAAkE;AAClE,MAAM,WAAW,+BAAgC,SAAQ,wBAAwB;IAChF;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE;QACb,2EAA2E;QAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,+DAA+D;QAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,sDAAsD;QACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;CACF;AAED,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAyEF,CAAC"}

package/dist/testing/cross_backend/testing_backdoor.js

@@ -77,6 +77,8 @@ const NIL_UUID = '00000000-0000-0000-0000-000000000000';
  */
 const backdoor_methods = [
     { method: '_testing_reset', params: {} },
+    // The audit barrier — its input is void, so the call carries no params.
+    { method: '_testing_drain_effects', params: undefined },
     { method: '_testing_mint_session', params: { account_id: NIL_UUID, expires_in_seconds: -60 } },
     { method: '_testing_put_fact', params: { content: 'backdoor-probe' } },
     // An empty burst — valid input, so it clears the 400 phase; a refused

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

@@ -379,6 +379,11 @@ export declare const create_testing_flood_notifications_action: () => RpcAction;
  * shapes match by design). Optional `exclude_tables` drops documented
  * divergences from both sides before comparison.
  *
+ * A backend running on pglet (a TS backend config's `memory://` default)
+ * answers with an error when its schema holds an index: the snapshot exists
+ * to be compared, and pglet's index definitions omit the modifiers a
+ * comparison needs (`query_schema_snapshot`). Run the backend on PostgreSQL.
+ *
  * `auth` gates on the daemon-token credential, matching `_testing_reset`.
  */
 export declare const testing_schema_snapshot_action_spec: {

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

@@ -1 +1 @@
-{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"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"}

package/dist/testing/cross_backend/testing_reset_actions.js

@@ -397,6 +397,11 @@ rpc_action(testing_flood_notifications_action_spec, ({ count, size }, ctx) => {
  * shapes match by design). Optional `exclude_tables` drops documented
  * divergences from both sides before comparison.
  *
+ * A backend running on pglet (a TS backend config's `memory://` default)
+ * answers with an error when its schema holds an index: the snapshot exists
+ * to be compared, and pglet's index definitions omit the modifiers a
+ * comparison needs (`query_schema_snapshot`). Run the backend on PostgreSQL.
+ *
  * `auth` gates on the daemon-token credential, matching `_testing_reset`.
  */
 export const testing_schema_snapshot_action_spec = {

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

@@ -1 +1 @@
-{"version":3,"file":"token_lifetime.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/token_lifetime.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA4C9B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAaD,eAAO,MAAM,mCAAmC,GAC/C,SAAS,6BAA6B,KACpC,IAsHF,CAAC"}
+{"version":3,"file":"token_lifetime.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/token_lifetime.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAkD9B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAaD,eAAO,MAAM,mCAAmC,GAC/C,SAAS,6BAA6B,KACpC,IA6KF,CAAC"}

package/dist/testing/cross_backend/token_lifetime.js

@@ -27,11 +27,16 @@ import '../assert_dev_env.js';
  *   pin on the silently-ignoring-unknown-shapes hazard.
  * - **Out-of-range days are refused** — `days: 0` 400s identically, so the
  *   two hand-rolled bounds checks can't drift.
+ * - **The `name` cap** — the same blind spot on another field of the same
+ *   mint: a name of exactly `API_TOKEN_NAME_LENGTH_MAX` UTF-16 code units
+ *   mints and reads back whole, and one unit past it is `invalid_params`,
+ *   with an astral-plane name at each side of the boundary so the two spines
+ *   count the same unit.
  *
  * @module
  */
 import { describe, test, assert } from 'vitest';
-import { account_token_create_action_spec, account_token_list_action_spec, TokenCreateOutput, TokenListOutput } from '../../auth/account_action_specs.js';
+import { account_token_create_action_spec, account_token_list_action_spec, API_TOKEN_NAME_LENGTH_MAX, TokenCreateOutput, TokenListOutput } from '../../auth/account_action_specs.js';
 import { cross_rpc_call, error_reason, expect_output } from './cell_cross_helpers.js';
 import { assert_iso8601_seconds } from './wire_shapes.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
@@ -97,5 +102,33 @@ export const describe_token_lifetime_cross_tests = (options) => {
             assert.ok(!res.ok, 'days: 0 must be refused');
             assert.strictEqual(res.error?.code, -32602, `expected invalid_params: ${JSON.stringify(res.error)}`);
         });
+        test('a name at the length cap mints and reads back; one past it is invalid_params', async () => {
+            const fixture = await setup_test();
+            const astral = '\u{1F600}';
+            // the cap is odd: whole astral characters, plus one unit to land on it
+            const astral_at_cap = astral.repeat((API_TOKEN_NAME_LENGTH_MAX - 1) / 2) + 'a';
+            const mint = (name) => cross_rpc_call(fixture.transport, rpc_path, account_token_create_action_spec.method, { name, scope: { kind: 'full' }, lifetime: { kind: 'eternal' } }, fixture.create_session_headers());
+            const admitted = ['a'.repeat(API_TOKEN_NAME_LENGTH_MAX), astral_at_cap];
+            const minted_ids = [];
+            for (const name of admitted) {
+                assert.strictEqual(name.length, API_TOKEN_NAME_LENGTH_MAX);
+                minted_ids.push(expect_output(await mint(name), TokenCreateOutput).id);
+            }
+            const listed = expect_output(await cross_rpc_call(fixture.transport, rpc_path, account_token_list_action_spec.method, undefined, fixture.create_session_headers()), TokenListOutput);
+            for (const [index, id] of minted_ids.entries()) {
+                assert.strictEqual(listed.tokens.find((t) => t.id === id)?.name, admitted[index], 'a name at the cap must be stored whole');
+            }
+            for (const name of [
+                'a'.repeat(API_TOKEN_NAME_LENGTH_MAX + 1),
+                // one astral character past the cap: two units over an even count
+                astral.repeat((API_TOKEN_NAME_LENGTH_MAX + 1) / 2),
+                astral_at_cap + 'a'
+            ]) {
+                const res = await mint(name);
+                assert.ok(!res.ok, `a ${name.length}-unit name must be refused`);
+                assert.strictEqual(res.error?.code, -32602, `expected invalid_params for a ${name.length}-unit name, got ${JSON.stringify(res.error)}`);
+                assert.strictEqual(error_reason(res), undefined, 'a schema refusal carries no reason');
+            }
+        });
     });
 };

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

@@ -1 +1 @@
-{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAwDzD,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,MAAM,CAAC;CACjD;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAiCF,CAAC"}
+{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAiDzD,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,MAAM,CAAC;CACjD;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAiCF,CAAC"}

package/dist/testing/cross_backend/ts_spine_backend_config.js

@@ -22,25 +22,18 @@ const ts_spine_capabilities = Object.freeze({
 });
 /**
  * Capabilities for the **Bun** spine binary — `ts_spine_capabilities` with
- * `oversized_reject_closes_connection: false` and
  * `ws_handshake_pipelining: false`.
  *
- * `Bun.serve` does not close the connection after an oversized-body `413`:
- * the response carries `Connection: close`, and Bun keeps the socket open,
- * skips the declared body, and serves the request that follows it (observed
- * on Bun 1.3.11). The next request is framed on `Content-Length`, so nothing
- * is desynchronized, but the smuggling suite's "the pipelined request is never
- * served" assertion does not hold; the flag puts Bun on the suite's no-desync
- * arm, which requires exactly the 413 and the reply to the pipelined request.
- * See `docs/security.md` §"Body Size Limiting".
- *
- * `Bun.serve` also answers `400` to an upgrade request that carries WebSocket
- * frames in the same TCP write, before any handler runs, so the WS suite's
- * frames-with-the-handshake case has nothing to drive there.
+ * `Bun.serve` answers `400` to an upgrade request that carries WebSocket
+ * frames in the same TCP write when the handler upgrades after an await that
+ * yields to the event loop — a timer, I/O; the spine's does, behind the auth
+ * middleware's database reads — so the WS suite's frames-with-the-handshake
+ * case has nothing to drive there (observed on Bun 1.4.3; an upgrade made
+ * synchronously in `fetch`, or after an await that settles in the same
+ * microtask run, takes the frames).
  */
 const ts_spine_bun_capabilities = Object.freeze({
     ...ts_spine_capabilities,
-    oversized_reject_closes_connection: false,
     ws_handshake_pipelining: false
 });
 /** Default port for the Node TS spine binary — slots beside the Rust `spine_stub` (1177). */

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

@@ -1 +1 @@
-{"version":3,"file":"ws_outbound_overflow.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_outbound_overflow.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAiE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAiCzD,sDAAsD;AACtD,MAAM,WAAW,kCAAkC;IAClD,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,GACrD,SAAS,kCAAkC,KACzC,IA0LF,CAAC"}
+{"version":3,"file":"ws_outbound_overflow.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_outbound_overflow.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAwE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAoFzD,sDAAsD;AACtD,MAAM,WAAW,kCAAkC;IAClD,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,GACrD,SAAS,kCAAkC,KACzC,IA0NF,CAAC"}

package/dist/testing/cross_backend/ws_outbound_overflow.js

@@ -32,6 +32,13 @@ import '../assert_dev_env.js';
  *   `invalid_params`, and the socket stays open.
  * - **no connection** — over HTTP RPC the action refuses with `invalid_params`
  *   and reason `no_connection`, rather than answering as though it flooded.
+ * - **the action's limits** — over HTTP RPC a call at each of the action's
+ *   limits (`count`, `size`, `count` × `size`) is refused for having no
+ *   connection, and a call one past each is refused `invalid_params` with no
+ *   reason. Both spines check the limits before they look for the connection
+ *   and before they build a payload, so the boundaries are read off the
+ *   refusal and no burst is ever allocated — which pins the two spines'
+ *   limits equal.
  *
  * What the suite does **not** assert, because it is each implementation's own:
  * how many frames accepted before the overflow reach the client (the Rust
@@ -77,6 +84,50 @@ const LARGE_FITS = { count: 3, size: MIB };
 const OVERFLOWS = { count: 32, size: MIB };
 /** One mebibyte past the action's `count` × `size` limit. */
 const REFUSED = { count: 65, size: MIB };
+/** The most notifications one flood call may ask for. */
+const FLOOD_MAX_COUNT = 65_536;
+/** The largest payload one flood call may ask for. */
+const FLOOD_MAX_SIZE = 16 * MIB;
+/** The most payload bytes (`count` × `size`) one flood call may ask for. */
+const FLOOD_MAX_TOTAL_BYTES = 64 * MIB;
+/**
+ * A `count` and `size`, each within its own limit, whose product is exactly
+ * one byte past `FLOOD_MAX_TOTAL_BYTES` (the factors of 2^26 + 1).
+ */
+const FLOOD_ONE_BYTE_PAST_TOTAL = { count: 265, size: 253_241 };
+/**
+ * Calls at and one past each of the flood action's limits. Each "past" call
+ * holds the other axis at zero, or both axes within their own limit, so one
+ * limit alone decides it.
+ */
+const FLOOD_LIMIT_CASES = [
+    { name: 'count at its limit', params: { count: FLOOD_MAX_COUNT, size: 1 }, within: true },
+    { name: 'count past its limit', params: { count: FLOOD_MAX_COUNT + 1, size: 0 }, within: false },
+    { name: 'size at its limit', params: { count: 1, size: FLOOD_MAX_SIZE }, within: true },
+    { name: 'size past its limit', params: { count: 0, size: FLOOD_MAX_SIZE + 1 }, within: false },
+    {
+        name: 'count × size at its limit, both axes at theirs or under',
+        params: { count: FLOOD_MAX_TOTAL_BYTES / FLOOD_MAX_SIZE, size: FLOOD_MAX_SIZE },
+        within: true
+    },
+    {
+        name: 'count × size at its limit, count at its own',
+        params: { count: FLOOD_MAX_COUNT, size: FLOOD_MAX_TOTAL_BYTES / FLOOD_MAX_COUNT },
+        within: true
+    },
+    {
+        name: 'count × size past its limit, each axis within its own',
+        params: { count: FLOOD_MAX_COUNT, size: FLOOD_MAX_TOTAL_BYTES / FLOOD_MAX_COUNT + 1 },
+        within: false
+    },
+    {
+        // the smallest step past the product limit: the row above overshoots it by
+        // `FLOOD_MAX_COUNT` bytes, so alone it admits a limit that many bytes loose
+        name: 'count × size one byte past its limit',
+        params: FLOOD_ONE_BYTE_PAST_TOTAL,
+        within: false
+    }
+];
 /** How long the test waits for the megabyte burst and its response. */
 const LARGE_BURST_TIMEOUT_MS = 15_000;
 /** How long the test waits for the overflow close. */
@@ -207,5 +258,19 @@ export const describe_ws_outbound_overflow_cross_tests = (options) => {
             assert.strictEqual(res.error?.code, INVALID_PARAMS);
             assert.strictEqual(res.error?.data?.reason, REASON_NO_CONNECTION);
         });
+        test_if(rpc_path !== undefined, 'over HTTP a flood call at each limit is refused for no connection, one past it for its params', async () => {
+            const fixture = await setup_test();
+            const transport = fixture.fresh_transport({ origin: null });
+            // the hand-factored case is only "one byte past" for this limit
+            assert.strictEqual(FLOOD_ONE_BYTE_PAST_TOTAL.count * FLOOD_ONE_BYTE_PAST_TOTAL.size, FLOOD_MAX_TOTAL_BYTES + 1);
+            for (const { name, params, within } of FLOOD_LIMIT_CASES) {
+                const res = await cross_rpc_call(transport, rpc_path, FLOOD_METHOD, params, fixture.create_daemon_token_headers());
+                assert.strictEqual(res.ok, false, `${name}: expected a refusal over HTTP`);
+                assert.strictEqual(res.error?.code, INVALID_PARAMS, name);
+                // within the limits the call gets as far as the connection check;
+                // past one it is refused before that, with no reason
+                assert.strictEqual(res.error?.data?.reason, within ? REASON_NO_CONNECTION : undefined, `${name}: ${JSON.stringify(params)}`);
+            }
+        });
     });
 };

package/dist/testing/schema_introspect.d.ts

@@ -21,10 +21,14 @@ import './assert_dev_env.js';
  * Index and constraint definitions are compared as the engine renders them,
  * so both sides of a parity comparison need engines that render alike. pglet
  * leaves an index's modifiers out of `pg_indexes.indexdef` — per-key sort
- * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — so a
- * pglet snapshot diffed against a PostgreSQL one reports every index that
- * uses one, with identical DDL on both sides. Take both snapshots on
- * PostgreSQL.
+ * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — and
+ * that misleads a comparison in both directions: a pglet snapshot diffed
+ * against a PostgreSQL one reports every index that uses a modifier, with
+ * identical DDL on both sides (a false difference), and two pglet snapshots
+ * agree when the two schemas differ only in a modifier (a false agreement).
+ * So `query_schema_snapshot` throws on pglet when the snapshot holds an
+ * index, unless the caller passes `accept_pglet_index_definitions`. Take both
+ * snapshots of a parity comparison on PostgreSQL.
  *
  * Paired with `testing/schema_parity.ts` for comparison + assertion helpers.
  *
@@ -170,6 +174,17 @@ export interface QuerySchemaSnapshotOptions {
      * consumer's domain schema.
      */
     readonly exclude_tables?: ReadonlyArray<string>;
+    /**
+     * Take the snapshot on pglet even though it holds indexes. Default `false`:
+     * pglet's `pg_indexes.indexdef` omits index modifiers (sort direction,
+     * `NULLS` placement, operator classes, `NULLS NOT DISTINCT`), so the
+     * snapshot's index definitions cannot be compared with another engine's,
+     * and do not tell two pglet schemas apart when they differ only in a
+     * modifier. Pass `true` only where no index definition is compared —
+     * reading tables, columns, constraints, sequences or enums off the
+     * snapshot. No effect on PostgreSQL or PGlite.
+     */
+    readonly accept_pglet_index_definitions?: boolean;
 }
 /**
  * Introspect a live database into a deterministic `SchemaSnapshot`.
@@ -180,6 +195,11 @@ export interface QuerySchemaSnapshotOptions {
  * The `schema_version` migration tracker never appears in the `tables`
  * field — it's framework bookkeeping created by the migration runner,
  * identical across consumers, and would only add noise.
+ *
+ * @param db - the database to introspect
+ * @param options - schema, table excludes, and the pglet opt-in
+ * @returns the snapshot, every collection sorted
+ * @throws Error on pglet when the snapshot holds an index and `accept_pglet_index_definitions` is not set — its index definitions omit modifiers, so a comparison built on them is wrong in both directions
  */
 export declare const query_schema_snapshot: (db: Db, options?: QuerySchemaSnapshotOptions) => Promise<SchemaSnapshot>;
 //# sourceMappingURL=schema_introspect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;iBAWzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,qCAAqC;AACrC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;iBAOxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAU,IAAI,EAAE,KAAG,OAAO,CAAC,gBAAgB,CAa9E,CAAC;AAEF,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChD;AA8DD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CAyHxB,CAAC"}
+{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;iBAWzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,qCAAqC;AACrC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;iBAOxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAU,IAAI,EAAE,KAAG,OAAO,CAAC,gBAAgB,CAa9E,CAAC;AAEF,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChD;;;;;;;;;OASG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAClD;AAiED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CA0IxB,CAAC"}

package/dist/testing/schema_introspect.js

@@ -21,10 +21,14 @@ import './assert_dev_env.js';
  * Index and constraint definitions are compared as the engine renders them,
  * so both sides of a parity comparison need engines that render alike. pglet
  * leaves an index's modifiers out of `pg_indexes.indexdef` — per-key sort
- * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — so a
- * pglet snapshot diffed against a PostgreSQL one reports every index that
- * uses one, with identical DDL on both sides. Take both snapshots on
- * PostgreSQL.
+ * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — and
+ * that misleads a comparison in both directions: a pglet snapshot diffed
+ * against a PostgreSQL one reports every index that uses a modifier, with
+ * identical DDL on both sides (a false difference), and two pglet snapshots
+ * agree when the two schemas differ only in a modifier (a false agreement).
+ * So `query_schema_snapshot` throws on pglet when the snapshot holds an
+ * index, unless the caller passes `accept_pglet_index_definitions`. Take both
+ * snapshots of a parity comparison on PostgreSQL.
  *
  * Paired with `testing/schema_parity.ts` for comparison + assertion helpers.
  *
@@ -136,6 +140,8 @@ export const query_migration_tracker = async (db) => {
         }))
     };
 };
+/** The marker pglet's `version()` carries. */
+const PGLET_VERSION_MARKER = '(pglet)';
 const sort_keys = (record) => {
     const sorted = {};
     for (const key of Object.keys(record).sort()) {
@@ -170,6 +176,11 @@ const contype_to_kind = (contype) => {
  * The `schema_version` migration tracker never appears in the `tables`
  * field — it's framework bookkeeping created by the migration runner,
  * identical across consumers, and would only add noise.
+ *
+ * @param db - the database to introspect
+ * @param options - schema, table excludes, and the pglet opt-in
+ * @returns the snapshot, every collection sorted
+ * @throws Error on pglet when the snapshot holds an index and `accept_pglet_index_definitions` is not set — its index definitions omit modifiers, so a comparison built on them is wrong in both directions
  */
 export const query_schema_snapshot = async (db, options = {}) => {
     const schema = options.schema ?? 'public';
@@ -260,6 +271,18 @@ export const query_schema_snapshot = async (db, options = {}) => {
     for (const row of enum_rows) {
         (enums[row.enum_name] ??= { labels: [] }).labels.push(row.label);
     }
+    if (!options.accept_pglet_index_definitions &&
+        Object.values(tables).some((table) => table.indexes.length > 0)) {
+        const [version_row] = await db.query(`SELECT version() AS version`);
+        if (version_row?.version.includes(PGLET_VERSION_MARKER)) {
+            throw new Error('query_schema_snapshot: this database is pglet, whose pg_indexes.indexdef omits index ' +
+                'modifiers (sort direction, NULLS placement, operator classes, NULLS NOT DISTINCT), so ' +
+                "the snapshot's index definitions report false differences against PostgreSQL and false " +
+                'agreement between two pglet schemas. Take the snapshot on PostgreSQL (a TS backend ' +
+                'config defaults to memory://, which is pglet), or pass ' +
+                '{accept_pglet_index_definitions: true} when no index definition is compared.');
+        }
+    }
     return {
         tables: sort_keys(tables),
         sequences: sort_keys(sequences),

package/dist/testing/transports/raw_http.d.ts

@@ -0,0 +1,78 @@
+import '../assert_dev_env.js';
+/** What a raw exchange read back, and how it ended. */
+export interface RawHttpExchange {
+    /** Every byte the server sent, `latin1`-decoded. */
+    readonly received: string;
+    /**
+     * `true` when the connection ended before the exchange stopped reading —
+     * the server closed it, or it never opened (a refused or unresolvable
+     * address reads as closed, with nothing received).
+     */
+    readonly closed_by_server: boolean;
+}
+/** Options for `raw_http_exchange`. */
+export interface RawHttpExchangeOptions {
+    /** How long to read before giving up on the server. */
+    readonly read_timeout_ms: number;
+    /**
+     * When the exchange stops reading. `'close'` reads until the server closes
+     * the connection; `'response'` stops as soon as one whole response has
+     * arrived (`raw_http_parse_response`), for a server that answers and then
+     * keeps the connection open. Either way the read timeout bounds it.
+     *
+     * `'response'` stops at the first response the bytes frame, so it is for a
+     * final response carrying `Content-Length` or chunked framing: a `1xx`
+     * interim response ends the read, and so does the head of a response
+     * delimited by the connection closing, before its body.
+     *
+     * @default 'close'
+     */
+    readonly until?: 'close' | 'response';
+}
+/** One parsed HTTP/1.1 response. */
+export interface RawHttpResponse {
+    readonly status: number;
+    /** Response headers, names lowercased; a repeated name keeps its last value. */
+    readonly headers: Readonly<Record<string, string>>;
+    /** The response body, with any chunked framing removed. */
+    readonly body: string;
+}
+/**
+ * Open a raw TCP socket to `base_url`, write `request_bytes` once, and collect
+ * what the server sends back until it closes the connection, a whole response
+ * has arrived (`until: 'response'`), or `read_timeout_ms` elapses.
+ *
+ * Write errors are swallowed: a server that refuses a request and closes
+ * mid-upload surfaces as `EPIPE` / `ECONNRESET` on the unfinished write, and
+ * what a caller asserts on is what was read back. A write error also ends the
+ * socket, so bytes the server sent just before it can go unread — a caller
+ * that needs to read a refusal reliably sends nothing the server will leave
+ * unread.
+ *
+ * @param base_url - the server's base URL; only its host and port are used
+ * @param request_bytes - the bytes to send, `latin1`-encoded
+ */
+export declare const raw_http_exchange: (base_url: string, request_bytes: string, options: RawHttpExchangeOptions) => Promise<RawHttpExchange>;
+/**
+ * Count HTTP response status lines in a raw byte stream. Deliberately
+ * **unanchored** (no `^`/`m`): a second pipelined response is concatenated
+ * straight after the first response's body, which carries no trailing newline,
+ * so a line-anchored match would miss it — and missing a smuggled second
+ * response is a silent false negative. It counts exactly the status lines as
+ * long as no response header or body contains the literal `HTTP/1.x NNN`.
+ */
+export declare const raw_http_count_responses: (raw: string) => number;
+/** The status code of the first HTTP response in a raw byte stream, or `null` if none. */
+export declare const raw_http_first_status: (raw: string) => number | null;
+/**
+ * Parse the first response in a raw byte stream, once all of it has arrived.
+ *
+ * The body is delimited by `Transfer-Encoding: chunked` or `Content-Length`.
+ * A response carrying neither is delimited by the connection closing, which
+ * the bytes alone don't show, so its body is whatever followed the head.
+ *
+ * @param raw - the bytes read so far, `latin1`-decoded
+ * @returns the response, or `null` when the head or the framed body is incomplete
+ */
+export declare const raw_http_parse_response: (raw: string) => RawHttpResponse | null;
+//# sourceMappingURL=raw_http.d.ts.map

package/dist/testing/transports/raw_http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw_http.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/transports/raw_http.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACnC;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;CACtC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC7B,UAAU,MAAM,EAChB,eAAe,MAAM,EACrB,SAAS,sBAAsB,KAC7B,OAAO,CAAC,eAAe,CAwBvB,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,KAAG,MACN,CAAC;AAElD,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,IAG5D,CAAC;AAyBF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,MAAM,KAAG,eAAe,GAAG,IAyBvE,CAAC"}

package/dist/testing/transports/raw_http.js

@@ -0,0 +1,141 @@
+import '../assert_dev_env.js';
+/**
+ * Raw-socket HTTP/1.1 exchanges, for tests that need to control exactly which
+ * bytes reach the server.
+ *
+ * `fetch` frames a request itself and sends all of it, so some server
+ * behaviors can't be reached through it: what a server does with two requests
+ * in one write, with duplicate or malformed headers, with a request head whose
+ * body never follows, or with a chunked body that is never terminated. This
+ * writes caller-built bytes over `node:net` and hands back what the server
+ * sent, plus just enough parsing to read a status or one whole response.
+ *
+ * Everything is `latin1`-decoded, so a string's length is its byte length.
+ *
+ * Plain TCP only: an `https:` URL is not spoken to over TLS, and the host must
+ * be a name or an IPv4 address — a bracketed IPv6 literal does not connect.
+ *
+ * @module
+ */
+import { connect } from 'node:net';
+/**
+ * Open a raw TCP socket to `base_url`, write `request_bytes` once, and collect
+ * what the server sends back until it closes the connection, a whole response
+ * has arrived (`until: 'response'`), or `read_timeout_ms` elapses.
+ *
+ * Write errors are swallowed: a server that refuses a request and closes
+ * mid-upload surfaces as `EPIPE` / `ECONNRESET` on the unfinished write, and
+ * what a caller asserts on is what was read back. A write error also ends the
+ * socket, so bytes the server sent just before it can go unread — a caller
+ * that needs to read a refusal reliably sends nothing the server will leave
+ * unread.
+ *
+ * @param base_url - the server's base URL; only its host and port are used
+ * @param request_bytes - the bytes to send, `latin1`-encoded
+ */
+export const raw_http_exchange = (base_url, request_bytes, options) => new Promise((resolve) => {
+    const { read_timeout_ms, until = 'close' } = options;
+    const url = new URL(base_url);
+    const port = Number(url.port) || (url.protocol === 'https:' ? 443 : 80);
+    const socket = connect({ host: url.hostname, port });
+    let received = '';
+    let settled = false;
+    const finish = (closed_by_server) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve({ received, closed_by_server });
+    };
+    const timer = setTimeout(() => finish(false), read_timeout_ms);
+    socket.setEncoding('latin1');
+    socket.on('connect', () => socket.write(request_bytes, 'latin1'));
+    socket.on('data', (chunk) => {
+        received += chunk;
+        if (until === 'response' && raw_http_parse_response(received))
+            finish(false);
+    });
+    socket.on('error', () => { }); // EPIPE/ECONNRESET on a mid-write close is expected
+    socket.on('close', () => finish(true));
+});
+/**
+ * Count HTTP response status lines in a raw byte stream. Deliberately
+ * **unanchored** (no `^`/`m`): a second pipelined response is concatenated
+ * straight after the first response's body, which carries no trailing newline,
+ * so a line-anchored match would miss it — and missing a smuggled second
+ * response is a silent false negative. It counts exactly the status lines as
+ * long as no response header or body contains the literal `HTTP/1.x NNN`.
+ */
+export const raw_http_count_responses = (raw) => (raw.match(/HTTP\/1\.[01] \d{3}/g) ?? []).length;
+/** The status code of the first HTTP response in a raw byte stream, or `null` if none. */
+export const raw_http_first_status = (raw) => {
+    const match = /HTTP\/1\.[01] (\d{3})/.exec(raw);
+    return match ? Number(match[1]) : null;
+};
+/**
+ * Remove chunked framing from a body.
+ *
+ * @returns the decoded body, or `null` when the terminating chunk hasn't arrived
+ */
+const decode_chunked = (raw) => {
+    let body = '';
+    let offset = 0;
+    for (;;) {
+        const line_end = raw.indexOf('\r\n', offset);
+        if (line_end === -1)
+            return null;
+        // a chunk-size line may carry `;extension`s after the hex size
+        const size = Number.parseInt(raw.slice(offset, line_end), 16);
+        if (!Number.isFinite(size))
+            return null;
+        const data_start = line_end + 2;
+        // the last chunk is followed by optional trailers and an empty line
+        if (size === 0)
+            return raw.includes('\r\n\r\n', line_end) ? body : null;
+        if (raw.length < data_start + size + 2)
+            return null;
+        body += raw.slice(data_start, data_start + size);
+        offset = data_start + size + 2;
+    }
+};
+/**
+ * Parse the first response in a raw byte stream, once all of it has arrived.
+ *
+ * The body is delimited by `Transfer-Encoding: chunked` or `Content-Length`.
+ * A response carrying neither is delimited by the connection closing, which
+ * the bytes alone don't show, so its body is whatever followed the head.
+ *
+ * @param raw - the bytes read so far, `latin1`-decoded
+ * @returns the response, or `null` when the head or the framed body is incomplete
+ */
+export const raw_http_parse_response = (raw) => {
+    const head_end = raw.indexOf('\r\n\r\n');
+    if (head_end === -1)
+        return null;
+    const [status_line, ...header_lines] = raw.slice(0, head_end).split('\r\n');
+    const status_match = /^HTTP\/1\.[01] (\d{3})/.exec(status_line);
+    if (!status_match)
+        return null;
+    const headers = {};
+    for (const line of header_lines) {
+        const colon = line.indexOf(':');
+        if (colon <= 0)
+            continue;
+        headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+    }
+    const status = Number(status_match[1]);
+    const rest = raw.slice(head_end + 4);
+    if (headers['transfer-encoding']?.toLowerCase().includes('chunked')) {
+        const body = decode_chunked(rest);
+        return body === null ? null : { status, headers, body };
+    }
+    const content_length = headers['content-length'];
+    if (content_length !== undefined) {
+        const length = Number(content_length);
+        if (!Number.isSafeInteger(length) || length < 0 || rest.length < length)
+            return null;
+        return { status, headers, body: rest.slice(0, length) };
+    }
+    return { status, headers, body: rest };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.135.0",
+  "version": "0.136.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",