@decocms/blocks-cli 7.36.0 → 7.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.36.0",
+  "version": "7.37.1",
   "type": "module",
   "description": "Deco codegen (generate-blocks, generate-schema, generate-invoke) and Fresh-to-TanStack migration tooling",
   "repository": {
@@ -31,7 +31,7 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.36.0",
+    "@decocms/blocks": "7.37.1",
     "ts-morph": "^27.0.0",
     "tsx": "^4.22.5"
   },

package/scripts/deco-migrate-cli.ts

@@ -429,8 +429,7 @@ async function main() {
       console.log(`\n  ${bold("Next steps:")}`);
       console.log(`    cd ${outputDir}`);
       console.log(`    npm install`);
-      console.log(`    npm run generate:blocks`);
-      console.log(`    npm run generate:schema`);
+      console.log(`    npm run generate`);
       console.log(`    npx tsr generate`);
       console.log(`    npm run dev`);
     }

package/scripts/generate-blocks.test.ts

@@ -1,7 +1,5 @@
 import * as cp from "node:child_process";
-import * as fs from "node:fs";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import * as os from "node:os";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
@@ -105,66 +103,3 @@ describe("readBlockDelta", () => {
     expect(delta).toEqual({});
   });
 });
-
-describe("generate-blocks legacy artifact sync", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "generate-blocks-legacy-"));
-    // Minimal .deco/blocks/ dir with one block so output is non-empty.
-    fs.mkdirSync(path.join(tmpDir, ".deco", "blocks"), { recursive: true });
-    fs.writeFileSync(
-      path.join(tmpDir, ".deco", "blocks", "pages-Home.json"),
-      JSON.stringify({ path: "/" }),
-    );
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("syncs .ts and .json to the old path when legacy file is detected", () => {
-    const oldDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDir, "blocks.gen.ts"), "// stale\n");
-
-    const { code, stderr } = runGenerator([], { cwd: tmpDir });
-    expect(code).toBe(0);
-
-    expect(stderr).toContain("src/server/cms/blocks.gen.ts");
-    expect(stderr).toContain(".deco/blocks.gen.ts");
-    expect(stderr).toContain("Update importers to use the new path");
-
-    // New path must exist.
-    expect(fs.existsSync(path.join(tmpDir, ".deco", "blocks.gen.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, ".deco", "blocks.gen.json"))).toBe(true);
-
-    // Old .ts must be synced (stub content, not the stale placeholder).
-    const oldTs = fs.readFileSync(path.join(oldDir, "blocks.gen.ts"), "utf-8");
-    expect(oldTs).not.toBe("// stale\n");
-
-    // Old .json sibling must be synced — the Vite plugin reads it by suffix.
-    const oldJson = path.join(oldDir, "blocks.gen.json");
-    expect(fs.existsSync(oldJson)).toBe(true);
-    const oldContent = JSON.parse(fs.readFileSync(oldJson, "utf-8"));
-    const newContent = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, ".deco", "blocks.gen.json"), "utf-8"),
-    );
-    expect(oldContent).toEqual(newContent);
-  }, 30_000);
-
-  it("does not warn and does not sync when an explicit --out-file is passed", () => {
-    const oldDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDir, "blocks.gen.ts"), "// stale\n");
-
-    const explicitOut = path.join(tmpDir, "custom", "blocks.gen.ts");
-    const { code, stderr } = runGenerator(["--out-file", explicitOut], { cwd: tmpDir });
-    expect(code).toBe(0);
-
-    expect(stderr).not.toContain("Generator default output moved");
-    expect(fs.existsSync(explicitOut)).toBe(true);
-    // Old file must be untouched.
-    expect(fs.readFileSync(path.join(oldDir, "blocks.gen.ts"), "utf-8")).toBe("// stale\n");
-  }, 30_000);
-});

package/scripts/generate-blocks.ts

@@ -27,10 +27,6 @@
  *                 --out-file by swapping its extension, so passing --out-file
  *                 moves both artifacts together)
  *
- * If no `--out-file` is passed and the OLD default (src/server/cms/blocks.gen.ts)
- * still exists on disk, a one-line legacy warning is printed to stderr and the
- * NEW default is written anyway — see lib/legacyArtifact.ts.
- *
  * Programmatic:
  *   import { generateBlocks } from "@decocms/blocks-cli/generate-blocks";
  *   await generateBlocks({ blocksDir, outFile });
@@ -49,7 +45,6 @@ import {
   singleDecodeBlockName,
 } from "./lib/blocks-dedupe";
 import { buildCsvRedirectBlocks } from "./lib/csv-redirects";
-import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const TS_STUB = [
   "// Auto-generated — thin wrapper around blocks.gen.json.",
@@ -321,24 +316,10 @@ if (isMainModule()) {
   };
 
   const blocksDir = path.resolve(process.cwd(), arg("blocks-dir", ".deco/blocks"));
-  const OUT_FILE_EXPLICIT = args.includes("--out-file");
   const NEW_DEFAULT_OUT_FILE = ".deco/blocks.gen.ts";
-  const OLD_DEFAULT_OUT_FILE = "src/server/cms/blocks.gen.ts";
   const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-  const oldFilePath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
-  const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldFilePath);
-  if (hasLegacy) {
-    warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
-  }
 
-  generateBlocks({ blocksDir, outFile }).then((result) => {
-    if (hasLegacy) {
-      syncLegacyArtifact(oldFilePath, result.outFile);
-      // The .ts is a Vite stub — the plugin reads the .json sibling by suffix.
-      // Sync the JSON too so the Vite interceptor at the old path finds it.
-      syncLegacyArtifact(oldFilePath.replace(/\.ts$/, ".json"), result.jsonFile);
-    }
-  }).catch((err) => {
+  generateBlocks({ blocksDir, outFile }).catch((err) => {
     console.error(err);
     process.exit(1);
   });

package/scripts/generate-loaders.test.ts

@@ -62,58 +62,3 @@ describe("generate-loaders — loader vs action emit", () => {
     expect(out).not.toContain('createLoaderEntry("site/actions/addToCart"');
   });
 });
