@nimbus-sh/fabric 0.1.0 → 0.2.0

package/src/workerd-facet-host.ts

@@ -13,20 +13,25 @@
  * `HostedProcess` and never imports this file.
  */
 
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import {
   getCtxExports,
+  stagedBootAssembler,
   supervisorEntrypoint,
   supervisorEntrypointName,
-} from './ctx-exports.js';
+} from './composition.js';
 import {
+  assertModuleMapWithinCodeLimit,
   beginLoaderFetch,
+  facetNameCount,
+  facetNameCountDurable,
+  recordFacetNameMinted,
   recordLoaderId,
   withDynamicWorkerCapNamed,
-} from './loader-ledger.js';
+  withFacetBudgetNamed,
+} from './budgets.js';
 import {
   RESIDENT_PROCESS_CLASS,
-  requireStagedBootAssembler,
   residentLoaderConfig,
   type HostedProcess,
   type OneShotCodeSpec,
@@ -91,71 +96,6 @@ export async function createLoadedWorkerEntrypoint(
   });
 }
 
-/**
- * Total bytes a dynamic Worker's module map may carry, across every member of
- * it. A hard platform limit, not a policy knob: 62 MiB lands and 64 MiB is
- * refused with "Dynamic Worker code size (N bytes) exceeds the maximum allowed
- * size of 67108864 bytes", confirmed at five sizes with two trials each. The
- * budget is shared, so a ruby process is already 34.3 MiB down before its disk
- * is counted.
- */
-export const DYNAMIC_WORKER_CODE_LIMIT_BYTES = 67_108_864;
-
-/**
- * Refuse a module map over {@link DYNAMIC_WORKER_CODE_LIMIT_BYTES}, naming
- * the largest members. The platform's own refusal reports one number for a
- * budget shared across every member of the map, which tells the operator
- * nothing about WHAT to shrink — so every fabric seam that assembles a map
- * runs this before the loader sees it.
- *
- * Costed to its two paths. Under the ceiling: one length read per member —
- * UTF-16 code units for text, which equal UTF-8 bytes for the ASCII module
- * text the generators emit and undercount otherwise; the platform's own
- * refusal still backstops the exotic case, because this check exists to name
- * members, not to be the ceiling. Over it: exact UTF-8 sizes, computed only
- * then, sorted so the biggest lever is first.
- */
-export function assertModuleMapWithinCodeLimit(modules: Record<string, unknown>): void {
-  let estimate = 0;
-  for (const content of Object.values(modules)) {
-    estimate += memberBytes(content, null);
-  }
-  if (estimate <= DYNAMIC_WORKER_CODE_LIMIT_BYTES) return;
-
-  const encoder = new TextEncoder();
-  const sized = Object.entries(modules)
-    .map(([name, content]) => ({ name, bytes: memberBytes(content, encoder) }))
-    .sort((a, b) => b.bytes - a.bytes);
-  const total = sized.reduce((sum, member) => sum + member.bytes, 0);
-  const top = sized.slice(0, 5)
-    .map(({ name, bytes }) => `'${name}' (${bytes.toLocaleString('en-US')} bytes)`)
-    .join(', ');
-  throw new Error(
-    `Nimbus: dynamic-worker module map is ${total.toLocaleString('en-US')} bytes, over the `
-      + `${DYNAMIC_WORKER_CODE_LIMIT_BYTES.toLocaleString('en-US')}-byte platform ceiling shared by `
-      + `every member. Largest members: ${top}`,
-  );
-}
-
-/**
- * Bytes one module-map member carries, across the loader's content kinds
- * (plain string, `{ js | cjs | py | text }`, `{ wasm | data }`). With an
- * encoder, text is measured exactly; without one, by code-unit length.
- */
-function memberBytes(content: unknown, encoder: TextEncoder | null): number {
-  const textBytes = (text: string): number =>
-    encoder ? encoder.encode(text).byteLength : text.length;
-  if (typeof content === 'string') return textBytes(content);
-  if (content !== null && typeof content === 'object') {
-    for (const value of Object.values(content)) {
-      if (typeof value === 'string') return textBytes(value);
-      if (value instanceof ArrayBuffer) return value.byteLength;
-      if (ArrayBuffer.isView(value)) return value.byteLength;
-    }
-  }
-  return 0;
-}
-
 // ── Facet plumbing ──────────────────────────────────────────────────────────
 
 /** The subset of a facet stub a resident process exposes to whoever opened it. */
