@nxtedition/scheduler 4.1.11 → 4.1.13

package/README.md

@@ -62,7 +62,7 @@ Unspecified priorities inherit the cap from the priority just below them — cap
 
 #### Starvation prevention
 
-Per-priority caps act as backpressure: when running tasks exceed a priority's cap, new tasks at that priority queue. If higher-priority tasks keep arriving, the capped queue could be starved indefinitely. To prevent that, the dispatch loop's fairness lottery (already used to give lower priorities a turn under uniform concurrency) **bypasses per-priority caps** when it picks a queued priority — so a fully-capped queue still drains slowly. The overall `max` is still respected.
+Per-priority caps act as backpressure: when running tasks exceed a priority's cap, new tasks at that priority queue. If higher-priority tasks keep arriving, the capped queue could be starved indefinitely. To prevent that, the dispatch loop's fairness lottery (already used to give lower priorities a turn under uniform concurrency) **bypasses per-priority caps** when it picks a queued priority — so a fully-capped queue still drains slowly. The overall `max` is still respected. When the lottery picks an empty tier, its share goes to the highest-priority backlogged queue (within caps), so unused tiers never inflate lower-priority throughput.
 
 In `SharedArrayBuffer` mode, the second constructor argument carries per-priority limits (the buffer carries `max` across workers):
 
@@ -79,9 +79,9 @@ For more control, use `acquire` / `release` directly:
 
 ```js
 scheduler.acquire(
-  (opaque) => {
+  async (opaque) => {
     try {
-      doWork(opaque)
+      await doWork(opaque)
     } finally {
       scheduler.release()
     }
@@ -91,6 +91,8 @@ scheduler.acquire(
 )
 ```
 
+**Error contract:** if `fn` throws **synchronously**, the scheduler releases the slot itself (the error propagates to the `acquire()` caller on the fast path, and surfaces as a deferred uncaught exception when thrown from a queued dispatch). Do **not** also call `release()` on the synchronous-throw path — a `try`/`finally` around _synchronous_ work would double-release and free a slot belonging to some other in-flight task. With an `async` callback as above the `finally` is correct: a rejecting async function does not throw synchronously, so the slot is yours to release exactly once.
+
 ### Multi-Worker Coordination
 
 Share a concurrency limit across worker threads using `SharedArrayBuffer`:
@@ -115,6 +117,27 @@ The global `max` is a hard cap across all workers — a worker that finds the gl
 
 `Atomics.waitAsync` does not keep the Node event loop alive. If a worker is fully idle (`running === 0`) with tasks queued waiting for capacity, you need something else holding the loop open — usually trivial in real applications (HTTP servers, intervals, etc.), but standalone scripts may need a `setInterval(() => {}, …)` until their work is done.
 
+### Child Schedulers (hierarchical limits)
+
+`scheduler.child(opts?)` creates a child that enforces an **additional** concurrency limit _on top of_ its parent. A task dispatched through a child runs only when it is admitted by **both** the child's own per-priority cap **and** the parent's overall `max`. This composes the classic "global pool of N, M per worker" shape: a shared parent caps total concurrency across the whole process while each worker uses a local child to cap its own share.
+
+```js
+// main.js — one shared global pool of 16
+const sharedState = Scheduler.makeSharedState(16)
+for (let i = 0; i < 4; i++) new Worker('./worker.js', { workerData: sharedState })
+
+// worker.js — at most 4 concurrent reads on THIS worker, ≤16 across the whole process
+const parent = new Scheduler(workerData)
+const reads = parent.child({ concurrency: 4 })
+const data = await reads.run(() => fs.readFile(path), 'high')
+```
+
+- `opts` mirrors the constructor (`{ concurrency }`), so children get their own per-priority caps too: `parent.child({ concurrency: { max: 4, low: 1 } })`. Omit it for an unlimited local cap (only the parent constrains).
+- The child has its own independent **priority lottery and starvation prevention**; the parent's overall `max` is the global gate — a **soft limit** when the parent/root is shared (the same bounded read-then-increment overshoot across workers as a plain shared `Scheduler`; see the dispose note above). The parent's _own_ per-priority caps constrain only tasks submitted **directly** to the parent — child tasks see the parent solely as an overall `max`.
+- Children may be **nested** arbitrarily; the tightest cap in the chain wins, and every level's `max` is enforced.
+- A child is a local (non-shared) scheduler that delegates all global accounting — and, when the root is shared, all cross-thread waiting — up the parent chain; only the root touches the `SharedArrayBuffer`.
+- `child[Symbol.dispose]()` returns the child's in-flight slots to the parent, rejects its queued `run()` promises, and unregisters it. Disposing a parent disposes its descendants. Children of a long-lived shared root live until process exit unless disposed — dispose short-lived children explicitly.
+
 ### UV Thread Pool Scheduling
 
 A practical use case is coordinating access to the libuv thread pool (`UV_THREADPOOL_SIZE`) across multiple worker threads. For example, several HTTP file-serving workers can share a scheduler so that file-system operations (which consume UV thread pool slots) are prioritized and throttled globally:
