@intentius/chant-lexicon-render 0.53.0

package/src/ownership.ts

@@ -0,0 +1,44 @@
+/**
+ * The render lexicon's ownership convention, declared here so core carries no
+ * render-specific branch — the #686 seam: each lexicon owns its key names; core
+ * keeps only the generic stamp/detect logic (@intentius/chant/ownership).
+ *
+ * Render has no tags or labels on any resource. What it does have, on the two
+ * kinds chant creates most and prunes — services and env groups — is a
+ * key/value store the API writes and reads back verbatim: environment
+ * variables. chant stamps `CHANT_MANAGED_BY=chant` (+ `CHANT_STACK` /
+ * `CHANT_ENV`) into a service's or env group's env vars at serialize time and
+ * reads them back through `GET .../env-vars`; that is the primary marker and
+ * the basis for owned-only prune. A service without it is never modified or
+ * deleted by a prune. The keys are upper-snake because that is what an env var
+ * is; the values are exactly what every other lexicon stamps.
+ *
+ * Disks and custom domains carry no marker either, but they hang off a
+ * service, so they inherit the parent's verdict — the service boundary, one
+ * level down from fly's app boundary. An undeclared disk under a chant-owned
+ * service is chant's and is pruned; one under a foreign service is foreign.
+ *
+ * Datastores, projects, environments, registry credentials, and webhooks
+ * carry no channel and no boundary. Their verdict is `unknown` (never
+ * `foreign`, never `owned`): the change set never escalates `unknown` to a
+ * delete, so an undeclared Postgres is never pruned. Removing one is an
+ * explicit `renderDelete` of a plan that names it.
+ */
+
+import type { ChannelKeys } from "@intentius/chant/ownership";
+
+/** Env-var keys for chant's ownership markers on services and env groups. */
+export const RENDER_ENV_OWNERSHIP_KEYS: ChannelKeys = {
+  managedBy: "CHANT_MANAGED_BY",
+  stack: "CHANT_STACK",
+  env: "CHANT_ENV",
+};
+
+/** True when a key is one of chant's marker env vars. */
+export function isOwnershipKey(key: string): boolean {
+  return (
+    key === RENDER_ENV_OWNERSHIP_KEYS.managedBy ||
+    key === RENDER_ENV_OWNERSHIP_KEYS.stack ||
+    key === RENDER_ENV_OWNERSHIP_KEYS.env
+  );
+}

