@intentius/chant-lexicon-render 0.124.31 → 0.124.32

package/dist/catalog.js

@@ -0,0 +1,221 @@
+/**
+ * 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).
+ */
+// ── Entity types ───────────────────────────────────────────────────
+export const ENTITY_TYPES = {
+    webService: "Render::Services::WebService",
+    staticSite: "Render::Services::StaticSite",
+    privateService: "Render::Services::PrivateService",
+    backgroundWorker: "Render::Services::BackgroundWorker",
+    cronJob: "Render::Services::CronJob",
+    postgres: "Render::Datastores::Postgres",
+    keyValue: "Render::Datastores::KeyValue",
+    envGroup: "Render::Config::EnvGroup",
+    registryCredential: "Render::Config::RegistryCredential",
+    webhook: "Render::Config::Webhook",
+    project: "Render::Projects::Project",
+    environment: "Render::Projects::Environment",
+    disk: "Render::Services::Disk",
+    customDomain: "Render::Services::CustomDomain",
+};
+/** The five service entity types (share `POST /services`). */
+export const SERVICE_ENTITY_TYPES = [
+    ENTITY_TYPES.webService,
+    ENTITY_TYPES.staticSite,
+    ENTITY_TYPES.privateService,
+    ENTITY_TYPES.backgroundWorker,
+    ENTITY_TYPES.cronJob,
+];
+/** Service entity type → the `type` discriminator `POST /services` takes. */
+export const SERVICE_TYPE_OF = {
+    [ENTITY_TYPES.webService]: "web_service",
+    [ENTITY_TYPES.staticSite]: "static_site",
+    [ENTITY_TYPES.privateService]: "private_service",
+    [ENTITY_TYPES.backgroundWorker]: "background_worker",
+    [ENTITY_TYPES.cronJob]: "cron_job",
+};
+/** The reverse: a live service's `type` → chant entity type. */
+export const ENTITY_TYPE_OF_SERVICE = Object.fromEntries(Object.entries(SERVICE_TYPE_OF).map(([k, v]) => [v, k]));
+export function isServiceEntityType(entityType) {
+    return !!entityType && SERVICE_ENTITY_TYPES.includes(entityType);
+}
+const SERVICE_PATCH_FIELDS = [
+    "autoDeploy",
+    "repo",
+    "branch",
+    "image",
+    "name",
+    "buildFilter",
+    "rootDir",
+    "serviceDetails",
+];
+function serviceEntry(kind) {
+    return {
+        kind,
+        collection: "/services",
+        listKey: "service",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: SERVICE_PATCH_FIELDS,
+        marked: true,
+        ownerScoped: true,
+        order: 40,
+        nonBodyProps: [],
+    };
+}
+export const CATALOG = {
+    [ENTITY_TYPES.project]: {
+        kind: "Project",
+        collection: "/projects",
+        listKey: "project",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: ["name"],
+        marked: false,
+        ownerScoped: true,
+        order: 10,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.environment]: {
+        kind: "Environment",
+        collection: "/environments",
+        listKey: "environment",
+        filters: { name: true, ownerId: false },
+        patchable: true,
+        patchFields: ["name", "protectedStatus", "networkIsolationEnabled", "ipAllowList"],
+        marked: false,
+        ownerScoped: false,
+        order: 20,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.registryCredential]: {
+        kind: "RegistryCredential",
+        collection: "/registrycredentials",
+        listKey: "registryCredential",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: ["registry", "name", "username", "authToken"],
+        marked: false,
+        ownerScoped: true,
+        order: 25,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.envGroup]: {
+        kind: "EnvGroup",
+        collection: "/env-groups",
+        listKey: "envGroup",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: ["name", "environmentId"],
+        marked: true,
+        ownerScoped: true,
+        order: 30,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.postgres]: {
+        kind: "Postgres",
+        collection: "/postgres",
+        listKey: "postgres",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: [
+            "name",
+            "plan",
+            "enableHighAvailability",
+            "diskSizeGB",
+            "enableDiskAutoscaling",
+            "readReplicas",
+            "ipAllowList",
+            "parameterOverrides",
+        ],
+        marked: false,
+        ownerScoped: true,
+        order: 30,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.keyValue]: {
+        kind: "KeyValue",
+        collection: "/key-value",
+        listKey: "keyValue",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: ["name", "plan", "maxmemoryPolicy", "ipAllowList"],
+        marked: false,
+        ownerScoped: true,
+        order: 30,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.webService]: serviceEntry("WebService"),
+    [ENTITY_TYPES.staticSite]: serviceEntry("StaticSite"),
+    [ENTITY_TYPES.privateService]: serviceEntry("PrivateService"),
+    [ENTITY_TYPES.backgroundWorker]: serviceEntry("BackgroundWorker"),
+    [ENTITY_TYPES.cronJob]: serviceEntry("CronJob"),
+    [ENTITY_TYPES.disk]: {
+        kind: "Disk",
+        collection: "/disks",
+        listKey: "disk",
+        filters: { name: true, ownerId: true },
+        patchable: true,
+        patchFields: ["name", "sizeGB", "mountPath"],
+        marked: false,
+        boundary: "service",
+        ownerScoped: false,
+        order: 50,
+        nonBodyProps: [],
+    },
+    [ENTITY_TYPES.customDomain]: {
+        kind: "CustomDomain",
+        collection: "/services/{serviceId}/custom-domains",
+        listKey: "customDomain",
+        filters: { name: true, ownerId: false },
+        patchable: false,
+        patchFields: [],
+        marked: false,
+        boundary: "service",
+        ownerScoped: false,
+        order: 50,
+        nonBodyProps: ["serviceId"],
+    },
+    [ENTITY_TYPES.webhook]: {
+        kind: "Webhook",
+        collection: "/webhooks",
+        listKey: "webhook",
+        filters: { name: false, ownerId: true },
+        patchable: true,
+        patchFields: ["url", "name", "enabled", "eventFilter"],
+        marked: false,
+        ownerScoped: true,
+        order: 60,
+        nonBodyProps: [],
+    },
+};
+/** Look up a catalog entry, or throw — an unknown entity type is a lexicon bug, not user error. */
+export function catalogEntry(entityType) {
+    const entry = CATALOG[entityType];
+    if (!entry)
+        throw new Error(`render: no catalog entry for entity type ${entityType}`);
+    return entry;
+}
+/** Entity type ← short kind (`WebService` → `Render::Services::WebService`). */
+export function entityTypeOfKind(kind) {
+    for (const [type, entry] of Object.entries(CATALOG)) {
+        if (entry.kind === kind)
+            return type;
+    }
+    return undefined;
+}

