@intentius/chant-lexicon-render 0.53.0

package/dist/skills/chant-render-patterns.md

@@ -0,0 +1,126 @@
+---
+skill: chant-render-patterns
+description: Render patterns in chant — env groups, projects and environments, disks, custom domains, image-backed and cron services, and the ownership model
+user-invocable: true
+---
+
+# Render Patterns
+
+Companion to `chant-render`. Each pattern is a fragment you can drop into `src/`.
+
+## Env groups shared across services
+
+An `EnvGroup` holds env vars (and secret files) many services share. Link services with `serviceIds`, passing the declared resources:
+
+```ts
+import { EnvGroup, EnvVar, GeneratedEnvVar, WebService, BackgroundWorker, WebServiceDetails, BackgroundWorkerDetails } from "@intentius/chant-lexicon-render";
+
+export const web = new WebService({ name: "web", repo: REPO, serviceDetails: new WebServiceDetails({ runtime: "docker" }) });
+export const worker = new BackgroundWorker({ name: "worker", repo: REPO, serviceDetails: new BackgroundWorkerDetails({ runtime: "docker" }) });
+
+export const shared = new EnvGroup({
+  name: "shared",
+  envVars: [
+    new EnvVar({ key: "LOG_LEVEL", value: "info" }),
+    new GeneratedEnvVar({ key: "SIGNING_KEY", generateValue: true }),
+  ],
+  serviceIds: [web, worker],
+});
+```
+
+The applier links each service after both exist (`POST /env-groups/{id}/services/{serviceId}`) and reconciles group vars per key on later runs. Env groups carry the ownership marker, so they are prunable.
+
+## Projects and environments
+
+A `Project` groups `Environment`s; a service, datastore, or env group joins one through `environmentId`. Reference the declared environment and the applier fills the id:
+
+```ts
+import { Project, ProjectEnvironment, Environment, Postgres } from "@intentius/chant-lexicon-render";
+
+export const project = new Project({ name: "shop", environments: [new ProjectEnvironment({ name: "production" })] });
+export const prod = new Environment({ name: "production", projectId: project, protectedStatus: "protected" });
+export const db = new Postgres({ name: "shop-db", plan: "basic_1gb", version: "16", environmentId: prod });
+```
+
+`Project.environments` creates environments with the project (Render requires at least one); a separate `Environment` resource is how you reference one from other resources and PATCH it later. Reconciling by name means the environment created inline and the one declared separately are the same live object.
+
+## Persistent disks
+
+Two ways. Inline, as part of the service (created with it):
+
+```ts
+serviceDetails: new WebServiceDetails({ runtime: "docker", plan: "starter", disk: new ServiceDisk({ name: "data", mountPath: "/data", sizeGB: 10 }) })
+```
+
+Or as a standalone `Disk` attached to a declared service, which can be resized independently:
+
+```ts
+export const data = new Disk({ name: "data", sizeGB: 10, mountPath: "/data", serviceId: web });
+```
+
+Disks are only valid on web services, private services, and background workers (the `serviceId` type says so), and never on the free plan (REN012).
+
+## Custom domains
+
+```ts
+export const apex = new CustomDomain({ name: "example.com", serviceId: web });
+export const www = new CustomDomain({ name: "www.example.com", serviceId: web });
+```
+
+The domain is created under the service (`POST /services/{id}/custom-domains`); DNS verification stays a manual step in Render's dashboard or via the `/verify` endpoint. `describeResources` reports the domain's `verificationStatus` as its status.
+
+## Image-backed services
+
+```ts
+import { WebService, WebServiceDetails, Image, RegistryCredential } from "@intentius/chant-lexicon-render";
+
+export const cred = new RegistryCredential({ name: "ghcr", registry: "GITHUB", username: "me", authToken: process.env.GHCR_TOKEN! });
+export const api = new WebService({
+  name: "api",
+  image: new Image({ imagePath: "ghcr.io/acme/api:1.4.2", registryCredentialId: cred }),
+  serviceDetails: new WebServiceDetails({ runtime: "image", plan: "starter" }),
+});
+```
+
+`Image.ownerId` is filled from the service's owner. `registryCredentialId` accepts the declared credential. Deploying a new tag is a change to `imagePath` → a PATCH → Render redeploys.
+
+## Cron jobs
+
+```ts
+export const nightly = new CronJob({
+  name: "nightly-report",
+  repo: REPO,
+  serviceDetails: new CronJobDetails({
+    runtime: "python",
+    schedule: "0 3 * * *",
+    envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "pip install -r requirements.txt", startCommand: "python report.py" }),
+  }),
+});
+```
+
+`schedule` is a five-field cron expression (REN003); Render accepts no `@daily`-style macros.
+
+## Static sites
+
+```ts
+export const site = new StaticSite({
+  name: "docs",
+  repo: REPO,
+  serviceDetails: new StaticSiteDetails({
+    buildCommand: "npm ci && npm run build",
+    publishPath: "dist",
+    routes: [new Route({ type: "rewrite", source: "/*", destination: "/index.html" })],
+    headers: [new Header({ path: "/*", name: "X-Frame-Options", value: "DENY" })],
+  }),
+});
+```
+
+## The ownership model
+
+Render has no tags or labels. chant's marker is an env var:
+
+- **Services and env groups** carry `CHANT_MANAGED_BY=chant`, `CHANT_STACK=<stack>`, `CHANT_ENV=<env>` in their env vars. That is the primary marker: `describeResources` answers `owned` / `foreign` from it, and `prune: true` deletes only marked resources of the current stack that the plan no longer declares. A service someone created in the dashboard is `foreign` and is never modified or deleted by prune — but it *is* adopted by name if you declare it (a PATCH brings it to the declared shape and stamps the marker).
+- **Disks and custom domains** have no marker but hang off a service and inherit its verdict — the service boundary. An undeclared disk or domain under a chant-owned service is pruned with `prune: true`; one under a foreign service is foreign and untouched.
+- **Everything else** (Postgres, KeyValue, Project, Environment, RegistryCredential, Webhook) has no marker channel and no boundary; its verdict is `unknown` and it is never pruned. Remove one by dropping it from the plan and running `renderDelete` on the old plan, or by hand.
+
+The marker keys are visible in the service's environment. That is deliberate — it is the same information a Kubernetes label or an AWS tag carries, in the only durable key/value store Render exposes.

