@intentius/chant-lexicon-temporal 0.1.5

package/src/codegen/docs-cli.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for `npm run docs` in lexicon-temporal.
+ */
+import { generateDocs } from "./docs";
+
+await generateDocs({ verbose: true });

package/src/codegen/docs.ts

@@ -0,0 +1,23 @@
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+
+/**
+ * Generate documentation site for the Temporal lexicon.
+ */
+export async function generateDocs(options?: { verbose?: boolean }): Promise<void> {
+  const config = {
+    name: "temporal",
+    displayName: "Temporal",
+    description: "Temporal lexicon documentation",
+    distDir: "./dist",
+    outDir: "./docs",
+    serviceFromType: (type: string) => type.split("::")[1] ?? type,
+    resourceTypeUrl: (type: string) => `#${type}`,
+  };
+
+  const result = docsPipeline(config);
+  writeDocsSite(config, result);
+
+  if (options?.verbose) {
+    console.error("Documentation generated");
+  }
+}

package/src/codegen/generate-cli.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run generate` in lexicon-temporal.
+ */
+import { generate, writeGeneratedFiles } from "./generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+const result = await generate({ verbose: true });
+// src/codegen/generate-cli.ts → dirname x3 → package root
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+writeGeneratedFiles(result, pkgDir);
+
+console.error(`temporal: ${result.resources} resources (hand-written)`);
+if (result.warnings.length > 0) {
+  console.error(`${result.warnings.length} warnings`);
+}

package/src/codegen/generate.ts

@@ -0,0 +1,82 @@
+/**
+ * Temporal lexicon generation step.
+ *
+ * All 4 resources (TemporalServer, TemporalNamespace, SearchAttribute, TemporalSchedule)
+ * are hand-written. There is no remote spec to fetch or parse. This module builds
+ * the required lexiconJSON catalog and typesDTS stubs so that packagePipeline
+ * can hash and write dist/ artifacts correctly.
+ */
+
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { GenerateResult } from "@intentius/chant/codegen/generate";
+
+export type { GenerateResult };
+
+// ── Lexicon catalog (meta.json) ──────────────────────────────────────
+// Describes the 4 hand-written resources so tooling (LSP, MCP, docs) can
+// enumerate them without parsing the TypeScript source at runtime.
+
+const LEXICON_JSON = JSON.stringify(
+  {
+    TemporalServer: {
+      resourceType: "Temporal::Server",
+      kind: "resource",
+      lexicon: "temporal",
+      description: "Temporal server deployment — emits docker-compose.yml and Helm values",
+    },
+    TemporalNamespace: {
+      resourceType: "Temporal::Namespace",
+      kind: "resource",
+      lexicon: "temporal",
+      description: "Temporal namespace — emits namespace create command in temporal-setup.sh",
+    },
+    SearchAttribute: {
+      resourceType: "Temporal::SearchAttribute",
+      kind: "resource",
+      lexicon: "temporal",
+      description: "Temporal search attribute — emits search-attribute create command in temporal-setup.sh",
+    },
+    TemporalSchedule: {
+      resourceType: "Temporal::Schedule",
+      kind: "resource",
+      lexicon: "temporal",
+      description: "Temporal schedule — emits SDK schedule creation TypeScript to schedules/<id>.ts",
+    },
+  },
+  null,
+  2,
+);
+
+// ── Type declarations stub (types/index.d.ts) ────────────────────────
+// All types are declared in src/resources.ts and re-exported from src/index.ts.
+// The dist/types/index.d.ts file is a stub that satisfies the BundleSpec shape.
+
+const TYPES_DTS = `// Types for @intentius/chant-lexicon-temporal are declared in src/resources.ts.
+// They are available via the package's main export: import { ... } from "@intentius/chant-lexicon-temporal";
+export {};
+`;
+
+// ── Generate ─────────────────────────────────────────────────────────
+
+export async function generate(opts?: { verbose?: boolean; force?: boolean }): Promise<GenerateResult> {
+  if (opts?.verbose) {
+    console.error("temporal: all resources are hand-written — building catalog from static definitions");
+  }
+  return {
+    lexiconJSON: LEXICON_JSON,
+    typesDTS: TYPES_DTS,
+    indexTS: "",
+    resources: 4,
+    properties: 0,
+    enums: 0,
+    warnings: [],
+  };
+}
+
+export function writeGeneratedFiles(_result: GenerateResult, pkgDir: string): void {
+  // Write the catalog to src/generated/ so createCatalogResource can locate it at runtime.
+  const generatedDir = join(pkgDir, "src", "generated");
+  mkdirSync(generatedDir, { recursive: true });
+  writeFileSync(join(generatedDir, "lexicon-temporal.json"), LEXICON_JSON, "utf-8");
+}

package/src/codegen/package-cli.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for `npm run bundle` in lexicon-temporal.
+ */
+import { packageLexicon } from "./package";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+const { spec, stats } = await packageLexicon({ verbose: true });
+writeBundleSpec(spec, join(pkgDir, "dist"));
+
+console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);

package/src/codegen/package.ts

@@ -0,0 +1,55 @@
+/**
+ * Temporal lexicon packaging — delegates to core packagePipeline.
+ */
+
+import { readFileSync } from "fs";
+import { temporalPlugin } from "../plugin";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  packagePipeline,
+  collectSkills,
+  type PackageOptions,
+  type PackageResult,
+} from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+
+export type { PackageOptions, PackageResult };
+
+// package.ts is at src/codegen/package.ts — 2 dirname calls reach src/
+// then join(pkgDir, "..") is the package root where package.json lives
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+
+/**
+ * Package the Temporal lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts: PackageOptions = {}): Promise<PackageResult> {
+  const pkgJson = JSON.parse(readFileSync(join(pkgDir, "..", "package.json"), "utf-8"));
+
+  return packagePipeline(
+    {
+      generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+
+      buildManifest: (_genResult) => {
+        return {
+          name: "temporal",
+          version: pkgJson.version ?? "0.0.1",
+          chantVersion: ">=0.1.0",
+          namespace: "Temporal",
+          intrinsics: [],
+          pseudoParameters: {},
+        };
+      },
+
+      srcDir: pkgDir,
+
+      collectSkills: () => {
+        const skillDefs = temporalPlugin.skills?.() ?? [];
+        return collectSkills(skillDefs);
+      },
+
+      version: pkgJson.version ?? "0.0.1",
+    },
+    opts,
+  );
+}

package/src/composites/cloud-stack.ts

@@ -0,0 +1,74 @@
+/**
+ * TemporalCloudStack composite — a Temporal Cloud namespace + search attributes.
+ *
+ * Bundles a TemporalNamespace with an optional set of SearchAttribute entities.
+ * No server resource is included — this composite assumes you are connecting
+ * to Temporal Cloud (or a remotely managed server).
+ *
+ * @example
+ * ```typescript
+ * export const { ns, searchAttributes } = TemporalCloudStack({
+ *   namespace: "prod",
+ *   retention: "30d",
+ *   searchAttributes: [
+ *     { name: "Project", type: "Keyword" },
+ *     { name: "Priority", type: "Int" },
+ *   ],
+ * });
+ * ```
+ */
+
+import { TemporalNamespace, SearchAttribute } from "../resources";
+import type { SearchAttributeProps } from "../resources";
+
+export interface TemporalCloudStackConfig {
+  /** Namespace name (required). */
+  namespace: string;
+  /**
+   * Workflow history retention.
+   * @default "30d"
+   */
+  retention?: string;
+  /** Human-readable description for the namespace. */
+  description?: string;
+  /**
+   * Search attribute definitions to register in this namespace.
+   * Each entry creates a SearchAttribute entity scoped to this namespace.
+   */
+  searchAttributes?: Array<Pick<SearchAttributeProps, "name" | "type">>;
+}
+
+export interface TemporalCloudStackResources {
+  ns: InstanceType<typeof TemporalNamespace>;
+  searchAttributes: InstanceType<typeof SearchAttribute>[];
+}
+
+/**
+ * Create a Temporal Cloud namespace stack.
+ *
+ * Returns a TemporalNamespace and an array of SearchAttribute entities.
+ * Export the namespace and spread the search attributes from your chant project:
+ *
+ * ```typescript
+ * export const { ns, searchAttributes } = TemporalCloudStack({ namespace: "prod" });
+ * export const [projectAttr, priorityAttr] = searchAttributes;
+ * ```
+ */
+export function TemporalCloudStack(config: TemporalCloudStackConfig): TemporalCloudStackResources {
+  const ns = new TemporalNamespace({
+    name: config.namespace,
+    retention: config.retention ?? "30d",
+    ...(config.description ? { description: config.description } : {}),
+  } as Record<string, unknown>);
+
+  const searchAttributes = (config.searchAttributes ?? []).map(
+    ({ name, type }) =>
+      new SearchAttribute({
+        name,
+        type,
+        namespace: config.namespace,
+      } as Record<string, unknown>),
+  );
+
+  return { ns, searchAttributes };
+}

package/src/composites/composites.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Composite unit tests — TemporalDevStack, TemporalCloudStack.
+ */
+
+import { describe, test, expect } from "vitest";
+import { TemporalDevStack } from "./dev-stack";
+import { TemporalCloudStack } from "./cloud-stack";
+import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
+
+function getProps(entity: unknown): Record<string, unknown> {
+  return (entity as { props: Record<string, unknown> }).props;
+}
+
+function getEntityType(entity: unknown): string {
+  return (entity as Record<string, unknown>).entityType as string;
+}
+
+// ── TemporalDevStack ─────────────────────────────────────────────────
+
+describe("TemporalDevStack: basic", () => {
+  test("returns server and ns", () => {
+    const result = TemporalDevStack();
+    expect(result.server).toBeDefined();
+    expect(result.ns).toBeDefined();
+  });
+
+  test("server has entityType Temporal::Server", () => {
+    const { server } = TemporalDevStack();
+    expect(getEntityType(server)).toBe("Temporal::Server");
+  });
+
+  test("ns has entityType Temporal::Namespace", () => {
+    const { ns } = TemporalDevStack();
+    expect(getEntityType(ns)).toBe("Temporal::Namespace");
+  });
+
+  test("both entities have DECLARABLE_MARKER", () => {
+    const { server, ns } = TemporalDevStack();
+    expect((server as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+    expect((ns as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+  });
+
+  test("defaults: namespace=default, retention=7d, mode=dev", () => {
+    const { server, ns } = TemporalDevStack();
+    expect(getProps(ns).name).toBe("default");
+    expect(getProps(ns).retention).toBe("7d");
+    expect(getProps(server).mode).toBe("dev");
+  });
+
+  test("config overrides namespace and retention", () => {
+    const { ns } = TemporalDevStack({ namespace: "my-app", retention: "14d" });
+    expect(getProps(ns).name).toBe("my-app");
+    expect(getProps(ns).retention).toBe("14d");
+  });
+
+  test("config passes version and ports to server", () => {
+    const { server } = TemporalDevStack({ version: "1.25.0", port: 7234, uiPort: 8081 });
+    expect(getProps(server).version).toBe("1.25.0");
+    expect(getProps(server).port).toBe(7234);
+    expect(getProps(server).uiPort).toBe(8081);
+  });
+
+  test("description is forwarded to namespace when provided", () => {
+    const { ns } = TemporalDevStack({ description: "local dev namespace" });
+    expect(getProps(ns).description).toBe("local dev namespace");
+  });
+
+  test("description is absent when not provided", () => {
+    const { ns } = TemporalDevStack();
+    expect(getProps(ns).description).toBeUndefined();
+  });
+});
+
+// ── TemporalCloudStack ───────────────────────────────────────────────
+
+describe("TemporalCloudStack: basic", () => {
+  test("returns ns and searchAttributes array", () => {
+    const result = TemporalCloudStack({ namespace: "prod" });
+    expect(result.ns).toBeDefined();
+    expect(result.searchAttributes).toBeDefined();
+  });
+
+  test("ns has entityType Temporal::Namespace", () => {
+    const { ns } = TemporalCloudStack({ namespace: "prod" });
+    expect(getEntityType(ns)).toBe("Temporal::Namespace");
+  });
+
+  test("defaults retention to 30d", () => {
+    const { ns } = TemporalCloudStack({ namespace: "prod" });
+    expect(getProps(ns).name).toBe("prod");
+    expect(getProps(ns).retention).toBe("30d");
+  });
+
+  test("custom retention is forwarded", () => {
+    const { ns } = TemporalCloudStack({ namespace: "staging", retention: "14d" });
+    expect(getProps(ns).retention).toBe("14d");
+  });
+
+  test("returns empty searchAttributes when none specified", () => {
+    const { searchAttributes } = TemporalCloudStack({ namespace: "prod" });
+    expect(searchAttributes).toHaveLength(0);
+  });
+
+  test("creates SearchAttribute entities for each entry", () => {
+    const { searchAttributes } = TemporalCloudStack({
+      namespace: "prod",
+      searchAttributes: [
+        { name: "Project", type: "Keyword" },
+        { name: "Priority", type: "Int" },
+      ],
+    });
+    expect(searchAttributes).toHaveLength(2);
+    expect(getEntityType(searchAttributes[0])).toBe("Temporal::SearchAttribute");
+    expect(getEntityType(searchAttributes[1])).toBe("Temporal::SearchAttribute");
+  });
+
+  test("search attributes are scoped to the namespace", () => {
+    const { searchAttributes } = TemporalCloudStack({
+      namespace: "prod",
+      searchAttributes: [{ name: "Project", type: "Keyword" }],
+    });
+    expect(getProps(searchAttributes[0]).namespace).toBe("prod");
+    expect(getProps(searchAttributes[0]).name).toBe("Project");
+    expect(getProps(searchAttributes[0]).type).toBe("Keyword");
+  });
+
+  test("description is forwarded to namespace", () => {
+    const { ns } = TemporalCloudStack({ namespace: "prod", description: "Production namespace" });
+    expect(getProps(ns).description).toBe("Production namespace");
+  });
+});

package/src/composites/dev-stack.ts

@@ -0,0 +1,81 @@
+/**
+ * TemporalDevStack composite — a local dev server + default namespace.
+ *
+ * Wires together a TemporalServer (dev mode) and a TemporalNamespace so
+ * that `chant build` emits a docker-compose.yml and temporal-setup.sh
+ * ready for local development.
+ *
+ * @example
+ * ```typescript
+ * export const { server, ns } = TemporalDevStack({
+ *   namespace: "my-app",
+ *   retention: "7d",
+ * });
+ * ```
+ */
+
+import { TemporalServer, TemporalNamespace } from "../resources";
+
+export interface TemporalDevStackConfig {
+  /**
+   * Temporal server version.
+   * @default "1.26.2"
+   */
+  version?: string;
+  /**
+   * gRPC port for the Temporal frontend.
+   * @default 7233
+   */
+  port?: number;
+  /**
+   * Port for the Temporal Web UI.
+   * @default 8080
+   */
+  uiPort?: number;
+  /**
+   * Namespace to create on first run.
+   * @default "default"
+   */
+  namespace?: string;
+  /**
+   * Workflow history retention for the namespace.
+   * @default "7d"
+   */
+  retention?: string;
+  /**
+   * Human-readable description for the namespace.
+   */
+  description?: string;
+}
+
+export interface TemporalDevStackResources {
+  server: InstanceType<typeof TemporalServer>;
+  ns: InstanceType<typeof TemporalNamespace>;
+}
+
+/**
+ * Create a local Temporal dev stack.
+ *
+ * Returns a TemporalServer (dev mode) and a TemporalNamespace wired to the
+ * same default namespace. Export both from your chant project:
+ *
+ * ```typescript
+ * export const { server, ns } = TemporalDevStack({ namespace: "my-app" });
+ * ```
+ */
+export function TemporalDevStack(config: TemporalDevStackConfig = {}): TemporalDevStackResources {
+  const server = new TemporalServer({
+    mode: "dev",
+    version: config.version,
+    port: config.port,
+    uiPort: config.uiPort,
+  } as Record<string, unknown>);
+
+  const ns = new TemporalNamespace({
+    name: config.namespace ?? "default",
+    retention: config.retention ?? "7d",
+    ...(config.description ? { description: config.description } : {}),
+  } as Record<string, unknown>);
+
+  return { server, ns };
+}

package/src/config.ts

@@ -0,0 +1,150 @@
+/**
+ * Temporal worker profile — connection configuration for `chant run`.
+ *
+ * Add this to `chant.config.ts` to define how chant connects to Temporal:
+ *
+ * ```ts
+ * import type { TemporalChantConfig } from "@intentius/chant-lexicon-temporal";
+ *
+ * export default {
+ *   lexicons: ["temporal"],
+ *   temporal: {
+ *     profiles: {
+ *       local: {
+ *         address: "localhost:7233",
+ *         namespace: "default",
+ *         taskQueue: "my-deploy",
+ *         autoStart: true,
+ *       },
+ *       cloud: {
+ *         address: "myns.a2dd6.tmprl.cloud:7233",
+ *         namespace: "myns.a2dd6",
+ *         taskQueue: "my-deploy",
+ *         tls: true,
+ *         apiKey: { env: "TEMPORAL_API_KEY" },
+ *       },
+ *     },
+ *     defaultProfile: "local",
+ *   } satisfies TemporalChantConfig,
+ * };
+ * ```
+ *
+ * ChantConfig uses `.passthrough()` in its Zod schema so the `temporal` key
+ * is accepted at runtime without core changes. Issue #8 (`chant run`) will
+ * read these profiles when starting workers.
+ */
+
+/**
+ * Activity timeout and retry configuration for infrastructure activity groups.
+ *
+ * Pre-built profiles match the four activity groups typically seen in infra workflows:
+ * fast/idempotent operations, long-running infra (GKE, kubectl apply --wait),
+ * K8s wait loops, and human-gate activities.
+ *
+ * @example
+ * ```ts
+ * import { TEMPORAL_ACTIVITY_PROFILES } from "@intentius/chant-lexicon-temporal";
+ * import { proxyActivities } from "@temporalio/workflow";
+ *
+ * const { applyInfra } = proxyActivities<typeof infraActivities>(
+ *   TEMPORAL_ACTIVITY_PROFILES.longInfra
+ * );
+ * ```
+ */
+export interface TemporalActivityProfile {
+  /** Maximum time allowed for a single activity execution attempt. */
+  startToCloseTimeout: string;
+  /**
+   * Time after the last heartbeat before Temporal marks the activity as timed out.
+   * Required for activities that call `activity.heartbeat()` to signal liveness.
+   */
+  heartbeatTimeout?: string;
+  /** Retry policy for failed activity attempts. */
+  retry?: {
+    /** Initial wait before the first retry (e.g. "5s"). */
+    initialInterval?: string;
+    /** Multiplier applied to the interval on each retry (e.g. 2). */
+    backoffCoefficient?: number;
+    /** Maximum number of attempts including the first (0 = unlimited). */
+    maximumAttempts?: number;
+    /** Cap on retry intervals (e.g. "5m"). */
+    maximumInterval?: string;
+  };
+}
+
+/**
+ * Named activity profiles for common infrastructure workflow patterns.
+ *
+ * Import and spread into `proxyActivities()` so retry/timeout configuration
+ * lives in the lexicon rather than inline in workflow code.
+ */
+export const TEMPORAL_ACTIVITY_PROFILES = {
+  /**
+   * Fast, idempotent operations: `chant build`, `kubectl apply` without `--wait`,
+   * fetching nameservers, reading cluster status.
+   */
+  fastIdempotent: {
+    startToCloseTimeout: "5m",
+    retry: { maximumAttempts: 3, initialInterval: "5s", backoffCoefficient: 2 },
+  },
+
+  /**
+   * Long-running infra: GKE cluster creation via Config Connector (~10-20 min),
+   * `kubectl apply --wait` for large resource sets, Helm installs.
+   * Must heartbeat; 60 s silence → Temporal marks the activity dead.
+   */
+  longInfra: {
+    startToCloseTimeout: "20m",
+    heartbeatTimeout: "60s",
+    retry: { maximumAttempts: 3, initialInterval: "30s", backoffCoefficient: 2 },
+  },
+
+  /**
+   * K8s wait loops: polling for StatefulSet rollout, ExternalDNS A-records,
+   * DNS propagation. Medium timeout with heartbeating.
+   */
+  k8sWait: {
+    startToCloseTimeout: "15m",
+    heartbeatTimeout: "60s",
+    retry: { maximumAttempts: 3, initialInterval: "10s", backoffCoefficient: 2 },
+  },
+
+  /**
+   * Human-gate activities: waiting for an operator action (DNS delegation, approval).
+   * Very long timeout, single attempt — no retry on human-gate timeouts.
+   */
+  humanGate: {
+    startToCloseTimeout: "48h",
+    heartbeatTimeout: "90s",
+    retry: { maximumAttempts: 1 },
+  },
+} as const satisfies Record<string, TemporalActivityProfile>;
+
+export interface TemporalWorkerProfile {
+  /** Temporal server gRPC address. e.g. "localhost:7233" or "myns.a2dd6.tmprl.cloud:7233" */
+  address: string;
+  /** Temporal namespace to connect to */
+  namespace: string;
+  /** Task queue the worker polls */
+  taskQueue: string;
+  /** TLS configuration. Pass `true` or `{}` for Temporal Cloud default TLS */
+  tls?: boolean | { serverNameOverride?: string };
+  /**
+   * API key for Temporal Cloud authentication.
+   * String value: used as-is (Bearer token).
+   * Object form: reads from process.env at runtime.
+   */
+  apiKey?: string | { env: string };
+  /**
+   * Automatically start `temporal server start-dev` before the worker.
+   * Only applicable for local development profiles.
+   */
+  autoStart?: boolean;
+}
+
+export interface TemporalChantConfig {
+  /** Named connection profiles */
+  profiles: Record<string, TemporalWorkerProfile>;
+  /** Profile used when --profile flag is omitted from `chant run` */
+  defaultProfile?: string;
+}

package/src/coverage.test.ts

@@ -0,0 +1,9 @@
+import { test, expect } from "vitest";
+import { analyze } from "./coverage";
+
+test("coverage is 100% — all 4 resources are hand-written", () => {
+  const result = analyze();
+  expect(result.total).toBe(4);
+  expect(result.covered).toBe(4);
+  expect(result.missing).toHaveLength(0);
+});

package/src/coverage.ts

@@ -0,0 +1,37 @@
+/**
+ * Coverage analysis for the Temporal lexicon.
+ *
+ * All 4 resources are hand-written (no remote spec), so coverage is always
+ * 100% by definition. This module satisfies the lexicon completeness checklist
+ * and provides a consistent interface for the plugin's coverage() lifecycle method.
+ */
+
+export interface CoverageResult {
+  total: number;
+  covered: number;
+  missing: string[];
+}
+
+const RESOURCES = [
+  "Temporal::Server",
+  "Temporal::Namespace",
+  "Temporal::SearchAttribute",
+  "Temporal::Schedule",
+] as const;
+
+export function analyze(): CoverageResult {
+  return {
+    total: RESOURCES.length,
+    covered: RESOURCES.length,
+    missing: [],
+  };
+}
+
+export function printCoverageResult(result: CoverageResult, verbose?: boolean): void {
+  if (verbose) {
+    console.error(
+      `Coverage: ${result.covered}/${result.total} resources (${Math.round((result.covered / result.total) * 100)}%).`,
+    );
+    console.error("All resources are hand-written — no remote spec to track against.");
+  }
+}