@@ -186,23 +209,39 @@ const { running, pending, queues } = scheduler.stats
 
 ### `scheduler.run(fn, priority?, opaque?): Promise<T>`
 
-Execute `fn` within the scheduler. Returns a promise that resolves with the return value of `fn`. After the scheduler has been disposed, `run()` rejects with `Error('Scheduler is disposed')` instead of hanging.
+Execute `fn` within the scheduler. Returns a promise that resolves with the return value of `fn` (thenables are assimilated via `Promise.resolve`). After the scheduler has been disposed, `run()` rejects with `Error('Scheduler is disposed')` instead of hanging; with an overall concurrency of `0` (which could never dispatch anything) it rejects with `Error('Scheduler concurrency is 0')`.
 
 ### `scheduler.acquire(fn, priority?, opaque?): boolean`
 
-Low-level task acquisition. Returns `true` if a slot was available and `fn` ran synchronously, or `false` if the task was queued (also `false` if the scheduler has been disposed). You **must** call `scheduler.release()` when `fn` completes.
+Low-level task acquisition. Returns `true` if a slot was available and `fn` ran synchronously, or `false` if the task was queued (also `false` if the scheduler has been disposed). The fast path additionally requires that nothing is queued at the same priority, preserving FIFO order within a priority; a fresh task can still start ahead of work queued at a _different_ priority while a freed slot is in flight (a deliberate latency trade-off, bounded to a microtask in shared mode). You **must** call `scheduler.release()` when `fn` completes — except when `fn` throws synchronously, in which case the scheduler has already released the slot (see the Low-Level API example).
+
+### `scheduler.tryAcquire(priority?): boolean`
+
+Non-blocking. Takes a slot and returns `true` only if one is free at the given priority **and** nothing is queued at that priority (mirroring `limiter.tryConsume`); otherwise returns `false` without queuing. A successful `tryAcquire` must be paired with `release()`.
 
 ### `scheduler.release(): void`
 
 Signal task completion. Dequeues the next pending task if concurrency allows.
 
