@intentius/chant-lexicon-k3s 0.124.30 → 0.124.32

package/dist/codegen/docs-cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+import { generateDocs } from "./docs.js";
+await generateDocs({ verbose: true });

package/dist/codegen/docs.js

@@ -0,0 +1,83 @@
+/**
+ * Documentation generation for the k3s lexicon.
+ *
+ * Generates Starlight MDX pages for k3s entities using the core docs pipeline.
+ * The overview prose lives here; authored pages live under docs/pages/.
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+function serviceFromType(resourceType) {
+    const parts = resourceType.split("::");
+    return parts.length >= 2 ? parts[1] : "K3s";
+}
+const overview = `The k3s lexicon declares the files k3s itself consumes: \`config.yaml\` for
+\`k3s server\` / \`k3s agent\`, and \`registries.yaml\` for the embedded
+containerd. The emitted files are exactly what the native tool accepts —
+drop them at \`/etc/rancher/k3s/\` (or pass \`--config\`) and chant is nowhere
+in sight. That walk-away property is the reason this is a lexicon at all.
+
+\`\`\`bash
+npm install --save-dev @intentius/chant @intentius/chant-lexicon-k3s
+\`\`\`
+
+\`\`\`typescript
+// chant.config.ts
+export default {
+  lexicons: ["k3s"],
+};
+\`\`\`
+
+## A two-node cluster
+
+\`\`\`typescript
+import { Agent, Server } from "@intentius/chant-lexicon-k3s";
+
+export const controlPlane = new Server({
+  "cluster-init": true,
+  "tls-san": ["10.0.0.10", "cp.example.internal"],
+  "write-kubeconfig-mode": "0600",
+});
+
+export const worker = new Agent({
+  server: "https://cp.example.internal:6443",
+  "token-file": "/etc/rancher/k3s/agent-token",
+});
+\`\`\`
+
+## The token boundary
+
+There is no \`token\` property, on purpose. The join secret reaches a node
+as a file (\`token-file\`, \`agent-token-file\`) or as \`K3S_TOKEN\` /
+\`K3S_TOKEN_FILE\` in the installer's environment — never as a value in
+source. A literal that arrives through raw props anyway fails K3S001 at
+lint and K3S101 at build; the same wall covers the etcd S3 snapshot
+credentials (\`etcd-s3-config-secret\` is the reference form upstream
+provides).
+
+## Relationship to k3d
+
+The [k3d lexicon](/chant/lexicons/k3d/) declares a k3d-managed cluster —
+k3s wrapped in Docker, config consumed by the \`k3d\` CLI. This lexicon
+declares k3s on real hosts: Lima VMs, bare metal, cloud instances. The
+acceptance test for both is the same idea — the native tool consuming the
+emitted file is the proof.
+`;
+export async function generateDocs(opts) {
+    const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    const config = {
+        name: "k3s",
+        displayName: "K3s",
+        description: "k3s host configuration (server/agent config.yaml and registries.yaml) as typed chant source",
+        distDir: join(pkgDir, "dist"),
+        outDir: join(pkgDir, "docs"),
+        basePath: process.env.DOCS_BASE_PATH ?? "/chant/lexicons/k3s/",
+        overview,
+        serviceFromType,
+    };
+    const result = docsPipeline(config);
+    writeDocsSite(config, result);
+    if (opts?.verbose) {
+        console.error(`Generated ${result.pages.size} documentation pages`);
+    }
+}

package/dist/codegen/generate-cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env tsx
+import { generate, writeGeneratedFiles } from "./generate.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+const result = await generate({ verbose: true });
+writeGeneratedFiles(result, pkgDir);

package/dist/codegen/generate-lexicon.js

@@ -0,0 +1,39 @@
+/**
+ * Lexicon JSON generator — produces lexicon-k3s.json with metadata
+ * for all k3s entities.
+ */
+import { k3sShortName } from "./parse.js";
+import { buildRegistry, serializeRegistry, } from "@intentius/chant/codegen/generate-registry";
+/**
+ * Generate the lexicon-k3s.json content.
+ */
+export function generateLexiconJSON(results, naming) {
+    const registryResources = results.map((r) => ({
+        typeName: r.resource.typeName,
+        attributes: r.resource.attributes,
+        properties: r.resource.properties,
+        propertyTypes: r.propertyTypes.map((pt) => ({ name: pt.name, specType: pt.defType })),
+    }));
+    const entries = buildRegistry(registryResources, naming, {
+        shortName: k3sShortName,
+        buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+            const r = results.find((res) => res.resource.typeName === resource.typeName);
+            return {
+                resourceType: resource.typeName,
+                kind: (r?.isProperty ? "property" : "resource"),
+                lexicon: "k3s",
+                ...(r?.resource.deprecatedProperties?.length && {
+                    deprecatedProperties: r.resource.deprecatedProperties,
+                }),
+                ...(propConstraints &&
+                    Object.keys(propConstraints).length > 0 && { constraints: propConstraints }),
+            };
+        },
+        buildPropertyEntry: (resourceType, propertyType) => ({
+            resourceType: `${resourceType}.${propertyType}`,
+            kind: "property",
+            lexicon: "k3s",
+        }),
+    });
+    return serializeRegistry(entries);
+}

