@intentius/chant 0.0.18 → 0.0.24

package/src/codegen/docs.ts

@@ -7,151 +7,18 @@
  * (service grouping, resource type URLs, custom overview content).
  */
 
-import { readFileSync, readdirSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 
-/** Escape curly braces so MDX doesn't treat them as JSX expressions. */
-function escapeMdx(text: string): string {
-  return text.replace(/\{/g, "\\{").replace(/\}/g, "\\}");
-}
-
-// ── Types ──────────────────────────────────────────────────────────
-
-export interface DocsConfig {
-  /** Lexicon name (used for page titles and paths) */
-  name: string;
-  /** Display name (e.g. "AWS CloudFormation") */
-  displayName: string;
-  /** Short description of what this lexicon targets */
-  description: string;
-  /** Path to dist/ directory containing manifest.json and meta.json */
-  distDir: string;
-  /** Output directory for generated .mdx files */
-  outDir: string;
-  /** Lexicon-specific overview content (markdown) */
-  overview?: string;
-  /** Output format description (e.g. "CloudFormation JSON template") */
-  outputFormat?: string;
-  /** Custom service grouping from resource type (e.g. "AWS::S3::Bucket" → "S3") */
-  serviceFromType?: (resourceType: string) => string;
-  /** Custom sections to append to overview page */
-  extraSections?: Array<{ title: string; content: string }>;
-  /** Standalone pages added to the sidebar after Overview */
-  extraPages?: Array<{ slug: string; title: string; description?: string; content: string; sidebar?: boolean }>;
-  /** Slugs of auto-generated pages to suppress (e.g. "pseudo-parameters") */
-  suppressPages?: string[];
-  /** Source directory for scanning rule files (defaults to srcDir sibling of distDir) */
-  srcDir?: string;
-  /** Base path for the generated Astro site (e.g. '/lexicons/aws/') */
-  basePath?: string;
-  /** Root directory for resolving {{file:...}} markers in extra page content */
-  examplesDir?: string;
-  /** Extra sidebar entries appended after extraPages (supports Starlight groups) */
-  sidebarExtra?: Array<Record<string, unknown>>;
-}
-
-export interface DocsResult {
-  pages: Map<string, string>;
-  stats: {
-    resources: number;
-    properties: number;
-    services: number;
-    rules: number;
-    intrinsics: number;
-  };
-}
-
-interface ManifestJSON {
-  name: string;
-  version: string;
-  namespace?: string;
-  intrinsics?: Array<{
-    name: string;
-    description?: string;
-    outputKey?: string;
-    isTag?: boolean;
-  }>;
-  pseudoParameters?: Record<string, string>;
-}
-
-interface MetaEntry {
-  resourceType: string;
-  kind: "resource" | "property";
-  lexicon: string;
-  attrs?: Record<string, string>;
-  propertyConstraints?: Record<string, unknown>;
-  createOnly?: string[];
-  writeOnly?: string[];
-  primaryIdentifier?: string[];
-}
-
-interface RuleMeta {
-  id: string;
-  severity: string;
-  category: string;
-  description: string;
-  type: "lint" | "post-synth";
-}
-
-// ── File marker interpolation ──────────────────────────────────────
-
-/**
- * Expand `{{file:path.ts}}` markers in content with fenced code blocks.
- *
- * Supported forms:
- * - `{{file:path.ts}}` — full file
- * - `{{file:path.ts:5-12}}` — lines 5–12 (1-based, inclusive)
- * - `{{file:path.ts|title=custom.ts}}` — override the code block title
- * - `{{file:path.ts:5-12|title=custom.ts}}` — both
- */
-export function expandFileMarkers(content: string, examplesDir: string): string {
-  return content.replace(
-    /\{\{file:([^}]+)\}\}/g,
-    (_match, spec: string) => {
-      // Parse options after |
-      let filePart = spec;
-      let title: string | undefined;
-      const pipeIdx = spec.indexOf("|");
-      if (pipeIdx !== -1) {
-        filePart = spec.substring(0, pipeIdx);
-        const opts = spec.substring(pipeIdx + 1);
-        const titleMatch = opts.match(/title=([^\s|]+)/);
-        if (titleMatch) title = titleMatch[1];
-      }
+import { expandFileMarkers } from "./docs-file-markers";
+import { scanRules, generateRules } from "./docs-rule-scanning";
+import { buildSidebar } from "./docs-sidebar";
+import { generateOverview, generateIntrinsics, generatePseudoParameters, generateSerialization } from "./docs-sections";
+import type { DocsConfig, DocsResult, ManifestJSON, MetaEntry } from "./docs-types";
 
-      // Parse line range after :digits-digits at end of filePart
-      let lineStart: number | undefined;
-      let lineEnd: number | undefined;
-      const rangeMatch = filePart.match(/^(.+):(\d+)-(\d+)$/);
-      if (rangeMatch) {
-        filePart = rangeMatch[1];
-        lineStart = parseInt(rangeMatch[2], 10);
-        lineEnd = parseInt(rangeMatch[3], 10);
-      }
-
-      const filePath = join(examplesDir, filePart);
-      let fileContent: string;
-      try {
-        fileContent = readFileSync(filePath, "utf-8");
-      } catch {
-        throw new Error(`File marker {{file:${spec}}} — file not found: ${filePath}`);
-      }
-
-      // Extract line range if specified
-      if (lineStart !== undefined && lineEnd !== undefined) {
-        const lines = fileContent.split("\n");
-        fileContent = lines.slice(lineStart - 1, lineEnd).join("\n");
-      }
-
-      // Determine language from extension
-      const ext = filePart.substring(filePart.lastIndexOf(".") + 1);
-      const lang = ext === "ts" || ext === "tsx" ? "typescript" : ext;
-      const displayTitle = title ?? filePart.substring(filePart.lastIndexOf("/") + 1);
-
-      return `\`\`\`${lang} title="${displayTitle}"\n${fileContent.trimEnd()}\n\`\`\``;
-    },
-  );
-}
+// Re-export all public types and functions so existing importers continue to work.
+export { expandFileMarkers } from "./docs-file-markers";
+export type { DocsConfig, DocsResult } from "./docs-types";
 
 // ── Pipeline ───────────────────────────────────────────────────────
 
