@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/analytics-path-key.js

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The map key a request path is counted under inside a day-counter document
+ * (`hosts/{hostId}/analytics/{YYYY-MM-DD}`, field `paths`).
+ *
+ * ## Why this is shared rather than inlined at the writer
+ *
+ * It began as a private helper in the tenant's `/api/analytics/collect`
+ * route, which was fine while the only reader listed the whole map — the host
+ * traffic card renders `Object.entries(paths)` and never has to BUILD a key.
+ *
+ * The content entry's traffic card does (AGL-2498): it holds one entry's
+ * public path and looks that single key up. A second, hand-copied
+ * `.replace(/[.$#[\]]/g, '_')` is exactly the kind of twin that drifts by one
+ * character and then reports a real page as zero views — and a swallowed
+ * lookup renders as a MEASURED zero, which is indistinguishable from "nobody
+ * read it". So the rule lives in one place and both sides call it.
+ *
+ * ## What it does, and why
+ *
+ * Firestore map keys cannot be parsed as field paths on read when they carry
+ * `.`, `$`, `#`, `[` or `]`, so those are folded to `_`. The value is capped
+ * at 200 characters because a path is attacker-supplied and a map key is
+ * unbounded otherwise. An empty path counts as `/` — the home page, which is
+ * what an empty path means to a router.
+ *
+ * ⚠️ The substitution is LOSSY and deliberately so: `/a.b` and `/a_b` share a
+ * key. That was already true of every count ever written, so it cannot be
+ * fixed here without orphaning the history; a reader must not "improve" it.
+ */ export const analyticsPathKey = (path)=>(path || '/').slice(0, 200).replace(/[.$#[\]]/g, '_');
+
+//# sourceMappingURL=analytics-path-key.js.map

package/src/lib/app-utils/analytics-path-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/analytics-path-key.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The map key a request path is counted under inside a day-counter document\n * (`hosts/{hostId}/analytics/{YYYY-MM-DD}`, field `paths`).\n *\n * ## Why this is shared rather than inlined at the writer\n *\n * It began as a private helper in the tenant's `/api/analytics/collect`\n * route, which was fine while the only reader listed the whole map — the host\n * traffic card renders `Object.entries(paths)` and never has to BUILD a key.\n *\n * The content entry's traffic card does (AGL-2498): it holds one entry's\n * public path and looks that single key up. A second, hand-copied\n * `.replace(/[.$#[\\]]/g, '_')` is exactly the kind of twin that drifts by one\n * character and then reports a real page as zero views — and a swallowed\n * lookup renders as a MEASURED zero, which is indistinguishable from \"nobody\n * read it\". So the rule lives in one place and both sides call it.\n *\n * ## What it does, and why\n *\n * Firestore map keys cannot be parsed as field paths on read when they carry\n * `.`, `$`, `#`, `[` or `]`, so those are folded to `_`. The value is capped\n * at 200 characters because a path is attacker-supplied and a map key is\n * unbounded otherwise. An empty path counts as `/` — the home page, which is\n * what an empty path means to a router.\n *\n * ⚠️ The substitution is LOSSY and deliberately so: `/a.b` and `/a_b` share a\n * key. That was already true of every count ever written, so it cannot be\n * fixed here without orphaning the history; a reader must not \"improve\" it.\n */\nexport const analyticsPathKey = (path: string): string =>\n  (path || '/').slice(0, 200).replace(/[.$#[\\]]/g, '_')\n"],"names":["analyticsPathKey","path","slice","replace"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,MAAMA,mBAAmB,CAACC,OAC/B,AAACA,CAAAA,QAAQ,GAAE,EAAGC,KAAK,CAAC,GAAG,KAAKC,OAAO,CAAC,aAAa,KAAI"}

package/src/lib/app-utils/api-adapter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { PluginApiRequest } from './api-plugins';
+/**
+ * A node-style API handler runnable through {@link runLegacyHandler}. Both
+ * the framework-light `PluginApiHandler` and the shared handlers typed with
+ * `NextApiRequest`/`NextApiResponse` (serveMediaCdn/servePluginFetch) satisfy
+ * it — their parameter types differ (contravariance), so the boundary is
+ * intentionally loose. The runtime shapes we pass (below) cover what each
+ * handler actually touches.
+ */
+export type LegacyApiHandler = (req: any, res: any) => unknown;
+/**
+ * Builds a `PluginApiRequest` from a Web `Request` plus the App Router route
+ * `params` (awaited by the caller). Body parsing mirrors Next's default
+ * body parser: JSON for `application/json`, form fields for urlencoded,
+ * raw text otherwise; GET/HEAD carry no body.
+ */
+export declare function pluginRequestFromWeb(request: Request, params?: Record<string, string | string[]>): Promise<PluginApiRequest>;
+/**
+ * Runs a node-style `(req, res)` handler against a Web `Request` and returns
+ * the Web `Response` it produced. The entry point for App Router `route.ts`
+ * files that dispatch to plugin handlers or the shared `serveMediaCdn` /
+ * `servePluginFetch` handlers. Runs on the Node.js runtime (streams,
+ * firebase-admin) — not edge.
+ *
+ * A handler that responds with a complete body is awaited to the end, and a
+ * throw before it responds rejects exactly as it always has. A handler that
+ * streams gets its `Response` back at the first chunk while it keeps writing;
+ * if it fails after that, the body fails with it (see
+ * {@link PluginResponseCollector}).
+ */
+export declare function runLegacyHandler(handler: LegacyApiHandler, request: Request, params?: Record<string, string | string[]>): Promise<Response>;

package/src/lib/app-utils/api-adapter.js

@@ -0,0 +1,367 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { Writable } from "node:stream";
+import { readClientIp } from "./request-ip.js";
+/**
+ * App Router ↔ node-style handler adapter (AGL-407). The plugin API contract
+ * (`PluginApiHandler`) and a few shared handlers (`serveMediaCdn`,
+ * `servePluginFetch`) are deliberately framework-light `(req, res)` functions
+ * — that structural shape is what keeps plugins decoupled from any Next
+ * router. This module lets an App Router `route.ts` invoke them from a Web
+ * `Request`, so the tenant's API surface moves to the App Router with **zero
+ * changes to plugin handlers** (they still run unchanged on the console's
+ * Pages Router too). The response collector is a real `Writable`, so a
+ * handler that pipes a read stream into `res` streams its body to the client
+ * rather than handing it over whole — see {@link PluginResponseCollector}.
+ */ /**
+ * The address a node-style handler reads as `req.socket.remoteAddress`.
+ *
+ * There is no real socket behind an App Router `Request`, so this stands in
+ * for one — which makes it a client-address reader wearing a socket's name,
+ * and every plugin handler that falls back to `req.socket?.remoteAddress`
+ * inherits whatever it decides. It goes through the shared reader for exactly
+ * that reason: the fallback has to be the same trusted hop as the header
+ * reading it falls back FROM, or a handler could be steered onto a
+ * caller-supplied value by omitting a header.
+ *
+ * `undefined` rather than a placeholder when nothing is readable — node leaves
+ * `remoteAddress` undefined on a destroyed socket, so handlers already have to
+ * cope with its absence.
+ */ function clientIp(headers) {
+    var _readClientIp;
+    return (_readClientIp = readClientIp(headers)) != null ? _readClientIp : undefined;
+}
+/** Parse a `Cookie` header into a flat record. */ function parseCookies(headers) {
+    const raw = headers.get('cookie');
+    if (!raw) return {};
+    const out = {};
+    for (const pair of raw.split(';')){
+        const index = pair.indexOf('=');
+        if (index < 0) continue;
+        const key = pair.slice(0, index).trim();
+        if (key) out[key] = decodeURIComponent(pair.slice(index + 1).trim());
+    }
+    return out;
+}
+/**
+ * Builds a `PluginApiRequest` from a Web `Request` plus the App Router route
+ * `params` (awaited by the caller). Body parsing mirrors Next's default
+ * body parser: JSON for `application/json`, form fields for urlencoded,
+ * raw text otherwise; GET/HEAD carry no body.
+ */ export async function pluginRequestFromWeb(request, params = {}) {
+    var _request_method;
+    const url = new URL(request.url);
+    const query = _extends({}, params);
+    for (const key of url.searchParams.keys()){
+        var _all_;
+        if (key in query) continue;
+        const all = url.searchParams.getAll(key);
+        query[key] = all.length > 1 ? all : (_all_ = all[0]) != null ? _all_ : '';
+    }
+    const method = (_request_method = request.method) != null ? _request_method : 'GET';
+    let body;
+    let rawBody;
+    if (method !== 'GET' && method !== 'HEAD') {
+        const raw = await request.text();
+        rawBody = raw || undefined;
+        if (raw) {
+            var _request_headers_get;
+            const contentType = (_request_headers_get = request.headers.get('content-type')) != null ? _request_headers_get : '';
+            if (contentType.includes('application/json')) {
+                try {
+                    body = JSON.parse(raw);
+                } catch (unused) {
+                    body = raw;
+                }
+            } else if (contentType.includes('application/x-www-form-urlencoded')) {
+                body = Object.fromEntries(new URLSearchParams(raw));
+            } else {
+                body = raw;
+            }
+        }
+    }
+    const headers = {};
+    request.headers.forEach((value, key)=>{
+        headers[key] = value;
+    });
+    return {
+        method,
+        query,
+        body,
+        rawBody,
+        headers,
+        cookies: parseCookies(request.headers),
+        socket: {
+            remoteAddress: clientIp(request.headers)
+        }
+    };
+}
+/** A promise and the function that settles it. */ function signal() {
+    let resolve = ()=>undefined;
+    const promise = new Promise((settle)=>{
+        resolve = settle;
+    });
+    return {
+        promise,
+        resolve
+    };
+}
+/** Statuses a `Response` may not carry a body on (Fetch §2.2.4). */ const NULL_BODY_STATUSES = new Set([
+    101,
+    103,
+    204,
+    205,
+    304
+]);
+/**
+ * A `PluginApiResponse` that turns a node-style handler's output into a Web
+ * `Response`, in one of two shapes.
+ *
+ * - **A complete body** — `json`, `send`, `redirect`, or `end()` with nothing
+ *   written. It is kept whole and becomes a buffered `Response` once the
+ *   handler returns, which is the shape every plugin handler relies on.
+ * - **A streamed body** — anything written through the `Writable` side:
+ *   `write()`, `stream.pipe(res)`, `pipeline(source, res)`. The `Response` is
+ *   handed back at the FIRST chunk, carrying the status and headers set by
+ *   then, and its body is a `ReadableStream` the client pulls one chunk at a
+ *   time (AGL-2810).
+ *
+ * ## Why a streamed body is never collected
+ *
+ * The media CDN pipes whole Storage objects into `res`. Collected, each
+ * request held its entire file in function memory — briefly twice, while the
+ * chunks were concatenated — and sent nothing until the last byte had been
+ * read, so a player's opening `bytes=0-` on a large video pulled the whole
+ * file before playback could start.
+ *
+ * ## Backpressure
+ *
+ * The body stream holds one chunk. A write is acknowledged only when the
+ * client has taken the chunk before it, so `pipe`/`pipeline` pause the source
+ * while the client is slow and a response never holds more than a few chunks
+ * in memory, whatever the size of the file behind it.
+ *
+ * ## Failure after the first chunk
+ *
+ * Once the status line is gone the only honest signal left is to fail the
+ * body. `destroy(error)` errors the stream, so the client sees a broken
+ * transfer. Closing it instead would present a truncated file as complete —
+ * which, for a video player, is a corrupt file it has no reason to doubt.
+ *
+ * ## A client that stops reading
+ *
+ * Canceling the body destroys this writer, and `pipeline` answers a
+ * destination that closed early by destroying its source. An abandoned
+ * response therefore stops reading from Storage instead of leaving the read
+ * open behind a client that has gone.
+ */ let PluginResponseCollector = class PluginResponseCollector extends Writable {
+    /** True once a chunk has been written, so the `Response` is committed. */ get streaming() {
+        return this.body !== null;
+    }
+    /** Settles at the first streamed chunk. */ get firstChunkWritten() {
+        return this.firstChunk.promise;
+    }
+    _write(chunk, encoding, callback) {
+        var _this_controller, _controller_desiredSize;
+        this.headersSent = true;
+        const controller = (_this_controller = this.controller) != null ? _this_controller : this.openBody();
+        try {
+            controller.enqueue(chunk instanceof Uint8Array ? chunk : Buffer.from(String(chunk), encoding));
+        } catch (error) {
+            // The client already canceled or the body already failed: the write
+            // fails the way a write to a closed socket does.
+            callback(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (((_controller_desiredSize = controller.desiredSize) != null ? _controller_desiredSize : 0) > 0) callback();
+        else this.awaitingPull = callback;
+    }
+    _final(callback) {
+        this.bodyEnded = true;
+        try {
+            var _this_controller;
+            (_this_controller = this.controller) == null ? void 0 : _this_controller.close();
+        } catch (unused) {
+        // Canceled by the client; nothing is waiting for the end.
+        }
+        callback();
+    }
+    _destroy(error, callback) {
+        this.awaitingPull = null;
+        if (this.controller && !this.bodyEnded) {
+            try {
+                this.controller.error(error != null ? error : new Error('Response body closed before it ended'));
+            } catch (unused) {
+            // Already closed or errored.
+            }
+        }
+        callback(error);
+    }
+    /** Commits the response: the status and headers set so far are final. */ openBody() {
+        const started = {};
+        this.body = new ReadableStream({
+            start: (controller)=>{
+                started.controller = controller;
+            },
+            pull: ()=>{
+                const acknowledge = this.awaitingPull;
+                this.awaitingPull = null;
+                acknowledge == null ? void 0 : acknowledge();
+            },
+            cancel: ()=>{
+                this.awaitingPull = null;
+                this.destroy();
+            }
+        }, {
+            highWaterMark: 1
+        });
+        // `start` runs synchronously inside the constructor (Streams §4.2.4).
+        if (!started.controller) {
+            throw new Error('ReadableStream did not start synchronously');
+        }
+        this.controller = started.controller;
+        this.firstChunk.resolve();
+        return started.controller;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    setHeader(name, value) {
+        this.outHeaders[name.toLowerCase()] = value;
+    }
+    removeHeader(name) {
+        delete this.outHeaders[name.toLowerCase()];
+    }
+    json(body) {
+        if (this.outHeaders['content-type'] === undefined) {
+            this.setHeader('content-type', 'application/json; charset=utf-8');
+        }
+        this.endWith(Buffer.from(JSON.stringify(body)));
+    }
+    send(body) {
+        if (body === undefined || body === null) return void this.end();
+        if (Buffer.isBuffer(body)) return void this.endWith(body);
+        if (typeof body === 'string') return void this.endWith(Buffer.from(body));
+        return this.json(body);
+    }
+    redirect(statusOrUrl, maybeUrl) {
+        const status = typeof statusOrUrl === 'number' ? statusOrUrl : 302;
+        const location = typeof statusOrUrl === 'number' ? maybeUrl != null ? maybeUrl : '' : statusOrUrl;
+        this.statusCode = status;
+        this.setHeader('location', location);
+        this.end();
+    }
+    /**
+   * Ends the response with a complete body. After a streamed chunk the body
+   * is already a stream, so the bytes can only join it.
+   */ endWith(body) {
+        if (this.body) {
+            this.end(body);
+            return;
+        }
+        this.completeBody = body;
+        this.end();
+    }
+    /**
+   * The Web `Response`, as soon as it is decided: at the first streamed chunk,
+   * or once the handler has ended the response with a complete body.
+   */ async toResponse() {
+        await Promise.race([
+            this.ended.promise,
+            this.firstChunk.promise
+        ]);
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(this.outHeaders)){
+            if (Array.isArray(value)) {
+                for (const item of value)headers.append(key, String(item));
+            } else {
+                headers.set(key, String(value));
+            }
+        }
+        const bodyless = NULL_BODY_STATUSES.has(this.statusCode);
+        if (this.body) {
+            if (bodyless) {
+                void this.body.cancel();
+                return new Response(null, {
+                    status: this.statusCode,
+                    headers
+                });
+            }
+            return new Response(this.body, {
+                status: this.statusCode,
+                headers
+            });
+        }
+        const body = this.completeBody;
+        return new Response(bodyless || !body || body.length === 0 ? null : body, {
+            status: this.statusCode,
+            headers
+        });
+    }
+    constructor(){
+        super(), this.statusCode = 200, this.outHeaders = {}, /** What `json`/`send` produced, when nothing was streamed. */ this.completeBody = null, this.body = null, this.controller = null, /** The acknowledgement for the chunk the client has not taken yet. */ this.awaitingPull = null, /** Set by `_final`: the body ended, so a later teardown is not a failure. */ this.bodyEnded = false, this.ended = signal(), this.firstChunk = signal(), this.headersSent = false;
+        this.once('finish', this.ended.resolve);
+        // `close` as well as `finish`: a writer destroyed before it wrote or
+        // ended must still let `toResponse` return rather than wait forever.
+        this.once('close', this.ended.resolve);
+        // A streamed failure reaches the client through the body (`_destroy`).
+        // Without a listener, `destroy(error)` would also emit an `error` event
+        // nothing handles, and an unhandled `error` takes the process down.
+        this.on('error', ()=>undefined);
+    }
+};
+/**
+ * Runs a node-style `(req, res)` handler against a Web `Request` and returns
+ * the Web `Response` it produced. The entry point for App Router `route.ts`
+ * files that dispatch to plugin handlers or the shared `serveMediaCdn` /
+ * `servePluginFetch` handlers. Runs on the Node.js runtime (streams,
+ * firebase-admin) — not edge.
+ *
+ * A handler that responds with a complete body is awaited to the end, and a
+ * throw before it responds rejects exactly as it always has. A handler that
+ * streams gets its `Response` back at the first chunk while it keeps writing;
+ * if it fails after that, the body fails with it (see
+ * {@link PluginResponseCollector}).
+ */ export async function runLegacyHandler(handler, request, params = {}) {
+    const req = await pluginRequestFromWeb(request, params);
+    const res = new PluginResponseCollector();
+    const failure = {
+        failed: false
+    };
+    const handled = (async ()=>{
+        try {
+            await handler(req, res);
+        } catch (error) {
+            if (res.streaming) {
+                // The status line is already out, so only the body can carry this.
+                res.destroy(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            failure.failed = true;
+            failure.error = error;
+        }
+    })();
+    await Promise.race([
+        handled,
+        res.firstChunkWritten
+    ]);
+    if (failure.failed) throw failure.error;
+    return res.toResponse();
+}
+
+//# sourceMappingURL=api-adapter.js.map

package/src/lib/app-utils/api-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/api-adapter.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Writable } from 'node:stream'\nimport type { PluginApiRequest, PluginApiResponse } from './api-plugins'\nimport { readClientIp } from './request-ip'\n\n/**\n * A node-style API handler runnable through {@link runLegacyHandler}. Both\n * the framework-light `PluginApiHandler` and the shared handlers typed with\n * `NextApiRequest`/`NextApiResponse` (serveMediaCdn/servePluginFetch) satisfy\n * it — their parameter types differ (contravariance), so the boundary is\n * intentionally loose. The runtime shapes we pass (below) cover what each\n * handler actually touches.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LegacyApiHandler = (req: any, res: any) => unknown\n\n/**\n * App Router ↔ node-style handler adapter (AGL-407). The plugin API contract\n * (`PluginApiHandler`) and a few shared handlers (`serveMediaCdn`,\n * `servePluginFetch`) are deliberately framework-light `(req, res)` functions\n * — that structural shape is what keeps plugins decoupled from any Next\n * router. This module lets an App Router `route.ts` invoke them from a Web\n * `Request`, so the tenant's API surface moves to the App Router with **zero\n * changes to plugin handlers** (they still run unchanged on the console's\n * Pages Router too). The response collector is a real `Writable`, so a\n * handler that pipes a read stream into `res` streams its body to the client\n * rather than handing it over whole — see {@link PluginResponseCollector}.\n */\n\n/**\n * The address a node-style handler reads as `req.socket.remoteAddress`.\n *\n * There is no real socket behind an App Router `Request`, so this stands in\n * for one — which makes it a client-address reader wearing a socket's name,\n * and every plugin handler that falls back to `req.socket?.remoteAddress`\n * inherits whatever it decides. It goes through the shared reader for exactly\n * that reason: the fallback has to be the same trusted hop as the header\n * reading it falls back FROM, or a handler could be steered onto a\n * caller-supplied value by omitting a header.\n *\n * `undefined` rather than a placeholder when nothing is readable — node leaves\n * `remoteAddress` undefined on a destroyed socket, so handlers already have to\n * cope with its absence.\n */\nfunction clientIp(headers: Headers): string | undefined {\n  return readClientIp(headers) ?? undefined\n}\n\n/** Parse a `Cookie` header into a flat record. */\nfunction parseCookies(headers: Headers): Record<string, string> {\n  const raw = headers.get('cookie')\n  if (!raw) return {}\n  const out: Record<string, string> = {}\n  for (const pair of raw.split(';')) {\n    const index = pair.indexOf('=')\n    if (index < 0) continue\n    const key = pair.slice(0, index).trim()\n    if (key) out[key] = decodeURIComponent(pair.slice(index + 1).trim())\n  }\n  return out\n}\n\n/**\n * Builds a `PluginApiRequest` from a Web `Request` plus the App Router route\n * `params` (awaited by the caller). Body parsing mirrors Next's default\n * body parser: JSON for `application/json`, form fields for urlencoded,\n * raw text otherwise; GET/HEAD carry no body.\n */\nexport async function pluginRequestFromWeb(\n  request: Request,\n  params: Record<string, string | string[]> = {},\n): Promise<PluginApiRequest> {\n  const url = new URL(request.url)\n  const query: Record<string, string | string[]> = { ...params }\n  for (const key of url.searchParams.keys()) {\n    if (key in query) continue\n    const all = url.searchParams.getAll(key)\n    query[key] = all.length > 1 ? all : (all[0] ?? '')\n  }\n\n  const method = request.method ?? 'GET'\n  let body: unknown\n  let rawBody: string | undefined\n  if (method !== 'GET' && method !== 'HEAD') {\n    const raw = await request.text()\n    rawBody = raw || undefined\n    if (raw) {\n      const contentType = request.headers.get('content-type') ?? ''\n      if (contentType.includes('application/json')) {\n        try {\n          body = JSON.parse(raw)\n        } catch {\n          body = raw\n        }\n      } else if (contentType.includes('application/x-www-form-urlencoded')) {\n        body = Object.fromEntries(new URLSearchParams(raw))\n      } else {\n        body = raw\n      }\n    }\n  }\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return {\n    method,\n    query,\n    body,\n    rawBody,\n    headers,\n    cookies: parseCookies(request.headers),\n    socket: { remoteAddress: clientIp(request.headers) },\n  }\n}\n\ntype WriteCallback = (error?: Error | null) => void\n\n/** A promise and the function that settles it. */\nfunction signal(): { promise: Promise<void>; resolve: () => void } {\n  let resolve: () => void = () => undefined\n  const promise = new Promise<void>((settle) => {\n    resolve = settle\n  })\n  return { promise, resolve }\n}\n\n/** Statuses a `Response` may not carry a body on (Fetch §2.2.4). */\nconst NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304])\n\n/**\n * A `PluginApiResponse` that turns a node-style handler's output into a Web\n * `Response`, in one of two shapes.\n *\n * - **A complete body** — `json`, `send`, `redirect`, or `end()` with nothing\n *   written. It is kept whole and becomes a buffered `Response` once the\n *   handler returns, which is the shape every plugin handler relies on.\n * - **A streamed body** — anything written through the `Writable` side:\n *   `write()`, `stream.pipe(res)`, `pipeline(source, res)`. The `Response` is\n *   handed back at the FIRST chunk, carrying the status and headers set by\n *   then, and its body is a `ReadableStream` the client pulls one chunk at a\n *   time (AGL-2810).\n *\n * ## Why a streamed body is never collected\n *\n * The media CDN pipes whole Storage objects into `res`. Collected, each\n * request held its entire file in function memory — briefly twice, while the\n * chunks were concatenated — and sent nothing until the last byte had been\n * read, so a player's opening `bytes=0-` on a large video pulled the whole\n * file before playback could start.\n *\n * ## Backpressure\n *\n * The body stream holds one chunk. A write is acknowledged only when the\n * client has taken the chunk before it, so `pipe`/`pipeline` pause the source\n * while the client is slow and a response never holds more than a few chunks\n * in memory, whatever the size of the file behind it.\n *\n * ## Failure after the first chunk\n *\n * Once the status line is gone the only honest signal left is to fail the\n * body. `destroy(error)` errors the stream, so the client sees a broken\n * transfer. Closing it instead would present a truncated file as complete —\n * which, for a video player, is a corrupt file it has no reason to doubt.\n *\n * ## A client that stops reading\n *\n * Canceling the body destroys this writer, and `pipeline` answers a\n * destination that closed early by destroying its source. An abandoned\n * response therefore stops reading from Storage instead of leaving the read\n * open behind a client that has gone.\n */\nclass PluginResponseCollector extends Writable implements PluginApiResponse {\n  private statusCode = 200\n  private readonly outHeaders: Record<string, string | number | readonly string[]> =\n    {}\n  /** What `json`/`send` produced, when nothing was streamed. */\n  private completeBody: Buffer | null = null\n  private body: ReadableStream<Uint8Array> | null = null\n  private controller: ReadableStreamDefaultController<Uint8Array> | null = null\n  /** The acknowledgement for the chunk the client has not taken yet. */\n  private awaitingPull: WriteCallback | null = null\n  /** Set by `_final`: the body ended, so a later teardown is not a failure. */\n  private bodyEnded = false\n  private readonly ended = signal()\n  private readonly firstChunk = signal()\n  headersSent = false\n\n  constructor() {\n    super()\n    this.once('finish', this.ended.resolve)\n    // `close` as well as `finish`: a writer destroyed before it wrote or\n    // ended must still let `toResponse` return rather than wait forever.\n    this.once('close', this.ended.resolve)\n    // A streamed failure reaches the client through the body (`_destroy`).\n    // Without a listener, `destroy(error)` would also emit an `error` event\n    // nothing handles, and an unhandled `error` takes the process down.\n    this.on('error', () => undefined)\n  }\n\n  /** True once a chunk has been written, so the `Response` is committed. */\n  get streaming(): boolean {\n    return this.body !== null\n  }\n\n  /** Settles at the first streamed chunk. */\n  get firstChunkWritten(): Promise<void> {\n    return this.firstChunk.promise\n  }\n\n  override _write(\n    chunk: unknown,\n    encoding: BufferEncoding,\n    callback: WriteCallback,\n  ): void {\n    this.headersSent = true\n    const controller = this.controller ?? this.openBody()\n    try {\n      controller.enqueue(\n        chunk instanceof Uint8Array ? chunk : Buffer.from(String(chunk), encoding),\n      )\n    } catch (error) {\n      // The client already canceled or the body already failed: the write\n      // fails the way a write to a closed socket does.\n      callback(error instanceof Error ? error : new Error(String(error)))\n      return\n    }\n    if ((controller.desiredSize ?? 0) > 0) callback()\n    else this.awaitingPull = callback\n  }\n\n  override _final(callback: WriteCallback): void {\n    this.bodyEnded = true\n    try {\n      this.controller?.close()\n    } catch {\n      // Canceled by the client; nothing is waiting for the end.\n    }\n    callback()\n  }\n\n  override _destroy(error: Error | null, callback: WriteCallback): void {\n    this.awaitingPull = null\n    if (this.controller && !this.bodyEnded) {\n      try {\n        this.controller.error(\n          error ?? new Error('Response body closed before it ended'),\n        )\n      } catch {\n        // Already closed or errored.\n      }\n    }\n    callback(error)\n  }\n\n  /** Commits the response: the status and headers set so far are final. */\n  private openBody(): ReadableStreamDefaultController<Uint8Array> {\n    const started: { controller?: ReadableStreamDefaultController<Uint8Array> } =\n      {}\n    this.body = new ReadableStream<Uint8Array>(\n      {\n        start: (controller) => {\n          started.controller = controller\n        },\n        pull: () => {\n          const acknowledge = this.awaitingPull\n          this.awaitingPull = null\n          acknowledge?.()\n        },\n        cancel: () => {\n          this.awaitingPull = null\n          this.destroy()\n        },\n      },\n      { highWaterMark: 1 },\n    )\n    // `start` runs synchronously inside the constructor (Streams §4.2.4).\n    if (!started.controller) {\n      throw new Error('ReadableStream did not start synchronously')\n    }\n    this.controller = started.controller\n    this.firstChunk.resolve()\n    return started.controller\n  }\n\n  status(code: number): this {\n    this.statusCode = code\n    return this\n  }\n\n  setHeader(name: string, value: string | number | readonly string[]): void {\n    this.outHeaders[name.toLowerCase()] = value\n  }\n\n  removeHeader(name: string): void {\n    delete this.outHeaders[name.toLowerCase()]\n  }\n\n  json(body: unknown): void {\n    if (this.outHeaders['content-type'] === undefined) {\n      this.setHeader('content-type', 'application/json; charset=utf-8')\n    }\n    this.endWith(Buffer.from(JSON.stringify(body)))\n  }\n\n  send(body: unknown): void {\n    if (body === undefined || body === null) return void this.end()\n    if (Buffer.isBuffer(body)) return void this.endWith(body)\n    if (typeof body === 'string') return void this.endWith(Buffer.from(body))\n    return this.json(body)\n  }\n\n  redirect(statusOrUrl: number | string, maybeUrl?: string): void {\n    const status = typeof statusOrUrl === 'number' ? statusOrUrl : 302\n    const location = typeof statusOrUrl === 'number' ? (maybeUrl ?? '') : statusOrUrl\n    this.statusCode = status\n    this.setHeader('location', location)\n    this.end()\n  }\n\n  /**\n   * Ends the response with a complete body. After a streamed chunk the body\n   * is already a stream, so the bytes can only join it.\n   */\n  private endWith(body: Buffer): void {\n    if (this.body) {\n      this.end(body)\n      return\n    }\n    this.completeBody = body\n    this.end()\n  }\n\n  /**\n   * The Web `Response`, as soon as it is decided: at the first streamed chunk,\n   * or once the handler has ended the response with a complete body.\n   */\n  async toResponse(): Promise<Response> {\n    await Promise.race([this.ended.promise, this.firstChunk.promise])\n    const headers = new Headers()\n    for (const [key, value] of Object.entries(this.outHeaders)) {\n      if (Array.isArray(value)) {\n        for (const item of value) headers.append(key, String(item))\n      } else {\n        headers.set(key, String(value))\n      }\n    }\n    const bodyless = NULL_BODY_STATUSES.has(this.statusCode)\n    if (this.body) {\n      if (bodyless) {\n        void this.body.cancel()\n        return new Response(null, { status: this.statusCode, headers })\n      }\n      return new Response(this.body, { status: this.statusCode, headers })\n    }\n    const body = this.completeBody\n    return new Response(\n      bodyless || !body || body.length === 0 ? null : (body as BodyInit),\n      { status: this.statusCode, headers },\n    )\n  }\n}\n\n/**\n * Runs a node-style `(req, res)` handler against a Web `Request` and returns\n * the Web `Response` it produced. The entry point for App Router `route.ts`\n * files that dispatch to plugin handlers or the shared `serveMediaCdn` /\n * `servePluginFetch` handlers. Runs on the Node.js runtime (streams,\n * firebase-admin) — not edge.\n *\n * A handler that responds with a complete body is awaited to the end, and a\n * throw before it responds rejects exactly as it always has. A handler that\n * streams gets its `Response` back at the first chunk while it keeps writing;\n * if it fails after that, the body fails with it (see\n * {@link PluginResponseCollector}).\n */\nexport async function runLegacyHandler(\n  handler: LegacyApiHandler,\n  request: Request,\n  params: Record<string, string | string[]> = {},\n): Promise<Response> {\n  const req = await pluginRequestFromWeb(request, params)\n  const res = new PluginResponseCollector()\n  const failure: { error?: unknown; failed: boolean } = { failed: false }\n  const handled = (async (): Promise<void> => {\n    try {\n      await handler(req, res)\n    } catch (error) {\n      if (res.streaming) {\n        // The status line is already out, so only the body can carry this.\n        res.destroy(error instanceof Error ? error : new Error(String(error)))\n        return\n      }\n      failure.failed = true\n      failure.error = error\n    }\n  })()\n  await Promise.race([handled, res.firstChunkWritten])\n  if (failure.failed) throw failure.error\n  return res.toResponse()\n}\n"],"names":["Writable","readClientIp","clientIp","headers","undefined","parseCookies","raw","get","out","pair","split","index","indexOf","key","slice","trim","decodeURIComponent","pluginRequestFromWeb","request","params","url","URL","query","searchParams","keys","all","getAll","length","method","body","rawBody","text","contentType","includes","JSON","parse","Object","fromEntries","URLSearchParams","forEach","value","cookies","socket","remoteAddress","signal","resolve","promise","Promise","settle","NULL_BODY_STATUSES","Set","PluginResponseCollector","streaming","firstChunkWritten","firstChunk","_write","chunk","encoding","callback","controller","headersSent","openBody","enqueue","Uint8Array","Buffer","from","String","error","Error","desiredSize","awaitingPull","_final","bodyEnded","close","_destroy","started","ReadableStream","start","pull","acknowledge","cancel","destroy","highWaterMark","status","code","statusCode","setHeader","name","outHeaders","toLowerCase","removeHeader","json","endWith","stringify","send","end","isBuffer","redirect","statusOrUrl","maybeUrl","location","completeBody","toResponse","race","ended","Headers","entries","Array","isArray","item","append","set","bodyless","has","Response","once","on","runLegacyHandler","handler","req","res","failure","failed","handled"],"mappings":"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"}