package/dist/codegen/generate-typescript.js

@@ -0,0 +1,38 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with all
+ * k3s entity classes.
+ */
+import { writeResourceClass, } from "@intentius/chant/codegen/generate-typescript";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(results, naming) {
+    const lines = [];
+    lines.push("// Code generated by chant k3s generate. DO NOT EDIT.");
+    const resources = [];
+    for (const r of results) {
+        const typeName = r.resource.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        const dtsProps = r.resource.properties.map((p) => ({
+            name: p.name,
+            type: p.tsType,
+            required: p.required,
+            description: p.description,
+        }));
+        const dtsAttrs = r.resource.attributes.map((a) => ({
+            name: a.name,
+            type: a.tsType,
+        }));
+        resources.push({ tsName, properties: dtsProps, attributes: dtsAttrs, remap: new Map() });
+    }
+    resources.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    lines.push("");
+    lines.push("// --- k3s Entity classes ---");
+    for (const re of resources) {
+        writeResourceClass(lines, re.tsName, re.properties, re.attributes, re.remap);
+    }
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/codegen/generate.js

@@ -0,0 +1,93 @@
+/**
+ * k3s generation pipeline — uses core generatePipeline with k3s-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+import { generatePipeline, writeGeneratedArtifacts, } from "@intentius/chant/codegen/generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { fetchSchemas } from "../spec/fetch.js";
+import { parseSpecFiles } from "./parse.js";
+import { NamingStrategy } from "./naming.js";
+import { generateLexiconJSON } from "./generate-lexicon.js";
+import { generateTypeScriptDeclarations } from "./generate-typescript.js";
+import { generateRuntimeIndex as coreGenerateRuntimeIndex, } from "@intentius/chant/codegen/generate-runtime-index";
+/**
+ * Run the full k3s generation pipeline.
+ */
+export async function generate(opts = {}) {
+    let pendingResults = [];
+    const config = {
+        fetchSchemas: async (fetchOpts) => {
+            return fetchSchemas(fetchOpts.force);
+        },
+        parseSchema: (_typeName, data) => {
+            const results = parseSpecFiles(data);
+            if (results.length === 0)
+                return null;
+            pendingResults = results.slice(1);
+            return results[0];
+        },
+        createNaming: (results) => new NamingStrategy(results),
+        augmentResults: (results, _opts, log) => {
+            if (pendingResults.length > 0) {
+                results.push(...pendingResults);
+                log(`Added ${pendingResults.length} additional entities from single spec`);
+                pendingResults = [];
+            }
+            for (const r of results) {
+                for (const w of r.warnings ?? [])
+                    log(`warning: ${w}`);
+            }
+            const props = results.map((r) => `${r.resource.typeName}(${r.resource.properties.length})`);
+            log(`Total: ${results.length} k3s entities — ${props.join(", ")}`);
+            return { results };
+        },
+        generateRegistry: (results, naming) => {
+            return generateLexiconJSON(results, naming);
+        },
+        generateTypes: (results, naming) => {
+            return generateTypeScriptDeclarations(results, naming);
+        },
+        generateRuntimeIndex: (results, naming) => {
+            return generateRuntimeIndex(results, naming);
+        },
+    };
+    return generatePipeline(config, opts);
+}
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result, pkgDir) {
+    const baseDir = pkgDir ?? dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    writeGeneratedArtifacts({
+        baseDir,
+        files: {
+            "lexicon-k3s.json": result.lexiconJSON,
+            "index.d.ts": result.typesDTS,
+            "index.ts": result.indexTS,
+            "runtime.ts": `/**\n * Runtime factory constructors — re-exported from core.\n */\nexport { createResource, createProperty } from "@intentius/chant/runtime";\n`,
+        },
+    });
+}
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(results, naming) {
+    const resourceEntries = [];
+    const propertyEntries = [];
+    for (const r of results) {
+        const typeName = r.resource.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        if (r.isProperty) {
+            propertyEntries.push({ tsName, resourceType: typeName });
+        }
+        else {
+            resourceEntries.push({ tsName, resourceType: typeName, attrs: {} });
+        }
+    }
+    return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+        lexiconName: "k3s",
+    });
+}

