@nimbus-sh/worker 0.1.0

package/dist/_shared/exports-resolver.js

@@ -0,0 +1,284 @@
+/**
+ * exports-resolver.ts — Single source of truth for `package.json#exports` /
+ * `package.json#imports` resolution per the Node.js spec.
+ *
+ * Used in three contexts:
+ *
+ *   1. Install-time supervisor (TS) — `src/npm-resolver.ts` re-exports the
+ *      typed functions for tree resolution.
+ *
+ *   2. NimbusLoaderPool isolates (JS string) — `src/parallel/pre-bundle-preamble.ts`
+ *      embeds `getExportsResolverJS()` as part of the pool preamble so the
+ *      pre-bundle facet uses identical resolution semantics to the supervisor.
+ *
+ *   3. User-shell `node` runtime (JS string) — `src/node-shims.ts` embeds
+ *      the same JS source so `require()` from inside a user's `node` script
+ *      sees the same exports map as the install pipeline.
+ *
+ * Audit reference: audit/sections/03-resolver-gaps.md §3.1, §3.2.
+ *
+ * Spec features supported:
+ *   - String shorthand:                "exports": "./dist/index.mjs"
+ *   - Subpath maps:                    { ".": "...", "./client": "..." }
+ *   - Conditional maps (top-level):    { "import": "...", "require": "..." }
+ *   - Nested conditions:               { ".": { "node": { "default": "..." } } }
+ *   - Subpath wildcards:               { "./*": "./dist/*.js" }
+ *   - Array fallbacks:                 [ "./esm.js", "./cjs.js" ]
+ *   - `imports` field (`#name`):       same shape, same impl (re-uses resolveExports)
+ *   - Null-target enforcement:         { "./private/*": null } — returns null, blocks fallback
+ *
+ * Caller-controlled `conditions` lets the same impl serve:
+ *   - install/ESM/browser  →  ['import', 'module', 'browser', 'default']
+ *   - runtime CJS          →  ['require', 'node', 'default']
+ */
+/** Default conditions for ESM/install/browser resolution. */
+export const DEFAULT_ESM_CONDITIONS = ['import', 'module', 'browser', 'default'];
+/** Default conditions for CJS runtime resolution (user-shell node). */
+export const DEFAULT_CJS_CONDITIONS = ['require', 'node', 'default'];
+/**
+ * Resolve `package.json#exports` (or `#imports`) per Node spec.
+ *
+ * @param exportsField  Raw value from package.json#exports or #imports
+ * @param subpath       '.' for root, './foo' for subpath, '#name' for imports
+ * @param conditions    Active conditions, in priority order
+ * @returns             Relative path target string, or null if not found / forbidden
+ */
+export function resolveExports(exportsField, subpath = '.', conditions = DEFAULT_ESM_CONDITIONS) {
+    if (exportsField === undefined || exportsField === null)
+        return null;
+    // String shorthand — only valid for root entry
+    if (typeof exportsField === 'string') {
+        return subpath === '.' ? exportsField : null;
+    }
+    // Array fallback — try each in order
+    if (Array.isArray(exportsField)) {
+        for (const item of exportsField) {
+            const r = resolveExports(item, subpath, conditions);
+            if (r)
+                return r;
+        }
+        return null;
+    }
+    if (typeof exportsField !== 'object')
+        return null;
+    const keys = Object.keys(exportsField);
+    if (keys.length === 0)
+        return null;
+    // Subpath-map detection: keys begin with "." (exports) or "#" (imports)
+    const isSubpathMap = keys[0].startsWith('.') || keys[0].startsWith('#');
+    if (isSubpathMap) {
+        // Exact match first
+        if (subpath in exportsField) {
+            const target = exportsField[subpath];
+            // Null target — forbidden subpath, returns null and BLOCKS fallback
+            if (target === null)
+                return null;
+            return resolveConditionValue(target, conditions);
+        }
+        // Wildcard pattern match — try most-specific (longest prefix) first
+        const wildcardKeys = keys
+            .filter(k => k.includes('*'))
+            .sort((a, b) => b.length - a.length); // longest pattern wins
+        for (const pattern of wildcardKeys) {
+            const target = exportsField[pattern];
+            const starIdx = pattern.indexOf('*');
+            const prefix = pattern.slice(0, starIdx);
+            const suffix = pattern.slice(starIdx + 1);
+            if (subpath.startsWith(prefix) &&
+                (suffix ? subpath.endsWith(suffix) : true) &&
+                subpath.length >= prefix.length + suffix.length) {
+                // Null target on wildcard — forbidden, BLOCK fallback
+                if (target === null)
+                    return null;
+                const matched = subpath.slice(prefix.length, suffix ? subpath.length - suffix.length : undefined);
+                const resolved = resolveConditionValue(target, conditions);
+                if (resolved)
+                    return resolved.split('*').join(matched);
+            }
+        }
+        return null;
+    }
+    // Condition map (no subpath map keys) — only valid for root entry
+    if (subpath !== '.')
+        return null;
+    return resolveConditionValue(exportsField, conditions);
+}
+/**
+ * Resolve a condition target. Recurses through nested condition objects
+ * and array fallbacks. Honours `default` even if not in the conditions
+ * array (Node spec).
+ */
+function resolveConditionValue(target, conditions) {
+    if (target === null || target === undefined)
+        return null;
+    if (typeof target === 'string')
+        return target;
+    if (Array.isArray(target)) {
+        for (const item of target) {
+            const r = resolveConditionValue(item, conditions);
+            if (r)
+                return r;
+        }
+        return null;
+    }
+    if (typeof target !== 'object')
+        return null;
+    // Try each requested condition in priority order
+    for (const cond of conditions) {
+        if (cond in target) {
+            const r = resolveConditionValue(target[cond], conditions);
+            if (r)
+                return r;
+        }
+    }
+    // Spec: `default` is always a valid fallback
+    if (!conditions.includes('default') && 'default' in target) {
+        return resolveConditionValue(target.default, conditions);
+    }
+    return null;
+}
+/**
+ * Resolve a package's entry-point file relative to its directory.
+ * Priority: exports → module → main → null.
+ * For non-root subpaths without an `exports` field, returns the subpath
+ * itself (caller probes filesystem with extension-list).
+ */
+export function resolvePackageEntry(pkg, subpath = '.', conditions = DEFAULT_ESM_CONDITIONS) {
+    // 1. exports field
+    if (pkg.exports !== undefined && pkg.exports !== null) {
+        const entry = resolveExports(pkg.exports, subpath, conditions);
+        if (entry)
+            return entry;
+        // If exports is defined but yields nothing for this subpath,
+        // Node spec is: this is an error (subpath isn't exposed).
+        // We return null to let caller decide (some callers fall back to
+        // direct filesystem probing for compatibility with packages that
+        // mis-declare exports).
+    }
+    // 2. Root entry: module → main
+    if (subpath === '.') {
+        if (pkg.module)
+            return pkg.module;
+        if (pkg.main)
+            return pkg.main;
+        return null;
+    }
+    // 3. Non-root subpath without exports — caller probes raw subpath
+    return subpath;
+}
+// ─── JS-source emission for embedding into facet preambles ───────────────
+/**
+ * Returns the resolver source as plain JavaScript (no TypeScript syntax),
+ * suitable for embedding into a generated worker preamble or shim string.
+ *
+ * The emitted source declares three top-level functions in scope:
+ *   - resolveExports(exports, subpath, conditions)
+ *   - resolveConditionValue(target, conditions)        (helper)
+ *   - resolvePackageEntry(pkg, subpath, conditions)
+ *
+ * It also declares two arrays:
+ *   - DEFAULT_ESM_CONDITIONS
+ *   - DEFAULT_CJS_CONDITIONS
+ *
+ * This source must be byte-equivalent to the TS impl above (modulo type
+ * annotations and `export` keywords). Keep them in sync — there is one
+ * verification probe in audit/probes that compares parity.
+ */
+export function getExportsResolverJS() {
+    return `
+// ── exports-resolver.js (auto-generated; keep in sync with src/_shared/exports-resolver.ts) ──
+const DEFAULT_ESM_CONDITIONS = ['import', 'module', 'browser', 'default'];
+const DEFAULT_CJS_CONDITIONS = ['require', 'node', 'default'];
+
+function resolveExports(exportsField, subpath, conditions) {
+  if (subpath === undefined) subpath = '.';
+  if (!conditions) conditions = DEFAULT_ESM_CONDITIONS;
+  if (exportsField === undefined || exportsField === null) return null;
+  if (typeof exportsField === 'string') {
+    return subpath === '.' ? exportsField : null;
+  }
+  if (Array.isArray(exportsField)) {
+    for (const item of exportsField) {
+      const r = resolveExports(item, subpath, conditions);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (typeof exportsField !== 'object') return null;
+  const keys = Object.keys(exportsField);
+  if (keys.length === 0) return null;
+  const isSubpathMap = keys[0].startsWith('.') || keys[0].startsWith('#');
+  if (isSubpathMap) {
+    if (subpath in exportsField) {
+      const target = exportsField[subpath];
+      if (target === null) return null;
+      return resolveConditionValue(target, conditions);
+    }
+    const wildcardKeys = keys
+      .filter(k => k.includes('*'))
+      .sort((a, b) => b.length - a.length);
+    for (const pattern of wildcardKeys) {
+      const target = exportsField[pattern];
+      const starIdx = pattern.indexOf('*');
+      const prefix = pattern.slice(0, starIdx);
+      const suffix = pattern.slice(starIdx + 1);
+      if (
+        subpath.startsWith(prefix) &&
+        (suffix ? subpath.endsWith(suffix) : true) &&
+        subpath.length >= prefix.length + suffix.length
+      ) {
+        if (target === null) return null;
+        const matched = subpath.slice(
+          prefix.length,
+          suffix ? subpath.length - suffix.length : undefined,
+        );
+        const resolved = resolveConditionValue(target, conditions);
+        if (resolved) return resolved.split('*').join(matched);
+      }
+    }
+    return null;
+  }
+  if (subpath !== '.') return null;
+  return resolveConditionValue(exportsField, conditions);
+}
+
+function resolveConditionValue(target, conditions) {
+  if (target === null || target === undefined) return null;
+  if (typeof target === 'string') return target;
+  if (Array.isArray(target)) {
+    for (const item of target) {
+      const r = resolveConditionValue(item, conditions);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (typeof target !== 'object') return null;
+  for (const cond of conditions) {
+    if (cond in target) {
+      const r = resolveConditionValue(target[cond], conditions);
+      if (r) return r;
+    }
+  }
+  if (!conditions.includes('default') && 'default' in target) {
+    return resolveConditionValue(target.default, conditions);
+  }
+  return null;
+}
+
+function resolvePackageEntry(pkg, subpath, conditions) {
+  if (subpath === undefined) subpath = '.';
+  if (!conditions) conditions = DEFAULT_ESM_CONDITIONS;
+  if (pkg.exports !== undefined && pkg.exports !== null) {
+    const entry = resolveExports(pkg.exports, subpath, conditions);
+    if (entry) return entry;
+  }
+  if (subpath === '.') {
+    if (pkg.module) return pkg.module;
+    if (pkg.main) return pkg.main;
+    return null;
+  }
+  return subpath;
+}
+// ── end exports-resolver.js ────────────────────────────────────────────
+`;
+}

