@intentius/chant-lexicon-render 0.53.0

package/src/catalog.ts

@@ -0,0 +1,286 @@
+/**
+ * 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",
+} as const;
+
+export type EntityType = (typeof ENTITY_TYPES)[keyof typeof ENTITY_TYPES];
+
+/** The five service entity types (share `POST /services`). */
+export const SERVICE_ENTITY_TYPES: readonly string[] = [
+  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: Record<string, string> = {
+  [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: Record<string, string> = Object.fromEntries(
+  Object.entries(SERVICE_TYPE_OF).map(([k, v]) => [v, k]),
+);
+
+export function isServiceEntityType(entityType: string | undefined): boolean {
+  return !!entityType && SERVICE_ENTITY_TYPES.includes(entityType);
+}
+
+// ── Catalog ────────────────────────────────────────────────────────
+
+/** 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[];
+}
+
+const SERVICE_PATCH_FIELDS = [
+  "autoDeploy",
+  "repo",
+  "branch",
+  "image",
+  "name",
+  "buildFilter",
+  "rootDir",
+  "serviceDetails",
+] as const;
+
+function serviceEntry(kind: string): CatalogEntry {
+  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: Record<string, CatalogEntry> = {
+  [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: string): CatalogEntry {
+  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: string): string | undefined {
+  for (const [type, entry] of Object.entries(CATALOG)) {
+    if (entry.kind === kind) return type;
+  }
+  return undefined;
+}

package/src/codegen/docs-cli.ts

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

package/src/codegen/docs.ts

@@ -0,0 +1,120 @@
+/**
+ * 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.
+ */
+
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite, type DocsConfig } 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: string): string {
+  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?: { verbose?: boolean }): Promise<void> {
+  const config: DocsConfig = {
+    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/src/codegen/generate-cli.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for render lexicon generation.
+ */
+
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate";
+
+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/src/codegen/generate-lexicon.ts

@@ -0,0 +1,52 @@
+/**
+ * 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";
+import { renderShortName } from "../spec/parse";
+import type { NamingStrategy } from "./naming";
+import { buildRegistry, serializeRegistry, type RegistryResource } from "@intentius/chant/codegen/generate-registry";
+
+export interface RenderLexiconEntry {
+  resourceType: string;
+  kind: "resource" | "property";
+  lexicon: "render";
+  constraints?: Record<string, PropertyConstraints>;
+}
+
+/**
+ * Generate the lexicon-render.json content.
+ */
+export function generateLexiconJSON(results: RenderParseResult[], naming: NamingStrategy): string {
+  const registryResources: RegistryResource[] = results.map((r) => ({
+    typeName: r.resource.typeName,
+    attributes: r.resource.attributes,
+    properties: r.resource.properties,
+    propertyTypes: [],
+  }));
+
+  const entries = buildRegistry<RenderLexiconEntry>(registryResources, naming, {
+    shortName: renderShortName,
+    buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+      const r = results.find((res) => res.resource.typeName === resource.typeName);
+      const entry: RenderLexiconEntry = {
+        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/src/codegen/generate-typescript.ts

@@ -0,0 +1,70 @@
+/**
+ * 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";
+import type { NamingStrategy } from "./naming";
+import {
+  writeResourceClass,
+  writePropertyClass,
+  type DtsProperty,
+  type DtsAttribute,
+} from "@intentius/chant/codegen/generate-typescript";
+
+interface Entry {
+  tsName: string;
+  isProperty: boolean;
+  properties: DtsProperty[];
+  attributes: DtsAttribute[];
+}
+
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(results: RenderParseResult[], naming: NamingStrategy): string {
+  const lines: string[] = [];
+  lines.push("// Code generated by chant render generate. DO NOT EDIT.");
+
+  const entries: Entry[] = [];
+
+  for (const r of results) {
+    const tsName = naming.resolve(r.resource.typeName);
+    if (!tsName) continue;
+
+    const properties: DtsProperty[] = r.resource.properties.map((p) => ({
+      name: p.name,
+      type: p.tsType,
+      required: p.required,
+      description: p.description,
+    }));
+    const attributes: DtsAttribute[] = 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/src/codegen/generate.ts

@@ -0,0 +1,106 @@
+/**
+ * Render generation pipeline — uses core generatePipeline with render-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+
+import {
+  generatePipeline,
+  writeGeneratedArtifacts,
+  type GenerateOptions,
+  type GenerateResult,
+  type GeneratePipelineConfig,
+} from "@intentius/chant/codegen/generate";
+import { fetchSchemas } from "../spec/fetch";
+import { parseRenderOpenAPI, type RenderParseResult } from "../spec/parse";
+import { NamingStrategy } from "./naming";
+import { generateLexiconJSON } from "./generate-lexicon";
+import { generateTypeScriptDeclarations } from "./generate-typescript";
+import {
+  generateRuntimeIndex as coreGenerateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+} from "@intentius/chant/codegen/generate-runtime-index";
+
+export type { GenerateResult };
+
+/**
+ * Run the full render generation pipeline.
+ */
+export async function generate(opts: GenerateOptions = {}): Promise<GenerateResult> {
+  // 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: RenderParseResult[] = [];
+
+  const config: GeneratePipelineConfig<RenderParseResult> = {
+    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 as NamingStrategy),
+
+    generateTypes: (results, naming) => generateTypeScriptDeclarations(results, naming as NamingStrategy),
+
+    generateRuntimeIndex: (results, naming) => generateRuntimeIndex(results, naming as NamingStrategy),
+  };
+
+  return generatePipeline(config, opts);
+}
+
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result: GenerateResult, baseDir: string): void {
+  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: RenderParseResult[], naming: NamingStrategy): string {
+  const resourceEntries: RuntimeIndexEntry[] = [];
+  const propertyEntries: RuntimeIndexPropertyEntry[] = [];
+
+  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: Record<string, string> = {};
+      for (const attr of r.resource.attributes) {
+        attrs[attr.name] = attr.name;
+      }
+      resourceEntries.push({ tsName, resourceType: typeName, attrs });
+    }
+  }
+
+  return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, { lexiconName: "render" });
+}