@intentius/chant-lexicon-k3d 0.0.1

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@intentius/chant-lexicon-k3d",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./*": {
+      "development": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./src/*.ts"
+    },
+    "./op/activities": {
+      "development": "./src/op/activities/index.ts",
+      "types": "./dist/op/activities/index.d.ts",
+      "default": "./src/op/activities/index.ts"
+    },
+    "./lint/post-synth": {
+      "development": "./src/lint/post-synth/index.ts",
+      "types": "./dist/lint/post-synth/index.d.ts",
+      "default": "./src/lint/post-synth/index.ts"
+    },
+    "./manifest": "./dist/manifest.json",
+    "./meta": "./dist/meta.json",
+    "./types": "./dist/types/index.d.ts"
+  },
+  "scripts": {
+    "generate": "npx tsx src/codegen/generate-cli.ts",
+    "validate": "npx tsx src/validate-cli.ts",
+    "docs": "npx tsx src/codegen/docs-cli.ts",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && find dist -type f \\( -name \"*.js\" -o -name \"*.js.map\" \\) -delete",
+    "prepack": "npm run generate && npm run bundle && npm run validate && npm run build",
+    "bundle": "tsx src/package-cli.ts"
+  },
+  "devDependencies": {
+    "@intentius/chant": "*",
+    "tsc-alias": "^1.8.17",
+    "typescript": "^5.9.3",
+    "@types/js-yaml": "^4.0.9"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@intentius/chant": "^0.41.12",
+    "typescript": "^5.9.3"
+  }
+}

package/src/codegen/docs.ts

@@ -0,0 +1,25 @@
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+
+/**
+ * Generate documentation site for the k3d lexicon.
+ */
+export async function generateDocs(options?: { verbose?: boolean }): Promise<void> {
+  const config = {
+    name: "k3d",
+    displayName: "K3d",
+    description: "k3d lexicon documentation",
+    distDir: "./dist",
+    outDir: "./docs",
+    // TODO: Implement service grouping for your provider
+    serviceFromType: (type: string) => type.split("::")[1] ?? type,
+    // TODO: Implement resource documentation URLs
+    resourceTypeUrl: (type: string) => `#${type}`,
+  };
+
+  const result = docsPipeline(config);
+  writeDocsSite(config, result);
+
+  if (options?.verbose) {
+    console.error("Documentation generated");
+  }
+}

package/src/codegen/generate-cli.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for k3d lexicon generation.
+ */
+
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate";
+
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+
+async function main() {
+  const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+  const force = process.argv.includes("--force") || process.argv.includes("-f");
+
+  console.error("Generating k3d lexicon...");
+
+  const result = await generate({ verbose, force });
+  writeGeneratedFiles(result, pkgDir);
+
+  console.error(
+    `Generated ${result.resources} entities, ${result.properties} property types, ${result.enums} enums`,
+  );
+
+  if (result.warnings.length > 0) {
+    console.error(`${result.warnings.length} warnings:`);
+    for (const w of result.warnings) {
+      console.error(`  ${w.file}: ${w.error}`);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error("Generation failed:", err);
+  process.exit(1);
+});

package/src/codegen/generate-lexicon.ts

@@ -0,0 +1,58 @@
+/**
+ * Lexicon JSON generator — produces lexicon-k3d.json with metadata
+ * for all k3d entities.
+ */
+
+import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+import type { K3dParseResult } from "./parse";
+import { k3dShortName } from "./parse";
+import type { NamingStrategy } from "./naming";
+import {
+  buildRegistry,
+  serializeRegistry,
+  type RegistryResource,
+} from "@intentius/chant/codegen/generate-registry";
+
+export interface LexiconEntry {
+  resourceType: string;
+  kind: "resource" | "property";
+  lexicon: "k3d";
+  deprecatedProperties?: string[];
+  constraints?: Record<string, PropertyConstraints>;
+}
+
+/**
+ * Generate the lexicon-k3d.json content.
+ */
+export function generateLexiconJSON(
+  results: K3dParseResult[],
+  naming: NamingStrategy,
+): string {
+  const registryResources: RegistryResource[] = 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<LexiconEntry>(registryResources, naming, {
+    shortName: k3dShortName,
+    buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+      const r = results.find((res) => res.resource.typeName === resource.typeName);
+      return {
+        resourceType: resource.typeName,
+        kind: (r?.isProperty ? "property" : "resource") as "resource" | "property",
+        lexicon: "k3d" as const,
+        ...(r?.resource.deprecatedProperties?.length && { deprecatedProperties: r.resource.deprecatedProperties }),
+        ...(propConstraints && Object.keys(propConstraints).length > 0 && { constraints: propConstraints }),
+      };
+    },
+    buildPropertyEntry: (resourceType, propertyType) => ({
+      resourceType: `${resourceType}.${propertyType}`,
+      kind: "property" as const,
+      lexicon: "k3d" as const,
+    }),
+  });
+
+  return serializeRegistry(entries);
+}

package/src/codegen/generate-typescript.ts

@@ -0,0 +1,102 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with all
+ * k3d entity classes.
+ */
+
+import type { K3dParseResult } from "./parse";
+import { k3dShortName } from "./parse";
+import type { NamingStrategy } from "./naming";
+import { propertyTypeName, extractDefName } from "./naming";
+import {
+  writeResourceClass,
+  writeEnumType,
+  type DtsProperty,
+  type DtsAttribute,
+} from "@intentius/chant/codegen/generate-typescript";
+
+interface ResourceEntry {
+  tsName: string;
+  properties: DtsProperty[];
+  attributes: DtsAttribute[];
+  remap: Map<string, string>;
+}
+
+interface EnumEntry {
+  tsName: string;
+  values: string[];
+}
+
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(
+  results: K3dParseResult[],
+  naming: NamingStrategy,
+): string {
+  const lines: string[] = [];
+  lines.push("// Code generated by chant k3d generate. DO NOT EDIT.");
+
+  const resources: ResourceEntry[] = [];
+  const enums: EnumEntry[] = [];
+
+  for (const r of results) {
+    const typeName = r.resource.typeName;
+    const tsName = naming.resolve(typeName);
+    if (!tsName) continue;
+
+    const shortName = k3dShortName(typeName);
+    const remap = new Map<string, string>();
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      remap.set(pt.name, propertyTypeName(tsName, defName));
+    }
+    for (const e of r.enums) {
+      const defName = extractDefName(e.name, shortName);
+      remap.set(e.name, propertyTypeName(tsName, defName));
+    }
+
+    const dtsProps: DtsProperty[] = r.resource.properties.map((p) => ({
+      name: p.name,
+      type: p.tsType,
+      required: p.required,
+      description: p.description,
+    }));
+    const dtsAttrs: DtsAttribute[] = r.resource.attributes.map((a) => ({
+      name: a.name,
+      type: a.tsType,
+    }));
+
+    resources.push({ tsName, properties: dtsProps, attributes: dtsAttrs, remap });
+
+    for (const alias of naming.aliases(typeName)) {
+      resources.push({ tsName: alias, properties: dtsProps, attributes: dtsAttrs, remap });
+    }
+
+    for (const e of r.enums) {
+      const defName = extractDefName(e.name, shortName);
+      const eName = propertyTypeName(tsName, defName);
+      enums.push({ tsName: eName, values: e.values });
+    }
+  }
+
+  resources.sort((a, b) => a.tsName.localeCompare(b.tsName));
+  enums.sort((a, b) => a.tsName.localeCompare(b.tsName));
+
+  lines.push("");
+  lines.push("// --- k3d Entity classes ---");
+  for (const re of resources) {
+    writeResourceClass(lines, re.tsName, re.properties, re.attributes, re.remap);
+  }
+
+  if (enums.length > 0) {
+    lines.push("");
+    lines.push("// --- Enum types ---");
+    for (const ee of enums) {
+      writeEnumType(lines, ee.tsName, ee.values);
+    }
+  }
+
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/codegen/generate.test.ts

@@ -0,0 +1,154 @@
+import { describe, test, expect } from "vitest";
+import { generate, writeGeneratedFiles } from "./generate";
+import { parseConfigSchema } from "./parse";
+import { loadSchemaFixture, loadSchemaFixtureMap } from "../testdata/load-fixtures";
+
+const PROPERTY_ENTITY_NAMES = [
+  "Metadata",
+  "KubeAPI",
+  "Volume",
+  "Port",
+  "File",
+  "EnvVar",
+  "HostAlias",
+  "Registries",
+  "RegistryCreate",
+  "RegistryProxy",
+  "Options",
+  "K3dOptions",
+  "LoadbalancerOptions",
+  "K3sOptions",
+  "K3sExtraArg",
+  "NodeLabel",
+  "KubeconfigOptions",
+  "RuntimeOptions",
+  "RuntimeLabel",
+  "Ulimit",
+];
+
+describe("generate pipeline", () => {
+  test("generate function is exported and callable", () => {
+    expect(typeof generate).toBe("function");
+  });
+
+  test("writeGeneratedFiles function is exported", () => {
+    expect(typeof writeGeneratedFiles).toBe("function");
+  });
+});
+
+describe("offline fixture pipeline", () => {
+  test("registry parses and covers all entities", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+
+    expect(result.resources).toBe(21);
+    expect(result.warnings).toHaveLength(0);
+
+    const lexicon = JSON.parse(result.lexiconJSON);
+    expect(Object.keys(lexicon)).toHaveLength(21);
+  });
+
+  test("K3d::Cluster is present with kind resource", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+    const lexicon = JSON.parse(result.lexiconJSON);
+
+    expect(lexicon["Cluster"]).toBeDefined();
+    expect(lexicon["Cluster"].resourceType).toBe("K3d::Cluster");
+    expect(lexicon["Cluster"].kind).toBe("resource");
+    expect(lexicon["Cluster"].lexicon).toBe("k3d");
+  });
+
+  test("apiVersion and kind survive as declared Cluster properties", async () => {
+    // The serializer needs these to round-trip into the emitted config;
+    // they must not be stripped by codegen.
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+
+    expect(result.typesDTS).toContain('apiVersion: "k3d.io/v1alpha5";');
+    expect(result.typesDTS).toContain('kind: "Simple";');
+
+    const lexicon = JSON.parse(result.lexiconJSON);
+    expect(lexicon["Cluster"].constraints.apiVersion.enum).toEqual(["k3d.io/v1alpha5"]);
+    expect(lexicon["Cluster"].constraints.kind.enum).toEqual(["Simple"]);
+  });
+
+  test("all property entities are present with kind property", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+    const lexicon = JSON.parse(result.lexiconJSON);
+
+    for (const name of PROPERTY_ENTITY_NAMES) {
+      expect(lexicon[name], name).toBeDefined();
+      expect(lexicon[name].kind, name).toBe("property");
+      expect(lexicon[name].resourceType, name).toBe(`K3d::${name}`);
+    }
+  });
+
+  test("the misplaced additionalProperties key is not emitted anywhere", async () => {
+    // Upstream bug: registries.properties contains a nested
+    // "additionalProperties": false — a naive walk would emit a property
+    // literally named additionalProperties. See parse.ts.
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+
+    expect(result.typesDTS).not.toContain("additionalProperties");
+    expect(result.lexiconJSON).not.toContain("additionalProperties");
+    expect(result.indexTS).not.toContain("additionalProperties");
+  });
+
+  test("type-less timeout with string examples is typed as string", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+    expect(result.typesDTS).toContain("timeout?: string;");
+  });
+
+  test("Cluster cross-references property entity classes", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+
+    expect(result.typesDTS).toContain("volumes?: Volume[];");
+    expect(result.typesDTS).toContain("ports?: Port[];");
+    expect(result.typesDTS).toContain("files?: File[];");
+    expect(result.typesDTS).toContain("env?: EnvVar[];");
+    expect(result.typesDTS).toContain("hostAliases?: HostAlias[];");
+    expect(result.typesDTS).toContain("registries?: Registries;");
+    expect(result.typesDTS).toContain("options?: Options;");
+    expect(result.typesDTS).toContain("kubeAPI?: KubeAPI;");
+    expect(result.typesDTS).toContain("metadata?: Metadata;");
+    // Nested cross-references
+    expect(result.typesDTS).toContain("k3d?: K3dOptions;");
+    expect(result.typesDTS).toContain("extraArgs?: K3sExtraArg[];");
+    expect(result.typesDTS).toContain("proxy?: RegistryProxy;");
+  });
+
+  test("KubeconfigOptions has its boolean flags", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+    expect(result.typesDTS).toContain("updateDefaultKubeconfig?: boolean;");
+    expect(result.typesDTS).toContain("switchCurrentContext?: boolean;");
+  });
+
+  test("nodeFilters resolves through the definition to string[]", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+    expect(result.typesDTS).toContain("nodeFilters?: string[];");
+  });
+
+  test("runtime index exports Cluster as resource and the rest as properties", async () => {
+    const result = await generate({ schemaSource: loadSchemaFixtureMap() });
+
+    expect(result.indexTS).toContain('export const Cluster = createResource("K3d::Cluster", "k3d", {});');
+    for (const name of PROPERTY_ENTITY_NAMES) {
+      expect(result.indexTS).toContain(`export const ${name} = createProperty("K3d::${name}", "k3d");`);
+    }
+  });
+});
+
+describe("parseConfigSchema", () => {
+  test("splits the single schema into 21 entities", () => {
+    const results = parseConfigSchema(loadSchemaFixture());
+    expect(results).toHaveLength(21);
+    expect(results[0].resource.typeName).toBe("K3d::Cluster");
+    expect(results[0].isProperty).toBeUndefined();
+    expect(results.filter((r) => r.isProperty)).toHaveLength(20);
+  });
+
+  test("files item keeps its required properties", () => {
+    const results = parseConfigSchema(loadSchemaFixture());
+    const file = results.find((r) => r.resource.typeName === "K3d::File");
+    const required = file!.resource.properties.filter((p) => p.required).map((p) => p.name);
+    expect(required.sort()).toEqual(["destination", "source"]);
+  });
+});