package/dist/_shared/install-phase.d.ts

@@ -0,0 +1,47 @@
+/**
+ * _shared/install-phase.ts — single source of truth for the npm-install
+ * state-machine phase enum.
+ *
+ * History: CLN-1 (2026-05-11) — consolidated from two diverged copies.
+ *   - `npm/installer.ts:93-95` was the progress-event variant. Included
+ *     'lock-check' (a real progress event emitted while parsing
+ *     package-lock.json) but lacked 'idle'.
+ *   - `observability/diag-counters.ts:33-35` was the counter-state variant.
+ *     Included 'idle' (the resting state when no install is in flight)
+ *     but lacked 'lock-check'. The diag-counter's `setInstallPhase()`
+ *     was actually called with 'idle' (installer.ts:184,201) — passing
+ *     a value not declared in installer.ts's local type. The type check
+ *     fell through to diag-counters' type because installer.ts imports
+ *     setInstallPhase from there; the local `InstallPhase` definition
+ *     in installer.ts was only used by `InstallProgress.phase`.
+ *
+ * Going forward both consumers import from this module; any new phase
+ * value added here is automatically available everywhere.
+ *
+ * Phase semantics (chronological order for a single install run):
+ *
+ *   idle         resting state, no install in flight
+ *     ↓
+ *   lock-check   parsing existing package-lock.json (if present)
+ *     ↓
+ *   resolve      walking the dep tree, fetching packuments
+ *     ↓
+ *   hoist        hoisting peer-deps + flattening node_modules
+ *     ↓
+ *   diff         comparing target tree against current install state
+ *     ↓
+ *   fetch        downloading missing tarballs
+ *     ↓
+ *   write        extracting tarballs into the VFS
+ *     ↓
+ *   link-bins    creating bin/ symlinks
+ *     ↓
+ *   bundle       (post-install) pre-bundling for esbuild fast path
+ *     ↓
+ *   done         install complete; about to return to 'idle'
+ *
+ * The phase strings are surfaced via /api/_diag/install-pipeline and
+ * displayed in the install-progress UI; treat them as a public API.
+ */
+export type InstallPhase = 'idle' | 'lock-check' | 'resolve' | 'hoist' | 'diff' | 'fetch' | 'write' | 'link-bins' | 'bundle' | 'done';
+//# sourceMappingURL=install-phase.d.ts.map

