alchemy 0.43.5 → 0.44.1

package/lib/llms.cloudflare.txt

@@ -0,0 +1,379 @@
+# Alchemy - TypeScript-native Infrastructure as Code
+
+Alchemy is a TypeScript-native Infrastructure-as-Code framework that allows you to define cloud resources using familiar TypeScript patterns. This guide focuses on Cloudflare integration.
+
+## Core Concepts
+
+**Resources**: Async functions that manage cloud infrastructure lifecycle (create, update, delete)
+**Bindings**: Type-safe connections between resources (workers, KV stores, databases)
+**State Management**: Tracks resource state for consistent deployments
+**Finalization**: Always call `app.finalize()` to clean up orphaned resources
+
+## Basic Setup
+
+### Project Structure
+```typescript
+// alchemy.run.ts - Your infrastructure definition
+import alchemy from "alchemy";
+import { Worker, KVNamespace } from "alchemy/cloudflare";
+
+const app = await alchemy("my-app");
+
+export const worker = await Worker("api", {
+  entrypoint: "./src/worker.ts",
+  bindings: {
+    CACHE: await KVNamespace("cache", { title: "cache-store" })
+  }
+});
+
+console.log({ url: worker.url });
+await app.finalize(); // ⚠️ ALWAYS call finalize()
+```
+
+### Environment Setup
+```bash
+# .env - Required for secret encryption
+ALCHEMY_PASSWORD=your-secure-password
+
+# Optional: Use Cloudflare state store in production
+ALCHEMY_STATE_STORE=cloudflare
+```
+
+### Commands
+```bash
+bun ./alchemy.run.ts           # Deploy
+bun ./alchemy.run.ts --destroy # Destroy all resources
+```
+
+## Workers
+
+### Basic Worker
+```typescript
+const worker = await Worker("api", {
+  entrypoint: "./src/worker.ts",
+  url: true, // Get public URL
+});
+```
+
+### Worker with Bindings
+```typescript
+const worker = await Worker("api", {
+  entrypoint: "./src/worker.ts",
+  bindings: {
+    // Resource bindings
+    CACHE: kvNamespace,
+    STORAGE: r2Bucket,
+    COUNTER: durableObjectNamespace,
+    QUEUE: queue,
+    API: otherWorker,
+    
+    // Environment variables
+    API_KEY: alchemy.secret(process.env.API_KEY),
+    DEBUG: "true"
+  }
+});
+```
+
+### Worker Implementation
+```typescript
+// src/worker.ts
+import type { worker } from "../alchemy.run";
+
+export default {
+  async fetch(request: Request, env: typeof worker.Env): Promise<Response> {
+    // Type-safe access to all bindings
+    const cached = await env.CACHE.get("key");
+    const apiKey = env.API_KEY;
+    
+    return new Response("Hello World");
+  }
+};
+```
+
+### Type Safety Setup
+```typescript
+// types/env.d.ts
+import type { worker } from "../alchemy.run";
+
+declare module "cloudflare:workers" {
+  namespace Cloudflare {
+    export interface Env extends typeof worker.Env {}
+  }
+}
+```
+
+## Durable Objects
+
+### Creating Durable Object Namespace
+```typescript
+// Use 'new' instead of 'await' for DurableObjectNamespace
+const counter = new DurableObjectNamespace("counter", {
+  className: "Counter",
+  sqlite: true, // Enable SQLite storage
+});
+
+const worker = await Worker("api", {
+  entrypoint: "./src/worker.ts",
+  bindings: {
+    COUNTER: counter, // Bind to worker
+  }
+});
+```
+
+### Durable Object Implementation
+```typescript
+// src/counter.ts
+import { DurableObject } from "cloudflare:workers";
+
+export class Counter extends DurableObject {
+  async increment(): Promise<number> {
+    let count = (await this.ctx.storage.get("count")) || 0;
+    count++;
+    await this.ctx.storage.put("count", count);
+    return count;
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    const count = await this.increment();
+    return new Response(JSON.stringify({ count }));
+  }
+}
+```
+
+### Using Durable Objects in Worker
+```typescript
+// src/worker.ts
+export default {
+  async fetch(request: Request, env: typeof worker.Env) {
+    // Get a Durable Object instance
+    const id = env.COUNTER.idFromName("global-counter");
+    const obj = env.COUNTER.get(id);
+    
+    // Call the Durable Object
+    return obj.fetch(request);
+  }
+};
+```
+
+### Cross-Script Durable Objects
+```typescript
+// Method 1: Re-export from provider worker
+const sharedCounter = host.bindings.SHARED_COUNTER;
+
+// Method 2: Reference by worker script name
+const counter = new DurableObjectNamespace("counter", {
+  className: "Counter",
+  scriptName: "provider-worker"
+});
+```
+
+## Key Resources
+
+### KV Namespace
+```typescript
+const cache = await KVNamespace("cache", {
+  title: "my-cache-store"
+});
+
+// Usage in worker
+const value = await env.CACHE.get("key");
+await env.CACHE.put("key", "value", { expirationTtl: 3600 });
+```
+
+### R2 Bucket
+```typescript
+const storage = await R2Bucket("storage", {
+  allowPublicAccess: false
+});
+
+// Usage in worker
+const object = await env.STORAGE.get("file.txt");
+await env.STORAGE.put("file.txt", "content");
+```
+
+### Queue
+```typescript
+// Typed queue
+const queue = await Queue<{ name: string; email: string }>("notifications");
+
+// Producer worker
+const producer = await Worker("producer", {
+  bindings: { QUEUE: queue },
+  // Queue sending code
+});
+
+// Consumer worker
+const consumer = await Worker("consumer", {
+  eventSources: [queue], // Register as consumer
+  // Queue processing code
+});
+
+// Worker implementation for queue processing
+export default {
+  async queue(batch: typeof queue.Batch, env: Env) {
+    for (const message of batch.messages) {
+      console.log("Processing:", message.body);
+      message.ack(); // Acknowledge message
+    }
+  }
+};
+```
+
+### Custom Domains
+```typescript
+const worker = await Worker("api", {
+  entrypoint: "./src/worker.ts",
+  routes: [
+    { pattern: "api.example.com/*", zone: "example.com" },
+    { pattern: "example.com/api/*", zone: "example.com" }
+  ]
+});
+```
+
+## Converting Existing Cloudflare Projects
+
+### 1. Migrate wrangler.toml Configuration
+```toml
+# Old wrangler.toml
+name = "my-worker"
+main = "src/index.js"
+
+[env.production]
+kv_namespaces = [
+  { binding = "CACHE", id = "abc123" }
+]
+
+[[env.production.r2_buckets]]
+binding = "STORAGE"
+bucket_name = "my-bucket"
+```
+
+```typescript
+// New alchemy.run.ts
+const worker = await Worker("my-worker", {
+  entrypoint: "./src/index.js",
+  bindings: {
+    CACHE: await KVNamespace("cache", { 
+      title: "cache-store",
+      adopt: true // Use existing KV namespace
+    }),
+    STORAGE: await R2Bucket("storage", {
+      name: "my-bucket",
+      adopt: true // Use existing bucket
+    })
+  }
+});
+```
+
+### 2. Enable Development Compatibility
+```typescript
+// Generate wrangler.json for local development
+await WranglerJson("wrangler.json", {
+  worker,
+});
+```
+
+### 3. Adopt Existing Resources
+```typescript
+// Use adopt: true to use existing resources instead of failing
+const bucket = await R2Bucket("storage", {
+  name: "existing-bucket-name",
+  adopt: true // Won't fail if bucket already exists
+});
+```
+
+### 4. State Store Migration
+```typescript
+// Local development (default)
+const app = await alchemy("my-app");
+
+// Production with Cloudflare state store
+const app = await alchemy("my-app", {
+  stateStore: process.env.NODE_ENV === "production" 
+    ? (scope) => new DOStateStore(scope)
+    : undefined
+});
+```
+
+## Advanced Patterns
+
+### Framework Integration (Vite/React/etc.)
+```typescript
+const website = await Vite("website", {
+  main: "./src/worker.ts",
+  command: "bun run build", // Build command
+  bindings: {
+    API: await Worker("api", { entrypoint: "./api/worker.ts" }),
+    STORAGE: await R2Bucket("assets")
+  }
+});
+```
+
+### Resource Scoping
+```typescript
+// Organize resources into logical groups
+await alchemy.run("backend", async () => {
+  await Worker("api", { entrypoint: "./api.ts" });
+  await KVNamespace("cache", { title: "api-cache" });
+});
+
+await alchemy.run("frontend", async () => {
+  await Vite("website", { main: "./src/worker.ts" });
+});
+```
+
+### Testing Pattern
+```typescript
+import { alchemy } from "../../src/alchemy";
+const test = alchemy.test(import.meta, { prefix: "test" });
+
+describe("Worker Tests", () => {
+  test("creates worker", async (scope) => {
+    const worker = await Worker("test-worker", {
+      entrypoint: "./src/worker.ts"
+    });
+    
+    expect(worker.url).toBeTruthy();
+    // Resources auto-cleaned after test
+  });
+});
+```
+
+## Best Practices
+
+1. **Always call finalize()**: `await app.finalize()` at the end of your script
+2. **Use adoption for migrations**: `adopt: true` when converting existing projects  
+3. **Type-safe bindings**: Set up env.d.ts for full type safety
+4. **Resource naming**: Use consistent, descriptive names for resources
+5. **State store**: Use DOStateStore for production deployments
+6. **Secrets**: Use `alchemy.secret()` for sensitive values
+7. **Scoping**: Organize related resources using `alchemy.run()`
+8. **Testing**: Use `alchemy.test()` for integration tests
+
+## Common Issues
+
+- **Missing finalize()**: Resources won't be cleaned up properly
+- **Wrong DurableObject syntax**: Use `new DurableObjectNamespace()` not `await`
+- **Type errors**: Set up env.d.ts file for binding types
+- **State conflicts**: Use different stages/prefixes for different environments
+- **Resource adoption**: Use `adopt: true` when migrating existing resources
+
+## Development Workflow
+
+```bash
+# Create new project
+bunx alchemy create my-app --template=vite
+cd my-app
+
+# Set up authentication (one-time)
+bun wrangler login
+
+# Deploy infrastructure
+bun run deploy
+
+# Local development
+bun run dev
+
+# Clean up
+bun run destroy
+```