package/dist/codegen/docs-cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+import { generateDocs } from "./docs.js";
+generateDocs({ verbose: true }).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/codegen/docs.js

@@ -0,0 +1,110 @@
+/**
+ * render documentation generator.
+ *
+ * Calls the core docsPipeline with render-specific config: service grouping and
+ * overview content. writeDocsSite puts the pages in the main docs site under
+ * docs/src/content/docs/lexicons/render/ (chant #3993).
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+/**
+ * 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 function serviceFromType(resourceType) {
+    return resourceType.split("::")[1] ?? resourceType;
+}
+const overview = `The **Render** lexicon defines Render services, datastores, env groups, projects, and environments using chant's declarative TypeScript syntax. Resources are serialized to the JSON create bodies the [Render Public API](https://api-docs.render.com/) accepts, so the applier can POST them straight through — no Blueprint, no CLI, no state file.
+
+This lexicon is generated from Render's published [OpenAPI spec](https://api-docs.render.com/v1.0/openapi/render-public-api-1.json).
+
+Install it with:
+
+\`\`\`bash
+npm install --save-dev @intentius/chant-lexicon-render
+\`\`\`
+
+## Quick Start
+
+\`\`\`typescript
+import {
+  WebService, WebServiceDetails, NativeEnvironmentDetails, EnvVar, GeneratedEnvVar, Postgres, Render,
+} from "@intentius/chant-lexicon-render";
+
+const db = new Postgres({ name: "app-db", plan: "free", version: "16", region: Render.Region });
+
+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 }),
+  ],
+});
+
+export { db, web };
+\`\`\`
+
+\`Render.OwnerId\` and \`Render.Region\` are pseudo-parameters resolved from the environment at build time (\`RENDER_OWNER_ID\`, \`RENDER_REGION\`). Every \`ownerId\` chant fills in defaults to \`Render.OwnerId\`, so a stack rarely names it. \`db.internalConnectionString\` is an attribute read the applier resolves from the live database.`;
+const outputFormat = `The render lexicon serializes resources into the JSON create bodies the Render Public API accepts.
+
+## Building
+
+Each declared resource becomes a single request keyed by its logical name:
+
+\`\`\`json
+{
+  "web": {
+    "kind": "WebService",
+    "entityType": "Render::Services::WebService",
+    "endpoint": "/services",
+    "method": "POST",
+    "name": "app-web",
+    "body": { "type": "web_service", "name": "app-web", "ownerId": "tea-…", "serviceDetails": { ... }, "envVars": [ ... ] }
+  }
+}
+\`\`\`
+
+- Each service type becomes \`POST /services\` with its \`type\` discriminator re-injected and \`serviceDetails\` in that type's shape.
+- \`Postgres\` → \`POST /postgres\`; \`KeyValue\` → \`POST /key-value\`; \`EnvGroup\` → \`POST /env-groups\`; \`Project\` → \`POST /projects\`; \`Environment\` → \`POST /environments\`; \`Disk\` → \`POST /disks\`; \`RegistryCredential\` → \`POST /registrycredentials\`; \`Webhook\` → \`POST /webhooks\`.
+- \`CustomDomain\` → \`POST /services/{serviceId}/custom-domains\`; the service is a path segment carried in \`pathParams\`.
+
+Three markers may appear in a body, resolved by the applier once their target is live: \`{ "$ref": "<entity>" }\` (a declared resource's id), \`{ "$attr": { "entity", "attribute" } }\` (an attribute read — \`id\`, \`dashboardUrl\`, or a datastore connection string), and \`{ "$owner": true }\` (the workspace, when neither the author nor \`RENDER_OWNER_ID\` named one).
+
+Every serialized service and env group carries the \`CHANT_MANAGED_BY=chant\` ownership marker (plus \`CHANT_STACK\` / \`CHANT_ENV\`) in its \`envVars\`, which the owned-only prune reads back.
+
+## Applying
+
+The output is applied against the Public API directly by \`renderApply\` (via \`chant run\` and the \`renderDeploy\` Op). Endpoint and auth come from \`RENDER_API_BASE_URL\` and \`RENDER_API_KEY\`; the workspace from \`RENDER_OWNER_ID\` (or the sole workspace the key can see). Each resource is found by name and created or PATCHed; created services are waited to \`live\`; with \`prune\` the owned services and env groups no longer declared — and the disks and custom domains under owned services no longer declared — are deleted.`;
+/**
+ * Generate documentation for the render lexicon.
+ */
+export async function generateDocs(options) {
+    const config = {
+        name: "render",
+        displayName: "Render",
+        description: "Typed constructors for Render services, datastores, and env groups, serialized to Public API create bodies",
+        distDir: join(pkgDir, "dist"),
+        outDir: join(pkgDir, "docs"),
+        srcDir: join(pkgDir, "src"),
+        basePath: process.env.DOCS_BASE_PATH ?? "/chant/lexicons/render/",
+        overview,
+        outputFormat,
+        serviceFromType,
+    };
+    const result = docsPipeline(config);
+    writeDocsSite(config, result);
+    if (options?.verbose) {
+        console.error(`Generated docs: ${result.stats.resources} resources, ${result.stats.properties} properties, ${result.stats.services} services, ${result.stats.rules} rules`);
+    }
+}