package/dist/_shared/install-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-phase.d.ts","sourceRoot":"","sources":["../../src/_shared/install-phase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,YAAY,GACZ,SAAS,GACT,OAAO,GACP,MAAM,GACN,OAAO,GACP,OAAO,GACP,WAAW,GACX,QAAQ,GACR,MAAM,CAAC"}

package/dist/_shared/install-phase.js

@@ -0,0 +1 @@
+export {};

package/dist/_shared/real-node-imports.d.ts

@@ -0,0 +1,38 @@
+/**
+ * real-node-imports.ts — single source of truth for the static
+ * `import * as __real_X from 'node:X'` block that the generated facet
+ * code prepends so the SHIMS string can forward to workerd's real
+ * `node:*` builtins.
+ *
+ * Used by:
+ *   - src/facet-manager.ts:generateFacetCode (NodeProcess template)
+ *   - src/facet-manager.ts: LOADER.load fallback template
+ *
+ * Symmetry constraint (W3 plan §3): both templates MUST consume this
+ * helper to prevent drift. If you add a new `import * as __real_X`,
+ * also wire it into the matching shim block in node-shims.ts.
+ *
+ * Why this lives in _shared/ alongside exports-resolver.ts: same
+ * pattern — JS-string emitter consumed by the facet-code generators
+ * that can't `import` at runtime because the surrounding code is a
+ * raw string template.
+ *
+ * Workerd availability matrix (probe-verified 2026-05-04 at compat
+ * date 2026-04-01, flag `nodejs_compat`):
+ *   - node:crypto       — full Node 20 surface
+ *   - node:tls          — connect/TLSSocket/createSecureContext/...
+ *   - node:async_hooks  — AsyncLocalStorage + AsyncResource + createHook
+ *   - node:fs/promises  — full surface (BUT operates on real-host FS,
+ *                         not our VFS, so we shim VFS-backed instead
+ *                         of forwarding fs/promises)
+ *   - node:diagnostics_channel — full surface incl. tracingChannel +
+ *                                Channel.runStores (fastify-critical)
+ *   - node:repl         — surface stub (start/REPLServer)
+ *   - node:vm           — surface stub: classes/constants present BUT
+ *                         every code-running method throws
+ *                         ERR_METHOD_NOT_IMPLEMENTED. Hybrid shim:
+ *                         forward surface, wrap eval methods with
+ *                         honest error.
+ */
+export declare function getRealNodeImportsCode(): string;
+//# sourceMappingURL=real-node-imports.d.ts.map

