@beignet/provider-cache-redis 0.0.32

package/CHANGELOG.md

@@ -0,0 +1,162 @@
+# @beignet/provider-redis
+
+## 0.0.32
+
+### Patch Changes
+
+- f759611: Provider factory options now resolve through one framework-owned rule:
+  `ProviderConfigDef` gains an `overrides` map that merges defined values over
+  env-derived input before validation, and every first-party provider factory
+  uses it instead of hand-rolled schema defaults and setup-time fallbacks. The
+  precedence is now uniform — defined factory options win over environment
+  variables in all thirteen providers. This flips the previous env-wins
+  behavior of `provider-cache-redis`, `provider-locks-redis`, and the storage,
+  search, and blob providers; set the env var (or drop the option) if you
+  relied on env winning. `installProviderForTest(...)` gains an `env` option
+  that resolves config through the same loader, and unreachable missing-config
+  guards in the pino and inngest factories are gone.
+- eb680ef: Provider naming now follows one implementation-first order matching the
+  factories. `@beignet/provider-redis` is renamed `@beignet/provider-cache-redis`
+  (the package fills the cache port; the raw client stays as the
+  `ctx.ports.redis` escape hatch) with `redisCacheProvider`,
+  `createRedisCacheProvider`, and provider name `cache-redis` matching
+  `locks-redis`. Default consts flip to implementation-first:
+  `loggerPinoProvider` is now `pinoLoggerProvider`, `mailResendProvider` is now
+  `resendMailProvider`, and `mailSmtpProvider` is now `smtpMailProvider`.
+  CLI starter templates and the `redis-cache` provider preset wire the new
+  names. No aliases are kept.
+
+## 0.0.31
+
+## 0.0.30
+
+### Patch Changes
+
+- 38d1770: Every published package now rebuilds in `prepack`, so publishing can never ship a stale `dist/` again (the 0.0.28 packaging incident). No runtime behavior changes.
+
+## 0.0.29
+
+## 0.0.28
+
+## 0.0.27
+
+### Patch Changes
+
+- f2461a9: Add lazy Next route server loaders and update generated route files and package docs to avoid booting providers during production build imports.
+
+## 0.0.26
+
+## 0.0.25
+
+## 0.0.24
+
+### Patch Changes
+
+- d07a420: Redact Redis credentials from provider startup errors and show a production
+  hardening checklist when doctor reports deployment-readiness diagnostics.
+
+## 0.0.23
+
+## 0.0.22
+
+### Patch Changes
+
+- Add app-owned readiness helpers, first-party provider health checks, generated `/api/ready` routes, and doctor readiness hints.
+- Normalize provider README setup guidance across first-party provider packages.
+
+## 0.0.21
+
+## 0.0.20
+
+## 0.0.19
+
+## 0.0.18
+
+## 0.0.17
+
+## 0.0.16
+
+## 0.0.15
+
+## 0.0.14
+
+## 0.0.13
+
+## 0.0.12
+
+## 0.0.11
+
+## 0.0.10
+
+## 0.0.9
+
+## 0.0.8
+
+## 0.0.7
+
+## 0.0.6
+
+## 0.0.5
+
+## 0.0.4
+
+### Patch Changes
+
+- 8bcb31f: Mark package READMEs with Beignet's experimental alpha status and 0.0.x stability expectations.
+- d137044: Declare `@beignet/core` as a peer dependency with a lockstep version range in
+  every integration and provider package instead of a regular `"*"` dependency.
+  Installs now always resolve a single shared copy of core, so `instanceof`
+  checks such as `isContractError` and upload error identity keep working, and
+  mixed Beignet versions fail loudly at install time instead of at runtime.
+
+  If your package manager does not install peer dependencies automatically, add
+  `@beignet/core` to your app alongside these packages. `@beignet/nuqs` now also
+  declares `@beignet/react-query` as a peer dependency, and
+  `@beignet/provider-storage-s3` now expects you to install
+  `@aws-sdk/client-s3` and `@aws-sdk/s3-request-presigner` yourself, matching
+  how other providers treat their SDKs.
+
+- 603478f: Align package documentation with the canonical route registry and AppContext conventions.
+- 1a79090: Emit Node-compatible ESM: all relative imports in published packages now carry explicit .js extensions, fixing ERR_MODULE_NOT_FOUND when running the CLI or importing package dist files under plain Node.
+- 44f1192: Move first-party provider diagnostics to package-owned `beignet.provider`
+  manifest metadata and have doctor read installed provider package manifests.
+- 2aa77ca: Add static provider metadata and provider wiring diagnostics for generated apps.
+- 89390fe: Add `createRedisProvider(options)` factory with connection robustness controls
+  and move the raw client escape hatch to a separate port.
+
+  - New config: `REDIS_CONNECT_TIMEOUT_MS` (default 5000),
+    `REDIS_MAX_RETRIES_PER_REQUEST` (default 2), and
+    `REDIS_CONNECT_MAX_ATTEMPTS` (default 3), with matching factory options
+    `connectTimeoutMs`, `maxRetriesPerRequest`, `retryStrategy`, and `db`.
+  - Startup now fails fast with a clear error when Redis is unreachable instead
+    of retrying forever. After a successful connection, reconnects use capped
+    exponential backoff (max 2s).
+  - The provider now contributes `{ cache: CachePort, redis: { client } }`.
+    `RedisCachePort` is replaced by the exported `RedisProviderPorts` interface;
+    access the raw ioredis client through `ctx.ports.redis.client` instead of
+    casting `ctx.ports.cache`.
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [3160184]
+- Updated dependencies [254ef6d]
+- Updated dependencies [4cb1784]
+- Updated dependencies [8bd9085]
+  - @beignet/core@0.0.3
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [90b29ad]
+- Updated dependencies [07fa19c]
+- Updated dependencies [08bae67]
+- Updated dependencies [730a818]
+- Updated dependencies [a79f60c]
+  - @beignet/core@0.0.2
+
+## 0.0.1
+
+- Initial Beignet release under the `@beignet` npm scope.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Taylor Bryant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,256 @@
+# @beignet/provider-cache-redis
+
+> [!CAUTION]
+> Beignet is experimental alpha software. The `0.0.x` package line is for early
+> evaluation, and APIs may change between releases while the framework settles.
+
+Redis-backed `CachePort` provider for Beignet applications.
+
+The provider installs `ctx.ports.cache` using
+[ioredis](https://github.com/redis/ioredis) and exposes the raw Redis client
+separately as `ctx.ports.redis` for Redis-specific features.
+
+## Install
+
+```bash
+bun add @beignet/provider-cache-redis @beignet/core ioredis
+```
+
+## Setup
+
+```typescript
+import { createNextServer, createNextServerLoader } from "@beignet/next";
+import { definePorts } from "@beignet/core/ports";
+import { redisCacheProvider } from "@beignet/provider-cache-redis";
+import { routes } from "@/server/routes";
+
+// Set environment variables:
+// REDIS_URL=redis://localhost:6379
+// REDIS_DB=0 (optional)
+
+const appPorts = definePorts({});
+
+export const getServer = createNextServerLoader(() =>
+  createNextServer({
+    ports: appPorts,
+    providers: [redisCacheProvider],
+    context: ({ ports }) => ({
+      ports,
+    }),
+    routes,
+  }),
+);
+```
+
+`beignet doctor --strict` checks that installed Redis cache providers are
+registered in `server/providers.ts` and that `REDIS_URL` is present in app env
+examples or config when the env-backed provider is used.
+
+## Usage
+
+Once the provider is registered, your ports will include a `cache` property:
+
+```typescript
+// In your use case
+async function getUserProfile(ctx: AppContext) {
+  const userId = ctx.actor.type === "user" ? ctx.actor.id : undefined;
+  if (!userId) throw new Error("User actor required.");
+
+  const cacheKey = `user:${userId}:profile`;
+  
+  // Try to get from cache
+  const cached = await ctx.ports.cache.get(cacheKey);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+  
+  // Fetch from database
+  const profile = await ctx.ports.db.users.findById(userId);
+  
+  // Store in cache for 1 hour
+  await ctx.ports.cache.set(
+    cacheKey,
+    JSON.stringify(profile),
+    { ttlSeconds: 3600 }
+  );
+  
+  return profile;
+}
+```
+
+## Configuration
+
+The Redis provider reads configuration from environment variables with the `REDIS_` prefix:
+
+| Variable | Required | Description | Example |
+|----------|----------|-------------|---------|
+| `REDIS_URL` | Yes | Redis connection URL | `redis://localhost:6379` |
+| `REDIS_DB` | No | Redis database number (default: 0) | `0` |
+| `REDIS_CONNECT_TIMEOUT_MS` | No | Initial connection timeout in milliseconds (default: 5000) | `2000` |
+| `REDIS_MAX_RETRIES_PER_REQUEST` | No | Per-command retry limit before the command rejects (default: 2) | `1` |
+| `REDIS_CONNECT_MAX_ATTEMPTS` | No | Connection attempts before startup fails (default: 3) | `5` |
+
+### Factory options
+
+Use `createRedisCacheProvider(options)` when the app should own connection
+defaults. Defined options override matching `REDIS_*` environment variables:
+
+```typescript
+import { createRedisCacheProvider } from "@beignet/provider-cache-redis";
+
+const redisCacheProvider = createRedisCacheProvider({
+  connectTimeoutMs: 2000,
+  maxRetriesPerRequest: 1,
+  db: 1,
+  // Optional: replace the default retry strategy entirely.
+  retryStrategy: (times) => Math.min(times * 100, 1000),
+});
+```
+
+The default `redisCacheProvider` export is `createRedisCacheProvider()` with no options.
+
+### Connection behavior
+
+During startup the provider connects eagerly and fails fast: the initial
+`connect()` stops retrying after `REDIS_CONNECT_MAX_ATTEMPTS` attempts (or
+after `REDIS_CONNECT_TIMEOUT_MS` per attempt) and throws a clear error instead
+of hanging against an unreachable host. After a successful connection, lost
+connections are retried forever with capped exponential backoff (maximum 2
+seconds between attempts).
+
+## Cache port API
+
+The provider extends your ports with the following cache interface:
+
+### `get(key: string): Promise<string | null>`
+
+Get a value from the cache.
+
+```typescript
+const value = await ctx.ports.cache.get("my-key");
+```
+
+### `set(key: string, value: string, options?: { ttlSeconds?: number }): Promise<void>`
+
+Set a value in the cache with optional TTL (time-to-live) in seconds.
+
+```typescript
+// Without TTL (persists forever)
+await ctx.ports.cache.set("key", "value");
+
+// With TTL (expires after 1 hour)
+await ctx.ports.cache.set("key", "value", { ttlSeconds: 3600 });
+```
+
+### `delete(key: string): Promise<boolean>`
+
+Delete a key from the cache. Returns `true` when a key was deleted.
+
+```typescript
+const deleted = await ctx.ports.cache.delete("my-key");
+```
+
+### `has(key: string): Promise<boolean>`
+
+Check if a key exists in the cache.
+
+```typescript
+const exists = await ctx.ports.cache.has("my-key");
+```
+
+### `remember(key: string, factory: () => Promise<string>, options?: { ttlSeconds?: number }): Promise<string>`
+
+Return the cached value when present. On a miss, compute, store, and return the
+factory value.
+
+```typescript
+const value = await ctx.ports.cache.remember(
+  "my-key",
+  async () => JSON.stringify(await loadExpensiveData()),
+  { ttlSeconds: 300 },
+);
+```
+
+## Escape hatch
+
+The provider also contributes `ctx.ports.redis` with the raw ioredis client
+for operations the stable cache port does not model:
+
+```typescript
+// Use ioredis methods directly
+await ctx.ports.redis.client.expire("key", 300);
+await ctx.ports.redis.client.incr("counter");
+
+// Use from app-owned readiness endpoints
+const health = await ctx.ports.redis.checkHealth();
+```
+
+Use the stable `CachePort` for normal application behavior. Use the raw client
+only when the Redis-specific operation is intentional. `checkHealth()` sends a
+cheap Redis `PING` and returns a structured result instead of throwing.
+
+## Failure behavior
+
+The env-backed provider throws during startup when `REDIS_URL` is missing or
+Redis cannot be reached within the configured connection attempts. Runtime cache
+operations throw Redis errors so callers can decide whether to fail, retry, or
+fall back to the source of truth.
+
+## Devtools
+
+When `@beignet/devtools` is installed before this provider, Redis cache
+operations appear under the dashboard's Cache watcher.
+
+The provider records `cache.get`, `cache.set`, `cache.delete`, `cache.has`, and
+`cache.remember` events with the cache key, hit/miss or deleted status, TTL, and
+duration. Cached values are not recorded.
+
+## TypeScript support
+
+To get proper type inference for the contributed ports, extend your ports
+type with `RedisCacheProviderPorts`:
+
+```typescript
+import type { RedisCacheProviderPorts } from "@beignet/provider-cache-redis";
+
+// Your base ports, if any
+const basePorts = definePorts({});
+
+// After using redisCacheProvider, your ports will have this shape:
+type AppPorts = typeof basePorts & RedisCacheProviderPorts;
+// { cache: CachePort; redis: { client: Redis } }
+```
+
+## Lifecycle
+
+The Redis provider:
+
+1. **During `setup`**: Connects to Redis and returns the `cache` and `redis`
+   ports
+2. **During `stop`**: Gracefully closes the Redis connection
+
+## Error handling
+
+The provider will throw errors in these cases:
+
+- Missing `REDIS_URL` environment variable
+- Failed connection to Redis server after `REDIS_CONNECT_MAX_ATTEMPTS`
+  attempts
+
+Make sure to handle these during application startup.
+
+## Local and tests
+
+Use an app-owned fake or memory `CachePort` in use-case tests. For local
+development, either run Redis locally or omit this provider until cache behavior
+is part of the workflow being tested.
+
+## Deployment notes
+
+Set `REDIS_DB` or a key prefix strategy per app/environment if Redis is shared.
+Cache values are never the source of truth; design misses and Redis outages so
+the app can rebuild from durable state when appropriate.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @beignet/provider-cache-redis
+ *
+ * Redis provider that extends ports with cache capabilities using ioredis.
+ *
+ * Configuration:
+ * - REDIS_URL: Redis connection URL (required)
+ * - REDIS_DB: Redis database number (optional, default: 0)
+ * - REDIS_CONNECT_TIMEOUT_MS: Initial connection timeout in milliseconds (optional, default: 5000)
+ * - REDIS_MAX_RETRIES_PER_REQUEST: Per-command retry limit (optional, default: 2)
+ * - REDIS_CONNECT_MAX_ATTEMPTS: Connection attempts before startup fails (optional, default: 3)
+ *
+ * @example
+ * ```ts
+ * import { createNextServer } from "@beignet/next";
+ * import { redisCacheProvider } from "@beignet/provider-cache-redis";
+ *
+ * const server = await createNextServer({
+ *   ports: basePorts,
+ *   providers: [redisCacheProvider],
+ *   // ...
+ * });
+ *
+ * // In your use cases:
+ * async function myUseCase(ctx: AppCtx) {
+ *   const cached = await ctx.ports.cache.get("key");
+ *   if (!cached) {
+ *     const value = await fetchData();
+ *     await ctx.ports.cache.set("key", value, { ttlSeconds: 3600 });
+ *   }
+ * }
+ * ```
+ */
+import type { CachePort } from "@beignet/core/ports";
+import { Redis } from "ioredis";
+import { z } from "zod";
+/**
+ * Configuration schema for the Redis provider.
+ * Validates environment variables with REDIS_ prefix.
+ */
+declare const RedisConfigSchema: z.ZodObject<{
+    URL: z.ZodString;
+    DB: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    CONNECT_TIMEOUT_MS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    MAX_RETRIES_PER_REQUEST: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    CONNECT_MAX_ATTEMPTS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+}, z.core.$strip>;
+/**
+ * Inferred configuration type for Redis provider.
+ */
+export type RedisConfig = z.infer<typeof RedisConfigSchema>;
+/**
+ * Options for {@link createRedisCacheProvider}.
+ *
+ * Numeric options become schema defaults, so matching `REDIS_*` environment
+ * variables still win when both are set.
+ */
+export interface RedisCacheProviderOptions {
+    /**
+     * Timeout for the initial connection attempt, in milliseconds.
+     *
+     * @default 5000
+     */
+    connectTimeoutMs?: number;
+    /**
+     * How many times a single command is retried before its promise rejects.
+     *
+     * @default 2
+     */
+    maxRetriesPerRequest?: number;
+    /**
+     * Custom ioredis retry strategy. Replaces the default strategy, which stops
+     * retrying after `REDIS_CONNECT_MAX_ATTEMPTS` during the initial connect and
+     * reconnects with capped exponential backoff afterwards.
+     */
+    retryStrategy?: (times: number) => number | null;
+    /**
+     * Redis database number.
+     *
+     * @default 0
+     */
+    db?: number;
+}
+export interface RedisHealth {
+    ok: boolean;
+    message?: string;
+    metadata: {
+        adapter: "redis";
+        response?: string;
+    };
+}
+/**
+ * Escape hatch for apps that need the raw ioredis client.
+ */
+export interface RedisEscapeHatch {
+    /**
+     * Raw ioredis client.
+     * Use this for Redis operations the stable cache port does not model.
+     */
+    client: Redis;
+    /**
+     * Check whether Redis responds to a cheap PING command.
+     */
+    checkHealth(): Promise<RedisHealth>;
+}
+/**
+ * Ports contributed by the Redis provider.
+ */
+export interface RedisCacheProviderPorts {
+    /**
+     * Beignet cache port backed by Redis.
+     */
+    cache: CachePort;
+    /**
+     * Raw ioredis client escape hatch.
+     */
+    redis: RedisEscapeHatch;
+}
+/**
+ * Create an env-backed Redis cache provider.
+ *
+ * Reads `REDIS_*` env vars, contributes `ports.cache`, and exposes
+ * `ports.redis` for raw ioredis client access.
+ *
+ * @example
+ * ```ts
+ * const provider = createRedisCacheProvider({ connectTimeoutMs: 2000 });
+ * ```
+ */
+export declare function createRedisCacheProvider(options?: RedisCacheProviderOptions): import("@beignet/core/providers").ServiceProvider<unknown, z.ZodObject<{
+    URL: z.ZodString;
+    CONNECT_MAX_ATTEMPTS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    DB: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>> | z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    CONNECT_TIMEOUT_MS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    MAX_RETRIES_PER_REQUEST: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+}, z.core.$strip>, {
+    cache: CachePort;
+    redis: {
+        client: Redis;
+        checkHealth: () => Promise<RedisHealth>;
+    };
+}, unknown, void>;
+/**
+ * Default env-backed Redis provider.
+ *
+ * Configuration via environment variables:
+ * - REDIS_URL: Redis connection URL (required)
+ * - REDIS_DB: Redis database number (optional)
+ * - REDIS_CONNECT_TIMEOUT_MS: Initial connection timeout in ms (optional)
+ * - REDIS_MAX_RETRIES_PER_REQUEST: Per-command retry limit (optional)
+ * - REDIS_CONNECT_MAX_ATTEMPTS: Connection attempts before startup fails (optional)
+ *
+ * @example
+ * ```ts
+ * const server = await createNextServer({
+ *   ports: basePorts,
+ *   providers: [redisCacheProvider],
+ *   // ...
+ * });
+ * ```
+ */
+export declare const redisCacheProvider: import("@beignet/core/providers").ServiceProvider<unknown, z.ZodObject<{
+    URL: z.ZodString;
+    CONNECT_MAX_ATTEMPTS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    DB: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>> | z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    CONNECT_TIMEOUT_MS: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    MAX_RETRIES_PER_REQUEST: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+}, z.core.$strip>, {
+    cache: CachePort;
+    redis: {
+        client: Redis;
+        checkHealth: () => Promise<RedisHealth>;
+    };
+}, unknown, void>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;GAGG;AACH,QAAA,MAAM,iBAAiB;;;;;;iBAgCrB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAEjD;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE;QACR,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,MAAM,EAAE,KAAK,CAAC;IACd;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IACjB;;OAEG;IACH,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAuCD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,yBAA8B;;;;;;;;;;;;kBAwSxC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAA6B,CAAC"}