@@ -178,7 +118,7 @@ interface FacetContainer {
   /**
    * Present on deployed Cloudflare workerd, absent from the pinned
    * `@cloudflare/workers-types` and from local workerd ≤ 1.20260603.1 — see
-   * {@link cloneFacetStorage}, the one way the fabric calls it.
+   * {@link cloneStorage}, the one way the fabric calls it.
    */
   clone?(src: string, dst: string): void;
 }
@@ -203,7 +143,7 @@ interface WorkerLoaderBinding {
 }
 
 /**
- * The bindings `openResidentFacet` needs off whichever DO is hosting. A
+ * The bindings `processes` needs off whichever DO is hosting. A
  * staged boot's assembler may read more off the same env (Nimbus's reads
  * ASSETS); the env travels to it whole, so nothing further is named here.
  */
@@ -250,7 +190,7 @@ function facetContainer(ctx: DurableObjectState): FacetContainer {
  * storage budget grants no copy-on-write credit — crossing it resets the
  * object rather than raising an error.
  */
-export async function cloneFacetStorage(
+export async function cloneStorage(
   ctx: DurableObjectState,
   clone: {
     src: string;
@@ -300,17 +240,6 @@ export function residentFacetName(slot: number): string {
   return `proc-slot-${slot}`;
 }
 
-/**
- * Facet IDs a Durable Object is granted over its LIFETIME. Append-only and
- * never reclaimed, so crossing it is unrecoverable for the object — which is
- * why the ledger below counts consumption durably instead of leaving the
- * bound as prose the slot book merely respects.
- */
-export const FACET_ID_LIFETIME_BUDGET = 65_536;
-
-/** Where the ledger persists the count of facet names ever minted. */
-export const FACET_NAME_HIGH_WATER_KEY = 'fabric_facet_name_high_water';
-
 /** One hosting actor's slot book. */
 interface SlotBook {
   /** Returned slots, lowest reused first so the high-water mark stays low. */
@@ -319,16 +248,6 @@ interface SlotBook {
   next: number;
   /** Slot held by each live pid, so release can find it. */
   held: Map<number, number>;
-  /**
-   * The durable high-water of names ever minted, as an adopt-then-advance
-   * chain. It starts as the read of {@link FACET_NAME_HIGH_WATER_KEY} and
-   * every later link writes only a LARGER count — a fresh incarnation restarts
-   * `next` at zero, and a write that had not adopted first would clobber the
-   * lifetime count down to this incarnation's. The chain never rejects.
-   */
-  ledger: Promise<number>;
-  /** The largest count the chain has adopted or written, for sync reads. */
-  ledgerKnown: number;
 }
 
 /**
@@ -351,46 +270,12 @@ const slotBooks = new WeakMap<DurableObjectState, SlotBook>();
 function slotBook(ctx: DurableObjectState): SlotBook {
   let book = slotBooks.get(ctx);
   if (!book) {
-    const created: SlotBook = {
-      free: [],
-      next: 0,
-      held: new Map(),
-      ledger: Promise.resolve(0),
-      ledgerKnown: 0,
-    };
-    created.ledger = Promise.resolve(ctx.storage.get(FACET_NAME_HIGH_WATER_KEY))
-      .then((value) => (typeof value === 'number' ? value : 0))
-      .catch(() => 0)
-      .then((adopted) => {
-        created.ledgerKnown = Math.max(created.ledgerKnown, adopted);
-        return adopted;
-      });
-    book = created;
+    book = { free: [], next: 0, held: new Map() };
     slotBooks.set(ctx, book);
   }
   return book;
 }
 
-/**
- * The lifetime facet-ID ledger: how many facet names this fabric has ever
- * minted on the Durable Object, against the 65,536 the platform will ever
- * grant it. `consumed` only ever counts FIRST uses — a reused name, in this
- * incarnation or any earlier one, cost no new ID, which is the slot book's
- * whole reason to exist. Surfaced so an operator can see proximity to a wall
- * whose crossing is unrecoverable, instead of discovering it from the
- * platform's opaque failure.
- */
-export async function facetIdBudget(
-  ctx: DurableObjectState,
-): Promise<{ consumed: number; budget: number }> {
-  const book = slotBook(ctx);
-  const durable = await book.ledger;
-  return {
-    consumed: Math.max(durable, book.next),
-    budget: FACET_ID_LIFETIME_BUDGET,
-  };
-}
-
 /** Take a slot for `pid`, reusing a returned one before minting a new name. */
 function acquireSlot(ctx: DurableObjectState, pid: number): number {
   const book = slotBook(ctx);
@@ -399,49 +284,12 @@ function acquireSlot(ctx: DurableObjectState, pid: number): number {
   const reused = book.free.length > 0;
   const slot = reused ? book.free.shift()! : book.next++;
   book.held.set(pid, slot);
-  if (!reused) recordNameMinted(ctx, book);
+  // A fresh name is a permanently consumed facet ID; the durable count lives
+  // in the budgets ledger (see budgets.ts).
+  if (!reused) recordFacetNameMinted(ctx, book.next);
   return slot;
 }
 
-/**
- * Advance the durable ledger to this incarnation's name count, if it is a new
- * lifetime high. Chained behind adoption so the comparison is always against
- * the real persisted value; a failed write leaves the old link's count and the
- * next mint tries again — the ledger may transiently undercount, never over.
- */
-function recordNameMinted(ctx: DurableObjectState, book: SlotBook): void {
-  const count = book.next;
-  book.ledger = book.ledger.then(async (durable) => {
-    if (count <= durable) return durable;
-    try {
-      await ctx.storage.put(FACET_NAME_HIGH_WATER_KEY, count);
-    } catch {
-      return durable;
-    }
-    book.ledgerKnown = Math.max(book.ledgerKnown, count);
-    return count;
-  });
-}
-
-/**
- * Name the facet-ID budget on a creation failure at the wall; below it, hand
- * the error back untouched. Exhaustion is the one failure here the platform
- * reports opaquely AND that no teardown, retry or reset can undo, so the
- * ledger — the only witness to the real cause — does the naming. Not a
- * threshold: the comparison is against the budget itself.
- */
-function withFacetBudgetNamed(consumed: number, error: unknown): unknown {
-  if (consumed < FACET_ID_LIFETIME_BUDGET) return error;
-  const platform = error instanceof Error ? error.message : String(error);
-  return new Error(
-    `Nimbus: facet creation failed with this Durable Object's `
-      + `${FACET_ID_LIFETIME_BUDGET.toLocaleString('en-US')} facet-ID lifetime budget consumed `
-      + `(${consumed} facet names ever created). Facet IDs are append-only and never reclaimed, `
-      + `so this failure is permanent for the object: ${platform}`,
-    { cause: error },
-  );
-}
-
 /** Return `pid`'s slot to the free list. */
 function releaseSlot(ctx: DurableObjectState, pid: number): void {
   const book = slotBook(ctx);
@@ -454,7 +302,7 @@ function releaseSlot(ctx: DurableObjectState, pid: number): void {
 
 
 /**
- * What `openResidentFacet` hands back: a running process, minus its placement.
+ * What `processes(ctx, env).spawn` hands back: a running process, minus its placement.
  *
  * `slot` rides along because the caller's `describe` needs the facet's real
  * name and the slot is not derivable from the pid — that indirection is the
@@ -464,17 +312,58 @@ function releaseSlot(ctx: DurableObjectState, pid: number): void {
 export type ResidentFacet = Omit<HostedProcess, 'describe'> & { slot: number };
 
 /**
- * Open a resident process as a facet of the actor whose `ctx` and `env` are
- * given, and start its runner.
+ * The process surface of one hosting actor: how a resident process comes
+ * into existence on workerd, and how a one-shot program runs to completion.
  *
- * This is the ONE way a resident process comes into existence, and every
+ * `spawn` is the ONE way a resident process comes into existence, and every
  * substrate goes through it: the facet host calls it with the coordinator's
  * own `ctx`, the peer host calls it — over one RPC — with a sibling session
  * DO's. Everything a substrate could plausibly want to special-case is a
  * PARAMETER here rather than a branch: which actor hosts the child, and how
  * the boot spec's by-path members are read.
  */
-export function openResidentFacet(
+export function processes(ctx: DurableObjectState, env: ResidentFacetEnv): Processes {
+  return new Processes(ctx, env);
+}
+
+export class Processes {
+  constructor(
+    private readonly ctx: DurableObjectState,
+    private readonly env: ResidentFacetEnv,
+  ) {}
+
+  /** Open a resident process as a facet of this actor, and start its runner. */
+  spawn(
+    disk: () => ResidentDiskReader,
+    supervisor: ResidentSupervisorProps,
+    params: ProcessHostParams,
+  ): ResidentFacet {
+    return spawnResident(this.ctx, this.env, disk, supervisor, params);
+  }
+
+  /**
+   * Run one program to completion as an UNKEYED dynamic worker.
+   *
+   * Unkeyed is the whole difference from `spawn`: nothing can re-resolve this
+   * worker into a later request's context, so it can never be a routeable
+   * target and never has to be released by name. It exists for the duration
+   * of one call and its stubs are dropped as that call unwinds.
+   *
+   * Shared by both substrates on purpose. `peer` places processes that have a
+   * residency to place; a one-shot has none, and shipping its fully-inline
+   * map across a sibling hop would meet the 32 MiB RPC ceiling that by-path
+   * boot specs exist to avoid — for a run that gains nothing by moving.
+   */
+  run<T>(
+    supervisor: ResidentSupervisorProps,
+    params: OneShotParams,
+    consume: (response: Response) => Promise<T>,
+  ): Promise<T> {
+    return runOneShot(this.ctx, this.env, supervisor, params, consume);
+  }
+}
+
+function spawnResident(
   ctx: DurableObjectState,
   env: ResidentFacetEnv,
   disk: () => ResidentDiskReader,
@@ -482,7 +371,6 @@ export function openResidentFacet(
   params: ProcessHostParams,
 ): ResidentFacet {
   const facets = facetContainer(ctx);
-  const book = slotBook(ctx);
   const slot = acquireSlot(ctx, params.pid);
   const name = residentFacetName(slot);
   // The start callback is the ONLY way this facet is ever created, and it
@@ -511,7 +399,7 @@ export function openResidentFacet(
     facet = facets.get(name, start);
   } catch (error) {
     releaseSlot(ctx, params.pid);
-    throw withFacetBudgetNamed(Math.max(book.ledgerKnown, book.next), error);
+    throw withFacetBudgetNamed(facetNameCount(ctx), error);
   }
 
   let disposed = false;
@@ -531,15 +419,14 @@ export function openResidentFacet(
     started = facet.startProcess(params.startArgs);
   } catch (error) {
     void release();
-    throw withFacetBudgetNamed(Math.max(book.ledgerKnown, book.next), error);
+    throw withFacetBudgetNamed(facetNameCount(ctx), error);
   }
   // The rejection that carries the platform's failure at ID exhaustion is
   // this one, and it is annotated AFTER awaiting the ledger — the first
   // failure of a fresh incarnation must compare against the persisted count,
   // not the zero its adoption read has not yet replaced.
   started = started.catch(async (error) => {
-    const durable = await book.ledger;
-    throw withFacetBudgetNamed(Math.max(durable, book.next), error);
+    throw withFacetBudgetNamed(await facetNameCountDurable(ctx), error);
   });
   // A caller reads whichever of `started` and the lifecycle it needs, so keep
   // the runtime from reporting the other as an unhandled rejection.
@@ -587,20 +474,7 @@ function residentProcessClass(
   }
 }
 
-/**
- * Run one program to completion as an UNKEYED dynamic worker.
- *
- * Unkeyed is the whole difference from `openResidentFacet`: nothing can
- * re-resolve this worker into a later request's context, so it can never be a
- * routeable target and never has to be released by name. It exists for the
- * duration of one call and its stubs are dropped as that call unwinds.
- *
- * Shared by both substrates on purpose. `peer` places processes that have a
- * residency to place; a one-shot has none, and shipping its fully-inline map
- * across a sibling hop would meet the 32 MiB RPC ceiling that by-path boot
- * specs exist to avoid — for a run that gains nothing by moving.
- */
-export async function runOneShotWorker<T>(
+async function runOneShot<T>(
   ctx: DurableObjectState,
   env: ResidentFacetEnv,
   supervisor: ResidentSupervisorProps,
@@ -679,7 +553,7 @@ async function residentWorkerConfig(
   boot: ResidentBootSpec,
 ): Promise<Record<string, unknown>> {
   const config = boot.kind === 'staged'
-    ? await requireStagedBootAssembler()(env, boot.stage)
+    ? await stagedBootAssembler()(env, boot.stage)
     : await residentLoaderConfig(boot.code, disk());
   assertModuleMapWithinCodeLimit(
     (config as { modules?: Record<string, unknown> }).modules ?? {},

package/dist/alarms.d.ts

@@ -1,134 +0,0 @@
-/**
- * alarms.ts — Durable Object alarm multiplexing + isolate-generation
- * machinery, persisted across hibernation.
- *
- * Workerd hibernates Durable Objects between requests to free memory. On
- * wake, the new isolate must rebuild its in-memory state from SQL — but it
- * also needs to know "is this the same lifecycle as before, or did workerd
- * recycle me?" That distinction matters for recovery (warmJoin vs cold init)
- * and is captured by the isolate generation, a counter persisted across
- * hibernations.
- *
- * A Durable Object has ONE alarm, and a second `setAlarm()` silently
- * overwrites the first — so every alarm-driven subsystem coordinates through
- * a single reason→deadline map and one dispatcher. Reasons are plain strings
- * registered by the embedder: `scheduleAlarm` arms one, and `dispatchAlarm`
- * runs the embedder-supplied handler for every reason whose deadline has
- * passed.
- */
-/**
- * The storage the alarm map lives in. `setAlarm` is optional because
- * `wrangler dev` serves a storage without it, which is the whole reason
- * scheduling degrades to a no-op instead of throwing.
- */
-export interface AlarmStorage {
-    get(key: string): Promise<unknown>;
-    put(key: string, value: unknown): Promise<void>;
-    delete(key: string): Promise<boolean>;
-    setAlarm?(scheduledTime: number): Promise<void>;
-}
-/** The hosting actor's context, as the alarm coordination reads it. */
-export interface AlarmContext {
-    storage: AlarmStorage;
-}
-/**
- * Multi-reason alarm coordination map.
- *
- * JSON-serialised `Record<reason, deadlineMsEpoch>` where keys are the
- * embedder's canonical reason strings (e.g. 'w9-flush', 'log-janitor'). The
- * alarm() dispatcher reads this on fire, dispatches every reason whose
- * deadline has passed, and re-arms `ctx.storage.setAlarm` at the earliest
- * remaining deadline.
- *
- * Why a map (not a single nextAlarmAt + reason): two subsystems can have
- * distinct deadlines. Without the map, the later setAlarm() call would
- * overwrite the earlier reason silently, breaking whichever subsystem
- * expected its deadline.
- *
- * Forward-compat: the dispatcher silently drops unknown reasons so a
- * rollback from a future deploy that added new reasons doesn't leave the
- * alarm stuck.
- *
- * The VALUE is live production DO storage ('w1_next_alarm_reasons', from the
- * workstream that introduced it) and must never change — renaming a storage
- * key is a migration, and orphaned rows are the least of what it breaks.
- */
-export declare const ALARM_REASONS_KEY = "w1_next_alarm_reasons";
-/**
- * Storage key for the isolate-generation counter (cold-start +
- * post-hibernation wake; one increment per fresh isolate).
- *
- * The VALUE is live production DO storage ('w9_isolate_gen') and must never
- * change, same contract as {@link ALARM_REASONS_KEY}.
- */
-export declare const ISOLATE_GEN_KEY = "w9_isolate_gen";
-/**
- * The host instance carrying the per-instance alarm chain. The field lives on
- * the embedder's DO instance so one chain serializes every alarm-map
- * read-modify-write for that instance (see {@link scheduleAlarm}).
- */
-export interface AlarmHost {
-    _alarmChain?: Promise<unknown>;
-}
-/** The host instance carrying the isolate-generation state. */
-export interface IsolateGenHost {
-    _isolateGen: number;
-    _isolateGenPersisted: boolean;
-}
-/**
- * Schedule (or re-schedule) an alarm reason. Coordinated via a single map in
- * DO storage so multiple subsystems don't clobber each other's `setAlarm()`
- * calls.
- *
- * Semantics:
- *   - Reads the existing reasons map.
- *   - Sets `map[reason] = whenMs` IF `whenMs` is sooner than the
- *     currently-pending deadline for that reason (or no entry exists).
- *     Later-than-pending requests are silently ignored — the existing
- *     alarm will fire and re-arm anyway.
- *   - Writes the map back and calls `ctx.storage.setAlarm(min(deadlines))`.
- *
- * Cost: 1 storage read + 1 storage write + 1 setAlarm per call. setAlarm
- * itself is billed as 1 row written per DO pricing. At a 60s janitor
- * cadence, this is ~$0.05/mo/session at scale — dwarfed by the
- * hibernation duration savings.
- *
- * Fail-soft: any throw is swallowed with a warn. On older runtimes /
- * wrangler-dev where setAlarm is unavailable, this is a no-op (the
- * subsystem's in-isolate setTimeout fallback continues to work).
- */
-export declare function scheduleAlarm(host: AlarmHost, ctx: AlarmContext, reason: string, whenMs: number): Promise<boolean>;
-/**
- * What one alarm handler may return: nothing, or a deadline this reason
- * re-arms itself at. Re-arming through the return value keeps the map's
- * read-modify-write inside the dispatcher, where it is serialized.
- */
-export type AlarmHandlerResult = void | {
-    rearmAt: number;
-};
-/** The embedder's reasons, each with the handler that answers it. */
-export type AlarmHandlers = Record<string, (now: number) => AlarmHandlerResult | Promise<AlarmHandlerResult>>;
-/**
- * Multi-reason alarm dispatcher. Called from the DO's `alarm()` handler with
- * the embedder's handler map.
- *
- * For each pending reason whose deadline has passed, run its handler.
- * Handlers are awaited in place: the alarm invocation is the fresh turn a
- * re-entering subsystem asked for, and it has to stay the one paying for the
- * work it just released.
- *
- * After running fireable reasons, re-arms `ctx.storage.setAlarm` at the
- * earliest remaining deadline. If no reasons remain, deletes the map key and
- * does NOT call setAlarm — the DO becomes hibernation-eligible after the 10s
- * idle window.
- *
- * Forward/back-compat: unknown reasons silently dropped. `onLegacyAlarm`
- * covers an alarm that fires with no map at all — a deploy from before the
- * map existed left a bare `setAlarm` behind, and the embedder decides what
- * that one-time fire means (one dispatch later the map is populated by the
- * next scheduleAlarm call).
- */
-export declare function dispatchAlarm(host: AlarmHost, ctx: AlarmContext, handlers: AlarmHandlers, onLegacyAlarm?: () => void): Promise<void>;
-/** Increment + persist the isolate-gen counter once per fresh isolate. */
-export declare function maybeBumpIsolateGen(host: IsolateGenHost, ctx: AlarmContext): Promise<void>;
-//# sourceMappingURL=alarms.d.ts.map

package/dist/alarms.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"alarms.d.ts","sourceRoot":"","sources":["../src/alarms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,QAAQ,CAAC,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,0BAA0B,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CAChC;AAED,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,qEAAqE;AACrE,MAAM,MAAM,aAAa,GAAG,MAAM,CAChC,MAAM,EACN,CAAC,GAAG,EAAE,MAAM,KAAK,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAClE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,GAAG,EAAE,YAAY,EACjB,QAAQ,EAAE,aAAa,EACvB,aAAa,CAAC,EAAE,MAAM,IAAI,GACzB,OAAO,CAAC,IAAI,CAAC,CASf;AAwDD,0EAA0E;AAC1E,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBhG"}