package/dist/_shared/real-node-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-node-imports.d.ts","sourceRoot":"","sources":["../../src/_shared/real-node-imports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CAS/C"}

package/dist/_shared/real-node-imports.js

@@ -0,0 +1,46 @@
+/**
+ * real-node-imports.ts — single source of truth for the static
+ * `import * as __real_X from 'node:X'` block that the generated facet
+ * code prepends so the SHIMS string can forward to workerd's real
+ * `node:*` builtins.
+ *
+ * Used by:
+ *   - src/facet-manager.ts:generateFacetCode (NodeProcess template)
+ *   - src/facet-manager.ts: LOADER.load fallback template
+ *
+ * Symmetry constraint (W3 plan §3): both templates MUST consume this
+ * helper to prevent drift. If you add a new `import * as __real_X`,
+ * also wire it into the matching shim block in node-shims.ts.
+ *
+ * Why this lives in _shared/ alongside exports-resolver.ts: same
+ * pattern — JS-string emitter consumed by the facet-code generators
+ * that can't `import` at runtime because the surrounding code is a
+ * raw string template.
+ *
+ * Workerd availability matrix (probe-verified 2026-05-04 at compat
+ * date 2026-04-01, flag `nodejs_compat`):
+ *   - node:crypto       — full Node 20 surface
+ *   - node:tls          — connect/TLSSocket/createSecureContext/...
+ *   - node:async_hooks  — AsyncLocalStorage + AsyncResource + createHook
+ *   - node:fs/promises  — full surface (BUT operates on real-host FS,
+ *                         not our VFS, so we shim VFS-backed instead
+ *                         of forwarding fs/promises)
+ *   - node:diagnostics_channel — full surface incl. tracingChannel +
+ *                                Channel.runStores (fastify-critical)
+ *   - node:repl         — surface stub (start/REPLServer)
+ *   - node:vm           — surface stub: classes/constants present BUT
+ *                         every code-running method throws
+ *                         ERR_METHOD_NOT_IMPLEMENTED. Hybrid shim:
+ *                         forward surface, wrap eval methods with
+ *                         honest error.
+ */
+export function getRealNodeImportsCode() {
+    return `
+import * as __real_crypto from 'node:crypto';
+import * as __real_tls from 'node:tls';
+import * as __real_async_hooks from 'node:async_hooks';
+import * as __real_diagnostics_channel from 'node:diagnostics_channel';
+import * as __real_repl from 'node:repl';
+import * as __real_vm from 'node:vm';
+`.trim();
+}

