@aglyn/shared-util-http 1.0.0-beta.222 → 1.0.0-beta.223

package/README.md

@@ -24,6 +24,7 @@ By subpath only (not re-exported from the root):
 
 - `@aglyn/shared-util-http/safe-redirect` - `isSameOriginPath(candidate)` and `safeSameOriginPath(candidate, fallback = '/')`. Instead of pattern-matching the string, they resolve it with the URL parser against a probe origin and accept it only if the origin is unchanged, which catches `//host`, `/\host`, and tab or newline tricks alike.
 - `@aglyn/shared-util-http/safe-url-scheme` - `hasSafeLinkScheme(value)` (`http`, `https`, `mailto`, `tel`, `sms`, or no scheme) and `hasSafeMediaScheme(value)` (`http`, `https`, or no scheme). They check the scheme only; you still have to escape the value into the attribute afterwards.
+- `@aglyn/shared-util-http/bounded-await` - `boundedAwait(work, ms, fallback, label)` and `createSettledValueCache()`. The first answers with `work`'s result, or with `fallback` once `ms` has passed, using a real timer rather than trusting an abort signal; `work` may be a function of an `AbortSignal` that aborts at the deadline. A deadline that wins writes one structured `console.warn` per label a minute. The second is a TTL cache that holds settled values and refuses a promise, with a `readThrough(key, load, ttlFor)` that stores only once `load` has settled.
 - `@aglyn/shared-util-http/authorized-token` - `resolveIdToken(user, options?)`, `authorizedFetch(user, input, init?, options?)`, `describeCallFailure(error, fallback)`, `AuthorizationUnavailableError`, `ID_TOKEN_TIMEOUT_MS`. `user` is anything with a `getIdToken()` method. The token wait has a deadline, and when no token can be had `authorizedFetch` sends nothing and resolves to a `401`-shaped response carrying the reason.
 
 ## Usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aglyn/shared-util-http",