package/dist/codegen/naming.js

@@ -0,0 +1,34 @@
+/**
+ * k3s naming strategy — flat namespace, one short name per entity.
+ */
+import { NamingStrategy as CoreNamingStrategy, } from "@intentius/chant/codegen/naming";
+import { k3sShortName, k3sServiceName } from "./parse.js";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+const k3sNamingConfig = {
+    priorityNames: {
+        "K3s::Server": "Server",
+        "K3s::Agent": "Agent",
+        "K3s::Registries": "Registries",
+        "K3s::Mirror": "Mirror",
+        "K3s::RegistryConfig": "RegistryConfig",
+        "K3s::RegistryAuth": "RegistryAuth",
+        "K3s::RegistryTLS": "RegistryTLS",
+    },
+    priorityAliases: {},
+    priorityPropertyAliases: {},
+    serviceAbbreviations: {},
+    shortName: k3sShortName,
+    serviceName: k3sServiceName,
+};
+/**
+ * k3s naming strategy.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+    constructor(results) {
+        const inputs = results.map((r) => ({
+            typeName: r.resource.typeName,
+            propertyTypes: r.propertyTypes,
+        }));
+        super(inputs, k3sNamingConfig);
+    }
+}

package/dist/codegen/package.js

@@ -0,0 +1,23 @@
+import { packagePipeline, collectSkills } from "@intentius/chant/codegen/package";
+import { k3sPlugin } from "../plugin.js";
+import { generate } from "./generate.js";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+/**
+ * Package the k3s lexicon for distribution.
+ */
+export async function packageLexicon(options) {
+    const srcDir = moduleSourceDir(import.meta.url);
+    const { spec, stats } = await packagePipeline({
+        generate: (opts) => generate({ verbose: opts?.verbose, force: opts?.force }),
+        buildManifest: () => ({
+            name: "k3s",
+            version: "0.0.1",
+            chantVersion: ">=0.1.0",
+            namespace: "K3s",
+        }),
+        srcDir,
+        collectSkills: () => collectSkills(k3sPlugin.skills?.() ?? []),
+    });
+    console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules`);
+    return { spec, stats };
+}

package/dist/codegen/parse.js

@@ -0,0 +1,313 @@
+/**
+ * k3s CLI flag-definition parser.
+ *
+ * The spec is the pinned Go source of pkg/cli/cmds (#1599): urfave/cli
+ * struct literals carrying Name, Usage, Value and Hidden. This parser
+ * extracts the server and agent flag lists, resolves shared flag-var
+ * references across the fetched files, and produces one entity per config
+ * document k3s consumes:
+ *
+ *   K3s::Server     — /etc/rancher/k3s/config.yaml for `k3s server`
+ *   K3s::Agent      — /etc/rancher/k3s/config.yaml for `k3s agent`
+ *   K3s::Registries — /etc/rancher/k3s/registries.yaml
+ *
+ * registries.yaml has no flag surface; its shape is hand-typed from the
+ * documented structure (docs.k3s.io/installation/private-registry) and
+ * pinned by the same release constant.
+ *
+ * ## The token boundary (#1601)
+ *
+ * `token`, `agent-token` and the deprecated `cluster-secret` are excluded
+ * from the typed surface on purpose. A literal shared secret in an emitted
+ * config.yaml is the #1365 wall; the reference forms (`token-file`,
+ * `agent-token-file`, and the K3S_TOKEN/K3S_TOKEN_FILE env vars at install
+ * time) stay. K3SC001 catches a literal that arrives through a raw prop
+ * anyway.
+ */
+/**
+ * Config keys that must not reach the typed surface.
+ *
+ * - `config`: the --config flag itself — a config file naming its own path
+ *   is not a property.
+ * - `token` / `agent-token` / `cluster-secret`: literal shared secrets;
+ *   see the module doc.
+ * - `help`: urfave built-in.
+ */
+const SKIP_KEYS = new Set(["config", "token", "agent-token", "cluster-secret", "help"]);
+/**
+ * Extract every `&cli.<T>Flag{...}` literal in a Go source text, keyed by
+ * the variable name it is assigned to when there is one.
+ */
+export function extractFlagLiterals(text) {
+    const byVar = new Map();
+    const all = [];
+    const re = /(?:([A-Za-z_][A-Za-z0-9_]*)\s*=\s*)?&cli\.([A-Za-z0-9]+)Flag\{/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const bodyStart = m.index + m[0].length;
+        const body = balancedBody(text, bodyStart);
+        if (body === null)
+            continue;
+        const def = parseFlagBody(m[2], body);
+        if (m[1]) {
+            def.varName = m[1];
+            byVar.set(m[1], def);
+        }
+        all.push(def);
+        re.lastIndex = bodyStart + body.length;
+    }
+    return { byVar, all };
+}
+/** Return the text between an opening brace's position and its matching `}` (exclusive). */
+function balancedBody(text, start) {
+    let depth = 1;
+    let inString = false;
+    for (let i = start; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            if (c === "\\")
+                i++;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"')
+            inString = true;
+        else if (c === "{")
+            depth++;
+        else if (c === "}") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i);
+        }
+    }
+    return null;
+}
+function parseFlagBody(flagType, body) {
+    const def = { flagType, hidden: /(^|\n)\s*Hidden:\s*true\s*,/.test(body) };
+    const name = body.match(/(^|\n)\s*Name:\s*"([^"]+)"/);
+    if (name)
+        def.name = name[2];
+    // Usage may be a multi-line concatenation of string literals; join every
+    // quoted segment between `Usage:` and the next field key at line start.
+    const usageStart = body.search(/(^|\n)\s*Usage:/);
+    if (usageStart >= 0) {
+        const rest = body.slice(usageStart);
+        const end = rest.slice(1).search(/\n\s*[A-Z][A-Za-z]*:\s/);
+        const segment = end >= 0 ? rest.slice(0, end + 1) : rest;
+        const parts = [...segment.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((s) => s[1]);
+        if (parts.length > 0)
+            def.usage = parts.join("").replace(/\\"/g, '"');
+    }
+    const value = body.match(/(^|\n)\s*Value:\s*([^,\n]+)/);
+    if (value) {
+        const raw = value[2].trim();
+        const str = raw.match(/^"([^"]*)"$/);
+        if (str)
+            def.value = str[1];
+        else if (/^[\d.]+$/.test(raw))
+            def.value = raw;
+        else if (/^(true|false)$/.test(raw))
+            def.value = raw;
+        // Composite defaults (cli.NewStringSlice(...), consts) are dropped —
+        // they document poorly as a bare expression.
+    }
+    return def;
+}
+/**
+ * Extract the ordered item list of a `[]cli.Flag{...}` block starting at
+ * `startIndex` (the index of the opening brace + 1). Items are either
+ * bare identifiers (shared flag vars) or inline `&cli.*Flag{...}` literals.
+ */
+export function extractFlagList(text, marker) {
+    const idx = typeof marker === "string" ? text.indexOf(marker) : (text.match(marker)?.index ?? -1);
+    if (idx < 0)
+        return [];
+    const open = text.indexOf("{", idx + (typeof marker === "string" ? marker.length - 1 : 0));
+    if (open < 0)
+        return [];
+    const body = balancedBody(text, open + 1);
+    if (body === null)
+        return [];
+    const items = [];
+    const re = /(?:^|\n)\s*(?:([A-Za-z_][A-Za-z0-9_]*)\s*,|&cli\.([A-Za-z0-9]+)Flag\{)/g;
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        if (m[1]) {
+            items.push(m[1]);
+            continue;
+        }
+        const bodyStart = m.index + m[0].length;
+        const flagBody = balancedBody(body, bodyStart);
+        if (flagBody === null)
+            continue;
+        items.push(parseFlagBody(m[2], flagBody));
+        re.lastIndex = bodyStart + flagBody.length;
+    }
+    return items;
+}
+// ── Flag → property mapping ────────────────────────────────────────
+function tsTypeFor(flagType) {
+    switch (flagType) {
+        case "String":
+            return "string";
+        case "Int":
+        case "Int64":
+        case "Uint":
+        case "Float64":
+            return "number";
+        case "Bool":
+            return "boolean";
+        // config.yaml accepts a single value or a list for slice flags.
+        case "StringSlice":
+            return "string | string[]";
+        case "IntSlice":
+            return "number | number[]";
+        // Durations are Go duration strings ("12h", "5m") in YAML.
+        case "Duration":
+            return "string";
+        default:
+            return "string";
+    }
+}
+function toProperty(def) {
+    if (!def.name || def.hidden)
+        return null;
+    // urfave v2 keeps aliases in Aliases, not the Name — but keep the guard
+    // for a comma form arriving through an older definition.
+    const name = def.name.split(",")[0].trim();
+    if (SKIP_KEYS.has(name))
+        return null;
+    if (def.usage && /\(deprecated/i.test(def.usage))
+        return null;
+    let description = def.usage;
+    if (def.value !== undefined && def.value !== "" && description) {
+        description += ` (default: ${def.value})`;
+    }
+    return {
+        name,
+        tsType: tsTypeFor(def.flagType),
+        required: false,
+        description,
+        constraints: {},
+    };
+}
+function resolveList(items, byVar, warnings, context) {
+    const props = [];
+    const seen = new Set();
+    for (const item of items) {
+        let def;
+        if (typeof item === "string") {
+            def = byVar.get(item);
+            if (!def) {
+                warnings.push(`${context}: unresolved flag reference ${item}`);
+                continue;
+            }
+        }
+        else {
+            def = item;
+        }
+        const prop = toProperty(def);
+        if (!prop || seen.has(prop.name))
+            continue;
+        seen.add(prop.name);
+        props.push(prop);
+    }
+    return props;
+}
+// ── Hand-typed registries.yaml surface ─────────────────────────────
+function prop(name, tsType, description, required = false) {
+    return { name, tsType, required, description, constraints: {} };
+}
+function registriesEntities() {
+    const mk = (typeName, description, properties, isProperty = true) => ({
+        resource: { typeName, description, properties, attributes: [], deprecatedProperties: [] },
+        propertyTypes: [],
+        enums: [],
+        isProperty,
+    });
+    return [
+        mk("K3s::Registries", "Private registry configuration (/etc/rancher/k3s/registries.yaml) for the embedded containerd", [
+            prop("mirrors", "Record<string, Mirror>", "Registry name (or wildcard) to mirror configuration"),
+            prop("configs", "Record<string, RegistryConfig>", "Registry endpoint to auth/TLS configuration"),
+        ], false),
+        mk("K3s::Mirror", "Endpoint rewrites for one registry", [
+            prop("endpoint", "string | string[]", "Mirror endpoint URLs, tried in order"),
+            prop("rewrite", "Record<string, string>", "Image name rewrite rules (regex to replacement)"),
+        ]),
+        mk("K3s::RegistryConfig", "Auth and TLS for one registry endpoint", [
+            prop("auth", "RegistryAuth", "Credentials for the registry"),
+            prop("tls", "RegistryTLS", "TLS settings for the registry"),
+        ]),
+        mk("K3s::RegistryAuth", "Registry credentials — prefer out-of-band credential helpers; K3SC002 flags literals", [
+            prop("username", "string", "Basic auth username"),
+            prop("password", "string", "Basic auth password. A literal here fails K3SC002"),
+            prop("token", "string", "Bearer token. A literal here fails K3SC002"),
+        ]),
+        mk("K3s::RegistryTLS", "Registry TLS settings", [
+            prop("cert_file", "string", "Client certificate path on the node"),
+            prop("key_file", "string", "Client key path on the node"),
+            prop("ca_file", "string", "CA bundle path on the node"),
+            prop("insecure_skip_verify", "boolean", "Skip TLS verification. K3SS002 flags this"),
+        ]),
+    ];
+}
+// ── Entry point ────────────────────────────────────────────────────
+/**
+ * Parse the fetched spec envelope (filename → Go source) into the k3s
+ * entity results.
+ */
+export function parseSpecFiles(data) {
+    const files = JSON.parse(typeof data === "string" ? data : data.toString("utf-8"));
+    const combined = Object.values(files).join("\n");
+    const warnings = [];
+    const { byVar } = extractFlagLiterals(combined);
+    const serverItems = extractFlagList(files["server.go"] ?? "", "var ServerFlags = []cli.Flag{");
+    const serverProps = resolveList(serverItems, byVar, warnings, "ServerFlags");
+    const agentItems = extractFlagList(files["agent.go"] ?? "", /Flags:\s*\[\]cli\.Flag\{/);
+    const agentProps = resolveList(agentItems, byVar, warnings, "AgentFlags");
+    // An agent is nothing without the server it joins. `token-file` stays
+    // optional because the join secret may arrive as K3S_TOKEN_FILE at
+    // install time instead (#1601).
+    for (const p of agentProps) {
+        if (p.name === "server")
+            p.required = true;
+    }
+    const results = [
+        {
+            resource: {
+                typeName: "K3s::Server",
+                description: `k3s server configuration (/etc/rancher/k3s/config.yaml) — every \`k3s server\` flag as a YAML key`,
+                properties: serverProps,
+                attributes: [],
+                deprecatedProperties: [],
+            },
+            propertyTypes: [],
+            enums: [],
+            warnings,
+        },
+        {
+            resource: {
+                typeName: "K3s::Agent",
+                description: `k3s agent configuration (/etc/rancher/k3s/config.yaml) — every \`k3s agent\` flag as a YAML key`,
+                properties: agentProps,
+                attributes: [],
+                deprecatedProperties: [],
+            },
+            propertyTypes: [],
+            enums: [],
+        },
+        ...registriesEntities(),
+    ];
+    return results;
+}
+// ── Helpers ────────────────────────────────────────────────────────
+/** Extract short name: "K3s::Server" → "Server" */
+export function k3sShortName(typeName) {
+    const parts = typeName.split("::");
+    return parts[parts.length - 1];
+}
+/** Extract service name: always "K3s" — the lexicon is a single flat service. */
+export function k3sServiceName(_typeName) {
+    return "K3s";
+}