@intentius/chant-lexicon-render 0.53.0

package/README.md

@@ -0,0 +1,89 @@
+# @intentius/chant-lexicon-render
+
+The Render lexicon for [chant](https://intentius.io/chant/). Declare Render web services, static sites, private services, background workers, cron jobs, Postgres and Key Value datastores, env groups, projects, environments, disks, custom domains, registry credentials, and webhooks as typed TypeScript and apply them straight to the Render Public API.
+
+```bash
+npm install --save-dev @intentius/chant @intentius/chant-lexicon-render
+```
+
+## What it does
+
+chant is a type system for operations: you describe infrastructure as typed TypeScript, and each lexicon turns those declarations into real provider API calls. This one covers [Render](https://render.com).
+
+The resource types are generated from Render's own [Public API OpenAPI spec](https://api-docs.render.com/v1.0/openapi/render-public-api-1.json), so they track the real API and give you full editor autocomplete — every `plan`, `region`, and `runtime` is a string-literal union, and `serviceDetails` is typed per service type. A build step lints them, and `renderApply` reconciles them against a workspace over `https://api.render.com/v1` directly.
+
+It fits two kinds of user: teams running on Render who want their infrastructure as typed, reviewed, reconciled code rather than a `render.yaml` Blueprint or dashboard clicks, and platform engineers who already manage AWS, GCP, Kubernetes, or Fly through chant and want Render in the same model.
+
+## Author infrastructure as typed code
+
+```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",
+  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. Cross-resource ids accept the declared resource — `serviceId: web`, `projectId: project`, `environmentId: env` — and attribute reads like `db.internalConnectionString` resolve from the live resource at apply time. `Render.OwnerId` and `Render.Region` are pseudo-parameters resolved from `RENDER_OWNER_ID` / `RENDER_REGION`.
+
+## Apply without a state file
+
+`renderApply` speaks the Public API directly. There is no CLI shell-out, no Blueprint sync, and no state file to store, lock, or keep in sync. It reconciles what you declared against what is actually running:
+
+- Finds each resource by name (services also by type), `POST`s a create when absent or `PATCH`es the differing fields when present, and replaces service env vars through `PUT /services/{id}/env-vars` — keeping a `generateValue` var's live value rather than regenerating it.
+- Resolves references in dependency order: projects → environments → env groups and datastores → services → disks and custom domains → webhooks.
+- Waits each created service's first deploy to `live`, and fails on `build_failed` / `update_failed`.
+- Prunes only what chant owns. Every service and env group chant creates carries a `CHANT_MANAGED_BY=chant` env-var marker (plus `CHANT_STACK` / `CHANT_ENV`); disks and custom domains inherit their service's verdict. A resource without the marker — or belonging to another stack — is never modified or deleted by `prune`, so the applier is safe to point at a workspace that also holds resources you manage elsewhere. Datastores, projects, environments, registry credentials, and webhooks have no marker channel and are never pruned — remove those with `renderDelete`.
+
+Auth is `RENDER_API_KEY`; the workspace is `RENDER_OWNER_ID`, or the sole workspace the key can see. `RENDER_API_BASE_URL` (or an `endpoint` arg) redirects the whole loop to a local stand-in.
+
+## Catch mistakes at build time
+
+Lint rules run during `chant build`, before anything reaches the API:
+
+- `region` must be a Render region (REN001).
+- A secret-looking env var may not carry a literal value — use `generateValue`, an `EnvGroup`, a resource attribute, or `process.env` (REN002).
+- A cron job `schedule` must be a five-field cron expression (REN003).
+- A native-runtime service must set `buildCommand` and `startCommand` (REN010); every service needs a `repo` or an `image` (REN011); a free-plan service cannot scale or mount a disk (REN012).
+
+## Read back and plan
+
+`describeResources` lists what is live for every declared entity with an ownership verdict — `owned` / `foreign` for services and env groups by the marker, inherited by their disks and custom domains, `unknown` for the rest — and surfaces undeclared chant-owned services, env groups, disks, and domains as owned orphans, so `chant lifecycle plan` shows the delete before you prune.
+
+## The deploy Op
+
+`renderDeploy()` returns a `build → renderApply [→ verify] [→ teardown]` Op, and the runnable [`examples/getting-started`](examples/getting-started) starter wires it up:
+
+```bash
+cd lexicons/render/examples/getting-started
+export RENDER_API_KEY=… RENDER_OWNER_ID=…
+chant run render
+```
+
+## Compared to a Blueprint (`render.yaml`)
+
+|              | Blueprint                                    | This lexicon                                                    |
+| ------------ | -------------------------------------------- | --------------------------------------------------------------- |
+| **Language** | YAML, validated at sync time                 | TypeScript, types generated from the Public API spec, linted at build |
+| **Apply**    | Render syncs from the repo on push           | `renderApply` from anywhere with an API key — CI, a laptop, an agent |
+| **State**    | Render's own; resources tied to the Blueprint | None; reconciles by name from live state + the ownership marker |
+| **References** | `fromDatabase` / `fromService` YAML keys   | `db.internalConnectionString`, `serviceId: web` — typed, checked |
+
+## Agent skill
+
+The agent-facing entry point is the `chant-render` skill: a short operational playbook that walks an agent through authoring a service and a database, linting with `chant build`, and reconciling over the Public API with `renderApply`, including credentials and the workspace. It ships with `chant-render-patterns` (env groups, projects and environments, disks, custom domains, image-backed and cron services, and the ownership model). The skill sources live in [`src/skills/`](src/skills/).

package/dist/catalog.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The Render resource catalog — the one place that knows, per chant entity
+ * type, which REST collection it lives in, how it is identified, and how it is
+ * ordered against its neighbours. The serializer, the applier, the observation
+ * seam, and the lint rules all read this table so the four cannot drift apart
+ * on a resource's wire shape.
+ *
+ * Render's Public API is a plain REST surface (`https://api.render.com/v1`):
+ *   - collections are `POST /services`, `POST /postgres`, ...; children of a
+ *     service are `POST /services/{serviceId}/custom-domains`;
+ *   - a resource is identified by an opaque id (`srv-…`, `dpg-…`) Render
+ *     assigns on create; the *name* is the human key chant reconciles by, and
+ *     is unique per workspace for services (Render enforces it) and, in
+ *     practice, for the rest of what chant declares;
+ *   - lists paginate by cursor and filter by `name` + `ownerId`;
+ *   - updates are `PATCH` with the resource's PATCH DTO — a strict subset of
+ *     the POST body (`ownerId`, `type`, `envVars` and friends are excluded).
+ */
+export declare const ENTITY_TYPES: {
+    readonly webService: "Render::Services::WebService";
+    readonly staticSite: "Render::Services::StaticSite";
+    readonly privateService: "Render::Services::PrivateService";
+    readonly backgroundWorker: "Render::Services::BackgroundWorker";
+    readonly cronJob: "Render::Services::CronJob";
+    readonly postgres: "Render::Datastores::Postgres";
+    readonly keyValue: "Render::Datastores::KeyValue";
+    readonly envGroup: "Render::Config::EnvGroup";
+    readonly registryCredential: "Render::Config::RegistryCredential";
+    readonly webhook: "Render::Config::Webhook";
+    readonly project: "Render::Projects::Project";
+    readonly environment: "Render::Projects::Environment";
+    readonly disk: "Render::Services::Disk";
+    readonly customDomain: "Render::Services::CustomDomain";
+};
+export type EntityType = (typeof ENTITY_TYPES)[keyof typeof ENTITY_TYPES];
+/** The five service entity types (share `POST /services`). */
+export declare const SERVICE_ENTITY_TYPES: readonly string[];
+/** Service entity type → the `type` discriminator `POST /services` takes. */
+export declare const SERVICE_TYPE_OF: Record<string, string>;
+/** The reverse: a live service's `type` → chant entity type. */
+export declare const ENTITY_TYPE_OF_SERVICE: Record<string, string>;
+export declare function isServiceEntityType(entityType: string | undefined): boolean;
+/** How one resource kind maps onto the REST API. */
+export interface CatalogEntry {
+    /** Short kind name — the generated class name (`WebService`, `Postgres`). */
+    kind: string;
+    /**
+     * The create collection. May carry a `{serviceId}` placeholder that the
+     * serializer fills from the resource's `serviceId` prop (a literal id, or a
+     * `{ $ref }` the applier resolves before issuing the request).
+     */
+    collection: string;
+    /**
+     * The key in each element of the list envelope: `GET /services` returns
+     * `[{ service: {...}, cursor }]`. `null` for lists that return bare objects.
+     */
+    listKey: string | null;
+    /** Whether the list endpoint accepts `?name=` and `?ownerId=` filters. */
+    filters: {
+        name: boolean;
+        ownerId: boolean;
+    };
+    /** Whether the API offers `PATCH /{collection}/{id}` for updates. */
+    patchable: boolean;
+    /**
+     * The body fields the PATCH DTO accepts. Fields outside this set are
+     * create-only (or apply through a side endpoint — env vars) and are excluded
+     * from the diff so a rename of `ownerId` never proposes an impossible update.
+     */
+    patchFields: readonly string[];
+    /** Whether the resource carries chant's env-var ownership marker. */
+    marked: boolean;
+    /**
+     * The ownership boundary for a kind with no marker of its own. `"service"`:
+     * the resource hangs off a service (`serviceId`), and inherits that service's
+     * verdict — a disk or custom domain under a chant-owned service is chant's,
+     * the same way fly treats volumes and IPs at the app boundary. Absent: no
+     * boundary either; the verdict is `unknown` and the kind is never pruned.
+     */
+    boundary?: "service";
+    /**
+     * Whether the create body takes an `ownerId` (workspace). When it does and
+     * the author omitted it, the serializer fills it from `Render.OwnerId`.
+     */
+    ownerScoped: boolean;
+    /**
+     * Apply ordering. Lower applies first; delete runs in reverse. Projects
+     * before environments before everything that can join one; services before
+     * the disks/domains that hang off them.
+     */
+    order: number;
+    /** Chant-side props that are association hints, not body fields. */
+    nonBodyProps: readonly string[];
+}
+export declare const CATALOG: Record<string, CatalogEntry>;
+/** Look up a catalog entry, or throw — an unknown entity type is a lexicon bug, not user error. */
+export declare function catalogEntry(entityType: string): CatalogEntry;
+/** Entity type ← short kind (`WebService` → `Render::Services::WebService`). */
+export declare function entityTypeOfKind(kind: string): string | undefined;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CAef,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE1E,8DAA8D;AAC9D,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAMjD,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMlD,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAEzD,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE3E;AAID,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,0EAA0E;IAC1E,OAAO,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7C,qEAAqE;IACrE,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,qEAAqE;IACrE,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AA4BD,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CA6HhD,CAAC;AAEF,mGAAmG;AACnG,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAI7D;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKjE"}

package/dist/codegen/docs-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=docs-cli.d.ts.map

package/dist/codegen/docs-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-cli.d.ts","sourceRoot":"","sources":["../../src/codegen/docs-cli.ts"],"names":[],"mappings":""}

package/dist/codegen/docs.d.ts

@@ -0,0 +1,21 @@
+/**
+ * render documentation generator.
+ *
+ * Calls the core docsPipeline with render-specific config: service grouping and
+ * overview content. Produces a standalone Starlight docs site at
+ * lexicons/render/docs/, like the fly and gcp lexicons.
+ */
+/**
+ * Group a render resource type into a bucket for the reference sidebar. Type
+ * names are `Render::<Group>::<Kind>`; the middle segment is the group
+ * (Services, Datastores, Config, Projects). Property types are all filed under
+ * Services by the generator; keep them there.
+ */
+export declare function serviceFromType(resourceType: string): string;
+/**
+ * Generate documentation for the render lexicon.
+ */
+export declare function generateDocs(options?: {
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=docs.d.ts.map

package/dist/codegen/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE5D;AAwED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBjF"}

package/dist/codegen/generate-cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for render lexicon generation.
+ */
+export {};
+//# sourceMappingURL=generate-cli.d.ts.map

package/dist/codegen/generate-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-cli.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-cli.ts"],"names":[],"mappings":";AACA;;GAEG"}

package/dist/codegen/generate-lexicon.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lexicon JSON generator — produces lexicon-render.json with metadata for the
+ * render resource and property types.
+ */
+import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+import type { RenderParseResult } from "../spec/parse.js";
+import type { NamingStrategy } from "./naming.js";
+export interface RenderLexiconEntry {
+    resourceType: string;
+    kind: "resource" | "property";
+    lexicon: "render";
+    constraints?: Record<string, PropertyConstraints>;
+}
+/**
+ * Generate the lexicon-render.json content.
+ */
+export declare function generateLexiconJSON(results: RenderParseResult[], naming: NamingStrategy): string;
+//# sourceMappingURL=generate-lexicon.d.ts.map

package/dist/codegen/generate-lexicon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-lexicon.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-lexicon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAC9B,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CA8BhG"}

package/dist/codegen/generate-typescript.d.ts

@@ -0,0 +1,12 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with the render
+ * resource classes (WebService, Postgres, EnvGroup, ...) and their
+ * property-type classes.
+ */
+import type { RenderParseResult } from "../spec/parse.js";
+import type { NamingStrategy } from "./naming.js";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export declare function generateTypeScriptDeclarations(results: RenderParseResult[], naming: NamingStrategy): string;
+//# sourceMappingURL=generate-typescript.d.ts.map

package/dist/codegen/generate-typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-typescript.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-typescript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAe/C;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CA4C3G"}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Render generation pipeline — uses core generatePipeline with render-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+import { type GenerateOptions, type GenerateResult } from "@intentius/chant/codegen/generate";
+export type { GenerateResult };
+/**
+ * Run the full render generation pipeline.
+ */
+export declare function generate(opts?: GenerateOptions): Promise<GenerateResult>;
+/**
+ * Write generated artifacts to disk.
+ */
+export declare function writeGeneratedFiles(result: GenerateResult, baseDir: string): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EAEpB,MAAM,mCAAmC,CAAC;AAY3C,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoClF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAUjF"}

package/dist/codegen/naming.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Render naming strategy — maps Render::{Group}::{Kind} type names to
+ * user-friendly TypeScript class names.
+ */
+import { NamingStrategy as CoreNamingStrategy } from "@intentius/chant/codegen/naming";
+import { type RenderParseResult } from "../spec/parse.js";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+/**
+ * Render-specific naming strategy. Extends the core strategy with the render config.
+ */
+export declare class NamingStrategy extends CoreNamingStrategy {
+    constructor(results: RenderParseResult[]);
+}
+//# sourceMappingURL=naming.d.ts.map

package/dist/codegen/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/codegen/naming.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,cAAc,IAAI,kBAAkB,EAGrC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAsC,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE3F,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AA+BnF;;GAEG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;gBACxC,OAAO,EAAE,iBAAiB,EAAE;CAOzC"}

package/dist/codegen/package.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Package the render lexicon for distribution.
+ */
+export declare function packageLexicon(options?: {
+    verbose?: boolean;
+    force?: boolean;
+}): Promise<{
+    spec: import("packages/core/src").BundleSpec;
+    stats: {
+        resources: number;
+        properties: number;
+        enums: number;
+        ruleCount: number;
+        skillCount: number;
+    };
+}>;
+//# sourceMappingURL=package.d.ts.map

package/dist/codegen/package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/codegen/package.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;GAmBpF"}

package/dist/composites/render-deploy.d.ts

@@ -0,0 +1,88 @@
+/**
+ * render deploy Op — `build → renderApply [→ verify]` on the local executor.
+ * The peer of `flyDeploy`, for a platform with no local emulator: it targets a
+ * real Render workspace with a `RENDER_API_KEY`.
+ *
+ * The phases compose modeled activities, no raw shell:
+ *   Build    run the project's `build:render` npm script → the serialized plan
+ *   Apply    `renderApply` the plan straight to the Render Public API (creates
+ *            or PATCHes each resource by name, waits each created service's
+ *            deploy to `live`, prunes owned-only when asked)
+ *   Verify   optional: GET a public URL and assert on its body
+ *
+ * The activity steps are the generic `activity(fn, args)` builder tagged with
+ * the exported activity function names the render lexicon contributes
+ * (`renderApply`/`renderDelete` from `src/op/activities`). The core activity
+ * registry resolves them by name when a project lists the `render` lexicon.
+ */
+import type { OpResource } from "@intentius/chant/op";
+import type { ActivityStep } from "@intentius/chant/op";
+/** Options for the render apply step (mirror `RenderApplyArgs`, minus `planPath`). */
+export interface RenderApplyStepOpts {
+    /** API base URL override. Default: `RENDER_API_BASE_URL` env, else api.render.com. */
+    endpoint?: string;
+    /** Bearer token. Default: `RENDER_API_KEY`. */
+    token?: string;
+    /** Workspace id for `$owner` markers. Default: `RENDER_OWNER_ID`, else the sole visible owner. */
+    ownerId?: string;
+    /** Prune chant-owned services/env groups the plan no longer declares. Destructive — off by default. */
+    prune?: boolean;
+    /** Deploy wait tuning. */
+    wait?: Record<string, unknown>;
+    /** Activity profile override. */
+    profile?: ActivityStep["profile"];
+}
+/**
+ * Apply the serialized render plan straight to the Render Public API — the
+ * typed twin of `flyApplyStep`. Resolves to the `renderApply` activity.
+ * Defaults to the `longInfra` profile (a first deploy builds and can take
+ * minutes); override via `opts.profile`.
+ */
+export declare const renderApplyStep: (planPath: string, opts?: RenderApplyStepOpts) => ActivityStep;
+/**
+ * Delete everything the plan declares, in reverse order — the teardown twin.
+ * Resolves to the `renderDelete` activity.
+ */
+export declare const renderDeleteStep: (planPath: string, opts?: RenderApplyStepOpts) => ActivityStep;
+/** Options for {@link renderDeploy}. */
+export interface RenderDeployOpts {
+    /** Op name (the `chant run <name>` target). Default: `render`. */
+    name?: string;
+    /** Op overview line. */
+    overview?: string;
+    /** Temporal task queue (unused by the local executor). Default: `local-render`. */
+    taskQueue?: string;
+    /** Directory the `build:render` script and plan path are relative to. Default: `.`. */
+    path?: string;
+    /** npm build script to run. Default: `build:render`. */
+    buildScript?: string;
+    /** Path to the serialized render plan the build writes. Default: `dist/render.json`. */
+    planPath?: string;
+    /** API base URL override (a local stand-in). Default: real Render via `RENDER_API_BASE_URL` / `RENDER_API_KEY`. */
+    endpoint?: string;
+    /** Workspace id. Default: `RENDER_OWNER_ID`, else the sole visible owner. */
+    ownerId?: string;
+    /** Prune declared-then-removed owned resources on apply. Off by default. */
+    prune?: boolean;
+    /** Deploy wait tuning passed through to `renderApply`. */
+    wait?: Record<string, unknown>;
+    /**
+     * A public URL to GET after apply, with the text it must contain. When set,
+     * the Op adds a Verify phase. Omitted → no Verify (the Apply step still
+     * waits each created service's deploy to `live`).
+     */
+    verify?: {
+        url: string;
+        contains?: string;
+        retries?: number;
+        intervalMs?: number;
+    };
+    /** Add a Teardown phase that deletes what the plan declares. Off by default. */
+    teardown?: boolean;
+}
+/**
+ * Build a render deploy Op: build the plan, apply it to the workspace, verify
+ * a URL when asked, tear down when asked. See the module docstring.
+ */
+export declare function renderDeploy(opts?: RenderDeployOpts): InstanceType<typeof OpResource>;
+//# sourceMappingURL=render-deploy.d.ts.map

package/dist/composites/render-deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-deploy.d.ts","sourceRoot":"","sources":["../../src/composites/render-deploy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAClC,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kGAAkG;IAClG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uGAAuG;IACvG,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,iCAAiC;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,EAAE,OAAO,mBAAmB,KAAG,YAG9E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,OAAO,mBAAmB,KAAG,YAG/E,CAAC;AAEF,wCAAwC;AACxC,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mHAAmH;IACnH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,gFAAgF;IAChF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,gBAAqB,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAsCzF"}

package/dist/coverage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Coverage analysis for the render lexicon — how much of the generated Render
+ * API surface the lexicon's typed resources cover. Thin wrapper over the shared
+ * `computeCoverage`, mirroring the fly/gcp peers.
+ */
+import { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds, type CoverageReport, type CoverageThresholds } from "@intentius/chant/codegen/coverage";
+export type { CoverageReport, CoverageThresholds };
+export { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds };
+/** Run coverage analysis for the render lexicon. */
+export declare function analyzeRenderCoverage(opts?: {
+    basePath?: string;
+    verbose?: boolean;
+    minOverall?: number;
+}): Promise<CoverageReport>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACL,eAAe,EACf,UAAU,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAEtF,oDAAoD;AACpD,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,cAAc,CAAC,CAqB1B"}

package/dist/describe-resources.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Live introspection of Render resources — the read-back seam for chant's
+ * plan/drift machinery.
+ *
+ * The write path (renderApply) already GETs live state to decide
+ * create/update/unchanged and to prune owned orphans. This surfaces that same
+ * read side through the standard `describeResources` seam so core's change set
+ * and `chant lifecycle plan` can see live Render state and classify
+ * create/update/delete/adopt/noop.
+ *
+ * Peer of fly's describe-resources: list what is live, key it by chant entity
+ * name, attach an ownership verdict. Two-tier ownership, matching the applier:
+ *
+ *   - Services and env groups carry the primary marker (`CHANT_MANAGED_BY`,
+ *     RENDER_ENV_OWNERSHIP_KEYS) in their env vars, so their verdict is
+ *     per-resource: `owned` when marked, else `foreign`.
+ *   - Disks and custom domains carry no marker but hang off a service, so
+ *     they inherit the parent's verdict (the service boundary — fly's app
+ *     boundary, one level down); undeclared ones under an owned declared
+ *     service surface as owned orphans.
+ *   - Datastores, projects, environments, registry credentials, and webhooks
+ *     carry no marker channel and no boundary, so their verdict is `unknown`
+ *     — the change set never escalates `unknown` to a delete. When the
+ *     `owned` filter asks for those types, this logs that no verdict is
+ *     available rather than silently returning everything.
+ *
+ * Endpoint + auth reuse the applier verbatim (resolveEndpoint /
+ * RENDER_API_BASE_URL / RENDER_API_KEY), so plan reads the same target
+ * renderApply writes. Undeclared chant-marked services and env groups in the
+ * workspace are also returned (as orphans keyed by `<type>/<name>`), so a
+ * declared-then-removed service shows up as a delete candidate.
+ */
+import type { ObservationResult } from "@intentius/chant/lexicon";
+import { type RenderHttp } from "./op/activities/render-apply.js";
+export interface DescribeResourcesOptions {
+    environment: string;
+    buildOutput: string;
+    entityNames: string[];
+    entities: Map<string, {
+        entityType: string;
+        props: Record<string, unknown>;
+    }>;
+    /** Restrict to chant-owned resources (#119). */
+    owned?: boolean;
+    /** API endpoint override (tests). Defaults to resolveEndpoint() → RENDER_API_BASE_URL. */
+    endpoint?: string;
+    /** Workspace override (tests). Defaults to RENDER_OWNER_ID, else the sole visible owner. */
+    ownerId?: string;
+}
+/**
+ * List live Render resources and return them keyed by chant entity name, each
+ * tagged with an ownership verdict the core change set reads to decide whether
+ * an orphan is a delete (owned) or an adopt candidate (foreign). Reused by
+ * `renderPlugin.describeResources`.
+ *
+ * `http` is injectable for tests; the default reuses the applier's fetch client
+ * (bearer token from RENDER_API_KEY).
+ */
+export declare function describeResources(options: DescribeResourcesOptions, http?: RenderHttp, signal?: AbortSignal): Promise<ObservationResult>;
+//# sourceMappingURL=describe-resources.d.ts.map

package/dist/describe-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../src/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAsC,MAAM,0BAA0B,CAAC;AAItG,OAAO,EAWL,KAAK,UAAU,EAEhB,MAAM,8BAA8B,CAAC;AAEtC,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4FAA4F;IAC5F,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAaD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,EACjC,IAAI,GAAE,UAAgC,EACtC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,iBAAiB,CAAC,CA4Q5B"}

package/dist/detect.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Template detection for the render lexicon.
+ *
+ * `chant import` parses a template file as JSON and asks each installed lexicon
+ * whether it recognizes the shape. render's importable source is the serializer
+ * plan (what `chant build` emits and `renderApply` POSTs): an object keyed by
+ * entity name whose values carry a `Render::…` entityType and a `POST` request.
+ */
+/** The serializer's whole output: entity name → request. */
+export declare function isSerializerPlan(v: unknown): boolean;
+export declare function detectTemplate(data: unknown): boolean;
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAYH,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAIpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAErD"}

package/dist/generated/index.d.ts

@@ -0,0 +1,38 @@
+export declare const BackgroundWorker: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const CronJob: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const CustomDomain: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Disk: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const EnvGroup: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Environment: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const KeyValue: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Postgres: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const PrivateService: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Project: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const RegistryCredential: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const StaticSite: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Webhook: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const WebService: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Autoscaling: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const AutoscalingCriteria: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const AutoscalingCriterion: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const BackgroundWorkerDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const BuildFilter: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const CidrBlockAndDescription: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const CronJobDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const DockerDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const EnvVar: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const GeneratedEnvVar: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const Header: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const Image: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const MaintenanceMode: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const NativeEnvironmentDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const Previews: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const PrivateServiceDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const ProjectEnvironment: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const ReadReplica: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const Route: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const SecretFile: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const ServiceDisk: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const StaticSiteDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+export declare const WebServiceDetails: new (props: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generated/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,+IAA4T,CAAC;AAC1V,eAAO,MAAM,OAAO,+IAAmT,CAAC;AACxU,eAAO,MAAM,YAAY,+IAA0P,CAAC;AACpR,eAAO,MAAM,IAAI,+IAAkH,CAAC;AACpI,eAAO,MAAM,QAAQ,+IAAkJ,CAAC;AACxK,eAAO,MAAM,WAAW,+IAAmL,CAAC;AAC5M,eAAO,MAAM,QAAQ,+IAAoW,CAAC;AAC1X,eAAO,MAAM,QAAQ,+IAAkkB,CAAC;AACxlB,eAAO,MAAM,cAAc,+IAA0T,CAAC;AACtV,eAAO,MAAM,OAAO,+IAAuK,CAAC;AAC5L,eAAO,MAAM,kBAAkB,+IAAsG,CAAC;AACtI,eAAO,MAAM,UAAU,+IAAsT,CAAC;AAC9U,eAAO,MAAM,OAAO,+IAAqF,CAAC;AAC1G,eAAO,MAAM,UAAU,+IAAsT,CAAC;AAE9U,eAAO,MAAM,WAAW,0GAA4D,CAAC;AACrF,eAAO,MAAM,mBAAmB,0GAAoE,CAAC;AACrG,eAAO,MAAM,oBAAoB,0GAAqE,CAAC;AACvG,eAAO,MAAM,uBAAuB,0GAAwE,CAAC;AAC7G,eAAO,MAAM,WAAW,0GAA4D,CAAC;AACrF,eAAO,MAAM,uBAAuB,0GAAwE,CAAC;AAC7G,eAAO,MAAM,cAAc,0GAA+D,CAAC;AAC3F,eAAO,MAAM,aAAa,0GAA8D,CAAC;AACzF,eAAO,MAAM,MAAM,0GAAuD,CAAC;AAC3E,eAAO,MAAM,eAAe,0GAAgE,CAAC;AAC7F,eAAO,MAAM,MAAM,0GAAuD,CAAC;AAC3E,eAAO,MAAM,KAAK,0GAAsD,CAAC;AACzE,eAAO,MAAM,eAAe,0GAAgE,CAAC;AAC7F,eAAO,MAAM,wBAAwB,0GAAyE,CAAC;AAC/G,eAAO,MAAM,QAAQ,0GAAyD,CAAC;AAC/E,eAAO,MAAM,qBAAqB,0GAAsE,CAAC;AACzG,eAAO,MAAM,kBAAkB,0GAAmE,CAAC;AACnG,eAAO,MAAM,WAAW,0GAA4D,CAAC;AACrF,eAAO,MAAM,KAAK,0GAAsD,CAAC;AACzE,eAAO,MAAM,UAAU,0GAA2D,CAAC;AACnF,eAAO,MAAM,WAAW,0GAA4D,CAAC;AACrF,eAAO,MAAM,iBAAiB,0GAAkE,CAAC;AACjG,eAAO,MAAM,iBAAiB,0GAAkE,CAAC"}

package/dist/generated/runtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/generated/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/generated/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { renderPlugin } from "./plugin.js";
+export { renderSerializer, isRefMarker, isAttrMarker, isOwnerMarker } from "./serializer.js";
+export type { RenderPlan, RenderRequest, RefMarker, AttrMarker, OwnerMarker } from "./serializer.js";
+export { Render, OwnerId, Region, PseudoParameter } from "./pseudo.js";
+export { RENDER_ENV_OWNERSHIP_KEYS } from "./ownership.js";
+export { CATALOG, ENTITY_TYPES, SERVICE_TYPE_OF, catalogEntry, isServiceEntityType } from "./catalog.js";
+export type { CatalogEntry, EntityType } from "./catalog.js";
+export { renderDeploy, renderApplyStep, renderDeleteStep } from "./composites/render-deploy.js";
+export type { RenderDeployOpts, RenderApplyStepOpts } from "./composites/render-deploy.js";
+export * from "./generated/index.js";
+//# 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":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1F,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAIlG,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAGxD,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACtG,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAK1D,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAOxF,cAAc,mBAAmB,CAAC"}