package/dist/skills/chant-render.md

@@ -0,0 +1,112 @@
+---
+skill: chant-render
+description: Author, lint, and deploy Render services, datastores, and env groups from a chant project, applied straight to the Render Public API
+user-invocable: true
+---
+
+# Deploy to Render Operational Playbook
+
+## How chant and Render relate
+
+chant is a synthesis compiler: it compiles TypeScript in `src/` into a plan of Render Public API create requests, then reconciles that plan against a Render workspace. There is no external CLI to hand off to and no Blueprint (`render.yaml`) to keep in sync. `renderApply` speaks the Public API directly (`https://api.render.com/v1`), so the same code that builds the plan also applies it, and there is no state file to store, lock, or back up.
+
+The source of truth is the TypeScript in `src/`. The serialized plan (a JSON object keyed by entity name, each value a `{ kind, entityType, endpoint, method, name, body }` request) is an intermediate artifact.
+
+Your job as an agent:
+
+- Use `chant build` for synthesis and lint (region, secret literals, cron schedule, runtime commands, source, free-plan scaling).
+- Use `renderApply` (via the deploy Op, `chant run`) to reconcile the plan against the workspace: create or update each resource by name, wait each created service's deploy to `live`, and optionally prune what chant owns.
+
+## Credentials and the workspace
+
+Three environment variables:
+
+- `RENDER_API_KEY` — a Render API key (Account Settings → API Keys). Required for every apply and read. Sent as `Authorization: Bearer`.
+- `RENDER_OWNER_ID` — the workspace (team or personal) id, `tea-…` or `usr-…`. Every `ownerId` chant fills in defaults to it (`Render.OwnerId`). If unset, the applier reads `GET /owners` and uses the sole workspace the key can see; several visible workspaces is an error, never a guess.
+- `RENDER_API_BASE_URL` — optional endpoint override (a local stand-in). Default `https://api.render.com/v1`.
+
+Resolution order for the endpoint is: an explicit `endpoint` arg, then `RENDER_API_BASE_URL`, then the default.
+
+Start from the runnable [`examples/getting-started`](../../lexicons/render/examples/getting-started) stack:
+
+```bash
+cd lexicons/render/examples/getting-started
+export RENDER_API_KEY=rnd_…  RENDER_OWNER_ID=tea-…
+npm run build        # chant build src --lexicon render -o dist/render.json
+chant run render     # build → renderApply (creates the web service, waits for its deploy)
+```
+
+## Author a service and a database
+
+Import resource types from `@intentius/chant-lexicon-render`. They are generated from Render's Public API OpenAPI spec, so `WebServiceDetails`, `Image`, `ServiceDisk`, and friends are typed all the way down, and every enum (`plan`, `region`, `runtime`) is a string-literal union.
+
+```ts
+import {
+  WebService, WebServiceDetails, NativeEnvironmentDetails, EnvVar, GeneratedEnvVar, Postgres, Render,
+} from "@intentius/chant-lexicon-render";
+
+export const db = new Postgres({ name: "app-db", plan: "free", version: "16", region: Render.Region });
+
+export const web = new WebService({
+  name: "app-web",
+  repo: "https://github.com/render-examples/express-hello-world",
+  branch: "main",
+  serviceDetails: new WebServiceDetails({
+    runtime: "node",
+    plan: "starter",
+    region: Render.Region,
+    envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "npm ci", startCommand: "npm start" }),
+  }),
+  envVars: [
+    new EnvVar({ key: "DATABASE_URL", value: db.internalConnectionString }),
+    new GeneratedEnvVar({ key: "SESSION_SECRET", generateValue: true }),
+  ],
+});
+```
+
+Each service type is its own class — `WebService`, `StaticSite`, `PrivateService`, `BackgroundWorker`, `CronJob` — with `serviceDetails` narrowed to that type's shape (`CronJobDetails` requires `schedule`; `StaticSiteDetails` has `publishPath` and `routes`). The other resources are `Postgres`, `KeyValue`, `EnvGroup`, `Project`, `Environment`, `Disk`, `CustomDomain`, `RegistryCredential`, and `Webhook`.
+
+You do not stamp the ownership marker yourself: the serializer writes `CHANT_MANAGED_BY=chant` (plus `CHANT_STACK` / `CHANT_ENV`) into each service's and env group's `envVars`, and the owned-only prune reads it back.
+
+### References between resources
+
+Render assigns ids on create, so a Disk's `serviceId`, an Environment's `projectId`, or a service's `environmentId` cannot be a literal at build time. Pass the declared resource instead — `serviceId: web`, `projectId: project`, `environmentId: env` — and the applier substitutes the live id after the target exists. Attribute reads work the same way: `db.internalConnectionString`, `db.externalConnectionString`, `kv.internalConnectionString`, `web.id`, `web.dashboardUrl` resolve from the live resource (connection strings from the `/connection-info` endpoint).
+
+## Build and lint
+
+```bash
+chant build src/
+```
+
+Build synthesizes the plan and runs the lint rules before anything reaches the API:
+
+| Rule | Catches |
+|------|---------|
+| REN001 | `region` is not a Render region (frankfurt, oregon, ohio, singapore, virginia) |
+| REN002 | A secret-looking env var (`*_PASSWORD`, `*_TOKEN`, `API_KEY`, …) with a literal value |
+| REN003 | A `schedule` that is not a five-field cron expression |
+| REN010 | A native-runtime service (node, python, …) with no `buildCommand`/`startCommand` |
+| REN011 | A service with neither `repo` nor `image`, or `runtime: "image"` without an image |
+| REN012 | A free-plan service with `numInstances > 1`, `autoscaling`, or a `disk` |
+
+Fix every reported violation before applying. Secret values belong in `generateValue: true`, an `EnvGroup`, a resource attribute, or `process.env` — never a literal (REN002).
+
+## Apply with renderApply
+
+`renderApply` reads the plan and, in dependency order (projects → environments → env groups/datastores → services → disks/domains → webhooks):
+
+1. Resolves `{ $ref }`, `{ $attr }`, and `{ $owner }` markers from what is already live.
+2. Finds the existing resource by name (services also by type; environments by project; disks by service).
+3. `POST`s a create when absent, or `PATCH`es the differing patchable fields when present. Service env vars are replaced through `PUT /services/{id}/env-vars`; a `generateValue` var keeps its live value rather than being regenerated. Env-group vars are reconciled per key.
+4. Waits each **created** service's first deploy to `live` (`wait.deploys: false` to skip; `wait.deadlineMs` default 15 minutes) and throws on `build_failed`/`update_failed`/`canceled`.
+5. With `prune: true`, deletes services and env groups that carry the marker for this stack but are no longer in the plan, and the disks and custom domains under an owned declared service that the plan no longer declares. Foreign resources (no marker) and other stacks' resources are never touched. Datastores, projects, environments, registry credentials, and webhooks are never pruned — they have no marker; remove them explicitly with `renderDelete`.
+
+Returns the versioned apply envelope: `applied` (`created` / `updated` / `unchanged`, with the Render id as `physicalId`) and `pruned`.
+
+## Read back with plan
+
+`chant lifecycle plan` (via `describeResources`) lists what is live for every declared entity, with an ownership verdict: services and env groups are `owned` or `foreign` by the marker; disks and custom domains inherit their service's verdict; everything else is `unknown`, which the change set never escalates to a delete. Undeclared chant-owned services, env groups, disks, and domains surface as owned orphans, so a removed declaration shows up as a delete candidate before you prune.
+
+## Teardown
+
+`renderDelete` (or `renderDeploy({ teardown: true })`) deletes what the plan names in reverse order, looking each up by name; already-gone resources are reported `deleted: false`. Only what the plan declares is touched.

