@intentius/chant 0.0.1

package/src/codegen/fetch.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect } from "bun:test";
+import { extractFromTar } from "./fetch";
+
+/**
+ * Build a minimal valid tar buffer with a single file entry.
+ * Tar format: 512-byte header + data padded to 512-byte boundary + 1024 zero bytes (end marker).
+ */
+function buildTar(entries: Array<{ name: string; content: string; typeFlag?: string }>): Uint8Array {
+  const blocks: Uint8Array[] = [];
+
+  for (const entry of entries) {
+    const header = new Uint8Array(512);
+    const content = new TextEncoder().encode(entry.content);
+
+    // Name (bytes 0-99)
+    const nameBytes = new TextEncoder().encode(entry.name);
+    header.set(nameBytes.slice(0, 100), 0);
+
+    // Mode (bytes 100-107): "0000644\0"
+    header.set(new TextEncoder().encode("0000644\0"), 100);
+
+    // UID (bytes 108-115): "0000000\0"
+    header.set(new TextEncoder().encode("0000000\0"), 108);
+
+    // GID (bytes 116-123): "0000000\0"
+    header.set(new TextEncoder().encode("0000000\0"), 116);
+
+    // Size (bytes 124-135): octal, 11 chars + null
+    const sizeOctal = content.length.toString(8).padStart(11, "0") + "\0";
+    header.set(new TextEncoder().encode(sizeOctal), 124);
+
+    // Mtime (bytes 136-147): "00000000000\0"
+    header.set(new TextEncoder().encode("00000000000\0"), 136);
+
+    // Type flag (byte 156): '0' for regular file
+    header[156] = (entry.typeFlag ?? "0").charCodeAt(0);
+
+    // Checksum (bytes 148-155): calculate sum of all header bytes with checksum field as spaces
+    header.set(new TextEncoder().encode("        "), 148); // 8 spaces
+    let sum = 0;
+    for (let i = 0; i < 512; i++) sum += header[i];
+    const checksumStr = sum.toString(8).padStart(6, "0") + "\0 ";
+    header.set(new TextEncoder().encode(checksumStr), 148);
+
+    blocks.push(header);
+
+    // Data blocks
+    const dataBlocks = Math.ceil(content.length / 512);
+    const dataBuffer = new Uint8Array(dataBlocks * 512);
+    dataBuffer.set(content);
+    blocks.push(dataBuffer);
+  }
+
+  // End-of-archive marker (two zero blocks)
+  blocks.push(new Uint8Array(1024));
+
+  const totalLength = blocks.reduce((sum, b) => sum + b.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const block of blocks) {
+    result.set(block, offset);
+    offset += block.length;
+  }
+  return result;
+}
+
+describe("extractFromTar", () => {
+  test("extracts all regular files", () => {
+    const tar = buildTar([
+      { name: "file1.txt", content: "hello" },
+      { name: "dir/file2.txt", content: "world" },
+    ]);
+
+    const files = extractFromTar(tar);
+    expect(files.size).toBe(2);
+    expect(files.get("file1.txt")!.toString()).toBe("hello");
+    expect(files.get("dir/file2.txt")!.toString()).toBe("world");
+  });
+
+  test("applies filter", () => {
+    const tar = buildTar([
+      { name: "a.json", content: '{"a":1}' },
+      { name: "b.txt", content: "text" },
+      { name: "c.json", content: '{"c":3}' },
+    ]);
+
+    const files = extractFromTar(tar, (path) => path.endsWith(".json"));
+    expect(files.size).toBe(2);
+    expect(files.has("a.json")).toBe(true);
+    expect(files.has("c.json")).toBe(true);
+    expect(files.has("b.txt")).toBe(false);
+  });
+
+  test("skips directory entries", () => {
+    const tar = buildTar([
+      { name: "dir/", content: "", typeFlag: "5" },
+      { name: "dir/file.txt", content: "content" },
+    ]);
+
+    const files = extractFromTar(tar);
+    expect(files.size).toBe(1);
+    expect(files.has("dir/file.txt")).toBe(true);
+  });
+
+  test("returns empty map for empty tar", () => {
+    // Just end-of-archive marker
+    const tar = new Uint8Array(1024);
+    const files = extractFromTar(tar);
+    expect(files.size).toBe(0);
+  });
+
+  test("handles files with various content", () => {
+    const content = "abc\ndef\n";
+    const tar = buildTar([{ name: "multi.txt", content }]);
+    const files = extractFromTar(tar);
+    expect(files.size).toBe(1);
+    expect(files.get("multi.txt")!.toString()).toBe(content);
+  });
+});