package/lib/llms.d.ts

@@ -0,0 +1,10 @@
+export interface AlchemyRule {
+    name: string;
+    rule: string;
+    description?: string;
+    alwaysApply?: boolean;
+    globs?: string | string[];
+}
+declare const alchemyRules: AlchemyRule[];
+export default alchemyRules;
+//# sourceMappingURL=llms.d.ts.map

package/lib/llms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llms.d.ts","sourceRoot":"","sources":["../src/llms.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B;AAaD,QAAA,MAAM,YAAY,EAAE,WAAW,EAAc,CAAC;AAE9C,eAAe,YAAY,CAAC"}

package/lib/llms.js

@@ -0,0 +1,12 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const alchemy = {
+    name: "cloudflare",
+    description: "Core Alchemy development guidelines and patterns",
+    alwaysApply: true,
+    globs: ["*.ts"],
+    rule: await fs.readFile(path.join(import.meta.dirname, "llms.cloudflare.txt"), "utf-8"),
+};
+const alchemyRules = [alchemy];
+export default alchemyRules;
+//# sourceMappingURL=llms.js.map

package/lib/llms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llms.js","sourceRoot":"","sources":["../src/llms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAU7B,MAAM,OAAO,GAAgB;IAC3B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,kDAAkD;IAC/D,WAAW,EAAE,IAAI;IACjB,KAAK,EAAE,CAAC,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC,QAAQ,CACrB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,qBAAqB,CAAC,EACrD,OAAO,CACR;CACF,CAAC;AAEF,MAAM,YAAY,GAAkB,CAAC,OAAO,CAAC,CAAC;AAE9C,eAAe,YAAY,CAAC"}