package/dist/spec/fetch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Render's published Public API OpenAPI 3.0 spec.
+ *
+ * Render serves the current spec at a fixed URL with no version or release tag
+ * to pin (the document's own `info.version` has sat at "1.0.0" across many
+ * additive changes), so — like fly — the plugin declares no `upstreamPin`.
+ * Re-running `generate` picks up whatever the URL currently serves.
+ */
+export declare const SCHEMA_URL = "https://api-docs.render.com/v1.0/openapi/render-public-api-1.json";
+/**
+ * Fetch the Render OpenAPI spec and return it as a Map<typeName, Buffer>
+ * compatible with the generatePipeline fetchSchemas callback.
+ *
+ * The spec is a single document, so we return a single entry keyed by
+ * "Render::OpenAPI" — the parse step splits it into the curated resources and
+ * their reachable property types.
+ */
+export declare function fetchSchemas(options?: {
+    force?: boolean;
+}): Promise<Map<string, Buffer>>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/spec/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/spec/fetch.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,sEAAsE,CAAC;AAS9F;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAG9F"}

package/dist/spec/parse.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Render Public API OpenAPI 3.0 parser.
+ *
+ * Render's spec is a REST API description — request/response DTOs, not a
+ * resource catalog — so, like fly, we generate a *curated* set of resources
+ * rather than every schema. Each curated resource pairs a create-request
+ * schema (the writable authoring surface) with a response schema (read-only
+ * attributes). The named object schemas reachable from the request schemas
+ * (`webServiceDetailsPOST`, `image`, `serviceDisk`, `cidrBlockAndDescription`,
+ * ...) become standalone property-type classes so nested config is typed all
+ * the way down; anonymous inline objects (Render leans on `#/paths/...` JSON
+ * pointers for a few of these — autoscaling, env vars, secret files) are
+ * emitted as inline TypeScript object literals, and enums inline as
+ * string-literal unions.
+ *
+ * Services are split by type. Render's `POST /services` takes a `type`
+ * discriminator plus a `serviceDetails` oneOf; authoring `new WebService({...})`
+ * with `serviceDetails` typed as `WebServiceDetails` is both tighter and more
+ * honest than one `Service` class with a five-way union, so each service type
+ * is its own resource with `type` fixed and `serviceDetails` narrowed.
+ */
+import { type PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+export type { PropertyConstraints };
+export interface ParsedProperty {
+    name: string;
+    tsType: string;
+    required: boolean;
+    description?: string;
+    constraints: PropertyConstraints;
+}
+export interface ParsedAttribute {
+    name: string;
+    tsType: string;
+}
+export interface ParsedResource {
+    typeName: string;
+    description?: string;
+    properties: ParsedProperty[];
+    attributes: ParsedAttribute[];
+}
+export interface RenderParseResult {
+    resource: ParsedResource;
+    /** Always empty — render emits property types as standalone results. */
+    propertyTypes: Array<{
+        name: string;
+        defType: string;
+    }>;
+    /** Always empty — enums are inlined as string-literal unions. */
+    enums: Array<{
+        name: string;
+        values: string[];
+    }>;
+    /** Whether this entity is a property type (nested config shape). */
+    isProperty?: boolean;
+}
+/** The type-name namespace every render entity lives under. */
+export declare const NAMESPACE = "Render";
+/**
+ * How a curated resource maps onto the spec. `request`/`response` are schema
+ * locators: either a `#/components/schemas/X` name (bare `X`) or a JSON
+ * pointer into `#/paths/...` for the handful of bodies Render leaves inline.
+ */
+export interface ResourceSpec {
+    typeName: string;
+    request: string;
+    response: string;
+    /**
+     * Request properties chant fixes and therefore hides from the authoring
+     * surface — the service `type` discriminator. The serializer re-injects them.
+     */
+    fixed?: Record<string, unknown>;
+    /** Property → schema locator that replaces the request schema's own type (narrowing `serviceDetails`). */
+    overrides?: Record<string, string>;
+    /**
+     * Properties the API requires but chant can default — `ownerId` resolves from
+     * the `Render.OwnerId` pseudo-parameter (`RENDER_OWNER_ID`) at build time.
+     */
+    optional?: string[];
+    /** Synthetic properties not in the request schema (path parameters such as CustomDomain's `serviceId`). */
+    extraProperties?: ParsedProperty[];
+    /** Synthetic attributes not in the response schema (datastore connection strings, read from a side endpoint). */
+    extraAttributes?: ParsedAttribute[];
+    /**
+     * Property → additional TS union members. Render's cross-resource fields are
+     * opaque ids (`serviceId`, `projectId`, `environmentId`); widening them to
+     * accept the declared resource lets `serviceId: web` reference another entity
+     * and have the applier substitute the live id after it exists.
+     */
+    widen?: Record<string, string>;
+    /** Property → full TS type replacement (array-valued references, where a plain union would not typecheck). */
+    retype?: Record<string, string>;
+    /**
+     * Properties the API marks optional but that are required in practice —
+     * `serviceDetails` on every runtime-bearing service (its `runtime` is
+     * required; a WebService without it is rejected by the API).
+     */
+    require?: string[];
+}
+export declare const RESOURCES: ResourceSpec[];
+/**
+ * Parse the Render OpenAPI spec into the curated resources and the property
+ * types reachable from their request schemas.
+ */
+export declare function parseRenderOpenAPI(data: string | Buffer): RenderParseResult[];
+/** Apply the schema aliases (spec quirks) to a component name. */
+export declare function canonicalSchemaName(name: string): string;
+/**
+ * Convert a component schema name into a PascalCase class name, dropping the
+ * request-shape suffixes Render uses so the authoring surface reads as the
+ * concept, not the wire DTO:
+ * "webServiceDetailsPOST" → "WebServiceDetails", "readReplicaInput" →
+ * "ReadReplica", "routePost" → "Route", "cidrBlockAndDescription" →
+ * "CidrBlockAndDescription".
+ */
+export declare function schemaToClassName(schemaName: string): string;
+/** Extract short name: "Render::Services::WebService" → "WebService". */
+export declare function renderShortName(typeName: string): string;
+/** Extract service name: "Render::Services::WebService" → "Services". */
+export declare function renderServiceName(typeName: string): string;
+//# sourceMappingURL=parse.d.ts.map

package/dist/spec/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/spec/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAKL,KAAK,mBAAmB,EACzB,MAAM,sCAAsC,CAAC;AAI9C,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,mBAAmB,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,cAAc,CAAC;IACzB,wEAAwE;IACxE,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,iEAAiE;IACjE,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACjD,oEAAoE;IACpE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAqBD,+DAA+D;AAC/D,eAAO,MAAM,SAAS,WAAW,CAAC;AAElC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,0GAA0G;IAC1G,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,2GAA2G;IAC3G,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,iHAAiH;IACjH,eAAe,CAAC,EAAE,eAAe,EAAE,CAAC;IACpC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,8GAA8G;IAC9G,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAgDD,eAAO,MAAM,SAAS,EAAE,YAAY,EA0EnC,CAAC;AA+DF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,EAAE,CAuF7E;AA2RD,kEAAkE;AAClE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAID;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ5D;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG1D"}