@intentius/chant 0.124.12 → 0.124.14

package/dist/codegen/fetch.js

@@ -0,0 +1,340 @@
+/**
+ * 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.js";
+// ── Transient-aware fetch ──────────────────────────────────────────
+/**
+ * HTTP statuses worth retrying. These are transient: a gateway hiccup,
+ * a rate limit, or an overloaded upstream — not a permanent 404/403.
+ */
+const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
+const DEFAULT_RETRIES = 4;
+const DEFAULT_BACKOFF_MS = 1000;
+/**
+ * Per-attempt ceiling, so an upstream that accepts a connection and then stops
+ * answering cannot hold a build open.
+ *
+ * Without one, a hung connect waits on the OS default — which on Linux is over
+ * a minute — and five of those plus back-off is enough to run a CI job past its
+ * timeout. That is not hypothetical: it is what pushed chant's `check` job from
+ * ~9m30s to a cancellation at 10m, twice, on two unreachable spec endpoints
+ * whose results are only ever a fallback to a committed snapshot anyway.
+ *
+ * Generous enough for a slow-but-alive endpoint; the point is a bound, not
+ * speed.
+ */
+const DEFAULT_ATTEMPT_TIMEOUT_MS = 15000;
+/** Hard cap on Retry-After delays so a rogue header cannot stall CI indefinitely. */
+const MAX_RETRY_AFTER_MS = 60000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Parse the `Retry-After` response header and return a delay in milliseconds.
+ *
+ * The header value may be an integer number of seconds or an HTTP-date.
+ * Returns `null` when the header is absent or unparseable.
+ * The returned value is capped at {@link MAX_RETRY_AFTER_MS}.
+ */
+function parseRetryAfter(response) {
+    const raw = response.headers.get("retry-after");
+    if (!raw)
+        return null;
+    const seconds = Number(raw.trim());
+    if (!Number.isNaN(seconds) && seconds >= 0) {
+        return Math.min(Math.ceil(seconds * 1000), MAX_RETRY_AFTER_MS);
+    }
+    // HTTP-date format: "Wed, 01 Jul 2026 12:00:00 GMT"
+    const date = new Date(raw);
+    if (!Number.isNaN(date.getTime())) {
+        return Math.min(Math.max(0, date.getTime() - Date.now()), MAX_RETRY_AFTER_MS);
+    }
+    return null;
+}
+/**
+ * Fetch a URL, retrying on transient failures (network errors and
+ * retryable HTTP statuses) with exponential backoff.
+ *
+ * Permanent failures (e.g. 404, 403) are not retried — they throw on the
+ * first response. The returned response is guaranteed `ok`.
+ *
+ * When a `Retry-After` header is present on a 429 or 503 response the delay
+ * from that header is used instead of the exponential back-off for that
+ * specific retry, capped at {@link MAX_RETRY_AFTER_MS}.
+ *
+ * `init` is passed through to `fetch` on every attempt, so callers that
+ * need request headers (e.g. the GitHub API `Accept` header) or an abort
+ * signal get retries without duplicating the loop.
+ *
+ * On exhaustion a descriptive {@link TransientFetchError} is thrown rather
+ * than the raw last error so the caller can surface a human-readable message.
+ */
+export async function fetchWithRetry(url, retries = DEFAULT_RETRIES, backoffMs = DEFAULT_BACKOFF_MS, init, attemptTimeoutMs = DEFAULT_ATTEMPT_TIMEOUT_MS) {
+    let lastStatus;
+    let lastError;
+    // When a response carries a Retry-After header, the indicated delay replaces
+    // the exponential back-off for that specific next retry.
+    let retryAfterOverride = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        if (attempt > 0) {
+            const delay = retryAfterOverride ?? backoffMs * 2 ** (attempt - 1);
+            debug(`retrying ${url} (attempt ${attempt}/${retries}) after ${delay}ms: ${lastError?.message}`);
+            retryAfterOverride = null;
+            await sleep(delay);
+        }
+        let response;
+        // A caller's own signal still wins; this only bounds an attempt that would
+        // otherwise hang with no signal at all.
+        const signal = init?.signal ?? AbortSignal.timeout(attemptTimeoutMs);
+        try {
+            response = await fetch(url, { ...(init ?? {}), signal });
+        }
+        catch (e) {
+            // Network-level failure (DNS, connection reset, timeout). Transient.
+            lastError = e instanceof Error ? e : new Error(String(e));
+            lastStatus = undefined;
+            continue;
+        }
+        if (response.ok)
+            return response;
+        const err = new Error(`Download from ${url} returned ${response.status}`);
+        if (!RETRYABLE_STATUSES.has(response.status))
+            throw err;
+        lastError = err;
+        lastStatus = response.status;
+        // Capture Retry-After so the next loop iteration uses it instead of backoff
+        const retryAfterMs = parseRetryAfter(response);
+        if (retryAfterMs !== null) {
+            debug(`Retry-After for ${url}: ${retryAfterMs}ms`);
+            retryAfterOverride = retryAfterMs;
+        }
+    }
+    throw new TransientFetchError(url, retries, lastStatus, lastError);
+}
+/**
+ * Thrown when {@link fetchWithRetry} exhausts all retry attempts on a
+ * transient failure (429 / 5xx / network error).
+ *
+ * The message is human-readable and actionable: it names the URL, the number
+ * of attempts made, and the last HTTP status (if any) so that an upstream Op
+ * can route it to a report/issue without exposing a raw stack trace.
+ */
+export class TransientFetchError extends Error {
+    constructor(url, retries, lastStatus, cause) {
+        const attempts = retries + 1;
+        const statusPart = lastStatus !== undefined ? ` (HTTP ${lastStatus})` : "";
+        super(`Transient fetch failure for ${url}${statusPart} — failed after ${attempts} attempt${attempts === 1 ? "" : "s"}. ` +
+            `This is typically a rate-limit or upstream outage. Retry later or check upstream status.`);
+        this.url = url;
+        this.retries = retries;
+        this.lastStatus = lastStatus;
+        this.cause = cause;
+        this.name = "TransientFetchError";
+    }
+}
+// ── 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, force = false) {
+    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);
+                }
+            }
+        }
+        catch (e) {
+            debug("cache read failed:", e);
+        }
+    }
+    let response;
+    try {
+        response = await fetchWithRetry(config.url, config.retries ?? DEFAULT_RETRIES, config.backoffMs ?? DEFAULT_BACKOFF_MS, undefined, config.attemptTimeoutMs ?? DEFAULT_ATTEMPT_TIMEOUT_MS);
+    }
+    catch (e) {
+        // A stale copy beats a failed build. The archives this caches are pinned
+        // by tag or by version in the URL, so a copy past its TTL is the same
+        // bytes; the TTL exists to notice an unpinned URL moving, not to expire
+        // good data. `force` means the caller needs fresh bytes, so it still throws.
+        if (!force && e instanceof TransientFetchError && existsSync(config.cacheFile)) {
+            console.error(`${e.message} Using the cached copy at ${config.cacheFile} from ${new Date(statSync(config.cacheFile).mtimeMs).toISOString()}.`);
+            return readFileSync(config.cacheFile);
+        }
+        throw e;
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const data = Buffer.from(arrayBuffer);
+    try {
+        mkdirSync(dirname(config.cacheFile), { recursive: true });
+        writeFileSync(config.cacheFile, data);
+    }
+    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, filter) {
+    const { unzipSync } = await import("fflate");
+    const files = unzipSync(new Uint8Array(zipData));
+    const result = new Map();
+    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, filter) {
+    const result = new Map();
+    let offset = 0;
+    let longName = 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;
+}
+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, tarPrefix, force = false) {
+    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 fetchWithRetry(config.url);
+    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);
+        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) {
+    try {
+        if (existsSync(cacheFile))
+            unlinkSync(cacheFile);
+    }
+    catch (e) {
+        debug("cache clear failed:", e);
+    }
+}