package/lib/planetscale/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./api.ts";
-export * from "./utils.ts";
-export * from "./database.ts";
 export * from "./branch.ts";
+export * from "./database.ts";
+export * from "./password.ts";
+export * from "./utils.ts";
 //# sourceMappingURL=index.d.ts.map

package/lib/planetscale/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/planetscale/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/planetscale/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/lib/planetscale/index.js

@@ -1,5 +1,6 @@
 export * from "./api.js";
-export * from "./utils.js";
-export * from "./database.js";
 export * from "./branch.js";
+export * from "./database.js";
+export * from "./password.js";
+export * from "./utils.js";
 //# sourceMappingURL=index.js.map

package/lib/planetscale/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/planetscale/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/planetscale/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/lib/planetscale/password.d.ts

@@ -0,0 +1,233 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+import type { Branch } from "./branch.ts";
+import type { Database } from "./database.ts";
+/**
+ * Properties for creating or updating a PlanetScale Branch
+ */
+export interface PasswordProps {
+    /**
+     * The name of the password
+     */
+    name: string;
+    /**
+     * The organization ID where the password will be created
+     * Required when using string database name, optional when using Database resource
+     */
+    organizationId?: string;
+    /**
+     * The database where the password will be created
+     * Can be either a database name (string) or Database resource
+     */
+    database: string | Database;
+    /**
+     * The branch where the password will be created
+     * Can be either a branch name (string) or Branch resource
+     * Defaults to "main" if not provided
+     */
+    branch?: string | Branch;
+    /**
+     * PlanetScale API token (overrides environment variable)
+     */
+    apiKey?: Secret;
+    /**
+     * The password
+     */
+    role: "reader" | "writer" | "admin" | "readwriter";
+    /**
+     * Whether the password is for a read replica
+     */
+    replica?: boolean;
+    /**
+     * The TTL of the password in seconds
+     */
+    ttl?: number;
+    /**
+     * The CIDRs of the password
+     */
+    cidrs?: string[];
+}
+/**
+ * Represents a PlanetScale Branch
+ */
+export interface Password extends Resource<"planetscale::Password">, PasswordProps {
+    /**
+     * The unique identifier for the password
+     */
+    id: string;
+    /**
+     * The timestamp when the password expires (ISO 8601 format)
+     */
+    expiresAt: string;
+    /**
+     * The host URL for database connection
+     */
+    host: string;
+    /**
+     * The username for database authentication
+     */
+    username: string;
+    /**
+     * The encrypted password for database authentication
+     */
+    password: Secret<string>;
+    /**
+     * The name slug for the password
+     */
+    nameSlug: string;
+}
+/**
+ * Create and manage database passwords for PlanetScale branches. Database passwords provide secure access to your database with specific roles and permissions.
+ *
+ * @example
+ * ## Basic Reader Password
+ *
+ * Create a read-only password for a database branch:
+ *
+ * ```ts
+ * import { Password } from "alchemy/planetscale";
+ *
+ * const readerPassword = await Password("app-reader", {
+ *   name: "app-reader",
+ *   organizationId: "my-org",
+ *   database: "my-app-db",
+ *   branch: "main",
+ *   role: "reader"
+ * });
+ *
+ * // Access connection details
+ * console.log(`Host: ${readerPassword.password.host}`);
+ * console.log(`Username: ${readerPassword.password.username}`);
+ * console.log(`Password: ${readerPassword.password.password.unencrypted}`);
+ * ```
+ *
+ * @example
+ * ## Writer Password with TTL
+ *
+ * Create a writer password that expires after 24 hours:
+ *
+ * ```ts
+ * import { Password } from "alchemy/planetscale";
+ *
+ * const writerPassword = await Password("app-writer", {
+ *   name: "app-writer",
+ *   organizationId: "my-org",
+ *   database: "my-app-db",
+ *   branch: "development",
+ *   role: "writer",
+ *   ttl: 86400 // 24 hours in seconds
+ * });
+ *
+ * // Password will expire at the specified time
+ * console.log(`Expires at: ${writerPassword.expiresAt}`);
+ * ```
+ *
+ * @example
+ * ## Admin Password with IP Restrictions
+ *
+ * Create an admin password that only allows connections from specific IP addresses:
+ *
+ * ```ts
+ * import { Password } from "alchemy/planetscale";
+ *
+ * const adminPassword = await Password("admin-access", {
+ *   name: "admin-access",
+ *   organizationId: "my-org",
+ *   database: "my-app-db",
+ *   branch: "main",
+ *   role: "admin",
+ *   cidrs: ["203.0.113.0/24", "198.51.100.0/24"],
+ *   ttl: 3600 // 1 hour
+ * });
+ * ```
+ *
+ * @example
+ * ## Database Password with Custom API Key
+ *
+ * Create a password using a specific API key instead of the default environment variable:
+ *
+ * ```ts
+ * import { Password } from "alchemy/planetscale";
+ *
+ * const password = await Password("custom-auth", {
+ *   name: "custom-auth",
+ *   organizationId: "my-org",
+ *   database: "my-app-db",
+ *   branch: "main",
+ *   role: "readwriter",
+ *   apiKey: alchemy.secret(process.env.CUSTOM_PLANETSCALE_TOKEN)
+ * });
+ * ```
+ *
+ * @example
+ * ## Read Replica Password
+ *
+ * Create a password for accessing a read replica:
+ *
+ * ```ts
+ * import { Password } from "alchemy/planetscale";
+ *
+ * const replicaPassword = await Password("replica-reader", {
+ *   name: "replica-reader",
+ *   organizationId: "my-org",
+ *   database: "my-app-db",
+ *   branch: "main",
+ *   role: "reader",
+ *   replica: true
+ * });
+ *
+ * @example
+ * ## Using Database Resource Instance
+ *
+ * Create a password using a Database resource instead of string:
+ *
+ * ```ts
+ * import { Database, Password } from "alchemy/planetscale";
+ *
+ * const database = await Database("my-db", {
+ *   name: "my-app-db",
+ *   organizationId: "my-org",
+ *   clusterSize: "PS_10"
+ * });
+ *
+ * const password = await Password("db-reader", {
+ *   name: "db-reader",
+ *   database: database, // Using Database resource
+ *   role: "reader"
+ * });
+ * ```
+ *
+ * @example
+ * ## Using Both Database and Branch Resources
+ *
+ * Create a password using both Database and Branch resources:
+ *
+ * ```ts
+ * import { Database, Branch, Password } from "alchemy/planetscale";
+ *
+ * const database = await Database("my-db", {
+ *   name: "my-app-db",
+ *   organizationId: "my-org",
+ *   clusterSize: "PS_10"
+ * });
+ *
+ * const branch = await Branch("feature-branch", {
+ *   name: "feature-branch",
+ *   organizationId: "my-org",
+ *   databaseName: "my-app-db",
+ *   parentBranch: "main",
+ *   isProduction: false
+ * });
+ *
+ * const password = await Password("feature-writer", {
+ *   name: "feature-writer",
+ *   database: database, // Using Database resource
+ *   branch: branch, // Using Branch resource
+ *   role: "writer"
+ * });
+ * ```
+ * ```
+ */
+export declare const Password: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Password>, _id: string, props: PasswordProps) => Promise<Password>);
+//# sourceMappingURL=password.d.ts.map

package/lib/planetscale/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../src/planetscale/password.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;IAE5B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEzB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;IAEnD;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,QACf,SAAQ,QAAQ,CAAC,uBAAuB,CAAC,EACvC,aAAa;IACf;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAEzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJG;AACH,eAAO,MAAM,QAAQ,yFAGX,OAAO,CAAC,QAAQ,CAAC,OAClB,MAAM,SACJ,aAAa,KACnB,OAAO,CAAC,QAAQ,CAAC,CA0GrB,CAAC"}