package/dist/codegen/generate-cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for render lexicon generation.
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate.js";
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+async function main() {
+    const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+    const force = process.argv.includes("--force") || process.argv.includes("-f");
+    console.error("Generating render lexicon...");
+    const result = await generate({ verbose, force });
+    writeGeneratedFiles(result, pkgDir);
+    console.error(`Generated ${result.resources} resources, ${result.properties} property types, ${result.enums} enums`);
+    if (result.warnings.length > 0) {
+        console.error(`${result.warnings.length} warnings:`);
+        for (const w of result.warnings) {
+            console.error(`  ${w.file}: ${w.error}`);
+        }
+    }
+}
+main().catch((err) => {
+    console.error("Generation failed:", err);
+    process.exit(1);
+});

package/dist/codegen/generate-lexicon.js

@@ -0,0 +1,38 @@
+/**
+ * Lexicon JSON generator — produces lexicon-render.json with metadata for the
+ * render resource and property types.
+ */
+import { renderShortName } from "../spec/parse.js";
+import { buildRegistry, serializeRegistry } from "@intentius/chant/codegen/generate-registry";
+/**
+ * Generate the lexicon-render.json content.
+ */
+export function generateLexiconJSON(results, naming) {
+    const registryResources = results.map((r) => ({
+        typeName: r.resource.typeName,
+        attributes: r.resource.attributes,
+        properties: r.resource.properties,
+        propertyTypes: [],
+    }));
+    const entries = buildRegistry(registryResources, naming, {
+        shortName: renderShortName,
+        buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+            const r = results.find((res) => res.resource.typeName === resource.typeName);
+            const entry = {
+                resourceType: resource.typeName,
+                kind: r?.isProperty ? "property" : "resource",
+                lexicon: "render",
+            };
+            if (propConstraints && Object.keys(propConstraints).length > 0) {
+                entry.constraints = propConstraints;
+            }
+            return entry;
+        },
+        buildPropertyEntry: (resourceType, propertyType) => ({
+            resourceType: `${resourceType}.${propertyType}`,
+            kind: "property",
+            lexicon: "render",
+        }),
+    });
+    return serializeRegistry(entries);
+}