@@ -373,356 +240,3 @@ export default defineConfig({${config.basePath ? `\n  base: '${config.basePath}'
 `,
   );
 }
-
-function buildSidebar(
-  config: DocsConfig,
-  result: DocsResult,
-): Array<Record<string, unknown>> {
-  // Starlight prepends basePath to every sidebar `link`, so a site-root-relative
-  // path like "/chant/" becomes "/chant/lexicons/aws/chant/" — a 404.  Instead
-  // we use relative traversal: "../../" is prepended to become
-  // "/chant/lexicons/aws/../../" which the browser resolves to "/chant/".
-  const segments = (config.basePath ?? "/").replace(/^\/|\/$/g, "").split("/");
-  const backLink = segments.length > 1 ? "../".repeat(segments.length - 1) : "/";
-
-  const items: Array<Record<string, unknown>> = [
-    { label: "← chant docs", link: backLink },
-    { label: "Overview", slug: "index" },
-  ];
-
-  const suppress = new Set(config.suppressPages ?? []);
-  const extraSlugs = new Set((config.extraPages ?? []).map((p) => p.slug));
-
-  // Extra pages from lexicon config (appear after Overview)
-  if (config.extraPages) {
-    for (const page of config.extraPages) {
-      if (page.sidebar === false) continue;
-      items.push({ label: page.title, slug: page.slug });
-    }
-  }
-
-  if (!suppress.has("intrinsics") && !extraSlugs.has("intrinsics") && result.pages.has("intrinsics.mdx")) {
-    items.push({ label: "Intrinsics", slug: "intrinsics" });
-  }
-
-  if (!suppress.has("pseudo-parameters") && !extraSlugs.has("pseudo-parameters") && result.pages.has("pseudo-parameters.mdx")) {
-    items.push({ label: "Pseudo-Parameters", slug: "pseudo-parameters" });
-  }
-
-  if (!suppress.has("rules") && !extraSlugs.has("rules") && !extraSlugs.has("lint-rules") && result.pages.has("rules.mdx")) {
-    items.push({ label: "Lint Rules", slug: "rules" });
-  }
-
-  if (!suppress.has("serialization") && !extraSlugs.has("serialization") && result.pages.has("serialization.mdx")) {
-    items.push({ label: "Serialization", slug: "serialization" });
-  }
-
-  // Append raw sidebar entries (supports groups and nested items)
-  if (config.sidebarExtra) {
-    items.push(...config.sidebarExtra);
-  }
-
-  return items;
-}
-
-// ── Page generators ────────────────────────────────────────────────
-
-function generateOverview(
-  config: DocsConfig,
-  manifest: ManifestJSON,
-  resources: Map<string, MetaEntry>,
-  properties: Map<string, MetaEntry>,
-  serviceGroups: Map<string, Map<string, MetaEntry>>,
-  rules: RuleMeta[],
-): string {
-  const lines: string[] = [
-    "---",
-    `title: "${config.displayName}"`,
-    `description: "${config.description}"`,
-    "---",
-    "",
-    config.overview ?? `Reference documentation for the **${config.displayName}** lexicon.`,
-    "",
-    "## At a Glance",
-    "",
-    `| Metric | Count |`,
-    `|--------|-------|`,
-    `| Resources | ${resources.size} |`,
-    `| Property types | ${properties.size} |`,
-    `| Services | ${serviceGroups.size} |`,
-    `| Intrinsic functions | ${manifest.intrinsics?.length ?? 0} |`,
-    `| Pseudo-parameters | ${Object.keys(manifest.pseudoParameters ?? {}).length} |`,
-    `| Lint rules | ${rules.length} |`,
-    "",
-    `**Lexicon version:** ${manifest.version}  `,
-    `**Namespace:** \`${manifest.namespace ?? manifest.name}\``,
-    "",
-  ];
-
-  const suppress = new Set(config.suppressPages ?? []);
-
-  // Extra pages listed first in reference links
-  if (config.extraPages && config.extraPages.length > 0) {
-    for (const page of config.extraPages) {
-      if (page.sidebar === false) continue;
-      lines.push(`- [${page.title}](./${page.slug})`);
-    }
-  }
-
-  if (!suppress.has("intrinsics") && manifest.intrinsics && manifest.intrinsics.length > 0) {
-    lines.push(
-      `- [Intrinsic Functions](./intrinsics) — ${manifest.intrinsics.length} built-in functions`,
-    );
-  }
-  if (
-    !suppress.has("pseudo-parameters") &&
-    manifest.pseudoParameters &&
-    Object.keys(manifest.pseudoParameters).length > 0
-  ) {
-    lines.push(
-      `- [Pseudo-Parameters](./pseudo-parameters) — ${Object.keys(manifest.pseudoParameters).length} pseudo-parameters`,
-    );
-  }
-  const overviewExtraSlugs = new Set((config.extraPages ?? []).map((p) => p.slug));
-  if (!suppress.has("rules") && !overviewExtraSlugs.has("lint-rules") && rules.length > 0) {
-    lines.push(`- [Lint Rules](./rules) — ${rules.length} rules`);
-  }
-  if (!suppress.has("serialization")) {
-    lines.push(`- [Serialization](./serialization) — output format details`);
-  }
-
-  if (config.extraSections) {
-    for (const section of config.extraSections) {
-      lines.push("", `## ${section.title}`, "", section.content);
-    }
-  }
-
-  lines.push("");
-  return lines.join("\n");
-}
-
-function generateIntrinsics(
-  config: DocsConfig,
-  manifest: ManifestJSON,
-): string {
-  const intrinsics = manifest.intrinsics!;
-  const lines: string[] = [
-    "---",
-    `title: "Intrinsic Functions"`,
-    `description: "Built-in intrinsic functions for the ${config.displayName} lexicon"`,
-    "---",
-    "",
-    `The ${config.displayName} lexicon provides **${intrinsics.length}** intrinsic functions.`,
-    "",
-    "| Function | Description | Output Key | Tag? |",
-    "|----------|-------------|------------|------|",
-  ];
-
-  for (const fn of intrinsics) {
-    const tag = fn.isTag ? "Yes" : "No";
-    lines.push(
-      `| \`${fn.name}\` | ${escapeMdx(fn.description ?? "—")} | \`${fn.outputKey ?? fn.name}\` | ${tag} |`,
-    );
-  }
-
-  lines.push("");
-  return lines.join("\n");
-}
-
-function generatePseudoParameters(
-  config: DocsConfig,
-  manifest: ManifestJSON,
-): string {
-  const params = manifest.pseudoParameters!;
-  const entries = Object.entries(params);
-  const lines: string[] = [
-    "---",
-    `title: "Pseudo-Parameters"`,
-    `description: "Pseudo-parameters available in the ${config.displayName} lexicon"`,
-    "---",
-    "",
-    `The ${config.displayName} lexicon provides **${entries.length}** pseudo-parameters — predefined values available in every stack without explicit declaration.`,
-    "",
-    "| Name | Value |",
-    "|------|-------|",
-  ];
-
-  for (const [name, value] of entries) {
-    lines.push(`| \`${name}\` | \`${value}\` |`);
-  }
-
-  lines.push("");
-  return lines.join("\n");
-}
-
-function generateRules(config: DocsConfig, rules: RuleMeta[]): string {
-  const lintRules = rules.filter((r) => r.type === "lint");
-  const postSynthRules = rules.filter((r) => r.type === "post-synth");
-
-  const lines: string[] = [
-    "---",
-    `title: "Lint Rules"`,
-    `description: "Lint rules and post-synth checks provided by the ${config.displayName} lexicon"`,
-    "---",
-    "",
-    `The ${config.displayName} lexicon provides **${rules.length}** rules: ${lintRules.length} lint rules and ${postSynthRules.length} post-synth checks.`,
-    "",
-  ];
-
-  if (lintRules.length > 0) {
-    lines.push(
-      "## Lint Rules",
-      "",
-      "| ID | Severity | Category | Description |",
-      "|----|----------|----------|-------------|",
-    );
-    for (const rule of lintRules.sort((a, b) => a.id.localeCompare(b.id))) {
-      lines.push(
-        `| \`${rule.id}\` | ${rule.severity} | ${rule.category} | ${escapeMdx(rule.description)} |`,
-      );
-    }
-    lines.push("");
-  }
-
-  if (postSynthRules.length > 0) {
-    lines.push(
-      "## Post-Synth Checks",
-      "",
-      "Post-synth checks validate the serialized output after the build pipeline completes.",
-      "",
-      "| ID | Description |",
-      "|----|-------------|",
-    );
-    for (const rule of postSynthRules.sort((a, b) =>
-      a.id.localeCompare(b.id),
-    )) {
-      lines.push(`| \`${rule.id}\` | ${escapeMdx(rule.description)} |`);
-    }
-    lines.push("");
-  }
-
-  return lines.join("\n");
-}
-
-function generateSerialization(config: DocsConfig): string {
-  const lines: string[] = [
-    "---",
-    `title: "Serialization"`,
-    `description: "Output format for the ${config.displayName} lexicon"`,
-    "---",
-    "",
-  ];
-
-  if (config.outputFormat) {
-    lines.push(config.outputFormat);
-  } else {
-    lines.push(
-      `The ${config.displayName} lexicon serializes resources into its native output format during the build step.`,
-      "",
-      "See the [Serialization](/serialization/output-formats) guide for general information about output formats in chant.",
-    );
-  }
-
-  lines.push("");
-  return lines.join("\n");
-}
-
-// ── Rule scanning ──────────────────────────────────────────────────
-
-/**
- * Scan lint rule and post-synth check source files to extract metadata.
- * Uses regex to find id, severity, category, and description from source.
- */
-function scanRules(srcDir: string): RuleMeta[] {
-  const rules: RuleMeta[] = [];
-
-  // Scan lint rules
-  scanDir(join(srcDir, "lint", "rules"), "lint", rules);
-
-  // Scan post-synth checks
-  scanDir(join(srcDir, "lint", "post-synth"), "post-synth", rules);
-
-  return rules;
-}
-
-function scanDir(dir: string, type: "lint" | "post-synth", out: RuleMeta[]): void {
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return;
-  }
-
-  for (const entry of entries) {
-    if (!entry.endsWith(".ts")) continue;
-    if (entry.endsWith(".test.ts")) continue;
-    if (entry === "index.ts") continue;
-    // Skip utility files (no rule definitions)
-    if (entry === "cf-refs.ts") continue;
-
-    let content: string;
-    try {
-      content = readFileSync(join(dir, entry), "utf-8");
-    } catch {
-      continue;
-    }
-
-    if (type === "lint") {
-      // Extract from LintRule objects: id, severity, category
-      const idMatch = content.match(/id:\s*"([^"]+)"/);
-      const severityMatch = content.match(/severity:\s*"([^"]+)"/);
-      const categoryMatch = content.match(/category:\s*"([^"]+)"/);
-
-      if (idMatch) {
-        // Try to get description from JSDoc comment
-        const descMatch = content.match(
-          new RegExp(`\\*\\s*${idMatch[1]}:\\s*(.+?)\\n`),
-        );
-
-        out.push({
-          id: idMatch[1],
-          severity: severityMatch?.[1] ?? "warning",
-          category: categoryMatch?.[1] ?? "general",
-          description:
-            descMatch?.[1]?.trim() ??
-            extractDescriptionFromComment(content, idMatch[1]),
-          type: "lint",
-        });
-      }
-    } else {
-      // Extract from PostSynthCheck objects: id, description
-      const idMatch = content.match(/id:\s*"([^"]+)"/);
-      const descMatch = content.match(/description:\s*"([^"]+)"/);
-
-      if (idMatch) {
-        out.push({
-          id: idMatch[1],
-          severity: "error",
-          category: "post-synth",
-          description: descMatch?.[1] ?? idMatch[1],
-          type: "post-synth",
-        });
-      }
-    }
-  }
-}
-
-function extractDescriptionFromComment(
-  content: string,
-  ruleId: string,
-): string {
-  // Try to extract from the first line after the rule ID in JSDoc
-  const pattern = new RegExp(
-    `${ruleId}[:\\s]+([^\\n]+?)\\n\\s*\\*\\s*\\n\\s*\\*\\s*(.+?)\\n`,
-  );
-  const match = content.match(pattern);
-  if (match) return match[1].trim();
-
-  // Fallback: use text after "ruleId:" in JSDoc
-  const simpleMatch = content.match(
-    new RegExp(`\\*\\s*${ruleId}:\\s*(.+?)(?:\\n|\\*)`),
-  );
-  if (simpleMatch) return simpleMatch[1].trim();
-
-  return ruleId;
-}