-
-describe("generate-loaders legacy artifact sync", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "generate-loaders-legacy-"));
-    const write = (rel: string, content: string) => {
-      const abs = path.join(tmpDir, rel);
-      fs.mkdirSync(path.dirname(abs), { recursive: true });
-      fs.writeFileSync(abs, content);
-    };
-    write("src/loaders/related.ts", "export default async () => [];\n");
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("syncs to the old path when legacy file is detected", () => {
-    const oldDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDir, "loaders.gen.ts"), "// stale\n");
-
-    const { code, stderr } = run(tmpDir);
-    expect(code).toBe(0);
-
-    expect(stderr).toContain("src/server/cms/loaders.gen.ts");
-    expect(stderr).toContain(".deco/loaders.gen.ts");
-    expect(stderr).toContain("Update importers to use the new path");
-
-    // New path must exist.
-    expect(fs.existsSync(path.join(tmpDir, ".deco", "loaders.gen.ts"))).toBe(true);
-
-    // Old file must be synced as a re-export shim (not the stale placeholder,
-    // and not a verbatim copy — a byte copy would carry `.deco/`-relative
-    // import paths that break at the deeper legacy location).
-    const oldContent = fs.readFileSync(path.join(oldDir, "loaders.gen.ts"), "utf-8");
-    expect(oldContent).not.toBe("// stale\n");
-    expect(oldContent).toContain('export * from "../../../.deco/loaders.gen"');
-  }, 30_000);
-
-  it("does not warn and does not sync when an explicit --out-file is passed", () => {
-    const oldDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDir, "loaders.gen.ts"), "// stale\n");
-
-    const explicitOut = path.join(tmpDir, "custom", "loaders.gen.ts");
-    const { code, stderr } = run(tmpDir, ["--out-file", explicitOut]);
-    expect(code).toBe(0);
-
-    expect(stderr).not.toContain("Generator default output moved");
-    expect(fs.existsSync(explicitOut)).toBe(true);
-    expect(fs.readFileSync(path.join(oldDir, "loaders.gen.ts"), "utf-8")).toBe("// stale\n");
-  }, 30_000);
-});

package/scripts/generate-loaders.ts

@@ -43,14 +43,9 @@
  *   --exclude             comma-separated list of loader keys to skip (they have custom wiring)
  *   --prune-by-decofile   only emit entries whose key appears as `__resolveType` in any JSON
  *   --decofile-dir        @deprecated alias for --prune-by-decofile
- *
- * If no `--out-file` is passed and the OLD default (src/server/cms/loaders.gen.ts)
- * still exists on disk, a one-line legacy warning is printed to stderr and the
- * NEW default is written anyway — see lib/legacyArtifact.ts.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -60,15 +55,8 @@ function arg(name: string, fallback: string): string {
 
 const loadersDir = path.resolve(process.cwd(), arg("loaders-dir", "src/loaders"));
 const actionsDir = path.resolve(process.cwd(), arg("actions-dir", "src/actions"));
-const OUT_FILE_EXPLICIT = args.includes("--out-file");
 const NEW_DEFAULT_OUT_FILE = ".deco/loaders.gen.ts";
-const OLD_DEFAULT_OUT_FILE = "src/server/cms/loaders.gen.ts";
 const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-const oldLoadersPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
-const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldLoadersPath);
-if (hasLegacy) {
-  warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
-}
 const excludeRaw = arg("exclude", "");
 const excludeSet = new Set(excludeRaw.split(",").map((s) => s.trim()).filter(Boolean));
 
@@ -256,7 +244,6 @@ lines.push("");
 
 fs.mkdirSync(path.dirname(outFile), { recursive: true });
 fs.writeFileSync(outFile, lines.join("\n"));
-if (hasLegacy) syncLegacyArtifact(oldLoadersPath, outFile);
 
 const filterNote = cmsReferences
   ? ` (filtered against ${cmsReferences.size} CMS __resolveType references; pruned ${prunedCount} dead entries)`

package/scripts/generate-schema.test.ts

@@ -252,10 +252,10 @@ describe("typeToJsonSchema loader block-ref matching", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Default output path (.deco/) + legacy warning — subprocess, mirrors the
-// pattern in generate-sections.test.ts. generate-schema.ts IS guarded by
-// isMainModule(), but it's still driven as a subprocess here so the CLI's
-// argv-parsed OUT_REL/legacy-check top-level code runs against a real cwd.
+// Default output path (.deco/) — subprocess, mirrors the pattern in
+// generate-sections.test.ts. generate-schema.ts IS guarded by isMainModule(),
+// but it's still driven as a subprocess here so the CLI's argv-parsed OUT_REL
+// top-level code runs against a real cwd.
 // ---------------------------------------------------------------------------
 
 const SCRIPT = path.resolve(__dirname, "generate-schema.ts");
@@ -313,39 +313,9 @@ describe("generate-schema default output path (.deco/)", () => {
     expect(meta.manifest.blocks.sections).toHaveProperty("site/sections/Hero.tsx");
   }, 30_000);
 
-  it("warns once to stderr naming both paths when the OLD default file exists and no --out is passed, but still writes the NEW default", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "admin");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "meta.gen.json"), "{}");
-
+  it("does not warn about a legacy default path", () => {
     const { code, stderr } = runGenerator(["--skip-apps"], { cwd: tmpDir });
     expect(code).toBe(0);
-
-    expect(stderr).toContain("src/server/admin/meta.gen.json");
-    expect(stderr).toContain(".deco/meta.gen.json");
-    expect(stderr).toContain("Update importers to use the new path");
-
-    const newDefault = path.join(tmpDir, ".deco", "meta.gen.json");
-    expect(fs.existsSync(newDefault)).toBe(true);
-
-    // Old file must be kept in sync so mid-migration imports still work.
-    const oldDefault = path.join(tmpDir, "src", "server", "admin", "meta.gen.json");
-    expect(fs.existsSync(oldDefault)).toBe(true);
-    const oldContent = JSON.parse(fs.readFileSync(oldDefault, "utf-8"));
-    const newContent = JSON.parse(fs.readFileSync(newDefault, "utf-8"));
-    expect(oldContent).toEqual(newContent);
-  }, 30_000);
-
-  it("does not warn when an explicit --out is passed, even if the OLD default file exists", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "admin");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "meta.gen.json"), "{}");
-
-    const explicitOut = path.join(tmpDir, "custom", "meta.gen.json");
-    const { code, stderr } = runGenerator(["--skip-apps", "--out", explicitOut], { cwd: tmpDir });
-    expect(code).toBe(0);
-
     expect(stderr).not.toContain("Generator default output moved");
