sliccy 6.112.1 → 6.112.3

package/dist/node-server/bridge-security.d.ts

@@ -161,3 +161,12 @@ export declare function buildCorsHeaders(origin: string | undefined | null, requ
  * — Chrome blocks public→private fetch / WS otherwise.
  */
 export declare function buildPnaPreflightHeaders(): Record<string, string>;
+/**
+ * Preflight cache lifetime. `/api/hostfs/*` gets Chrome's cap (7200s) because
+ * the mounted-filesystem traffic is thousands of requests per command and
+ * every one of them is non-simple (bridge-token header) plus public→loopback
+ * (Chrome's Private Network Access preflight) — see #2715. The rest of /api
+ * keeps the conservative 10 minutes: those routes are low-volume, and a short
+ * window bounds how long a stale allowed-header set can linger.
+ */
+export declare function preflightMaxAge(path: string): string;

package/dist/node-server/bridge-security.js

@@ -332,3 +332,14 @@ export function buildCorsHeaders(origin, requestHeadersHeader) {
 export function buildPnaPreflightHeaders() {
     return { 'Access-Control-Allow-Private-Network': 'true' };
 }
+/**
+ * Preflight cache lifetime. `/api/hostfs/*` gets Chrome's cap (7200s) because
+ * the mounted-filesystem traffic is thousands of requests per command and
+ * every one of them is non-simple (bridge-token header) plus public→loopback
+ * (Chrome's Private Network Access preflight) — see #2715. The rest of /api
+ * keeps the conservative 10 minutes: those routes are low-volume, and a short
+ * window bounds how long a stale allowed-header set can linger.
+ */
+export function preflightMaxAge(path) {
+    return path === '/api/hostfs' || path.startsWith('/api/hostfs/') ? '7200' : '600';
+}

package/dist/node-server/fetch-proxy-headers.d.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage } from 'http';
 /**
  * Headers the `/api/fetch-proxy` route does NOT forward upstream.
  *
@@ -66,3 +67,15 @@ export declare const FETCH_PROXY_BASE_EXPOSE_HEADERS: readonly string[];
  * Dedupes case-insensitively while preserving the first-seen spelling.
  */
 export declare function buildFetchProxyExposeHeaders(forwardedHeaderNames: Iterable<string>): string;
+/**
+ * Which requests the global `express.json()` consumes. Two exclusions:
+ *
+ *   - `X-Slicc-Raw-Body: 1` — SigV4-signed bodies must reach the
+ *     /api/fetch-proxy handler byte-for-byte (the parser would re-serialize
+ *     them via JSON.stringify and break the signature);
+ *   - the stable hostfs dispatcher — it owns a bounded 1 MiB parser and an
+ *     errno error adapter, and this parser is mounted ahead of
+ *     `registerHostFsRoutes`, so without the exclusion it would consume the
+ *     body first and answer a malformed one with code-less HTML.
+ */
+export declare function shouldParseGlobalJson(req: IncomingMessage): boolean;

package/dist/node-server/fetch-proxy-headers.js

@@ -1,3 +1,4 @@
+import { isHostFsStableBodyRequest } from './hostfs.js';
 /**
  * Headers the `/api/fetch-proxy` route does NOT forward upstream.
  *
@@ -111,3 +112,21 @@ export function buildFetchProxyExposeHeaders(forwardedHeaderNames) {
     }
     return out.join(', ');
 }
+/**
+ * Which requests the global `express.json()` consumes. Two exclusions:
+ *
+ *   - `X-Slicc-Raw-Body: 1` — SigV4-signed bodies must reach the
+ *     /api/fetch-proxy handler byte-for-byte (the parser would re-serialize
+ *     them via JSON.stringify and break the signature);
+ *   - the stable hostfs dispatcher — it owns a bounded 1 MiB parser and an
+ *     errno error adapter, and this parser is mounted ahead of
+ *     `registerHostFsRoutes`, so without the exclusion it would consume the
+ *     body first and answer a malformed one with code-less HTML.
+ */
+export function shouldParseGlobalJson(req) {
+    if (req.headers['x-slicc-raw-body'] === '1')
+        return false;
+    if (isHostFsStableBodyRequest(req))
+        return false;
+    return (req.headers['content-type'] ?? '').includes('application/json');
+}

package/dist/node-server/hostfs.d.ts

@@ -14,6 +14,31 @@
  * Protected like every other /api route: same-origin / loopback callers
  * pass, cross-origin callers need the bridge token (see
  * `createThinBridgeCorsMiddleware` in index.ts).
+ *
+ * Two request shapes reach the same handlers:
+ *
+ *   - the per-op routes (`GET /api/hostfs/list?mount=&path=` …), kept for
+ *     compatibility and used for the body ops (`read`, `write`);
+ *   - a single stable `POST /api/hostfs` whose JSON body carries
+ *     `{ op, mount, path, … }`.
+ *
+ * The stable endpoint exists purely to make CORS preflights cacheable. The
+ * bridge token travels as a custom header, so every cross-origin hostfs call
+ * is a non-simple request, and Chrome's Private Network Access preflights
+ * public→loopback traffic regardless — but the preflight cache is keyed by
+ * URL, and the per-op URLs are unique per path, so `Access-Control-Max-Age`
+ * never got a chance to help (issue #2715: 246,893 `OPTIONS` for 385,033
+ * `GET`s in one session). One stable URL collapses that to one preflight per
+ * max-age. `read` deliberately stays a `GET` on a per-file URL so the
+ * browser HTTP cache can still revalidate large blobs with a 304.
+ *
+ * The hostfs surface owns its own body parsing end to end. `index.ts` skips
+ * the stable dispatcher in its global `express.json()` filter (via
+ * `isHostFsStableBodyRequest`) so the bounded 1 MiB parser here is the one
+ * that runs, and `hostFsBodyErrorHandler` maps body-parser failures to the
+ * same `{ code, message }` errno shape as every other error on this surface —
+ * otherwise express's default handler answers malformed JSON with code-less
+ * HTML and the webapp cannot rethrow a faithful `FsError`.
  */
 import type { Express } from 'express';
 import type { HostMountMapping } from './runtime-flags.js';
@@ -40,19 +65,50 @@ interface HostMountRoot {
  * webapp will surface the absent mount as "not mounted".
  */
 export declare function resolveHostMountRoots(mounts: readonly HostMountMapping[], warn?: (msg: string) => void): Promise<HostMountRoot[]>;
+/**
+ * Bounded body cap for the stable dispatcher — it only ever carries a small
+ * JSON envelope, so it has no business inheriting the global 50 MiB limit.
+ */
+export declare const HOSTFS_STABLE_MAX_BODY_BYTES: number;
+/**
+ * True for a request `index.ts`'s global `express.json()` must NOT consume.
+ * The global parser is mounted before these routes with a 50 MiB limit, so
+ * without this exclusion it would swallow the stable dispatcher's body first:
+ * the route-local 1 MiB cap would never apply, and a malformed body would
+ * fail in the global parser and reach express's default (code-less HTML)
+ * handler instead of the errno shape every hostfs caller expects. Exported so
+ * `index.ts` and the middleware-order test filter identically.
+ */
+export declare function isHostFsStableBodyRequest(req: {
+    method?: string;
+    url?: string;
+}): boolean;
 /**
  * Register the /api/hostfs routes for the resolved mount roots. The route
  * surface mirrors `MountBackend` 1:1 (webapp `backend-hostfs.ts`):
  *
+ *   POST   /api/hostfs           ← { op, mount, path, to?, recursive? }
  *   GET    /api/hostfs/list?mount=&path=          → { entries: [...] }
  *   GET    /api/hostfs/stat?mount=&path=          → { kind, size, mtime }
  *   GET    /api/hostfs/read?mount=&path=          → octet-stream body
  *   PUT    /api/hostfs/write?mount=&path=         ← octet-stream body
  *   POST   /api/hostfs/mkdir?mount=&path=
+ *   POST   /api/hostfs/rename?mount=&path=&to=
  *   DELETE /api/hostfs/remove?mount=&path=[&recursive=1]
  *
+ * `POST /api/hostfs` is the preflight-cacheable form of `list`/`stat`/
+ * `mkdir`/`rename`/`remove` — one URL for all of them, so one CORS preflight
+ * covers the whole `Access-Control-Max-Age` window instead of one per path
+ * (#2715). It is purely a transport change: same handlers, same payloads,
+ * same errno JSON. The per-op routes stay for compatibility (older webapps,
+ * `curl`) and remain the only form for the two body ops.
+ *
  * Errors are `{ code, message }` JSON with an errno-derived status so the
- * webapp backend can rethrow faithful `FsError`s.
+ * webapp backend can rethrow faithful `FsError`s — including body-parser
+ * failures, via `hostFsBodyErrorHandler` registered at the end. A bridge that
+ * predates the stable endpoint answers `POST /api/hostfs` with a framework 404
+ * that has no `code`, which is how the webapp detects it and falls back to the
+ * per-op routes — so every error this route emits MUST carry a `code`.
  */
 export declare function registerHostFsRoutes(app: Express, roots: readonly HostMountRoot[]): void;
 export {};

package/dist/node-server/hostfs.js

@@ -14,6 +14,31 @@
  * Protected like every other /api route: same-origin / loopback callers
  * pass, cross-origin callers need the bridge token (see
  * `createThinBridgeCorsMiddleware` in index.ts).
+ *
+ * Two request shapes reach the same handlers:
+ *
+ *   - the per-op routes (`GET /api/hostfs/list?mount=&path=` …), kept for
+ *     compatibility and used for the body ops (`read`, `write`);
+ *   - a single stable `POST /api/hostfs` whose JSON body carries
+ *     `{ op, mount, path, … }`.
+ *
+ * The stable endpoint exists purely to make CORS preflights cacheable. The
+ * bridge token travels as a custom header, so every cross-origin hostfs call
+ * is a non-simple request, and Chrome's Private Network Access preflights
+ * public→loopback traffic regardless — but the preflight cache is keyed by
+ * URL, and the per-op URLs are unique per path, so `Access-Control-Max-Age`
+ * never got a chance to help (issue #2715: 246,893 `OPTIONS` for 385,033
+ * `GET`s in one session). One stable URL collapses that to one preflight per
+ * max-age. `read` deliberately stays a `GET` on a per-file URL so the
+ * browser HTTP cache can still revalidate large blobs with a 304.
+ *
+ * The hostfs surface owns its own body parsing end to end. `index.ts` skips
+ * the stable dispatcher in its global `express.json()` filter (via
+ * `isHostFsStableBodyRequest`) so the bounded 1 MiB parser here is the one
+ * that runs, and `hostFsBodyErrorHandler` maps body-parser failures to the
+ * same `{ code, message }` errno shape as every other error on this surface —
+ * otherwise express's default handler answers malformed JSON with code-less
+ * HTML and the webapp cannot rethrow a faithful `FsError`.
  */
 import express from 'express';
 import { lstat, mkdir, readdir, readFile, realpath, rename, rm, stat, writeFile, } from 'fs/promises';
@@ -124,19 +149,138 @@ function queryString(req, name) {
     const value = req.query[name];
     return typeof value === 'string' && value.length > 0 ? value : null;
 }
+/** Path of the stable dispatcher. */
+const HOSTFS_STABLE_PATH = '/api/hostfs';
+/**
+ * Bounded body cap for the stable dispatcher — it only ever carries a small
+ * JSON envelope, so it has no business inheriting the global 50 MiB limit.
+ */
+export const HOSTFS_STABLE_MAX_BODY_BYTES = 1024 * 1024;
+function isHostFsPath(path) {
+    return path === HOSTFS_STABLE_PATH || path.startsWith(`${HOSTFS_STABLE_PATH}/`);
+}
+/**
+ * True for a request `index.ts`'s global `express.json()` must NOT consume.
+ * The global parser is mounted before these routes with a 50 MiB limit, so
+ * without this exclusion it would swallow the stable dispatcher's body first:
+ * the route-local 1 MiB cap would never apply, and a malformed body would
+ * fail in the global parser and reach express's default (code-less HTML)
+ * handler instead of the errno shape every hostfs caller expects. Exported so
+ * `index.ts` and the middleware-order test filter identically.
+ */
+export function isHostFsStableBodyRequest(req) {
+    if (req.method !== 'POST')
+        return false;
+    const path = (req.url ?? '').split('?')[0];
+    return path === HOSTFS_STABLE_PATH || path === `${HOSTFS_STABLE_PATH}/`;
+}
+/**
+ * Map body-parser failures on the hostfs surface to `{ code, message }`.
+ * Registered after the routes (express only runs an error handler for
+ * middleware mounted before it), so it catches the stable dispatcher's JSON
+ * parser AND `PUT /write`'s raw parser. Mirrors swift-server, which answers
+ * 400 `EINVAL` for an unparseable body and 413 `EFBIG` for an oversized one.
+ * Anything that is not a body-parser error, and every non-hostfs path, is
+ * passed through untouched.
+ */
+const hostFsBodyErrorHandler = (err, req, res, next) => {
+    const type = err?.type;
+    if (typeof type !== 'string' || res.headersSent || !isHostFsPath(req.path)) {
+        next(err);
+        return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    if (type === 'entity.too.large') {
+        res.status(413).json({ code: 'EFBIG', message: `hostfs body too large: ${message}` });
+        return;
+    }
+    res.status(400).json({ code: 'EINVAL', message: `hostfs body rejected: ${message}` });
+};
+/** Ops reachable through the stable `POST /api/hostfs` endpoint. */
+const STABLE_OPS = ['list', 'stat', 'mkdir', 'rename', 'remove'];
+function isStableOp(value) {
+    return typeof value === 'string' && STABLE_OPS.includes(value);
+}
+function bodyString(body, name) {
+    const value = body[name];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/** `recursive` accepts the query-string `'1'` and a JSON `true` alike. */
+function isRecursive(value) {
+    return value === true || value === '1' || value === 1;
+}
+/** `readdir` + a stat per entry, so consumers get size/mtime without an N+1. */
+async function listOp(target) {
+    const dirents = await readdir(target, { withFileTypes: true });
+    const entries = await Promise.all(dirents.map(async (d) => {
+        if (d.isDirectory())
+            return { name: d.name, kind: 'directory' };
+        try {
+            // stat() follows symlinks, so a link to a directory classifies as
+            // a directory — matching what every subsequent access sees (and
+            // the swift server, whose fileExists follows links). Escaping
+            // links are still refused at access time by resolveWithinRoot.
+            const s = await stat(resolve(target, d.name));
+            if (s.isDirectory())
+                return { name: d.name, kind: 'directory' };
+            return {
+                name: d.name,
+                kind: 'file',
+                size: s.size,
+                lastModified: Math.round(s.mtimeMs),
+            };
+        }
+        catch {
+            // Raced deletion / dangling link / unreadable: name only.
+            return { name: d.name, kind: 'file' };
+        }
+    }));
+    return { entries };
+}
+async function statOp(target) {
+    return statPayload(await stat(target));
+}
+async function mkdirOp(target) {
+    await mkdir(target, { recursive: true });
+    return { ok: true };
+}
+async function renameOp(from, to) {
+    await rename(from, to);
+    return { ok: true };
+}
+async function removeOp(target, recursive, roots) {
+    if (roots.some((r) => r.root === target)) {
+        throw Object.assign(new Error('refusing to remove a mount root'), { code: 'EACCES' });
+    }
+    await rm(target, { recursive, force: false });
+    return { ok: true };
+}
 /**
  * Register the /api/hostfs routes for the resolved mount roots. The route
  * surface mirrors `MountBackend` 1:1 (webapp `backend-hostfs.ts`):
  *
+ *   POST   /api/hostfs           ← { op, mount, path, to?, recursive? }
  *   GET    /api/hostfs/list?mount=&path=          → { entries: [...] }
  *   GET    /api/hostfs/stat?mount=&path=          → { kind, size, mtime }
  *   GET    /api/hostfs/read?mount=&path=          → octet-stream body
  *   PUT    /api/hostfs/write?mount=&path=         ← octet-stream body
  *   POST   /api/hostfs/mkdir?mount=&path=
+ *   POST   /api/hostfs/rename?mount=&path=&to=
  *   DELETE /api/hostfs/remove?mount=&path=[&recursive=1]
  *
+ * `POST /api/hostfs` is the preflight-cacheable form of `list`/`stat`/
+ * `mkdir`/`rename`/`remove` — one URL for all of them, so one CORS preflight
+ * covers the whole `Access-Control-Max-Age` window instead of one per path
+ * (#2715). It is purely a transport change: same handlers, same payloads,
+ * same errno JSON. The per-op routes stay for compatibility (older webapps,
+ * `curl`) and remain the only form for the two body ops.
+ *
  * Errors are `{ code, message }` JSON with an errno-derived status so the
- * webapp backend can rethrow faithful `FsError`s.
+ * webapp backend can rethrow faithful `FsError`s — including body-parser
+ * failures, via `hostFsBodyErrorHandler` registered at the end. A bridge that
+ * predates the stable endpoint answers `POST /api/hostfs` with a framework 404
+ * that has no `code`, which is how the webapp detects it and falls back to the
+ * per-op routes — so every error this route emits MUST carry a `code`.
  */
 export function registerHostFsRoutes(app, roots) {
     const byPath = new Map(roots.map((r) => [r.path, r]));
@@ -160,35 +304,58 @@ export function registerHostFsRoutes(app, roots) {
             })();
         };
     };
-    app.get('/api/hostfs/list', withTarget(async (target, _req, res) => {
-        const dirents = await readdir(target, { withFileTypes: true });
-        const entries = await Promise.all(dirents.map(async (d) => {
-            if (d.isDirectory())
-                return { name: d.name, kind: 'directory' };
+    // Stable-URL dispatcher. Mounted before the per-op routes so `/api/hostfs`
+    // is matched exactly; express keeps `/api/hostfs/mkdir` distinct.
+    app.post(HOSTFS_STABLE_PATH, express.json({ limit: HOSTFS_STABLE_MAX_BODY_BYTES }), (req, res) => {
+        void (async () => {
+            const body = (req.body ?? {});
+            const op = body.op;
+            if (!isStableOp(op)) {
+                res.status(400).json({ code: 'EINVAL', message: `unsupported hostfs op: ${String(op)}` });
+                return;
+            }
+            const mount = bodyString(body, 'mount');
+            const entry = mount ? byPath.get(mount) : undefined;
+            if (!entry) {
+                res.status(404).json({ code: 'ENOENT', message: `no such mount: ${mount ?? ''}` });
+                return;
+            }
             try {
-                // stat() follows symlinks, so a link to a directory classifies as
-                // a directory — matching what every subsequent access sees (and
-                // the swift server, whose fileExists follows links). Escaping
-                // links are still refused at access time by resolveWithinRoot.
-                const s = await stat(resolve(target, d.name));
-                if (s.isDirectory())
-                    return { name: d.name, kind: 'directory' };
-                return {
-                    name: d.name,
-                    kind: 'file',
-                    size: s.size,
-                    lastModified: Math.round(s.mtimeMs),
-                };
+                const target = await resolveWithinRoot(entry.root, bodyString(body, 'path') ?? '');
+                switch (op) {
+                    case 'list':
+                        res.json(await listOp(target));
+                        return;
+                    case 'stat':
+                        res.json(await statOp(target));
+                        return;
+                    case 'mkdir':
+                        res.json(await mkdirOp(target));
+                        return;
+                    case 'rename': {
+                        const toRel = bodyString(body, 'to');
+                        if (!toRel) {
+                            res.status(400).json({ code: 'EINVAL', message: 'rename requires to' });
+                            return;
+                        }
+                        res.json(await renameOp(target, await resolveWithinRoot(entry.root, toRel)));
+                        return;
+                    }
+                    case 'remove':
+                        res.json(await removeOp(target, isRecursive(body.recursive), roots));
+                        return;
+                }
             }
-            catch {
-                // Raced deletion / dangling link / unreadable: name only.
-                return { name: d.name, kind: 'file' };
+            catch (err) {
+                sendFsError(res, err);
             }
-        }));
-        res.json({ entries });
+        })();
+    });
+    app.get('/api/hostfs/list', withTarget(async (target, _req, res) => {
+        res.json(await listOp(target));
     }));
     app.get('/api/hostfs/stat', withTarget(async (target, _req, res) => {
-        res.json(statPayload(await stat(target)));
+        res.json(await statOp(target));
     }));
     app.get('/api/hostfs/read', withTarget(async (target, _req, res) => {
         // lstat first so a dangling symlink is ENOENT, a directory is EISDIR.
@@ -229,8 +396,7 @@ export function registerHostFsRoutes(app, roots) {
         res.json({ ok: true });
     }));
     app.post('/api/hostfs/mkdir', withTarget(async (target, _req, res) => {
-        await mkdir(target, { recursive: true });
-        res.json({ ok: true });
+        res.json(await mkdirOp(target));
     }));
     app.post('/api/hostfs/rename', withTarget(async (target, req, res) => {
         const mount = queryString(req, 'mount');
@@ -240,18 +406,11 @@ export function registerHostFsRoutes(app, roots) {
             res.status(400).json({ code: 'EINVAL', message: 'rename requires mount and to' });
             return;
         }
-        const to = await resolveWithinRoot(entry.root, toRel);
-        await rename(target, to);
-        res.json({ ok: true });
+        res.json(await renameOp(target, await resolveWithinRoot(entry.root, toRel)));
     }));
     app.delete('/api/hostfs/remove', withTarget(async (target, req, res) => {
-        const isRoot = roots.some((r) => r.root === target);
-        if (isRoot) {
-            res.status(403).json({ code: 'EACCES', message: 'refusing to remove a mount root' });
-            return;
-        }
-        const recursive = queryString(req, 'recursive') === '1';
-        await rm(target, { recursive, force: false });
-        res.json({ ok: true });
+        res.json(await removeOp(target, queryString(req, 'recursive') === '1', roots));
     }));
+    // Last: only reachable for errors raised by middleware mounted above it.
+    app.use(hostFsBodyErrorHandler);
 }

package/dist/node-server/index.js

@@ -11,7 +11,7 @@ import { homedir } from 'os';
 import { basename, dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { WebSocket, WebSocketServer } from 'ws';
-import { BRIDGE_TOKEN_HEADER, buildCorsHeaders, buildPnaPreflightHeaders, isLoopbackBridgeOrigin, resolveServerBridgeToken, selectBridgeSubprotocol, shouldMountThinBridgeCors, validateBridgeToken, validateBridgeUpgrade, } from './bridge-security.js';
+import { BRIDGE_TOKEN_HEADER, buildCorsHeaders, buildPnaPreflightHeaders, isLoopbackBridgeOrigin, preflightMaxAge, resolveServerBridgeToken, selectBridgeSubprotocol, shouldMountThinBridgeCors, validateBridgeToken, validateBridgeUpgrade, } from './bridge-security.js';
 import { closeLaunchedBrowserGracefully } from './browser-shutdown.js';
 import { applyCdpUnmask } from './cdp-proxy/cdp-unmask.js';
 import { createCdpSessionUrlTracker } from './cdp-proxy/session-url-tracker.js';
@@ -28,6 +28,7 @@ import { registerCloudStatusEndpoint } from './cloud-status.js';
 import { ElectronAppAlreadyRunningError, ElectronOverlayInjector, launchElectronApp, resolveOverlayThinBridge, } from './electron-controller.js';
 import { getElectronAppPorts } from './electron-runtime.js';
 import { ElectronTrayFollower } from './electron-tray-follower.js';
+import { shouldParseGlobalJson } from './fetch-proxy-headers.js';
 import { FileLogger } from './file-logger.js';
 import { registerHostedBootstrapEndpoint } from './hosted-bootstrap.js';
 import { registerHostFsRoutes, resolveHostMountRoots } from './hostfs.js';
@@ -1018,7 +1019,7 @@ function createThinBridgeCorsMiddleware(bridgeToken) {
         if (req.method === 'OPTIONS' && cors) {
             for (const [k, v] of Object.entries(buildPnaPreflightHeaders()))
                 res.setHeader(k, v);
-            res.setHeader('Access-Control-Max-Age', '600');
+            res.setHeader('Access-Control-Max-Age', preflightMaxAge(req.path));
             res.status(204).end();
             return;
         }
@@ -1084,15 +1085,9 @@ async function main() {
     const { lickWss, broadcastLickEvent } = lickBridge;
     // OAuth callback — generic redirect target for OAuth providers (implicit + PKCE)
     registerOAuthCallbackRoutes(app);
-    // Global JSON body parser. Skipped when the request carries
-    // `X-Slicc-Raw-Body: 1`, so SigV4-signed bodies survive into the
-    // /api/fetch-proxy handler byte-for-byte (the parser would otherwise
-    // re-serialize them via JSON.stringify, breaking the signature).
-    app.use(express.json({
-        limit: '50mb',
-        type: (req) => req.headers['x-slicc-raw-body'] !== '1' &&
-            (req.headers['content-type'] ?? '').includes('application/json'),
-    }));
+    // Global JSON body parser; `shouldParseGlobalJson` owns the exclusions
+    // (SigV4 raw bodies, the stable hostfs dispatcher).
+    app.use(express.json({ limit: '50mb', type: shouldParseGlobalJson }));
     app.get('/api/runtime-config', (_req, res) => {
         res.json({
             trayWorkerBaseUrl: