fimo 0.7.0-experimental.6 → 0.7.0-experimental.7

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-22T17:22:19.882Z",
+  "bundledAt": "2026-07-23T07:43:57.934Z",
   "cliVersion": "0.6.0",
   "external": [
     "oxc-parser",

package/dist/cli/index.js

@@ -115543,6 +115543,151 @@ __name(writeSchemaDrafts, "writeSchemaDrafts");
 // src/cli/commands/migrate-wrap.ts
 init_discover();
 init_wiring();
+
+// src/scripts/frameworks/support.ts
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "node:fs";
+import { join as join27 } from "node:path";
+var REACT_CHECK = {
+  pkg: "react",
+  min: "18.0.0",
+  label: "React",
+  reason: "Fimo's inline-editing runtime uses React 18 APIs (useSyncExternalStore).",
+  remedy: "Upgrade React to 18 or newer. The content still migrates on older React; only inline editing needs 18+."
+};
+function supportChecksFor(detection) {
+  switch (detection.framework) {
+    case "next":
+    case "remix":
+    case "react-router":
+      return [REACT_CHECK];
+    case "vite":
+      return detection.react ? [REACT_CHECK] : [];
+    case "nuxt":
+      return [
+        {
+          pkg: "nuxt",
+          min: "3.0.0",
+          label: "Nuxt",
+          reason: "Fimo supports Nuxt 3+ (Vue 3). Nuxt 2 is end-of-life.",
+          remedy: "Upgrade to Nuxt 3 or newer."
+        }
+      ];
+    case "vue":
+      return [
+        {
+          pkg: "vue",
+          min: "3.0.0",
+          label: "Vue",
+          reason: "Fimo supports Vue 3+. Vue 2 is end-of-life.",
+          remedy: "Upgrade to Vue 3 or newer."
+        }
+      ];
+    case "astro":
+      return [
+        {
+          pkg: "astro",
+          min: "4.0.0",
+          label: "Astro",
+          reason: "Fimo supports Astro 4+.",
+          remedy: "Upgrade Astro to 4 or newer."
+        }
+      ];
+    case "sveltekit":
+      return [
+        {
+          pkg: "@sveltejs/kit",
+          min: "2.0.0",
+          label: "SvelteKit",
+          reason: "Fimo supports SvelteKit 2+.",
+          remedy: "Upgrade @sveltejs/kit to 2 or newer."
+        }
+      ];
+    default:
+      return [];
+  }
+}
+__name(supportChecksFor, "supportChecksFor");
+function parseVersionFloor(spec) {
+  if (!spec) {
+    return null;
+  }
+  const first2 = spec.split("||")[0];
+  const match = first2.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: match[2] ? Number(match[2]) : 0,
+    patch: match[3] ? Number(match[3]) : 0,
+    raw: spec.trim()
+  };
+}
+__name(parseVersionFloor, "parseVersionFloor");
+function isBelowFloor(found, min) {
+  const floor = parseVersionFloor(min);
+  if (!floor) {
+    return false;
+  }
+  if (found.major !== floor.major) {
+    return found.major < floor.major;
+  }
+  if (found.minor !== floor.minor) {
+    return found.minor < floor.minor;
+  }
+  return found.patch < floor.patch;
+}
+__name(isBelowFloor, "isBelowFloor");
+function readHostVersion(cwd, pkg) {
+  const installed = join27(cwd, "node_modules", pkg, "package.json");
+  if (existsSync16(installed)) {
+    try {
+      const version2 = JSON.parse(readFileSync20(installed, "utf8")).version;
+      const parsed = parseVersionFloor(String(version2));
+      if (parsed) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const rootPkg = join27(cwd, "package.json");
+  if (existsSync16(rootPkg)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync20(rootPkg, "utf8"));
+      const spec = { ...pkgJson.dependencies, ...pkgJson.devDependencies }[pkg];
+      if (spec) {
+        return parseVersionFloor(String(spec));
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+__name(readHostVersion, "readHostVersion");
+function checkHostSupport(cwd, detection) {
+  const violations = [];
+  const detected = [];
+  for (const check2 of supportChecksFor(detection)) {
+    const found = readHostVersion(cwd, check2.pkg);
+    if (!found) {
+      continue;
+    }
+    detected.push({ label: check2.label, version: found.raw });
+    if (isBelowFloor(found, check2.min)) {
+      violations.push({
+        subject: check2.label,
+        found: found.raw,
+        min: check2.min,
+        headline: `${check2.label} ${found.raw} is below Fimo's floor of ${check2.label} ${check2.min}. ${check2.reason}`,
+        remedy: check2.remedy
+      });
+    }
+  }
+  return { ok: violations.length === 0, violations, detected };
+}
+__name(checkHostSupport, "checkHostSupport");
+
+// src/cli/commands/migrate-wrap.ts
 init_scan_wrappable();
 init_fimo_dep();
 init_color();
@@ -116103,6 +116248,16 @@ async function migrateWrapCommand(options) {
   }
   const detection = detectFramework(cwd);
   const framework = typeof config2.framework === "string" ? config2.framework : detection.framework;
+  const support = checkHostSupport(cwd, detection);
+  if (!support.ok) {
+    ui.error({
+      command: "migrate wrap",
+      code: "HOST_UNSUPPORTED",
+      message: support.violations.map((violation) => violation.headline).join(" "),
+      hint: support.violations.map((violation) => violation.remedy).join(" ")
+    });
+    return;
+  }
   if (!options.check && currentMode().format === "pretty") {
     process.stdout.write("\n");
   }

package/dist/scripts/frameworks/support.d.ts

@@ -0,0 +1,75 @@
+import type { FrameworkDetection } from '../detect-framework.js';
+/**
+ * A host dependency the wrap gates on, with the floor Fimo's runtime requires.
+ * The floor is honest to the API surface the in-tree runtime actually uses —
+ * React frameworks gate on `react` 18 (the runtime touches `useSyncExternalStore`),
+ * Vue/Svelte/Astro on their own framework floor. The version gate is what turns
+ * an unsupported host into one actionable sentence instead of an npm `ERESOLVE`
+ * or an install-then-crash.
+ */
+export interface SupportCheck {
+    pkg: string;
+    /** Floor, `X.Y.Z`. */
+    min: string;
+    label: string;
+    /** Why this floor exists — shown to the user. */
+    reason: string;
+    /** One actionable next step — shown as the error hint. */
+    remedy: string;
+}
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export declare function supportChecksFor(detection: Pick<FrameworkDetection, 'framework' | 'react'>): SupportCheck[];
+interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    /** The original spec, for display. */
+    raw: string;
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export declare function parseVersionFloor(spec: string): ParsedVersion | null;
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export declare function readHostVersion(cwd: string, pkg: string): ParsedVersion | null;
+export interface HostSupportViolation {
+    subject: string;
+    /** The version we found on the host. */
+    found: string;
+    /** The floor Fimo requires. */
+    min: string;
+    /** Headline sentence for the error message. */
+    headline: string;
+    /** Actionable next step for the error hint. */
+    remedy: string;
+}
+export interface HostSupportResult {
+    ok: boolean;
+    violations: HostSupportViolation[];
+    /** Versions read successfully — for the summary line ("React 18.3.1"). */
+    detected: Array<{
+        label: string;
+        version: string;
+    }>;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export declare function checkHostSupport(cwd: string, detection: Pick<FrameworkDetection, 'framework' | 'react'>): HostSupportResult;
+export {};

package/dist/scripts/frameworks/support.js

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const REACT_CHECK = {
+    pkg: 'react',
+    min: '18.0.0',
+    label: 'React',
+    reason: "Fimo's inline-editing runtime uses React 18 APIs (useSyncExternalStore).",
+    remedy: 'Upgrade React to 18 or newer. The content still migrates on older React; only inline editing needs 18+.',
+};
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export function supportChecksFor(detection) {
+    switch (detection.framework) {
+        case 'next':
+        case 'remix':
+        case 'react-router':
+            return [REACT_CHECK];
+        case 'vite':
+            return detection.react ? [REACT_CHECK] : [];
+        case 'nuxt':
+            return [
+                {
+                    pkg: 'nuxt',
+                    min: '3.0.0',
+                    label: 'Nuxt',
+                    reason: 'Fimo supports Nuxt 3+ (Vue 3). Nuxt 2 is end-of-life.',
+                    remedy: 'Upgrade to Nuxt 3 or newer.',
+                },
+            ];
+        case 'vue':
+            return [
+                {
+                    pkg: 'vue',
+                    min: '3.0.0',
+                    label: 'Vue',
+                    reason: 'Fimo supports Vue 3+. Vue 2 is end-of-life.',
+                    remedy: 'Upgrade to Vue 3 or newer.',
+                },
+            ];
+        case 'astro':
+            return [
+                {
+                    pkg: 'astro',
+                    min: '4.0.0',
+                    label: 'Astro',
+                    reason: 'Fimo supports Astro 4+.',
+                    remedy: 'Upgrade Astro to 4 or newer.',
+                },
+            ];
+        case 'sveltekit':
+            return [
+                {
+                    pkg: '@sveltejs/kit',
+                    min: '2.0.0',
+                    label: 'SvelteKit',
+                    reason: 'Fimo supports SvelteKit 2+.',
+                    remedy: 'Upgrade @sveltejs/kit to 2 or newer.',
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export function parseVersionFloor(spec) {
+    if (!spec) {
+        return null;
+    }
+    // A `||` union — the floor is the lowest branch, i.e. the first token.
+    const first = spec.split('||')[0];
+    const match = first.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: match[2] ? Number(match[2]) : 0,
+        patch: match[3] ? Number(match[3]) : 0,
+        raw: spec.trim(),
+    };
+}
+function isBelowFloor(found, min) {
+    const floor = parseVersionFloor(min);
+    if (!floor) {
+        return false;
+    }
+    if (found.major !== floor.major) {
+        return found.major < floor.major;
+    }
+    if (found.minor !== floor.minor) {
+        return found.minor < floor.minor;
+    }
+    return found.patch < floor.patch;
+}
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export function readHostVersion(cwd, pkg) {
+    const installed = join(cwd, 'node_modules', pkg, 'package.json');
+    if (existsSync(installed)) {
+        try {
+            const version = JSON.parse(readFileSync(installed, 'utf8')).version;
+            const parsed = parseVersionFloor(String(version));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // fall through to the declared range
+        }
+    }
+    const rootPkg = join(cwd, 'package.json');
+    if (existsSync(rootPkg)) {
+        try {
+            const pkgJson = JSON.parse(readFileSync(rootPkg, 'utf8'));
+            const spec = { ...pkgJson.dependencies, ...pkgJson.devDependencies }[pkg];
+            if (spec) {
+                return parseVersionFloor(String(spec));
+            }
+        }
+        catch {
+            // unreadable — nothing to gate on
+        }
+    }
+    return null;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export function checkHostSupport(cwd, detection) {
+    const violations = [];
+    const detected = [];
+    for (const check of supportChecksFor(detection)) {
+        const found = readHostVersion(cwd, check.pkg);
+        if (!found) {
+            continue;
+        }
+        detected.push({ label: check.label, version: found.raw });
+        if (isBelowFloor(found, check.min)) {
+            violations.push({
+                subject: check.label,
+                found: found.raw,
+                min: check.min,
+                headline: `${check.label} ${found.raw} is below Fimo's floor of ${check.label} ${check.min}. ${check.reason}`,
+                remedy: check.remedy,
+            });
+        }
+    }
+    return { ok: violations.length === 0, violations, detected };
+}

package/dist/scripts/frameworks/support.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/frameworks/support.test.js

@@ -0,0 +1,87 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { checkHostSupport, parseVersionFloor, readHostVersion } from './support.js';
+let dir;
+function project(pkg, installed = {}) {
+    dir = mkdtempSync(join(tmpdir(), 'host-support-'));
+    writeFileSync(join(dir, 'package.json'), JSON.stringify(pkg));
+    for (const [name, version] of Object.entries(installed)) {
+        const modDir = join(dir, 'node_modules', name);
+        mkdirSync(modDir, { recursive: true });
+        writeFileSync(join(modDir, 'package.json'), JSON.stringify({ name, version }));
+    }
+    return dir;
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('parseVersionFloor', () => {
+    it('reads the lowest concrete version from real spec shapes', () => {
+        expect(parseVersionFloor('^18.2.0')).toMatchObject({ major: 18, minor: 2, patch: 0 });
+        expect(parseVersionFloor('>=2.0.0')).toMatchObject({ major: 2, minor: 0, patch: 0 });
+        expect(parseVersionFloor('~3.4')).toMatchObject({ major: 3, minor: 4, patch: 0 });
+        expect(parseVersionFloor('18')).toMatchObject({ major: 18, minor: 0, patch: 0 });
+        // a `||` union floors on the lowest (first) branch
+        expect(parseVersionFloor('^17.0.0 || ^18.0.0')).toMatchObject({ major: 17 });
+    });
+    it('returns null for specs with no numeric floor', () => {
+        expect(parseVersionFloor('latest')).toBeNull();
+        expect(parseVersionFloor('*')).toBeNull();
+        expect(parseVersionFloor('workspace:*')).toBeNull();
+        expect(parseVersionFloor('')).toBeNull();
+    });
+});
+describe('readHostVersion', () => {
+    it('prefers the installed manifest over the declared range', () => {
+        const cwd = project({ dependencies: { react: '^18.0.0' } }, { react: '18.3.1' });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 18, minor: 3, patch: 1 });
+    });
+    it('falls back to the declared range when nothing is installed', () => {
+        const cwd = project({ dependencies: { react: '^19.0.0' } });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 19, minor: 0, patch: 0 });
+    });
+    it('returns null when the dependency is absent', () => {
+        const cwd = project({ dependencies: {} });
+        expect(readHostVersion(cwd, 'react')).toBeNull();
+    });
+});
+describe('checkHostSupport', () => {
+    it('passes a Next.js site on React 18', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^18.2.0' } }, { react: '18.3.1' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(true);
+        expect(result.violations).toEqual([]);
+        expect(result.detected).toContainEqual({ label: 'React', version: '18.3.1' });
+    });
+    it('passes a Next.js site on React 19', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^19.0.0' } }, { react: '19.0.0' });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+    it('flags a React 17 site below the floor with an actionable message', () => {
+        const cwd = project({ dependencies: { next: '13.0.0', react: '^17.0.2' } }, { react: '17.0.2' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(false);
+        expect(result.violations).toHaveLength(1);
+        expect(result.violations[0]).toMatchObject({ subject: 'React', min: '18.0.0' });
+        expect(result.violations[0].headline).toContain('React 17.0.2');
+        expect(result.violations[0].remedy).toMatch(/upgrade react/i);
+    });
+    it('flags a Nuxt 2 site below the floor', () => {
+        const cwd = project({ dependencies: { nuxt: '^2.17.0' } }, { nuxt: '2.17.0' });
+        const result = checkHostSupport(cwd, { framework: 'nuxt' });
+        expect(result.ok).toBe(false);
+        expect(result.violations[0]).toMatchObject({ subject: 'Nuxt', min: '3.0.0' });
+    });
+    it('does not gate a non-React bare Vite site', () => {
+        const cwd = project({ dependencies: { vite: '^5.0.0' } });
+        expect(checkHostSupport(cwd, { framework: 'vite', react: false }).ok).toBe(true);
+    });
+    it('does not gate on a version it cannot read', () => {
+        const cwd = project({ dependencies: { next: '16.0.0', react: 'workspace:*' } });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.7.0-experimental.6",
+  "version": "0.7.0-experimental.7",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -158,8 +158,8 @@
     "astro": ">=4.0.0",
     "next": ">=14.0.0",
     "nuxt": ">=3.0.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^18.2.0 || ^19.0.0",
+    "react-dom": "^18.2.0 || ^19.0.0",
     "react-router": "^7.0.0",
     "vue": ">=3.0.0"
   },

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.7.0-experimental.6",
+    "fimo": "0.7.0-experimental.7",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",