-    expect(fs.existsSync(explicitOut)).toBe(true);
   }, 30_000);
 });

package/scripts/generate-schema.ts

@@ -33,10 +33,6 @@ import { fileURLToPath } from "node:url";
  *                 from disk with no runtime (FS-based Studio / Eitri stack).
  *   --framework   With --compose, the value written to the `framework` field
  *                 (default: "tanstack-start").
- *
- * If no `--out` is passed and the OLD default (src/server/admin/meta.gen.json)
- * still exists on disk, a one-line legacy warning is printed to stderr and the
- * NEW default is written anyway — see lib/legacyArtifact.ts.
  */
 import {
   type Symbol as MorphSymbol,
@@ -47,7 +43,6 @@ import {
   type Type,
 } from "ts-morph";
 import { isExcludedCodegenFile } from "./lib/codegenExclusions";
-import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 // ---------------------------------------------------------------------------
 // CLI arg parsing
@@ -56,12 +51,9 @@ import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 // here) so that importing this module for its pure exports
 // (definitionIdForPath, applyWidgetFormat, typeToJsonSchema — see
 // generate-schema.test.ts) never reads argv or touches the filesystem.
-// Without the guard, every import used to run an `fs.existsSync` check
-// against the *importing process's* cwd and could print a legacy-artifact
-// warning to stderr as an import-time side effect, unrelated to whatever
-// the test actually wanted to exercise. generateMeta() (below) and the
-// final write are themselves only reached inside `if (isMainModule())`, so
-// these vars only need real values in that same case.
+// generateMeta() (below) and the final write are themselves only reached
+// inside `if (isMainModule())`, so these vars only need real values in that
+// same case.
 // ---------------------------------------------------------------------------
 const argv = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -70,7 +62,6 @@ function arg(name: string, fallback: string): string {
 }
 
 const NEW_DEFAULT_OUT_REL = ".deco/meta.gen.json";
-const OLD_DEFAULT_OUT_REL = "src/server/admin/meta.gen.json";
 
 let SITE_NAMESPACE = "site";
 let SITE_NAME = "storefront";
@@ -90,8 +81,6 @@ let COMPOSE = false;
 // Value written to the composed meta's `framework` field (only used with
 // --compose). Defaults to composeMeta's historical "tanstack-start".
 let FRAMEWORK = "tanstack-start";
-let _hasLegacySchema = false;
-let _oldSchemaPath = "";
 
 if (isMainModule()) {
   SITE_NAMESPACE = arg("namespace", SITE_NAMESPACE);
@@ -101,16 +90,10 @@ if (isMainModule()) {
   LOADERS_REL = arg("loaders", LOADERS_REL);
   APPS_REL = arg("apps", APPS_REL);
   SKIP_APPS = argv.includes("--skip-apps");
-  const outFileExplicit = argv.includes("--out");
   OUT_REL = arg("out", NEW_DEFAULT_OUT_REL);
   PLATFORM = arg("platform", PLATFORM);
   COMPOSE = argv.includes("--compose");
   FRAMEWORK = arg("framework", FRAMEWORK);
-  _oldSchemaPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_REL);
-  _hasLegacySchema = !outFileExplicit && fs.existsSync(_oldSchemaPath);
-  if (_hasLegacySchema) {
-    warnLegacyArtifact(OLD_DEFAULT_OUT_REL, NEW_DEFAULT_OUT_REL);
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -1541,7 +1524,6 @@ if (isMainModule()) {
     const outPath = path.resolve(process.cwd(), OUT_REL);
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
     fs.writeFileSync(outPath, JSON.stringify(meta, null, 2));
-    if (_hasLegacySchema) syncLegacyArtifact(_oldSchemaPath, outPath);
 
     const defCount = Object.keys(meta.schema.definitions).length;
     const secCount = Object.keys(meta.manifest.blocks.sections || {}).length;

package/scripts/generate-sections.test.ts

@@ -115,48 +115,9 @@ describe("generate-sections default output path (.deco/)", () => {
     const newDefault = path.join(tmpDir, ".deco", "sections.gen.ts");
     expect(fs.existsSync(newDefault)).toBe(true);
     expect(fs.readFileSync(newDefault, "utf-8")).toContain("site/sections/Hero.tsx");
-    // No legacy file present, so no warning is expected.
+    // No legacy default path is written anymore, so no warning is expected.
     expect(stderr).not.toContain("Generator default output moved");
   }, 30_000);
-
-  it("warns once to stderr naming both paths when the OLD default file exists and no --out-file is passed, but still writes the NEW default", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "sections.gen.ts"), "// stale\n");
-
-    const { code, stderr } = runGenerator([], { cwd: tmpDir });
-    expect(code).toBe(0);
-
-    expect(stderr).toContain("src/server/cms/sections.gen.ts");
-    expect(stderr).toContain(".deco/sections.gen.ts");
-    expect(stderr).toContain("Update importers to use the new path");
-
-    const newDefault = path.join(tmpDir, ".deco", "sections.gen.ts");
-    expect(fs.existsSync(newDefault)).toBe(true);
-    expect(fs.readFileSync(newDefault, "utf-8")).toContain("site/sections/Hero.tsx");
-
-    // Old file is kept in sync as a re-export shim (NOT a verbatim copy — a
-    // byte copy would carry `.deco/`-relative import paths that break at the
-    // deeper legacy location). It re-exports the new file so mid-migration
-    // imports still resolve at any depth.
-    const oldDefault = path.join(tmpDir, "src", "server", "cms", "sections.gen.ts");
-    const oldContent = fs.readFileSync(oldDefault, "utf-8");
-    expect(oldContent).toContain('export * from "../../../.deco/sections.gen"');
-    expect(oldContent).not.toContain("site/sections/Hero.tsx");
-  }, 30_000);
-
-  it("does not warn when an explicit --out-file is passed, even if the OLD default file exists", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "cms");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "sections.gen.ts"), "// stale\n");
-
-    const explicitOut = path.join(tmpDir, "custom", "sections.gen.ts");
-    const { code, stderr } = runGenerator(["--out-file", explicitOut], { cwd: tmpDir });
-    expect(code).toBe(0);
-
-    expect(stderr).not.toContain("Generator default output moved");
-    expect(fs.existsSync(explicitOut)).toBe(true);
-  }, 30_000);
 });
 
 describe("generate-sections --registry", () => {

package/scripts/generate-sections.ts

@@ -28,15 +28,10 @@
  *                   Built from every scanned section file, not just the ones
  *                   carrying convention exports. Off by default so existing
  *                   Vite sites regenerating sections.gen.ts in CI see zero diff.
- *
- * If no `--out-file` is passed and the OLD default (src/server/cms/sections.gen.ts)
- * still exists on disk, a one-line legacy warning is printed to stderr and the
- * NEW default is written anyway — see lib/legacyArtifact.ts.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { isExcludedCodegenFile } from "./lib/codegenExclusions";
-import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -45,15 +40,8 @@ function arg(name: string, fallback: string): string {
 }
 
 const sectionsDir = path.resolve(process.cwd(), arg("sections-dir", "src/sections"));
-const OUT_FILE_EXPLICIT = args.includes("--out-file");
 const NEW_DEFAULT_OUT_FILE = ".deco/sections.gen.ts";
-const OLD_DEFAULT_OUT_FILE = "src/server/cms/sections.gen.ts";
 const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-const oldSectionsPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
-const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldSectionsPath);
-if (hasLegacy) {
-  warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
-}
 const EMIT_REGISTRY = args.includes("--registry");
 
 interface SectionMeta {
@@ -295,7 +283,6 @@ fs.writeFileSync(
   outFile,
   lines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n*$/, "\n"),
 );
-if (hasLegacy) syncLegacyArtifact(oldSectionsPath, outFile);
 
 console.log(
   `Generated section metadata for ${entries.length} sections → ${path.relative(process.cwd(), outFile)}`,

package/scripts/migrate/phase-report.ts

@@ -199,7 +199,7 @@ export function report(ctx: MigrationContext): void {
   lines.push("- [ ] `src/hooks/useCart.ts` — wire to actual server functions for your platform");
   lines.push("- [ ] `src/worker-entry.ts` — verify CSP, proxy, and segment builder");
   lines.push("- [ ] See the **CSS Migration** section above for DaisyUI v4→v5 / Tailwind v3→v4 findings specific to this site");
-  lines.push("- [ ] Run `npm run generate:blocks` and `npm run generate:schema` after migration");
+  lines.push("- [ ] Run `npm run generate` (unified: blocks, sections, loaders, schema) after migration");
   lines.push("");
 
   // Known Issues
@@ -250,9 +250,8 @@ export function report(ctx: MigrationContext): void {
   lines.push("# 1. Install dependencies (bun is the canonical PM)");
   lines.push("bun install");
   lines.push("");
-  lines.push("# 2. Generate CMS blocks and schema");
-  lines.push("bun run generate:blocks");
-  lines.push("bun run generate:schema");
+  lines.push("# 2. Generate CMS artifacts (blocks, sections, loaders, schema)");
+  lines.push("bun run generate");
   lines.push("");
   lines.push("# 3. Generate routes");
   lines.push("bunx tsr generate");

package/scripts/migrate/phase-scaffold.ts

@@ -20,6 +20,7 @@ import { generateSectionLoaders } from "./templates/section-loaders";
 import { generateCacheConfig } from "./templates/cache-config";
 import { generateSdkFiles } from "./templates/sdk-gen";
 import { generateMigrationPolicyPointerRule } from "./templates/cursor-rules";
+import { generatePerfFiles } from "./templates/perf-yml";
 // `lib-utils` is imported lazily — see end of phase-cleanup. Eager
 // generation of all 11 shims left every site with dead code that had
 // to be cleaned up by hand.
@@ -87,6 +88,11 @@ export function scaffold(ctx: MigrationContext): void {
     generateLockfileCheckYml(CANONICAL_BUN_VERSION),
   );
 
+  // Advisory per-PR performance workflow: detects which sections changed,
+  // maps them to CMS page paths, runs Lighthouse against the CF preview URL
+  // (PR vs main), and posts a comparison comment. Gate = CLS + TBT only.
+  writeMultiFile(ctx, generatePerfFiles(ctx.siteName));
+
   // Server entry files (server.ts, worker-entry.ts, router.tsx, runtime.ts, context.ts)
   writeMultiFile(ctx, generateServerEntry(ctx));
 

package/scripts/migrate/phase-verify.ts

@@ -20,7 +20,6 @@ const REQUIRED_FILES = [
   // Deploy / preview / sync-secrets pipelines are owned by Cloudflare
   // Workers Builds (D6.3) -- configured in the CF dashboard, not via
   // GitHub workflow files in the site repo.
-  ".github/workflows/regen-blocks.yml",
   ".github/workflows/lockfile-check.yml",
   "knip.config.ts",
   ".prettierrc",

package/scripts/migrate/templates/perf-yml.ts

@@ -0,0 +1,425 @@
+/**
+ * Scaffolds the advisory per-PR performance workflow and its companion tools:
+ *   .github/workflows/perf.yml     — GitHub Actions workflow
+ *   tools/perf/changed-paths.sh    — maps edited sections → CMS page paths
+ *   tools/perf/compare.mjs         — compares two LHCI result dirs, emits markdown
+ *   lighthouserc.json              — LHCI collect settings (3 runs, mobile UA)
+ *
+ * Design rationale:
+ *   - CF Workers Builds generates a per-PR preview URL (workers.dev). Both the
+ *     PR and main previews are workers.dev — no edge cache — so the delta is
+ *     purely code, not cache state.
+ *   - Gate signal = CLS + TBT (layout stability / JS work; cache-insensitive).
+ *     LCP and score are informational only (noisy on cold SSR).
+ *   - Advisory: `continue-on-error: true`. Remove it once the site stabilises.
+ *   - LHCI 0.15 does not write manifest.json; compare.mjs reads lhr-*.json
+ *     directly and selects the median run by performance score.
+ */
+
+/**
+ * @param workerName  Cloudflare Worker name (= wrangler `name` field, e.g. "oficina-tanstack").
+ *                    Used in the CF check-run name and the main preview base URL.
+ */
+export function generatePerfFiles(workerName: string): Record<string, string> {
+  return {
+    ".github/workflows/perf.yml": generatePerfYml(workerName),
+    "tools/perf/changed-paths.sh": CHANGED_PATHS_SH,
+    "tools/perf/compare.mjs": COMPARE_MJS,
+    "lighthouserc.json": LIGHTHOUSERC_JSON,
+  };
+}
+
+function generatePerfYml(workerName: string): string {
+  return `name: Perf
+
+# Teste de performance por PR (advisory — comenta, não trava; vire gate removendo
+# o \`continue-on-error\` do job quando estabilizar, igual react-doctor/typecheck).
+#
+# Trigger: pull_request (único trigger que roda do branch do PR, não do main).
+# Aguarda o check do CF Workers Builds completar via polling, então extrai a
+# preview URL do output — sem token CF nem build local.
+#
+# Baseline: URL fixa da preview do main (https://${workerName}.deco-cx.workers.dev).
+# Gate: CLS + TBT (estrutura/JS, insensíveis a cache). LCP/score: informativos.
+
+on:
+  pull_request:
+
+permissions:
+  contents: read
+  pull-requests: write
+  checks: read
+
+concurrency:
+  group: perf-\${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  MOBILE_UA: "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"
+  BASE_URL: "https://${workerName}.deco-cx.workers.dev"
+  PERF_FALLBACK_PATHS: |
+    /
+
+jobs:
+  perf:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      # Aguarda o CF Workers Builds completar e extrai a preview URL do output.
+      # Timeout: 10 min (builds normalmente terminam em ~3 min).
+      - id: cf
+        name: Aguardar CF build e extrair preview URL
+        env:
+          GH_TOKEN: \${{ github.token }}
+          SHA: \${{ github.event.pull_request.head.sha }}
+        run: |
+          echo "Aguardando CF Workers Builds para \$SHA..."
+          for i in \$(seq 1 60); do
+            summary=\$(gh api \\
+              "repos/\$GITHUB_REPOSITORY/commits/\$SHA/check-runs" \\
+              --jq '.check_runs[] | select(.name == "Workers Builds: ${workerName}") | .output.summary' \\
+              2>/dev/null || true)
+
+            if [ -n "\$summary" ]; then
+              conclusion=\$(gh api \\
+                "repos/\$GITHUB_REPOSITORY/commits/\$SHA/check-runs" \\
+                --jq '.check_runs[] | select(.name == "Workers Builds: ${workerName}") | .conclusion' \\
+                2>/dev/null || true)
+
+              if [ "\$conclusion" = "success" ]; then
+                url=\$(printf '%s' "\$summary" | grep -oP '(?<=Preview URL: )https://\\S+' | head -1)
+                if [ -n "\$url" ]; then
+                  echo "url=\$url" >> "\$GITHUB_OUTPUT"
+                  echo "run=true"  >> "\$GITHUB_OUTPUT"
+                  echo "CF build OK — preview: \$url"
+                  exit 0
+                fi
+              elif [ -n "\$conclusion" ] && [ "\$conclusion" != "null" ]; then
+                echo "CF build concluiu com: \$conclusion — pulando perf"
+                echo "run=false" >> "\$GITHUB_OUTPUT"
+                exit 0
+              fi
+            fi
+
+            echo "Tentativa \$i/60 — aguardando 10s..."
+            sleep 10
+          done
+
+          echo "Timeout aguardando CF build — pulando perf"
+          echo "run=false" >> "\$GITHUB_OUTPUT"
+
+      - uses: actions/checkout@v4
+        if: steps.cf.outputs.run == 'true'
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        if: steps.cf.outputs.run == 'true'
+        with:
+          node-version: "22.15.0"
+
+      - id: paths
+        name: Mapear seções editadas → paths
+        if: steps.cf.outputs.run == 'true'
+        env:
+          GH_TOKEN: \${{ github.token }}
+        run: |
+          # GitHub PR Files API = source of truth (evita problemas de squash merge)
+          changed=\$(gh api \\
+            "repos/\$GITHUB_REPOSITORY/pulls/\${{ github.event.pull_request.number }}/files" \\
+            --paginate --jq '.[].filename' \\
+            | grep -E '^src/(sections|previews)/.*\\.tsx\$' || true)
+          echo "--- seções alteradas neste PR ---"
+          printf '%s\\n' "\$changed"
+          chmod +x tools/perf/changed-paths.sh
+          CHANGED_FILES="\$changed" tools/perf/changed-paths.sh > perf-paths.txt || true
+          echo "--- paths a medir ---"; cat perf-paths.txt
+          if [ -s perf-paths.txt ]; then echo "run=true" >> "\$GITHUB_OUTPUT"
+          else echo "run=false" >> "\$GITHUB_OUTPUT"; fi
+
+      - name: Warm previews
+        if: steps.cf.outputs.run == 'true' && steps.paths.outputs.run == 'true'
+        env:
+          PR_URL: \${{ steps.cf.outputs.url }}
+        run: |
+          # --max-time 30: garante que curl não trava num SSR lento
+          while IFS= read -r p; do
+            [ -n "\$p" ] || continue
+            for origin in "\$PR_URL" "\$BASE_URL"; do
+              for _ in 1 2; do
+                curl -s -o /dev/null --max-time 30 -A "\$MOBILE_UA" \\
+                  -w "warm %{http_code} \${origin}\${p} ttfb=%{time_starttransfer}s\\n" \\
+                  "\${origin}\${p}" || true
+              done
+            done
+          done < perf-paths.txt
+
+      - name: Lighthouse (PR + base)
+        if: steps.cf.outputs.run == 'true' && steps.paths.outputs.run == 'true'
+        env:
+          PR_URL: \${{ steps.cf.outputs.url }}
+        run: |
+          collect() {
+            local origin="\$1" out="\$2" args=()
+            while IFS= read -r p; do [ -n "\$p" ] && args+=(--url="\${origin}\${p}"); done < perf-paths.txt
+            rm -rf .lighthouseci "\$out"
+            npx @lhci/cli collect --config=lighthouserc.json "\${args[@]}"
+            mv .lighthouseci "\$out"
+            echo "--- \$out contents ---"; ls -la "\$out" || true
+          }
+          collect "\$PR_URL" .lhci-pr
+          collect "\$BASE_URL" .lhci-base
+
+      - name: Montar comentário
+        if: steps.cf.outputs.run == 'true' && steps.paths.outputs.run == 'true'
+        run: |
+          node tools/perf/compare.mjs .lhci-base .lhci-pr | tee perf-comment.md >> "\$GITHUB_STEP_SUMMARY"
+
+      - name: Comentar no PR
+        if: steps.cf.outputs.run == 'true' && steps.paths.outputs.run == 'true'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: perf
+          path: perf-comment.md
+`;
+}
+
+const CHANGED_PATHS_SH = `#!/usr/bin/env bash
+set -euo pipefail
+
+# Map the sections changed in this PR to the CMS page path(s) that render them,
+# so the perf workflow only measures pages the PR can actually affect.
+#
+# How: each edited src/sections/**/*.tsx (or its previews/ twin) becomes a
+# resolveType ("site/sections/<subpath>"); we grep the checked-in decofile
+# (.deco/blocks/*.json) for that string and emit the \`path\` of every PAGE block
+# that references it. Reusable/instance blocks (path == null) and param/wildcard
+# paths (/*, /:slug/p, /conta/*) are skipped — they can't be measured as-is.
+#
+# Outcomes:
+#   - No section/preview files changed  → print PERF_FALLBACK_PATHS (home sanity).
+#   - Sections changed, page(s) mapped  → print the mapped path(s).
+#   - Sections changed, none mapped     → print PERF_FALLBACK_PATHS + log why.
+#
+# Output: one URL path per line on stdout. Diagnostics go to stderr.
+#
+# Env:
+#   CHANGED_FILES         newline-separated list of changed section/preview files
+#                         (from GitHub PR Files API — preferred, avoids squash-merge issues)
+#   BASE_REF              git ref/sha to diff against (fallback if CHANGED_FILES unset)
+#   PERF_FALLBACK_PATHS   newline-separated fallback paths (default: "/")
+#   PERF_MAX_PATHS        max paths to emit (default: 3). Sections used on many
+#                         pages (Header/Footer) would otherwise produce 100+ paths;
+#                         any page is representative for a shared section.
+
+ROOT_DIR="\$(cd "\$(dirname "\${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "\$ROOT_DIR"
+
+BASE_REF="\${BASE_REF:-origin/main}"
+BLOCKS_DIR=".deco/blocks"
+
+log() { printf '%s\\n' "\$*" >&2; }
+
+emit_fallback() {
+  log "perf: sections changed but no page mapped — using PERF_FALLBACK_PATHS"
+  printf '%s\\n' "\${PERF_FALLBACK_PATHS:-/}" | sed 's/[[:space:]]*\$//' | sed '/^\$/d'
+}
+
+# Prefer CHANGED_FILES (set by the workflow from the GitHub PR Files API) to
+# avoid squash-merge ancestry issues where git log A..B shows all historical commits.
+# Fall back to git log only when running locally without CHANGED_FILES.
+changed=()
+if [ -n "\${CHANGED_FILES:-}" ]; then
+  while IFS= read -r line; do
+    [ -n "\$line" ] && changed+=("\$line")
+  done < <(printf '%s\\n' "\$CHANGED_FILES" | grep -E '\\.tsx\$' | sort -u || true)
+else
+  while IFS= read -r line; do
+    [ -n "\$line" ] && changed+=("\$line")
+  done < <(git log --name-only --format="" "\$BASE_REF"..HEAD -- src/sections src/previews 2>/dev/null | grep -E '\\.tsx\$' | sort -u || true)
+fi
+
+# No sections changed → measure home as a baseline sanity check.
+if [ "\${#changed[@]}" -eq 0 ]; then
+  log "perf: nenhuma seção alterada — usando PERF_FALLBACK_PATHS como sanity"
+  emit_fallback
+  exit 0
+fi
+
+# Each changed file → the resolveType the decofile references it by.
+resolvetypes=()
+for f in "\${changed[@]}"; do
+  case "\$f" in
+    src/sections/*) resolvetypes+=("site/\${f#src/}") ;;
+    src/previews/*) resolvetypes+=("site/sections/\${f#src/previews/}") ;;
+  esac
+done
+[ "\${#resolvetypes[@]}" -eq 0 ] && exit 0
+
+# Grep the decofile for each resolveType; collect page paths (non-null).
+paths=()
+for rt in "\${resolvetypes[@]}"; do
+  while IFS= read -r block; do
+    [ -n "\$block" ] || continue
+    while IFS= read -r p; do
+      [ -n "\$p" ] && paths+=("\$p")
+    done < <(jq -r 'select(.path != null and (.path | type == "string")) | .path' "\$block" 2>/dev/null || true)
+  done < <(grep -Fl "\$rt" "\$BLOCKS_DIR"/*.json 2>/dev/null || true)
+done
+
+# Dedupe + drop param/wildcard paths (need a concrete slug; can't measure as-is).
+clean=()
+if [ "\${#paths[@]}" -gt 0 ]; then
+  while IFS= read -r line; do
+    [ -n "\$line" ] && clean+=("\$line")
+  done < <(printf '%s\\n' "\${paths[@]}" | grep -vE '[:*]' | sort -u)
+fi
+
+if [ "\${#clean[@]}" -eq 0 ]; then
+  emit_fallback
+  exit 0
+fi
+
+MAX="\${PERF_MAX_PATHS:-3}"
+total="\${#clean[@]}"
+if [ "\$total" -gt "\$MAX" ]; then
+  log "perf: \${total} pages mapped — capped at \${MAX} (ponytail: PERF_MAX_PATHS). Dropped: \${clean[*]:\$MAX}"
+  clean=("\${clean[@]:0:\$MAX}")
+fi
+
+log "perf: measuring \${#clean[@]} page(s) mapped from \${#changed[@]} changed file(s)"
+printf '%s\\n' "\${clean[@]}"
+`;
+
+const COMPARE_MJS = `#!/usr/bin/env node
+// Compare two Lighthouse CI result dirs (base = main preview, pr = PR preview)
+// and emit a markdown table. Both previews run on *.workers.dev with no edge
+// cache, same runner/region, same mobile UA — so the delta is the PR's code
+// effect, not cache warm/cold.
+//
+// Gate signal = CLS + TBT (page structure / JS work — cache-insensitive).
+// LCP / score are shown but informative only (noisy on cold workers.dev SSR).
+//
+// LHCI 0.15 does not write manifest.json; we read lhr-*.json directly.
+//
+// Usage: node compare.mjs <baseDir> <prDir>   → writes markdown to stdout
+//        node compare.mjs --selftest          → runs assertions, exits 0/1
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+const TBT_ABS = 50; // ms — deltas below this are noise
+const TBT_REL = 0.15; // 15% relative change
+const CLS_ABS = 0.02; // absolute CLS delta that matters
+const CLS_FLOOR = 0.1; // only flag CLS regression when PR is above "good"
+
+function verdict(base, pr) {
+  const tbtUp = pr.tbt - base.tbt;
+  const tbtBad = tbtUp > TBT_ABS && tbtUp > base.tbt * TBT_REL;
+  const tbtGood = -tbtUp > TBT_ABS && -tbtUp > base.tbt * TBT_REL;
+  const clsUp = pr.cls - base.cls;
+  const clsBad = clsUp > CLS_ABS && pr.cls > CLS_FLOOR;
+  const clsGood = -clsUp > CLS_ABS && base.cls > CLS_FLOOR;
+  if (tbtBad || clsBad) return { icon: "🔴", gate: true };
+  if (tbtGood || clsGood) return { icon: "🟢", gate: false };
+  return { icon: "⚪", gate: false };
+}
+
+function loadDir(dir) {
+  const files = readdirSync(dir).filter((f) => f.startsWith("lhr-") && f.endsWith(".json"));
+  const byUrl = {};
+  for (const f of files) {
+    const lhr = JSON.parse(readFileSync(join(dir, f), "utf8"));
+    const url = lhr.finalUrl || lhr.requestedUrl;
+    if (!byUrl[url]) byUrl[url] = [];
+    byUrl[url].push(lhr);
+  }
+  const byPath = {};
+  for (const [url, runs] of Object.entries(byUrl)) {
+    runs.sort((a, b) => a.categories.performance.score - b.categories.performance.score);
+    const lhr = runs[Math.floor(runs.length / 2)];
+    const a = lhr.audits;
+    byPath[new URL(url).pathname] = {
+      score: Math.round((lhr.categories.performance.score ?? 0) * 100),
+      lcp: a["largest-contentful-paint"].numericValue,
+      cls: a["cumulative-layout-shift"].numericValue,
+      tbt: a["total-blocking-time"].numericValue,
+    };
+  }
+  return byPath;
+}
+
+const ms = (v) => \`\${Math.round(v)}ms\`;
+const cls = (v) => v.toFixed(3);
+function delta(base, pr, fmt) {
+  const d = pr - base;
+  const arrow = d < 0 ? "↓" : d > 0 ? "↑" : "";
+  return \`\${d > 0 ? "+" : ""}\${fmt(d)} \${arrow}\`.trim();
+}
+
+function render(base, pr) {
+  const paths = [...new Set([...Object.keys(base), ...Object.keys(pr)])].sort();
+  let anyGate = false;
+  const lines = [
+    "### ⚡ Perf — preview do PR × preview do main",
+    "",
+    "Ambas as previews rodam em \`*.workers.dev\` (sem edge cache), mesmo runner e UA mobile — o delta é efeito do código, não de cache quente/frio.",
+    "",
+    "**Gate:** CLS + TBT (estrutura / JS). LCP e score são informativos (ruído esperado em SSR frio).",
+    "",
+    "| Página | | CLS (base→PR) | TBT (base→PR) | LCP | Score |",
+    "|---|:--:|---|---|---|---|",
+  ];
+  for (const p of paths) {
+    const b = base[p];
+    const r = pr[p];
+    if (!b || !r) {
+      lines.push(\`| \\\`\${p}\\\` | ⚠️ | \${b ? "faltou PR" : "faltou base"} | | | |\`);
+      continue;
+    }
+    const v = verdict(b, r);
+    anyGate = anyGate || v.gate;
+    lines.push(
+      \`| \\\`\${p}\\\` | \${v.icon} | \${cls(b.cls)}→\${cls(r.cls)} (\${delta(b.cls, r.cls, cls)}) | \${ms(b.tbt)}→\${ms(r.tbt)} (\${delta(b.tbt, r.tbt, ms)}) | \${ms(b.lcp)}→\${ms(r.lcp)} | \${b.score}→\${r.score} |\`,
+    );
+  }
+  lines.push("");
+  lines.push(
+    anyGate
+      ? "🔴 **Regressão de CLS/TBT detectada** (advisory — não trava o merge)."
+      : "🟢 Sem regressão de CLS/TBT.",
+  );
+  return { md: lines.join("\\n"), anyGate };
+}
+
+function selftest() {
+  const ok = (c, m) => { if (!c) throw new Error("FAIL: " + m); };
+  ok(verdict({ tbt: 100, cls: 0.01 }, { tbt: 200, cls: 0.01 }).gate, "tbt +100ms should gate");
+  ok(!verdict({ tbt: 100, cls: 0.01 }, { tbt: 130, cls: 0.01 }).gate, "tbt +30ms is noise");
+  ok(verdict({ tbt: 100, cls: 0.11 }, { tbt: 100, cls: 0.2 }).gate, "cls 0.11→0.20 should gate");
+  ok(!verdict({ tbt: 100, cls: 0.02 }, { tbt: 100, cls: 0.08 }).gate, "cls under 0.1 floor no gate");
+  ok(verdict({ tbt: 300, cls: 0.01 }, { tbt: 100, cls: 0.01 }).icon === "🟢", "tbt drop is green");
+  ok(verdict({ tbt: 100, cls: 0.01 }, { tbt: 105, cls: 0.01 }).icon === "⚪", "tiny change is neutral");
+  console.log("compare.mjs selftest: OK");
+}
+
+if (process.argv[2] === "--selftest") { selftest(); process.exit(0); }
+
+const [baseDir, prDir] = process.argv.slice(2);
+if (!baseDir || !prDir) { console.error("usage: compare.mjs <baseDir> <prDir> | --selftest"); process.exit(2); }
+process.stdout.write(render(loadDir(baseDir), loadDir(prDir)).md + "\\n");
+`;
+
+const LIGHTHOUSERC_JSON = `{
+  "//": "Lighthouse CI config for the per-PR perf workflow (.github/workflows/perf.yml). Mobile UA matches worker-entry.ts buildSegment (MOBILE_RE) so warmup and measurement hit the same device cache key.",
+  "ci": {
+    "collect": {
+      "numberOfRuns": 3,
+      "settings": {
+        "onlyCategories": ["performance"],
+        "emulatedUserAgent": "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"
+      }
+    }
+  }
+}
+`;

package/scripts/lib/legacyArtifact.ts

@@ -1,64 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-/**
- * Generator default output paths flipped from `src/server/{cms,admin}/` to
- * `.deco/` (framework artifacts live in the framework's folder, not mixed
- * into app source). Sites that never pass an explicit `--out`/`--out-file`
- * flag pick up the new default silently — except when the OLD default file
- * is still sitting on disk, which almost always means something (an
- * importer, a `.gitignore` entry, a stale CI cache check) still points at
- * it. In that case we warn once, to stderr, and then write to the NEW
- * default anyway: the artifact is regenerated code, so there's no reason to
- * block the run — the warning is just a nudge to go clean up the stale file
- * and its importers.
- *
- * An explicit flag means the caller made a deliberate choice about where
- * output goes; it gets no warning and no guard.
- */
-export function warnLegacyArtifact(oldPath: string, newPath: string): void {
-  console.warn(
-    `[deco] Generator default output moved: ${oldPath} -> ${newPath}. Update importers to use the new path, then delete the old file.`,
-  );
-}
-
-/**
- * Keeps the legacy `oldPath` in sync with the freshly-generated `newPath` so
- * sites mid-migration whose imports still point at the old location keep
- * working without a full migration first. Call this after generation
- * completes, only when the old file was detected.
- *
- * For `.ts`/`.tsx` artifacts a verbatim copy would be broken: the generated
- * file's import specifiers are relative to `newPath`'s directory (`.deco/`,
- * one level deep), but `oldPath` lives deeper (`src/server/cms/`), so every
- * `../src/...` specifier would resolve to a nonexistent path and crash the
- * dev server on boot. Instead we write a re-export shim pointing at `newPath`
- * — one specifier, correct at any depth, and self-documenting the deprecation.
- * The generated `.gen.ts` files only have named exports, so `export *` forwards
- * everything (including type exports). Non-TS artifacts (e.g. `.json` schema)
- * have no import paths, so a byte copy is still correct.
- */
-export function syncLegacyArtifact(oldPath: string, newPath: string): void {
-  fs.mkdirSync(path.dirname(oldPath), { recursive: true });
-
-  if (!/\.tsx?$/.test(oldPath)) {
-    fs.copyFileSync(newPath, oldPath);
-    return;
-  }
-
-  const newRel = path.relative(process.cwd(), newPath).replace(/\\/g, "/");
-  let specifier = path
-    .relative(path.dirname(oldPath), newPath)
-    .replace(/\\/g, "/")
-    .replace(/\.tsx?$/, "");
-  if (!specifier.startsWith(".")) specifier = `./${specifier}`;
-
-  fs.writeFileSync(
-    oldPath,
-    `// AUTO-GENERATED — DO NOT EDIT.\n` +
-      `// Deprecated path: the generator now writes to "${newRel}".\n` +
-      `// This file only re-exports it so mid-migration imports keep working.\n` +
-      `// Update your imports to the new path, then delete this file.\n` +
-      `export * from "${specifier}";\n`,
-  );
-}