package/dist/codegen/generate-typescript.js

@@ -0,0 +1,46 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with the render
+ * resource classes (WebService, Postgres, EnvGroup, ...) and their
+ * property-type classes.
+ */
+import { writeResourceClass, writePropertyClass, } from "@intentius/chant/codegen/generate-typescript";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(results, naming) {
+    const lines = [];
+    lines.push("// Code generated by chant render generate. DO NOT EDIT.");
+    const entries = [];
+    for (const r of results) {
+        const tsName = naming.resolve(r.resource.typeName);
+        if (!tsName)
+            continue;
+        const properties = r.resource.properties.map((p) => ({
+            name: p.name,
+            type: p.tsType,
+            required: p.required,
+            description: p.description,
+        }));
+        const attributes = r.resource.attributes.map((a) => ({ name: a.name, type: a.tsType }));
+        entries.push({ tsName, isProperty: !!r.isProperty, properties, attributes });
+    }
+    entries.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    const resources = entries.filter((e) => !e.isProperty);
+    const propertyTypes = entries.filter((e) => e.isProperty);
+    if (resources.length > 0) {
+        lines.push("");
+        lines.push("// --- Render Resource classes ---");
+        for (const re of resources) {
+            writeResourceClass(lines, re.tsName, re.properties, re.attributes);
+        }
+    }
+    if (propertyTypes.length > 0) {
+        lines.push("");
+        lines.push("// --- Property type classes ---");
+        for (const pe of propertyTypes) {
+            writePropertyClass(lines, pe.tsName, pe.properties);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/codegen/generate.js

@@ -0,0 +1,82 @@
+/**
+ * Render generation pipeline — uses core generatePipeline with render-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+import { generatePipeline, writeGeneratedArtifacts, } from "@intentius/chant/codegen/generate";
+import { fetchSchemas } from "../spec/fetch.js";
+import { parseRenderOpenAPI } from "../spec/parse.js";
+import { NamingStrategy } from "./naming.js";
+import { generateLexiconJSON } from "./generate-lexicon.js";
+import { generateTypeScriptDeclarations } from "./generate-typescript.js";
+import { generateRuntimeIndex as coreGenerateRuntimeIndex, } from "@intentius/chant/codegen/generate-runtime-index";
+/**
+ * Run the full render generation pipeline.
+ */
+export async function generate(opts = {}) {
+    // The Render spec is a single document — parseRenderOpenAPI returns multiple
+    // results. The pipeline calls parseSchema once, so we return the first result
+    // and inject the rest via augmentResults.
+    let pendingResults = [];
+    const config = {
+        fetchSchemas: (fetchOpts) => fetchSchemas({ force: fetchOpts.force }),
+        parseSchema: (_typeName, data) => {
+            const results = parseRenderOpenAPI(data);
+            if (results.length === 0)
+                return null;
+            pendingResults = results.slice(1);
+            return results[0];
+        },
+        createNaming: (results) => new NamingStrategy(results),
+        augmentResults: (results, _opts, log) => {
+            if (pendingResults.length > 0) {
+                results.push(...pendingResults);
+                log(`Added ${pendingResults.length} additional render schemas from OpenAPI spec`);
+                pendingResults = [];
+            }
+            log(`Total: ${results.length} render resource/property schemas`);
+            return { results };
+        },
+        generateRegistry: (results, naming) => generateLexiconJSON(results, naming),
+        generateTypes: (results, naming) => generateTypeScriptDeclarations(results, naming),
+        generateRuntimeIndex: (results, naming) => generateRuntimeIndex(results, naming),
+    };
+    return generatePipeline(config, opts);
+}
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result, baseDir) {
+    writeGeneratedArtifacts({
+        baseDir,
+        files: {
+            "lexicon-render.json": result.lexiconJSON,
+            "index.d.ts": result.typesDTS,
+            "index.ts": result.indexTS,
+            "runtime.ts": `/**\n * Runtime factory constructors — re-exported from core.\n */\nexport { createResource, createProperty } from "@intentius/chant/runtime";\n`,
+        },
+    });
+}
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(results, naming) {
+    const resourceEntries = [];
+    const propertyEntries = [];
+    for (const r of results) {
+        const typeName = r.resource.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        if (r.isProperty) {
+            propertyEntries.push({ tsName, resourceType: typeName });
+        }
+        else {
+            const attrs = {};
+            for (const attr of r.resource.attributes) {
+                attrs[attr.name] = attr.name;
+            }
+            resourceEntries.push({ tsName, resourceType: typeName, attrs });
+        }
+    }
+    return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, { lexiconName: "render" });
+}

package/dist/codegen/naming.js

@@ -0,0 +1,43 @@
+/**
+ * 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 { renderShortName, renderServiceName } from "../spec/parse.js";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+const renderNamingConfig = {
+    priorityNames: {
+        "Render::Services::WebService": "WebService",
+        "Render::Services::StaticSite": "StaticSite",
+        "Render::Services::PrivateService": "PrivateService",
+        "Render::Services::BackgroundWorker": "BackgroundWorker",
+        "Render::Services::CronJob": "CronJob",
+        "Render::Datastores::Postgres": "Postgres",
+        "Render::Datastores::KeyValue": "KeyValue",
+        "Render::Config::EnvGroup": "EnvGroup",
+        "Render::Projects::Project": "Project",
+        "Render::Projects::Environment": "Environment",
+    },
+    priorityAliases: {},
+    priorityPropertyAliases: {},
+    serviceAbbreviations: {
+        Services: "Services",
+        Datastores: "Datastores",
+        Config: "Config",
+        Projects: "Projects",
+    },
+    shortName: renderShortName,
+    serviceName: renderServiceName,
+};
+/**
+ * Render-specific naming strategy. Extends the core strategy with the render config.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+    constructor(results) {
+        const inputs = results.map((r) => ({
+            typeName: r.resource.typeName,
+            propertyTypes: r.propertyTypes,
+        }));
+        super(inputs, renderNamingConfig);
+    }
+}

package/dist/codegen/package.js

@@ -0,0 +1,27 @@
+import { packagePipeline, collectSkills } from "@intentius/chant/codegen/package";
+import { generate } from "./generate.js";
+import { renderPlugin } from "../plugin.js";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+/**
+ * Package the render lexicon for distribution.
+ */
+export async function packageLexicon(options) {
+    // This file is src/codegen/package.ts — rules and skills are collected
+    // relative to src/, so srcDir must be the parent of this directory.
+    const srcDir = dirname(moduleSourceDir(import.meta.url));
+    const pkgJson = JSON.parse(readFileSync(join(srcDir, "..", "package.json"), "utf-8"));
+    const { spec, stats } = await packagePipeline({
+        generate: (opts) => generate({ verbose: opts?.verbose, force: opts?.force }),
+        buildManifest: (_genResult) => ({
+            name: "render",
+            version: pkgJson.version ?? "0.0.0",
+            chantVersion: ">=0.1.0",
+            namespace: "Render",
+        }),
+        srcDir,
+        collectSkills: () => collectSkills(renderPlugin.skills?.() ?? []),
+    });
+    return { spec, stats };
+}

package/dist/composites/render-deploy.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { Op, phase, build, activity, httpCheck } from "@intentius/chant/op";
+/**
+ * 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 const renderApplyStep = (planPath, opts) => {
+    const { profile, ...rest } = opts ?? {};
+    return activity("renderApply", { planPath, ...rest }, profile ?? "longInfra");
+};
+/**
+ * Delete everything the plan declares, in reverse order — the teardown twin.
+ * Resolves to the `renderDelete` activity.
+ */
+export const renderDeleteStep = (planPath, opts) => {
+    const { profile, ...rest } = opts ?? {};
+    return activity("renderDelete", { planPath, ...rest }, profile ?? "longInfra");
+};
+/**
+ * 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 function renderDeploy(opts = {}) {
+    const path = opts.path ?? ".";
+    const planPath = opts.planPath ?? "dist/render.json";
+    const applyOpts = {
+        ...(opts.endpoint ? { endpoint: opts.endpoint } : {}),
+        ...(opts.ownerId ? { ownerId: opts.ownerId } : {}),
+        ...(opts.prune ? { prune: true } : {}),
+        ...(opts.wait ? { wait: opts.wait } : {}),
+    };
+    const phases = [
+        phase("Build", [build(path, { script: opts.buildScript ?? "build:render" })]),
+        phase("Apply", [renderApplyStep(planPath, applyOpts)]),
+    ];
+    if (opts.verify) {
+        phases.push(phase("Verify", [
+            httpCheck(opts.verify.url, {
+                ...(opts.verify.contains ? { contains: opts.verify.contains } : {}),
+                retries: opts.verify.retries ?? 30,
+                intervalMs: opts.verify.intervalMs ?? 5000,
+            }),
+        ]));
+    }
+    if (opts.teardown) {
+        phases.push(phase("Teardown", [renderDeleteStep(planPath, applyOpts)]));
+    }
+    return Op({
+        name: opts.name ?? "render",
+        overview: opts.overview ?? "Render: build the plan, apply it to the workspace over the Public API, verify",
+        phases,
+    });
+}