+### `scheduler.concurrency`
+
+The overall concurrency ceiling (`Infinity` when unlimited). In shared mode this is the buffer's global `max`; a per-instance `options.concurrency.max` is enforced but not reflected here.
+
+### `scheduler.stats`
+
+`{ running, pending, queues, shared }` — locally running tasks, locally queued tasks, per-priority queue counts, and (shared mode only) the global `{ running, waiters }` counters. Allocates fresh objects on every read; poll accordingly.
+
+### `scheduler.child(opts?): Scheduler`
+
+Create a child scheduler that enforces an additional concurrency limit on top of this one (see [Child Schedulers](#child-schedulers-hierarchical-limits)). `opts` mirrors the constructor (`{ concurrency }`, a number or per-priority object); omit it for an unlimited local cap. A task runs only when admitted by both the child's cap and the parent's overall `max`. Returns a fully-featured `Scheduler` (`run` / `acquire` / `tryAcquire` / `release` / `stats` / `Symbol.dispose`). Throws if the parent is disposed.
+
 ### `Scheduler.makeSharedState(concurrency): SharedArrayBuffer`
 
-Create shared state for cross-worker scheduling.
+Create shared state for cross-worker scheduling. `concurrency` must be `Infinity` or a non-negative integer that fits in a signed 32-bit integer (≤ 2,147,483,647) — the counter is stored as `Int32`.
 
 ### `scheduler[Symbol.dispose]()`
 
-Disposes the scheduler: releases any global slots it still holds (shared mode), drops the reference to a pending shared-mode `Atomics.waitAsync`, and makes all further calls inert (`acquire` / `tryAcquire` return `false`; `run` rejects). Use when abandoning a shared-mode Scheduler with tasks still queued so the instance and its parked wait can be garbage-collected (it is otherwise kept alive until process exit so its held slots can be released). Works with `using`.
+Disposes the scheduler: releases any global slots it still holds (shared mode), rejects queued `run()` promises with `Error('Scheduler is disposed')`, drops the reference to a pending shared-mode `Atomics.waitAsync`, and makes all further calls inert (`acquire` / `tryAcquire` return `false`; `run` rejects). Use when abandoning a shared-mode Scheduler with tasks still queued so the instance and its parked wait can be garbage-collected (it is otherwise kept alive until process exit so its held slots can be released). Works with `using`. Note that slots held by still-in-flight tasks are returned to the shared pool immediately — until those tasks actually finish, other workers can transiently admit more than `max` (the limit is soft by design). Disposing a scheduler also disposes its [children](#child-schedulers-hierarchical-limits); disposing a child returns its in-flight slots to the parent and unregisters it.
 
 ### `parsePriority(value): number`
 
@@ -216,7 +255,7 @@ Parse a string or number into a normalized priority value.
 
 > Previously exported as `Throttle`. The `Throttle` alias is retained for backward compatibility but is **deprecated** — prefer `Limiter`.
 
-Tokens refill automatically: the constructor starts an internal `unref()`'d timer, and refills are also triggered lazily from `consume()` / `tryConsume()`. There is no manual refill step.
+Tokens refill automatically: the constructor starts an internal timer, and refills are also triggered lazily from `consume()` / `tryConsume()`. There is no manual refill step. While work is queued the timer holds the event loop open (so a script never exits with queued callbacks silently dropped); an idle limiter does not keep the process alive.
 
 ### Basic
 
@@ -284,7 +323,24 @@ const ran = limiter.consume(
 )
 ```
 
-`consume` returns `true` if the callback ran immediately (tokens were available and nothing was queued ahead of it), or `false` if it was queued.
+`consume` returns `true` if the callback ran immediately (tokens were available and nothing was queued ahead of it — the call refills the bucket from elapsed time first, so an idle or freshly created limiter answers `true` when the credit covers the request), or `false` if it was queued. Note the boundary is not airtight: a `false` (queued) task can still run synchronously _within_ the same call when the drain the call triggers reaches it immediately.
+
+### Child Limiters (hierarchical rates)
+
+`limiter.child(opts)` creates a child token bucket that enforces an **additional** rate _on top of_ its parent. A `consume` of N tokens through the child runs only when N tokens are available in **both** the child's own bucket **and** the parent chain's bucket(s), and the N tokens are debited from every level — exactly mirroring `Scheduler.child()`, for byte-rate instead of concurrency. The canonical shape is a shared parent capping the aggregate rate while each worker caps its own share:
+
+```js
+// main.js — 16 MB/s shared across the whole process
+const sharedState = Limiter.makeSharedState(16_000_000)
+for (let i = 0; i < 4; i++) new Worker('./worker.js', { workerData: sharedState })
+
+// worker.js — at most 4 MB/s on THIS worker, ≤16 MB/s across the process
+const parent = new Limiter(workerData)
+const out = parent.child({ tokensPerSecond: 4_000_000 })
+out.consume(() => send(chunk), chunk.length, 'high')
+```
+
+Priorities, `stream()`, and the ~1s anti-starvation force-through all work as usual and apply per level (a forced item is charged into debt on the whole chain, so each level's long-run rate still holds). The child has its own refill timer; the parent needs no knowledge of its children. Children may be nested.
 
 ## API
 
@@ -297,22 +353,74 @@ const ran = limiter.consume(
 
 Consume `bytes` tokens, running `fn(opaque)` when they are available. Returns `true` if `fn` ran immediately, `false` if it was queued. `opaque` is passed through to `fn` on both paths.
 
-`bytes` must be a non-negative integer no larger than 2,147,483,647 (the signed Int32 max — tokens are tracked as `Int32`); negative, non-integer, `NaN`, `Infinity`, and out-of-range values throw (a negative or wrapping value would otherwise _add_ tokens via `Atomics.sub` and corrupt the shared bucket). A `bytes` of `0` consumes no tokens and never waits on the bucket. It runs immediately, returning `true`, only when nothing is queued at all (`pending === 0`); otherwise `consume` returns `false`, but the task is still serviced on the very next drain (which the call itself triggers) regardless of the token balance — even while the bucket is empty or in debt. So a weightless task is never blocked by a starved bucket, and it can drain ahead of token-starved work (priority is still honored among tasks that fit). A request larger than `tokensPerSecond` (the bucket's capacity) can never fit a full bucket; rather than stalling forever it is admitted once the bucket fills, drawing the bucket into debt that subsequent refills repay before any other work drains — i.e. it is throttled, not dropped.
+`bytes` must be a non-negative integer no larger than 2,147,483,647 (the signed Int32 max — tokens are tracked as `Int32`); negative, non-integer, `NaN`, `Infinity`, and out-of-range values throw (a negative or wrapping value would otherwise _add_ tokens via `Atomics.sub` and corrupt the shared bucket). A `bytes` of `0` consumes no tokens and never waits on the bucket. It runs immediately, returning `true`, only when nothing is queued at all (`pending === 0`); otherwise `consume` returns `false`, but once it reaches the front of its priority queue it drains regardless of the token balance — even while the bucket is empty or in debt. Queued behind token-starved work at the same priority it waits its turn like any other task (FIFO head-of-line; a different, unblocked priority queue can drain it sooner).
+
+**Starvation guard:** a queued task larger than the instantaneous token balance could otherwise starve under sustained traffic — smaller tasks would keep spending each refill's credit first. Any queue whose front item makes no progress for ~1 second is force-admitted into token debt; the negative balance is repaid by subsequent refills before anything else drains, so the long-run rate still holds (the trade-off is a transient burst, at most one stalled item per queue per second). The same mechanism bounds the wait for a request larger than `tokensPerSecond` (the bucket's capacity, which it could never fit): it is admitted once the bucket fills **or** the ~1s stall guard fires, whichever comes first — i.e. it is throttled, not dropped or stalled forever. In shared mode the guard is per-instance best-effort: other workers may keep consuming the shared bucket.
 
 ### `limiter.tryConsume(bytes): boolean`
 
 Non-blocking. Consumes `bytes` and returns `true` only if enough tokens are available right now and nothing is queued; otherwise returns `false` without queuing.
 
+### `limiter.tokensPerSecond`
+
+The configured rate (and bucket capacity).
+
+### `limiter.stats`
+
+`{ tokens, pending, queues }` — current token balance (negative while in debt), queued tasks, and per-priority queue counts. Allocates fresh objects on every read.
+
 ### `limiter.stream(priority?, options?): Transform`
 
 Returns a `Transform` stream that rate-limits data passing through it. Each chunk consumes `chunk.length` tokens; a chunk with no non-negative-integer `length` (e.g. in `objectMode`) is treated as weightless (0 tokens) — it never waits on tokens, though it still preserves the limiter's queue ordering (if other work is already queued, it drains in turn rather than jumping ahead). `options` is forwarded to the underlying `Transform` (e.g. `objectMode`, `highWaterMark`). Destroying the stream while a chunk is still queued in the limiter does not push into the dead stream.
 
+### `limiter.child(opts): Limiter`
+
+Create a child limiter that enforces an additional rate on top of this one (see [Child Limiters](#child-limiters-hierarchical-rates)). `opts` mirrors the constructor (`{ tokensPerSecond }`). A `consume` runs only when its tokens fit both the child's bucket and the parent chain's, and is debited from both. Returns a fully-featured `Limiter` (`consume` / `tryConsume` / `stream` / `stats`).
+
 ### `Limiter.makeSharedState(tokensPerSecond): SharedArrayBuffer`
 
 Create shared state for cross-worker rate limiting.
 
 ---
 
+## Performance
+
+Microbenchmarks from `bench.js` on an AMD EPYC (linux-x64, Node 26). `Mops/s` = millions of ops/sec; higher is better. Numbers are indicative and machine-dependent — run `node --expose-gc bench.js` to reproduce.
+
+### Scheduler hot paths (single thread)
+
+| Operation                                 | Throughput  |
+| ----------------------------------------- | ----------- |
+| `acquire`+`release` (unlimited, no queue) | ~110 Mops/s |
+| `tryAcquire` fast path                    | ~150 Mops/s |
+| `acquire`+`release` (SharedArrayBuffer)   | ~38 Mops/s  |
+| queue drain (concurrency=1, batch)        | ~37 Mops/s  |
+| `run()` (sync body, Promise per task)     | ~4 Mops/s   |
+
+### `child()` overhead (single thread)
+
+A child adds a local per-priority gate plus one parent-chain acquire/release per task:
+
+| Operation                                       | Throughput |
+| ----------------------------------------------- | ---------- |
+| `acquire`+`release` (parent only)               | ~71 Mops/s |
+| `acquire`+`release` (through 1 child)           | ~36 Mops/s |
+| `acquire`+`release` (through 2 nested children) | ~24 Mops/s |
+| child queue drain (cap=1, batch)                | ~20 Mops/s |
+
+### With vs without per-worker `child()` (8 workers, shared global cap=8)
+
+The overhead that matters in practice is end-to-end, where real per-task work dominates the extra bookkeeping. With realistic ~50µs tasks a per-worker `child()` costs only **~4%**:
+
+| Workload (8 workers)                | Plain        | With `child(4)` | Overhead |
+| ----------------------------------- | ------------ | --------------- | -------- |
+| 0µs tasks (pure scheduler overhead) | ~1.45 Mops/s | ~1.38 Mops/s    | ~5%      |
+| 50µs tasks (realistic)              | ~132 Kops/s  | ~127 Kops/s     | ~4%      |
+
+> An earlier revision sharded the global `RUNNING`/`WAITERS` counters across cache lines to cut contention. Benchmarking on the x64 target showed it was a **net regression** (~25% slower at 32 workers): `RUNNING` is read on every acquire, so aggregating shards costs more coherency traffic than the single-line write contention it avoids. It was reverted to a single counter.
+
+---
+
 ## License
 
 MIT

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export { Scheduler } from './scheduler.ts';
+export type { ConcurrencyOptions } from './scheduler.ts';
 export { Limiter } from './limiter.ts';
 /** @deprecated Use `Limiter` instead. */
 export { Limiter as Throttle } from './limiter.ts';

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,yCAAyC;AACzC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAClD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,yCAAyC;AACzC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAClD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,yCAAyC;AACzC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,yCAAyC;AACzC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}

package/lib/limiter.d.ts

@@ -13,6 +13,27 @@ export declare class Limiter extends Queue {
         }[];
     };
     get tokensPerSecond(): number;
+    /**
+     * Create a child Limiter that enforces an ADDITIONAL token-rate limit on top of this
+     * (the parent). A consume of N tokens through the child runs only when N tokens are
+     * available in BOTH the child's own bucket AND the parent chain's bucket(s), and the N
+     * tokens are debited from every level.
+     *
+     * Canonical use: a shared parent caps the aggregate rate (e.g. 16 MB/s across the whole
+     * process) while each worker uses a local child to cap its own share (e.g. 4 MB/s):
+     *
+     *   const parent = new Limiter(Limiter.makeSharedState(16_000_000))  // global rate
+     *   const out = parent.child({ tokensPerSecond: 4_000_000 })         // this worker's rate
+     *   out.consume(() => send(chunk), chunk.length, 'high')
+     *
+     * `opts` mirrors the constructor's options. Priorities, streaming, and the ~1s
+     * anti-starvation force-through all work as usual and apply per level (a forced item is
+     * debited into debt on the whole chain). The child has its own refill timer; the parent
+     * needs no knowledge of its children.
+     */
+    child(opts: {
+        tokensPerSecond: number;
+    }): Limiter;
     constructor(opts: SharedArrayBuffer | {
         tokensPerSecond: number;
     });

package/lib/limiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limiter.d.ts","sourceRoot":"","sources":["../src/limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAuC,KAAK,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AA0BtF,qBAAa,OAAQ,SAAQ,KAAK;;IAChC,OAAO,CAAC,SAAS,CAAY;IAE7B,OAAO,CAAC,OAAO,CAAI;IAUnB,MAAM,CAAC,eAAe,CAAC,eAAe,EAAE,MAAM;IAS9C,IAAI,KAAK;;;;;;MAMR;IAED,IAAI,eAAe,WAElB;gBAEW,IAAI,EAAE,iBAAiB,GAAG;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;IAwBjE,MAAM,CAAC,QAAQ,GAAE,QAAuB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAoBpE,OAAO,CAAC,EAAE,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO;IACvE,OAAO,CAAC,CAAC,EACP,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,EAC1B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAC9B,MAAM,EAAE,CAAC,GACR,OAAO;IAmDV,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CA8LnC"}
+{"version":3,"file":"limiter.d.ts","sourceRoot":"","sources":["../src/limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE9D,OAAO,EAAuC,KAAK,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AAqCtF,qBAAa,OAAQ,SAAQ,KAAK;;IAChC,OAAO,CAAC,SAAS,CAAY;IAgB7B,OAAO,CAAC,OAAO,CAAI;IAoBnB,MAAM,CAAC,eAAe,CAAC,eAAe,EAAE,MAAM;IAS9C,IAAI,KAAK;;;;;;MAMR;IAED,IAAI,eAAe,WAElB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,IAAI,EAAE;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;gBAMrC,IAAI,EAAE,iBAAiB,GAAG;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;IA6BjE,MAAM,CAAC,QAAQ,GAAE,QAAuB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IA8BpE,OAAO,CAAC,EAAE,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO;IACvE,OAAO,CAAC,CAAC,EACP,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,EAC1B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAC9B,MAAM,EAAE,CAAC,GACR,OAAO;IAyEV,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAmUnC"}