package/src/package-cli.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run bundle` in lexicon-render.
+ * Generates src/generated/ files and writes dist/ bundle.
+ */
+import { packageLexicon } from "./codegen/package";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const pkgDir = dirname(fileURLToPath(import.meta.url));
+const distDir = join(pkgDir, "..", "dist");
+
+const verbose = process.argv.includes("--verbose") || !process.argv.includes("--quiet");
+const force = process.argv.includes("--force");
+
+const { spec, stats } = await packageLexicon({ verbose, force });
+writeBundleSpec(spec, distDir);
+
+console.error(
+  `Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`,
+);
+console.error(`dist/ written to ${distDir}`);

package/src/plugin.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { renderPlugin } from "./plugin";
+import { isLexiconPlugin } from "@intentius/chant/lexicon";
+
+describe("render plugin", () => {
+  it("is a valid LexiconPlugin", () => {
+    expect(isLexiconPlugin(renderPlugin)).toBe(true);
+  });
+
+  it("has the correct name and serializer", () => {
+    expect(renderPlugin.name).toBe("render");
+    expect(renderPlugin.serializer.name).toBe("render");
+    expect(renderPlugin.serializer.rulePrefix).toBe("REN");
+  });
+
+  it("ships lint rules and post-synth checks under the REN prefix", () => {
+    const rules = renderPlugin.lintRules?.() ?? [];
+    const checks = renderPlugin.postSynthChecks?.() ?? [];
+    expect(rules.map((r) => r.id)).toEqual(["REN001", "REN002", "REN003"]);
+    expect(checks.map((c) => c.id)).toEqual(["REN010", "REN011", "REN012"]);
+    for (const id of checks.map((c) => c.id)) {
+      expect(renderPlugin.auditCatalog?.()[id]).toBeDefined();
+    }
+  });
+
+  it("declares its ownership channel on the read path it implements", () => {
+    expect(renderPlugin.ownershipChannel?.reads).toEqual(["describeResources"]);
+    expect(typeof renderPlugin.describeResources).toBe("function");
+    expect(renderPlugin.ownershipChannel?.keys.managedBy).toBe("CHANT_MANAGED_BY");
+  });
+
+  it("loads its skills with content", () => {
+    const skills = renderPlugin.skills?.() ?? [];
+    expect(skills.map((s) => s.name)).toEqual(["chant-render", "chant-render-patterns"]);
+    for (const s of skills) expect(s.content.length).toBeGreaterThan(500);
+  });
+
+  it("detects its own serializer plan and nothing else", () => {
+    expect(
+      renderPlugin.detectTemplate?.({
+        web: { kind: "WebService", entityType: "Render::Services::WebService", endpoint: "/services", method: "POST", name: "web", body: {} },
+      }),
+    ).toBe(true);
+    expect(renderPlugin.detectTemplate?.({ Resources: {} })).toBe(false);
+    expect(renderPlugin.detectTemplate?.([])).toBe(false);
+  });
+
+  it("offers init templates that mention the package", () => {
+    for (const t of [undefined, "database", "static"]) {
+      const set = renderPlugin.initTemplates?.(t);
+      expect(set?.src["infra.ts"]).toContain("@intentius/chant-lexicon-render");
+    }
+  });
+});

package/src/plugin.ts

@@ -0,0 +1,258 @@
+import type { LexiconPlugin, InitTemplateSet } from "@intentius/chant/lexicon";
+import type { CompletionContext, HoverContext } from "@intentius/chant/lsp/types";
+import { createSkillsLoader } from "@intentius/chant/lexicon-plugin-helpers";
+import { renderSerializer } from "./serializer";
+import { rules } from "./lint/rules";
+import { postSynthChecks } from "./lint/post-synth";
+import { renderAuditCatalog } from "./lint/audit-catalog";
+import { completions } from "./lsp/completions";
+import { hover } from "./lsp/hover";
+import { detectTemplate as detectRenderTemplate } from "./detect";
+import { RENDER_ENV_OWNERSHIP_KEYS } from "./ownership";
+
+/**
+ * render lexicon plugin.
+ *
+ * Implements all required LexiconPlugin lifecycle methods.
+ */
+export const renderPlugin: LexiconPlugin = {
+  name: "render",
+  // Services and env groups carry the env-var marker; describeResources reads
+  // it back. See ./ownership.ts for the two-tier story.
+  ownershipChannel: { keys: RENDER_ENV_OWNERSHIP_KEYS, reads: ["describeResources"] },
+  auditCatalog: () => renderAuditCatalog,
+  serializer: renderSerializer,
+
+  // ── Required lifecycle methods ────────────────────────────────
+
+  async generate(options?: { verbose?: boolean }): Promise<void> {
+    const { generate } = await import("./codegen/generate");
+    await generate(options);
+  },
+
+  async validate(options?: { verbose?: boolean }): Promise<void> {
+    const { validate } = await import("./validate");
+    const { printValidationResult } = await import("@intentius/chant/codegen/validate");
+    const result = await validate();
+    printValidationResult(result);
+  },
+
+  async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
+    const { analyzeRenderCoverage } = await import("./coverage");
+    await analyzeRenderCoverage({ verbose: options?.verbose, minOverall: options?.minOverall });
+  },
+
+  async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
+    const { packageLexicon } = await import("./codegen/package");
+    const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+
+    const { spec, stats } = await packageLexicon(options);
+    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+    writeBundleSpec(spec, join(pkgDir, "dist"));
+
+    console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
+  },
+
+  // ── Optional extensions ────────────────────────────────────
+
+  lintRules() {
+    return rules;
+  },
+
+  postSynthChecks() {
+    return postSynthChecks;
+  },
+
+  skills: createSkillsLoader(import.meta.url, [
+    {
+      file: "chant-render.md",
+      name: "chant-render",
+      description:
+        "Author, lint, and deploy Render services, datastores, and env groups from a chant project, applied straight to the Render Public API",
+      triggers: [
+        { type: "file-pattern" as const, value: "*.render.ts" },
+        { type: "context" as const, value: "render" },
+        { type: "context" as const, value: "render.com" },
+      ],
+      parameters: [
+        {
+          name: "resourceType",
+          type: "string",
+          description:
+            "Render resource type to work with (WebService, StaticSite, PrivateService, BackgroundWorker, CronJob, Postgres, KeyValue, EnvGroup, Project, Environment, Disk, CustomDomain, RegistryCredential, Webhook)",
+        },
+      ],
+      examples: [
+        {
+          title: "Author a web service and a database",
+          output:
+            'new Postgres({ name: "app-db", plan: "free", version: "16" });\nnew WebService({ name: "app-web", repo: "https://github.com/…", serviceDetails: new WebServiceDetails({ runtime: "node", envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "npm ci", startCommand: "npm start" }) }), envVars: [new EnvVar({ key: "DATABASE_URL", value: db.internalConnectionString })] })',
+        },
+        {
+          title: "Deploy to a workspace",
+          input: "Apply the stack to Render",
+          output: "export RENDER_API_KEY=… RENDER_OWNER_ID=… && chant run render",
+        },
+      ],
+    },
+    {
+      file: "chant-render-patterns.md",
+      name: "chant-render-patterns",
+      description:
+        "Render patterns in chant — env groups, projects and environments, disks, custom domains, image-backed and cron services, and the ownership model",
+      triggers: [
+        { type: "context" as const, value: "render env group" },
+        { type: "context" as const, value: "render disk" },
+        { type: "context" as const, value: "render custom domain" },
+        { type: "context" as const, value: "render cron" },
+      ],
+      parameters: [],
+      examples: [
+        {
+          title: "Env group shared by two services",
+          input: "Share env vars between a web service and a worker",
+          output: 'new EnvGroup({ name: "shared", envVars: [new EnvVar({ key: "LOG_LEVEL", value: "info" })], serviceIds: [web, worker] })',
+        },
+      ],
+    },
+  ]),
+
+  mcpTools() {
+    // No MCP tools yet: Render's read-only context is the chant-render skills.
+    return [];
+  },
+
+  mcpResources() {
+    return [];
+  },
+
+  detectTemplate(data: unknown) {
+    return detectRenderTemplate(data);
+  },
+
+  pseudoParameters(): string[] {
+    return ["Render::OwnerId", "Render::Region"];
+  },
+
+  initTemplates(template?: string): InitTemplateSet {
+    if (template === "database") {
+      return {
+        src: {
+          "infra.ts": `import {
+  WebService,
+  WebServiceDetails,
+  NativeEnvironmentDetails,
+  EnvVar,
+  GeneratedEnvVar,
+  Postgres,
+  Render,
+} from "@intentius/chant-lexicon-render";
+
+// A Postgres database and a web service wired to it. The connection string is
+// read from the live database at apply time, after it exists. The owner comes
+// from Render.OwnerId (RENDER_OWNER_ID); the region from Render.Region
+// (RENDER_REGION, default "oregon").
+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",
+  branch: "main",
+  serviceDetails: new WebServiceDetails({
+    runtime: "node",
+    plan: "starter",
+    region: Render.Region,
+    envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "npm ci", startCommand: "npm start" }),
+  }),
+  envVars: [
+    new EnvVar({ key: "DATABASE_URL", value: db.internalConnectionString }),
+    new GeneratedEnvVar({ key: "SESSION_SECRET", generateValue: true }),
+  ],
+});
+
+export { db, web };
+`,
+        },
+      };
+    }
+
+    if (template === "static") {
+      return {
+        src: {
+          "infra.ts": `import { StaticSite, StaticSiteDetails, Route } from "@intentius/chant-lexicon-render";
+
+// A static site built from a repo and served from its publish path, with an
+// SPA rewrite. The owner comes from Render.OwnerId (RENDER_OWNER_ID).
+const site = new StaticSite({
+  name: "my-site",
+  repo: "https://github.com/render-examples/vite-react-hello-world",
+  branch: "main",
+  serviceDetails: new StaticSiteDetails({
+    buildCommand: "npm ci && npm run build",
+    publishPath: "dist",
+    routes: [new Route({ type: "rewrite", source: "/*", destination: "/index.html" })],
+  }),
+});
+
+export { site };
+`,
+        },
+      };
+    }
+
+    // Default: one web service — the smallest complete deploy.
+    return {
+      src: {
+        "infra.ts": `import { WebService, WebServiceDetails, NativeEnvironmentDetails, Render } from "@intentius/chant-lexicon-render";
+
+// One Render web service — the smallest complete deploy. The serializer turns
+// this into the POST /services body renderApply issues. The owner comes from
+// Render.OwnerId (RENDER_OWNER_ID); the region from Render.Region
+// (RENDER_REGION, default "oregon").
+const web = new WebService({
+  name: "my-web",
+  repo: "https://github.com/render-examples/express-hello-world",
+  branch: "main",
+  serviceDetails: new WebServiceDetails({
+    runtime: "node",
+    plan: "starter",
+    region: Render.Region,
+    envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "npm ci", startCommand: "npm start" }),
+  }),
+});
+
+export { web };
+`,
+      },
+    };
+  },
+
+  completionProvider(ctx: CompletionContext) {
+    return completions(ctx);
+  },
+
+  hoverProvider(ctx: HoverContext) {
+    return hover(ctx);
+  },
+
+  async docs(options?) {
+    const { generateDocs } = await import("./codegen/docs");
+    return generateDocs(options);
+  },
+
+  // The read-back seam for plan + drift. Lists live Render resources over the
+  // Public API, keyed by chant entity name, with an ownership verdict core's
+  // change set reads. Endpoint + auth reuse the applier (RENDER_API_BASE_URL /
+  // RENDER_API_KEY / RENDER_OWNER_ID), so it reads the same target renderApply writes.
+  async describeResources(options) {
+    const { describeResources } = await import("./describe-resources");
+    return describeResources(options);
+  },
+};

package/src/pseudo.ts

@@ -0,0 +1,26 @@
+import { PseudoParameter, createPseudoParameters } from "@intentius/chant/pseudo-parameter";
+
+export { PseudoParameter };
+
+/**
+ * Render pseudo-parameters — environment-resolved values a project references
+ * without hard-coding. Each serializes to a `{ Ref: "Render::..." }` marker
+ * that the serializer resolves from an environment variable at build time (see
+ * PSEUDO_ENV_MAP in ./serializer.ts), mirroring fly's `Fly.OrgSlug`.
+ *
+ *   - OwnerId → the workspace (team or personal) id (RENDER_OWNER_ID), e.g. `tea-…`.
+ *     Every ownerId chant fills in defaults to this, so a stack rarely names it.
+ *   - Region  → the target region (RENDER_REGION), default `oregon`.
+ */
+export const { OwnerId, Region } = createPseudoParameters({
+  OwnerId: "Render::OwnerId",
+  Region: "Render::Region",
+});
+
+/**
+ * Render namespace containing all pseudo-parameters.
+ */
+export const Render = {
+  OwnerId,
+  Region,
+} as const;

package/src/serializer.test.ts

@@ -0,0 +1,221 @@
+import { afterEach, describe, expect, it } from "vitest";
+import type { Declarable } from "@intentius/chant";
+import { resolveAttrRefs } from "@intentius/chant/discovery/resolve";
+import { renderSerializer, serializeRender, stampOwnership } from "./serializer";
+import {
+  WebService,
+  WebServiceDetails,
+  StaticSite,
+  StaticSiteDetails,
+  CronJob,
+  CronJobDetails,
+  NativeEnvironmentDetails,
+  DockerDetails,
+  Postgres,
+  KeyValue,
+  EnvGroup,
+  Project,
+  ProjectEnvironment,
+  Environment,
+  Disk,
+  CustomDomain,
+  Image,
+} from "./generated/index";
+import { Render } from "./pseudo";
+import { RENDER_ENV_OWNERSHIP_KEYS } from "./ownership";
+
+/** Author a map of declarables keyed by logical name, in insertion order. */
+function stack(...entries: Array<[string, unknown]>): Map<string, Declarable> {
+  return new Map(entries as Array<[string, Declarable]>);
+}
+
+const parse = (entities: Map<string, Declarable>, ctx?: Parameters<typeof serializeRender>[2]) => {
+  // The build pipeline assigns each entity's logical name before serializing;
+  // do the same so attribute reads (`db.internalConnectionString`) resolve.
+  resolveAttrRefs(entities);
+  return JSON.parse(serializeRender(entities, undefined, ctx));
+};
+
+describe("render serializer", () => {
+  afterEach(() => {
+    delete process.env.RENDER_OWNER_ID;
+    delete process.env.RENDER_REGION;
+  });
+
+  it("serializes an empty map to valid JSON", () => {
+    expect(JSON.parse(serializeRender(new Map()))).toEqual({});
+  });
+
+  it("has the correct name and rule prefix", () => {
+    expect(renderSerializer.name).toBe("render");
+    expect(renderSerializer.rulePrefix).toBe("REN");
+  });
+
+  it("emits a WebService as POST /services with the fixed type, the marker, and the owner", () => {
+    process.env.RENDER_OWNER_ID = "tea-123";
+    const out = parse(
+      stack([
+        "web",
+        new WebService({
+          name: "my-web",
+          repo: "https://github.com/render-examples/express-hello-world",
+          serviceDetails: new WebServiceDetails({
+            runtime: "node",
+            plan: "starter",
+            region: "oregon",
+            envSpecificDetails: new NativeEnvironmentDetails({ buildCommand: "npm ci", startCommand: "npm start" }),
+          }),
+          envVars: [{ key: "LOG_LEVEL", value: "info" }],
+        }),
+      ]),
+    );
+    expect(out.web.kind).toBe("WebService");
+    expect(out.web.entityType).toBe("Render::Services::WebService");
+    expect(out.web.endpoint).toBe("/services");
+    expect(out.web.method).toBe("POST");
+    expect(out.web.name).toBe("my-web");
+    expect(out.web.body.type).toBe("web_service");
+    expect(out.web.body.ownerId).toBe("tea-123");
+    expect(out.web.body.serviceDetails).toEqual({
+      runtime: "node",
+      plan: "starter",
+      region: "oregon",
+      envSpecificDetails: { buildCommand: "npm ci", startCommand: "npm start" },
+    });
+    expect(out.web.body.envVars).toEqual([
+      { key: "LOG_LEVEL", value: "info" },
+      { key: RENDER_ENV_OWNERSHIP_KEYS.managedBy, value: "chant" },
+    ]);
+  });
+
+  it("stamps stack/env identity from the serialize context", () => {
+    const out = parse(
+      stack(["web", new WebService({ name: "w", serviceDetails: new WebServiceDetails({ runtime: "docker" }) })]),
+      { ownership: { stack: "shop", env: "prod" } },
+    );
+    expect(out.web.body.envVars).toEqual([
+      { key: "CHANT_MANAGED_BY", value: "chant" },
+      { key: "CHANT_STACK", value: "shop" },
+      { key: "CHANT_ENV", value: "prod" },
+    ]);
+  });
+
+  it("the marker wins over a colliding user env var", () => {
+    expect(
+      stampOwnership([{ key: "CHANT_MANAGED_BY", value: "me" }, { key: "A", value: "1" }], { CHANT_MANAGED_BY: "chant" }),
+    ).toEqual([
+      { key: "A", value: "1" },
+      { key: "CHANT_MANAGED_BY", value: "chant" },
+    ]);
+  });
+
+  it("leaves an $owner marker when no owner is known, and resolves Render.OwnerId from the env", () => {
+    const noEnv = parse(stack(["db", new Postgres({ name: "db", plan: "free", version: "16" })]));
+    expect(noEnv.db.body.ownerId).toEqual({ $owner: true });
+
+    process.env.RENDER_OWNER_ID = "tea-999";
+    const explicit = parse(stack(["db", new Postgres({ name: "db", plan: "free", version: "16", ownerId: Render.OwnerId })]));
+    expect(explicit.db.body.ownerId).toBe("tea-999");
+    expect(explicit.db.endpoint).toBe("/postgres");
+    expect(explicit.db.kind).toBe("Postgres");
+  });
+
+  it("resolves Render.Region from RENDER_REGION with an oregon fallback", () => {
+    const fallback = parse(stack(["kv", new KeyValue({ name: "kv", plan: "free", region: Render.Region })]));
+    expect(fallback.kv.body.region).toBe("oregon");
+    process.env.RENDER_REGION = "frankfurt";
+    const set = parse(stack(["kv", new KeyValue({ name: "kv", plan: "free", region: Render.Region })]));
+    expect(set.kv.body.region).toBe("frankfurt");
+  });
+
+  it("falls back to the entity name when no explicit name", () => {
+    const out = parse(stack(["billing", new Project({ name: "billing", environments: [new ProjectEnvironment({ name: "prod" })] })]));
+    expect(out.billing.name).toBe("billing");
+    expect(out.billing.body.environments).toEqual([{ name: "prod" }]);
+  });
+
+  it("turns a declared-resource reference into a $ref marker and an attribute read into $attr", () => {
+    const db = new Postgres({ name: "db", plan: "free", version: "16" });
+    const project = new Project({ name: "p", environments: [] });
+    const env = new Environment({ name: "prod", projectId: project });
+    const web = new WebService({
+      name: "web",
+      environmentId: env,
+      serviceDetails: new WebServiceDetails({ runtime: "docker" }),
+      envVars: [{ key: "DATABASE_URL", value: db.internalConnectionString }],
+    });
+    const out = parse(stack(["db", db], ["project", project], ["env", env], ["web", web]));
+    expect(out.env.body.projectId).toEqual({ $ref: "project" });
+    expect(out.web.body.environmentId).toEqual({ $ref: "env" });
+    expect(out.web.body.envVars[0]).toEqual({
+      key: "DATABASE_URL",
+      value: { $attr: { entity: "db", attribute: "internalConnectionString" } },
+    });
+  });
+
+  it("routes child collections through pathParams and fills literal ids into the endpoint", () => {
+    const web = new WebService({ name: "web", serviceDetails: new WebServiceDetails({ runtime: "docker" }) });
+    const out = parse(
+      stack(
+        ["web", web],
+        ["domain", new CustomDomain({ name: "example.com", serviceId: web })],
+        ["literal", new CustomDomain({ name: "www.example.com", serviceId: "srv-abc" })],
+        ["disk", new Disk({ name: "data", sizeGB: 10, mountPath: "/data", serviceId: web })],
+      ),
+    );
+    expect(out.domain.endpoint).toBe("/services/{serviceId}/custom-domains");
+    expect(out.domain.pathParams).toEqual({ serviceId: { $ref: "web" } });
+    expect(out.domain.body).toEqual({ name: "example.com" });
+    expect(out.literal.endpoint).toBe("/services/srv-abc/custom-domains");
+    // Disk's serviceId is a body field, not a path segment.
+    expect(out.disk.endpoint).toBe("/disks");
+    expect(out.disk.body.serviceId).toEqual({ $ref: "web" });
+    expect(out.disk.pathParams).toBeUndefined();
+  });
+
+  it("defaults image.ownerId to the service ownerId", () => {
+    process.env.RENDER_OWNER_ID = "tea-1";
+    const out = parse(
+      stack([
+        "web",
+        new WebService({
+          name: "web",
+          image: new Image({ imagePath: "docker.io/library/nginx:latest" }),
+          serviceDetails: new WebServiceDetails({ runtime: "image" }),
+        }),
+      ]),
+    );
+    expect(out.web.body.image).toEqual({ imagePath: "docker.io/library/nginx:latest", ownerId: "tea-1" });
+  });
+
+  it("emits every service type with its discriminator", () => {
+    const out = parse(
+      stack(
+        ["site", new StaticSite({ name: "site", serviceDetails: new StaticSiteDetails({ publishPath: "dist" }) })],
+        [
+          "cron",
+          new CronJob({
+            name: "cron",
+            serviceDetails: new CronJobDetails({
+              runtime: "docker",
+              schedule: "0 * * * *",
+              envSpecificDetails: new DockerDetails({ dockerfilePath: "./Dockerfile" }),
+            }),
+          }),
+        ],
+      ),
+    );
+    expect(out.site.body.type).toBe("static_site");
+    expect(out.cron.body.type).toBe("cron_job");
+    expect(out.cron.body.serviceDetails.schedule).toBe("0 * * * *");
+  });
+
+  it("stamps env groups too, and keeps their env vars", () => {
+    const out = parse(stack(["shared", new EnvGroup({ name: "shared", envVars: [{ key: "A", value: "1" }] })]));
+    expect(out.shared.endpoint).toBe("/env-groups");
+    expect(out.shared.body.envVars).toEqual([
+      { key: "A", value: "1" },
+      { key: "CHANT_MANAGED_BY", value: "chant" },
+    ]);
+  });
+});