-  "version": "1.0.0-beta.222",
+  "version": "1.0.0-beta.223",
   "license": "Apache-2.0",
   "homepage": "https://aglyn.com",
   "repository": {
@@ -25,7 +25,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@aglyn/shared-data-enums": "1.0.0-beta.222",
+    "@aglyn/shared-data-enums": "1.0.0-beta.223",
     "@swc/helpers": "0.5.23"
   },
   "peerDependencies": {

package/src/lib/bounded-await.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @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.
+ */
+/**
+ * A server render never waits on outside I/O past a deadline (AGL-3565).
+ *
+ * ## Why an abort signal is not a deadline
+ *
+ * A request's `AbortSignal` bounds the REQUEST, and only when whatever is
+ * answering honors it. Next's patched `fetch` on Vercel handed back a promise
+ * that never settled — with `AbortSignal.timeout(2500)` on it, on cold
+ * instances as well as warm ones — and the site layout awaited it. Every
+ * uncached page render on the tenant then sat until the platform's 60 s limit.
+ *
+ * So the bound here is a timer the awaiting code owns: the work races a
+ * `setTimeout`, and the timer wins whatever the work does or fails to do. The
+ * signal handed to the work is still aborted at the deadline, so a request
+ * that CAN be canceled is; but nothing depends on that happening.
+ *
+ * ## Why a settled-value cache sits beside it
+ *
+ * The same incident's second half: the module cached the in-flight PROMISE
+ * for a day, so every later render on the instance awaited the one that never
+ * settled — each with its own fresh deadline in front of nothing. A process
+ * cache that outlives a request holds what a request LEARNED, never the work
+ * still being done. {@link createSettledValueCache} refuses a thenable.
+ */
+/** What a bounded await is handed: the work, or a function that starts it. */
+export type BoundedWork<T> = Promise<T> | ((signal: AbortSignal) => Promise<T>);
+/** The structured line a deadline writes when it wins. */
+export interface BoundedAwaitTimeout {
+    event: 'bounded-await-timeout';
+    /** Names the await, `area.what` — the line is searched for by it. */
+    label: string;
+    /** The deadline that passed. */
+    ms: number;
+    /** Deadlines of this label that passed since the last line, unwritten. */
+    suppressed: number;
+}
+/** Test seam: forget which labels have warned. */
+export declare function resetBoundedAwaitWarningsForTests(): void;
+/**
+ * `work`'s answer, or `fallback` once `ms` has passed without one.
+ *
+ * - The deadline is a real timer, cleared as soon as either side settles, so
+ *   a fast answer leaves nothing scheduled behind it.
+ * - Given a function, the work is started with an `AbortSignal` that aborts
+ *   at the deadline — pass it to `fetch` so the request is canceled too.
+ * - A rejection before the deadline is the caller's, unchanged: this bounds
+ *   time, it does not swallow errors. A rejection after it is ignored.
+ * - The deadline winning writes a `console.warn` carrying a
+ *   {@link BoundedAwaitTimeout}, so a stalled dependency is visible in the
+ *   logs rather than only as pages that are a little plainer — at most one
+ *   per label a minute, the rest counted onto the next.
+ *
+ * @example
+ * ```ts
+ * const faces = await boundedAwait(
+ *   (signal) => fetch(url, { signal }).then(parse).catch(() => null),
+ *   2_500,
+ *   null,
+ *   'self-hosted-fonts.stylesheet',
+ * )
+ * ```
+ */
+export declare function boundedAwait<T, F>(work: BoundedWork<T>, ms: number, fallback: F, label: string): Promise<T | F>;
+/** A process cache whose entries are answers, never work in progress. */
+export interface SettledValueCache<K, V> {
+    /** The held answer while it is fresh, as `{ value }`, else undefined. */
+    lookup(key: K, nowMs?: number): {
+        value: V;
+    } | undefined;
+    /** Hold `value` for `ttlMs`. A promise or other thenable is refused. */
+    set(key: K, value: V, ttlMs: number, nowMs?: number): void;
+    /**
+     * The held answer, or `load`'s once it settles — and only then is it held,
+     * for `ttlFor(value)`. Concurrent misses each run `load`; none of them
+     * waits on another's work, which is the point.
+     */
+    readThrough(key: K, load: () => Promise<V>, ttlFor: (value: V) => number): Promise<V>;
+    delete(key: K): void;
+    clear(): void;
+}
+/**
+ * A process-lifetime cache for values a render learned — see the module
+ * note for why it will not hold a promise.
+ */
+export declare function createSettledValueCache<K, V>(): SettledValueCache<K, V>;

package/src/lib/bounded-await.js

@@ -0,0 +1,158 @@
+/**
+ * @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.
+ */ /**
+ * A server render never waits on outside I/O past a deadline (AGL-3565).
+ *
+ * ## Why an abort signal is not a deadline
+ *
+ * A request's `AbortSignal` bounds the REQUEST, and only when whatever is
+ * answering honors it. Next's patched `fetch` on Vercel handed back a promise
+ * that never settled — with `AbortSignal.timeout(2500)` on it, on cold
+ * instances as well as warm ones — and the site layout awaited it. Every
+ * uncached page render on the tenant then sat until the platform's 60 s limit.
+ *
+ * So the bound here is a timer the awaiting code owns: the work races a
+ * `setTimeout`, and the timer wins whatever the work does or fails to do. The
+ * signal handed to the work is still aborted at the deadline, so a request
+ * that CAN be canceled is; but nothing depends on that happening.
+ *
+ * ## Why a settled-value cache sits beside it
+ *
+ * The same incident's second half: the module cached the in-flight PROMISE
+ * for a day, so every later render on the instance awaited the one that never
+ * settled — each with its own fresh deadline in front of nothing. A process
+ * cache that outlives a request holds what a request LEARNED, never the work
+ * still being done. {@link createSettledValueCache} refuses a thenable.
+ */ /** What a bounded await is handed: the work, or a function that starts it. */ /**
+ * One line per label per window. A dependency that is down misses its
+ * deadline on every render that asks it; a line per render would bury the
+ * logs in the one fact, so the rest are counted onto the next line.
+ */ const WARN_WINDOW_MS = 60000;
+const lastWarned = new Map();
+function warnTimeout(label, ms) {
+    var _ref;
+    const nowMs = Date.now();
+    const held = lastWarned.get(label);
+    if (held && nowMs - held.atMs < WARN_WINDOW_MS) {
+        held.suppressed += 1;
+        return;
+    }
+    const line = {
+        event: 'bounded-await-timeout',
+        label,
+        ms,
+        suppressed: (_ref = held == null ? void 0 : held.suppressed) != null ? _ref : 0
+    };
+    lastWarned.set(label, {
+        atMs: nowMs,
+        suppressed: 0
+    });
+    console.warn('[bounded-await] deadline passed; using the fallback', line);
+}
+/** Test seam: forget which labels have warned. */ export function resetBoundedAwaitWarningsForTests() {
+    lastWarned.clear();
+}
+/**
+ * `work`'s answer, or `fallback` once `ms` has passed without one.
+ *
+ * - The deadline is a real timer, cleared as soon as either side settles, so
+ *   a fast answer leaves nothing scheduled behind it.
+ * - Given a function, the work is started with an `AbortSignal` that aborts
+ *   at the deadline — pass it to `fetch` so the request is canceled too.
+ * - A rejection before the deadline is the caller's, unchanged: this bounds
+ *   time, it does not swallow errors. A rejection after it is ignored.
+ * - The deadline winning writes a `console.warn` carrying a
+ *   {@link BoundedAwaitTimeout}, so a stalled dependency is visible in the
+ *   logs rather than only as pages that are a little plainer — at most one
+ *   per label a minute, the rest counted onto the next.
+ *
+ * @example
+ * ```ts
+ * const faces = await boundedAwait(
+ *   (signal) => fetch(url, { signal }).then(parse).catch(() => null),
+ *   2_500,
+ *   null,
+ *   'self-hosted-fonts.stylesheet',
+ * )
+ * ```
+ */ export function boundedAwait(work, ms, fallback, label) {
+    const controller = new AbortController();
+    let timer;
+    let started;
+    try {
+        started = typeof work === 'function' ? work(controller.signal) : work;
+    } catch (error) {
+        return Promise.reject(error);
+    }
+    const deadline = new Promise((resolve)=>{
+        timer = setTimeout(()=>{
+            controller.abort(new Error(`${label} passed its ${ms} ms deadline`));
+            warnTimeout(label, ms);
+            resolve(fallback);
+        }, ms);
+    });
+    return Promise.race([
+        started,
+        deadline
+    ]).finally(()=>clearTimeout(timer));
+}
+function isThenable(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null && typeof value.then === 'function';
+}
+/**
+ * A process-lifetime cache for values a render learned — see the module
+ * note for why it will not hold a promise.
+ */ export function createSettledValueCache() {
+    const entries = new Map();
+    const cache = {
+        lookup (key, nowMs = Date.now()) {
+            const held = entries.get(key);
+            if (!held) return undefined;
+            if (held.expires <= nowMs) {
+                entries.delete(key);
+                return undefined;
+            }
+            return {
+                value: held.value
+            };
+        },
+        set (key, value, ttlMs, nowMs = Date.now()) {
+            if (isThenable(value)) {
+                throw new TypeError('A settled-value cache holds answers, not work in progress: await it first (AGL-3565)');
+            }
+            entries.set(key, {
+                value,
+                expires: nowMs + ttlMs
+            });
+        },
+        async readThrough (key, load, ttlFor) {
+            const held = cache.lookup(key);
+            if (held) return held.value;
+            const value = await load();
+            cache.set(key, value, ttlFor(value));
+            return value;
+        },
+        delete (key) {
+            entries.delete(key);
+        },
+        clear () {
+            entries.clear();
+        }
+    };
+    return cache;
+}
+
+//# sourceMappingURL=bounded-await.js.map

package/src/lib/bounded-await.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/util/http/src/lib/bounded-await.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 * A server render never waits on outside I/O past a deadline (AGL-3565).\n *\n * ## Why an abort signal is not a deadline\n *\n * A request's `AbortSignal` bounds the REQUEST, and only when whatever is\n * answering honors it. Next's patched `fetch` on Vercel handed back a promise\n * that never settled — with `AbortSignal.timeout(2500)` on it, on cold\n * instances as well as warm ones — and the site layout awaited it. Every\n * uncached page render on the tenant then sat until the platform's 60 s limit.\n *\n * So the bound here is a timer the awaiting code owns: the work races a\n * `setTimeout`, and the timer wins whatever the work does or fails to do. The\n * signal handed to the work is still aborted at the deadline, so a request\n * that CAN be canceled is; but nothing depends on that happening.\n *\n * ## Why a settled-value cache sits beside it\n *\n * The same incident's second half: the module cached the in-flight PROMISE\n * for a day, so every later render on the instance awaited the one that never\n * settled — each with its own fresh deadline in front of nothing. A process\n * cache that outlives a request holds what a request LEARNED, never the work\n * still being done. {@link createSettledValueCache} refuses a thenable.\n */\n\n/** What a bounded await is handed: the work, or a function that starts it. */\nexport type BoundedWork<T> = Promise<T> | ((signal: AbortSignal) => Promise<T>)\n\n/** The structured line a deadline writes when it wins. */\nexport interface BoundedAwaitTimeout {\n  event: 'bounded-await-timeout'\n  /** Names the await, `area.what` — the line is searched for by it. */\n  label: string\n  /** The deadline that passed. */\n  ms: number\n  /** Deadlines of this label that passed since the last line, unwritten. */\n  suppressed: number\n}\n\n/**\n * One line per label per window. A dependency that is down misses its\n * deadline on every render that asks it; a line per render would bury the\n * logs in the one fact, so the rest are counted onto the next line.\n */\nconst WARN_WINDOW_MS = 60_000\nconst lastWarned = new Map<string, { atMs: number; suppressed: number }>()\n\nfunction warnTimeout(label: string, ms: number): void {\n  const nowMs = Date.now()\n  const held = lastWarned.get(label)\n  if (held && nowMs - held.atMs < WARN_WINDOW_MS) {\n    held.suppressed += 1\n    return\n  }\n  const line: BoundedAwaitTimeout = {\n    event: 'bounded-await-timeout',\n    label,\n    ms,\n    suppressed: held?.suppressed ?? 0,\n  }\n  lastWarned.set(label, { atMs: nowMs, suppressed: 0 })\n  console.warn('[bounded-await] deadline passed; using the fallback', line)\n}\n\n/** Test seam: forget which labels have warned. */\nexport function resetBoundedAwaitWarningsForTests(): void {\n  lastWarned.clear()\n}\n\n/**\n * `work`'s answer, or `fallback` once `ms` has passed without one.\n *\n * - The deadline is a real timer, cleared as soon as either side settles, so\n *   a fast answer leaves nothing scheduled behind it.\n * - Given a function, the work is started with an `AbortSignal` that aborts\n *   at the deadline — pass it to `fetch` so the request is canceled too.\n * - A rejection before the deadline is the caller's, unchanged: this bounds\n *   time, it does not swallow errors. A rejection after it is ignored.\n * - The deadline winning writes a `console.warn` carrying a\n *   {@link BoundedAwaitTimeout}, so a stalled dependency is visible in the\n *   logs rather than only as pages that are a little plainer — at most one\n *   per label a minute, the rest counted onto the next.\n *\n * @example\n * ```ts\n * const faces = await boundedAwait(\n *   (signal) => fetch(url, { signal }).then(parse).catch(() => null),\n *   2_500,\n *   null,\n *   'self-hosted-fonts.stylesheet',\n * )\n * ```\n */\nexport function boundedAwait<T, F>(\n  work: BoundedWork<T>,\n  ms: number,\n  fallback: F,\n  label: string,\n): Promise<T | F> {\n  const controller = new AbortController()\n  let timer: ReturnType<typeof setTimeout> | undefined\n  let started: Promise<T>\n  try {\n    started = typeof work === 'function' ? work(controller.signal) : work\n  } catch (error) {\n    return Promise.reject(error)\n  }\n  const deadline = new Promise<F>((resolve) => {\n    timer = setTimeout(() => {\n      controller.abort(new Error(`${label} passed its ${ms} ms deadline`))\n      warnTimeout(label, ms)\n      resolve(fallback)\n    }, ms)\n  })\n  return Promise.race([started, deadline]).finally(() => clearTimeout(timer))\n}\n\n/** A process cache whose entries are answers, never work in progress. */\nexport interface SettledValueCache<K, V> {\n  /** The held answer while it is fresh, as `{ value }`, else undefined. */\n  lookup(key: K, nowMs?: number): { value: V } | undefined\n  /** Hold `value` for `ttlMs`. A promise or other thenable is refused. */\n  set(key: K, value: V, ttlMs: number, nowMs?: number): void\n  /**\n   * The held answer, or `load`'s once it settles — and only then is it held,\n   * for `ttlFor(value)`. Concurrent misses each run `load`; none of them\n   * waits on another's work, which is the point.\n   */\n  readThrough(\n    key: K,\n    load: () => Promise<V>,\n    ttlFor: (value: V) => number,\n  ): Promise<V>\n  delete(key: K): void\n  clear(): void\n}\n\nfunction isThenable(value: unknown): boolean {\n  return (\n    (typeof value === 'object' || typeof value === 'function') &&\n    value !== null &&\n    typeof (value as { then?: unknown }).then === 'function'\n  )\n}\n\n/**\n * A process-lifetime cache for values a render learned — see the module\n * note for why it will not hold a promise.\n */\nexport function createSettledValueCache<K, V>(): SettledValueCache<K, V> {\n  const entries = new Map<K, { value: V; expires: number }>()\n  const cache: SettledValueCache<K, V> = {\n    lookup(key, nowMs = Date.now()) {\n      const held = entries.get(key)\n      if (!held) return undefined\n      if (held.expires <= nowMs) {\n        entries.delete(key)\n        return undefined\n      }\n      return { value: held.value }\n    },\n    set(key, value, ttlMs, nowMs = Date.now()) {\n      if (isThenable(value)) {\n        throw new TypeError(\n          'A settled-value cache holds answers, not work in progress: await it first (AGL-3565)',\n        )\n      }\n      entries.set(key, { value, expires: nowMs + ttlMs })\n    },\n    async readThrough(key, load, ttlFor) {\n      const held = cache.lookup(key)\n      if (held) return held.value\n      const value = await load()\n      cache.set(key, value, ttlFor(value))\n      return value\n    },\n    delete(key) {\n      entries.delete(key)\n    },\n    clear() {\n      entries.clear()\n    },\n  }\n  return cache\n}\n"],"names":["WARN_WINDOW_MS","lastWarned","Map","warnTimeout","label","ms","nowMs","Date","now","held","get","atMs","suppressed","line","event","set","console","warn","resetBoundedAwaitWarningsForTests","clear","boundedAwait","work","fallback","controller","AbortController","timer","started","signal","error","Promise","reject","deadline","resolve","setTimeout","abort","Error","race","finally","clearTimeout","isThenable","value","then","createSettledValueCache","entries","cache","lookup","key","undefined","expires","delete","ttlMs","TypeError","readThrough","load","ttlFor"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GAED,4EAA4E,GAc5E;;;;CAIC,GACD,MAAMA,iBAAiB;AACvB,MAAMC,aAAa,IAAIC;AAEvB,SAASC,YAAYC,KAAa,EAAEC,EAAU;;IAC5C,MAAMC,QAAQC,KAAKC,GAAG;IACtB,MAAMC,OAAOR,WAAWS,GAAG,CAACN;IAC5B,IAAIK,QAAQH,QAAQG,KAAKE,IAAI,GAAGX,gBAAgB;QAC9CS,KAAKG,UAAU,IAAI;QACnB;IACF;IACA,MAAMC,OAA4B;QAChCC,OAAO;QACPV;QACAC;QACAO,UAAU,UAAEH,wBAAAA,KAAMG,UAAU,mBAAI;IAClC;IACAX,WAAWc,GAAG,CAACX,OAAO;QAAEO,MAAML;QAAOM,YAAY;IAAE;IACnDI,QAAQC,IAAI,CAAC,uDAAuDJ;AACtE;AAEA,gDAAgD,GAChD,OAAO,SAASK;IACdjB,WAAWkB,KAAK;AAClB;AAEA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,aACdC,IAAoB,EACpBhB,EAAU,EACViB,QAAW,EACXlB,KAAa;IAEb,MAAMmB,aAAa,IAAIC;IACvB,IAAIC;IACJ,IAAIC;IACJ,IAAI;QACFA,UAAU,OAAOL,SAAS,aAAaA,KAAKE,WAAWI,MAAM,IAAIN;IACnE,EAAE,OAAOO,OAAO;QACd,OAAOC,QAAQC,MAAM,CAACF;IACxB;IACA,MAAMG,WAAW,IAAIF,QAAW,CAACG;QAC/BP,QAAQQ,WAAW;YACjBV,WAAWW,KAAK,CAAC,IAAIC,MAAM,GAAG/B,MAAM,YAAY,EAAEC,GAAG,YAAY,CAAC;YAClEF,YAAYC,OAAOC;YACnB2B,QAAQV;QACV,GAAGjB;IACL;IACA,OAAOwB,QAAQO,IAAI,CAAC;QAACV;QAASK;KAAS,EAAEM,OAAO,CAAC,IAAMC,aAAab;AACtE;AAsBA,SAASc,WAAWC,KAAc;IAChC,OACE,AAAC,CAAA,OAAOA,UAAU,YAAY,OAAOA,UAAU,UAAS,KACxDA,UAAU,QACV,OAAO,AAACA,MAA6BC,IAAI,KAAK;AAElD;AAEA;;;CAGC,GACD,OAAO,SAASC;IACd,MAAMC,UAAU,IAAIzC;IACpB,MAAM0C,QAAiC;QACrCC,QAAOC,GAAG,EAAExC,QAAQC,KAAKC,GAAG,EAAE;YAC5B,MAAMC,OAAOkC,QAAQjC,GAAG,CAACoC;YACzB,IAAI,CAACrC,MAAM,OAAOsC;YAClB,IAAItC,KAAKuC,OAAO,IAAI1C,OAAO;gBACzBqC,QAAQM,MAAM,CAACH;gBACf,OAAOC;YACT;YACA,OAAO;gBAAEP,OAAO/B,KAAK+B,KAAK;YAAC;QAC7B;QACAzB,KAAI+B,GAAG,EAAEN,KAAK,EAAEU,KAAK,EAAE5C,QAAQC,KAAKC,GAAG,EAAE;YACvC,IAAI+B,WAAWC,QAAQ;gBACrB,MAAM,IAAIW,UACR;YAEJ;YACAR,QAAQ5B,GAAG,CAAC+B,KAAK;gBAAEN;gBAAOQ,SAAS1C,QAAQ4C;YAAM;QACnD;QACA,MAAME,aAAYN,GAAG,EAAEO,IAAI,EAAEC,MAAM;YACjC,MAAM7C,OAAOmC,MAAMC,MAAM,CAACC;YAC1B,IAAIrC,MAAM,OAAOA,KAAK+B,KAAK;YAC3B,MAAMA,QAAQ,MAAMa;YACpBT,MAAM7B,GAAG,CAAC+B,KAAKN,OAAOc,OAAOd;YAC7B,OAAOA;QACT;QACAS,QAAOH,GAAG;YACRH,QAAQM,MAAM,CAACH;QACjB;QACA3B;YACEwB,QAAQxB,KAAK;QACf;IACF;IACA,OAAOyB;AACT"}