@archora/forge-cli 1.3.0 → 2.0.0

package/dist/chunk-RL23SDLM.js

@@ -0,0 +1,4701 @@
+#!/usr/bin/env node
+
+// ../config/dist/index.js
+import { readFile } from "fs/promises";
+import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
+function defineForgeConfig(config) {
+  return config;
+}
+function createForgeConfigPreset(name, config) {
+  if (name === "simple") {
+    return {
+      ...config,
+      output: {
+        root: "./src",
+        generatedDir: "./src/api/generated",
+        featuresDir: "./src/api/features",
+        pagesDir: "./src/pages",
+        mocksDir: "./src/api/mocks",
+        ...config.output
+      },
+      target: {
+        framework: "neutral",
+        language: "typescript",
+        query: "promise",
+        ui: "metadata",
+        architecture: "simple",
+        ...config.target
+      }
+    };
+  }
+  if (name === "monorepo" && config.inputs) {
+    return {
+      ...config,
+      inputs: config.inputs.map((input) => ({
+        ...input,
+        output: {
+          generatedDir: `./src/generated/${input.name}`,
+          ...input.output
+        }
+      }))
+    };
+  }
+  return {
+    ...config,
+    output: {
+      root: "./src",
+      generatedDir: "./src/shared/api/generated",
+      featuresDir: "./src/features",
+      pagesDir: "./src/pages",
+      mocksDir: "./src/shared/mocks",
+      ...config.output
+    },
+    target: {
+      framework: "neutral",
+      language: "typescript",
+      query: "promise",
+      ui: "metadata",
+      architecture: "feature-sliced",
+      ...config.target
+    }
+  };
+}
+function resolveForgeConfig(config) {
+  return {
+    input: config.input ?? config.inputs?.[0]?.path ?? "",
+    inputs: config.inputs ?? [],
+    output: {
+      root: config.output?.root ?? "./src",
+      generatedDir: config.output?.generatedDir ?? "./src/shared/api/generated",
+      featuresDir: config.output?.featuresDir ?? "./src/features",
+      pagesDir: config.output?.pagesDir ?? "./src/pages",
+      mocksDir: config.output?.mocksDir ?? "./src/shared/mocks"
+    },
+    target: {
+      framework: config.target?.framework ?? "neutral",
+      language: config.target?.language ?? "typescript",
+      query: config.target?.query ?? "promise",
+      ui: config.target?.ui ?? "metadata",
+      architecture: config.target?.architecture ?? "feature-sliced"
+    },
+    validation: config.validation ?? "none",
+    mocks: {
+      adapter: config.mocks?.adapter ?? "simple"
+    },
+    schemaRequest: {
+      headers: interpolateHeaders(config.schemaRequest?.headers ?? {}),
+      timeoutMs: config.schemaRequest?.timeoutMs ?? 3e4
+    },
+    plugins: config.plugins ?? [],
+    templates: config.templates ?? {},
+    uiAdapter: config.uiAdapter ?? {},
+    naming: {
+      resourceCase: config.naming?.resourceCase ?? "kebab",
+      fileCase: config.naming?.fileCase ?? "pascal",
+      componentPrefix: config.naming?.componentPrefix ?? "",
+      generatedSuffix: config.naming?.generatedSuffix ?? ".generated"
+    },
+    ci: {
+      failOnWarnings: config.ci?.failOnWarnings ?? false,
+      failOnUnsupportedFeatures: config.ci?.failOnUnsupportedFeatures ?? true,
+      failOnMissingSchemas: config.ci?.failOnMissingSchemas ?? false,
+      failOnDrift: config.ci?.failOnDrift ?? true,
+      minHealthScore: config.ci?.minHealthScore
+    },
+    resources: config.resources ?? {},
+    overwrite: {
+      generated: config.overwrite?.generated ?? true,
+      custom: config.overwrite?.custom ?? false
+    }
+  };
+}
+function interpolateHeaders(headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key,
+      value.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => process.env[name] ?? "")
+    ])
+  );
+}
+async function loadForgeConfig(filePath) {
+  if (filePath.endsWith(".json")) {
+    return parseConfig(JSON.parse(await readFile(filePath, "utf8")));
+  }
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  try {
+    const loaded = await jiti.import(pathToFileURL(filePath).href, { default: true });
+    return parseConfig(loaded);
+  } catch (error) {
+    const source = await readFile(filePath, "utf8");
+    const fallback = loadConfigFromSource(source);
+    if (fallback) {
+      return fallback;
+    }
+    throw error;
+  }
+}
+function parseConfig(value) {
+  if (!isForgeConfig(value)) {
+    throw new Error("Invalid Archora Forge config: `input` must be a string or `inputs` must contain at least one schema entry.");
+  }
+  return value;
+}
+function isForgeConfig(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if ("input" in value && value.input !== void 0 && typeof value.input !== "string") return false;
+  if ("input" in value && typeof value.input === "string") return true;
+  return "inputs" in value && Array.isArray(value.inputs) && value.inputs.length > 0 && value.inputs.every((input) => isInputEntry(input));
+}
+function isInputEntry(value) {
+  return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "path" in value && typeof value.path === "string";
+}
+function loadConfigFromSource(source) {
+  const match = source.match(/export\s+default\s+defineForgeConfig\(([\s\S]*)\)\s*;?\s*$/);
+  if (!match?.[1]) {
+    return null;
+  }
+  const createConfig = new Function("defineForgeConfig", `return defineForgeConfig(${match[1]})`);
+  return parseConfig(createConfig(defineForgeConfig));
+}
+
+// src/schema-request.ts
+function parseSchemaRequestHeaders(value) {
+  const entries = Array.isArray(value) ? value : value ? [value] : [];
+  return Object.fromEntries(entries.map(parseSchemaRequestHeader));
+}
+function parseSchemaRequestHeader(value) {
+  const separator = findHeaderSeparator(value);
+  if (separator === -1) {
+    throw new Error(`Invalid schema header "${value}". Expected "name:value" or "name=value".`);
+  }
+  const name = value.slice(0, separator).trim();
+  const headerValue = value.slice(separator + 1).trim();
+  if (!name || !headerValue) {
+    throw new Error(`Invalid schema header "${value}". Header name and value are required.`);
+  }
+  return [name, headerValue];
+}
+function findHeaderSeparator(value) {
+  const colon = value.indexOf(":");
+  const equals = value.indexOf("=");
+  if (colon === -1) return equals;
+  if (equals === -1) return colon;
+  return Math.min(colon, equals);
+}
+
+// src/config.ts
+import { access } from "fs/promises";
+import { dirname, isAbsolute, join, resolve } from "path";
+var configNames = ["archora-forge.config.ts", "archora-forge.config.js", "archora-forge.config.mjs", "archora-forge.config.json"];
+async function loadCliConfig(schema, options = {}) {
+  const configPath = options.config ? resolve(options.config) : await discoverConfig(process.cwd());
+  const loaded = configPath ? await loadForgeConfig(configPath) : { input: schema ?? "" };
+  const input = schema ?? loaded.input;
+  if (!input) {
+    throw new Error("OpenAPI schema path is required when no Archora Forge config is found.");
+  }
+  const inputBaseDir = configPath ? dirname(configPath) : process.cwd();
+  const absoluteInput = isRemoteInput(input) ? input : isAbsolute(input) ? input : resolve(inputBaseDir, input);
+  const baseDir = configPath ? dirname(configPath) : isRemoteInput(absoluteInput) ? process.cwd() : dirname(absoluteInput);
+  const config = resolveForgeConfig({
+    ...loaded,
+    input,
+    schemaRequest: mergeSchemaRequestHeaders(loaded.schemaRequest, options.schemaHeader),
+    output: {
+      ...loaded.output,
+      generatedDir: resolveOutput(baseDir, loaded.output?.generatedDir),
+      featuresDir: resolveOutput(baseDir, loaded.output?.featuresDir),
+      pagesDir: resolveOutput(baseDir, loaded.output?.pagesDir),
+      mocksDir: resolveOutput(baseDir, loaded.output?.mocksDir)
+    },
+    overwrite: {
+      ...loaded.overwrite,
+      custom: options.force ?? loaded.overwrite?.custom
+    }
+  });
+  return {
+    config,
+    schema: absoluteInput,
+    configPath,
+    cwd: baseDir
+  };
+}
+async function loadCliConfigSet(schema, options = {}) {
+  if (schema) return [await loadCliConfig(schema, options)];
+  const configPath = options.config ? resolve(options.config) : await discoverConfig(process.cwd());
+  if (!configPath) return [await loadCliConfig(schema, options)];
+  const loaded = await loadForgeConfig(configPath);
+  if (!loaded.inputs || loaded.inputs.length === 0) return [await loadCliConfig(schema, options)];
+  const baseDir = dirname(configPath);
+  return loaded.inputs.map((input) => {
+    const absoluteInput = isRemoteInput(input.path) ? input.path : isAbsolute(input.path) ? input.path : resolve(baseDir, input.path);
+    const output = {
+      ...loaded.output,
+      ...input.output
+    };
+    const config = resolveForgeConfig({
+      ...loaded,
+      input: input.path,
+      schemaRequest: mergeSchemaRequestHeaders(loaded.schemaRequest, options.schemaHeader),
+      output: {
+        ...output,
+        generatedDir: resolveOutput(baseDir, output.generatedDir),
+        featuresDir: resolveOutput(baseDir, output.featuresDir),
+        pagesDir: resolveOutput(baseDir, output.pagesDir),
+        mocksDir: resolveOutput(baseDir, output.mocksDir)
+      },
+      overwrite: {
+        ...loaded.overwrite,
+        custom: options.force ?? loaded.overwrite?.custom
+      }
+    });
+    return {
+      name: input.name,
+      config,
+      schema: absoluteInput,
+      configPath,
+      cwd: baseDir
+    };
+  });
+}
+async function discoverConfig(cwd) {
+  for (const name of configNames) {
+    const path = join(cwd, name);
+    try {
+      await access(path);
+      return path;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function resolveOutput(baseDir, value) {
+  if (!value) return void 0;
+  return isAbsolute(value) ? value : value.startsWith("./") ? value : join(baseDir, value);
+}
+function mergeSchemaRequestHeaders(schemaRequest, schemaHeader) {
+  return {
+    ...schemaRequest,
+    headers: {
+      ...schemaRequest?.headers,
+      ...parseSchemaRequestHeaders(schemaHeader)
+    }
+  };
+}
+function isRemoteInput(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+
+// src/report-file.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+async function writeReportFile(path, content) {
+  const resolvedPath = resolve2(path);
+  await mkdir(dirname2(resolvedPath), { recursive: true });
+  await writeFile(resolvedPath, `${content.trimEnd()}
+`, "utf8");
+  return resolvedPath;
+}
+
+// src/ui/logger.ts
+import pc from "picocolors";
+function printPendingPhaseMessage(command, detail) {
+  console.log(pc.bold("Archora Forge"));
+  console.log(`${pc.cyan(command)} is wired, but ${detail}.`);
+}
+var logger = {
+  title() {
+    console.log(pc.bold("Archora Forge"));
+  },
+  line(message = "") {
+    console.log(message);
+  },
+  success(message) {
+    console.log(`${pc.green("\u2713")} ${message}`);
+  },
+  warn(message) {
+    console.log(`${pc.yellow("-")} ${message}`);
+  },
+  error(message) {
+    console.error(`${pc.red("x")} ${message}`);
+  }
+};
+
+// src/html-report.ts
+function createHtmlReport(title, payload) {
+  const diagnostics = payload.diagnostics ?? [];
+  const drift = payload.drift ?? [];
+  const failedChecks = payload.failedChecks ?? [];
+  const healthScore = payload.healthScore ?? payload.health?.score ?? minDefined((payload.schemas ?? []).map((schema) => schema.healthScore ?? schema.health?.score));
+  const resources = typeof payload.resources === "number" ? payload.resources : payload.resourceCount ?? payload.resources?.length;
+  const status = payload.ok === false ? "failed" : "passed";
+  const generatedFiles = payload.generatedFiles ?? sumDefined((payload.schemas ?? []).map((schema) => schema.generatedFiles));
+  const topAffectedResources = collectAffectedResources(payload);
+  const diagnosticsByCode = groupBy(diagnostics, (diagnostic) => diagnostic.code ?? "diagnostic");
+  const diagnosticsBySeverity = groupBy(diagnostics, (diagnostic) => diagnostic.severity ?? "warning");
+  const driftByCategory = groupBy(drift, (entry) => fileCategory(entry.path ?? ""));
+  const unsupportedDiagnostics = diagnostics.filter((diagnostic) => (diagnostic.code ?? "").startsWith("unsupported-"));
+  const ciSummary = [
+    `Status: ${status}`,
+    `Health: ${healthScore ?? "n/a"}`,
+    `Resources: ${resources ?? "n/a"}`,
+    `Generated files: ${generatedFiles ?? "n/a"}`,
+    `Diagnostics: ${diagnostics.length}`,
+    `Drift: ${drift.length}`,
+    `Failed checks: ${failedChecks.length > 0 ? failedChecks.join(", ") : "none"}`
+  ].join("\n");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    :root { color-scheme: light; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #17202a; background: #f6f7f9; }
+    body { margin: 0; }
+    main { max-width: 1120px; margin: 0 auto; padding: 32px 20px 48px; }
+    h1, h2, h3 { margin: 0; line-height: 1.2; }
+    h1 { font-size: 30px; }
+    h2 { margin-top: 28px; font-size: 18px; }
+    p { margin: 8px 0 0; color: #526071; }
+    .top { display: flex; justify-content: space-between; gap: 20px; align-items: flex-start; }
+    .badge { display: inline-flex; align-items: center; border-radius: 999px; padding: 6px 10px; font-weight: 700; font-size: 13px; text-transform: uppercase; letter-spacing: .04em; }
+    .passed { color: #0b6b3a; background: #dff7ea; }
+    .failed { color: #9d2a1f; background: #ffe2dd; }
+    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; margin-top: 18px; }
+    .metric, .card { background: #fff; border: 1px solid #dfe4ea; border-radius: 8px; padding: 14px; box-shadow: 0 1px 2px rgba(23, 32, 42, .04); }
+    .metric strong { display: block; font-size: 24px; color: #17202a; }
+    .metric span, .muted { color: #667386; font-size: 13px; }
+    table { width: 100%; border-collapse: collapse; margin-top: 12px; background: #fff; border: 1px solid #dfe4ea; border-radius: 8px; overflow: hidden; }
+    th, td { text-align: left; padding: 10px 12px; border-bottom: 1px solid #edf0f3; vertical-align: top; font-size: 14px; }
+    th { background: #f0f3f6; color: #3f4b59; font-size: 12px; text-transform: uppercase; letter-spacing: .04em; }
+    tr:last-child td { border-bottom: 0; }
+    code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; background: #eef2f6; padding: 2px 4px; border-radius: 4px; }
+    .warning { color: #8a5a00; }
+    .error { color: #a32116; }
+    .summary { display: grid; grid-template-columns: minmax(0, 1.3fr) minmax(280px, .7fr); gap: 12px; margin-top: 18px; }
+    .summary ul { margin: 10px 0 0; padding-left: 18px; }
+    .summary li { margin: 6px 0; }
+    .pill-list { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 10px; }
+    .pill { display: inline-flex; gap: 6px; align-items: center; border: 1px solid #dfe4ea; border-radius: 999px; padding: 5px 9px; background: #f8fafc; font-size: 12px; }
+    details { background: #fff; border: 1px solid #dfe4ea; border-radius: 8px; margin-top: 12px; overflow: hidden; }
+    summary { cursor: pointer; padding: 12px 14px; font-weight: 700; background: #f8fafc; }
+    pre { white-space: pre-wrap; word-break: break-word; background: #17202a; color: #f6f7f9; border-radius: 8px; padding: 12px; font-size: 12px; margin: 12px 0 0; }
+    .empty { background: #fff; border: 1px dashed #cad2dc; border-radius: 8px; padding: 16px; color: #667386; margin-top: 12px; }
+    .footer { margin-top: 32px; font-size: 12px; color: #7a8797; }
+  </style>
+</head>
+<body>
+<main>
+  <section class="top">
+    <div>
+      <h1>${escapeHtml(title)}</h1>
+      <p>${escapeHtml(payload.schema ?? "Archora Forge CLI report")}</p>
+    </div>
+    <span class="badge ${status}">${status}</span>
+  </section>
+
+  <section class="grid">
+    ${metric("Health", healthScore ?? "n/a")}
+    ${metric("Diagnostics", diagnostics.length)}
+    ${metric("Failed checks", failedChecks.length)}
+    ${metric("Drift", drift.length)}
+    ${metric("Resources", resources ?? "n/a")}
+    ${metric("Generated files", generatedFiles ?? "n/a")}
+  </section>
+
+  ${renderExecutiveSummary({ status, healthScore, resources, generatedFiles, diagnostics, drift, failedChecks, topAffectedResources })}
+  ${renderReadiness(payload.readiness)}
+  ${renderCiSummary(ciSummary)}
+  ${renderGeneratedFileCategories(driftByCategory, payload.files, generatedFiles)}
+  ${renderDiagnosticGroups(diagnosticsBySeverity, diagnosticsByCode)}
+  ${renderUnsupportedOperations(unsupportedDiagnostics)}
+  ${renderAffectedResources(topAffectedResources)}
+  ${renderResourceExplorer(payload.resourceExplorer)}
+  ${renderCoverageMatrix(payload.coverage)}
+  ${renderImpactCenter(payload)}
+  ${renderContractDiffSummary(payload)}
+  ${renderSchemas(payload.schemas)}
+  ${renderFailedChecks(failedChecks)}
+  ${renderDiagnostics(diagnostics)}
+  ${renderDrift(drift)}
+
+  <p class="footer">Generated by Archora Forge CLI. Commit this report as a CI artifact or attach it to release validation notes.</p>
+</main>
+</body>
+</html>
+`;
+}
+function renderReadiness(readiness) {
+  if (!readiness) return "";
+  return `<section class="summary">
+    <div class="card">
+      <h2>Pilot Readiness</h2>
+      <p>Status: <strong>${escapeHtml(readiness.status ?? "n/a")}</strong></p>
+      ${readiness.gate ? `<p>Gate: <strong>${escapeHtml(readiness.gate.result ?? "n/a")}</strong></p>
+      <p>Recommended CI mode: <strong>${escapeHtml(readiness.gate.recommendedCiMode ?? "n/a")}</strong></p>
+      <p>${escapeHtml(readiness.gate.reason ?? "")}</p>` : ""}
+      <p>${escapeHtml(readiness.decision ?? "")}</p>
+    </div>
+    <div class="card">
+      <h2>Next Actions</h2>
+      ${renderSimpleList(readiness.nextActions ?? [], "No action required.")}
+    </div>
+    <div class="card">
+      <h2>Blockers</h2>
+      ${renderSimpleList(readiness.blockers ?? [], "No blockers.")}
+    </div>
+    <div class="card">
+      <h2>Warnings</h2>
+      ${renderSimpleList(readiness.warnings ?? [], "No warnings.")}
+    </div>
+    ${readiness.reviewerChecklist ? `<div class="card">
+      <h2>Reviewer Checklist</h2>
+      ${renderSimpleList(readiness.reviewerChecklist, "No reviewer checklist.")}
+    </div>` : ""}
+  </section>`;
+}
+function renderSimpleList(items, empty) {
+  const values = items.length > 0 ? items : [empty];
+  return `<ul>${values.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`;
+}
+function renderExecutiveSummary(input) {
+  const health = input.healthScore ?? "n/a";
+  const mainFinding = input.status === "passed" ? "Generated output is up to date for the configured checks." : "Generated output needs attention before this schema should pass CI.";
+  const affected = input.topAffectedResources.length > 0 ? input.topAffectedResources.slice(0, 5).map((item) => `${item.name} (${item.count})`).join(", ") : "none";
+  return `<section class="summary">
+    <div class="card">
+      <h2>Executive Summary</h2>
+      <ul>
+        <li>${escapeHtml(mainFinding)}</li>
+        <li>Health score: <strong>${escapeHtml(String(health))}</strong>.</li>
+        <li>Resources: <strong>${escapeHtml(String(input.resources ?? "n/a"))}</strong>; generated files: <strong>${escapeHtml(String(input.generatedFiles ?? "n/a"))}</strong>.</li>
+        <li>Diagnostics: <strong>${input.diagnostics.length}</strong>; drift entries: <strong>${input.drift.length}</strong>.</li>
+        <li>Top affected resources: ${escapeHtml(affected)}.</li>
+      </ul>
+    </div>
+    <div class="card">
+      <h2>Decision Signal</h2>
+      <p>${input.failedChecks.length === 0 ? "Ready for CI under the current policy." : `Blocked by: ${escapeHtml(input.failedChecks.join(", "))}.`}</p>
+    </div>
+  </section>`;
+}
+function renderCiSummary(summary) {
+  return `<section><h2>Copyable CI Summary</h2><pre>${escapeHtml(summary)}</pre></section>`;
+}
+function renderGeneratedFileCategories(groupedDrift, files, generatedFiles) {
+  const pills = [
+    generatedFiles !== void 0 ? ["total generated", generatedFiles] : null,
+    files?.create !== void 0 ? ["create", files.create] : null,
+    files?.update !== void 0 ? ["update", files.update] : null,
+    files?.protected !== void 0 ? ["protected", files.protected] : null,
+    ...[...groupedDrift.entries()].map(([name, entries]) => [name, entries.length])
+  ].filter((item) => Boolean(item));
+  if (pills.length === 0) return '<section><h2>Generated Files by Category</h2><div class="empty">No generated file summary available.</div></section>';
+  return `<section><h2>Generated Files by Category</h2><div class="pill-list">${pills.map(([name, count]) => `<span class="pill"><strong>${escapeHtml(String(count))}</strong>${escapeHtml(name)}</span>`).join("")}</div></section>`;
+}
+function renderDiagnosticGroups(bySeverity, byCode) {
+  if (bySeverity.size === 0 && byCode.size === 0) return '<section><h2>Diagnostics Grouped</h2><div class="empty">No diagnostics to group.</div></section>';
+  return `<section><h2>Diagnostics Grouped</h2>
+    <details open><summary>By severity</summary><div class="pill-list">${renderGroupPills(bySeverity)}</div></details>
+    <details><summary>By code</summary><div class="pill-list">${renderGroupPills(byCode)}</div></details>
+  </section>`;
+}
+function renderUnsupportedOperations(diagnostics) {
+  if (diagnostics.length === 0) return '<section><h2>Unsupported Operations</h2><div class="empty">No unsupported operations detected.</div></section>';
+  const grouped = groupBy(diagnostics, (diagnostic) => diagnostic.code ?? "unsupported");
+  return `<section><h2>Unsupported Operations</h2><div class="pill-list">${renderGroupPills(grouped)}</div></section>`;
+}
+function renderAffectedResources(resources) {
+  if (resources.length === 0) return '<section><h2>Top Affected Resources</h2><div class="empty">No affected resources detected.</div></section>';
+  return `<section><h2>Top Affected Resources</h2><div class="pill-list">${resources.slice(0, 20).map((item) => `<span class="pill"><strong>${item.count}</strong>${escapeHtml(item.name)}</span>`).join("")}</div></section>`;
+}
+function renderResourceExplorer(resources) {
+  if (!resources) return "";
+  if (resources.length === 0) return '<section><h2>Resource Explorer</h2><div class="empty">No resources detected.</div></section>';
+  const cards = resources.slice(0, 50).map((resource) => {
+    const operations = (resource.operations ?? []).slice(0, 20).map((operation) => `<li><code>${escapeHtml(`${operation.method?.toUpperCase() ?? ""} ${operation.path ?? ""}`.trim())}</code> ${escapeHtml(operation.id ?? "")} <span class="muted">${escapeHtml(operation.kind ?? "")}</span></li>`).join("");
+    const files = (resource.generatedFiles ?? []).slice(0, 12).map((file) => `<li><code>${escapeHtml(file)}</code></li>`).join("");
+    return `<div class="card">
+        <h3>${escapeHtml(resource.name ?? "resource")}</h3>
+        <p>${escapeHtml(String(resource.operations?.length ?? 0))} operations; ${escapeHtml(String(resource.generatedFiles?.length ?? 0))} generated files.</p>
+        ${operations ? `<details><summary>Operations</summary><ul>${operations}</ul></details>` : ""}
+        ${files ? `<details><summary>Generated files</summary><ul>${files}</ul></details>` : ""}
+      </div>`;
+  }).join("");
+  return `<section><h2>Resource Explorer</h2><div class="summary">${cards}</div></section>`;
+}
+function renderCoverageMatrix(coverage) {
+  if (!coverage) return "";
+  return `<section>
+    <h2>Schema Coverage Matrix</h2>
+    <div class="grid">
+      ${metric("Operations", coverage.operations?.total ?? "n/a")}
+      ${metric("Generated operations", coverage.operations?.generated ?? "n/a")}
+      ${metric("Fallback cases", coverage.cases?.fallback ?? "n/a")}
+      ${metric("Diagnostic-only cases", coverage.cases?.diagnosticOnly ?? "n/a")}
+      ${metric("Schemas", coverage.schemas?.total ?? "n/a")}
+      ${metric("Skipped operations", coverage.cases?.skipped ?? "n/a")}
+    </div>
+    <details open><summary>Operation types</summary><div class="pill-list">${renderRecordPills(coverage.operations?.byKind)}</div></details>
+    <details><summary>Request shapes</summary><div class="pill-list">${renderRecordPills(coverage.operations?.byRequestShape)}</div></details>
+    <details><summary>Response shapes</summary><div class="pill-list">${renderRecordPills(coverage.operations?.byResponseShape)}</div></details>
+    <details><summary>Unsupported schema constructs</summary><div class="pill-list">${renderRecordPills(coverage.schemas?.unsupportedConstructs)}</div></details>
+  </section>`;
+}
+function renderContractDiffSummary(payload) {
+  if (!payload.changes?.length && !payload.affectedResources?.length) {
+    return '<section><h2>Contract Diff Summary</h2><div class="empty">No contract diff changes in this report.</div></section>';
+  }
+  const breaking = payload.changes?.filter((change) => change.severity === "breaking").length ?? 0;
+  const nonBreaking = (payload.changes?.length ?? 0) - breaking;
+  return `<section><h2>Contract Diff Summary</h2><div class="card"><p>Breaking changes: <strong>${breaking}</strong>; non-breaking changes: <strong>${nonBreaking}</strong>; affected resources: <strong>${payload.affectedResources?.length ?? 0}</strong>.</p></div></section>`;
+}
+function renderImpactCenter(payload) {
+  if (!payload.decision && !payload.summary && !payload.migrationHints?.length && !payload.prSummary) return "";
+  return `<section>
+    <h2>Frontend Impact Center</h2>
+    <div class="summary">
+      <div class="card">
+        <h2>Decision</h2>
+        <p>Status: <strong>${escapeHtml(payload.decision?.status ?? "n/a")}</strong></p>
+        <p>Merge risk: <strong>${escapeHtml(payload.decision?.mergeRisk ?? "n/a")}</strong></p>
+        <p>${escapeHtml(payload.decision?.reason ?? "")}</p>
+      </div>
+      <div class="card">
+        <h2>Impact Counts</h2>
+        <ul>
+          <li>Breaking: <strong>${escapeHtml(String(payload.summary?.breaking ?? 0))}</strong></li>
+          <li>Warnings: <strong>${escapeHtml(String(payload.summary?.warnings ?? 0))}</strong></li>
+          <li>Non-breaking: <strong>${escapeHtml(String(payload.summary?.nonBreaking ?? 0))}</strong></li>
+          <li>Affected files: <strong>${escapeHtml(String(payload.affectedFiles?.length ?? 0))}</strong></li>
+        </ul>
+      </div>
+    </div>
+    <details open><summary>PR Summary</summary><pre>${escapeHtml(payload.prSummary ?? "")}</pre></details>
+    <details open><summary>Migration Hints</summary>${renderSimpleList(payload.migrationHints ?? [], "No migration hints.")}</details>
+    <details><summary>Impacted Surface</summary>
+      <div class="card">
+        <p>Operation IDs: ${escapeHtml(payload.impactedSurface?.operationIds?.join(", ") || "none")}</p>
+        <p>Client methods: ${escapeHtml(payload.impactedSurface?.clientMethods?.join(", ") || "none")}</p>
+        <p>Query hooks: ${escapeHtml(payload.impactedSurface?.queryHooks?.join(", ") || "none")}</p>
+      </div>
+    </details>
+    ${renderSourceUsages(payload.sourceUsages)}
+  </section>`;
+}
+function renderSourceUsages(usages) {
+  if (!usages) return "";
+  if (usages.length === 0) return '<details open><summary>Source Usage</summary><div class="empty">No impacted source usages found.</div></details>';
+  const rows = usages.slice(0, 100).map((usage) => `<tr><td><code>${escapeHtml(`${usage.path ?? ""}${usage.lines?.length ? `:${usage.lines.join(",")}` : ""}`)}</code></td><td>${escapeHtml((usage.matches ?? []).join(", "))}</td></tr>`).join("");
+  return `<details open><summary>Source Usage</summary><table><thead><tr><th>File</th><th>Matches</th></tr></thead><tbody>${rows}</tbody></table></details>`;
+}
+function renderSchemas(schemas) {
+  if (!schemas?.length) return "";
+  const rows = schemas.map((schema) => {
+    const healthScore = schema.healthScore ?? schema.health?.score ?? "n/a";
+    const resources = typeof schema.resources === "number" ? schema.resources : schema.resourceCount ?? schema.resources?.length ?? "n/a";
+    return `<tr><td>${escapeHtml(schema.name ?? "default")}</td><td><code>${escapeHtml(schema.schema ?? "")}</code></td><td>${escapeHtml(String(healthScore))}</td><td>${escapeHtml(String(resources))}</td><td>${escapeHtml(String(schema.diagnosticsCount ?? "n/a"))}</td></tr>`;
+  }).join("");
+  return `<section><h2>Schemas</h2><table><thead><tr><th>Name</th><th>Schema</th><th>Health</th><th>Resources</th><th>Diagnostics</th></tr></thead><tbody>${rows}</tbody></table></section>`;
+}
+function renderFailedChecks(failedChecks) {
+  if (failedChecks.length === 0) return '<section><h2>Failed Checks</h2><div class="empty">No failed checks.</div></section>';
+  return `<section><h2>Failed Checks</h2><div class="card">${failedChecks.map((check) => `<code>${escapeHtml(check)}</code>`).join(" ")}</div></section>`;
+}
+function renderDiagnostics(diagnostics) {
+  if (diagnostics.length === 0) return '<section><h2>Diagnostics</h2><div class="empty">No diagnostics.</div></section>';
+  const rows = diagnostics.slice(0, 200).map(
+    (diagnostic) => `<tr><td class="${escapeHtml(diagnostic.severity ?? "warning")}">${escapeHtml(diagnostic.severity ?? "warning")}</td><td><code>${escapeHtml(diagnostic.code ?? "diagnostic")}</code></td><td>${escapeHtml(diagnostic.location ?? "")}</td><td>${escapeHtml(diagnostic.message ?? "")}${diagnostic.suggestion ? `<p>${escapeHtml(diagnostic.suggestion)}</p>` : ""}</td></tr>`
+  ).join("");
+  return `<section><h2>Diagnostics</h2><table><thead><tr><th>Severity</th><th>Code</th><th>Location</th><th>Message</th></tr></thead><tbody>${rows}</tbody></table></section>`;
+}
+function renderDrift(drift) {
+  if (drift.length === 0) return '<section><h2>Drift</h2><div class="empty">No drift detected.</div></section>';
+  const rows = drift.map((entry) => `<tr><td><code>${escapeHtml(entry.path ?? "")}</code></td><td>${escapeHtml(entry.kind ?? "")}</td></tr>`).join("");
+  return `<section><h2>Drift</h2><table><thead><tr><th>Path</th><th>Kind</th></tr></thead><tbody>${rows}</tbody></table></section>`;
+}
+function metric(label, value) {
+  return `<div class="metric"><strong>${escapeHtml(String(value))}</strong><span>${escapeHtml(label)}</span></div>`;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function minDefined(values) {
+  const defined = values.filter((value) => value !== void 0);
+  return defined.length > 0 ? Math.min(...defined) : void 0;
+}
+function sumDefined(values) {
+  const defined = values.filter((value) => value !== void 0);
+  return defined.length > 0 ? defined.reduce((total, value) => total + value, 0) : void 0;
+}
+function groupBy(items, key) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = key(item);
+    groups.set(group, [...groups.get(group) ?? [], item]);
+  }
+  return groups;
+}
+function renderGroupPills(groups) {
+  return [...groups.entries()].sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0])).map(([name, items]) => `<span class="pill"><strong>${items.length}</strong>${escapeHtml(name)}</span>`).join("");
+}
+function renderRecordPills(record) {
+  if (!record || Object.keys(record).length === 0) return '<span class="muted">none</span>';
+  return Object.entries(record).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map(([name, count]) => `<span class="pill"><strong>${count}</strong>${escapeHtml(name)}</span>`).join("");
+}
+function collectAffectedResources(payload) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const resource of payload.affectedResources ?? []) {
+    counts.set(resource, (counts.get(resource) ?? 0) + 1);
+  }
+  for (const diagnostic of payload.diagnostics ?? []) {
+    const resource = resourceFromLocation(diagnostic.location);
+    if (resource) counts.set(resource, (counts.get(resource) ?? 0) + 1);
+  }
+  for (const entry of payload.drift ?? []) {
+    const resource = resourceFromPath(entry.path);
+    if (resource) counts.set(resource, (counts.get(resource) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([name, count]) => ({ name, count })).sort((left, right) => right.count - left.count || left.name.localeCompare(right.name));
+}
+function resourceFromLocation(location) {
+  const path = location?.match(/[A-Z]+\s+([^\s]+)/)?.[1];
+  if (!path) return null;
+  return path.split("/").filter(Boolean).filter((segment) => !segment.startsWith("{") && !/^v\d+$/i.test(segment)).at(-1) ?? null;
+}
+function resourceFromPath(path) {
+  if (!path) return null;
+  const feature = path.match(/src\/features\/([^/]+)/)?.[1];
+  if (feature) return feature;
+  return path.match(/src\/shared\/api\/generated\/([^/]+)/)?.[1] ?? null;
+}
+function fileCategory(path) {
+  if (path.includes("/features/") && path.includes("/api/")) return "feature api";
+  if (path.includes("/features/") && path.includes("/model/")) return "feature model";
+  if (path.includes("/shared/api/generated/")) return "api generated";
+  if (path.includes("/shared/mocks/")) return "mocks";
+  return "other";
+}
+
+// src/impact-report.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join as join2, relative } from "path";
+function formatImpactReport(format2, payload) {
+  if (format2 === "json") return JSON.stringify(payload, null, 2);
+  if (format2 === "html") return createHtmlReport("Frontend Impact Center", payload);
+  return formatImpactMarkdown(payload);
+}
+function formatImpactMarkdown(payload) {
+  const lines = [
+    "# Frontend API Impact",
+    "",
+    `Decision: ${payload.decision.status}`,
+    `Merge risk: ${payload.decision.mergeRisk}`,
+    `Reason: ${payload.decision.reason}`,
+    "",
+    "## Summary",
+    "",
+    `- Breaking: ${payload.summary.breaking}`,
+    `- Warnings: ${payload.summary.warnings}`,
+    `- Non-breaking: ${payload.summary.nonBreaking}`,
+    `- Affected resources: ${payload.affectedResources.length > 0 ? payload.affectedResources.join(", ") : "none"}`,
+    `- Affected generated files: ${payload.affectedFiles.length}`,
+    "",
+    "## PR Summary",
+    "",
+    payload.prSummary,
+    "",
+    "## Migration Hints",
+    "",
+    ...payload.migrationHints.length > 0 ? payload.migrationHints.map((hint) => `- ${hint}`) : ["No migration hints."],
+    "",
+    "## Changes",
+    "",
+    ...payload.changes.length > 0 ? payload.changes.map((change) => `- ${change.severity} ${change.code}: ${change.message} (${change.location})`) : ["No contract changes."],
+    "",
+    "## Impacted Surface",
+    "",
+    `- Operation IDs: ${payload.impactedSurface.operationIds.length > 0 ? payload.impactedSurface.operationIds.join(", ") : "none"}`,
+    `- Client methods: ${payload.impactedSurface.clientMethods.length > 0 ? payload.impactedSurface.clientMethods.join(", ") : "none"}`,
+    `- Query hooks: ${payload.impactedSurface.queryHooks.length > 0 ? payload.impactedSurface.queryHooks.join(", ") : "none"}`,
+    "",
+    "## Source Usage",
+    "",
+    ...formatSourceUsageLines(payload.sourceUsages ?? []),
+    ""
+  ];
+  return lines.join("\n");
+}
+function formatPullRequestComment(payload) {
+  return [
+    "## Frontend API Impact",
+    "",
+    `Merge decision: ${formatMergeDecision(payload.decision.status)}`,
+    `Merge risk: ${payload.decision.mergeRisk}`,
+    `Reason: ${payload.decision.reason}`,
+    "",
+    payload.prSummary,
+    "",
+    "## Next Actions",
+    "",
+    ...formatNextActionLines(payload),
+    "",
+    "## Source Usage",
+    "",
+    ...formatSourceUsageLines(payload.sourceUsages ?? []),
+    ""
+  ].join("\n");
+}
+function formatMergeDecision(status) {
+  if (status === "blocked") return "block";
+  if (status === "review") return "review";
+  return "pass";
+}
+function formatNextActionLines(payload) {
+  if (payload.decision.status === "blocked") {
+    return [
+      "- Do not merge until the breaking frontend contract changes are handled.",
+      "- Update impacted source usages before regenerating committed Forge output.",
+      "- Re-run `archora-forge impact` after the OpenAPI or frontend changes are updated."
+    ];
+  }
+  if (payload.decision.status === "review") {
+    return [
+      "- Review warnings with the frontend owner before merge.",
+      "- Regenerate Forge output in the branch if the contract change is accepted.",
+      "- Keep the PR comment attached to the API change for reviewer context."
+    ];
+  }
+  return [
+    "- Merge can continue from the API impact perspective.",
+    "- Regenerate Forge output when the schema change is accepted.",
+    "- Keep `archora-forge check` in CI to catch drift after regeneration."
+  ];
+}
+function formatSourceUsageLines(usages) {
+  if (usages.length === 0) return ["No impacted source usages found."];
+  return usages.slice(0, 50).map((usage) => `- \`${usage.path}:${usage.lines.join(",")}\`: ${usage.matches.join(", ")}`);
+}
+async function scanSourceUsages(repo, report) {
+  const tokens = createUsageTokens(report);
+  if (tokens.length === 0) return [];
+  const patterns = tokens.map((token) => ({ token, pattern: tokenPattern(token) }));
+  const files = await collectSourceFiles(repo);
+  const usages = [];
+  for (const file of files) {
+    const content = await readFile2(file, "utf8");
+    const matches = patterns.filter(({ pattern }) => pattern.test(content)).map(({ token }) => token);
+    if (matches.length > 0) {
+      usages.push({
+        path: normalizePath(relative(repo, file)),
+        matches: [...new Set(matches)].sort(),
+        lines: collectMatchedLines(content, matches)
+      });
+    }
+  }
+  return usages.sort((left, right) => left.path.localeCompare(right.path)).slice(0, 200);
+}
+function collectMatchedLines(content, matches) {
+  const patterns = matches.map((match) => tokenPattern(match));
+  const lines = content.split(/\r?\n/);
+  const matchedLines = /* @__PURE__ */ new Set();
+  lines.forEach((line, index) => {
+    if (patterns.some((pattern) => pattern.test(line))) matchedLines.add(index + 1);
+  });
+  return [...matchedLines].sort((left, right) => left - right).slice(0, 20);
+}
+function tokenPattern(token) {
+  return new RegExp(`(?<![\\w$])${escapeRegExp(token)}(?![\\w$])`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createUsageTokens(report) {
+  const clientMethods = report.impactedSurface.clientMethods.map((method) => method.replace(/\(\)$/, ""));
+  const resourceTokens = report.affectedResources.flatMap((resource) => [`${resource}Client`, `${resource}QueryKeys`, `${resource}Config`, `${resource}Permissions`]);
+  return [...new Set([...report.impactedSurface.operationIds, ...clientMethods, ...report.impactedSurface.queryHooks, ...resourceTokens].filter(Boolean))].sort();
+}
+async function collectSourceFiles(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry.name)) continue;
+    const path = join2(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectSourceFiles(path));
+    } else if (entry.isFile() && isSourceFile(entry.name)) {
+      files.push(path);
+    }
+  }
+  return files;
+}
+function shouldSkipEntry(name) {
+  return name === "node_modules" || name === ".git" || name === "dist" || name === "build" || name === "coverage" || name === ".vitepress" || name === ".turbo";
+}
+function isSourceFile(name) {
+  return /\.(cjs|cts|js|jsx|mjs|mts|svelte|ts|tsx|vue)$/.test(name);
+}
+function normalizePath(path) {
+  return path.replaceAll("\\", "/");
+}
+
+// src/audit-package.ts
+import { execFile } from "child_process";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4, join as join4, relative as relative3, resolve as resolve4 } from "path";
+import { promisify } from "util";
+
+// ../core/dist/index.js
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve3, sep } from "path";
+import { access as access2 } from "fs/promises";
+import { createHash } from "crypto";
+import { join as join22 } from "path";
+import { format } from "prettier";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { resolve as resolve22 } from "path";
+import { readFile as readFile22 } from "fs/promises";
+import { join as join32 } from "path";
+import { readFile as readFile32 } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+var ForgeError = class extends Error {
+  details;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "ForgeError";
+    this.details = details;
+  }
+};
+var forgeCoreVersion = "2.0.0";
+var forgeGeneratedMarker = "// @archora-forge-generated";
+var forgeGeneratedMetadataMarker = "// @archora-forge-meta";
+async function writeGeneratedFiles(files, options) {
+  const result2 = {
+    created: 0,
+    updated: 0,
+    unchanged: 0,
+    protected: 0
+  };
+  for (const file of files) {
+    const content = toWritableGeneratedContent(file);
+    if (file.exists && !file.overwrite) {
+      result2.protected += 1;
+      continue;
+    }
+    const absolutePath = join3(options.cwd, file.path);
+    if (file.exists && await readExistingFile(absolutePath) === content) {
+      result2.unchanged += 1;
+      continue;
+    }
+    if (file.exists) {
+      result2.updated += 1;
+    } else {
+      result2.created += 1;
+    }
+    if (options.dryRun) {
+      continue;
+    }
+    await mkdir2(dirname3(absolutePath), { recursive: true });
+    await writeFile2(absolutePath, content, "utf8");
+  }
+  return result2;
+}
+function toWritableGeneratedContent(file) {
+  if (file.kind !== "generated" || !file.path.endsWith(".ts")) {
+    return file.content;
+  }
+  const contentWithoutHeaders = stripGeneratedHeaders(file.content);
+  return `${forgeGeneratedMarker}
+${formatGeneratedMetadata(file)}${contentWithoutHeaders}`;
+}
+function formatGeneratedMetadata(file) {
+  if (!file.metadata) return "";
+  return `${forgeGeneratedMetadataMarker} ${JSON.stringify(file.metadata)}
+`;
+}
+function stripGeneratedHeaders(content) {
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  while (lines[0] === forgeGeneratedMarker || lines[0]?.startsWith(`${forgeGeneratedMetadataMarker} `)) {
+    lines.shift();
+  }
+  return lines.join("\n");
+}
+async function findPrunableGeneratedFiles(files, options) {
+  const planned = new Set(files.map((file) => normalizePath2(file.path)));
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of options.roots) {
+    const absoluteRoot = resolveRoot(options.cwd, root);
+    for (const absolutePath of await listFiles(absoluteRoot)) {
+      const path = normalizePath2(relative2(options.cwd, absolutePath));
+      if (seen.has(path) || planned.has(path)) continue;
+      seen.add(path);
+      const content = await readExistingFile(absolutePath);
+      if (!content?.startsWith(forgeGeneratedMarker)) continue;
+      candidates.push({ path });
+    }
+  }
+  return candidates.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function pruneGeneratedFiles(candidates, options) {
+  const result2 = { deleted: [], skipped: [] };
+  for (const candidate of candidates) {
+    if (options.dryRun) continue;
+    try {
+      await rm(resolve3(options.cwd, candidate.path), { force: false });
+      result2.deleted.push(candidate);
+    } catch (error) {
+      result2.skipped.push({ ...candidate, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return result2;
+}
+async function readExistingFile(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function listFiles(root) {
+  try {
+    const entries = await readdir2(root, { withFileTypes: true });
+    const nested = await Promise.all(
+      entries.map(async (entry) => {
+        const path = join3(root, entry.name);
+        if (entry.isDirectory()) return listFiles(path);
+        if (entry.isFile()) return [path];
+        return [];
+      })
+    );
+    return nested.flat();
+  } catch {
+    return [];
+  }
+}
+function resolveRoot(cwd, root) {
+  return isAbsolute2(root) ? root : resolve3(cwd, root);
+}
+function normalizePath2(path) {
+  return path.split(sep).join("/");
+}
+function analyzeAllOfSchema(document, schema) {
+  if (!schema.allOf) return { kind: "unsupported", reason: "Schema does not use allOf." };
+  const analysis = mergeAllOfBranches(document, schema.allOf, /* @__PURE__ */ new Set());
+  if (analysis.kind === "mergeable") return { kind: "mergeable" };
+  return analysis;
+}
+function mergeSimpleAllOfSchema(document, schema) {
+  if (!schema.allOf) return schema;
+  const unwrapped = unwrapAnnotationOnlyAllOfSchema(schema);
+  if (unwrapped) return unwrapped;
+  const analysis = mergeAllOfBranches(document, schema.allOf, /* @__PURE__ */ new Set());
+  if (analysis.kind !== "mergeable") return null;
+  return {
+    ...schema,
+    type: "object",
+    properties: analysis.properties,
+    required: analysis.required.length > 0 ? analysis.required : void 0
+  };
+}
+function unwrapAnnotationOnlyAllOfSchema(schema) {
+  if (!schema.allOf) return null;
+  const structuralBranches = schema.allOf.filter((branch) => !isAnnotationOnlySchema(branch));
+  if (structuralBranches.length !== 1) return null;
+  return {
+    ...structuralBranches[0],
+    nullable: schema.nullable ?? structuralBranches[0]?.nullable,
+    description: schema.description ?? structuralBranches[0]?.description
+  };
+}
+function mergeAllOfBranches(document, branches, seenRefs) {
+  const properties = {};
+  const required = /* @__PURE__ */ new Set();
+  for (const branch of branches) {
+    const resolved = resolveBranch(document, branch, seenRefs);
+    if (!resolved) {
+      return { kind: "unsupported", reason: "A branch references an unknown or circular schema." };
+    }
+    if (!isObjectLikeSchema(resolved)) {
+      return { kind: "unsupported", reason: "Only object allOf branches can be merged safely." };
+    }
+    for (const [name, property] of Object.entries(resolved.properties ?? {})) {
+      const existing = properties[name];
+      if (existing && !areCompatibleProperties(existing, property)) {
+        return {
+          kind: "conflicting",
+          property: name,
+          reason: `Property "${name}" is defined with incompatible schema constraints across allOf branches.`
+        };
+      }
+      properties[name] = property;
+    }
+    for (const name of resolved.required ?? []) {
+      required.add(name);
+    }
+  }
+  return {
+    kind: "mergeable",
+    properties,
+    required: [...required]
+  };
+}
+function resolveBranch(document, branch, seenRefs) {
+  const resolved = branch.$ref ? resolveRef(document, branch.$ref, seenRefs) : branch;
+  if (!resolved) return null;
+  if (!resolved.allOf) return resolved;
+  const merged = mergeSimpleAllOfSchema(document, resolved);
+  return merged ?? resolved;
+}
+function resolveRef(document, ref, seenRefs) {
+  if (seenRefs.has(ref)) return null;
+  seenRefs.add(ref);
+  const name = ref.startsWith("#/components/schemas/") ? ref.split("/").at(-1) : null;
+  const schema = name ? document.components?.schemas?.[name] : null;
+  if (!schema) return null;
+  return schema.$ref || schema.allOf ? resolveBranch(document, schema, seenRefs) : schema;
+}
+function isObjectLikeSchema(schema) {
+  return schema.type === "object" || Boolean(schema.properties);
+}
+function isAnnotationOnlySchema(schema) {
+  const annotationKeys = /* @__PURE__ */ new Set(["default", "description", "deprecated", "example", "examples", "nullable", "title"]);
+  return Object.keys(schema).length > 0 && Object.keys(schema).every((key) => annotationKeys.has(key));
+}
+function areCompatibleProperties(left, right) {
+  return left.type === right.type && left.format === right.format && Boolean(left.nullable) === Boolean(right.nullable) && JSON.stringify(left.enum ?? null) === JSON.stringify(right.enum ?? null);
+}
+var identifierPattern = /^[A-Za-z_$][\w$]*$/;
+var reservedWords = /* @__PURE__ */ new Set([
+  "abstract",
+  "any",
+  "as",
+  "async",
+  "await",
+  "boolean",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "constructor",
+  "continue",
+  "debugger",
+  "declare",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "get",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "infer",
+  "instanceof",
+  "interface",
+  "is",
+  "keyof",
+  "let",
+  "module",
+  "namespace",
+  "never",
+  "new",
+  "null",
+  "number",
+  "object",
+  "of",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "require",
+  "return",
+  "set",
+  "static",
+  "string",
+  "super",
+  "switch",
+  "symbol",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "type",
+  "typeof",
+  "undefined",
+  "unique",
+  "unknown",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+var cyrillicMap = {
+  \u0430: "a",
+  \u0431: "b",
+  \u0432: "v",
+  \u0433: "g",
+  \u0434: "d",
+  \u0435: "e",
+  \u0451: "e",
+  \u0436: "zh",
+  \u0437: "z",
+  \u0438: "i",
+  \u0439: "y",
+  \u043A: "k",
+  \u043B: "l",
+  \u043C: "m",
+  \u043D: "n",
+  \u043E: "o",
+  \u043F: "p",
+  \u0440: "r",
+  \u0441: "s",
+  \u0442: "t",
+  \u0443: "u",
+  \u0444: "f",
+  \u0445: "h",
+  \u0446: "c",
+  \u0447: "ch",
+  \u0448: "sh",
+  \u0449: "sch",
+  \u044A: "",
+  \u044B: "y",
+  \u044C: "",
+  \u044D: "e",
+  \u044E: "yu",
+  \u044F: "ya"
+};
+function toSafeIdentifier(value, fallback = "value") {
+  const parts = transliterate(value).trim().split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+  const identifier = parts.length === 0 ? fallback : parts.map((part, index) => {
+    const cleaned = part.replace(/[^\w$]/g, "");
+    if (!cleaned) return "";
+    if (index === 0) return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+    return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+  }).join("");
+  const safe = ensureIdentifierStart(identifier || fallback);
+  return avoidReservedWord(identifierPattern.test(safe) ? safe : ensureIdentifierStart(fallback));
+}
+function toSafeTypeName(value, fallback = "GeneratedType") {
+  const identifier = toSafeIdentifier(value, fallback);
+  const pascal = identifier.charAt(0).toUpperCase() + identifier.slice(1);
+  return avoidReservedWord(identifierPattern.test(pascal) ? pascal : toSafeIdentifier(fallback, "GeneratedType"));
+}
+function toSafeFileName(value, fallback = "file") {
+  return toSafeIdentifier(value, fallback);
+}
+function pluralizeTypeName(value) {
+  if (/(s|x|z|ch|sh)$/i.test(value)) return `${value}es`;
+  if (/[^aeiou]y$/i.test(value)) return `${value.slice(0, -1)}ies`;
+  return `${value}s`;
+}
+function createIdentifierRegistry() {
+  const used = /* @__PURE__ */ new Set();
+  const unique = (name) => {
+    let candidate = name;
+    let index = 2;
+    while (used.has(candidate)) {
+      candidate = `${name}${index}`;
+      index += 1;
+    }
+    used.add(candidate);
+    return candidate;
+  };
+  return {
+    identifier: (value, fallback) => unique(toSafeIdentifier(value, fallback)),
+    typeName: (value, fallback) => unique(toSafeTypeName(value, fallback)),
+    fileName: (value, fallback) => unique(toSafeFileName(value, fallback))
+  };
+}
+function quoteObjectKeyIfNeeded(value) {
+  return identifierPattern.test(value) ? value : `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function ensureIdentifierStart(value) {
+  if (!value) return "_";
+  return /^[A-Za-z_$]/.test(value) ? value : `_${value}`;
+}
+function avoidReservedWord(value) {
+  return reservedWords.has(value) ? `${value}Value` : value;
+}
+function transliterate(value) {
+  return [...value].map((char) => {
+    const lower = char.toLowerCase();
+    const transliterated = cyrillicMap[lower];
+    if (transliterated == null) return char;
+    return char === lower ? transliterated : capitalize(transliterated);
+  }).join("");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function createResourceTypeNames(resource) {
+  const entity = toSafeTypeName(resource.entity);
+  const collection = pluralizeTypeName(entity);
+  return {
+    idType: `${entity}Id`,
+    detailResponseType: `${entity}DetailResponse`,
+    listParamsType: `${collection}ListParams`,
+    listResponseType: `${collection}ListResponse`,
+    createRequestType: `Create${entity}Request`,
+    createResponseType: `Create${entity}Response`,
+    updateRequestType: `Update${entity}Request`,
+    updateResponseType: `Update${entity}Response`,
+    entityType: entity
+  };
+}
+function createOperationTypeNames(operation) {
+  const operationName = toSafeTypeName(operation.id ?? `${operation.method}Operation`);
+  return {
+    paramsType: `${operationName}OperationParams`,
+    requestType: `${operationName}OperationRequest`,
+    responseType: `${operationName}OperationResponse`
+  };
+}
+function createTypeScriptTypes(normalized, resource) {
+  const declarations = [];
+  if (!normalized.schemas.some((schema) => toSafeTypeName(schema.name) === toSafeTypeName(resource.entity))) {
+    declarations.push(`export interface ${toSafeTypeName(resource.entity)} {
+  [key: string]: unknown
+}`);
+  }
+  declarations.push(createOperationAliases(normalized, resource));
+  const body = declarations.filter(Boolean).join("\n\n");
+  const imports = collectSharedTypeImports(normalized, body);
+  const importBlock = imports.length > 0 ? `import type { ${imports.join(", ")} } from '../components.types'
+
+export type { ${imports.join(", ")} } from '../components.types'
+
+` : "";
+  return `${importBlock}${body}
+`;
+}
+function createSharedSchemaTypes(normalized) {
+  const declarations = [];
+  const enumAliases = /* @__PURE__ */ new Map();
+  for (const schema of normalized.schemas) {
+    declarations.push(createSchemaDeclaration(normalized, toSafeTypeName(schema.name), schema.schema, enumAliases));
+  }
+  declarations.unshift(...[...enumAliases.entries()].map(([name, value]) => `export type ${name} = ${value}`));
+  return declarations.length > 0 ? `${declarations.filter(Boolean).join("\n\n")}
+` : "export {}\n";
+}
+function schemaToTypeScript(normalized, schema, options = { mode: "response" }) {
+  if (!schema) return "unknown";
+  if (schema.$ref) return toSafeTypeName(schema.$ref.split("/").at(-1) ?? "unknown");
+  const unwrappedAllOf = unwrapAnnotationOnlyAllOfSchema(schema);
+  if (unwrappedAllOf) return schemaToTypeScript(normalized, unwrappedAllOf, options);
+  if (Array.isArray(schema.type)) {
+    const nonNullTypes = schema.type.filter((type) => type !== "null");
+    if (nonNullTypes.length !== 1) return "unknown";
+    const base = schemaToTypeScript(normalized, { ...schema, type: nonNullTypes[0] }, options);
+    return schema.type.includes("null") ? `${base} | null` : base;
+  }
+  if (schema.oneOf?.length || schema.anyOf?.length) {
+    const branches = schema.oneOf ?? schema.anyOf ?? [];
+    const discriminator = getDiscriminatorInfo(schema);
+    return branches.map((branch) => renderUnionBranch(normalized, branch, options, discriminator)).join(" | ");
+  }
+  if (hasConst(schema)) return enumValueToTypeScript(schema.const);
+  if (schema.enum) return schema.enum.map(enumValueToTypeScript).join(" | ");
+  if (schema.type === "string" && schema.format === "binary") return options.mode === "request" || options.indent !== void 0 ? "Blob | File" : "Blob";
+  if (schema.type === "string") return "string";
+  if (schema.type === "number" || schema.type === "integer") return "number";
+  if (schema.type === "boolean") return "boolean";
+  if (schema.type === "array") return `${toArrayElementType(schemaToTypeScript(normalized, schema.items, options))}[]`;
+  if (isPureDictionarySchema(schema)) return createDictionaryType(normalized, schema.additionalProperties, options);
+  if (schema.type === "object" && !schema.properties) return "Record<string, unknown>";
+  if (schema.type === "object" || schema.properties) {
+    const indent = options.indent ?? 0;
+    const childIndent = " ".repeat(indent + 2);
+    const closeIndent = " ".repeat(indent);
+    const required = new Set(schema.required ?? []);
+    const lines = Object.entries(schema.properties ?? {}).filter(([, property]) => options.mode === "request" ? !property.readOnly : !property.writeOnly).map(([name, property]) => {
+      const optional = required.has(name) ? "" : "?";
+      const nullable = property.nullable ? " | null" : "";
+      return `${childIndent}${quoteObjectKeyIfNeeded(name)}${optional}: ${schemaToTypeScript(normalized, property, {
+        ...options,
+        indent: indent + 2
+      })}${nullable}`;
+    });
+    const indexSignature = createAdditionalPropertiesIndex(normalized, schema, options, childIndent, required);
+    if (indexSignature) lines.push(indexSignature);
+    return `{
+${lines.join("\n")}
+${closeIndent}}`;
+  }
+  return "unknown";
+}
+function getDiscriminatorInfo(schema) {
+  const raw = schema.discriminator;
+  if (!raw || typeof raw !== "object") return null;
+  const propertyName = raw.propertyName;
+  if (typeof propertyName !== "string" || propertyName.length === 0) return null;
+  const mapping = {};
+  const rawMapping = raw.mapping;
+  if (rawMapping && typeof rawMapping === "object") {
+    for (const [key, value] of Object.entries(rawMapping)) {
+      if (typeof value === "string") mapping[key] = value;
+    }
+  }
+  return { propertyName, mapping };
+}
+function renderUnionBranch(normalized, branch, options, discriminator) {
+  const type = schemaToTypeScript(normalized, branch, options);
+  if (!discriminator || type === "unknown" || !isObjectSchemaBranch(normalized, branch)) return type;
+  const literal = discriminatorLiteral(discriminator, branch);
+  if (literal === null) return type;
+  return `(${type} & { ${quoteObjectKeyIfNeeded(discriminator.propertyName)}: ${JSON.stringify(literal)} })`;
+}
+function discriminatorLiteral(discriminator, branch) {
+  if (!branch.$ref) return null;
+  const refName = branch.$ref.split("/").at(-1) ?? "";
+  for (const [key, target] of Object.entries(discriminator.mapping)) {
+    if (target === branch.$ref || target.split("/").at(-1) === refName) return key;
+  }
+  return refName.length > 0 ? refName : null;
+}
+function isObjectSchemaBranch(normalized, branch) {
+  const resolved = branch.$ref ? resolveSchema(normalized, branch) : branch;
+  if (!resolved) return false;
+  return resolved.type === "object" || Boolean(resolved.properties) || Boolean(resolved.allOf);
+}
+function isSupportedUnion(normalized, schema, branches) {
+  if (branches.length === 0) return false;
+  const renderable = branches.every(
+    (branch) => schemaToTypeScript(normalized, branch, { mode: "response" }) !== "unknown"
+  );
+  if (!renderable) return false;
+  if (getDiscriminatorInfo(schema))
+    return branches.every((branch) => isObjectSchemaBranch(normalized, branch));
+  return true;
+}
+function getPathParams(operation) {
+  return (operation?.parameters ?? []).filter((parameter) => parameter.in === "path");
+}
+function getQueryParams(operation) {
+  return (operation?.parameters ?? []).filter((parameter) => parameter.in === "query");
+}
+function getHeaderParams(operation) {
+  return (operation?.parameters ?? []).filter((parameter) => parameter.in === "header");
+}
+function getOperationParams(operation) {
+  return (operation?.parameters ?? []).filter((parameter) => parameter.in === "path" || parameter.in === "query" || parameter.in === "header");
+}
+function getCollectionParams(resource) {
+  const params = [
+    ...getPathParams(resource.operations.list),
+    ...getQueryParams(resource.operations.list),
+    ...getPathParams(resource.operations.create)
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return params.filter((param) => {
+    const key = `${param.in}:${param.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function getIdentityParams(resource) {
+  return [resource.operations.detail, resource.operations.update, resource.operations.delete].map((operation) => getPathParams(operation)).find((params) => params.length > 0) ?? [];
+}
+function resolveSchema(normalized, schema) {
+  if (!schema) return null;
+  if (!schema.$ref) return schema;
+  const name = schema.$ref.split("/").at(-1);
+  return normalized.schemas.find((candidate) => candidate.name === name || toSafeTypeName(candidate.name) === toSafeTypeName(name ?? ""))?.schema ?? schema;
+}
+function resolveSchemaName(schema) {
+  if (!schema?.$ref) return null;
+  return toSafeTypeName(schema.$ref.split("/").at(-1) ?? "");
+}
+function createSchemaDeclaration(normalized, name, schema, enumAliases) {
+  if (schema.oneOf?.length || schema.anyOf?.length) {
+    return `export type ${name} = ${schemaToTypeScript(normalized, schema, { mode: "response" })}`;
+  }
+  if (isPureDictionarySchema(schema)) {
+    return `export type ${name} = ${createDictionaryType(normalized, schema.additionalProperties, { mode: "response" })}`;
+  }
+  const mode = name.endsWith("Dto") ? "request" : "response";
+  const required = new Set(schema.required ?? []);
+  const lines = Object.entries(schema.properties ?? {}).filter(([, property]) => mode === "request" ? !property.readOnly : !property.writeOnly).map(([propertyName, property]) => {
+    const enumName = property.enum ? `${name}${toSafeTypeName(propertyName)}` : void 0;
+    if (enumName && property.enum) {
+      enumAliases.set(enumName, property.enum.map(enumValueToTypeScript).join(" | "));
+    }
+    const optional = required.has(propertyName) ? "" : "?";
+    const baseType = enumName ?? schemaToTypeScript(normalized, property, { mode, indent: 2 });
+    const nullable = property.nullable ? " | null" : "";
+    return `  ${quoteObjectKeyIfNeeded(propertyName)}${optional}: ${baseType}${nullable}`;
+  });
+  const indexSignature = createAdditionalPropertiesIndex(normalized, schema, { mode, indent: 0 }, "  ", required);
+  if (indexSignature) lines.push(indexSignature);
+  return `export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function isPureDictionarySchema(schema) {
+  return Boolean(
+    (schema.type === "object" || schema.additionalProperties !== void 0) && schema.additionalProperties !== void 0 && Object.keys(schema.properties ?? {}).length === 0
+  );
+}
+function createDictionaryType(normalized, additionalProperties, options) {
+  if (additionalProperties === false) return "Record<string, never>";
+  if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
+  return `Record<string, ${schemaToTypeScript(normalized, additionalProperties, options)}>`;
+}
+function createAdditionalPropertiesIndex(normalized, schema, options, childIndent, required) {
+  if (schema.additionalProperties === void 0 || schema.additionalProperties === false || isPureDictionarySchema(schema)) return null;
+  const valueTypes = /* @__PURE__ */ new Set();
+  if (schema.additionalProperties === true) {
+    valueTypes.add("unknown");
+  } else {
+    valueTypes.add(schemaToTypeScript(normalized, schema.additionalProperties, options));
+  }
+  for (const [propertyName, property] of Object.entries(schema.properties ?? {})) {
+    if (options.mode === "request" && property.readOnly) continue;
+    if (options.mode === "response" && property.writeOnly) continue;
+    valueTypes.add(schemaToTypeScript(normalized, property, options));
+    if (property.nullable) valueTypes.add("null");
+    if (!required.has(propertyName)) valueTypes.add("undefined");
+  }
+  return `${childIndent}[key: string]: ${[...valueTypes].join(" | ")}`;
+}
+function toArrayElementType(type) {
+  return type.includes(" | ") ? `(${type})` : type;
+}
+function enumValueToTypeScript(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (value === null) return "null";
+  return String(value);
+}
+function hasConst(schema) {
+  return Object.hasOwn(schema, "const");
+}
+function createOperationAliases(normalized, resource) {
+  const names = createResourceTypeNames(resource);
+  const identityParams = getIdentityParams(resource);
+  const idDeclaration = identityParams.length > 1 ? createParamsInterface(normalized, names.idType, identityParams) : `export type ${names.idType} = ${identityParams[0]?.schema ? schemaToTypeScript(normalized, identityParams[0].schema, { mode: "request" }) : "string"}`;
+  const listParams = createParamsInterface(normalized, names.listParamsType, getCollectionParams(resource));
+  const listResponse = createResponseDeclaration(normalized, names.listResponseType, resource.operations.list);
+  const detailResponse = createResponseType(normalized, resource.operations.detail, names.entityType);
+  const createRequest = createRequestBodyType(normalized, resource.operations.create) ?? `Partial<${names.entityType}>`;
+  const updateRequest = createRequestBodyType(normalized, resource.operations.update) ?? `Partial<${names.entityType}>`;
+  const createResponse = createResponseType(normalized, resource.operations.create, names.entityType);
+  const updateResponse = createResponseType(normalized, resource.operations.update, names.entityType);
+  const operationAliases = resource.operationsList.filter((operation) => operation.operationKind !== "unsupported-operation" && !Object.values(resource.operations).includes(operation)).map((operation) => createOperationAlias(normalized, operation));
+  return [
+    idDeclaration,
+    `export type ${names.detailResponseType} = ${detailResponse}`,
+    listParams,
+    listResponse,
+    `export type ${names.createRequestType} = ${createRequest}`,
+    `export type ${names.createResponseType} = ${createResponse}`,
+    `export type ${names.updateRequestType} = ${updateRequest}`,
+    `export type ${names.updateResponseType} = ${updateResponse}`,
+    ...operationAliases
+  ].filter(Boolean).join("\n\n");
+}
+function createOperationAlias(normalized, operation) {
+  const names = createOperationTypeNames(operation);
+  const params = createParamsInterface(normalized, names.paramsType, getOperationParams(operation));
+  const request = createRequestBodyType(normalized, operation) ?? "void";
+  const response = createResponseType(normalized, operation, "unknown");
+  return [params, `export type ${names.requestType} = ${request}`, `export type ${names.responseType} = ${response}`].join("\n\n");
+}
+function createRequestBodyType(normalized, operation) {
+  if (!operation?.requestBodySchema) return null;
+  if (operation.requestContentTypes.some(isMultipartContentType)) return "FormData";
+  if (operation.requestContentTypes.some(isFormUrlEncodedContentType)) return "URLSearchParams";
+  if (operation.requestContentTypes.some(isBinaryContentType)) return "Blob | ArrayBuffer | ReadableStream";
+  return resolveSchemaName(operation.requestBodySchema) ?? schemaToTypeScript(normalized, operation.requestBodySchema, { mode: "request" });
+}
+function isMultipartContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "multipart/form-data";
+}
+function isFormUrlEncodedContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/x-www-form-urlencoded";
+}
+function isBinaryContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/octet-stream" || normalized === "application/pdf" || normalized.startsWith("image/");
+}
+function createParamsInterface(normalized, name, params) {
+  if (params.length === 0) {
+    return `export type ${name} = Record<string, never>`;
+  }
+  const lines = params.map((param) => {
+    const optional = param.required ? "" : "?";
+    return `  ${quoteObjectKeyIfNeeded(param.name)}${optional}: ${schemaToTypeScript(normalized, param.schema, { mode: "request" })}`;
+  });
+  return `export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function createResponseDeclaration(normalized, name, operation) {
+  if (operation?.responseBodyEmpty) return `export type ${name} = void`;
+  const schema = operation?.responseSchema;
+  const schemaName = resolveSchemaName(schema);
+  if (schemaName) return `export type ${name} = ${schemaName}`;
+  if (!schema) return `export type ${name} = unknown`;
+  const type = schemaToTypeScript(normalized, schema, { mode: "response" });
+  return type.startsWith("{") ? `export interface ${name} ${type}` : `export type ${name} = ${type}`;
+}
+function createResponseType(normalized, operation, fallback) {
+  if (operation?.responseBodyEmpty) return "void";
+  const schema = operation?.responseSchema;
+  return resolveSchemaName(schema) ?? (schema ? schemaToTypeScript(normalized, schema, { mode: "response" }) : fallback);
+}
+function collectSharedTypeImports(normalized, content) {
+  return normalized.schemas.map((schema) => toSafeTypeName(schema.name)).filter((name, index, names) => names.indexOf(name) === index).filter((name) => new RegExp(`\\b${escapeRegExp2(name)}\\b`).test(content)).sort((left, right) => left.localeCompare(right));
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizePlugins(plugins) {
+  return (plugins ?? []).filter(isForgePlugin);
+}
+async function runPluginArtifactHooks(input) {
+  const artifacts = [];
+  for (const plugin of normalizePlugins(input.plugins)) {
+    if (!plugin.generateArtifacts) continue;
+    try {
+      artifacts.push(...await plugin.generateArtifacts({ normalized: input.normalized, cwd: input.cwd }));
+    } catch (error) {
+      throw new Error(
+        `Plugin "${plugin.name}" failed during generateArtifacts: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return artifacts;
+}
+async function runPluginAfterGenerateHooks(input) {
+  for (const plugin of normalizePlugins(input.plugins)) {
+    if (!plugin.afterGenerate) continue;
+    await plugin.afterGenerate(input.files);
+  }
+}
+function runPluginDiagnostics(input) {
+  const diagnostics = [];
+  for (const plugin of normalizePlugins(input.plugins)) {
+    if (!plugin.diagnostics) continue;
+    try {
+      const result2 = plugin.diagnostics(input.normalized);
+      if (Array.isArray(result2)) diagnostics.push(...result2);
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "plugin-diagnostic-error",
+        message: `Plugin "${plugin.name}" failed while collecting diagnostics.`,
+        location: `plugins.${plugin.name}`,
+        suggestion: error instanceof Error ? error.message : "Inspect the plugin diagnostics hook."
+      });
+    }
+  }
+  return diagnostics;
+}
+function isForgePlugin(value) {
+  return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string";
+}
+function collectDiagnostics(normalized, options = {}) {
+  const diagnostics = [];
+  const groupedParameters = /* @__PURE__ */ new Map();
+  const unsupportedSecuritySchemes = Object.entries(normalized.document.components?.securitySchemes ?? {}).filter(
+    ([, scheme]) => !isRuntimeSupportedSecurityScheme(scheme)
+  );
+  if (unsupportedSecuritySchemes.length > 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "unsupported-security-schemes",
+      message: "Unsupported security schemes are detected.",
+      location: unsupportedSecuritySchemes.map(([name]) => `components.securitySchemes.${name}`).join(", "),
+      suggestion: "Configure auth headers through the runtime client until security scheme generation is supported."
+    });
+  }
+  for (const operation of normalized.operations) {
+    const location = `${operation.method.toUpperCase()} ${operation.path}`;
+    const requestContentTypes = getContentTypes(operation.operation.requestBody);
+    const responseContentTypes = Object.values(operation.operation.responses ?? {}).flatMap((response) => Object.keys(response.content ?? {}));
+    if (operation.operationKind === "unsupported-operation") {
+      diagnostics.push({
+        severity: "warning",
+        code: "unsupported-operation",
+        message: `${location} is preserved but is not generated as an interactive resource yet.`,
+        location,
+        impact: "Generated output uses an explicit unsupported operation panel instead of silently dropping the operation.",
+        suggestion: "Use a supported HTTP method and JSON-compatible request/response schemas, or implement this endpoint with custom code."
+      });
+    }
+    if (operation.operation.requestBody && !operation.requestBodySchema) {
+      diagnostics.push({
+        severity: "warning",
+        code: requestContentTypes.some((type) => !isJsonCompatibleContentType(type)) ? "unsupported-content-type" : "missing-request-schema",
+        message: `${location} has no supported JSON request schema. Generated request type will use an explicit fallback.`,
+        location,
+        impact: "Request payload typing may fall back to an explicit generic type.",
+        suggestion: "Add an application/json request body schema to improve generated request types."
+      });
+    }
+    if (!operation.responseSchema && !operation.responseBodyEmpty && operation.method !== "delete") {
+      diagnostics.push({
+        severity: "warning",
+        code: responseContentTypes.some((type) => !isJsonCompatibleContentType(type)) ? "unsupported-content-type" : "missing-response-schema",
+        message: `${location} has no 2xx JSON response schema. Generated response type will be unknown.`,
+        location,
+        impact: "Response typing and generated UI metadata may be incomplete.",
+        suggestion: "Add an application/json 2xx response schema to improve generated response types."
+      });
+    }
+    for (const parameter of operation.parameters) {
+      if (parameter.in === "header" || parameter.in === "cookie") {
+        if (parameter.in === "header" && parameter.name.toLowerCase() === "authorization") {
+          continue;
+        }
+        if (parameter.in === "header" && operation.operationKind !== "crud-resource" && parameter.name.toLowerCase() !== "authorization") {
+          continue;
+        }
+        if (parameter.in === "cookie" && parameter.name.toLowerCase() === "authorization") {
+          const key = `${parameter.in}:${parameter.name.toLowerCase()}`;
+          const grouped = groupedParameters.get(key) ?? { in: parameter.in, name: parameter.name, locations: [] };
+          grouped.locations.push(location);
+          groupedParameters.set(key, grouped);
+          continue;
+        }
+        diagnostics.push({
+          severity: "warning",
+          code: `unsupported-${parameter.in}-parameter`,
+          message: `${location} uses an unsupported ${parameter.in} parameter "${parameter.name}".`,
+          location,
+          impact: "Generated client signatures do not include this parameter yet.",
+          suggestion: "Model this value through runtime headers until header/cookie parameter generation is supported."
+        });
+      }
+    }
+    if (operation.operation.security) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unsupported-operation-security",
+        message: `${location} defines operation-level security that is not generated yet.`,
+        location,
+        impact: "Generated client calls require runtime auth configuration.",
+        suggestion: "Configure auth through createApiClient headers/getHeaders for now."
+      });
+    }
+  }
+  for (const grouped of groupedParameters.values()) {
+    diagnostics.push({
+      severity: "warning",
+      code: `unsupported-${grouped.in}-parameter`,
+      message: `${grouped.locations.length} operations use unsupported ${grouped.in} parameter "${grouped.name}".`,
+      location: grouped.locations.slice(0, 3).join(", ") + (grouped.locations.length > 3 ? ", ..." : ""),
+      impact: "Repeated auth/header parameters are grouped to reduce diagnostic noise.",
+      suggestion: "Model this value through runtime headers until header/cookie parameter generation is supported."
+    });
+  }
+  const schemaDiagnostics = [];
+  for (const schema of normalized.schemas) {
+    const originalSchema = normalized.document.components?.schemas?.[schema.name] ?? schema.schema;
+    collectSchemaDiagnostics(normalized, originalSchema, `#/components/schemas/${schema.name}`, schemaDiagnostics);
+  }
+  diagnostics.push(...schemaDiagnostics);
+  diagnostics.push(...runPluginDiagnostics({ plugins: options.plugins, normalized }));
+  return diagnostics;
+}
+function collectSchemaDiagnostics(normalized, schema, location, diagnostics) {
+  if (schema.allOf) {
+    const unwrapped = unwrapAnnotationOnlyAllOfSchema(schema);
+    const analysis = unwrapped ? null : analyzeAllOfSchema(normalized.document, schema);
+    if (!analysis) {
+    } else if (analysis.kind === "mergeable") {
+    } else if (analysis.kind === "conflicting") {
+      diagnostics.push({
+        severity: "error",
+        code: "conflicting-allof",
+        message: `${location} has conflicting allOf branches for property "${analysis.property}".`,
+        location,
+        suggestion: analysis.reason
+      });
+    } else {
+      diagnostics.push({
+        severity: "warning",
+        code: "unsupported-allof",
+        message: `${location} uses allOf, which is reported but not deeply modeled yet.`,
+        location,
+        suggestion: analysis.reason
+      });
+    }
+  }
+  for (const key of ["oneOf", "anyOf"]) {
+    if (!schema[key]) continue;
+    if (isSupportedUnion(normalized, schema, schema[key])) continue;
+    const branches = schema[key].map((_, index) => `${location}/${key}/${index}`).join(", ");
+    diagnostics.push({
+      severity: "warning",
+      code: `unsupported-${key.toLowerCase()}`,
+      message: `${location} uses ${key}, which is reported but not deeply modeled yet.`,
+      location,
+      impact: schema.discriminator ? `Generated types may fall back to a broader shape for discriminator-based branches: ${branches}.` : `Generated types may fall back to a broader shape for branches: ${branches}.`,
+      suggestion: schema.discriminator ? "Discriminator is present; validate generated fallback types carefully or prefer an explicit non-polymorphic response shape for v1 generation." : "Prefer a concrete object schema for v1 generation, or validate generated fallback types carefully."
+    });
+  }
+  if (schema.discriminator && !isSupportedDiscriminatedUnion(normalized, schema)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "unsupported-discriminator",
+      message: `${location} uses discriminator, which is not modeled yet.`,
+      location,
+      impact: "Generated union narrowing will not reflect discriminator semantics yet.",
+      suggestion: "Avoid discriminator-dependent generation until composition support is expanded."
+    });
+  }
+  for (const [name, property] of Object.entries(schema.properties ?? {})) {
+    collectSchemaDiagnostics(normalized, property, `${location}/properties/${name}`, diagnostics);
+  }
+  if (schema.items) {
+    collectSchemaDiagnostics(normalized, schema.items, `${location}/items`, diagnostics);
+  }
+}
+function isSupportedDiscriminatedUnion(normalized, schema) {
+  const branches = schema.oneOf ?? schema.anyOf;
+  return Boolean(branches?.length) && branches.every((branch) => isObjectSchemaBranch(normalized, branch));
+}
+function isRuntimeSupportedSecurityScheme(value) {
+  if (!value || typeof value !== "object") return false;
+  const scheme = value;
+  if (scheme.type === "http" && typeof scheme.scheme === "string" && scheme.scheme.toLowerCase() === "bearer") return true;
+  if (scheme.type === "oauth2") return true;
+  return scheme.type === "apiKey" && scheme.in === "header";
+}
+function getContentTypes(value) {
+  if (!value || typeof value !== "object" || !("content" in value)) return [];
+  const content = value.content;
+  return content && typeof content === "object" ? Object.keys(content) : [];
+}
+function isJsonCompatibleContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/json" || normalized.endsWith("+json");
+}
+function createSchemaCoverageMatrix(normalized, diagnostics) {
+  const operations = normalized.operations;
+  const unsupportedConstructs = countUnsupportedSchemaConstructs(normalized);
+  const operationDiagnosticOnly = operations.filter((operation) => operation.operationKind === "unsupported-operation").length;
+  const schemaDiagnosticOnly = Object.values(unsupportedConstructs).reduce((total, count) => total + count, 0);
+  const generated = operations.filter((operation) => operation.operationKind !== "unsupported-operation").length;
+  const fallback = operations.filter(hasFallbackShape).length + diagnostics.filter((diagnostic) => diagnostic.code === "missing-request-schema" || diagnostic.code === "missing-response-schema").length;
+  return {
+    operations: {
+      total: operations.length,
+      generated,
+      diagnosticOnly: operationDiagnosticOnly,
+      byKind: countBy(operations, (operation) => operation.operationKind),
+      byRequestShape: countBy(operations, requestShape),
+      byResponseShape: countBy(operations, responseShape)
+    },
+    schemas: {
+      total: normalized.schemas.length,
+      unsupportedConstructs
+    },
+    cases: {
+      generated,
+      skipped: operationDiagnosticOnly,
+      fallback,
+      diagnosticOnly: operationDiagnosticOnly + schemaDiagnosticOnly
+    }
+  };
+}
+function mergeSchemaCoverageMatrices(matrices) {
+  return {
+    operations: {
+      total: sum(matrices, (matrix) => matrix.operations.total),
+      generated: sum(matrices, (matrix) => matrix.operations.generated),
+      diagnosticOnly: sum(matrices, (matrix) => matrix.operations.diagnosticOnly),
+      byKind: mergeRecords(matrices.map((matrix) => matrix.operations.byKind)),
+      byRequestShape: mergeRecords(matrices.map((matrix) => matrix.operations.byRequestShape)),
+      byResponseShape: mergeRecords(matrices.map((matrix) => matrix.operations.byResponseShape))
+    },
+    schemas: {
+      total: sum(matrices, (matrix) => matrix.schemas.total),
+      unsupportedConstructs: mergeRecords(matrices.map((matrix) => matrix.schemas.unsupportedConstructs))
+    },
+    cases: {
+      generated: sum(matrices, (matrix) => matrix.cases.generated),
+      skipped: sum(matrices, (matrix) => matrix.cases.skipped),
+      fallback: sum(matrices, (matrix) => matrix.cases.fallback),
+      diagnosticOnly: sum(matrices, (matrix) => matrix.cases.diagnosticOnly)
+    }
+  };
+}
+function requestShape(operation) {
+  if (!operation.operation.requestBody) return "none";
+  if (operation.hasFilePayload) return "binary";
+  if (operation.isJsonRequest) return "json";
+  if (operation.requestContentTypes.some((type) => type.startsWith("text/"))) return "text";
+  if (operation.requestContentTypes.includes("multipart/form-data")) return "multipart";
+  if (operation.requestContentTypes.includes("application/x-www-form-urlencoded")) return "form";
+  return operation.requestBodySchema ? "non-json" : "missing";
+}
+function responseShape(operation) {
+  if (operation.responseBodyEmpty) return "empty";
+  if (operation.hasFilePayload) return "binary";
+  if (operation.isJsonResponse) return "json";
+  if (operation.responseContentTypes.some((type) => type.startsWith("text/"))) return "text";
+  return operation.responseSchema ? "non-json" : "missing";
+}
+function hasFallbackShape(operation) {
+  if (operation.operationKind === "unsupported-operation") return false;
+  const requestFallback = Boolean(operation.operation.requestBody) && !operation.isJsonRequest && !operation.hasFilePayload;
+  const responseFallback = !operation.responseBodyEmpty && !operation.isJsonResponse && !operation.hasFilePayload && operation.method !== "delete";
+  return requestFallback || responseFallback;
+}
+function countUnsupportedSchemaConstructs(normalized) {
+  const counts = {};
+  for (const { schema } of normalized.schemas) {
+    visitSchema(normalized, schema, counts);
+  }
+  return counts;
+}
+function visitSchema(normalized, schema, counts) {
+  if (schema.allOf) counts.allOf = (counts.allOf ?? 0) + 1;
+  if (schema.oneOf && !isSupportedUnion(normalized, schema, schema.oneOf)) counts.oneOf = (counts.oneOf ?? 0) + 1;
+  if (schema.anyOf && !isSupportedUnion(normalized, schema, schema.anyOf)) counts.anyOf = (counts.anyOf ?? 0) + 1;
+  const union = schema.oneOf ?? schema.anyOf;
+  if (schema.discriminator && !(union && isSupportedUnion(normalized, schema, union))) counts.discriminator = (counts.discriminator ?? 0) + 1;
+  for (const property of Object.values(schema.properties ?? {})) {
+    visitSchema(normalized, property, counts);
+  }
+  if (schema.items) {
+    visitSchema(normalized, schema.items, counts);
+  }
+  for (const branch of [...schema.allOf ?? [], ...schema.oneOf ?? [], ...schema.anyOf ?? []]) {
+    visitSchema(normalized, branch, counts);
+  }
+}
+function countBy(items, key) {
+  const counts = {};
+  for (const item of items) {
+    const value = key(item);
+    counts[value] = (counts[value] ?? 0) + 1;
+  }
+  return counts;
+}
+function mergeRecords(records) {
+  const merged = {};
+  for (const record of records) {
+    for (const [key, value] of Object.entries(record)) {
+      merged[key] = (merged[key] ?? 0) + value;
+    }
+  }
+  return merged;
+}
+function sum(items, value) {
+  return items.reduce((total, item) => total + value(item), 0);
+}
+function createListComposable(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  const collection = pluralizeTypeName(resource.entity);
+  if (!resource.operations.list?.id) return createMissingComposable(`use${collection}Query`);
+  const requiresParams = getPathParams(resource.operations.list).length > 0;
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.listParamsType}, ${names.listResponseType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function use${collection}Query(params${requiresParams ? "" : "?"}: ${names.listParamsType}): Promise<${names.listResponseType}> {
+  ${resourceName2}QueryKeys.list(params)
+  return ${resourceName2}Client.${resource.operations.list.id}(params)
+}
+`;
+}
+function createDetailComposable(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  if (!resource.operations.detail?.id) return createMissingComposable(`use${resource.entity}Query`);
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.detailResponseType}, ${names.idType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function use${resource.entity}Query(id: ${names.idType}): Promise<${names.detailResponseType}> {
+  ${resourceName2}QueryKeys.detail(id)
+  return ${resourceName2}Client.${resource.operations.detail.id}(id)
+}
+`;
+}
+function createCreateMutation(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  if (!resource.operations.create?.id) return createMissingComposable(`useCreate${resource.entity}Mutation`);
+  const pathParams = getPathParams(resource.operations.create);
+  if (pathParams.length > 0) {
+    return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.listParamsType}, ${names.createRequestType}, ${names.createResponseType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function useCreate${resource.entity}Mutation(): {
+  mutate: (input: { params: ${names.listParamsType}; payload: ${names.createRequestType} }) => Promise<${names.createResponseType}>
+  invalidate: (params: ${names.listParamsType}) => ReturnType<typeof ${resourceName2}QueryKeys.list>
+} {
+  return {
+    mutate: (input) => ${resourceName2}Client.${resource.operations.create.id}(input.params, input.payload),
+    invalidate: (params) => ${resourceName2}QueryKeys.list(params),
+  }
+}
+`;
+  }
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.createRequestType}, ${names.createResponseType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function useCreate${resource.entity}Mutation(): {
+  mutate: (payload: ${names.createRequestType}) => Promise<${names.createResponseType}>
+  invalidate: () => ReturnType<typeof ${resourceName2}QueryKeys.list>
+} {
+  return {
+    mutate: (payload: ${names.createRequestType}) => ${resourceName2}Client.${resource.operations.create.id}(payload),
+    invalidate: () => ${resourceName2}QueryKeys.list(),
+  }
+}
+`;
+}
+function createUpdateMutation(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  if (!resource.operations.update?.id) return createMissingComposable(`useUpdate${resource.entity}Mutation`);
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.idType}, ${names.updateRequestType}, ${names.updateResponseType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function useUpdate${resource.entity}Mutation(): {
+  mutate: (input: { id: ${names.idType}; payload: ${names.updateRequestType} }) => Promise<${names.updateResponseType}>
+  invalidate: (id: ${names.idType}) => ReturnType<typeof ${resourceName2}QueryKeys.detail>
+} {
+  return {
+    mutate: ({ id, payload }) => ${resourceName2}Client.${resource.operations.update.id}(id, payload),
+    invalidate: (id) => ${resourceName2}QueryKeys.detail(id),
+  }
+}
+`;
+}
+function createDeleteMutation(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  if (!resource.operations.delete?.id) return createMissingComposable(`useDelete${resource.entity}Mutation`);
+  const requiresListParams = getPathParams(resource.operations.delete).length > 1;
+  if (requiresListParams) {
+    return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.idType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function useDelete${resource.entity}Mutation(): {
+  mutate: (id: ${names.idType}) => Promise<void>
+  invalidate: (id: ${names.idType}) => ReturnType<typeof ${resourceName2}QueryKeys.detail>
+} {
+  return {
+    mutate: (id) => ${resourceName2}Client.${resource.operations.delete.id}(id),
+    invalidate: (id) => ${resourceName2}QueryKeys.detail(id),
+  }
+}
+`;
+  }
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import { ${resourceName2}QueryKeys } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.query-keys'
+import type { ${names.idType} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+export function useDelete${resource.entity}Mutation(): {
+  mutate: (id: ${names.idType}) => Promise<void>
+  invalidate: () => ReturnType<typeof ${resourceName2}QueryKeys.list>
+} {
+  return {
+    mutate: (id) => ${resourceName2}Client.${resource.operations.delete.id}(id),
+    invalidate: () => ${resourceName2}QueryKeys.list(),
+  }
+}
+`;
+}
+function createOperationComposable(resourceName2, operation) {
+  const names = createOperationTypeNames(operation);
+  const composableName = operationComposableName(operation);
+  const hasPayload = Boolean(operation.requestBodySchema);
+  const hasParams = getOperationParams(operation).length > 0;
+  const imports = [
+    ...hasPayload ? [names.requestType] : [],
+    ...hasParams ? [names.paramsType] : [],
+    names.responseType
+  ];
+  return `import { ${resourceName2}Client } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.client'
+import type { ${imports.join(", ")} } from '../../../shared/api/generated/${resourceName2}/${resourceName2}.types'
+
+type ${toInputTypeName(operation)} = ${operationInputType(names, hasPayload, hasParams)}
+
+export function ${composableName}(): {
+  mutate: (input: ${toInputTypeName(operation)}) => Promise<${names.responseType}>
+} {
+  return {
+    mutate: (input) => ${operationClientCall(resourceName2, operation, hasPayload, hasParams, true)},
+  }
+}
+`;
+}
+function operationComposableName(operation) {
+  const operationName = createOperationTypeNames(operation).requestType.replace(/OperationRequest$/, "");
+  return `use${operationName}${operation.method === "get" ? "Query" : "Mutation"}`;
+}
+function createMissingComposable(name) {
+  return `export function ${name}(): never {
+  throw new Error('${name} is not available: missing OpenAPI operation for this resource.')
+}
+`;
+}
+function toInputTypeName(operation) {
+  return `${createOperationTypeNames(operation).requestType.replace(/Request$/, "")}Input`;
+}
+function operationInputType(names, hasPayload, hasParams) {
+  if (hasPayload && hasParams) return `{ payload: ${names.requestType}; params: ${names.paramsType} }`;
+  if (hasPayload) return names.requestType;
+  if (hasParams) return names.paramsType;
+  return "void";
+}
+function operationClientCall(resourceName2, operation, hasPayload, hasParams, fromInput) {
+  const target = `${resourceName2}Client.${operation.id}`;
+  if (hasPayload && hasParams) return `${target}(${fromInput ? "input.payload, input.params" : "payload, params"})`;
+  if (hasPayload) return `${target}(${fromInput ? "input" : "payload"})`;
+  if (hasParams) return `${target}(${fromInput ? "input" : "params"})`;
+  return `${target}()`;
+}
+var neutralComposables = {
+  list: createListComposable,
+  detail: createDetailComposable,
+  createMutation: createCreateMutation,
+  updateMutation: createUpdateMutation,
+  deleteMutation: createDeleteMutation,
+  operation: createOperationComposable
+};
+function extractPathParameters(path) {
+  const params = [];
+  forEachPathParameter(path, (name) => {
+    params.push(name);
+  });
+  return params;
+}
+function hasPathParameters(path) {
+  let found = false;
+  forEachPathParameter(path, () => {
+    found = true;
+  });
+  return found;
+}
+function renderPathTemplate(path, renderParameter) {
+  let output = "";
+  let cursor = 0;
+  forEachPathParameter(path, (name, start, end) => {
+    output += path.slice(cursor, start);
+    output += renderParameter(name);
+    cursor = end + 1;
+  });
+  return output + path.slice(cursor);
+}
+function forEachPathParameter(path, visit) {
+  let index = 0;
+  while (index < path.length) {
+    const start = path.indexOf("{", index);
+    if (start === -1) return;
+    const end = path.indexOf("}", start + 1);
+    if (end === -1) return;
+    const name = path.slice(start + 1, end);
+    if (name.length > 0) {
+      visit(name, start, end);
+    }
+    index = end + 1;
+  }
+}
+function createClientArtifact(normalized, resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  const requestOptionsType = `${toSafeTypeName(resource.name)}RequestOptions`;
+  const signatures = [];
+  const implementations = [];
+  if (resource.operations.list?.id) {
+    const response = resource.operations.list.responseSchema || resource.operations.list.responseBodyEmpty ? names.listResponseType : "unknown";
+    const pathParams = getPathParams(resource.operations.list);
+    const queryParams = getQueryParams(resource.operations.list);
+    const requiresParams = pathParams.length > 0;
+    signatures.push(`  ${resource.operations.list.id}: (params${requiresParams ? "" : "?"}: ${names.listParamsType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    implementations.push(
+      `  ${resource.operations.list.id}: (params, options) => apiClient.request<${response}>('GET', ${pathWithParamsObject(resource.operations.list.path)}${createListRequestOptions(queryParams, requiresParams)}),`
+    );
+  }
+  if (resource.operations.detail?.id) {
+    const response = names.detailResponseType;
+    const pathParams = getPathParams(resource.operations.detail);
+    const paramSignature = createPathParamSignature(pathParams, names.idType);
+    const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
+    signatures.push(`  ${resource.operations.detail.id}: (${paramName}: ${paramSignature}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    implementations.push(
+      `  ${resource.operations.detail.id}: (${paramName}, options) => apiClient.request<${response}>('GET', ${pathWithParams(resource.operations.detail.path, pathParams)}, options),`
+    );
+  }
+  if (resource.operations.create?.id) {
+    const response = names.createResponseType;
+    const pathParams = getPathParams(resource.operations.create);
+    if (pathParams.length > 0) {
+      signatures.push(`  ${resource.operations.create.id}: (params: ${names.listParamsType}, payload: ${names.createRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+      implementations.push(
+        `  ${resource.operations.create.id}: (params, payload, options) => apiClient.request<${response}>('POST', ${pathWithParamsObject(resource.operations.create.path)}, { ...options, body: payload }),`
+      );
+    } else {
+      signatures.push(`  ${resource.operations.create.id}: (payload: ${names.createRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+      implementations.push(
+        `  ${resource.operations.create.id}: (payload, options) => apiClient.request<${response}>('POST', '${resource.operations.create.path}', { ...options, body: payload }),`
+      );
+    }
+  }
+  if (resource.operations.update?.id) {
+    const response = names.updateResponseType;
+    const pathParams = getPathParams(resource.operations.update);
+    const paramSignature = createPathParamSignature(pathParams, names.idType);
+    const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
+    signatures.push(`  ${resource.operations.update.id}: (${paramName}: ${paramSignature}, payload: ${names.updateRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    implementations.push(
+      `  ${resource.operations.update.id}: (${paramName}, payload, options) => apiClient.request<${response}>('PATCH', ${pathWithParams(resource.operations.update.path, pathParams)}, { ...options, body: payload }),`
+    );
+  }
+  if (resource.operations.delete?.id) {
+    const pathParams = getPathParams(resource.operations.delete);
+    const paramSignature = createPathParamSignature(pathParams, names.idType);
+    const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
+    signatures.push(`  ${resource.operations.delete.id}: (${paramName}: ${paramSignature}, options?: ${requestOptionsType}) => Promise<void>`);
+    implementations.push(
+      `  ${resource.operations.delete.id}: (${paramName}, options) => apiClient.request<void>('DELETE', ${pathWithParams(resource.operations.delete.path, pathParams)}, options),`
+    );
+  }
+  for (const operation of resource.operationsList.filter((item) => isGeneratedOperation(resource, item))) {
+    const names2 = createOperationTypeNames(operation);
+    const response = names2.responseType;
+    const params = getOperationParams(operation);
+    const queryParams = getQueryParams(operation);
+    const headerParams = getHeaderParams(operation);
+    const method = operation.method.toUpperCase();
+    const pathExpression = pathWithOperationParams(operation.path);
+    const options = createOperationRequestOptions(operation.requestBodySchema ? "payload" : null, queryParams, headerParams);
+    signatures.push(`  ${operation.id}: ${createOperationSignature(names2, Boolean(operation.requestBodySchema), params.length > 0, response, requestOptionsType)}`);
+    implementations.push(`  ${operation.id}: ${createOperationImplementationArgs(Boolean(operation.requestBodySchema), params.length > 0)} => apiClient.request<${response}>('${method}', ${pathExpression}${options}),`);
+  }
+  const imports = collectClientTypes(resource);
+  const typeImport = imports.length > 0 ? `import type { ${imports.join(", ")} } from './${resourceName2}.types'
+
+` : "";
+  const runtimeImports = ["createApiClient", ...usesQueryParamWrapper(resource) ? ["queryParam"] : []];
+  const entityCollectionName = pluralizeTypeName(resource.entity);
+  const configureName = `configure${entityCollectionName}Client`;
+  const setName = `set${entityCollectionName}Client`;
+  const operationHeaderHelper = resource.operationsList.filter((operation) => isGeneratedOperation(resource, operation)).some((operation) => getHeaderParams(operation).length > 0) ? `
+function createOperationHeaders(base: Record<string, string> | undefined, params: Record<string, unknown>): Record<string, string> {
+  const headers = { ...(base ?? {}) }
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) headers[key] = String(value)
+  }
+  return headers
+}
+` : "";
+  return `import { ${runtimeImports.join(", ")}, type ApiClient, type ApiClientOptions, type ApiRequestOptions } from '@archora/forge-runtime'
+${typeImport}export type ${requestOptionsType} = Omit<ApiRequestOptions, 'body' | 'params'>
+
+let apiClient = createApiClient({ baseUrl: '' })
+
+export function ${configureName}(options: ApiClientOptions): void {
+  apiClient = createApiClient(options)
+}
+
+export function ${setName}(client: ApiClient): void {
+  apiClient = client
+}
+
+export const ${resourceName2}Client: {
+${signatures.join("\n")}
+} = {
+${implementations.join("\n")}
+}
+${operationHeaderHelper}`;
+}
+function collectClientTypes(resource) {
+  const names = createResourceTypeNames(resource);
+  const types = /* @__PURE__ */ new Set();
+  if (resource.operations.list?.id) {
+    types.add(names.listParamsType);
+    if (resource.operations.list.responseSchema || resource.operations.list.responseBodyEmpty) types.add(names.listResponseType);
+  }
+  if (resource.operations.detail?.id) {
+    types.add(names.idType);
+    types.add(names.detailResponseType);
+  }
+  if (resource.operations.create?.id) {
+    if (!resource.operations.list?.id && getPathParams(resource.operations.create).length > 0) types.add(names.listParamsType);
+    types.add(names.createRequestType);
+    types.add(names.createResponseType);
+  }
+  if (resource.operations.update?.id) {
+    types.add(names.idType);
+    types.add(names.updateRequestType);
+    types.add(names.updateResponseType);
+  }
+  if (resource.operations.delete?.id) {
+    types.add(names.idType);
+  }
+  for (const operation of resource.operationsList.filter((item) => isGeneratedOperation(resource, item))) {
+    const operationNames = createOperationTypeNames(operation);
+    if (getOperationParams(operation).length > 0) types.add(operationNames.paramsType);
+    if (operation.requestBodySchema) types.add(operationNames.requestType);
+    types.add(operationNames.responseType);
+  }
+  return [...types];
+}
+function createPathParamSignature(params, singleType) {
+  return params.length <= 1 ? singleType : singleType;
+}
+function pathWithParams(path, params) {
+  if (params.length <= 1) {
+    const paramName = toSafeIdentifier(params[0]?.name ?? "id");
+    return `\`${renderPathTemplate(path, () => `\${${encodePathParam(paramName)}}`)}\``;
+  }
+  return `\`${renderPathTemplate(path, (name) => `\${${encodePathParam(paramValueAccess("params", name))}}`)}\``;
+}
+function pathWithParamsObject(path) {
+  return `\`${renderPathTemplate(path, (name) => `\${${encodePathParam(paramValueAccess("params", name))}}`)}\``;
+}
+function isGeneratedOperation(resource, operation) {
+  return operation.operationKind !== "unsupported-operation" && Boolean(operation.id) && !Object.values(resource.operations).includes(operation);
+}
+function createOperationSignature(names, hasPayload, hasParams, response, requestOptionsType) {
+  if (hasPayload && hasParams) return `(payload: ${names.requestType}, params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  if (hasPayload) return `(payload: ${names.requestType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  if (hasParams) return `(params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  return `(options?: ${requestOptionsType}) => Promise<${response}>`;
+}
+function createOperationImplementationArgs(hasPayload, hasParams) {
+  if (hasPayload && hasParams) return "(payload, params, options)";
+  if (hasPayload) return "(payload, options)";
+  if (hasParams) return "(params, options)";
+  return "(options)";
+}
+function createOperationRequestOptions(payloadName, queryParams, headerParams) {
+  const options = [];
+  options.push("...options");
+  if (payloadName) options.push(`body: ${payloadName}`);
+  if (queryParams.length > 0) {
+    options.push(`params: ${createQueryParamsObject(queryParams, false)}`);
+  }
+  if (headerParams.length > 0) {
+    options.push(`headers: createOperationHeaders(options?.headers, { ${headerParams.map((param) => `${quoteObjectKeyIfNeeded(param.name)}: ${paramValueAccess("params", param.name)}`).join(", ")} })`);
+  }
+  return options.length > 1 ? `, { ${options.join(", ")} }` : ", options";
+}
+function createListRequestOptions(queryParams, requiresParams) {
+  if (queryParams.length === 0) return ", options";
+  if (!requiresParams && !queryParams.some(requiresQueryParamWrapper)) return ", { ...options, params: params as Record<string, unknown> | undefined }";
+  return `, { ...options, params: ${createQueryParamsObject(queryParams, !requiresParams)} }`;
+}
+function pathWithOperationParams(path) {
+  if (!hasPathParameters(path)) return `'${path}'`;
+  return `\`${renderPathTemplate(path, (name) => `\${${encodePathParam(paramValueAccess("params", name))}}`)}\``;
+}
+function encodePathParam(expression) {
+  return `encodeURIComponent(String(${expression}))`;
+}
+function paramValueAccess(objectName, paramName) {
+  return /^[A-Za-z_$][\w$]*$/.test(paramName) ? `${objectName}.${paramName}` : `${objectName}[${JSON.stringify(paramName)}]`;
+}
+function createQueryParamsObject(queryParams, optionalParams) {
+  return `{ ${queryParams.map((param) => `${quoteObjectKeyIfNeeded(param.name)}: ${queryParamValue(param, optionalParams)}`).join(", ")} }`;
+}
+function queryParamValue(param, optionalParams) {
+  const access22 = optionalParams ? optionalParamValueAccess("params", param.name) : paramValueAccess("params", param.name);
+  if (!requiresQueryParamWrapper(param)) return access22;
+  return `queryParam(${access22}, { style: 'form', explode: false })`;
+}
+function optionalParamValueAccess(objectName, paramName) {
+  return /^[A-Za-z_$][\w$]*$/.test(paramName) ? `${objectName}?.${paramName}` : `${objectName}?.[${JSON.stringify(paramName)}]`;
+}
+function requiresQueryParamWrapper(param) {
+  return param.in === "query" && param.schema?.type === "array" && (param.style ?? "form") === "form" && param.explode === false;
+}
+function usesQueryParamWrapper(resource) {
+  return resource.operationsList.some((operation) => getQueryParams(operation).some(requiresQueryParamWrapper));
+}
+function createFixturesArtifact(resourceName2, entity) {
+  return `export const ${resourceName2}Fixtures: ${entity}Fixture[] = []
+
+type ${entity}Fixture = Record<string, unknown>
+`;
+}
+function createHandlersArtifact(resourceName2) {
+  return `export const ${resourceName2}Handlers = {
+  list: () => ({ status: 200, body: [] }),
+  detail: () => ({ status: 200, body: {} }),
+  create: () => ({ status: 201, body: {} }),
+  validationError: () => ({ status: 422, body: { message: 'Validation error' } }),
+  forbidden: () => ({ status: 403, body: { message: 'Forbidden' } }),
+  serverError: () => ({ status: 500, body: { message: 'Server error' } }),
+} as const
+`;
+}
+function createScenariosArtifact(resourceName2) {
+  return `export const ${resourceName2}Scenarios = ['success-list', 'empty-list', 'detail-success', 'create-success', 'validation-error', 'forbidden', 'server-error'] as const
+`;
+}
+function toCode(value) {
+  return JSON.stringify(value, null, 2).replace(/"([^"]+)":/g, "$1:");
+}
+function createPermissionsArtifact(resourceName2, config) {
+  return `export const ${resourceName2}Permissions = {
+  view: '${resourceName2}.read',
+  create: '${resourceName2}.create',
+  update: '${resourceName2}.update',
+  delete: '${resourceName2}.delete',
+} as const
+`.replace(`'${resourceName2}.read'`, `'${config?.permissions?.view ?? `${resourceName2}.read`}'`).replace(`'${resourceName2}.create'`, `'${config?.permissions?.create ?? `${resourceName2}.create`}'`).replace(`'${resourceName2}.update'`, `'${config?.permissions?.update ?? `${resourceName2}.update`}'`).replace(`'${resourceName2}.delete'`, `'${config?.permissions?.delete ?? `${resourceName2}.delete`}'`);
+}
+function createI18nArtifact(resourceName2, entity, model) {
+  const collection = pluralizeTypeName(entity);
+  const fields = [
+    ...model.formFields.map((field) => field.name),
+    ...model.filterFields.map((field) => field.name),
+    ...model.tableColumns.map((column) => column.name)
+  ];
+  const uniqueFields = [...new Set(fields)].map((field) => `    ${quoteObjectKeyIfNeeded(field)}: '${field.replace(/([A-Z])/g, " $1").replace(/^./, (char) => char.toUpperCase())}',`).join("\n");
+  return `export const ${resourceName2}I18n = {
+  title: '${collection}',
+  create: 'Create ${entity.toLowerCase()}',
+  edit: 'Edit ${entity.toLowerCase()}',
+  delete: 'Delete ${entity.toLowerCase()}',
+  fields: {
+${uniqueFields}
+  },
+} as const
+`;
+}
+function createResourceConfigArtifact(resourceName2, model) {
+  return `export const ${resourceName2}Config = {
+  resource: '${resourceName2}',
+  pagination: ${toCode(model.pagination)},
+  fields: ${toCode(model.formFields)},
+  filters: ${toCode(model.filterFields)},
+  columns: ${toCode(model.tableColumns)},
+} as const
+`;
+}
+function createIndex(exports) {
+  return `${exports.map((item) => `export * from './${item}'`).join("\n")}
+`;
+}
+function createQueryKeysArtifact(resourceName2, resource) {
+  const names = createResourceTypeNames(resource);
+  const requiresListParams = getPathParams(resource.operations.list).length > 0;
+  return `import type { ${names.idType}, ${names.listParamsType} } from './${resourceName2}.types'
+
+export const ${resourceName2}QueryKeys = {
+  all: ['${resourceName2}'] as const,
+  list: (params${requiresListParams ? "" : "?"}: ${names.listParamsType}) => [...${resourceName2}QueryKeys.all, 'list', params] as const,
+  detail: (id: ${names.idType}) => [...${resourceName2}QueryKeys.all, 'detail', id] as const,
+} as const
+`;
+}
+function createValidationSchemas(normalized, resourceName2, resource, validation) {
+  if (validation === "valibot") {
+    const createSchema2 = resource.operations.create?.requestBodySchema;
+    const updateSchema2 = resource.operations.update?.requestBodySchema;
+    const entity2 = resource.entity.charAt(0).toLowerCase() + resource.entity.slice(1);
+    return `import * as v from 'valibot'
+
+export const create${resource.entity}Schema = ${schemaToValibot(normalized, createSchema2)}
+
+export const update${resource.entity}Schema = ${schemaToValibot(normalized, updateSchema2)}
+
+export const ${entity2}ValidationSchemas = {
+  create: create${resource.entity}Schema,
+  update: update${resource.entity}Schema,
+} as const
+`;
+  }
+  const createSchema = resource.operations.create?.requestBodySchema;
+  const updateSchema = resource.operations.update?.requestBodySchema;
+  const entity = resource.entity.charAt(0).toLowerCase() + resource.entity.slice(1);
+  return `import { z } from 'zod'
+
+export const create${resource.entity}Schema = ${schemaToZod(normalized, createSchema)}
+
+export const update${resource.entity}Schema = ${schemaToZod(normalized, updateSchema)}
+
+export const ${entity}ValidationSchemas = {
+  create: create${resource.entity}Schema,
+  update: update${resource.entity}Schema,
+} as const
+`;
+}
+function schemaToZod(normalized, schema, resolvingRefs = []) {
+  if (schema?.$ref) {
+    const refName = resolveSchemaName(schema);
+    if (refName && resolvingRefs.includes(refName)) {
+      return appendNullable("z.lazy(() => z.unknown())", schema);
+    }
+    const resolved2 = resolveSchema(normalized, schema);
+    if (!resolved2 || resolved2 === schema) return appendNullable("z.unknown()", schema);
+    return schemaToZod(normalized, resolved2, refName ? [...resolvingRefs, refName] : resolvingRefs);
+  }
+  const resolved = resolveSchema(normalized, schema);
+  if (!resolved) return "z.object({}).passthrough()";
+  if (Array.isArray(resolved.type)) {
+    const normalizedSchema = normalizeNullableTypeArray(resolved);
+    if (normalizedSchema) return schemaToZod(normalized, normalizedSchema, resolvingRefs);
+    return appendNullable("z.unknown()", resolved);
+  }
+  if (resolved.oneOf?.length || resolved.anyOf?.length) {
+    return appendNullable(createZodUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs), resolved);
+  }
+  if (hasConst2(resolved)) return appendNullable(`z.literal(${JSON.stringify(resolved.const)})`, resolved);
+  if (resolved.enum?.length) return appendNullable(createZodEnum(resolved.enum), resolved);
+  if (resolved.type === "string") return zodString(resolved);
+  if (resolved.type === "integer") return appendNullable("z.number().int()", resolved);
+  if (resolved.type === "number") return appendNullable(zodNumber(resolved), resolved);
+  if (resolved.type === "boolean") return appendNullable("z.boolean()", resolved);
+  if (resolved.type === "array") return appendNullable(`z.array(${schemaToZod(normalized, resolved.items, resolvingRefs)})`, resolved);
+  if (isPureDictionarySchema2(resolved)) {
+    return appendNullable(`z.record(z.string(), ${schemaToZodRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`, resolved);
+  }
+  if (resolved.type === "object" || resolved.properties) {
+    const required = new Set(resolved.required ?? []);
+    const fields = Object.entries(resolved.properties ?? {}).map(([name, property]) => {
+      const base = schemaToZod(normalized, property, resolvingRefs);
+      const optional = required.has(name) ? base : `${base}.optional()`;
+      return `  ${toCodeKey(name)}: ${optional},`;
+    }).join("\n");
+    return appendNullable(`z.object({
+${fields}
+})`, resolved);
+  }
+  return appendNullable("z.unknown()", resolved);
+}
+function schemaToValibot(normalized, schema, resolvingRefs = []) {
+  if (schema?.$ref) {
+    const refName = resolveSchemaName(schema);
+    if (refName && resolvingRefs.includes(refName)) {
+      return wrapValibotNullable("v.lazy(() => v.unknown())", schema);
+    }
+    const resolved2 = resolveSchema(normalized, schema);
+    if (!resolved2 || resolved2 === schema) return wrapValibotNullable("v.unknown()", schema);
+    return schemaToValibot(normalized, resolved2, refName ? [...resolvingRefs, refName] : resolvingRefs);
+  }
+  const resolved = resolveSchema(normalized, schema);
+  if (!resolved) return "v.looseObject({})";
+  if (Array.isArray(resolved.type)) {
+    const normalizedSchema = normalizeNullableTypeArray(resolved);
+    if (normalizedSchema) return schemaToValibot(normalized, normalizedSchema, resolvingRefs);
+    return wrapValibotNullable("v.unknown()", resolved);
+  }
+  if (resolved.oneOf?.length || resolved.anyOf?.length) {
+    return wrapValibotNullable(createValibotUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs), resolved);
+  }
+  if (hasConst2(resolved)) return wrapValibotNullable(`v.literal(${JSON.stringify(resolved.const)})`, resolved);
+  if (resolved.enum?.length) {
+    return wrapValibotNullable(`v.picklist([${resolved.enum.map((value) => JSON.stringify(value)).join(", ")}])`, resolved);
+  }
+  if (resolved.type === "string") return valibotString(resolved);
+  if (resolved.type === "integer") return wrapValibotNullable("v.pipe(v.number(), v.integer())", resolved);
+  if (resolved.type === "number") return wrapValibotNullable(valibotNumber(resolved), resolved);
+  if (resolved.type === "boolean") return wrapValibotNullable("v.boolean()", resolved);
+  if (resolved.type === "array") return wrapValibotNullable(`v.array(${schemaToValibot(normalized, resolved.items, resolvingRefs)})`, resolved);
+  if (isPureDictionarySchema2(resolved)) {
+    return wrapValibotNullable(`v.record(v.string(), ${schemaToValibotRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`, resolved);
+  }
+  if (resolved.type === "object" || resolved.properties) {
+    const required = new Set(resolved.required ?? []);
+    const fields = Object.entries(resolved.properties ?? {}).map(([name, property]) => {
+      const base = schemaToValibot(normalized, property, resolvingRefs);
+      const optional = required.has(name) ? base : `v.optional(${base})`;
+      return `  ${toCodeKey(name)}: ${optional},`;
+    }).join("\n");
+    return wrapValibotNullable(`v.object({
+${fields}
+})`, resolved);
+  }
+  return wrapValibotNullable("v.unknown()", resolved);
+}
+function zodString(schema) {
+  let expression = "z.string()";
+  if (schema.format === "email") expression += ".email()";
+  if (schema.format === "uuid") expression += ".uuid()";
+  if (schema.format === "uri") expression += ".url()";
+  if (schema.format === "date") expression += ".date()";
+  if (schema.format === "date-time") expression += ".datetime()";
+  if (schema.minLength !== void 0) expression += `.min(${schema.minLength})`;
+  if (schema.maxLength !== void 0) expression += `.max(${schema.maxLength})`;
+  return appendNullable(expression, schema);
+}
+function zodNumber(schema) {
+  let expression = "z.number()";
+  if (schema.minimum !== void 0) expression += `.min(${schema.minimum})`;
+  if (schema.maximum !== void 0) expression += `.max(${schema.maximum})`;
+  return expression;
+}
+function appendNullable(expression, schema) {
+  return schema.nullable ? `${expression}.nullable()` : expression;
+}
+function createZodEnum(values) {
+  if (values.every((value) => typeof value === "string")) {
+    return `z.enum([${values.map((value) => JSON.stringify(value)).join(", ")}])`;
+  }
+  const literals = values.map((value) => `z.literal(${JSON.stringify(value)})`);
+  return literals.length === 1 ? literals[0] ?? "z.unknown()" : `z.union([${literals.join(", ")}])`;
+}
+function createZodUnion(normalized, branches, resolvingRefs) {
+  const schemas = branches.map((branch) => schemaToZod(normalized, branch, resolvingRefs));
+  if (schemas.length === 0) return "z.unknown()";
+  if (schemas.length === 1) return schemas[0] ?? "z.unknown()";
+  return `z.union([${schemas.join(", ")}])`;
+}
+function valibotString(schema) {
+  const actions = [];
+  if (schema.format === "email") actions.push("v.email()");
+  if (schema.format === "uuid") actions.push("v.uuid()");
+  if (schema.format === "uri") actions.push("v.url()");
+  if (schema.format === "date") actions.push("v.isoDate()");
+  if (schema.format === "date-time") actions.push("v.isoDateTime()");
+  if (schema.minLength !== void 0) actions.push(`v.minLength(${schema.minLength})`);
+  if (schema.maxLength !== void 0) actions.push(`v.maxLength(${schema.maxLength})`);
+  const expression = actions.length === 0 ? "v.string()" : `v.pipe(v.string(), ${actions.join(", ")})`;
+  return wrapValibotNullable(expression, schema);
+}
+function valibotNumber(schema) {
+  const actions = [];
+  if (schema.minimum !== void 0) actions.push(`v.minValue(${schema.minimum})`);
+  if (schema.maximum !== void 0) actions.push(`v.maxValue(${schema.maximum})`);
+  return actions.length === 0 ? "v.number()" : `v.pipe(v.number(), ${actions.join(", ")})`;
+}
+function wrapValibotNullable(expression, schema) {
+  return schema.nullable ? `v.nullable(${expression})` : expression;
+}
+function createValibotUnion(normalized, branches, resolvingRefs) {
+  const schemas = branches.map((branch) => schemaToValibot(normalized, branch, resolvingRefs));
+  if (schemas.length === 0) return "v.unknown()";
+  if (schemas.length === 1) return schemas[0] ?? "v.unknown()";
+  return `v.union([${schemas.join(", ")}])`;
+}
+function isPureDictionarySchema2(schema) {
+  return Boolean(
+    (schema.type === "object" || schema.additionalProperties !== void 0) && schema.additionalProperties !== void 0 && Object.keys(schema.properties ?? {}).length === 0
+  );
+}
+function normalizeNullableTypeArray(schema) {
+  if (!Array.isArray(schema.type)) return schema;
+  const nonNullTypes = schema.type.filter((type) => type !== "null");
+  if (nonNullTypes.length !== 1) return null;
+  return {
+    ...schema,
+    type: nonNullTypes[0],
+    nullable: schema.nullable || schema.type.includes("null")
+  };
+}
+function schemaToZodRecordValue(normalized, additionalProperties, resolvingRefs) {
+  if (additionalProperties === false) return "z.never()";
+  if (additionalProperties === true || additionalProperties === void 0) return "z.unknown()";
+  return schemaToZod(normalized, additionalProperties, resolvingRefs);
+}
+function schemaToValibotRecordValue(normalized, additionalProperties, resolvingRefs) {
+  if (additionalProperties === false) return "v.never()";
+  if (additionalProperties === true || additionalProperties === void 0) return "v.unknown()";
+  return schemaToValibot(normalized, additionalProperties, resolvingRefs);
+}
+function toCodeKey(value) {
+  return /^[A-Za-z_$][\w$]*$/.test(value) ? value : JSON.stringify(value);
+}
+function hasConst2(schema) {
+  return Object.hasOwn(schema, "const");
+}
+async function formatGeneratedContent(path, content) {
+  const parser = getParser(path);
+  if (!parser) {
+    return content;
+  }
+  try {
+    return await format(content, {
+      parser,
+      singleQuote: true,
+      semi: false,
+      trailingComma: "all",
+      printWidth: 100
+    });
+  } catch {
+    return content;
+  }
+}
+function getParser(path) {
+  if (path.endsWith(".ts")) return "typescript";
+  return null;
+}
+function createResourceUiModel(input) {
+  const entitySchema = resolveEntitySchema(input.normalized, input.resource);
+  const formSchema = resolveOperationBodySchema(input.normalized, input.resource.operations.create) ?? entitySchema;
+  const tableSchema = resolveListItemSchema(input.normalized, input.resource.operations.list) ?? entitySchema;
+  const formRequired = new Set(formSchema?.required ?? entitySchema?.required ?? []);
+  const tableProperties = tableSchema?.properties ?? {};
+  const formProperties = formSchema?.properties ?? tableProperties;
+  return {
+    resourceName: input.resource.name,
+    entityName: input.resource.entity,
+    formFields: selectProperties(formProperties, input.config?.form?.fields).filter(([, schema]) => !schema.readOnly).map(([name, schema]) => createFormField(name, schema, formRequired.has(name))),
+    filterFields: selectProperties(tableProperties, input.config?.table?.filters).filter(([, schema]) => !schema.writeOnly).map(([name, schema]) => createFormField(name, schema, false)),
+    tableColumns: selectProperties(tableProperties, input.config?.table?.columns).filter(([, schema]) => !schema.writeOnly).map(([name, schema]) => createTableColumn(name, schema)),
+    pagination: detectPagination(input.normalized, input.resource.operations.list)
+  };
+}
+function selectProperties(properties, explicitOrder) {
+  if (!explicitOrder || explicitOrder.length === 0) {
+    return Object.entries(properties);
+  }
+  return explicitOrder.flatMap((name) => {
+    const schema = properties[name];
+    return schema ? [[name, schema]] : [];
+  });
+}
+function createFormField(name, schema, required) {
+  return {
+    name,
+    label: toLabel(name),
+    input: mapFormInput(name, schema),
+    component: mapFieldComponent(name, schema),
+    required,
+    nullable: schema.nullable ?? isNullableTypeArray(schema),
+    enumValues: schema.enum,
+    ...Object.hasOwn(schema, "default") ? { defaultValue: schema.default } : {},
+    ...schema.deprecated ? { deprecated: true } : {},
+    hint: schema.description,
+    validation: {
+      minLength: schema.minLength,
+      maxLength: schema.maxLength,
+      minimum: schema.minimum,
+      maximum: schema.maximum
+    }
+  };
+}
+function createTableColumn(name, schema) {
+  const type = primarySchemaType(schema);
+  return {
+    name,
+    label: toLabel(name),
+    cell: mapTableCell(schema),
+    sortable: ["string", "number", "integer"].includes(type ?? "") || schema.format === "date" || schema.format === "date-time",
+    nullable: schema.nullable ?? isNullableTypeArray(schema),
+    ...schema.deprecated ? { deprecated: true } : {},
+    hint: schema.description
+  };
+}
+function mapFormInput(name, schema) {
+  if (schema.enum) return "select";
+  const type = primarySchemaType(schema);
+  if (name.toLowerCase().includes("password")) return "password";
+  if (schema.format === "email") return "email";
+  if (schema.format === "uri") return "url";
+  if (schema.format === "date") return "date";
+  if (schema.format === "date-time") return "dateTime";
+  if (type === "number" || type === "integer") return "number";
+  if (type === "boolean") return "switch";
+  if ((schema.maxLength ?? 0) > 160) return "textarea";
+  return "text";
+}
+function mapFieldComponent(name, schema) {
+  const input = mapFormInput(name, schema);
+  if (input === "select") return "ArchSelect";
+  if (input === "switch") return "ArchSwitch";
+  if (input === "date" || input === "dateTime") return "ArchDatePicker";
+  if (input === "textarea") return "ArchTextarea";
+  return "ArchInput";
+}
+function mapTableCell(schema) {
+  if (schema.enum) return "badge";
+  const type = primarySchemaType(schema);
+  if (schema.format === "date") return "date";
+  if (schema.format === "date-time") return "dateTime";
+  if (type === "boolean") return "boolean";
+  if (type === "number" || type === "integer") return "number";
+  if (type === "object" || type === "array") return "json";
+  return "text";
+}
+function primarySchemaType(schema) {
+  return Array.isArray(schema.type) ? schema.type.find((type) => type !== "null") : schema.type;
+}
+function isNullableTypeArray(schema) {
+  return Array.isArray(schema.type) && schema.type.includes("null");
+}
+function detectPagination(normalized, operation) {
+  const responseSchema = operation?.responseSchema ? resolveSchema2(normalized, operation.responseSchema) : null;
+  const properties = responseSchema?.properties ?? {};
+  const itemsPath = properties.items?.type === "array" ? "items" : void 0;
+  const totalPath = properties.total ? "total" : properties.totalCount ? "totalCount" : void 0;
+  const pagePath = properties.page ? "page" : properties.pageIndex ? "pageIndex" : void 0;
+  return {
+    enabled: Boolean(itemsPath && totalPath),
+    itemsPath,
+    totalPath,
+    pagePath
+  };
+}
+function resolveEntitySchema(normalized, resource) {
+  return normalized.schemas.find((schema) => schema.name === resource.entity)?.schema ?? null;
+}
+function resolveOperationBodySchema(normalized, operation) {
+  if (!operation?.requestBodySchema) {
+    return null;
+  }
+  return resolveSchema2(normalized, operation.requestBodySchema);
+}
+function resolveListItemSchema(normalized, operation) {
+  if (!operation?.responseSchema) {
+    return null;
+  }
+  const responseSchema = resolveSchema2(normalized, operation.responseSchema);
+  if (responseSchema?.type === "array" && responseSchema.items) {
+    return resolveSchema2(normalized, responseSchema.items);
+  }
+  const items = responseSchema?.properties?.items;
+  if (items?.type === "array" && items.items) {
+    return resolveSchema2(normalized, items.items);
+  }
+  return responseSchema;
+}
+function resolveSchema2(normalized, schema) {
+  if (schema.$ref) {
+    const name = schema.$ref.split("/").at(-1);
+    return normalized.schemas.find((candidate) => candidate.name === name)?.schema ?? schema;
+  }
+  return schema;
+}
+function toLabel(value) {
+  return value.replace(/([A-Z])/g, " $1").replace(/[-_]+/g, " ").replace(/^./, (char) => char.toUpperCase()).trim();
+}
+async function loadTemplateOverride(path, cwd) {
+  const absolutePath = resolve22(cwd, path);
+  let loaded;
+  try {
+    loaded = await import(pathToFileURL2(absolutePath).href);
+  } catch (error) {
+    throw new Error(`Failed to load template override "${path}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const candidate = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : loaded;
+  if (typeof candidate !== "function") {
+    throw new Error(`Template override "${path}" must export a default render function.`);
+  }
+  return candidate;
+}
+async function createGenerationPlan(input) {
+  const metadata = createGeneratedFileMetadata(input);
+  const files = [
+    await createFile(input.cwd, join22(input.config.output.generatedDir, "components.types.ts"), "generated", createSharedSchemaTypes(input.normalized), true)
+  ];
+  const templateOverrides = await loadTemplateOverrides(input.config.templates?.override, input.cwd);
+  const resolvedResources = [];
+  for (const resource of input.resources) {
+    if (input.config.resources?.[resource.name]?.enabled === false) continue;
+    const resolvedResource = applyResourceConfig(resource, input.config.resources?.[resource.name]);
+    resolvedResources.push(resolvedResource);
+    files.push(...await createResourceFiles(input, resolvedResource, templateOverrides));
+  }
+  for (const artifact of await runPluginArtifactHooks({ plugins: input.config.plugins, normalized: input.normalized, cwd: input.cwd })) {
+    files.push(await createFile(input.cwd, artifact.path, artifact.kind, artifact.content, artifact.overwrite));
+  }
+  await runPluginAfterGenerateHooks({ plugins: input.config.plugins, files });
+  for (const file of files) {
+    if (file.kind === "generated") file.metadata = metadata;
+  }
+  return {
+    resources: resolvedResources.map((resource) => ({
+      ...resource,
+      outputName: resource.name,
+      permissions: {
+        view: `${resource.name}.read`,
+        create: `${resource.name}.create`,
+        update: `${resource.name}.update`,
+        delete: `${resource.name}.delete`
+      }
+    })),
+    files
+  };
+}
+function createGeneratedFileMetadata(input) {
+  return {
+    version: forgeCoreVersion,
+    schemaHash: stableHash(input.normalized),
+    configHash: stableHash({
+      output: input.config.output,
+      target: input.config.target,
+      validation: input.config.validation,
+      resources: input.config.resources,
+      templates: input.config.templates
+    })
+  };
+}
+function stableHash(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex").slice(0, 12);
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function applyResourceConfig(resource, config) {
+  return {
+    ...resource,
+    entity: config?.entity ?? resource.entity
+  };
+}
+async function createResourceFiles(input, resource, templateOverrides) {
+  const uiModel = createResourceUiModel({
+    normalized: input.normalized,
+    resource,
+    config: input.config.resources?.[resource.name]
+  });
+  const paths = resourcePaths(input.config, resource);
+  const validation = input.config.validation ?? "none";
+  const apiExports = [`${resource.name}.client`, `${resource.name}.types`, `${resource.name}.query-keys`];
+  const validationArtifact = validation === "none" ? null : createValidationSchemas(input.normalized, resource.name, resource, validation);
+  if (validationArtifact) apiExports.push(`${resource.name}.validation`);
+  const generatedFiles = [
+    [join22(paths.apiDir, `${resource.name}.client.ts`), createClientArtifact(input.normalized, resource.name, resource)],
+    [join22(paths.apiDir, `${resource.name}.types.ts`), createTypeScriptTypes(input.normalized, resource)],
+    [join22(paths.apiDir, `${resource.name}.query-keys.ts`), createQueryKeysArtifact(resource.name, resource)],
+    ...validationArtifact ? [[join22(paths.apiDir, `${resource.name}.validation.ts`), validationArtifact]] : [],
+    [join22(paths.apiDir, "index.ts"), createIndex(apiExports)],
+    ...createFeatureApiFiles(paths.featureApiDir, resource.name, resource, input.composables ?? neutralComposables),
+    ...await createModelFiles(input, resource, paths.featureModelDir, uiModel, templateOverrides),
+    ...createMockFiles(paths.mocksDir, resource)
+  ];
+  return Promise.all(generatedFiles.map(([path, content]) => createFile(input.cwd, path, "generated", content, true)));
+}
+function createFeatureApiFiles(featureApiDir, resourceName2, resource, composables) {
+  const entity = resource.entity;
+  const collection = pluralizeTypeName(entity);
+  const crudComposables = [];
+  const crudExports = [];
+  if (resource.operations.list?.id) {
+    crudComposables.push([join22(featureApiDir, `use${collection}Query.ts`), composables.list(resourceName2, resource)]);
+    crudExports.push(`use${collection}Query`);
+  }
+  if (resource.operations.detail?.id) {
+    crudComposables.push([join22(featureApiDir, `use${entity}Query.ts`), composables.detail(resourceName2, resource)]);
+    crudExports.push(`use${entity}Query`);
+  }
+  if (resource.operations.create?.id) {
+    crudComposables.push([join22(featureApiDir, `useCreate${entity}Mutation.ts`), composables.createMutation(resourceName2, resource)]);
+    crudExports.push(`useCreate${entity}Mutation`);
+  }
+  if (resource.operations.update?.id) {
+    crudComposables.push([join22(featureApiDir, `useUpdate${entity}Mutation.ts`), composables.updateMutation(resourceName2, resource)]);
+    crudExports.push(`useUpdate${entity}Mutation`);
+  }
+  if (resource.operations.delete?.id) {
+    crudComposables.push([join22(featureApiDir, `useDelete${entity}Mutation.ts`), composables.deleteMutation(resourceName2, resource)]);
+    crudExports.push(`useDelete${entity}Mutation`);
+  }
+  const generatedOperations = resource.operationsList.filter((operation) => isGeneratedOperation2(resource, operation));
+  const operationComposables = generatedOperations.map((operation) => {
+    const composableName = operationComposableName(operation);
+    return [join22(featureApiDir, `${composableName}.ts`), composables.operation(resourceName2, operation)];
+  });
+  const operationExports = generatedOperations.map(operationComposableName);
+  const exports = [...crudExports, ...operationExports];
+  return [...crudComposables, ...operationComposables, ...exports.length > 0 ? [[join22(featureApiDir, "index.ts"), createIndex(exports)]] : []];
+}
+function isGeneratedOperation2(resource, operation) {
+  return operation.operationKind !== "unsupported-operation" && Boolean(operation.id) && !Object.values(resource.operations).includes(operation);
+}
+async function createModelFiles(input, resource, featureModelDir, uiModel, templateOverrides) {
+  const config = input.config.resources?.[resource.name];
+  return [
+    [join22(featureModelDir, `${resource.name}.permissions.ts`), createPermissionsArtifact(resource.name, config)],
+    [join22(featureModelDir, `${resource.name}.i18n.ts`), await renderTemplate(templateOverrides.i18n, input.cwd, resource, uiModel, () => createI18nArtifact(resource.name, resource.entity, uiModel))],
+    [join22(featureModelDir, `${resource.name}.config.ts`), createResourceConfigArtifact(resource.name, uiModel)],
+    [join22(featureModelDir, "index.ts"), createIndex([`${resource.name}.permissions`, `${resource.name}.i18n`, `${resource.name}.config`])]
+  ];
+}
+function createMockFiles(mocksDir, resource) {
+  return [
+    [join22(mocksDir, `${resource.name}.fixtures.ts`), createFixturesArtifact(resource.name, resource.entity)],
+    [join22(mocksDir, `${resource.name}.handlers.ts`), createHandlersArtifact(resource.name)],
+    [join22(mocksDir, `${resource.name}.scenarios.ts`), createScenariosArtifact(resource.name)],
+    [join22(mocksDir, "index.ts"), createIndex([`${resource.name}.fixtures`, `${resource.name}.handlers`, `${resource.name}.scenarios`])]
+  ];
+}
+function resourcePaths(config, resource) {
+  return {
+    apiDir: join22(config.output.generatedDir, resource.name),
+    featureApiDir: join22(config.output.featuresDir, resource.name, "api"),
+    featureModelDir: join22(config.output.featuresDir, resource.name, "model"),
+    mocksDir: join22(config.output.mocksDir ?? "./src/shared/mocks", resource.name)
+  };
+}
+async function loadTemplateOverrides(overrides, cwd) {
+  const registry = {};
+  for (const [key, path] of Object.entries(overrides ?? {})) {
+    registry[key] = await loadTemplateOverride(path, cwd);
+  }
+  return registry;
+}
+async function renderTemplate(template, cwd, resource, uiModel, fallback) {
+  return template ? template({ cwd, resource, uiModel }) : fallback();
+}
+function summarizeFilePlan(files) {
+  return files.reduce(
+    (summary, file) => {
+      if (file.exists && !file.overwrite) summary.protected += 1;
+      else if (file.exists) summary.update += 1;
+      else summary.create += 1;
+      return summary;
+    },
+    { create: 0, update: 0, protected: 0 }
+  );
+}
+async function createFile(cwd, path, kind, content, overwrite) {
+  const exists = await fileExists(join22(cwd, path));
+  return {
+    path,
+    content: await formatGeneratedContent(path, content),
+    kind,
+    overwrite,
+    exists
+  };
+}
+async function fileExists(path) {
+  return access2(path).then(() => true).catch(() => false);
+}
+async function calculateDrift(files, options) {
+  const drift = [];
+  for (const file of files) {
+    if (file.kind !== "generated") continue;
+    const absolutePath = join32(options.cwd, file.path);
+    try {
+      const current = await readFile22(absolutePath, "utf8");
+      if (normalize(current) !== normalize(toWritableGeneratedContent(file))) {
+        drift.push({ path: file.path, kind: "outdated" });
+      }
+    } catch {
+      drift.push({ path: file.path, kind: "missing" });
+    }
+  }
+  return drift;
+}
+function normalize(value) {
+  return value.replace(/\r\n/g, "\n").trimEnd();
+}
+var crudOperations = ["list", "detail", "create", "update", "delete"];
+function detectResources(operations) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    const resourceName2 = createResourceGroupName(operation);
+    grouped.set(resourceName2, [...grouped.get(resourceName2) ?? [], operation]);
+  }
+  const resourceNames = createIdentifierRegistry();
+  return [...grouped.entries()].map(([rawName, operationsList]) => {
+    const name = resourceNames.identifier(rawName, "resource");
+    const resourceOperations = createCrudOperations(operationsList);
+    const operationsByKind = groupByKind(operationsList);
+    const kind = classifyResourceKind(operationsList, resourceOperations);
+    const missing = crudOperations.filter((operation) => !resourceOperations[operation]);
+    return {
+      name,
+      entity: singularize(toSafeTypeName(name, "Resource")),
+      kind,
+      operationsList,
+      operationsByKind,
+      operations: resourceOperations,
+      missing,
+      isCrudCandidate: resourceOperations.list !== void 0 && resourceOperations.detail !== void 0
+    };
+  });
+}
+function createCrudOperations(operations) {
+  const resourceOperations = {};
+  for (const operation of operations) {
+    const crudOperation = classifyCrudOperation(operation);
+    if (!crudOperation || resourceOperations[crudOperation]) continue;
+    resourceOperations[crudOperation] = operation;
+  }
+  return resourceOperations;
+}
+function classifyCrudOperation(operation) {
+  if (operation.operationKind !== "crud-resource") return null;
+  const hasResourceIdentityParam = isResourceIdentityPath(operation.path);
+  if (operation.method === "get" && !hasResourceIdentityParam) return "list";
+  if (operation.method === "get" && hasResourceIdentityParam) return "detail";
+  if (operation.method === "post" && !hasResourceIdentityParam) return "create";
+  if ((operation.method === "patch" || operation.method === "put") && hasResourceIdentityParam) return "update";
+  if (operation.method === "delete" && hasResourceIdentityParam) return "delete";
+  return null;
+}
+function isResourceIdentityPath(path) {
+  return significantSegments(path).at(-1)?.startsWith("{") ?? false;
+}
+function createResourceGroupName(operation) {
+  const segments = meaningfulSegments(operation.path);
+  if (operation.operationKind === "crud-resource") {
+    return createCrudResourceGroupName(operation.path) ?? operation.id ?? "resource";
+  }
+  return segments.length > 0 ? segments.join("-") : operation.id ?? "operation";
+}
+function createCrudResourceGroupName(path) {
+  const segments = significantSegments(path);
+  const lastIndex = segments.length - 1;
+  const last = segments.at(lastIndex);
+  if (!last) return null;
+  if (last.startsWith("{")) {
+    return segments.slice(0, lastIndex).filter((segment) => !segment.startsWith("{")).at(-1) ?? null;
+  }
+  return last;
+}
+function meaningfulSegments(path) {
+  return significantSegments(path).filter((segment) => !segment.startsWith("{"));
+}
+function significantSegments(path) {
+  return path.split("/").filter(Boolean).filter((segment) => !["api", "v1", "v2", "v3"].includes(segment.toLowerCase()));
+}
+function groupByKind(operations) {
+  const grouped = {};
+  for (const operation of operations) {
+    grouped[operation.operationKind] = [...grouped[operation.operationKind] ?? [], operation];
+  }
+  return grouped;
+}
+function classifyResourceKind(operations, resourceOperations) {
+  const hasCrudSurface = Boolean(resourceOperations.list) || Boolean(resourceOperations.create) || Boolean(resourceOperations.update) || Boolean(resourceOperations.delete) || Boolean(resourceOperations.detail) && operations.every((operation) => operation.operationKind === "crud-resource");
+  if (hasCrudSurface) return "crud-resource";
+  const order = [
+    "file-operation",
+    "search-resource",
+    "action-operation",
+    "dashboard-resource",
+    "read-only-resource",
+    "unsupported-operation"
+  ];
+  return order.find((kind) => operations.some((operation) => operation.operationKind === kind)) ?? "unsupported-operation";
+}
+function singularize(value) {
+  if (value.endsWith("ies")) {
+    return `${value.slice(0, -3)}y`;
+  }
+  if (value.endsWith("s")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function calculateSchemaHealth(normalized) {
+  const warnings = [];
+  for (const operation of normalized.operations) {
+    const target = `${operation.method.toUpperCase()} ${operation.path}`;
+    if (!operation.id) warnings.push({ code: "operation-id-missing", message: "Operation has no operationId.", target });
+    if (operation.tags.length === 0) warnings.push({ code: "tags-missing", message: "Operation has no tags.", target });
+    if (!operation.responseSchema && !operation.responseBodyEmpty) warnings.push({ code: "response-schema-missing", message: "Operation has no explicit 2xx response schema.", target });
+    if (!operation.hasErrorResponse) warnings.push({ code: "error-response-missing", message: "Operation has no 4xx/5xx response.", target });
+  }
+  const resourceCount = detectResources(normalized.operations).filter((resource) => resource.isCrudCandidate).length;
+  const score = calculateScore(normalized, warnings);
+  return {
+    score,
+    endpointCount: normalized.operations.length,
+    schemaCount: normalized.schemas.length,
+    tagCount: normalized.tags.length,
+    crudCandidateCount: resourceCount,
+    enumCount: normalized.schemas.reduce((count, schema) => count + countEnums(schema.schema), 0),
+    warnings
+  };
+}
+function calculateScore(normalized, warnings) {
+  const maxPenalty = normalized.operations.length * 8 + normalized.schemas.length * 2;
+  const warningPenalty = warnings.reduce((sum2, warning) => {
+    if (warning.code === "operation-id-missing") return sum2 + 8;
+    if (warning.code === "tags-missing") return sum2 + 6;
+    if (warning.code === "response-schema-missing") return sum2 + 8;
+    if (warning.code === "error-response-missing") return sum2 + 3;
+    return sum2 + 2;
+  }, 0);
+  const schemaBonus = normalized.schemas.length > 0 ? 5 : 0;
+  const resourceBonus = detectResources(normalized.operations).some((resource) => resource.isCrudCandidate) ? 5 : 0;
+  return Math.max(0, Math.min(100, Math.round(100 - warningPenalty / Math.max(maxPenalty, 1) * 50 + schemaBonus + resourceBonus)));
+}
+function countEnums(schema) {
+  const own = schema.enum ? 1 : 0;
+  const propertyEnums = Object.values(schema.properties ?? {}).reduce((count, property) => count + countEnums(property), 0);
+  const itemEnums = schema.items ? countEnums(schema.items) : 0;
+  return own + propertyEnums + itemEnums;
+}
+function diffOpenApiContracts(oldSchema, newSchema) {
+  const changes = [];
+  const oldOperations = operationMap(oldSchema.operations);
+  const newOperations = operationMap(newSchema.operations);
+  for (const [key, operation] of oldOperations) {
+    if (!newOperations.has(key)) {
+      const resource = resourceName(operation);
+      changes.push({
+        code: "removed-endpoint",
+        severity: "breaking",
+        resource,
+        location: key,
+        message: `${operation.method.toUpperCase()} ${operation.path} was removed.`
+      });
+    }
+  }
+  for (const [key, operation] of newOperations) {
+    const previous = oldOperations.get(key);
+    const resource = resourceName(operation);
+    if (!previous) {
+      changes.push({
+        code: "added-endpoint",
+        severity: "non-breaking",
+        resource,
+        location: key,
+        message: `${operation.method.toUpperCase()} ${operation.path} was added.`
+      });
+      continue;
+    }
+    changes.push(...diffObjectSchemas(oldSchema, newSchema, previous.requestBodySchema, operation.requestBodySchema, resource, `${key} request`));
+    changes.push(...diffObjectSchemas(oldSchema, newSchema, previous.responseSchema, operation.responseSchema, resource, `${key} response`));
+  }
+  const affectedResources = [...new Set(changes.map((change) => change.resource))].sort();
+  const affectedFiles = affectedResources.flatMap((resource) => [
+    `src/shared/api/generated/${resource}/${resource}.types.ts`,
+    `src/shared/api/generated/${resource}/${resource}.client.ts`,
+    `src/features/${resource}/api/index.ts`
+  ]);
+  const summary = summarizeChanges(changes);
+  const decision = createImpactDecision(summary);
+  const impactedSurface = collectImpactedSurface(changes, oldOperations, newOperations);
+  const migrationHints = createMigrationHints(changes);
+  const changelog = formatContractDiffChangelog({ changes, affectedResources, affectedFiles });
+  return {
+    changes,
+    affectedResources,
+    affectedFiles,
+    changelog,
+    summary,
+    decision,
+    impactedSurface,
+    migrationHints,
+    prSummary: formatPullRequestSummary({ summary, decision, affectedResources, affectedFiles, migrationHints })
+  };
+}
+function formatContractDiffChangelog(report) {
+  const lines = [];
+  const byResource = /* @__PURE__ */ new Map();
+  for (const change of report.changes) {
+    byResource.set(change.resource, [...byResource.get(change.resource) ?? [], change]);
+  }
+  for (const [resource, changes] of [...byResource.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    const breaking = changes.filter((change) => change.severity === "breaking").length;
+    const nonBreaking = changes.filter((change) => change.severity === "non-breaking").length;
+    const warnings = changes.filter((change) => change.severity === "warning").length;
+    const prefix = breaking > 0 ? "BREAKING" : warnings > 0 ? "WARNING" : "CHANGED";
+    lines.push(`${prefix} ${resource}: ${breaking} breaking, ${nonBreaking} non-breaking, ${warnings} warning changes.`);
+  }
+  if (report.affectedFiles.length > 0) {
+    lines.push(`${report.affectedFiles.length} resource contract files affected.`);
+  }
+  return lines;
+}
+function operationMap(operations) {
+  return new Map(operations.map((operation) => [`${operation.method.toUpperCase()} ${operation.path}`, operation]));
+}
+function summarizeChanges(changes) {
+  const breaking = changes.filter((change) => change.severity === "breaking").length;
+  const warnings = changes.filter((change) => change.severity === "warning").length;
+  const nonBreaking = changes.filter((change) => change.severity === "non-breaking").length;
+  return { breaking, warnings, nonBreaking, total: changes.length };
+}
+function createImpactDecision(summary) {
+  if (summary.breaking > 0) {
+    return {
+      status: "blocked",
+      mergeRisk: "high",
+      reason: `${summary.breaking} breaking frontend contract change${summary.breaking === 1 ? "" : "s"} detected.`
+    };
+  }
+  if (summary.warnings > 0) {
+    return {
+      status: "review",
+      mergeRisk: "medium",
+      reason: `${summary.warnings} schema change${summary.warnings === 1 ? "" : "s"} need frontend review.`
+    };
+  }
+  return {
+    status: "approved",
+    mergeRisk: "low",
+    reason: summary.nonBreaking > 0 ? "Only non-breaking frontend contract changes detected." : "No frontend contract changes detected."
+  };
+}
+function collectImpactedSurface(changes, oldOperations, newOperations) {
+  const operationIds = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    const operation = oldOperations.get(operationKeyFromLocation(change.location)) ?? newOperations.get(operationKeyFromLocation(change.location));
+    const operationId = operation?.sourceOperationId ?? operation?.id;
+    if (operationId) operationIds.add(operationId);
+  }
+  const sortedOperationIds = [...operationIds].sort();
+  const resources = detectResources([...new Map([...oldOperations, ...newOperations]).values()]);
+  const queryHooks = /* @__PURE__ */ new Set();
+  for (const id of sortedOperationIds) {
+    queryHooks.add(
+      `use${pascalCase(id)}${id.toLowerCase().startsWith("get") || id.toLowerCase().startsWith("list") || id.toLowerCase().startsWith("search") ? "Query" : "Mutation"}`
+    );
+    const generatedHook = generatedHookName(resources, id);
+    if (generatedHook) queryHooks.add(generatedHook);
+  }
+  return {
+    operationIds: sortedOperationIds,
+    clientMethods: sortedOperationIds.map((id) => `${id}()`),
+    queryHooks: [...queryHooks].sort()
+  };
+}
+function generatedHookName(resources, operationId) {
+  const isOp = (operation) => Boolean(operation) && (operation.id === operationId || operation.sourceOperationId === operationId);
+  for (const resource of resources) {
+    const { entity, operations } = resource;
+    if (isOp(operations.list)) return `use${pluralizeTypeName(entity)}Query`;
+    if (isOp(operations.detail)) return `use${entity}Query`;
+    if (isOp(operations.create)) return `useCreate${entity}Mutation`;
+    if (isOp(operations.update)) return `useUpdate${entity}Mutation`;
+    if (isOp(operations.delete)) return `useDelete${entity}Mutation`;
+    const generated = resource.operationsList.find(
+      (operation) => isOp(operation) && operation.operationKind !== "unsupported-operation" && !Object.values(operations).includes(operation)
+    );
+    if (generated) return operationComposableName(generated);
+  }
+  return null;
+}
+function operationKeyFromLocation(location) {
+  const match = location.match(/^([A-Z]+)\s+([^\s]+)/);
+  return match ? `${match[1]} ${match[2]}` : location;
+}
+function createMigrationHints(changes) {
+  const hints = changes.map((change) => {
+    switch (change.code) {
+      case "removed-endpoint":
+        return `${change.resource}: replace usages before regenerating. ${change.message}`;
+      case "required-field-added":
+        return `${change.resource}: update create/update payload builders and forms for the new required field. ${change.message}`;
+      case "field-removed":
+        return `${change.resource}: remove reads, table columns and form bindings for the deleted field. ${change.message}`;
+      case "type-changed":
+        return `${change.resource}: update TypeScript consumers and runtime formatting for the changed field type. ${change.message}`;
+      case "enum-value-removed":
+        return `${change.resource}: remove UI options and branch handling for the removed enum value. ${change.message}`;
+      case "enum-value-added":
+        return `${change.resource}: add UI labels and handling for the new enum value if this field is user-visible. ${change.message}`;
+      case "request-schema-changed":
+        return `${change.resource}: review request mappers, forms and mutation payloads. ${change.message}`;
+      case "response-schema-changed":
+        return `${change.resource}: review response readers, tables and detail views. ${change.message}`;
+      case "added-endpoint":
+        return `${change.resource}: new endpoint is available after regeneration. ${change.message}`;
+    }
+  });
+  return [...new Set(hints)].slice(0, 30);
+}
+function formatPullRequestSummary(input) {
+  const lines = [
+    `Frontend API impact: ${input.decision.status} (${input.decision.mergeRisk} risk).`,
+    input.decision.reason,
+    `Changes: ${input.summary.breaking} breaking, ${input.summary.warnings} warnings, ${input.summary.nonBreaking} non-breaking.`,
+    `Affected resources: ${input.affectedResources.length > 0 ? input.affectedResources.join(", ") : "none"}.`,
+    `Affected generated files: ${input.affectedFiles.length}.`
+  ];
+  if (input.migrationHints.length > 0) {
+    lines.push("Migration hints:");
+    lines.push(...input.migrationHints.slice(0, 5).map((hint) => `- ${hint}`));
+  }
+  return lines.join("\n");
+}
+function pascalCase(value) {
+  return value.replace(/[^A-Za-z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^./, (char) => char.toUpperCase());
+}
+function diffObjectSchemas(oldNormalized, newNormalized, oldSchema, newSchema, resource, location) {
+  const oldResolved = resolveSchema(oldNormalized, oldSchema);
+  const newResolved = resolveSchema(newNormalized, newSchema);
+  if (!oldResolved || !newResolved) {
+    if (oldResolved === newResolved) return [];
+    return [
+      {
+        code: oldResolved ? "response-schema-changed" : "request-schema-changed",
+        severity: "warning",
+        resource,
+        location,
+        message: `${location} schema presence changed.`
+      }
+    ];
+  }
+  const changes = [];
+  const oldRequired = new Set(oldResolved.required ?? []);
+  const newRequired = new Set(newResolved.required ?? []);
+  const oldProperties = oldResolved.properties ?? {};
+  const newProperties = newResolved.properties ?? {};
+  for (const name of Object.keys(oldProperties)) {
+    if (!newProperties[name]) {
+      changes.push({
+        code: "field-removed",
+        severity: "breaking",
+        resource,
+        location: `${location}.${name}`,
+        message: `Field "${name}" was removed.`
+      });
+    }
+  }
+  for (const [name, property] of Object.entries(newProperties)) {
+    const previous = oldProperties[name];
+    if (newRequired.has(name) && !oldRequired.has(name)) {
+      changes.push({
+        code: "required-field-added",
+        severity: "breaking",
+        resource,
+        location: `${location}.${name}`,
+        message: `Field "${name}" became required.`
+      });
+    }
+    if (!previous) continue;
+    if (previous.type !== property.type) {
+      changes.push({
+        code: "type-changed",
+        severity: "breaking",
+        resource,
+        location: `${location}.${name}`,
+        message: `Field "${name}" changed type from ${previous.type ?? "unknown"} to ${property.type ?? "unknown"}.`
+      });
+    }
+    changes.push(...diffEnumValues(previous, property, resource, `${location}.${name}`));
+  }
+  return changes;
+}
+function diffEnumValues(previous, next, resource, location) {
+  const oldValues = new Set(previous.enum ?? []);
+  const newValues = new Set(next.enum ?? []);
+  const changes = [];
+  for (const value of oldValues) {
+    if (!newValues.has(value)) {
+      changes.push({
+        code: "enum-value-removed",
+        severity: "breaking",
+        resource,
+        location,
+        message: `Enum value "${value}" was removed.`
+      });
+    }
+  }
+  for (const value of newValues) {
+    if (!oldValues.has(value)) {
+      changes.push({
+        code: "enum-value-added",
+        severity: "non-breaking",
+        resource,
+        location,
+        message: `Enum value "${value}" was added.`
+      });
+    }
+  }
+  return changes;
+}
+function resourceName(operation) {
+  const tag = operation.tags[0];
+  if (tag) return tag.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").toLowerCase();
+  const firstPathSegment = operation.path.split("/").filter(Boolean).find((segment) => !segment.startsWith("{")) ?? "api";
+  return firstPathSegment.replace(/[^A-Za-z0-9]+/g, "-").toLowerCase();
+}
+var httpMethods = ["get", "post", "put", "patch", "delete", "options", "head"];
+function normalizeOpenApi(document) {
+  const operations = [];
+  const operationIds = createIdentifierRegistry();
+  for (const [path, pathItem] of Object.entries(document.paths ?? {})) {
+    for (const method of httpMethods) {
+      const operation = pathItem[method];
+      if (!operation) {
+        continue;
+      }
+      operations.push(normalizeOperation(document, path, method, operation, pathItem.parameters ?? [], operationIds));
+    }
+  }
+  return {
+    document,
+    operations,
+    schemas: normalizeSchemas(document),
+    tags: normalizeTags(document, operations)
+  };
+}
+function normalizeOperation(document, path, method, operation, pathParameters, operationIds) {
+  const requestContentTypes = getRequestContentTypes(operation.requestBody);
+  const responseContentTypes = getResponseContentTypes(operation.responses);
+  const requestBodySchema = extractRequestBodySchema(operation.requestBody);
+  const responseSchema = extractResponseSchema(operation.responses);
+  const responseBodyEmpty = hasEmptySuccessResponse(operation.responses);
+  const hasFilePayload = hasFileContentType(requestContentTypes) || hasFileContentType(responseContentTypes) || hasBinarySchema(requestBodySchema);
+  return {
+    id: operation.operationId ? operationIds.identifier(operation.operationId, `${method}Operation`) : null,
+    sourceOperationId: operation.operationId ?? null,
+    method,
+    path,
+    tags: operation.tags ?? [],
+    summary: operation.summary ?? null,
+    parameters: mergeParameters(document, pathParameters ?? [], operation.parameters ?? []),
+    requestContentTypes,
+    responseContentTypes,
+    isJsonRequest: requestContentTypes.some(isJsonCompatibleContentType2),
+    isJsonResponse: responseContentTypes.some(isJsonCompatibleContentType2),
+    hasFilePayload,
+    operationKind: classifyOperationKind(path, method, operation, requestContentTypes, responseContentTypes, hasFilePayload),
+    requestBodySchema,
+    responseSchema,
+    responseBodyEmpty,
+    hasErrorResponse: Object.keys(operation.responses ?? {}).some((status) => status.startsWith("4") || status.startsWith("5")),
+    operation
+  };
+}
+function mergeParameters(document, pathParameters, operationParameters) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const candidate of [...pathParameters, ...operationParameters]) {
+    const parameter = resolveParameterRef(document, candidate);
+    if (!parameter) continue;
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  return [...merged.values()];
+}
+function resolveParameterRef(document, parameter) {
+  if (!("$ref" in parameter)) return parameter;
+  const name = parameter.$ref.match(/^#\/components\/parameters\/(.+)$/)?.[1];
+  return name ? document.components?.parameters?.[name] ?? null : null;
+}
+function normalizeSchemas(document) {
+  return Object.entries(document.components?.schemas ?? {}).map(([name, schema]) => ({
+    name,
+    schema: mergeSimpleAllOfSchema(document, schema) ?? schema
+  }));
+}
+function normalizeTags(document, operations) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of document.tags ?? []) {
+    tags.add(tag.name);
+  }
+  for (const operation of operations) {
+    for (const tag of operation.tags) {
+      tags.add(tag);
+    }
+  }
+  return [...tags];
+}
+function extractRequestBodySchema(requestBody) {
+  if (!isObject(requestBody) || !isObject(requestBody.content)) {
+    return null;
+  }
+  return extractSchema(requestBody.content, isJsonCompatibleContentType2) ?? extractSchema(requestBody.content, isMultipartContentType2) ?? extractSchema(requestBody.content, isBinaryContentType2) ?? extractSchema(requestBody.content, isFormUrlEncodedContentType2) ?? extractSchema(requestBody.content, isTextContentType);
+}
+function extractResponseSchema(responses) {
+  if (!responses) {
+    return null;
+  }
+  const successStatus = Object.keys(responses).find((status) => status.startsWith("2")) ?? "default";
+  const response = responses[successStatus];
+  if (!response?.content) {
+    return null;
+  }
+  return extractSchema(response.content, isJsonCompatibleContentType2) ?? extractSchema(response.content, isBinaryContentType2) ?? extractSchema(response.content, isWildcardContentType, hasBinarySchema) ?? extractSchema(response.content, isTextContentType) ?? extractSchema(response.content, isWildcardContentType);
+}
+function hasEmptySuccessResponse(responses) {
+  if (!responses) return false;
+  const successStatus = Object.keys(responses).find((status) => status.startsWith("2")) ?? "default";
+  const response = responses[successStatus];
+  return Boolean(response && (!response.content || Object.keys(response.content).length === 0));
+}
+function extractSchema(content, predicate, schemaPredicate = () => true) {
+  if (!isObject(content)) {
+    return null;
+  }
+  const entry = Object.entries(content).find(([contentType, mediaType2]) => {
+    if (!predicate(contentType) || !isObject(mediaType2) || !isObject(mediaType2.schema)) return false;
+    return schemaPredicate(mediaType2.schema);
+  });
+  const mediaType = entry?.[1];
+  if (!isObject(mediaType) || !isObject(mediaType.schema)) {
+    return null;
+  }
+  return mediaType.schema;
+}
+function getRequestContentTypes(requestBody) {
+  if (!isObject(requestBody) || !isObject(requestBody.content)) return [];
+  return Object.keys(requestBody.content).map(normalizeContentType);
+}
+function getResponseContentTypes(responses) {
+  return Object.values(responses ?? {}).flatMap((response) => Object.keys(response.content ?? {}).map(normalizeContentType));
+}
+function normalizeContentType(contentType) {
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isJsonCompatibleContentType2(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/json" || normalized.endsWith("+json");
+}
+function isMultipartContentType2(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "multipart/form-data";
+}
+function isFormUrlEncodedContentType2(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/x-www-form-urlencoded";
+}
+function isBinaryContentType2(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/octet-stream" || normalized === "application/pdf" || normalized.startsWith("image/");
+}
+function isTextContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized.startsWith("text/") || normalized === "application/text";
+}
+function isWildcardContentType(contentType) {
+  return contentType.split(";")[0]?.trim().toLowerCase() === "*/*";
+}
+function hasFileContentType(contentTypes) {
+  return contentTypes.some((contentType) => {
+    const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+    return normalized === "multipart/form-data" || normalized === "application/octet-stream";
+  });
+}
+function hasBinarySchema(schema) {
+  if (!schema) return false;
+  if (schema.format === "binary") return true;
+  if (schema.items && hasBinarySchema(schema.items)) return true;
+  return Object.values(schema.properties ?? {}).some(hasBinarySchema);
+}
+function classifyOperationKind(path, method, operation, requestContentTypes, responseContentTypes, hasFilePayload) {
+  if (method === "options" || method === "head") return "unsupported-operation";
+  if (hasFilePayload || hasFileContentType(requestContentTypes) || hasFileContentType(responseContentTypes)) return "file-operation";
+  const haystack = `${path} ${operation.operationId ?? ""} ${operation.summary ?? ""} ${(operation.tags ?? []).join(" ")}`.toLowerCase();
+  if ((method === "post" || method === "get" && !hasTrailingIdentitySegment(path)) && hasSearchIntent(haystack)) return "search-resource";
+  if ((method === "post" || method === "put" || method === "patch" || method === "delete") && (haystack.includes("/action/") || haystack.includes("/actions/") || !isCanonicalCrudPath(path) || isSubresourceActionPath(path) || hasActionIntent(haystack)) && /(\/actions?\/|approve|archive|confirm|reject|start|submit|generate|import|export|manual|forward|change|block|unblock|details|personal|status|validate|cancel)/.test(haystack)) {
+    return "action-operation";
+  }
+  if (method === "get" && /(dashboard|summary|metrics|stats|statistics|main|categories)/.test(haystack)) return "dashboard-resource";
+  if (method === "get" && (isSubresourceActionPath(path) || hasReadOnlyIntent(haystack))) return "read-only-resource";
+  if (method === "get" && !isCanonicalCrudPath(path)) return "read-only-resource";
+  return "crud-resource";
+}
+function isCanonicalCrudPath(path) {
+  const segments = path.split("/").filter(Boolean).filter((segment) => !["api", "v1", "v2", "v3"].includes(segment.toLowerCase()));
+  const last = segments.at(-1);
+  if (!last) return false;
+  if (last.startsWith("{")) return true;
+  return true;
+}
+function hasTrailingIdentitySegment(path) {
+  return significantSegments2(path).at(-1)?.startsWith("{") ?? false;
+}
+function isSubresourceActionPath(path) {
+  const segments = significantSegments2(path);
+  const last = segments.at(-1)?.toLowerCase();
+  if (!last || last.startsWith("{")) return false;
+  const hasParentIdentity = segments.slice(0, -1).some((segment) => segment.startsWith("{"));
+  return hasParentIdentity && /^(details?|personal|status|state|validate|validation|cancel|confirm|approve|archive|reject)$/.test(last);
+}
+function significantSegments2(path) {
+  return path.split("/").filter(Boolean).filter((segment) => !["api", "v1", "v2", "v3"].includes(segment.toLowerCase()));
+}
+function hasActionIntent(value) {
+  return /(approve|archive|confirm|reject|start|submit|generate|import|export|manual|forward|change|block|unblock|validate|cancel)/.test(value);
+}
+function hasSearchIntent(value) {
+  return /(^|[^a-z0-9])(search|find|query|filter)([^a-z0-9]|$)/.test(value);
+}
+function hasReadOnlyIntent(value) {
+  return /(lookup|options|reference|preview|history|status|state|availability)/.test(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+async function parseOpenApi(filePath, options = {}) {
+  const loaded = isRemoteInput2(filePath) ? await fetchOpenApiSource(filePath, options) : await readOpenApiSource(filePath);
+  const value = parseOpenApiSource(loaded.source, filePath, loaded.kind);
+  if (!isOpenApiDocument(value)) {
+    throw new ForgeError(`Invalid OpenAPI document: ${filePath}`, {
+      reason: "The document does not contain a valid OpenAPI 3.x version.",
+      suggestion: "Add an `openapi: 3.x.x` field at the document root."
+    });
+  }
+  return value;
+}
+async function readOpenApiSource(filePath) {
+  const source = await readFile32(filePath, "utf8").catch((error) => {
+    throw new ForgeError(`Failed to read OpenAPI schema: ${filePath}`, {
+      reason: error instanceof Error ? error.message : "Unknown file system error",
+      suggestion: "Check that the schema path exists and is readable."
+    });
+  });
+  return { source, kind: filePath.endsWith(".json") ? "json" : "yaml" };
+}
+async function fetchOpenApiSource(filePath, options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timeoutReason = options.timeoutMs ? `Request timed out after ${options.timeoutMs}ms` : void 0;
+  const timeout = timeoutReason ? setTimeout(() => controller.abort(new DOMException(timeoutReason, "TimeoutError")), options.timeoutMs) : void 0;
+  try {
+    const response = await fetchImpl(filePath, {
+      headers: options.headers,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new ForgeError(`Failed to fetch OpenAPI schema: ${filePath}`, {
+        reason: `${response.status} ${response.statusText}`.trim(),
+        suggestion: "Check the remote schema URL, credentials and server availability."
+      });
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    return {
+      source: await response.text(),
+      kind: contentType.includes("json") || filePath.endsWith(".json") ? "json" : "yaml"
+    };
+  } catch (error) {
+    if (error instanceof ForgeError) throw error;
+    const reason = error instanceof Error ? error.message : "Unknown network error";
+    throw new ForgeError(`Failed to fetch OpenAPI schema: ${filePath}${reason ? ` (${reason})` : ""}`, {
+      reason,
+      suggestion: "Check the remote schema URL, network access and configured request headers."
+    });
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function parseOpenApiSource(source, filePath, kind) {
+  try {
+    if (kind === "json") {
+      return JSON.parse(source);
+    }
+    return parseYaml(source);
+  } catch (error) {
+    throw new ForgeError(`Failed to parse OpenAPI schema: ${filePath}`, {
+      reason: error instanceof Error ? error.message : "Unknown parse error",
+      suggestion: "Use valid JSON or YAML syntax."
+    });
+  }
+}
+function isRemoteInput2(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+function isOpenApiDocument(value) {
+  return typeof value === "object" && value !== null && "openapi" in value && typeof value.openapi === "string" && value.openapi.startsWith("3.");
+}
+function lintOpenApi(normalized, options = {}) {
+  const disabled = new Set(options.disabledRules ?? []);
+  const diagnostics = [];
+  const operationIds = /* @__PURE__ */ new Map();
+  for (const operation of normalized.operations) {
+    const location = `${operation.method.toUpperCase()} ${operation.path}`;
+    if (operation.operation.operationId) {
+      operationIds.set(operation.operation.operationId, [...operationIds.get(operation.operation.operationId) ?? [], location]);
+    }
+    if (!operation.operation.operationId) {
+      diagnostics.push({
+        severity: "warning",
+        code: "missing-operation-id",
+        message: `${location} does not define operationId.`,
+        location,
+        suggestion: "Add a stable operationId so generated method names do not depend on fallback naming."
+      });
+    }
+    if (operation.tags.length === 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "missing-tags",
+        message: `${location} has no tags, so resource detection is less precise.`,
+        location,
+        suggestion: "Add a resource tag such as Users, Orders or Reports."
+      });
+    }
+    if (operation.tags.length > 1) {
+      diagnostics.push({
+        severity: "warning",
+        code: "multiple-resource-tags",
+        message: `${location} has multiple tags, so resource ownership is ambiguous.`,
+        location,
+        suggestion: "Use one primary resource tag and move secondary grouping into summary or operationId naming."
+      });
+    }
+    for (const name of extractPathParameters(operation.path)) {
+      if (!operation.parameters.some((parameter) => parameter.in === "path" && parameter.name === name)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "path-template-parameter-missing",
+          message: `${location} uses path parameter "${name}" without a matching OpenAPI path parameter.`,
+          location,
+          suggestion: "Define every path template parameter with in: path and required: true."
+        });
+      }
+    }
+    if ((operation.method === "post" || operation.method === "put" || operation.method === "patch") && !operation.requestBodySchema) {
+      diagnostics.push({
+        severity: "warning",
+        code: "missing-request-schema",
+        message: `${location} has no JSON request schema.`,
+        location,
+        suggestion: "Add an application/json request schema for typed generated payloads."
+      });
+    }
+    if (operation.method !== "delete" && !operation.responseSchema && !operation.responseBodyEmpty) {
+      diagnostics.push({
+        severity: "warning",
+        code: "missing-response-schema",
+        message: `${location} has no 2xx JSON response schema.`,
+        location,
+        suggestion: "Add an application/json 2xx response schema for typed generated responses."
+      });
+    }
+    if (!operation.hasErrorResponse) {
+      diagnostics.push({
+        severity: "warning",
+        code: "missing-error-response",
+        message: `${location} does not document a 4xx or 5xx response.`,
+        location,
+        suggestion: "Document common error responses so frontend clients can model failure states."
+      });
+    }
+    if (operation.operation.operationId && toSafeIdentifier(operation.operation.operationId, "operation") !== operation.operation.operationId) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unsafe-identifiers",
+        message: `${location} has an operationId that must be sanitized for TypeScript output.`,
+        location,
+        suggestion: "Use alphanumeric camelCase operationId values when possible."
+      });
+    }
+  }
+  for (const [operationId, locations] of operationIds) {
+    if (locations.length < 2) continue;
+    diagnostics.push({
+      severity: "warning",
+      code: "duplicate-operation-id",
+      message: `operationId "${operationId}" is used by ${locations.length} operations.`,
+      location: locations.slice(0, 3).join(", ") + (locations.length > 3 ? ", ..." : ""),
+      suggestion: "Use stable unique operationId values so generated method names do not require collision suffixes."
+    });
+  }
+  diagnostics.push(...collectDiagnostics(normalized));
+  const filtered = dedupeDiagnostics(diagnostics.filter((diagnostic) => !disabled.has(diagnostic.code)));
+  const grouped = filtered.reduce((groups, diagnostic) => {
+    groups[diagnostic.code] = [...groups[diagnostic.code] ?? [], diagnostic];
+    return groups;
+  }, {});
+  const errors = filtered.filter((diagnostic) => diagnostic.severity === "error").length;
+  const warnings = filtered.length - errors;
+  const ruleCount = Object.keys(grouped).length;
+  const score = Math.max(0, 100 - errors * 20 - ruleCount * 6 - warnings);
+  const ok = options.strict ? filtered.length === 0 : errors === 0;
+  return { ok, score, diagnostics: filtered, grouped };
+}
+function dedupeDiagnostics(diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const diagnostic of diagnostics) {
+    const key = `${diagnostic.code}:${diagnostic.location ?? diagnostic.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(diagnostic);
+  }
+  return deduped;
+}
+
+// ../adapters/dist/index.js
+var tanstackQueryComposables = createQueryComposables("@tanstack/react-query");
+var vueQueryComposables = createQueryComposables("@tanstack/vue-query");
+function resolveQueryComposables(target) {
+  if (target === "tanstack-query") return tanstackQueryComposables;
+  if (target === "vue-query") return vueQueryComposables;
+  return void 0;
+}
+function createQueryComposables(queryModule) {
+  return {
+    list: (resourceName2, resource) => listHook(queryModule, resourceName2, resource),
+    detail: (resourceName2, resource) => detailHook(queryModule, resourceName2, resource),
+    createMutation: (resourceName2, resource) => createMutationHook(queryModule, resourceName2, resource),
+    updateMutation: (resourceName2, resource) => updateMutationHook(queryModule, resourceName2, resource),
+    deleteMutation: (resourceName2, resource) => deleteMutationHook(queryModule, resourceName2, resource),
+    operation: (resourceName2, operation) => operationHook(queryModule, resourceName2, operation)
+  };
+}
+function importPaths(resourceName2) {
+  const base = `../../../shared/api/generated/${resourceName2}/${resourceName2}`;
+  return { client: `${base}.client`, keys: `${base}.query-keys`, types: `${base}.types` };
+}
+function clientName(resourceName2) {
+  return `${resourceName2}Client`;
+}
+function keysName(resourceName2) {
+  return `${resourceName2}QueryKeys`;
+}
+function missingHook(name) {
+  return `export function ${name}(): never {
+  throw new Error('${name} is not available: missing OpenAPI operation for this resource.')
+}
+`;
+}
+function invalidateOnSuccess(invalidation, usesVariables) {
+  const signature = usesVariables ? "(_data, variables)" : "()";
+  return `onSuccess: ${signature} => {
+      queryClient.invalidateQueries({ queryKey: ${invalidation} })
+    },`;
+}
+function listHook(queryModule, resourceName2, resource) {
+  const collection = pluralizeTypeName(resource.entity);
+  if (!resource.operations.list?.id) return missingHook(`use${collection}Query`);
+  const names = createResourceTypeNames(resource);
+  const paths = importPaths(resourceName2);
+  const requiresParams = getPathParams(resource.operations.list).length > 0;
+  return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${names.listParamsType}, ${names.listResponseType} } from '${paths.types}'
+
+export function use${collection}Query(
+  params${requiresParams ? "" : "?"}: ${names.listParamsType},
+  options?: Omit<UseQueryOptions<${names.listResponseType}>, 'queryKey' | 'queryFn'>,
+) {
+  return useQuery({
+    queryKey: ${keysName(resourceName2)}.list(params),
+    queryFn: () => ${clientName(resourceName2)}.${resource.operations.list.id}(params),
+    ...options,
+  })
+}
+`;
+}
+function detailHook(queryModule, resourceName2, resource) {
+  if (!resource.operations.detail?.id) return missingHook(`use${resource.entity}Query`);
+  const names = createResourceTypeNames(resource);
+  const paths = importPaths(resourceName2);
+  return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${names.detailResponseType}, ${names.idType} } from '${paths.types}'
+
+export function use${resource.entity}Query(
+  id: ${names.idType},
+  options?: Omit<UseQueryOptions<${names.detailResponseType}>, 'queryKey' | 'queryFn'>,
+) {
+  return useQuery({
+    queryKey: ${keysName(resourceName2)}.detail(id),
+    queryFn: () => ${clientName(resourceName2)}.${resource.operations.detail.id}(id),
+    ...options,
+  })
+}
+`;
+}
+function createMutationHook(queryModule, resourceName2, resource) {
+  if (!resource.operations.create?.id) return missingHook(`useCreate${resource.entity}Mutation`);
+  const names = createResourceTypeNames(resource);
+  const paths = importPaths(resourceName2);
+  const hasPathParams = getPathParams(resource.operations.create).length > 0;
+  const inputType = hasPathParams ? `{ params: ${names.listParamsType}; payload: ${names.createRequestType} }` : names.createRequestType;
+  const callArgs = hasPathParams ? "input.params, input.payload" : "input";
+  const invalidation = hasPathParams ? `${keysName(resourceName2)}.list(variables.params)` : `${keysName(resourceName2)}.list()`;
+  const typeImports = hasPathParams ? `${names.createRequestType}, ${names.createResponseType}, ${names.listParamsType}` : `${names.createRequestType}, ${names.createResponseType}`;
+  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${typeImports} } from '${paths.types}'
+
+export function useCreate${resource.entity}Mutation(
+  options?: Omit<UseMutationOptions<${names.createResponseType}, Error, ${inputType}>, 'mutationFn'>,
+) {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.create.id}(${callArgs}),
+    ${invalidateOnSuccess(invalidation, hasPathParams)}
+    ...options,
+  })
+}
+`;
+}
+function updateMutationHook(queryModule, resourceName2, resource) {
+  if (!resource.operations.update?.id) return missingHook(`useUpdate${resource.entity}Mutation`);
+  const names = createResourceTypeNames(resource);
+  const paths = importPaths(resourceName2);
+  const inputType = `{ id: ${names.idType}; payload: ${names.updateRequestType} }`;
+  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${names.idType}, ${names.updateRequestType}, ${names.updateResponseType} } from '${paths.types}'
+
+export function useUpdate${resource.entity}Mutation(
+  options?: Omit<UseMutationOptions<${names.updateResponseType}, Error, ${inputType}>, 'mutationFn'>,
+) {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.update.id}(input.id, input.payload),
+    ${invalidateOnSuccess(`${keysName(resourceName2)}.detail(variables.id)`, true)}
+    ...options,
+  })
+}
+`;
+}
+function deleteMutationHook(queryModule, resourceName2, resource) {
+  if (!resource.operations.delete?.id) return missingHook(`useDelete${resource.entity}Mutation`);
+  const names = createResourceTypeNames(resource);
+  const paths = importPaths(resourceName2);
+  const invalidatesDetail = getPathParams(resource.operations.delete).length > 1;
+  const invalidation = invalidatesDetail ? `${keysName(resourceName2)}.detail(variables)` : `${keysName(resourceName2)}.list()`;
+  const onSuccess = invalidateOnSuccess(invalidation, invalidatesDetail);
+  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${names.idType} } from '${paths.types}'
+
+export function useDelete${resource.entity}Mutation(
+  options?: Omit<UseMutationOptions<void, Error, ${names.idType}>, 'mutationFn'>,
+) {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: ${names.idType}) => ${clientName(resourceName2)}.${resource.operations.delete.id}(id),
+    ${onSuccess}
+    ...options,
+  })
+}
+`;
+}
+function operationHook(queryModule, resourceName2, operation) {
+  const names = createOperationTypeNames(operation);
+  const hookName = operationComposableName(operation);
+  const paths = importPaths(resourceName2);
+  const hasPayload = Boolean(operation.requestBodySchema);
+  const hasParams = getOperationParams(operation).length > 0;
+  const isQuery = operation.method === "get";
+  const inputType = operationInputType2(names, hasPayload, hasParams);
+  const hasInput = inputType !== "void";
+  const callArgs = operationCallArgs(hasPayload, hasParams);
+  const typeImports = [
+    ...hasPayload ? [names.requestType] : [],
+    ...hasParams ? [names.paramsType] : [],
+    names.responseType
+  ].join(", ");
+  if (isQuery) {
+    const keyEntries = hasInput ? `[...${keysName(resourceName2)}.all, '${operation.id}', input]` : `[...${keysName(resourceName2)}.all, '${operation.id}']`;
+    return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import { ${keysName(resourceName2)} } from '${paths.keys}'
+import type { ${typeImports} } from '${paths.types}'
+
+export function ${hookName}(
+${hasInput ? `  input: ${inputType},
+` : ""}  options?: Omit<UseQueryOptions<${names.responseType}>, 'queryKey' | 'queryFn'>,
+) {
+  return useQuery({
+    queryKey: ${keyEntries},
+    queryFn: () => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
+    ...options,
+  })
+}
+`;
+  }
+  return `import { useMutation, type UseMutationOptions } from '${queryModule}'
+import { ${clientName(resourceName2)} } from '${paths.client}'
+import type { ${typeImports} } from '${paths.types}'
+
+export function ${hookName}(
+  options?: Omit<UseMutationOptions<${names.responseType}, Error, ${inputType}>, 'mutationFn'>,
+) {
+  return useMutation({
+    mutationFn: (${hasInput ? `input: ${inputType}` : ""}) => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
+    ...options,
+  })
+}
+`;
+}
+function operationInputType2(names, hasPayload, hasParams) {
+  if (hasPayload && hasParams)
+    return `{ payload: ${names.requestType}; params: ${names.paramsType} }`;
+  if (hasPayload) return names.requestType;
+  if (hasParams) return names.paramsType;
+  return "void";
+}
+function operationCallArgs(hasPayload, hasParams) {
+  if (hasPayload && hasParams) return "input.payload, input.params";
+  if (hasPayload || hasParams) return "input";
+  return "";
+}
+
+// src/audit-package.ts
+var execFileAsync = promisify(execFile);
+async function runAuditPackage(schema, options) {
+  const outDir = resolve4(options.out ?? "forge-audit");
+  const minHealthScore = parseMinHealthScore(options.minHealthScore) ?? 90;
+  const loaded = await loadCliConfigSet(schema, options);
+  const entries = await Promise.all(loaded.map(runAuditEntry));
+  const primary = entries[0];
+  if (!primary) throw new Error("No OpenAPI schema inputs were resolved.");
+  await mkdir3(outDir, { recursive: true });
+  await writeGeneratedPreview(outDir, entries);
+  const typecheck = options.skipTypecheck ? createSkippedTypecheck(outDir) : await runGeneratedOutputTypecheck(outDir, entries);
+  const payload = createAuditPayload(entries, { outDir, minHealthScore, typecheck });
+  const html = createHtmlReport("Archora Forge Audit", payload);
+  const markdown = createAuditMarkdown(payload);
+  await Promise.all([
+    writeReportFile(join4(outDir, "index.html"), html),
+    writeReportFile(join4(outDir, "report.json"), JSON.stringify(payload, null, 2)),
+    writeReportFile(join4(outDir, "report.md"), markdown),
+    writeReportFile(join4(outDir, "adoption-plan.md"), createAdoptionPlan(payload)),
+    writeReportFile(join4(outDir, "ci.yml"), createCiWorkflow(payload)),
+    writeReportFile(join4(outDir, "typecheck.md"), createTypecheckMarkdown(typecheck))
+  ]);
+  return { outDir, entries, payload };
+}
+async function runAuditEntry(loaded) {
+  const document = await parseOpenApi(loaded.schema, loaded.config.schemaRequest);
+  const normalized = normalizeOpenApi(document);
+  const resources = detectResources(normalized.operations).filter(
+    (resource) => loaded.config.resources[resource.name]?.enabled !== false
+  );
+  const plan = await createGenerationPlan({
+    config: loaded.config,
+    normalized,
+    resources,
+    cwd: loaded.cwd,
+    composables: resolveQueryComposables(loaded.config.target.query)
+  });
+  const fileSummary = summarizeFilePlan(plan.files);
+  const diagnostics = collectDiagnostics(normalized);
+  const coverage = createSchemaCoverageMatrix(normalized, diagnostics);
+  const drift = await calculateDrift(plan.files, { cwd: loaded.cwd });
+  return {
+    name: loaded.name ?? "default",
+    schema: loaded.schema,
+    configPath: loaded.configPath,
+    healthScore: calculateSchemaHealth(normalized).score,
+    resources: resources.length,
+    generatedFiles: plan.files.filter((file) => file.kind === "generated").length,
+    protectedFiles: fileSummary.protected,
+    drift,
+    diagnostics,
+    coverage,
+    plan,
+    resourceExplorer: resources.map((resource) => createResourceExplorerEntry(resource, plan))
+  };
+}
+function createAuditPayload(entries, options) {
+  const diagnostics = entries.flatMap((entry) => entry.diagnostics);
+  const drift = entries.flatMap((entry) => entry.drift);
+  const healthScore = Math.min(...entries.map((entry) => entry.healthScore));
+  const generatedFiles = entries.reduce((total, entry) => total + entry.generatedFiles, 0);
+  const protectedFiles = entries.reduce((total, entry) => total + entry.protectedFiles, 0);
+  const resources = entries.reduce((total, entry) => total + entry.resources, 0);
+  const coverage = mergeSchemaCoverageMatrices(entries.map((entry) => entry.coverage));
+  const generator = summarizeAuditGeneratorMetadata(entries);
+  const scorecard = createScorecard({
+    healthScore,
+    diagnostics,
+    drift,
+    coverage,
+    typecheck: options.typecheck
+  });
+  const failedChecks = [
+    ...drift.length > 0 ? ["drift"] : [],
+    ...healthScore < options.minHealthScore ? ["health-score"] : [],
+    ...diagnostics.some((diagnostic) => diagnostic.severity === "error") ? ["errors"] : [],
+    ...options.typecheck.status === "failed" ? ["generated-typecheck"] : []
+  ];
+  const ok = failedChecks.length === 0;
+  return {
+    ok,
+    schema: displayPath(entries[0]?.schema ?? ""),
+    schemas: entries.map((entry) => ({
+      name: entry.name,
+      schema: displayPath(entry.schema),
+      configPath: entry.configPath ? displayPath(entry.configPath) : null,
+      healthScore: entry.healthScore,
+      resources: entry.resources,
+      generatedFiles: entry.generatedFiles,
+      protectedFiles: entry.protectedFiles,
+      driftCount: entry.drift.length,
+      diagnosticsCount: entry.diagnostics.length,
+      coverage: entry.coverage
+    })),
+    audit: {
+      outDir: displayPath(options.outDir),
+      generatedPreview: displayPath(join4(options.outDir, "generated-preview")),
+      artifacts: [
+        "index.html",
+        "report.md",
+        "report.json",
+        "typecheck.md",
+        "ci.yml",
+        "adoption-plan.md",
+        "generated-preview/"
+      ]
+    },
+    healthScore,
+    resources,
+    generatedFiles,
+    protectedFiles,
+    failedChecks,
+    scorecard,
+    generator,
+    coverage,
+    typecheck: options.typecheck,
+    resourceExplorer: entries.flatMap((entry) => entry.resourceExplorer),
+    fixSuggestions: createFixSuggestions(diagnostics),
+    readiness: createAuditReadiness({
+      ok,
+      healthScore,
+      minHealthScore: options.minHealthScore,
+      diagnostics,
+      drift,
+      typecheck: options.typecheck,
+      generatedFiles,
+      resources
+    }),
+    drift,
+    diagnostics
+  };
+}
+function createResourceExplorerEntry(resource, plan) {
+  return {
+    name: resource.name,
+    entity: resource.entity,
+    kind: resource.kind,
+    operations: resource.operationsList.map((operation) => ({
+      method: operation.method.toUpperCase(),
+      path: operation.path,
+      operationId: operation.id,
+      kind: operation.operationKind
+    })),
+    generatedFiles: plan.files.filter(
+      (file) => file.path.includes(`/features/${resource.name}/`) || file.path.includes(`/shared/api/generated/${resource.name}/`)
+    ).map((file) => file.path).sort()
+  };
+}
+async function writeGeneratedPreview(outDir, entries) {
+  await Promise.all(
+    entries.flatMap(
+      (entry) => entry.plan.files.filter((file) => file.kind === "generated").map(async (file) => {
+        const path = join4(outDir, "generated-preview", entry.name, file.path);
+        await mkdir3(dirname4(path), { recursive: true });
+        await writeFile3(path, file.content, "utf8");
+      })
+    )
+  );
+}
+async function runGeneratedOutputTypecheck(outDir, entries) {
+  const workspace = join4(outDir, "generated-output-typecheck");
+  const tsconfigPath = join4(workspace, "tsconfig.json");
+  const srcDir = join4(workspace, "src");
+  await Promise.all(
+    entries.flatMap(
+      (entry) => entry.plan.files.filter((file) => file.kind === "generated" && file.path.endsWith(".ts")).map(async (file) => {
+        const path = join4(srcDir, entry.name, file.path);
+        await mkdir3(dirname4(path), { recursive: true });
+        await writeFile3(path, file.content, "utf8");
+      })
+    )
+  );
+  await writeFile3(tsconfigPath, JSON.stringify(createTypecheckTsconfig(workspace), null, 2), "utf8");
+  const command = `pnpm exec tsc -p ${displayPath(tsconfigPath)}`;
+  try {
+    await execFileAsync("pnpm", ["exec", "tsc", "-p", tsconfigPath], {
+      cwd: process.cwd(),
+      timeout: 12e4
+    });
+    return { status: "passed", command, workspace: displayPath(workspace), errors: [] };
+  } catch (error) {
+    const details = error;
+    const output = [details.stdout, details.stderr, details.message].filter(Boolean).join("\n").trim();
+    return {
+      status: "failed",
+      command,
+      workspace: displayPath(workspace),
+      errors: output ? output.split("\n").slice(0, 80) : [`tsc failed with code ${String(details.code ?? "unknown")}`]
+    };
+  }
+}
+function createTypecheckTsconfig(workspace) {
+  const runtimeSource = relative3(
+    workspace,
+    resolve4(process.cwd(), "packages/runtime/src/index.ts")
+  ).replace(/\\/g, "/");
+  return {
+    compilerOptions: {
+      baseUrl: ".",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      noEmit: true,
+      paths: {
+        "@archora/forge-runtime": [
+          runtimeSource,
+          "./node_modules/@archora/forge-runtime/dist/index.d.ts"
+        ]
+      },
+      skipLibCheck: true,
+      strict: true,
+      target: "ES2022"
+    },
+    include: ["src/**/*.ts"]
+  };
+}
+function createSkippedTypecheck(outDir) {
+  return {
+    status: "skipped",
+    command: "skipped by --skip-typecheck",
+    workspace: displayPath(join4(outDir, "generated-output-typecheck")),
+    errors: []
+  };
+}
+function createScorecard(input) {
+  const errorCount = input.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "error"
+  ).length;
+  const warningCount = input.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "warning"
+  ).length;
+  return {
+    frontendReadiness: clamp(
+      input.healthScore - errorCount * 15 - warningCount * 2 - input.drift.length * 2
+    ),
+    typeSafety: input.typecheck.status === "passed" ? 100 : input.typecheck.status === "skipped" ? 70 : 30,
+    resourceCoverage: input.coverage.operations.total === 0 ? 100 : Math.round(input.coverage.operations.generated / input.coverage.operations.total * 100),
+    driftSafety: input.drift.length === 0 ? 100 : clamp(100 - input.drift.length * 10),
+    ciAdoption: input.typecheck.status === "failed" ? 60 : 100
+  };
+}
+function createFixSuggestions(diagnostics) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    groups.set(diagnostic.code, [...groups.get(diagnostic.code) ?? [], diagnostic]);
+  }
+  return [...groups.entries()].map(([code, items]) => ({
+    code,
+    count: items.length,
+    suggestion: items.find((item) => item.suggestion)?.suggestion ?? defaultSuggestion(code)
+  })).sort((left, right) => right.count - left.count || left.code.localeCompare(right.code));
+}
+function defaultSuggestion(code) {
+  if (code.includes("response-schema"))
+    return "Add explicit 2xx JSON response schemas for generated response types.";
+  if (code.includes("request-schema"))
+    return "Add explicit application/json request body schemas for generated request types.";
+  if (code.startsWith("unsupported-"))
+    return "Keep the endpoint in custom code or simplify the schema shape for generated v1 adoption.";
+  return "Review the diagnostic and decide whether the schema or the adoption scope should change.";
+}
+function createAuditReadiness(input) {
+  const blockers = [
+    ...input.healthScore < input.minHealthScore ? [`Health score ${input.healthScore} is below the audit threshold ${input.minHealthScore}.`] : [],
+    ...input.drift.length > 0 ? ["Generated output drift is present."] : [],
+    ...input.diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => `Error diagnostic: ${diagnostic.code}.`),
+    ...input.typecheck.status === "failed" ? ["Generated TypeScript typecheck failed."] : []
+  ];
+  const warnings = [
+    ...input.diagnostics.some((diagnostic) => diagnostic.severity === "warning") ? [
+      `${input.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length} warning diagnostics need review.`
+    ] : [],
+    ...input.typecheck.status === "skipped" ? ["Generated TypeScript typecheck was skipped."] : []
+  ];
+  const nextActions = [
+    ...input.drift.length > 0 ? ["Run `archora-forge generate` and review generated drift."] : [],
+    ...input.typecheck.status === "failed" ? ["Open `typecheck.md`, fix generator/schema blockers, then rerun `archora-forge audit`."] : [],
+    ...input.diagnostics.length > 0 ? ["Use fix suggestions to decide which OpenAPI changes are required before purchase."] : [],
+    ...input.ok ? ["Use this audit package as the paid pilot evidence bundle."] : []
+  ];
+  const status = blockers.length > 0 ? "blocked" : warnings.length > 0 ? "needs-attention" : "ready";
+  const gate = status === "ready" ? {
+    result: "pass",
+    recommendedCiMode: "block",
+    reason: "Generated resource layer is ready for a blocking CI gate under the current policy."
+  } : status === "needs-attention" ? {
+    result: "warn",
+    recommendedCiMode: "comment",
+    reason: "Continue evaluation, but require explicit owner review before blocking merges."
+  } : {
+    result: "fail",
+    recommendedCiMode: "block",
+    reason: "Do not widen rollout until blockers are fixed or explicitly accepted."
+  };
+  return {
+    status,
+    gate,
+    decision: input.ok ? "Generated resource layer is ready for local adoption review." : "Generated resource layer needs fixes or explicit risk acceptance before purchase.",
+    blockers,
+    warnings,
+    nextActions: nextActions.length > 0 ? nextActions : ["No action required."],
+    reviewerChecklist: [
+      "Open `index.html` and confirm detected resources match the frontend mental model.",
+      "Open `report.md` and review blockers, warnings, scorecard and fix suggestions.",
+      "Open `typecheck.md` and confirm generated TypeScript passed or every failure is triaged.",
+      "Compare generated files with the existing API layer before committing rollout scope."
+    ],
+    summary: {
+      healthScore: input.healthScore,
+      resources: input.resources,
+      generatedFiles: input.generatedFiles,
+      protectedFiles: 0,
+      diagnostics: input.diagnostics.length,
+      drift: input.drift.length,
+      failedChecks: blockers.length
+    }
+  };
+}
+function summarizeAuditGeneratorMetadata(entries) {
+  const files = entries.flatMap((entry) => entry.plan.files);
+  const total = files.filter((file) => file.kind === "generated").length;
+  return {
+    status: "previewed",
+    version: files.find((file) => file.metadata)?.metadata?.version ?? "unknown",
+    files: {
+      total,
+      missingMetadata: files.filter((file) => file.kind === "generated" && !file.metadata).map((file) => ({ path: file.path })),
+      versionMismatches: [],
+      schemaHashMismatches: [],
+      configHashMismatches: []
+    }
+  };
+}
+function createAuditMarkdown(payload) {
+  return `# Archora Forge Audit
+
+Status: ${payload.ok ? "passed" : "failed"}
+
+## Executive Review
+
+Readiness: ${payload.readiness.status}
+
+Gate: ${payload.readiness.gate.result}
+
+Recommended CI mode: ${payload.readiness.gate.recommendedCiMode}
+
+Gate reason: ${payload.readiness.gate.reason}
+
+Decision: ${payload.readiness.decision}
+
+Health score: ${payload.healthScore}
+
+Resources: ${payload.resources}
+
+Generated files: ${payload.generatedFiles}
+
+Typecheck: ${payload.typecheck.status}
+
+## Scorecard
+
+${Object.entries(payload.scorecard).map(([key, value]) => `- ${key}: ${value}`).join("\n")}
+
+## Fix Suggestions
+
+${payload.fixSuggestions.length > 0 ? payload.fixSuggestions.map((item) => `- ${item.code} (${item.count}): ${item.suggestion}`).join("\n") : "- No fix suggestions."}
+
+## Reviewer Checklist
+
+${payload.readiness.reviewerChecklist.map((item) => `- ${item}`).join("\n")}
+
+## Artifacts
+
+${payload.audit.artifacts.map((artifact) => `- ${artifact}`).join("\n")}
+`;
+}
+function createAdoptionPlan(payload) {
+  return `# Adoption Plan
+
+Decision: ${payload.readiness.decision}
+
+## Next Actions
+
+${payload.readiness.nextActions.map((action) => `- ${action}`).join("\n")}
+
+## Acceptance Gates
+
+- Check report status: ${payload.ok ? "passed" : "failed"}
+- Generated TypeScript typecheck: ${payload.typecheck.status}
+- Drift entries: ${payload.drift.length}
+- Diagnostics: ${payload.diagnostics.length}
+
+## First Resource Candidates
+
+${payload.resourceExplorer.slice(0, 10).map(
+    (resource) => `- ${resource.name}: ${resource.operations.length} operations, ${resource.generatedFiles.length} generated files`
+  ).join("\n")}
+`;
+}
+function createCiWorkflow(payload) {
+  return `name: archora-forge-audit
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  forge-audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm exec archora-forge audit ${payload.schema} --out forge-audit
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: archora-forge-audit
+          path: forge-audit
+`;
+}
+function createTypecheckMarkdown(typecheck) {
+  return `# Generated Output Typecheck
+
+- Status: ${typecheck.status}
+- Command: \`${typecheck.command}\`
+- Workspace: \`${typecheck.workspace}\`
+
+## Errors
+
+${typecheck.errors.length > 0 ? typecheck.errors.map((line) => `- ${line}`).join("\n") : "- None."}
+`;
+}
+function parseMinHealthScore(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 100) {
+    throw new Error(`Invalid minimum health score "${value}". Expected a number between 0 and 100.`);
+  }
+  return parsed;
+}
+function clamp(value) {
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+function displayPath(path) {
+  if (!path) return path;
+  const relativePath = relative3(process.cwd(), path).replace(/\\/g, "/");
+  return relativePath && !relativePath.startsWith("..") ? relativePath : path.replace(/\\/g, "/");
+}
+
+// src/license.ts
+import { mkdir as mkdir4, readFile as readFile4, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { Buffer } from "buffer";
+import { webcrypto } from "crypto";
+import { homedir } from "os";
+import { dirname as dirname5, join as join5 } from "path";
+import { TextEncoder } from "util";
+var LICENSE_PREFIX = "ARCHORA-FORGE-";
+var CLOCK_SKEW_MS = 5 * 60 * 1e3;
+function resolvePublicKeyJwk() {
+  const embedded = true ? '{"key_ops":["verify"],"ext":true,"kty":"EC","x":"ywdUlfoB7-K8wgdlEZtA7HdxmFk2pdxfhgNS_BKp3e8","y":"HTlnIHOKdtJXA5bueRZKLxkFTCtICneFMvaNqDC1Fx4","crv":"P-256"}' : "";
+  return embedded || process.env.ARCHORA_FORGE_LICENSE_PUBLIC_KEY_JWK || "";
+}
+function isLicenseEnforcementConfigured() {
+  return resolvePublicKeyJwk().length > 0;
+}
+async function activateLicenseKey(licenseKey, options = {}) {
+  const validation = await validateLicenseKey(licenseKey, options);
+  if (validation.status !== "active") return validation;
+  const now = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  await writeStoredLicense({
+    key: licenseKey.trim(),
+    activatedAt: now,
+    lastSeenAt: now
+  });
+  return validation;
+}
+async function getStoredLicenseStatus(options = {}) {
+  const stored = await readStoredLicense();
+  if (!stored) return result("missing", null, "License key is not activated");
+  const validation = await validateLicenseKey(stored.key, { ...options, lastSeenAt: stored.lastSeenAt });
+  if (validation.status === "active") {
+    await writeStoredLicense({
+      ...stored,
+      lastSeenAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return validation;
+}
+async function removeStoredLicense() {
+  await rm2(licenseFilePath(), { force: true });
+}
+async function requireCommercialLicense(command) {
+  if (!isLicenseEnforcementConfigured()) return;
+  const status = await getStoredLicenseStatus();
+  if (status.status === "active") return;
+  throw new Error(
+    [
+      `License key required for "${command}".`,
+      status.message,
+      "Run: archora-forge license activate <license-key>",
+      "For evaluation or purchase, contact akotov@archora.dev or Telegram @akotofff."
+    ].join("\n")
+  );
+}
+async function validateLicenseKey(licenseKey, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const publicKey = options.publicKey ?? publicLicenseKey();
+  if (!publicKey) return result("missingPublicKey", null, "License public key is not configured");
+  const parsed = parseLicenseKey(licenseKey);
+  if (!parsed) return result("invalid", null, "Invalid license format");
+  const payload = parsePayload(parsed.payloadSegment);
+  if (!payload) return result("invalid", null, "Invalid license payload");
+  const verified = await verifySignature(publicKey, parsed.payloadSegment, parsed.signature);
+  if (!verified) return result("invalid", payload, "Invalid license signature");
+  if (isClockRollback(now, options.lastSeenAt)) {
+    return result("clockRollback", payload, "System clock is earlier than the last CLI run");
+  }
+  const expiresAt = Date.parse(payload.expiresAt);
+  if (!Number.isFinite(expiresAt) || now.getTime() > expiresAt) {
+    return result("expired", payload, "License has expired");
+  }
+  return result("active", payload, "License is active");
+}
+function publicLicenseKey() {
+  const raw = resolvePublicKeyJwk();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function licenseFilePath() {
+  if (process.env.ARCHORA_FORGE_LICENSE_FILE) return process.env.ARCHORA_FORGE_LICENSE_FILE;
+  const configHome = process.env.XDG_CONFIG_HOME ?? join5(homedir(), ".config");
+  return join5(configHome, "archora-forge", "license.json");
+}
+async function readStoredLicense() {
+  try {
+    const parsed = JSON.parse(await readFile4(licenseFilePath(), "utf8"));
+    if (typeof parsed.key !== "string" || typeof parsed.activatedAt !== "string" || typeof parsed.lastSeenAt !== "string") {
+      return null;
+    }
+    return {
+      key: parsed.key,
+      activatedAt: parsed.activatedAt,
+      lastSeenAt: parsed.lastSeenAt
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeStoredLicense(value) {
+  const path = licenseFilePath();
+  await mkdir4(dirname5(path), { recursive: true });
+  await writeFile4(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function parseLicenseKey(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith(LICENSE_PREFIX)) return null;
+  const body = trimmed.slice(LICENSE_PREFIX.length);
+  const [payloadSegment, signatureSegment, extra] = body.split(".");
+  if (!payloadSegment || !signatureSegment || extra) return null;
+  try {
+    return {
+      payloadSegment,
+      signature: base64UrlToBytes(signatureSegment)
+    };
+  } catch {
+    return null;
+  }
+}
+function parsePayload(segment) {
+  try {
+    const raw = Buffer.from(base64UrlToBase64(segment), "base64").toString("utf8");
+    const payload = JSON.parse(raw);
+    if (typeof payload.licenseId !== "string" || typeof payload.customer !== "string" || typeof payload.issuedAt !== "string" || typeof payload.expiresAt !== "string" || !isLicensePlan(payload.plan)) {
+      return null;
+    }
+    return {
+      licenseId: payload.licenseId,
+      customer: payload.customer,
+      issuedAt: payload.issuedAt,
+      expiresAt: payload.expiresAt,
+      plan: payload.plan
+    };
+  } catch {
+    return null;
+  }
+}
+async function verifySignature(publicKey, payloadSegment, signature) {
+  try {
+    const key = await webcrypto.subtle.importKey("jwk", publicKey, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    return webcrypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      key,
+      bytesToArrayBuffer(signature),
+      new TextEncoder().encode(payloadSegment)
+    );
+  } catch {
+    return false;
+  }
+}
+function isLicensePlan(value) {
+  return value === "trial" || value === "pilot" || value === "team" || value === "organization";
+}
+function isClockRollback(now, lastSeenAt) {
+  if (!lastSeenAt) return false;
+  const lastSeen = Date.parse(lastSeenAt);
+  if (!Number.isFinite(lastSeen)) return false;
+  return now.getTime() + CLOCK_SKEW_MS < lastSeen;
+}
+function base64UrlToBytes(value) {
+  return new Uint8Array(Buffer.from(base64UrlToBase64(value), "base64"));
+}
+function base64UrlToBase64(value) {
+  return value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+}
+function bytesToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function result(status, payload, message) {
+  return { status, payload, message };
+}
+
+export {
+  writeGeneratedFiles,
+  findPrunableGeneratedFiles,
+  pruneGeneratedFiles,
+  collectDiagnostics,
+  createSchemaCoverageMatrix,
+  mergeSchemaCoverageMatrices,
+  createGenerationPlan,
+  summarizeFilePlan,
+  calculateDrift,
+  detectResources,
+  calculateSchemaHealth,
+  diffOpenApiContracts,
+  normalizeOpenApi,
+  parseOpenApi,
+  lintOpenApi,
+  resolveQueryComposables,
+  defineForgeConfig,
+  createForgeConfigPreset,
+  parseSchemaRequestHeaders,
+  loadCliConfig,
+  loadCliConfigSet,
+  writeReportFile,
+  printPendingPhaseMessage,
+  logger,
+  createHtmlReport,
+  formatImpactReport,
+  formatImpactMarkdown,
+  formatPullRequestComment,
+  formatSourceUsageLines,
+  scanSourceUsages,
+  runAuditPackage,
+  isLicenseEnforcementConfigured,
+  activateLicenseKey,
+  getStoredLicenseStatus,
+  removeStoredLicense,
+  requireCommercialLicense,
+  validateLicenseKey
+};