package/src/composite.test.ts

@@ -9,6 +9,7 @@ import {
   withDefaults,
   propagate,
   SHARED_PROPS,
+  mergeDefaults,
 } from "./composite";
 import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 import { AttrRef } from "./attrref";
@@ -116,7 +117,7 @@ describe("Composite", () => {
     });
 
     const instance = MyComp({});
-    const roleProps = instance.members.role.props as Record<string, unknown>;
+    const roleProps = (instance.members.role as MockResource).props;
     expect(roleProps.bucketArn).toBeInstanceOf(AttrRef);
     // The AttrRef's parent should be the bucket instance
     expect((roleProps.bucketArn as AttrRef).attribute).toBe("Arn");
@@ -491,3 +492,77 @@ describe("propagate", () => {
     expect((expanded.get("sBucket") as any).props.name).toBe("data");
   });
 });
+
+describe("mergeDefaults", () => {
+  test("returns base unchanged when no overrides", () => {
+    const base = { a: 1, b: "hello" };
+    expect(mergeDefaults(base)).toBe(base);
+    expect(mergeDefaults(base, undefined)).toBe(base);
+  });
+
+  test("scalar override wins", () => {
+    const result = mergeDefaults({ a: 1, b: 2 }, { a: 10 });
+    expect(result).toEqual({ a: 10, b: 2 });
+  });
+
+  test("undefined values in overrides are skipped", () => {
+    const result = mergeDefaults({ a: 1, b: 2 }, { a: undefined });
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test("arrays are concatenated (base + overrides)", () => {
+    const result = mergeDefaults(
+      { tags: [{ key: "env", value: "prod" }] },
+      { tags: [{ key: "team", value: "alpha" }] },
+    );
+    expect(result.tags).toEqual([
+      { key: "env", value: "prod" },
+      { key: "team", value: "alpha" },
+    ]);
+  });
+
+  test("object override deep merges nested objects", () => {
+    const result = mergeDefaults(
+      { config: { a: 1, b: 2 } },
+      { config: { a: 10 } as any },
+    );
+    expect(result.config).toEqual({ a: 10, b: 2 } as any);
+  });
+
+  test("new keys from overrides are added", () => {
+    const result = mergeDefaults(
+      { a: 1 } as Record<string, unknown>,
+      { b: 2 },
+    );
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test("does not mutate the base object", () => {
+    const base = { a: 1, b: [1, 2] };
+    const result = mergeDefaults(base, { a: 10, b: [3] });
+    expect(base.a).toBe(1);
+    expect(base.b).toEqual([1, 2]);
+    expect(result.a).toBe(10);
+    expect(result.b).toEqual([1, 2, 3]);
+  });
+
+  test("empty overrides returns a shallow copy", () => {
+    const base = { a: 1 };
+    const result = mergeDefaults(base, {});
+    expect(result).toEqual({ a: 1 });
+    expect(result).not.toBe(base);
+  });
+
+  test("mixed: some scalars overridden, some arrays concatenated, some unchanged", () => {
+    const result = mergeDefaults(
+      { name: "orig", count: 5, tags: ["a"], config: { x: 1 } },
+      { name: "new", tags: ["b"], config: undefined },
+    );
+    expect(result).toEqual({
+      name: "new",
+      count: 5,
+      tags: ["a", "b"],
+      config: { x: 1 },
+    });
+  });
+});

package/src/composite.ts

@@ -243,3 +243,40 @@ export function resource<T extends Declarable, P>(
 ): T {
   return new Type(props, attributes);
 }
+
+/**
+ * Shallow-merges override values into a base props object.
+ *
+ * Merge semantics:
+ * - `undefined` values in overrides are skipped
+ * - Arrays: concatenated (base + overrides), matching `propagate()` semantics
+ * - Scalars / objects: override wins
+ *
+ * No deep merge — too dangerous with IaC props where nested objects
+ * (e.g. policy documents) should be replaced wholesale.
+ */
+export function mergeDefaults<T extends Record<string, unknown>>(
+  base: T,
+  overrides?: Partial<T>,
+): T {
+  if (!overrides) return base;
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined) continue;
+    const existing = result[key as keyof T];
+    if (Array.isArray(existing) && Array.isArray(value)) {
+      (result as any)[key] = [...existing, ...value];
+    } else if (
+      existing != null && typeof existing === "object" && !Array.isArray(existing) &&
+      value != null && typeof value === "object" && !Array.isArray(value)
+    ) {
+      (result as any)[key] = mergeDefaults(
+        existing as Record<string, unknown>,
+        value as Record<string, unknown>,
+      );
+    } else {
+      (result as any)[key] = value;
+    }
+  }
+  return result;
+}

package/src/config.ts

@@ -9,6 +9,7 @@ import type { LintConfig } from "./lint/config";
 export const ChantConfigSchema = z.object({
   runtime: z.enum(["bun", "node"]).optional(),
   lexicons: z.array(z.string().min(1)).optional(),
+  environments: z.array(z.string().min(1)).optional(),
   lint: z.record(z.string(), z.unknown()).optional(),
 }).passthrough();
 
@@ -24,6 +25,9 @@ export interface ChantConfig {
   /** Lexicon package names to load (e.g. ["aws"]) */
   lexicons?: string[];
 
+  /** Environment names (e.g. ["staging", "prod"]) */
+  environments?: string[];
+
   /** Lint configuration (rules, extends, overrides, plugins) */
   lint?: LintConfig;
 }

package/src/declarable.test.ts

@@ -12,7 +12,8 @@ describe("DECLARABLE_MARKER", () => {
   });
 
   test("uses Symbol.for for global registry", () => {
-    expect(DECLARABLE_MARKER).toBe(Symbol.for("chant.declarable"));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(DECLARABLE_MARKER).toBe(Symbol.for("chant.declarable") as any);
   });
 });
 

package/src/declarable.ts

@@ -9,7 +9,7 @@ export const DECLARABLE_MARKER = Symbol.for("chant.declarable");
 export interface Declarable {
   readonly lexicon: string;
   readonly entityType: string;
-  readonly kind?: "resource" | "property";
+  readonly kind?: "resource" | "property" | "output";
   readonly [DECLARABLE_MARKER]: true;
 }