package/src/codegen/generate.ts

@@ -0,0 +1,139 @@
+/**
+ * k3d generation pipeline — uses core generatePipeline with k3d-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+
+import {
+  generatePipeline,
+  writeGeneratedArtifacts,
+  type GenerateOptions,
+  type GenerateResult,
+  type GeneratePipelineConfig,
+} from "@intentius/chant/codegen/generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { fetchSchemas } from "../spec/fetch";
+import { parseConfigSchema, k3dShortName, type K3dParseResult } from "./parse";
+import { NamingStrategy, propertyTypeName, extractDefName } from "./naming";
+import { generateLexiconJSON } from "./generate-lexicon";
+import { generateTypeScriptDeclarations } from "./generate-typescript";
+import {
+  generateRuntimeIndex as coreGenerateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+} from "@intentius/chant/codegen/generate-runtime-index";
+
+export type { GenerateResult };
+
+/**
+ * Run the full k3d generation pipeline.
+ */
+export async function generate(opts: GenerateOptions = {}): Promise<GenerateResult> {
+  let pendingResults: K3dParseResult[] = [];
+
+  const config: GeneratePipelineConfig<K3dParseResult> = {
+    fetchSchemas: async (fetchOpts) => {
+      return fetchSchemas(fetchOpts.force);
+    },
+
+    parseSchema: (_typeName, data) => {
+      const results = parseConfigSchema(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 schema`);
+        pendingResults = [];
+      }
+      log(`Total: ${results.length} k3d entity schemas`);
+      return { results };
+    },
+
+    generateRegistry: (results, naming) => {
+      return generateLexiconJSON(results, naming as NamingStrategy);
+    },
+
+    generateTypes: (results, naming) => {
+      return generateTypeScriptDeclarations(results, naming as NamingStrategy);
+    },
+
+    generateRuntimeIndex: (results, naming) => {
+      return generateRuntimeIndex(results, naming as NamingStrategy);
+    },
+  };
+
+  return generatePipeline(config, opts);
+}
+
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result: GenerateResult, pkgDir?: string): void {
+  const baseDir = pkgDir ?? dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+  writeGeneratedArtifacts({
+    baseDir,
+    files: {
+      "lexicon-k3d.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: K3dParseResult[],
+  naming: NamingStrategy,
+): string {
+  const resourceEntries: RuntimeIndexEntry[] = [];
+  const propertyEntries: RuntimeIndexPropertyEntry[] = [];
+
+  for (const r of results) {
+    const typeName = r.resource.typeName;
+    const tsName = naming.resolve(typeName);
+    if (!tsName) continue;
+
+    const attrs: Record<string, string> = {};
+
+    if (r.isProperty) {
+      propertyEntries.push({ tsName, resourceType: typeName });
+      for (const alias of naming.aliases(typeName)) {
+        propertyEntries.push({ tsName: alias, resourceType: typeName });
+      }
+    } else {
+      resourceEntries.push({ tsName, resourceType: typeName, attrs });
+      for (const alias of naming.aliases(typeName)) {
+        resourceEntries.push({ tsName: alias, resourceType: typeName, attrs });
+      }
+    }
+
+    const shortName = k3dShortName(typeName);
+    const ptAliases = naming.propertyTypeAliases(typeName);
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      const ptName = propertyTypeName(tsName, defName);
+      const ptType = `${typeName}.${pt.defType}`;
+      propertyEntries.push({ tsName: ptName, resourceType: ptType });
+
+      if (ptAliases) {
+        const aliasName = ptAliases.get(defName);
+        if (aliasName) {
+          propertyEntries.push({ tsName: aliasName, resourceType: ptType });
+        }
+      }
+    }
+  }
+
+  return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+    lexiconName: "k3d",
+  });
+}

package/src/codegen/naming.ts

@@ -0,0 +1,56 @@
+/**
+ * k3d naming strategy — flat namespace, one short name per entity.
+ */
+
+import {
+  NamingStrategy as CoreNamingStrategy,
+  type NamingConfig,
+  type NamingInput,
+} from "@intentius/chant/codegen/naming";
+import { k3dShortName, k3dServiceName, type K3dParseResult } from "./parse";
+
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+
+const k3dNamingConfig: NamingConfig = {
+  priorityNames: {
+    "K3d::Cluster": "Cluster",
+    "K3d::Metadata": "Metadata",
+    "K3d::KubeAPI": "KubeAPI",
+    "K3d::Volume": "Volume",
+    "K3d::Port": "Port",
+    "K3d::File": "File",
+    "K3d::EnvVar": "EnvVar",
+    "K3d::HostAlias": "HostAlias",
+    "K3d::Registries": "Registries",
+    "K3d::RegistryCreate": "RegistryCreate",
+    "K3d::RegistryProxy": "RegistryProxy",
+    "K3d::Options": "Options",
+    "K3d::K3dOptions": "K3dOptions",
+    "K3d::LoadbalancerOptions": "LoadbalancerOptions",
+    "K3d::K3sOptions": "K3sOptions",
+    "K3d::K3sExtraArg": "K3sExtraArg",
+    "K3d::NodeLabel": "NodeLabel",
+    "K3d::KubeconfigOptions": "KubeconfigOptions",
+    "K3d::RuntimeOptions": "RuntimeOptions",
+    "K3d::RuntimeLabel": "RuntimeLabel",
+    "K3d::Ulimit": "Ulimit",
+  },
+  priorityAliases: {},
+  priorityPropertyAliases: {},
+  serviceAbbreviations: {},
+  shortName: k3dShortName,
+  serviceName: k3dServiceName,
+};
+
+/**
+ * k3d naming strategy.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+  constructor(results: K3dParseResult[]) {
+    const inputs: NamingInput[] = results.map((r) => ({
+      typeName: r.resource.typeName,
+      propertyTypes: r.propertyTypes,
+    }));
+    super(inputs, k3dNamingConfig);
+  }
+}

package/src/codegen/package.ts

@@ -0,0 +1,27 @@
+import { packagePipeline } from "@intentius/chant/codegen/package";
+import type { PackagePipelineConfig } from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Package the k3d lexicon for distribution.
+ */
+export async function packageLexicon(options?: { verbose?: boolean; force?: boolean }) {
+  const srcDir = dirname(fileURLToPath(import.meta.url));
+
+  const { spec, stats } = await packagePipeline({
+    generate: (opts) => generate({ verbose: opts?.verbose, force: opts?.force }),
+    buildManifest: () => ({
+      name: "k3d",
+      version: "0.0.1",
+      chantVersion: ">=0.1.0",
+      namespace: "K3d",
+    }),
+    srcDir,
+    collectSkills: () => new Map(),
+  });
+
+  console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules`);
+  return { spec, stats };
+}