@fragments-sdk/cli 0.10.0 → 0.11.1

package/src/commands/init.ts

@@ -143,6 +143,8 @@ function generateConfig(options: {
   includePaths: string[];
   componentPaths: string[];
   framework: string;
+  themeBlock?: string;
+  snapshotsBlock?: string;
 }): string {
   const includeStr = options.includePaths.map((p) => `    '${p}'`).join(",\n");
   const componentStr = options.componentPaths.map((p) => `    '${p}'`).join(",\n");
@@ -165,7 +167,7 @@ ${componentStr}
 
   // Framework (react, vue, svelte)
   framework: '${options.framework}',
-};
+${options.themeBlock || ""}${options.snapshotsBlock || ""}};
 
 export default config;
 `;
@@ -532,6 +534,8 @@ export async function init(options: InitOptions = {}): Promise<InitResult> {
   let runScan = scenario === "components" || scenario === "stories";
   let createExample = scenario === "fresh";
   let startServer = false;
+  let themeBlock = "";
+  let snapshotsBlock = "";
 
   if (!options.yes) {
     // Ask about component location
@@ -548,6 +552,75 @@ export async function init(options: InitOptions = {}): Promise<InitResult> {
       });
     }
 
+    // Theme seed configuration
+    const configureTheme = await confirm({
+      message: "Configure theme seeds? (brand color, density, radius)",
+      default: false,
+    });
+
+    if (configureTheme) {
+      const brand = await input({
+        message: "Brand color (hex)",
+        default: "#18181b",
+        validate: (v) => /^#[0-9a-fA-F]{6}$/.test(v) || "Enter a valid hex color (e.g., #6366f1)",
+      });
+
+      const neutral = await select({
+        message: "Neutral palette",
+        choices: [
+          { value: "stone", name: "Stone (warm gray)" },
+          { value: "ice", name: "Ice (cool blue-gray)" },
+          { value: "earth", name: "Earth (olive/khaki)" },
+          { value: "sand", name: "Sand (warm beige)" },
+          { value: "fire", name: "Fire (warm red-gray)" },
+        ],
+        default: "stone",
+      });
+
+      const density = await select({
+        message: "Spacing density",
+        choices: [
+          { value: "compact", name: "Compact (tighter spacing)" },
+          { value: "default", name: "Default" },
+          { value: "relaxed", name: "Relaxed (more breathing room)" },
+        ],
+        default: "default",
+      });
+
+      const radiusStyle = await select({
+        message: "Border radius style",
+        choices: [
+          { value: "sharp", name: "Sharp (0px)" },
+          { value: "subtle", name: "Subtle (2px)" },
+          { value: "default", name: "Default (6px)" },
+          { value: "rounded", name: "Rounded (10px)" },
+          { value: "pill", name: "Pill (999px)" },
+        ],
+        default: "default",
+      });
+
+      // Build theme config block — only include non-default values
+      const themeEntries: string[] = [];
+      if (brand !== "#18181b") themeEntries.push(`    brand: '${brand}'`);
+      if (neutral !== "stone") themeEntries.push(`    neutral: '${neutral}'`);
+      if (density !== "default") themeEntries.push(`    density: '${density}'`);
+      if (radiusStyle !== "default") themeEntries.push(`    radiusStyle: '${radiusStyle}'`);
+
+      if (themeEntries.length > 0) {
+        themeBlock = `\n  // Theme seed values (derives 120+ CSS custom properties)\n  theme: {\n${themeEntries.join(",\n")},\n  },\n`;
+      }
+    }
+
+    // Snapshot toggle
+    const enableSnapshots = await confirm({
+      message: "Enable visual snapshot tests per component variant?",
+      default: false,
+    });
+
+    if (enableSnapshots) {
+      snapshotsBlock = `\n  // Visual snapshot testing\n  snapshots: {\n    enabled: true,\n  },\n`;
+    }
+
     // Ask about starting the server
     startServer = await confirm({
       message: "Start the viewer now?",
@@ -575,6 +648,8 @@ export async function init(options: InitOptions = {}): Promise<InitResult> {
     includePaths,
     componentPaths: [`${componentPath}/**/*.tsx`],
     framework: "react",
+    themeBlock,
+    snapshotsBlock,
   });
 
   try {

package/src/commands/snapshot.ts

@@ -0,0 +1,197 @@
+/**
+ * fragments snapshot - Run visual snapshot tests per component variant
+ *
+ * Starts the dev server (if not already running), then runs Playwright
+ * snapshot tests against all component variants discovered in fragments.json.
+ */
+
+import { resolve } from "node:path";
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import pc from "picocolors";
+import { BRAND } from "../core/index.js";
+
+export interface SnapshotOptions {
+  /** Port of a running dev server (skips starting one) */
+  port?: number | string;
+  /** Update existing snapshots instead of comparing */
+  update?: boolean;
+  /** Filter to a specific component name */
+  component?: string;
+  /** Path to Playwright config (auto-detected if omitted) */
+  config?: string;
+  /** Path to the snapshot spec file */
+  spec?: string;
+  /** CI mode — non-interactive, exit 1 on mismatch */
+  ci?: boolean;
+}
+
+export interface SnapshotResult {
+  success: boolean;
+  totalTests: number;
+  passed: number;
+  failed: number;
+}
+
+/**
+ * Find the snapshot spec file.
+ * Checks project root e2e/ first, then falls back to the CLI's bundled spec.
+ */
+function findSnapshotSpec(projectRoot: string, explicitPath?: string): string | null {
+  if (explicitPath) {
+    const resolved = resolve(projectRoot, explicitPath);
+    return existsSync(resolved) ? resolved : null;
+  }
+
+  // Check common locations
+  const candidates = [
+    resolve(projectRoot, "e2e/component-visual-snapshots.spec.ts"),
+    resolve(projectRoot, "tests/visual-snapshots.spec.ts"),
+    resolve(projectRoot, "test/visual-snapshots.spec.ts"),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Run visual snapshot tests.
+ */
+export async function snapshot(options: SnapshotOptions = {}): Promise<SnapshotResult> {
+  const projectRoot = process.cwd();
+  const {
+    port,
+    update = false,
+    component,
+    ci = false,
+  } = options;
+
+  console.log(pc.cyan(`\n${BRAND.name} Visual Snapshots\n`));
+
+  // Check that fragments.json exists
+  const fragmentsJson = resolve(projectRoot, BRAND.outFile);
+  if (!existsSync(fragmentsJson)) {
+    console.error(
+      pc.red(`${BRAND.outFile} not found. Run ${pc.bold(`${BRAND.cliCommand} build`)} first.`)
+    );
+    return { success: false, totalTests: 0, passed: 0, failed: 0 };
+  }
+
+  // Find the snapshot spec
+  const specPath = findSnapshotSpec(projectRoot, options.spec);
+  if (!specPath) {
+    console.error(
+      pc.red("No snapshot spec found.") + "\n" +
+      pc.dim("Expected: e2e/component-visual-snapshots.spec.ts\n") +
+      pc.dim(`Create one or specify with --spec <path>`)
+    );
+    return { success: false, totalTests: 0, passed: 0, failed: 0 };
+  }
+
+  console.log(pc.dim(`Spec: ${specPath}`));
+
+  // Check for Playwright
+  try {
+    execSync("npx playwright --version", { stdio: "pipe" });
+  } catch {
+    console.error(
+      pc.red("Playwright not found.") + "\n" +
+      pc.dim("Install it: pnpm add -D @playwright/test && npx playwright install chromium")
+    );
+    return { success: false, totalTests: 0, passed: 0, failed: 0 };
+  }
+
+  // Build Playwright args
+  const args = ["playwright", "test", specPath];
+
+  if (update) {
+    args.push("--update-snapshots");
+    console.log(pc.yellow("Updating snapshots (baselines will be overwritten)"));
+  }
+
+  if (component) {
+    args.push("--grep", component);
+    console.log(pc.dim(`Filtering: ${component}`));
+  }
+
+  // If a port is specified, set the BASE_URL env var so the spec
+  // can connect to an already-running dev server
+  const env: Record<string, string> = { ...process.env as Record<string, string> };
+  if (port) {
+    env.FRAGMENTS_DEV_PORT = String(port);
+    console.log(pc.dim(`Using running dev server on port ${port}`));
+  }
+
+  console.log(pc.dim("\nRunning snapshot tests...\n"));
+
+  // Run Playwright
+  return new Promise<SnapshotResult>((resolveResult) => {
+    const child = spawn("npx", args, {
+      cwd: projectRoot,
+      stdio: ci ? "pipe" : "inherit",
+      env,
+    });
+
+    let stdout = "";
+
+    if (ci && child.stdout) {
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (ci && child.stderr) {
+      child.stderr.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+
+    child.on("close", (code) => {
+      const success = code === 0;
+
+      if (ci) {
+        // Parse Playwright output for test counts
+        const passedMatch = stdout.match(/(\d+) passed/);
+        const failedMatch = stdout.match(/(\d+) failed/);
+        const passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
+        const failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
+
+        if (!success) {
+          process.stdout.write(stdout);
+        }
+
+        resolveResult({
+          success,
+          totalTests: passed + failed,
+          passed,
+          failed,
+        });
+      } else {
+        if (success) {
+          console.log(pc.green("\n✓ All snapshots match\n"));
+        } else if (update) {
+          console.log(pc.green("\n✓ Snapshots updated\n"));
+        } else {
+          console.log(pc.red("\n✗ Snapshot mismatches detected"));
+          console.log(pc.dim(`Run ${pc.bold(`${BRAND.cliCommand} snapshot --update`)} to accept changes\n`));
+        }
+
+        resolveResult({
+          success: success || update,
+          totalTests: 0,
+          passed: 0,
+          failed: 0,
+        });
+      }
+    });
+
+    child.on("error", (err) => {
+      console.error(pc.red(`Failed to run Playwright: ${err.message}`));
+      resolveResult({ success: false, totalTests: 0, passed: 0, failed: 0 });
+    });
+  });
+}

package/src/core/loader.ts

@@ -53,6 +53,37 @@ function createFragmentsCoreShimPlugin(): Plugin {
 export async function loadFragmentFile(
   absolutePath: string
 ): Promise<FragmentDefinition | null> {
+  const unwrapFragmentExport = (
+    value: unknown
+  ): FragmentDefinition | null => {
+    if (!value) return null;
+
+    // Some CJS/ESM interop paths produce { default: fragment } wrappers.
+    // Prefer a shape that actually looks like a fragment definition.
+    const asObject = (v: unknown): Record<string, unknown> | null =>
+      v && typeof v === 'object' ? (v as Record<string, unknown>) : null;
+    const isFragmentLike = (v: unknown): boolean => {
+      const obj = asObject(v);
+      return !!obj && ('component' in obj || 'meta' in obj || 'variants' in obj);
+    };
+
+    if (isFragmentLike(value)) {
+      return value as FragmentDefinition;
+    }
+
+    const first = asObject(value)?.default;
+    if (isFragmentLike(first)) {
+      return first as FragmentDefinition;
+    }
+
+    const second = asObject(first)?.default;
+    if (isFragmentLike(second)) {
+      return second as FragmentDefinition;
+    }
+
+    return (value as FragmentDefinition) ?? null;
+  };
+
   const ext = absolutePath.split('.').pop()?.toLowerCase();
   const needsTransform = ext === 'tsx' || ext === 'ts' || ext === 'jsx';
 
@@ -60,24 +91,23 @@ export async function loadFragmentFile(
     // Plain JS file, import directly
     const fileUrl = pathToFileURL(absolutePath).href;
     const module = await import(fileUrl);
-    return module.default ?? null;
+    return unwrapFragmentExport(module.default ?? null);
   }
 
   // Bundle the file with all its local dependencies
   const sourceDir = dirname(absolutePath);
   const baseName = basename(absolutePath, `.${ext}`);
-  // Use .cjs extension to ensure CommonJS evaluation
-  const tempFile = join(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.cjs`);
+  // Use .mjs and ESM output for compatibility with ESM-only dependencies.
+  const tempFile = join(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
 
   try {
-    // Use esbuild to bundle the fragment file
-    // We inject a shim for @fragments-sdk/cli/core so it doesn't need to be installed
-    // Using CommonJS format to avoid ESM/CJS interop issues with node_modules
+    // Use esbuild to bundle the fragment file.
+    // We inject a shim for @fragments-sdk/cli/core so it doesn't need to be installed.
     await build({
       entryPoints: [absolutePath],
       outfile: tempFile,
       bundle: true,
-      format: 'cjs', // Use CommonJS to avoid ESM issues with lodash, etc.
+      format: 'esm',
       target: 'es2022',
       jsx: 'automatic',
       platform: 'node',
@@ -114,7 +144,7 @@ export async function loadFragmentFile(
 
     const fileUrl = pathToFileURL(tempFile).href;
     const module = await import(fileUrl);
-    return module.default ?? null;
+    return unwrapFragmentExport(module.default ?? null);
   } finally {
     // Clean up temp file
     try {

package/src/viewer/__tests__/viewer-integration.test.ts

@@ -7,63 +7,101 @@ import { tmpdir } from "node:os";
 import { discoverInstalledFragments } from "../../core/discovery.js";
 
 /**
- * Integration tests for the consolidated viewer.
+ * Integration tests for the viewer architecture.
  *
- * After packages were merged into @fragments-sdk/cli, the viewer's
- * path resolution changed. These tests verify that:
- * - Viewer assets (HTML, TSX entry points) are found at the correct paths
- * - The @fragments-sdk/cli/core alias resolves to the consolidated core source
+ * After the viewer extraction (Delivery A), viewer UI code lives in
+ * packages/viewer/ while CLI keeps the Vite server and plugin.
+ * These tests verify:
+ * - Viewer assets (HTML, TSX entry points) are found in packages/viewer/
+ * - The CLI server/plugin reference the viewer package correctly
+ * - The @fragments-sdk/cli/core alias resolves to consolidated core source
  * - The virtual module generates valid import statements
- * - The Vite config references correct file system locations
  */
 
-// Simulate the same path resolution used in server.ts and vite-plugin.ts
-// At runtime, __dirname is dist/. In tests (vitest), it's the source dir.
 const testDir = dirname(fileURLToPath(import.meta.url));
 const viewerDir = resolve(testDir, "..");
 const cliPackageRoot = resolve(viewerDir, "../..");
+const packagesRoot = resolve(cliPackageRoot, "..");
+const viewerPackageRoot = resolve(packagesRoot, "viewer");
+const viewerSrc = resolve(viewerPackageRoot, "src");
 
-describe("viewer path resolution", () => {
-  it("viewerRoot resolves to a directory containing index.html", () => {
-    // server.ts: viewerRoot = resolve(cliPackageRoot, "src/viewer")
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "index.html"))).toBe(true);
+describe("viewer package path resolution", () => {
+  it("viewer package root exists", () => {
+    expect(existsSync(viewerPackageRoot)).toBe(true);
   });
 
-  it("viewerRoot contains entry.tsx", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "entry.tsx"))).toBe(true);
+  it("viewer package contains index.html at root", () => {
+    expect(existsSync(resolve(viewerPackageRoot, "index.html"))).toBe(true);
   });
 
-  it("viewerRoot contains preview-frame.html", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "preview-frame.html"))).toBe(true);
+  it("viewer package contains entry.tsx", () => {
+    expect(existsSync(resolve(viewerSrc, "entry.tsx"))).toBe(true);
   });
 
-  it("viewerRoot contains preview-frame-entry.tsx", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "preview-frame-entry.tsx"))).toBe(true);
+  it("viewer package contains preview-frame.html in src/", () => {
+    expect(existsSync(resolve(viewerSrc, "preview-frame.html"))).toBe(true);
   });
 
-  it("viewerRoot contains render-template.html", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "render-template.html"))).toBe(true);
+  it("viewer package contains preview-frame-entry.tsx", () => {
+    expect(existsSync(resolve(viewerSrc, "preview-frame-entry.tsx"))).toBe(
+      true
+    );
+  });
+
+  it("viewer package contains render-template.html in src/", () => {
+    expect(existsSync(resolve(viewerSrc, "render-template.html"))).toBe(true);
   });
 
-  it("viewerRoot does not contain tailwind.config.js (removed in Tailwind→Fragments migration)", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "tailwind.config.js"))).toBe(false);
+  it("viewer package contains shared/index.ts barrel", () => {
+    expect(existsSync(resolve(viewerSrc, "shared/index.ts"))).toBe(true);
   });
 
-  it("viewerRoot contains styles/globals.css", () => {
-    const viewerRoot = resolve(cliPackageRoot, "src/viewer");
-    expect(existsSync(resolve(viewerRoot, "styles/globals.css"))).toBe(true);
+  it("viewer package contains app/index.ts barrel", () => {
+    expect(existsSync(resolve(viewerSrc, "app/index.ts"))).toBe(true);
+  });
+});
+
+describe("CLI viewer server references viewer package", () => {
+  it("server.ts has resolveViewerRoot function for monorepo and npm resolution", async () => {
+    const serverPath = resolve(viewerDir, "server.ts");
+    const content = await readFile(serverPath, "utf-8");
+
+    expect(content).toContain("function resolveViewerRoot(nodeModulesDir: string)");
+    // Checks monorepo path first
+    expect(content).toContain('resolve(packagesRoot, "viewer")');
+    // Falls back to npm-installed path
+    expect(content).toContain("@fragments-sdk/viewer");
+  });
+
+  it("server.ts sets up viewer subpath aliases", async () => {
+    const serverPath = resolve(viewerDir, "server.ts");
+    const content = await readFile(serverPath, "utf-8");
+
+    expect(content).toContain("@fragments-sdk/viewer/shared");
+    expect(content).toContain("@fragments-sdk/viewer/app");
+  });
+
+  it("server.ts does not reference old resolveFragmentsPackage for core", async () => {
+    const serverPath = resolve(viewerDir, "server.ts");
+    const content = await readFile(serverPath, "utf-8");
+
+    expect(content).not.toContain('resolveFragmentsPackage("core"');
+  });
+
+  it("no source files import from @fragments-sdk/cli/core as a runtime dependency", async () => {
+    const serverPath = resolve(viewerDir, "server.ts");
+    const content = await readFile(serverPath, "utf-8");
+
+    const lines = content.split("\n");
+    const importLines = lines.filter(
+      (l) => l.startsWith("import") && l.includes("@fragments-sdk/cli/core")
+    );
+    expect(importLines).toHaveLength(0);
   });
 });
 
 describe("@fragments-sdk/cli/core alias resolution", () => {
   it("core/index.ts exists at the expected path", () => {
-    // server.ts: "@fragments-sdk/cli/core": resolve(cliPackageRoot, "src/core/index.ts")
     const corePath = resolve(cliPackageRoot, "src/core/index.ts");
     expect(existsSync(corePath)).toBe(true);
   });
@@ -71,19 +109,15 @@ describe("@fragments-sdk/cli/core alias resolution", () => {
   it("core/index.ts re-exports from @fragments-sdk/core", async () => {
     const corePath = resolve(cliPackageRoot, "src/core/index.ts");
     const content = await readFile(corePath, "utf-8");
-    // After core extraction, cli/core is a thin re-export shim
     expect(content).toContain("@fragments-sdk/core");
   });
 });
 
 describe("virtual module @fragments-sdk/cli/core import", () => {
   it("vite-plugin generates import from @fragments-sdk/cli/core (resolved via alias)", async () => {
-    // The virtual module template in vite-plugin.ts must import from @fragments-sdk/cli/core
-    // which is resolved by the Vite alias to the consolidated core source
     const pluginPath = resolve(viewerDir, "vite-plugin.ts");
     const content = await readFile(pluginPath, "utf-8");
 
-    // The generated virtual module string should reference @fragments-sdk/cli/core
     expect(content).toContain(
       'import { storyModuleToFragment, setPreviewConfig, checkStoryExclusion, isForceIncluded, isConfigExcluded } from "@fragments-sdk/cli/core"'
     );
@@ -93,43 +127,47 @@ describe("virtual module @fragments-sdk/cli/core import", () => {
     const serverPath = resolve(viewerDir, "server.ts");
     const content = await readFile(serverPath, "utf-8");
 
-    // The alias must resolve @fragments-sdk/cli/core to the CLI's core source
-    expect(content).toContain('"@fragments-sdk/cli/core": resolve(cliPackageRoot, "src/core/index.ts")');
+    expect(content).toContain(
+      '"@fragments-sdk/cli/core": resolve(cliPackageRoot, "src/core/index.ts")'
+    );
   });
 
   it("vite-plugin merges authored variant code from metadata fragments", async () => {
     const pluginPath = resolve(viewerDir, "vite-plugin.ts");
     const content = await readFile(pluginPath, "utf-8");
 
-    expect(content).toContain("if (metaVariant.code && !fragmentVariant.code)");
+    expect(content).toContain(
+      "if (metaVariant.code && !fragmentVariant.code)"
+    );
     expect(content).toContain("fragmentVariant.code = metaVariant.code;");
   });
 });
 
 describe("viewer HTML templates", () => {
   it("index.html contains entry.tsx script reference", async () => {
-    const htmlPath = resolve(viewerDir, "index.html");
+    const htmlPath = resolve(viewerPackageRoot, "index.html");
     const content = await readFile(htmlPath, "utf-8");
 
-    // The HTML references /src/entry.tsx which gets rewritten to an absolute path
     expect(content).toContain('src="/src/entry.tsx"');
   });
 
   it("preview-frame.html contains preview-frame-entry.tsx reference", async () => {
-    const htmlPath = resolve(viewerDir, "preview-frame.html");
+    const htmlPath = resolve(viewerSrc, "preview-frame.html");
     const content = await readFile(htmlPath, "utf-8");
 
     expect(content).toContain('src="/src/preview-frame-entry.tsx"');
   });
 
-  it("vite-plugin rewrites entry paths using viewerAssetsRoot", async () => {
+  it("vite-plugin resolves viewerAssetsRoot with npm fallback", async () => {
     const pluginPath = resolve(viewerDir, "vite-plugin.ts");
     const content = await readFile(pluginPath, "utf-8");
 
-    // The plugin must use viewerAssetsRoot (not __dirname or resolve(__dirname, ".."))
-    // to find viewer HTML and entry files
-    expect(content).toContain("const viewerAssetsRoot = resolve(__dirname,");
-    expect(content).toContain('const viewerRoot = viewerAssetsRoot');
+    // Tries monorepo path first
+    expect(content).toContain("monorepoViewerSrc");
+    // Falls back to npm-installed
+    expect(content).toContain("npmViewerSrc");
+    // Resolves to a final viewerAssetsRoot
+    expect(content).toContain("const viewerAssetsRoot =");
   });
 });
 
@@ -139,7 +177,6 @@ describe("discoverInstalledFragments", () => {
   beforeAll(async () => {
     tmpDir = await mkdtemp(resolve(tmpdir(), "fragments-test-"));
 
-    // Create a fake project with a dependency that has fragments
     await writeFile(
       resolve(tmpDir, "package.json"),
       JSON.stringify({
@@ -147,7 +184,6 @@ describe("discoverInstalledFragments", () => {
       })
     );
 
-    // @acme/ui declares fragments
     const acmeDir = resolve(tmpDir, "node_modules/@acme/ui");
     await mkdir(resolve(acmeDir, "src/components"), { recursive: true });
     await writeFile(
@@ -163,7 +199,6 @@ describe("discoverInstalledFragments", () => {
       "export default {};"
     );
 
-    // some-lib does NOT declare fragments
     const someLibDir = resolve(tmpDir, "node_modules/some-lib");
     await mkdir(resolve(someLibDir, "src"), { recursive: true });
     await writeFile(
@@ -209,27 +244,3 @@ describe("discoverInstalledFragments", () => {
     await rm(emptyDir, { recursive: true, force: true });
   });
 });
-
-describe("no stale @fragments/* package references", () => {
-  it("server.ts does not reference old resolveFragmentsPackage for core", async () => {
-    const serverPath = resolve(viewerDir, "server.ts");
-    const content = await readFile(serverPath, "utf-8");
-
-    // Should NOT try to resolve @fragments-sdk/cli/core from node_modules
-    expect(content).not.toContain('resolveFragmentsPackage("core"');
-  });
-
-  it("no source files import from @fragments-sdk/cli/core as a runtime dependency", async () => {
-    // All source-level imports should use relative paths (../core/).
-    // Only the generated virtual module string uses @fragments-sdk/cli/core (resolved via alias).
-    const serverPath = resolve(viewerDir, "server.ts");
-    const content = await readFile(serverPath, "utf-8");
-
-    // server.ts should import from relative paths, not @fragments-sdk/cli/core
-    const lines = content.split("\n");
-    const importLines = lines.filter(
-      (l) => l.startsWith("import") && l.includes("@fragments-sdk/cli/core")
-    );
-    expect(importLines).toHaveLength(0);
-  });
-});