package/dist/codegen/generate-post-synth-barrel.js

@@ -0,0 +1,63 @@
+/**
+ * Generate a static, importable barrel of a lexicon's post-synth checks.
+ *
+ * The runtime loader (`discoverPostSynthChecks`) readdir-globs the directory and
+ * `require()`s each file via tsx — fs- and tsx-coupled, so it can't run in a
+ * bundle or on an edge runtime (Cloudflare Workers). This generator produces a
+ * committed `lint/post-synth/index.ts` with explicit static imports + an exported
+ * `postSynthChecks` array, which bundlers can follow with no fs/tsx/require. See #409.
+ *
+ * Detection reuses the runtime's own `isPostSynthCheck`, so the barrel contains
+ * exactly the checks discovery would — including files whose export name differs
+ * from the filename (docker/helm) and excluding helper modules
+ * (cf-refs, arm-refs, …) that export no check.
+ */
+import { createRequire } from "module";
+import { listRuleFiles } from "../lint/discover.js";
+import { isPostSynthCheck } from "../lint/post-synth.js";
+/**
+ * Scan a post-synth directory and return one entry per exported check.
+ * Runs at codegen time on Node (tsx-powered require), never in the shipped path.
+ */
+export function scanPostSynthChecks(dir, importMetaUrl) {
+    const require = createRequire(importMetaUrl);
+    const entries = [];
+    for (const file of listRuleFiles(dir)) {
+        const base = file.replace(/\.ts$/, "");
+        let mod;
+        try {
+            mod = require(`${dir}/${base}`);
+        }
+        catch {
+            continue; // a file that fails to load contributes nothing
+        }
+        for (const [exportName, value] of Object.entries(mod)) {
+            if (isPostSynthCheck(value)) {
+                entries.push({ module: `./${base}`, exportName, id: value.id });
+            }
+        }
+    }
+    return entries;
+}
+/** Render the barrel file content from scanned entries (pure — easy to unit test). */
+export function generatePostSynthBarrel(entries) {
+    const sorted = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+    const lines = [];
+    lines.push("// Code generated by chant generate. DO NOT EDIT.");
+    lines.push('import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";');
+    for (const e of sorted) {
+        lines.push(`import { ${e.exportName} } from ${JSON.stringify(e.module)};`);
+    }
+    lines.push("");
+    lines.push("export const postSynthChecks: PostSynthCheck[] = [");
+    for (const e of sorted) {
+        lines.push(`  ${e.exportName},`);
+    }
+    lines.push("];");
+    lines.push("");
+    return lines.join("\n");
+}
+/** Scan a directory and render its barrel in one step. */
+export function renderPostSynthBarrelForDir(dir, importMetaUrl) {
+    return generatePostSynthBarrel(scanPostSynthChecks(dir, importMetaUrl));
+}