package/dist/_shared/retry.d.ts

@@ -0,0 +1,93 @@
+/**
+ * retry.ts — small, dependency-free retry helper for flaky HTTP GETs.
+ *
+ * The npm path (resolver packument fetches + tarball fetches) talks to
+ * registry.npmjs.org via Cloudflare's edge. Either hop can produce a
+ * transient 5xx — we've seen HTTP 503 on a single tarball out of 456
+ * kill a whole install. npm's client retries 5xx by default; we didn't,
+ * until this file. Any single transient failure across hundreds of
+ * packages = whole install dead.
+ *
+ * Scope:
+ *   - Retries on 5xx (500/502/503/504 especially) and network errors
+ *     (fetch rejection, AbortError timeout, etc.).
+ *   - Does NOT retry on 4xx (those are hard: 404 means the package or
+ *     version genuinely doesn't exist; retrying is wrong and wastes time).
+ *   - Budget: 3 retries with jittered exponential backoff (500/1500/4500 ms
+ *     ±25% jitter). Worst-case added latency per package ≈ 6.5 s in the
+ *     fully-degraded path. Tighter than npm's ~5×60s because dev iteration
+ *     speed matters more than absolute resilience here.
+ *
+ * Intentionally NOT exported to the facet isolate: the facet serializes
+ * its task function via fn.toString() and can't cross a module boundary,
+ * so `src/npm-install-facet.ts` duplicates this retry loop inline inside
+ * `fetchAndStagePackage`. Keep the two in sync if behaviour changes.
+ */
+/** Default retry count AFTER the first attempt (3 = up to 4 total attempts). */
+export declare const DEFAULT_RETRIES = 3;
+/** Base backoff delays in ms. Index = retry attempt (0-indexed). */
+export declare const BACKOFF_MS: readonly number[];
+/** Jitter ±25% of the base delay, uniformly distributed. */
+export declare function jittered(baseMs: number): number;
+/** True if an HTTP status should trigger a retry. */
+export declare function isRetriableStatus(status: number): boolean;
+/**
+ * Signature of a fetch-compatible callable. Lets callers inject a proxy
+ * (e.g. the Nimbus supervisor-fetch RPC) without forcing global fetch.
+ */
+export type FetchCallable = (url: string, init?: RequestInit) => Promise<Response>;
+export interface RetryableFetchOptions {
+    /**
+     * Retries AFTER the initial attempt. Default DEFAULT_RETRIES (3).
+     * 0 = behave as a plain fetch.
+     */
+    retries?: number;
+    /**
+     * Fetch implementation. Defaults to globalThis.fetch. Pass a proxy
+     * fetch (e.g. env.SUPERVISOR-backed fetchFn) to route through it while
+     * keeping the retry semantics.
+     */
+    fetchImpl?: FetchCallable;
+    /**
+     * Human-readable name for the resource (used only in log messages).
+     * Typically "<pkg>@<version>" for npm or the URL.
+     */
+    name?: string;
+    /**
+     * Per-attempt timeout in ms. A fresh AbortController is used per attempt
+     * so a slow-to-fail upstream doesn't eat the whole retry budget on a
+     * single hang. Merges with any caller-provided `init.signal` (both are
+     * honored: whichever aborts first wins).
+     *
+     * Default: undefined (no timeout; caller is responsible for its own
+     * signal if it wants one).
+     */
+    perAttemptTimeoutMs?: number;
+    /**
+     * Optional logger called on each retry decision. Signature:
+     *   onRetry(attempt /* 1-indexed *\/, totalRetries, delayMs, reason)
+     *
+     * Caller uses this to surface visible progress ("retry 1/3 after 500ms
+     * (HTTP 503)") rather than have the whole install silently hang for
+     * several seconds.
+     */
+    onRetry?: (attempt: number, totalRetries: number, delayMs: number, reason: string) => void;
+}
+/**
+ * fetch() wrapper with 5xx + network-error retry and jittered backoff.
+ *
+ * On a 4xx response, returns the Response object as-is (caller decides
+ * whether that's an error). On a 5xx or network-level failure, retries
+ * up to `retries` times with BACKOFF_MS[attempt] ± 25% jitter.
+ *
+ * When retries are exhausted, either:
+ *   - Returns the last (5xx) Response, so the caller can read .status for
+ *     error reporting, OR
+ *   - Re-throws the last network error (caller never sees a Response).
+ *
+ * Callers that previously did `if (!resp.ok) throw ...` retain that shape;
+ * the only change is that transient failures are recovered before the
+ * throw instead of killing the whole install on the first hiccup.
+ */
+export declare function retryableFetch(url: string, init?: RequestInit, opts?: RetryableFetchOptions): Promise<Response>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/_shared/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/_shared/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,gFAAgF;AAChF,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,oEAAoE;AACpE,eAAO,MAAM,UAAU,EAAE,SAAS,MAAM,EAAsB,CAAC;AAE/D,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,qDAAqD;AACrD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAOzD;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEnF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;OAQG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,WAAW,EAClB,IAAI,CAAC,EAAE,qBAAqB,GAC3B,OAAO,CAAC,QAAQ,CAAC,CAyFnB"}