package/src/codegen/fetch.ts

@@ -0,0 +1,261 @@
+/**
+ * Generic HTTP fetch with caching and zip extraction utilities.
+ *
+ * Provides the download + cache + zip pattern used by lexicon codegen
+ * pipelines that fetch schemas from remote sources.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, unlinkSync, rmSync } from "fs";
+import { dirname, join } from "path";
+import { debug } from "../cli/debug";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export interface FetchConfig {
+  /** URL to fetch. */
+  url: string;
+  /** Local file path for caching the download. */
+  cacheFile: string;
+  /** Cache TTL in milliseconds (default: 24 hours). */
+  cacheTtlMs?: number;
+}
+
+// ── Fetch with cache ───────────────────────────────────────────────
+
+const DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Fetch a URL with local file caching.
+ *
+ * Returns cached data if the cache file exists and is younger than cacheTtlMs.
+ * Otherwise downloads from the URL, caches the result, and returns it.
+ */
+export async function fetchWithCache(config: FetchConfig, force = false): Promise<Buffer> {
+  const ttl = config.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+
+  if (!force) {
+    try {
+      if (existsSync(config.cacheFile)) {
+        const stat = statSync(config.cacheFile);
+        if (Date.now() - stat.mtimeMs < ttl) {
+          return readFileSync(config.cacheFile) as unknown as Buffer;
+        }
+      }
+    } catch (e) {
+      debug("cache read failed:", e);
+    }
+  }
+
+  const response = await fetch(config.url);
+  if (!response.ok) {
+    throw new Error(`Download from ${config.url} returned ${response.status}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  const data = Buffer.from(arrayBuffer);
+
+  try {
+    mkdirSync(dirname(config.cacheFile), { recursive: true });
+    writeFileSync(config.cacheFile, data as unknown as Uint8Array);
+  } catch (e) {
+    debug("cache write failed:", e);
+  }
+
+  return data;
+}
+
+// ── Zip extraction ─────────────────────────────────────────────────
+
+/**
+ * Extract files from a zip buffer using fflate.
+ *
+ * @param filter - Optional predicate to select which files to include.
+ *   Receives the file name (path within the zip). Defaults to all files.
+ * @returns Map of filename → Buffer for each extracted file.
+ */
+export async function extractFromZip(
+  zipData: Buffer,
+  filter?: (name: string) => boolean,
+): Promise<Map<string, Buffer>> {
+  const { unzipSync } = await import("fflate");
+  const files = unzipSync(new Uint8Array(zipData));
+
+  const result = new Map<string, Buffer>();
+  for (const [name, data] of Object.entries(files)) {
+    if (filter && !filter(name)) continue;
+    result.set(name, Buffer.from(data));
+  }
+  return result;
+}
+
+// ── Tar extraction ──────────────────────────────────────────────────
+
+/**
+ * Extract files from an uncompressed tar buffer.
+ *
+ * The caller handles gunzip (via `fflate.gunzipSync` or `zlib.gunzipSync`)
+ * and any prefix stripping. Returns `Map<path, Buffer>`.
+ *
+ * @param filter - Optional predicate to select which files to include.
+ *   Receives the full file name (path within the tar). Defaults to all regular files.
+ */
+export function extractFromTar(
+  tarData: Uint8Array,
+  filter?: (path: string) => boolean,
+): Map<string, Buffer> {
+  const result = new Map<string, Buffer>();
+  let offset = 0;
+  let longName: string | null = null;
+
+  while (offset < tarData.length - 512) {
+    const header = tarData.slice(offset, offset + 512);
+    offset += 512;
+
+    // Check for end-of-archive marker (all zeros)
+    if (header.every((b) => b === 0)) break;
+
+    // Parse file name (first 100 bytes)
+    const nameBytes = header.slice(0, 100);
+    let name = new TextDecoder().decode(nameBytes).replace(/\0+$/, "");
+
+    // Check type flag
+    const typeFlag = String.fromCharCode(header[156]);
+
+    // Parse file size (bytes 124-135, octal)
+    const sizeStr = new TextDecoder().decode(header.slice(124, 136)).replace(/\0+$/, "").trim();
+    const size = parseInt(sizeStr, 8) || 0;
+
+    // Calculate blocks to skip
+    const blocks = Math.ceil(size / 512);
+
+    if (typeFlag === "L") {
+      // GNU long name: read the name from the next data block
+      const longNameData = tarData.slice(offset, offset + size);
+      longName = new TextDecoder().decode(longNameData).replace(/\0+$/, "");
+      offset += blocks * 512;
+      continue;
+    }
+
+    // Apply long name from previous GNU 'L' entry
+    if (longName !== null) {
+      name = longName;
+      longName = null;
+    } else {
+      // Check prefix field (bytes 345-500) for USTAR format
+      const prefix = new TextDecoder().decode(header.slice(345, 500)).replace(/\0+$/, "");
+      if (prefix) {
+        name = prefix + "/" + name;
+      }
+    }
+
+    const fileData = tarData.slice(offset, offset + size);
+    offset += blocks * 512;
+
+    // Skip non-regular files
+    if (typeFlag !== "0" && typeFlag !== "\0") continue;
+
+    if (filter && !filter(name)) continue;
+    result.set(name, Buffer.from(fileData));
+  }
+
+  return result;
+}
+
+// ── Directory-level tar cache ───────────────────────────────────────
+
+export interface FetchTarConfig {
+  /** URL of the gzipped tarball. */
+  url: string;
+  /** Local directory for extracted files. */
+  destDir: string;
+  /** Cache TTL in milliseconds (default: 7 days). */
+  cacheTtlMs?: number;
+}
+
+const DEFAULT_TAR_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+/**
+ * Fetch a gzipped tarball, extract files matching `tarPrefix`, and cache them
+ * in `destDir`. Returns `destDir`.
+ *
+ * Checks `destDir` mtime against TTL. If fresh, returns immediately.
+ * Otherwise downloads, gunzips, extracts matching files, and writes to `destDir`.
+ *
+ * @param tarPrefix - Only files whose path (after stripping the top-level directory)
+ *   starts with this prefix will be extracted.
+ * @param force - If true, ignore cache and re-download.
+ */
+export async function fetchAndExtractTar(
+  config: FetchTarConfig,
+  tarPrefix: string,
+  force = false,
+): Promise<string> {
+  const ttl = config.cacheTtlMs ?? DEFAULT_TAR_CACHE_TTL_MS;
+
+  if (!force) {
+    try {
+      if (existsSync(config.destDir)) {
+        const stat = statSync(config.destDir);
+        if (Date.now() - stat.mtimeMs < ttl) {
+          return config.destDir;
+        }
+      }
+    } catch (e) {
+      debug("tar cache check failed:", e);
+    }
+  }
+
+  const resp = await fetch(config.url);
+  if (!resp.ok) {
+    throw new Error(`Tarball download from ${config.url} returned ${resp.status}`);
+  }
+
+  const compressed = new Uint8Array(await resp.arrayBuffer());
+  const { gunzipSync } = await import("fflate");
+  const tarData = gunzipSync(compressed);
+
+  // Remove old cache
+  if (existsSync(config.destDir)) {
+    rmSync(config.destDir, { recursive: true });
+  }
+
+  // Extract files matching the prefix
+  let extracted = 0;
+  const files = extractFromTar(tarData);
+
+  for (const [name, data] of files) {
+    // Strip top-level directory (e.g. "cfn-lint-main/")
+    const slashIdx = name.indexOf("/");
+    if (slashIdx < 0) continue;
+    const relPath = name.slice(slashIdx + 1);
+
+    if (!relPath.startsWith(tarPrefix)) continue;
+    const localPath = relPath.slice(tarPrefix.length);
+    if (!localPath) continue;
+
+    const fullPath = join(config.destDir, localPath);
+    const dir = dirname(fullPath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, data as unknown as Uint8Array);
+    extracted++;
+  }
+
+  if (extracted === 0) {
+    throw new Error(`No files matching prefix "${tarPrefix}" found in tarball`);
+  }
+
+  return config.destDir;
+}
+
+// ── Cache utilities ────────────────────────────────────────────────
+
+/**
+ * Clear a cache file. Ignores errors if the file doesn't exist.
+ */
+export function clearCacheFile(cacheFile: string): void {
+  try {
+    if (existsSync(cacheFile)) unlinkSync(cacheFile);
+  } catch (e) {
+    debug("cache clear failed:", e);
+  }
+}

package/src/codegen/generate-registry.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test";
+import { buildRegistry, serializeRegistry, type RegistryResource, type RegistryConfig } from "./generate-registry";
+import { NamingStrategy, type NamingInput, type NamingConfig } from "./naming";
+
+interface TestEntry {
+  resourceType: string;
+  kind: "resource" | "property";
+  attrs?: Record<string, string>;
+}
+
+function makeNaming(results: RegistryResource[]): NamingStrategy {
+  const inputs: NamingInput[] = results.map((r) => ({
+    typeName: r.typeName,
+    propertyTypes: r.propertyTypes,
+  }));
+  const config: NamingConfig = {
+    priorityNames: {},
+    priorityAliases: {},
+    priorityPropertyAliases: {},
+    serviceAbbreviations: {},
+    shortName: (t) => t.split("::")[2] ?? t,
+    serviceName: (t) => t.split("::")[1] ?? t,
+  };
+  return new NamingStrategy(inputs, config);
+}
+
+const testConfig: RegistryConfig<TestEntry> = {
+  shortName: (t) => t.split("::")[2] ?? t,
+  buildEntry: (_resource, _tsName, attrs) => ({
+    resourceType: _resource.typeName,
+    kind: "resource",
+    ...(attrs && { attrs }),
+  }),
+  buildPropertyEntry: (resourceType, propertyType) => ({
+    resourceType: `${resourceType}.${propertyType}`,
+    kind: "property",
+  }),
+};
+
+describe("buildRegistry", () => {
+  test("builds entries with attrs map", () => {
+    const resources: RegistryResource[] = [
+      {
+        typeName: "Test::S3::Bucket",
+        attributes: [{ name: "Arn" }, { name: "DomainName" }],
+        properties: [],
+        propertyTypes: [],
+      },
+    ];
+    const naming = makeNaming(resources);
+    const entries = buildRegistry(resources, naming, testConfig);
+
+    expect(entries["Bucket"]).toBeDefined();
+    expect(entries["Bucket"].attrs).toEqual({ arn: "Arn", domainName: "DomainName" });
+  });
+
+  test("omits attrs when empty", () => {
+    const resources: RegistryResource[] = [
+      { typeName: "Test::S3::Bucket", attributes: [], properties: [], propertyTypes: [] },
+    ];
+    const naming = makeNaming(resources);
+    const entries = buildRegistry(resources, naming, testConfig);
+    expect(entries["Bucket"].attrs).toBeUndefined();
+  });
+
+  test("includes property type entries", () => {
+    const resources: RegistryResource[] = [
+      {
+        typeName: "Test::S3::Bucket",
+        attributes: [],
+        properties: [],
+        propertyTypes: [{ name: "Bucket_Versioning", cfnType: "Versioning" }],
+      },
+    ];
+    const naming = makeNaming(resources);
+    const entries = buildRegistry(resources, naming, testConfig);
+    expect(entries["Bucket_Versioning"]).toEqual({
+      resourceType: "Test::S3::Bucket.Versioning",
+      kind: "property",
+    });
+  });
+
+  test("filters empty constraints", () => {
+    const resources: RegistryResource[] = [
+      {
+        typeName: "Test::S3::Bucket",
+        attributes: [],
+        properties: [
+          { name: "Name", constraints: { minLength: 3 } },
+          { name: "Tag", constraints: {} },
+        ],
+        propertyTypes: [],
+      },
+    ];
+    const naming = makeNaming(resources);
+
+    let capturedConstraints: Record<string, unknown> | undefined;
+    const config: RegistryConfig<TestEntry> = {
+      ...testConfig,
+      buildEntry: (_r, _t, _a, propConstraints) => {
+        capturedConstraints = propConstraints;
+        return { resourceType: _r.typeName, kind: "resource" };
+      },
+    };
+
+    buildRegistry(resources, naming, config);
+    expect(capturedConstraints).toEqual({ Name: { minLength: 3 } });
+  });
+});
+
+describe("serializeRegistry", () => {
+  test("sorts keys deterministically", () => {
+    const entries = { Zebra: { a: 1 }, Apple: { b: 2 }, Mango: { c: 3 } };
+    const json = serializeRegistry(entries);
+    const parsed = JSON.parse(json);
+    expect(Object.keys(parsed)).toEqual(["Apple", "Mango", "Zebra"]);
+  });
+});

package/src/codegen/generate-registry.ts

@@ -0,0 +1,107 @@
+/**
+ * Generic lexicon registry builder.
+ *
+ * Implements the shared loop: iterate parsed results, resolve naming,
+ * build attrs/constraints maps, call format-specific entry builders,
+ * handle aliases and property type sub-entries.
+ */
+
+import type { NamingStrategy } from "./naming";
+import { propertyTypeName, extractDefName } from "./naming";
+import { toCamelCase } from "./case";
+import { constraintsIsEmpty, type PropertyConstraints } from "./json-schema";
+
+export interface RegistryResource {
+  typeName: string;
+  attributes: { name: string }[];
+  properties: { name: string; constraints: PropertyConstraints }[];
+  propertyTypes: { name: string; cfnType: string }[];
+}
+
+export interface RegistryConfig<E> {
+  /** Short name extractor (e.g. cfnShortName). */
+  shortName: (typeName: string) => string;
+  /** Build a resource entry from parsed data. */
+  buildEntry: (
+    resource: RegistryResource,
+    tsName: string,
+    attrs: Record<string, string> | undefined,
+    propConstraints: Record<string, PropertyConstraints> | undefined,
+  ) => E;
+  /** Build a property type entry. */
+  buildPropertyEntry: (resourceType: string, propertyType: string) => E;
+}
+
+/**
+ * Build a registry of entries from parsed results using the naming strategy.
+ */
+export function buildRegistry<E>(
+  results: RegistryResource[],
+  naming: NamingStrategy,
+  config: RegistryConfig<E>,
+): Record<string, E> {
+  const entries: Record<string, E> = {};
+
+  for (const r of results) {
+    const typeName = r.typeName;
+    const tsName = naming.resolve(typeName);
+    if (!tsName) continue;
+
+    // Build attrs map: camelCase → raw name
+    let attrs: Record<string, string> | undefined;
+    if (r.attributes.length > 0) {
+      attrs = {};
+      for (const a of r.attributes) {
+        attrs[toCamelCase(a.name)] = a.name;
+      }
+    }
+
+    // Build per-property constraints (skip empty)
+    let propConstraints: Record<string, PropertyConstraints> | undefined;
+    for (const p of r.properties) {
+      if (!constraintsIsEmpty(p.constraints)) {
+        if (!propConstraints) propConstraints = {};
+        propConstraints[p.name] = p.constraints;
+      }
+    }
+
+    const entry = config.buildEntry(r, tsName, attrs, propConstraints);
+    entries[tsName] = entry;
+
+    // Alias entries
+    for (const alias of naming.aliases(typeName)) {
+      entries[alias] = entry;
+    }
+
+    // Property type entries
+    const shortName = config.shortName(typeName);
+    const ptAliases = naming.propertyTypeAliases(typeName);
+
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      const ptName = propertyTypeName(tsName, defName);
+      const ptEntry = config.buildPropertyEntry(typeName, pt.cfnType);
+      entries[ptName] = ptEntry;
+
+      if (ptAliases) {
+        const aliasName = ptAliases.get(defName);
+        if (aliasName) {
+          entries[aliasName] = ptEntry;
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Sort registry keys and serialize to JSON.
+ */
+export function serializeRegistry(entries: Record<string, unknown>): string {
+  const sorted: Record<string, unknown> = {};
+  for (const key of Object.keys(entries).sort()) {
+    sorted[key] = entries[key];
+  }
+  return JSON.stringify(sorted, null, 2);
+}

package/src/codegen/generate-runtime-index.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+import {
+  generateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+  type RuntimeIndexConfig,
+} from "./generate-runtime-index";
+
+const baseConfig: RuntimeIndexConfig = {
+  lexiconName: "test",
+  intrinsicReExports: { names: ["Sub", "Ref"], from: "../intrinsics" },
+  pseudoReExports: { names: ["Region", "AccountId"], from: "../pseudo" },
+};
+
+describe("generateRuntimeIndex", () => {
+  test("emits resource and property exports in sorted order", () => {
+    const resources: RuntimeIndexEntry[] = [
+      { tsName: "Bucket", resourceType: "AWS::S3::Bucket", attrs: { arn: "Arn" } },
+      { tsName: "Alarm", resourceType: "AWS::CloudWatch::Alarm", attrs: {} },
+    ];
+    const properties: RuntimeIndexPropertyEntry[] = [
+      { tsName: "Bucket_Versioning", resourceType: "AWS::S3::Bucket.VersioningConfiguration" },
+    ];
+
+    const result = generateRuntimeIndex(resources, properties, baseConfig);
+
+    // Resources sorted: Alarm before Bucket
+    expect(result).toContain('export const Alarm = createResource("AWS::CloudWatch::Alarm", "test", {});');
+    expect(result).toContain('export const Bucket = createResource("AWS::S3::Bucket", "test", {"arn":"Arn"});');
+    expect(result).toContain('export const Bucket_Versioning = createProperty("AWS::S3::Bucket.VersioningConfiguration", "test");');
+
+    // Alarm should come before Bucket in the output
+    const alarmIdx = result.indexOf("Alarm");
+    const bucketIdx = result.indexOf("Bucket");
+    expect(alarmIdx).toBeLessThan(bucketIdx);
+  });
+
+  test("includes re-exports", () => {
+    const result = generateRuntimeIndex([], [], baseConfig);
+    expect(result).toContain('export { Sub, Ref } from "../intrinsics";');
+    expect(result).toContain('export { Region, AccountId } from "../pseudo";');
+  });
+
+  test("filters colliding re-exports", () => {
+    const resources: RuntimeIndexEntry[] = [
+      { tsName: "Sub", resourceType: "Test::Sub", attrs: {} },
+      { tsName: "Region", resourceType: "Test::Region", attrs: {} },
+    ];
+
+    const result = generateRuntimeIndex(resources, [], baseConfig);
+    // "Sub" and "Region" collide with generated exports — only non-colliding survive
+    expect(result).toContain('export { Ref } from "../intrinsics";');
+    expect(result).toContain('export { AccountId } from "../pseudo";');
+    expect(result).not.toContain("export { Sub, Ref }");
+    expect(result).not.toContain("export { Region, AccountId }");
+  });
+
+  test("omits re-export line when all names collide", () => {
+    const resources: RuntimeIndexEntry[] = [
+      { tsName: "Sub", resourceType: "T::Sub", attrs: {} },
+      { tsName: "Ref", resourceType: "T::Ref", attrs: {} },
+    ];
+
+    const result = generateRuntimeIndex(resources, [], baseConfig);
+    // Both intrinsic names collide, so no intrinsic re-export line
+    expect(result).not.toContain("../intrinsics");
+  });
+
+  test("works with no re-exports configured", () => {
+    const config: RuntimeIndexConfig = { lexiconName: "bare" };
+    const result = generateRuntimeIndex([], [], config);
+    expect(result).toContain("// Re-exports for convenience");
+    expect(result).not.toContain("export {");
+  });
+
+  test("includes banner and import", () => {
+    const result = generateRuntimeIndex([], [], baseConfig);
+    expect(result).toContain("// Code generated by chant generate. DO NOT EDIT.");
+    expect(result).toContain('import { createResource, createProperty } from "./runtime";');
+  });
+});