package/dist/codegen/generate-registry.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { propertyTypeName, extractDefName } from "./naming.js";
+import { constraintsIsEmpty } from "./json-schema.js";
+/**
+ * Build a registry of entries from parsed results using the naming strategy.
+ */
+export function buildRegistry(results, naming, config) {
+    const entries = {};
+    for (const r of results) {
+        const typeName = r.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        // Build attrs map: TS key (underscores) → CF attr name (dots)
+        let attrs;
+        if (r.attributes.length > 0) {
+            attrs = {};
+            for (const a of r.attributes) {
+                const tsKey = a.name.replace(/\./g, "_");
+                attrs[tsKey] = a.name;
+            }
+        }
+        // Build per-property constraints (skip empty)
+        let propConstraints;
+        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.specType);
+            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) {
+    const sorted = {};
+    for (const key of Object.keys(entries).sort()) {
+        sorted[key] = entries[key];
+    }
+    return JSON.stringify(sorted, null, 2);
+}

package/dist/codegen/generate-runtime-index.js

@@ -0,0 +1,56 @@
+/**
+ * Generic runtime index generator for lexicon packages.
+ *
+ * Produces the `index.ts` file containing factory constructor exports
+ * (`createResource`, `createProperty`) and collision-safe re-exports. Each
+ * factory call is marked pure, so a bundler drops the classes a caller does
+ * not import instead of keeping every one.
+ */
+/**
+ * Generate the runtime index.ts content with factory constructor exports.
+ *
+ * Phases:
+ * 1. Banner + import createResource/createProperty
+ * 2. Sort and emit resource exports
+ * 3. Sort and emit property exports
+ * 4. Collision-safe re-exports of intrinsics and pseudo-parameters
+ */
+export function generateRuntimeIndex(resources, properties, config) {
+    const lines = [];
+    lines.push("// Code generated by chant generate. DO NOT EDIT.");
+    lines.push('import { createResource, createProperty } from "./runtime";');
+    lines.push("");
+    // Sort and emit resource exports
+    const sortedResources = [...resources].sort((a, b) => a.tsName.localeCompare(b.tsName));
+    for (const { tsName, resourceType, attrs } of sortedResources) {
+        const attrsStr = JSON.stringify(attrs);
+        lines.push(`export const ${tsName} = /* @__PURE__ */ createResource(${JSON.stringify(resourceType)}, ${JSON.stringify(config.lexiconName)}, ${attrsStr});`);
+    }
+    lines.push("");
+    // Sort and emit property exports
+    const sortedProperties = [...properties].sort((a, b) => a.tsName.localeCompare(b.tsName));
+    for (const { tsName, resourceType } of sortedProperties) {
+        lines.push(`export const ${tsName} = /* @__PURE__ */ createProperty(${JSON.stringify(resourceType)}, ${JSON.stringify(config.lexiconName)});`);
+    }
+    lines.push("");
+    // Collision-safe re-exports
+    const allExportNames = new Set([
+        ...resources.map((e) => e.tsName),
+        ...properties.map((e) => e.tsName),
+    ]);
+    lines.push("// Re-exports for convenience");
+    if (config.intrinsicReExports) {
+        const safe = config.intrinsicReExports.names.filter((n) => !allExportNames.has(n));
+        if (safe.length > 0) {
+            lines.push(`export { ${safe.join(", ")} } from ${JSON.stringify(config.intrinsicReExports.from)};`);
+        }
+    }
+    if (config.pseudoReExports) {
+        const safe = config.pseudoReExports.names.filter((n) => !allExportNames.has(n));
+        if (safe.length > 0) {
+            lines.push(`export { ${safe.join(", ")} } from ${JSON.stringify(config.pseudoReExports.from)};`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/codegen/generate-typescript.js

@@ -0,0 +1,119 @@
+/**
+ * Generic TypeScript declaration (.d.ts) generation utilities.
+ *
+ * Provides functions for writing resource classes, property classes,
+ * constructors, and enum types. Lexicon-specific generators use these
+ * building blocks with their own orchestration logic.
+ */
+// ── Writers ─────────────────────────────────────────────────────────
+/**
+ * Write a resource class declaration with constructor and readonly attributes.
+ */
+export function writeResourceClass(lines, tsName, properties, attributes, remap, resourceAttributesType) {
+    lines.push("");
+    lines.push(`export declare class ${tsName} {`);
+    writeConstructor(lines, properties, remap, resourceAttributesType);
+    // Attributes as readonly properties (sorted)
+    const attrs = [...attributes].sort((a, b) => a.name.localeCompare(b.name));
+    for (const a of attrs) {
+        const attrType = resolveConstructorType(a.type, remap);
+        lines.push(`  readonly ${a.name}: ${attrType};`);
+    }
+    lines.push("}");
+}
+/**
+ * Write a property class declaration with constructor.
+ */
+export function writePropertyClass(lines, tsName, properties, remap) {
+    lines.push("");
+    lines.push(`export declare class ${tsName} {`);
+    writeConstructor(lines, properties, remap);
+    lines.push("}");
+}
+/**
+ * Write a constructor with typed props parameter.
+ */
+export function writeConstructor(lines, props, remap, resourceAttributesType) {
+    if (props.length === 0) {
+        if (resourceAttributesType) {
+            lines.push(`  constructor(props: Record<string, unknown>, attributes?: ${resourceAttributesType});`);
+        }
+        else {
+            lines.push("  constructor(props: Record<string, unknown>);");
+        }
+        return;
+    }
+    // Sort: required first, then optional, each group alphabetically
+    const sorted = [...props].sort((a, b) => {
+        if (a.required !== b.required)
+            return a.required ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    lines.push("  constructor(props: {");
+    for (const p of sorted) {
+        const optional = p.required ? "" : "?";
+        const tsType = resolveConstructorType(p.type, remap);
+        if (p.description) {
+            // Sanitize: escape */ to prevent breaking JSDoc comments
+            const safeDesc = p.description.replace(/\*\//g, "*\\/");
+            lines.push(`    /** ${safeDesc} */`);
+        }
+        const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+        lines.push(`    ${safeName}${optional}: ${tsType};`);
+    }
+    if (resourceAttributesType) {
+        lines.push(`  }, attributes?: ${resourceAttributesType});`);
+    }
+    else {
+        lines.push("  });");
+    }
+}
+/**
+ * Write an enum union type.
+ */
+export function writeEnumType(lines, tsName, values) {
+    const sorted = [...values].sort();
+    const quoted = sorted.map((v) => JSON.stringify(v));
+    const singleLine = `\nexport type ${tsName} = ${quoted.join(" | ")};`;
+    if (singleLine.length <= 100) {
+        lines.push(singleLine);
+    }
+    else {
+        lines.push("");
+        lines.push(`export type ${tsName} =`);
+        for (let i = 0; i < quoted.length; i++) {
+            const suffix = i < quoted.length - 1 ? "" : ";";
+            lines.push(`  | ${quoted[i]}${suffix}`);
+        }
+    }
+}
+/**
+ * Resolve a type string through the remap table, handling arrays and
+ * common type normalization.
+ */
+export function resolveConstructorType(tsType, remap) {
+    // Handle array types
+    if (tsType.endsWith("[]")) {
+        const inner = tsType.slice(0, -2);
+        return resolveConstructorType(inner, remap) + "[]";
+    }
+    // Primitive and pass-through types
+    switch (tsType) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "any":
+            return tsType;
+        case "Record<string, any>":
+            return "Record<string, unknown>";
+        case "Record<string, unknown>":
+            return tsType;
+    }
+    // Remap parser property type names to resolved names
+    if (remap) {
+        const resolved = remap.get(tsType);
+        if (resolved)
+            return resolved;
+    }
+    return tsType;
+}