@intentius/chant-lexicon-k8s 0.124.30 → 0.124.32

package/dist/crd/parser.js

@@ -0,0 +1,382 @@
+/**
+ * CRD parser — converts CRD YAML into K8sParseResult entries.
+ *
+ * Parses the openAPIV3Schema from a CRD's versions to extract resource
+ * properties, building the same K8sParseResult structures used by the
+ * main K8s swagger parser. This enables CRD-based resources to integrate
+ * with the full codegen pipeline.
+ */
+import { namespaceSegmentForGroup } from "../group-namespace.js";
+import { loadAll } from "js-yaml";
+/**
+ * Parse a CRD YAML document string into K8sParseResult entries.
+ * Returns one result per served version in the CRD.
+ */
+export function parseCRD(content) {
+    const results = [];
+    // Use js-yaml to handle full YAML spec (CRD YAMLs use same-indent arrays,
+    // nested block scalars, and deep nesting not supported by the lightweight parser).
+    const documents = [];
+    loadAll(content, (doc) => documents.push(doc));
+    for (const doc of documents) {
+        if (!doc || typeof doc !== "object")
+            continue;
+        const docObj = doc;
+        if (docObj.kind !== "CustomResourceDefinition")
+            continue;
+        const spec = docObj.spec;
+        if (!spec?.group || !spec?.names?.kind || !spec?.versions)
+            continue;
+        const crdResults = parseCRDSpec(spec);
+        results.push(...crdResults);
+    }
+    return results;
+}
+/**
+ * The version a CRD's types are generated from: the served storage version,
+ * else the first served one.
+ */
+export function crdTargetVersion(spec) {
+    return spec.versions.find((v) => v.storage && v.served) ?? spec.versions.find((v) => v.served);
+}
+/**
+ * Parse a CRD spec into K8sParseResult entries.
+ * Extracts one result per served version with storage version preferred.
+ */
+export function parseCRDSpec(spec) {
+    const results = [];
+    const groupNs = namespaceSegmentForGroup(spec.group);
+    const targetVersion = crdTargetVersion(spec);
+    if (!targetVersion)
+        return results;
+    const typeName = `K8s::${groupNs}::${spec.names.kind}`;
+    const gvk = {
+        group: spec.group,
+        version: targetVersion.name,
+        kind: spec.names.kind,
+    };
+    const schema = targetVersion.schema?.openAPIV3Schema;
+    const properties = schema ? extractProperties(schema) : [];
+    const propertyTypes = schema ? extractPropertyTypes(schema, typeName) : [];
+    const status = schema ? extractStatusType(schema, typeName) : {};
+    const specSchema = schema?.properties?.spec ? toFieldSchema(schema.properties.spec) : undefined;
+    const attributes = [
+        { name: "name", tsType: "string" },
+        { name: "namespace", tsType: "string" },
+        { name: "uid", tsType: "string" },
+    ];
+    if (status.attribute)
+        attributes.push(status.attribute);
+    results.push({
+        resource: {
+            typeName,
+            description: `Custom resource: ${spec.names.kind} (${spec.group})`,
+            properties,
+            attributes,
+            deprecatedProperties: [],
+        },
+        propertyTypes: status.propertyType ? [...propertyTypes, status.propertyType] : propertyTypes,
+        enums: [],
+        gvk,
+        // chant #1372 — the spec's field schema, shipped in the lexicon JSON so
+        // the post-synth checks (WK8501/WK8502) can validate a custom resource
+        // the way the API server's structural schema would, before apply.
+        ...(specSchema ? { specSchema } : {}),
+        // chant #1074 — the CRD declares its own plural and scope, so the
+        // operation surface for a custom resource comes from the same document its
+        // types do, exactly as the OpenAPI `paths` supply them for built-in kinds.
+        operation: {
+            plural: spec.names.plural,
+            scope: spec.scope ?? "Namespaced",
+            verbs: ["delete", "get", "list", "patch", "post", "put", "watch"],
+        },
+    });
+    return results;
+}
+// ── Property extraction ─────────────────────────────────────────────
+/**
+ * Extract top-level properties from a CRD's openAPIV3Schema.
+ * Focuses on the "spec" sub-object and metadata, skipping status.
+ */
+function extractProperties(schema) {
+    const result = [];
+    const topProps = schema.properties ?? {};
+    const topRequired = new Set(schema.required ?? []);
+    // Skip apiVersion, kind, status — same pattern as core parser. `metadata` is
+    // skipped here too and re-added below: every custom resource carries the full
+    // ObjectMeta whatever its own schema says, and most CRD schemas say nothing.
+    const skipProps = new Set(["apiVersion", "kind", "metadata", "status"]);
+    // A CRD's openAPIV3Schema describes what the *controller* reads, so authors
+    // routinely declare only `spec` and `status` — the Fabric8 CRDGenerator emits
+    // exactly that, and so do most hand-written CRDs. The API server still accepts
+    // (and requires) the standard `metadata`, so deriving the constructor surface
+    // from the schema alone produced a class with no way to set a name or
+    // namespace, and every call site needed an `as any` to get one on. Emit it
+    // unconditionally, typed the same as every built-in kind's.
+    result.push({
+        name: "metadata",
+        tsType: "ObjectMeta",
+        required: false,
+        description: "Standard object's metadata.",
+        constraints: {},
+    });
+    for (const [name, prop] of Object.entries(topProps)) {
+        if (skipProps.has(name))
+            continue;
+        result.push({
+            name,
+            tsType: resolveSchemaType(prop),
+            required: topRequired.has(name),
+            description: prop.description,
+            enum: prop.enum,
+            constraints: extractConstraints(prop),
+        });
+    }
+    return result;
+}
+/**
+ * Extract nested object types as ParsedPropertyType entries.
+ * Walks the spec's properties looking for inline object definitions.
+ */
+function extractPropertyTypes(schema, parentTypeName) {
+    const results = [];
+    const specSchema = schema.properties?.spec;
+    if (!specSchema?.properties)
+        return results;
+    // Use the short name (last :: segment) as prefix so the naming pipeline
+    // produces valid TS identifiers: "RayCluster_AutoscalerOptions" not
+    // "K8s::Ray::RayCluster::AutoscalerOptions".
+    const shortName = parentTypeName.split("::").pop();
+    // Property-type identifiers must be unique within a resource. Singularizing
+    // array names can collide a sibling scalar object — e.g. Argo Application has
+    // both `source` (object) and `sources` (array), which both reduce to
+    // `Application_Source`. Track emitted names and fall back to the raw
+    // (un-singularized) name, then a numeric suffix, on collision.
+    const usedNames = new Set();
+    const uniqueName = (base, raw) => {
+        if (!usedNames.has(base)) {
+            usedNames.add(base);
+            return base;
+        }
+        const rawCandidate = `${shortName}_${pascalCase(raw)}`;
+        if (!usedNames.has(rawCandidate)) {
+            usedNames.add(rawCandidate);
+            return rawCandidate;
+        }
+        let i = 2;
+        while (usedNames.has(`${base}${i}`))
+            i++;
+        const suffixed = `${base}${i}`;
+        usedNames.add(suffixed);
+        return suffixed;
+    };
+    for (const [name, prop] of Object.entries(specSchema.properties)) {
+        // Extract inline object definitions as property types
+        if (prop.type === "object" && prop.properties) {
+            const ptName = uniqueName(`${shortName}_${pascalCase(name)}`, name);
+            const requiredSet = new Set(prop.required ?? []);
+            results.push({
+                name: ptName,
+                defType: name,
+                properties: Object.entries(prop.properties).map(([pName, pSchema]) => ({
+                    name: pName,
+                    tsType: resolveSchemaType(pSchema),
+                    required: requiredSet.has(pName),
+                    description: pSchema.description,
+                    enum: pSchema.enum,
+                    constraints: extractConstraints(pSchema),
+                })),
+            });
+        }
+        // Array of objects
+        if (prop.type === "array" && prop.items?.type === "object" && prop.items.properties) {
+            const itemSchema = prop.items;
+            const itemProps = itemSchema.properties;
+            const ptName = uniqueName(`${shortName}_${pascalCase(singularize(name))}`, name);
+            const requiredSet = new Set(itemSchema.required ?? []);
+            results.push({
+                name: ptName,
+                defType: name,
+                properties: Object.entries(itemProps).map(([pName, pSchema]) => ({
+                    name: pName,
+                    tsType: resolveSchemaType(pSchema),
+                    required: requiredSet.has(pName),
+                    description: pSchema.description,
+                    enum: pSchema.enum,
+                    constraints: extractConstraints(pSchema),
+                })),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Extract the read-only `status` sub-object as a property type plus a `status`
+ * attribute on the resource. Status is never part of the writable spec surface
+ * (it is server-owned), so it is exposed only as a read-only output.
+ *
+ * Shallow by design, mirroring extractPropertyTypes: scalar leaves are typed,
+ * nested objects and arrays-of-objects degrade to `Record<string, any>`. Status
+ * with `x-kubernetes-preserve-unknown-fields` (or no properties) degrades to a
+ * bare `Record<string, any>` attribute with no property type.
+ */
+function extractStatusType(schema, parentTypeName) {
+    const statusSchema = schema.properties?.status;
+    if (!statusSchema)
+        return {};
+    // The `.d.ts` accessor is deliberately opaque, like the constructor's
+    // `spec: Record<string, unknown>`. The writable side is typed through the
+    // lexicon JSON instead (`specSchema`, chant #1372, checked by WK8501/WK8502).
+    // Status is server-owned and never validated; the property type below only
+    // registers its name so the shape is discoverable (chant #1372 reviewed the
+    // claim that it fed LSP / validation — it did not, and does not need to).
+    const attribute = { name: "status", tsType: "Record<string, unknown>" };
+    // Opaque status (preserve-unknown or no schema) → read-only record only.
+    if (statusSchema["x-kubernetes-preserve-unknown-fields"] || !statusSchema.properties) {
+        return { attribute };
+    }
+    const shortName = parentTypeName.split("::").pop();
+    const propertyType = {
+        name: `${shortName}_Status`,
+        defType: "status",
+        properties: Object.entries(statusSchema.properties).map(([pName, pSchema]) => ({
+            name: pName,
+            tsType: resolveSchemaType(pSchema),
+            required: new Set(statusSchema.required ?? []).has(pName),
+            description: pSchema.description,
+            enum: pSchema.enum,
+            constraints: extractConstraints(pSchema),
+        })),
+    };
+    return { attribute, propertyType };
+}
+// ── Spec field schema (chant #1372) ────────────────────────────────
+/**
+ * Reduce an `openAPIV3Schema` node to the compact {@link CrdFieldSchema} the
+ * lexicon JSON ships. Walks the whole tree; drops descriptions, formats,
+ * defaults and numeric bounds. `allOf`/`oneOf`/`anyOf` are not modelled — a
+ * node that relies on them with no `type` of its own comes out untyped, which
+ * the validators treat as "anything goes".
+ */
+export function toFieldSchema(node) {
+    const out = {};
+    if (node["x-kubernetes-int-or-string"]) {
+        out.open = true;
+        return out;
+    }
+    const type = node.type;
+    if (type === "string" || type === "integer" || type === "number" || type === "boolean" || type === "object" || type === "array") {
+        out.type = type;
+    }
+    else if (node.properties) {
+        out.type = "object";
+    }
+    else if (node.items) {
+        out.type = "array";
+    }
+    if (node.enum && node.enum.length > 0) {
+        out.enum = node.enum.map((v) => String(v));
+    }
+    if (out.type === "object") {
+        if (node.properties) {
+            const fields = {};
+            for (const [name, child] of Object.entries(node.properties)) {
+                fields[name] = toFieldSchema(child);
+            }
+            out.fields = fields;
+        }
+        if (node.required && node.required.length > 0) {
+            out.required = [...node.required];
+        }
+        if (node["x-kubernetes-preserve-unknown-fields"] || node.additionalProperties || !node.properties) {
+            out.open = true;
+        }
+    }
+    else if (out.type === "array") {
+        if (node.items)
+            out.items = toFieldSchema(node.items);
+    }
+    else if (node["x-kubernetes-preserve-unknown-fields"] && !out.type) {
+        out.open = true;
+    }
+    return out;
+}
+/**
+ * Resolve an OpenAPI schema node to a TypeScript type string.
+ */
+function resolveSchemaType(schema) {
+    if (!schema)
+        return "any";
+    if (schema["x-kubernetes-int-or-string"])
+        return "string | number";
+    if (schema["x-kubernetes-preserve-unknown-fields"])
+        return "Record<string, any>";
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    switch (schema.type) {
+        case "string":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            if (schema.items) {
+                const itemType = resolveSchemaType(schema.items);
+                if (itemType.includes(" | "))
+                    return `(${itemType})[]`;
+                return `${itemType}[]`;
+            }
+            return "any[]";
+        case "object":
+            if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+                const valueType = resolveSchemaType(schema.additionalProperties);
+                return `Record<string, ${valueType}>`;
+            }
+            if (schema.properties)
+                return "Record<string, any>"; // will be a property type
+            return "Record<string, any>";
+        default:
+            return "any";
+    }
+}
+/**
+ * Extract property constraints from an OpenAPI schema node.
+ */
+function extractConstraints(schema) {
+    const constraints = {};
+    if (schema.minimum !== undefined)
+        constraints.minimum = schema.minimum;
+    if (schema.maximum !== undefined)
+        constraints.maximum = schema.maximum;
+    if (schema.minLength !== undefined)
+        constraints.minLength = schema.minLength;
+    if (schema.maxLength !== undefined)
+        constraints.maxLength = schema.maxLength;
+    if (schema.pattern !== undefined)
+        constraints.pattern = schema.pattern;
+    return constraints;
+}
+/**
+ * Convert a string to PascalCase.
+ */
+function pascalCase(str) {
+    return str
+        .split(/[-_.]/)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join("");
+}
+/**
+ * Naive singularize — removes trailing "s" for property type naming.
+ */
+function singularize(str) {
+    if (str.endsWith("ies"))
+        return str.slice(0, -3) + "y";
+    if (str.endsWith("ses"))
+        return str.slice(0, -2);
+    if (str.endsWith("s") && !str.endsWith("ss"))
+        return str.slice(0, -1);
+    return str;
+}

package/dist/crd/project-codegen.js

@@ -0,0 +1,273 @@
+/**
+ * Project-local CRD classes: the k8s lexicon's `projectCodegen` hook
+ * (`chant generate`, core's project-codegen.ts).
+ *
+ * A project lists CRD sources under `k8s.crds` in `chant.config.ts`. Generation
+ * parses each CRD with the same parser the lexicon's own CRD_SOURCES go
+ * through (./parser.ts), so the entity type, GVK and spec field schema match
+ * what a shipped CRD gets, and writes two files to `<outDir>/k8s/`:
+ *
+ * - `index.ts`: a typed class per kind. Its props are typed from the CRD's
+ *   `openAPIV3Schema` (a shipped CRD's `.d.ts` types `spec` as a record; a
+ *   project's own types it fully). The module registers its kinds with
+ *   ../project-kinds.ts when imported.
+ * - `kinds.json`: each kind's GVK and spec field schema, which a build loads
+ *   (`load`) so the serializer and the WK8501/WK8502 spec checks know the
+ *   kinds whatever process imported the module.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { loadAll } from "js-yaml";
+import { GENERATED_TS_HEADER } from "@intentius/chant/project-codegen";
+import { jsdocLines, schemaToTypeScript, tsPropertyKey } from "@intentius/chant/codegen/json-schema-to-ts";
+import { fetchWithRetry } from "@intentius/chant/codegen/fetch";
+import { namespaceSegmentForGroup } from "../group-namespace.js";
+import { registerProjectKinds } from "../project-kinds.js";
+import { gvkToApiVersion } from "../spec/parse.js";
+import { fetchCRDContent } from "./loader.js";
+import { crdTargetVersion, parseCRDSpec } from "./parser.js";
+/** The registry file written beside the module. */
+export const KINDS_FILE = "kinds.json";
+/** Fields every resource class handles itself; a CRD's own schema for them is ignored. */
+const RESERVED_FIELDS = new Set(["apiVersion", "kind", "metadata", "status"]);
+/** The hook, with injectable readers. */
+export function k8sProjectCodegen(readers = {}) {
+    return {
+        inputs: (ctx) => {
+            const sources = declaredSources(ctx);
+            if (!sources)
+                return undefined;
+            return sources.map((source, i) => describeSource(source, i, ctx.projectRoot));
+        },
+        async generate(ctx) {
+            const sources = declaredSources(ctx) ?? [];
+            const fetchUrl = readers.fetchUrl ??
+                (async (url) => {
+                    const response = ctx.fetch ? await ctx.fetch(url) : await fetchWithRetry(url);
+                    if (!response.ok)
+                        throw new Error(`${url}: HTTP ${response.status}`);
+                    return response.text();
+                });
+            const readChart = readers.readChart ??
+                ((s) => fetchCRDContent({ type: "helm", chart: s.chart, version: s.version, digest: s.digest, chartSubdir: s.chartSubdir }));
+            const kinds = [];
+            for (const [i, source] of sources.entries()) {
+                describeSource(source, i, ctx.projectRoot); // validates the pin before any fetch
+                let content;
+                if (source.type === "file") {
+                    content = readFileSync(resolve(ctx.projectRoot, source.path), "utf8");
+                }
+                else if (source.type === "url") {
+                    content = await fetchUrl(source.url);
+                    const actual = sha256(content);
+                    if (actual !== normalizeSha(source.sha256)) {
+                        throw new Error(`k8s.crds[${i}]: ${source.url} has sha256 ${actual}, but the config pins ${normalizeSha(source.sha256)}. ` +
+                            "Check the URL points at a fixed release, then update the pin.");
+                    }
+                }
+                else {
+                    content = await readChart(source);
+                }
+                const found = crdKinds(content, source.kinds);
+                if (found.length === 0) {
+                    throw new Error(`k8s.crds[${i}] (${sourceLabel(source)}) holds no CustomResourceDefinition${source.kinds ? ` of kind ${source.kinds.join(", ")}` : ""}`);
+                }
+                kinds.push(...found);
+            }
+            assignClassNames(kinds);
+            return {
+                files: { "index.ts": renderModule(kinds), [KINDS_FILE]: renderKinds(kinds) },
+                summary: kinds.map((k) => `${k.className} (${k.apiVersion}, ${k.scope === "Cluster" ? "cluster-scoped" : "namespaced"})`),
+            };
+        },
+        load(ctx) {
+            const path = join(ctx.outDir, KINDS_FILE);
+            if (!existsSync(path))
+                return;
+            registerProjectKinds(JSON.parse(readFileSync(path, "utf8")));
+        },
+    };
+}
+function declaredSources(ctx) {
+    const k8s = ctx.config.k8s;
+    return k8s?.crds && k8s.crds.length > 0 ? k8s.crds : undefined;
+}
+/**
+ * A source as a JSON value for the drift digest: a file by the hash of its
+ * content, a remote source by its pin. Throws on an unpinned remote source
+ * or a missing file.
+ */
+function describeSource(source, i, projectRoot) {
+    const kinds = source.kinds ? { kinds: [...source.kinds].sort() } : {};
+    switch (source.type) {
+        case "file": {
+            const path = resolve(projectRoot, source.path);
+            if (!existsSync(path))
+                throw new Error(`k8s.crds[${i}]: CRD file not found: ${source.path}`);
+            return { type: "file", path: source.path, sha256: sha256(readFileSync(path)), ...kinds };
+        }
+        case "url":
+            if (typeof source.sha256 !== "string" || !/^(sha256:)?[0-9a-f]{64}$/.test(source.sha256)) {
+                throw new Error(`k8s.crds[${i}]: ${source.url} needs a sha256 pin of its content. An unpinned URL makes the generated classes depend on when they were generated.`);
+            }
+            return { type: "url", url: source.url, sha256: normalizeSha(source.sha256), ...kinds };
+        case "helm":
+            if (!source.version) {
+                throw new Error(`k8s.crds[${i}]: chart ${source.chart} needs a version. An unpinned chart makes the generated classes depend on when they were generated.`);
+            }
+            return {
+                type: "helm",
+                chart: source.chart,
+                version: source.version,
+                ...(source.digest ? { digest: source.digest } : {}),
+                ...(source.chartSubdir ? { chartSubdir: source.chartSubdir } : {}),
+                ...kinds,
+            };
+        default:
+            throw new Error(`k8s.crds[${i}]: unsupported source type ${JSON.stringify(source.type)}`);
+    }
+}
+function sourceLabel(source) {
+    return source.type === "file" ? source.path : source.type === "url" ? source.url : `${source.chart} ${source.version}`;
+}
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function normalizeSha(pin) {
+    return pin.replace(/^sha256:/, "");
+}
+/** Every CRD in a (multi-document) YAML text, filtered to `allow` when given. */
+function crdKinds(content, allow) {
+    const docs = [];
+    loadAll(content, (doc) => docs.push(doc));
+    const out = [];
+    for (const doc of docs) {
+        if (!doc || typeof doc !== "object")
+            continue;
+        const d = doc;
+        if (d.kind !== "CustomResourceDefinition" || !d.spec?.group || !d.spec.names?.kind || !d.spec.versions)
+            continue;
+        if (allow && allow.length > 0 && !allow.includes(d.spec.names.kind))
+            continue;
+        const [parsed] = parseCRDSpec(d.spec);
+        const version = crdTargetVersion(d.spec);
+        if (!parsed || !version)
+            continue;
+        out.push({
+            resourceType: parsed.resource.typeName,
+            apiVersion: gvkToApiVersion(parsed.gvk),
+            kind: parsed.gvk.kind,
+            group: d.spec.group,
+            scope: d.spec.scope ?? "Namespaced",
+            attributes: parsed.resource.attributes,
+            ...(parsed.specSchema ? { specSchema: parsed.specSchema } : {}),
+            schema: version.schema?.openAPIV3Schema,
+            className: parsed.gvk.kind,
+        });
+    }
+    return out;
+}
+/**
+ * Class names are the kind. Two kinds of the same name from different groups
+ * both take the group's namespace segment as a prefix (`CertManagerCertificate`);
+ * the same group and kind twice is an error.
+ */
+function assignClassNames(kinds) {
+    const seen = new Set();
+    for (const k of kinds) {
+        const key = `${k.group}/${k.kind}`;
+        if (seen.has(key))
+            throw new Error(`k8s.crds declares ${k.kind} (${k.group}) more than once`);
+        seen.add(key);
+    }
+    const byKind = new Map();
+    for (const k of kinds)
+        byKind.set(k.kind, [...(byKind.get(k.kind) ?? []), k]);
+    for (const group of byKind.values()) {
+        if (group.length < 2)
+            continue;
+        for (const k of group)
+            k.className = `${namespaceSegmentForGroup(k.group).replace(/[^A-Za-z0-9]/g, "")}${k.kind}`;
+    }
+    kinds.sort((a, b) => a.className.localeCompare(b.className));
+}
+function renderKinds(kinds) {
+    const entries = kinds.map((k) => ({
+        resourceType: k.resourceType,
+        apiVersion: k.apiVersion,
+        kind: k.kind,
+        ...(k.specSchema ? { specSchema: k.specSchema } : {}),
+    }));
+    return JSON.stringify(entries, null, 2) + "\n";
+}
+/**
+ * The metadata a manifest author sets. Declared in the module rather than
+ * imported: the lexicon's `ObjectMeta` export is a runtime constructor, and
+ * its typed declaration is not reachable from every install.
+ */
+const OBJECT_META = [
+    "/** Standard object metadata: the fields a manifest sets. */",
+    "export interface ObjectMeta {",
+    "  name?: string;",
+    "  generateName?: string;",
+    "  namespace?: string;",
+    "  labels?: Record<string, string>;",
+    "  annotations?: Record<string, string>;",
+    "  finalizers?: string[];",
+    "  ownerReferences?: Array<{",
+    "    apiVersion: string;",
+    "    kind: string;",
+    "    name: string;",
+    "    uid: string;",
+    "    controller?: boolean;",
+    "    blockOwnerDeletion?: boolean;",
+    "  }>;",
+    "}",
+];
+function renderModule(kinds) {
+    const lines = [
+        GENERATED_TS_HEADER,
+        "// Classes for the custom resources k8s.crds declares in chant.config.",
+        'import type { Declarable } from "@intentius/chant";',
+        'import { createResource } from "@intentius/chant/runtime";',
+        'import { registerProjectKinds } from "@intentius/chant-lexicon-k8s";',
+        "",
+        "registerProjectKinds([",
+        ...kinds.map((k) => `  ${JSON.stringify({ resourceType: k.resourceType, apiVersion: k.apiVersion, kind: k.kind })},`),
+        "]);",
+        "",
+        ...OBJECT_META,
+    ];
+    for (const k of kinds) {
+        const name = k.className;
+        const properties = (k.schema?.properties ?? {});
+        const required = new Set(k.schema?.required ?? []);
+        const fields = Object.keys(properties).filter((f) => !RESERVED_FIELDS.has(f));
+        const members = ["  /** Standard object's metadata. */", "  metadata?: ObjectMeta;"];
+        for (const field of fields) {
+            const typeName = `${name}${pascal(field)}`;
+            const { type, declarations } = schemaToTypeScript(properties[field], {
+                openByDefault: false,
+                namePrefix: typeName,
+            });
+            for (const d of declarations) {
+                lines.push("", ...jsdocLines(d.description, ""), `export type ${d.name} = ${d.type};`);
+            }
+            lines.push("", `/** The \`${field}\` of a ${k.kind} (${k.apiVersion}). */`, `export type ${typeName} = ${type};`);
+            members.push(...jsdocLines(properties[field].description, "  "));
+            members.push(`  ${tsPropertyKey(field)}${required.has(field) ? "" : "?"}: ${typeName};`);
+        }
+        const attrMap = Object.fromEntries(k.attributes.map((a) => [a.name, a.name]));
+        lines.push("", `/** Props for a ${k.kind}, a custom resource of ${k.apiVersion}. */`, `export interface ${name}Props {`, ...members, "}", "", `/** A ${k.kind} (${k.apiVersion}, ${k.scope === "Cluster" ? "cluster-scoped" : "namespaced"}). */`, `export interface ${name} extends Declarable {`, ...k.attributes.map((a) => `  readonly ${a.name}: ${a.tsType};`), "}", "", `export const ${name}: new (props: ${name}Props) => ${name} = createResource(${JSON.stringify(k.resourceType)}, "k8s", ${JSON.stringify(attrMap)}) as never;`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function pascal(name) {
+    return name
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join("");
+}

package/dist/crd/types.js

@@ -0,0 +1,7 @@
+/**
+ * CRD (Custom Resource Definition) framework types.
+ *
+ * Defines the data structures used to load, parse, and process
+ * Kubernetes CRDs for code generation and lexicon extension.
+ */
+export {};