isotone 1.0.9 → 1.1.0

package/dist/vite-plugin.js

@@ -12,17 +12,20 @@ import {
   overrideSourcePath,
   readActive,
   readVariant,
+  readVariants,
   resolveOverride,
+  variantDir,
   variantsDir,
   variantsResponse
-} from "./chunk-UT2NLGBM.js";
+} from "./chunk-TGAU3WTF.js";
 import {
-  VARIANTS_ENDPOINT
-} from "./chunk-OSETWKGE.js";
+  VARIANTS_ENDPOINT,
+  overlayGroups
+} from "./chunk-PUXQGUMQ.js";
 import {
   UPDATE_ENDPOINT,
   startUpdateCheck
-} from "./chunk-MXGHTQB2.js";
+} from "./chunk-B3JNZITE.js";
 import {
   NOTES_ENDPOINT,
   ensureDirIgnored,
@@ -34,12 +37,445 @@ import "./chunk-A4DX2V4C.js";
 // src/vite/index.ts
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "fs";
 import { dirname, isAbsolute, join, relative, resolve } from "path";
-import { normalizePath } from "vite";
+import {
+  normalizePath
+} from "vite";
+
+// src/vite/exports.ts
+var ROUTE_EXPORTS = /* @__PURE__ */ new Set([
+  "loader",
+  "action",
+  "clientLoader",
+  "clientAction",
+  "headers",
+  "links",
+  "meta",
+  "handle",
+  "shouldRevalidate",
+  "middleware",
+  "clientMiddleware",
+  "unstable_middleware",
+  "unstable_clientMiddleware",
+  "HydrateFallback"
+]);
+var IDENT = /^[A-Za-z_$][\w$]*$/;
+function scanExports(code) {
+  const names = /* @__PURE__ */ new Set();
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").replace(/^(?:\/\*.*?\*\/\s*)+/, "");
+    if (!line.startsWith("export")) continue;
+    const rest = line.slice("export".length);
+    if (rest !== "" && !/^[\s{*]/.test(rest)) continue;
+    const body = rest.trim();
+    if (body.startsWith("{") || body.startsWith("type {")) {
+      if (body.startsWith("type")) continue;
+      let clause = body;
+      while (!clause.includes("}") && i + 1 < lines.length) clause += ` ${lines[++i]}`;
+      const inner = clause.slice(clause.indexOf("{") + 1, clause.indexOf("}"));
+      for (const raw of inner.split(",")) {
+        const spec = raw.replace(/\/\/.*$/, "").trim();
+        if (!spec || spec.startsWith("type ")) continue;
+        const as = spec.split(/\s+as\s+/);
+        const name = (as[1] ?? as[0] ?? "").trim().replace(/^["']|["']$/g, "");
+        if (!name) return null;
+        names.add(name);
+      }
+      continue;
+    }
+    if (/^type\s*\*/.test(body)) continue;
+    const star = body.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)/);
+    if (star?.[1]) {
+      names.add(star[1]);
+      continue;
+    }
+    if (body.startsWith("*")) return null;
+    if (/^default\b/.test(body)) {
+      names.add("default");
+      continue;
+    }
+    if (/^(?:declare\s|type\s|interface\s)/.test(body)) continue;
+    if (/^(?:=|import\s|namespace\s|module\s|as\s)/.test(body)) return null;
+    const decl = body.match(
+      /^(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)|^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)|^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/
+    );
+    const declared = decl?.[1] ?? decl?.[2] ?? decl?.[3];
+    if (declared) {
+      names.add(declared);
+      continue;
+    }
+    const variable = body.match(/^(?:const|let|var)\s+(.*)$/);
+    if (variable) {
+      const target = (variable[1] ?? "").trim();
+      if (target.startsWith("{") || target.startsWith("[")) return null;
+      const name = target.match(/^([A-Za-z_$][\w$]*)/)?.[1];
+      if (!name) return null;
+      if (hasSecondDeclarator(target)) return null;
+      names.add(name);
+      continue;
+    }
+    return null;
+  }
+  for (const name of names) if (name !== "default" && !IDENT.test(name)) return null;
+  return [...names];
+}
+function isRouteModule(names) {
+  return names.includes("default") && names.some((name) => ROUTE_EXPORTS.has(name));
+}
+function hasSecondDeclarator(declaration) {
+  const text = declaration.replace(/\/\/.*$/, "").replace(/'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`/g, '""');
+  let depth = 0;
+  let initialized = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "(" || ch === "[" || ch === "{" || ch === "<") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}" || ch === ">" && text[i - 1] !== "=") depth = Math.max(0, depth - 1);
+    else if (depth === 0 && ch === "=" && text[i + 1] !== "=" && text[i + 1] !== ">" && text[i - 1] !== "=") initialized = true;
+    else if (depth === 0 && ch === "," && initialized) return true;
+  }
+  return depth === 0 && /,\s*$/.test(text);
+}
+
+// src/vite/live.ts
+var VERSION_QUERY = "isotone";
+var BASE_VERSION = "_base";
+var LIVE_MODULE = "virtual:isotone/live";
+var RESOLVED_LIVE_MODULE = "\0isotone-live";
+var ACTIVE_EVENT = "isotone:active";
+function liveStore(win, cfg) {
+  if (win.__isotoneLive && win.__isotoneLive.version === 1) return win.__isotoneLive;
+  const PARAM = "v";
+  const DEFAULT = "default";
+  const groups = cfg.groups;
+  const byId = new Map(groups.map((group) => [group.id, group]));
+  const listeners = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Map();
+  const history = win.history;
+  const replace = history.replaceState;
+  const push = history.pushState;
+  const decode = (text) => {
+    try {
+      return decodeURIComponent(text.replace(/\+/g, " "));
+    } catch {
+      return text;
+    }
+  };
+  const readParam = (search2) => {
+    for (const part of search2.replace(/^\?/, "").split("&")) {
+      const at = part.indexOf("=");
+      const key = at < 0 ? part : part.slice(0, at);
+      if (decode(key) === PARAM) return decode(at < 0 ? "" : part.slice(at + 1));
+    }
+    return null;
+  };
+  const parse = (search2) => {
+    const raw = readParam(search2);
+    if (raw === null) return { picks: null, foreign: [] };
+    const foreign = [];
+    const picks = /* @__PURE__ */ new Map();
+    for (const pair of raw.split(",")) {
+      if (!pair) continue;
+      const at = pair.indexOf(":");
+      const group = at < 0 ? void 0 : byId.get(pair.slice(0, at));
+      const value = at < 0 ? "" : pair.slice(at + 1);
+      if (group && (value === DEFAULT || group.members.includes(value))) picks.set(group.id, value);
+      else foreign.push(pair);
+    }
+    if (picks.size === 0) return { picks: null, foreign };
+    return { picks: [...picks.values()].filter((value) => value !== DEFAULT), foreign };
+  };
+  const search = (set) => {
+    const { foreign } = parse(win.location.search);
+    const mine = [];
+    for (const group of groups) {
+      const pick = group.members.find((member) => set.includes(member));
+      if (pick) mine.push(`${group.id}:${pick}`);
+    }
+    const value = [...foreign, ...mine].join(",");
+    const kept = win.location.search.replace(/^\?/, "").split("&").filter((part) => {
+      if (!part) return false;
+      const at = part.indexOf("=");
+      return decode(at < 0 ? part : part.slice(0, at)) !== PARAM;
+    });
+    if (value) kept.push(`${PARAM}=${encodeURIComponent(value).replace(/%3A/gi, ":").replace(/%2C/gi, ",")}`);
+    return kept.length ? `?${kept.join("&")}` : "";
+  };
+  const writeUrl = (set) => {
+    const next = `${win.location.pathname}${search(set)}${win.location.hash}`;
+    if (next !== `${win.location.pathname}${win.location.search}${win.location.hash}`) {
+      replace.call(history, history.state, "", next);
+    }
+  };
+  const fromUrl = parse(win.location.search).picks;
+  const server = cfg.active.slice();
+  let active = fromUrl ?? server.slice();
+  let explicit = fromUrl !== null;
+  let reloading = false;
+  const versionOf = (ids, set) => {
+    for (const id of set) if (ids.includes(id)) return id;
+    return null;
+  };
+  const needsReload = (from, to) => {
+    for (const file of files.values()) {
+      if (file.pinned && versionOf(file.ids, from) !== versionOf(file.ids, to)) return true;
+    }
+    return false;
+  };
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  const reload = () => {
+    reloading = true;
+    win.location.reload();
+  };
+  let syncing = false;
+  const freshLoad = () => {
+    try {
+      const entry = win.performance.getEntriesByType("navigation")[0];
+      if (entry?.type) return entry.type !== "reload";
+      return win.performance.navigation?.type !== 1;
+    } catch {
+      return true;
+    }
+  };
+  const syncServer = () => {
+    if (syncing || !freshLoad()) return;
+    syncing = true;
+    const key = "isotone:live-sync";
+    const target = JSON.stringify(active);
+    try {
+      const last = JSON.parse(win.sessionStorage.getItem(key) ?? "null");
+      if (last && last.target === target && Date.now() - last.at < 1e4) return;
+      win.sessionStorage.setItem(key, JSON.stringify({ target, at: Date.now() }));
+    } catch {
+      return;
+    }
+    const send = win.__isotoneFetch ?? win.fetch.bind(win);
+    send(`${cfg.endpoint}/active`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ active })
+    }).then((res) => {
+      if (res.ok) reload();
+    }, () => {
+    });
+  };
+  const keep = (original) => function(...args) {
+    const result = original.apply(this, args);
+    if (explicit && parse(win.location.search).picks === null) writeUrl(active);
+    return result;
+  };
+  history.pushState = keep(push);
+  history.replaceState = keep(replace);
+  win.addEventListener("popstate", () => {
+    if (explicit) writeUrl(active);
+  });
+  const store = {
+    version: 1,
+    get active() {
+      return active;
+    },
+    get server() {
+      return server;
+    },
+    get explicit() {
+      return explicit;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    register(key, ids, pinned) {
+      files.set(key, { ids, pinned });
+      if (cfg.ssr && pinned && win.document.readyState !== "complete" && versionOf(ids, active) !== versionOf(ids, server)) {
+        queueMicrotask(syncServer);
+      }
+    },
+    needsReload(next) {
+      return needsReload(active, next);
+    },
+    select(next) {
+      if (reloading) return true;
+      const reloadNeeded = needsReload(active, next);
+      active = next.slice();
+      explicit = next.length > 0;
+      writeUrl(active);
+      if (reloadNeeded) return true;
+      emit();
+      return false;
+    },
+    follow(next) {
+      if (explicit || reloading) return;
+      const same = next.length === active.length && next.every((id) => active.includes(id));
+      if (same) return;
+      const reloadNeeded = needsReload(active, next);
+      active = next.slice();
+      if (reloadNeeded) reload();
+      else emit();
+    },
+    reload
+  };
+  win.__isotoneLive = store;
+  return store;
+}
+function liveBinder(React, store) {
+  const MEMO = /* @__PURE__ */ Symbol.for("react.memo");
+  const FORWARD = /* @__PURE__ */ Symbol.for("react.forward_ref");
+  const LAZY = /* @__PURE__ */ Symbol.for("react.lazy");
+  const refAsProp = Number.parseInt(React.version, 10) >= 19;
+  const BUILTIN = /* @__PURE__ */ new Set([
+    "length",
+    "name",
+    "prototype",
+    "caller",
+    "arguments",
+    "displayName",
+    "$$typeof",
+    "render",
+    "type",
+    "compare",
+    "_payload",
+    "_init"
+  ]);
+  const isClass = (value) => typeof value === "function" && /^class[\s{]/.test(Function.prototype.toString.call(value));
+  const isComponent = (name, value, jsx) => {
+    if (typeof value === "function") {
+      const proto = value.prototype;
+      if (proto?.isReactComponent) return true;
+      if (isClass(value)) return false;
+      if (name !== "default") return /^[A-Z]/.test(name);
+      const own = value.name ?? "";
+      return /^[A-Z]/.test(own) || jsx && (own === "" || own === "default");
+    }
+    if (!value || typeof value !== "object") return false;
+    const tag = value.$$typeof;
+    return tag === MEMO || tag === FORWARD || tag === LAZY;
+  };
+  return {
+    file(key, ids, modules, names) {
+      const pick = (set) => {
+        for (const id of set) {
+          const hit = ids.indexOf(id);
+          if (hit >= 0) return hit;
+        }
+        const base = ids.indexOf(null);
+        return base >= 0 ? base : 0;
+      };
+      const out = {};
+      const renders = /* @__PURE__ */ new Map();
+      const jsx = /x$/.test(key);
+      let pinned = false;
+      for (const name of names) {
+        const values = modules.map((mod) => mod[name]);
+        const first = values[0];
+        if (values.every((value) => value === first)) {
+          out[name] = first;
+          continue;
+        }
+        const defined = values.filter((value) => value !== void 0);
+        if (defined.length > 0 && defined.every((value) => isComponent(name, value, jsx))) {
+          const render = (props, ref) => {
+            const index = React.useSyncExternalStore(
+              store.subscribe,
+              () => pick(store.active),
+              () => pick(store.server)
+            );
+            const component = values[index];
+            if (component == null) return null;
+            return React.createElement(component, ref == null ? props : { ...props, ref });
+          };
+          renders.set(name, render);
+          const wrapper = refAsProp ? (props) => render(props) : React.forwardRef(render);
+          const label = name === "default" ? defined[0].displayName ?? defined[0].name ?? "Variant" : name;
+          if (typeof wrapper === "function") Object.defineProperty(wrapper, "name", { value: label });
+          wrapper.displayName = label;
+          const statics = /* @__PURE__ */ new Set();
+          for (const value of defined) {
+            for (const prop of Object.getOwnPropertyNames(value)) if (!BUILTIN.has(prop)) statics.add(prop);
+          }
+          for (const prop of statics) {
+            if (prop in wrapper && !Object.getOwnPropertyDescriptor(wrapper, prop)?.configurable) continue;
+            Object.defineProperty(wrapper, prop, {
+              configurable: true,
+              enumerable: true,
+              get: () => values[pick(store.active)]?.[prop]
+            });
+          }
+          out[name] = wrapper;
+          continue;
+        }
+        pinned = true;
+        out[name] = values[pick(store.active)];
+      }
+      store.register(key, ids, pinned);
+      Object.defineProperty(out, "__isotoneRender", {
+        value: (name, props, ref) => {
+          const render = renders.get(name);
+          if (render) return render(props, ref);
+          const value = out[name];
+          return typeof value === "function" || value && typeof value === "object" ? React.createElement(value, ref == null ? props : { ...props, ref }) : null;
+        }
+      });
+      return out;
+    }
+  };
+}
+function liveStoreScript(cfg) {
+  return `(${liveStore.toString()})(window, ${safeJson(cfg)});`;
+}
+function liveRuntimeModule(fallback) {
+  return [
+    `import * as React from 'react';`,
+    `const store = (${liveStore.toString()})(window, ${safeJson(fallback)});`,
+    `export const live = (${liveBinder.toString()})(React, store);`,
+    `if (import.meta.hot) import.meta.hot.on(${JSON.stringify(ACTIVE_EVENT)}, (data) => store.follow(data.active));`,
+    ""
+  ].join("\n");
+}
+function dispatcherModule(key, basename, versions, names) {
+  const lines = [`import { live as __isotone } from ${JSON.stringify(LIVE_MODULE)};`];
+  versions.forEach((id, i) => {
+    const spec = `./${basename}?${VERSION_QUERY}=${id ?? BASE_VERSION}`;
+    lines.push(`import * as __v${i} from ${JSON.stringify(spec)};`);
+  });
+  const hoisted = (name) => name === "default" || /^[A-Z][\w$]*$/.test(name);
+  const local = (name) => name === "default" ? "__isotoneDefault" : name;
+  for (const name of names.filter(hoisted)) {
+    const head = name === "default" ? "export default function __isotoneDefault" : `export function ${name}`;
+    lines.push(`${head}(props, ref) { return __f.__isotoneRender(${JSON.stringify(name)}, props, ref); }`);
+  }
+  lines.push(
+    `const __f = __isotone.file(${JSON.stringify(key)}, ${JSON.stringify(versions)}, [${versions.map((_, i) => `__v${i}`).join(", ")}], ${JSON.stringify(names)});`
+  );
+  names.forEach((name, i) => {
+    if (hoisted(name)) {
+      lines.push(`${local(name)} = __f[${JSON.stringify(name)}];`);
+      return;
+    }
+    lines.push(`const __e${i} = __f[${JSON.stringify(name)}];`);
+    lines.push(`export { __e${i} as ${name} };`);
+  });
+  lines.push("");
+  return lines.join("\n");
+}
+function safeJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+
+// src/vite/index.ts
 var DEFAULT_FILE = ".iteration-feedback.json";
 var INJECTED = /* @__PURE__ */ new WeakSet();
 var BUNDLE_PATH = "/@isotone/panel.js";
 var MANIFEST = "variant.json";
 var SPECIAL_QUERY = /[?&](raw|url|inline|no-inline|worker|sharedworker|html-proxy)(?:[&=]|$)/;
+var COMPARES_TYPES = /\.type\s*[!=]==?|[!=]==?\s*[\w$.]+\.type\b/;
+function versionOfId(id) {
+  const at = id?.indexOf("?") ?? -1;
+  if (!id || at < 0) return null;
+  return new URLSearchParams(id.slice(at + 1)).get(VERSION_QUERY);
+}
 function isInside(dir, path) {
   const rel = relative(dir, path);
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
@@ -65,7 +501,133 @@ function iteration(options = {}) {
   let activeFile = join(vopts.root, ACTIVE_FILE);
   let activeIds;
   const overrides = /* @__PURE__ */ new Map();
-  const swapping = /* @__PURE__ */ new Set();
+  const swapping = /* @__PURE__ */ new Map();
+  let live = false;
+  let hasReact = false;
+  let ssrHost = false;
+  let manifests = null;
+  let byFile = null;
+  let addedFiles = null;
+  const dispatched = /* @__PURE__ */ new Map();
+  let reloadTimer = null;
+  const readManifests = () => {
+    manifests ??= readVariants(vopts);
+    return manifests;
+  };
+  const versionsByFile = () => {
+    if (byFile) return byFile;
+    byFile = /* @__PURE__ */ new Map();
+    for (const variant of readManifests()) {
+      for (const key of Object.keys(variant.files)) {
+        const path = normalizePath(join(vopts.root, key));
+        byFile.set(path, [...byFile.get(path) ?? [], variant.id]);
+      }
+    }
+    return byFile;
+  };
+  const filesOnlyInVariants = () => {
+    if (addedFiles) return addedFiles;
+    addedFiles = /* @__PURE__ */ new Map();
+    for (const path of versionsByFile().keys()) {
+      if (existsSync(path)) continue;
+      const stem = path.replace(/\.[cm]?[jt]sx?$/, "");
+      addedFiles.set(stem, [...addedFiles.get(stem) ?? [], path]);
+    }
+    return addedFiles;
+  };
+  const forgetManifests = () => {
+    manifests = null;
+    byFile = null;
+    addedFiles = null;
+    overrides.clear();
+  };
+  const groupsOf = (list) => overlayGroups(list).map((group) => ({ id: group.id, members: group.members.map((m) => m.id) }));
+  const liveConfig = () => ({
+    groups: groupsOf(readManifests()),
+    active: currentActive(),
+    ssr: ssrHost,
+    endpoint: VARIANTS_ENDPOINT
+  });
+  const overrideOf = (id, path) => {
+    const key = normalizePath(relative(vopts.root, path));
+    const manifest = readManifests().find((v) => v.id === id);
+    if (!manifest || !Object.hasOwn(manifest.files, key)) return null;
+    const file2 = join(variantDir(vopts, id), key);
+    return existsSync(file2) ? file2 : null;
+  };
+  const dispatchPlan = (path) => {
+    if (!/\.[cm]?[jt]sx?$/.test(path)) return null;
+    const ids = versionsByFile().get(path);
+    if (!ids?.length) return null;
+    const versions = [];
+    const names = /* @__PURE__ */ new Set();
+    const sources = [];
+    if (existsSync(path)) sources.push([null, path]);
+    for (const id of ids) {
+      const file2 = overrideOf(id, path);
+      if (file2) sources.push([id, file2]);
+    }
+    for (const [id, file2] of sources) {
+      const code = readFileSync(file2, "utf8");
+      if (COMPARES_TYPES.test(code)) return null;
+      const found = scanExports(code);
+      if (!found || isRouteModule(found)) return null;
+      for (const name of found) names.add(name);
+      versions.push(id);
+    }
+    if (versions.length === 0 || names.size === 0) return null;
+    return { key: normalizePath(relative(vopts.root, path)), versions, names: [...names].sort() };
+  };
+  const namesChanged = (path) => {
+    const plan = dispatchPlan(path);
+    return !plan || plan.names.join(",") !== dispatched.get(path);
+  };
+  let reloadPage = () => {
+  };
+  const swapWaiters = /* @__PURE__ */ new Set();
+  const hotModules = (changed, modulesOf, env) => {
+    if (!variantsOptions) return void 0;
+    const client = env === null || env === "client";
+    if (isInside(vDir, changed)) {
+      overrides.clear();
+      const hit = overrideSourcePath(vopts, changed);
+      if (!hit || hit.file === MANIFEST) return [];
+      const source = normalizePath(join(vopts.root, hit.file));
+      if (live && client && dispatched.has(source)) {
+        if (namesChanged(source)) {
+          reloadPage();
+          return [];
+        }
+        return [...modulesOf(source) ?? []].filter((m) => versionOfId(m.id) === hit.id);
+      }
+      if (!currentActive().includes(hit.id)) return [];
+      return [...modulesOf(source) ?? []];
+    }
+    const seen = swapping.get(changed);
+    let swap = false;
+    if (seen) {
+      if (env === null) {
+        swapping.delete(changed);
+        swap = true;
+      } else if (!seen.has(env)) {
+        seen.add(env);
+        swap = true;
+        for (const check of [...swapWaiters]) check();
+      }
+    }
+    const path = normalizePath(changed);
+    if (live && client && dispatched.has(path)) {
+      if (swap) return [];
+      if (namesChanged(path)) {
+        reloadPage();
+        return [];
+      }
+      return [...modulesOf(path) ?? []].filter((m) => versionOfId(m.id) === BASE_VERSION);
+    }
+    if (swap) return void 0;
+    if (overridable(changed) && overrideFor(currentActive(), changed)) return [];
+    return void 0;
+  };
   const currentActive = () => {
     if (isBuild) return parseVariantList(process.env.ISOTONE_VARIANT);
     if (activeIds === void 0) activeIds = readActive(vopts);
@@ -96,29 +658,67 @@ function iteration(options = {}) {
       };
       vDir = variantsDir(vopts);
       activeFile = join(vopts.root, ACTIVE_FILE);
+      hasReact = (config.plugins ?? []).some((p) => /react/i.test(p.name));
+      ssrHost = config.appType !== "spa" && config.appType !== "mpa";
+      forgetManifests();
+    },
+    async resolveId(source, importer, opts = {}) {
+      if (!variantsOptions) return null;
+      if (source === LIVE_MODULE) return RESOLVED_LIVE_MODULE;
+      if (!importer) return null;
+      const marker = source.indexOf(`?${VERSION_QUERY}=`);
+      if (live && marker > 0 && source.startsWith("./")) {
+        const dir = dirname(importer.replace(/[?#].*$/, ""));
+        return normalizePath(resolve(dir, source.slice(0, marker))) + source.slice(marker);
+      }
+      const added = filesOnlyInVariants();
+      if (added.size === 0 || source.startsWith("\0")) return null;
+      const bare = source.replace(/[?#].*$/, "");
+      const leaf = bare.slice(bare.lastIndexOf("/") + 1).replace(/\.[cm]?[jt]sx?$/, "");
+      const candidates = [...added.entries()].filter(([stem]) => stem.endsWith(`/${leaf}`) || stem.endsWith(`/${leaf}/index`));
+      if (candidates.length === 0) return null;
+      const resolved = await this.resolve(source, importer, { ...opts, skipSelf: true });
+      if (resolved) return resolved;
+      const importerPath = importer.replace(/[?#].*$/, "");
+      const target = bare.startsWith(".") ? normalizePath(resolve(dirname(importerPath), bare)).replace(/\.[cm]?[jt]sx?$/, "") : null;
+      const tail = bare.split("/").slice(1).join("/").replace(/\.[cm]?[jt]sx?$/, "");
+      const hits = candidates.filter(([stem]) => target ? stem === target || stem === `${target}/index` : tail !== "" && (stem.endsWith(`/${tail}`) || stem.endsWith(`/${tail}/index`)));
+      if (hits.length !== 1) return null;
+      const paths = hits[0]?.[1] ?? [];
+      return paths.length === 1 ? paths[0] : null;
     },
-    load(id) {
+    load(id, opts) {
       if (!variantsOptions || SPECIAL_QUERY.test(id)) return null;
+      if (id === RESOLVED_LIVE_MODULE) return { code: liveRuntimeModule(liveConfig()), map: null };
       const path = id.replace(/[?#].*$/, "");
       if (!overridable(path)) return null;
+      const query = id.slice(path.length).replace(/^\?/, "").replace(/#.*$/, "");
+      const version = live ? new URLSearchParams(query).get(VERSION_QUERY) : null;
+      if (version !== null) {
+        const from = version === BASE_VERSION ? existsSync(path) ? path : null : overrideOf(version, path);
+        return { code: from ? readFileSync(from, "utf8") : "export {};\n", map: null };
+      }
+      if (live && !opts?.ssr && query === "") {
+        const plan = dispatchPlan(path);
+        if (plan) {
+          dispatched.set(path, plan.names.join(","));
+          const name = path.slice(path.lastIndexOf("/") + 1);
+          return { code: dispatcherModule(plan.key, name, plan.versions, plan.names), map: null };
+        }
+      }
       const override = overrideFor(currentActive(), path);
       if (!override) return null;
       return { code: readFileSync(override, "utf8"), map: null };
     },
+    // Vite 6 and later call this once per environment and skip
+    // handleHotUpdate; Vite 5 only knows handleHotUpdate.
+    hotUpdate(ctx) {
+      const env = this.environment;
+      return hotModules(ctx.file, (f) => env.moduleGraph.getModulesByFile(f), env.name);
+    },
     handleHotUpdate(ctx) {
-      if (!variantsOptions) return;
-      const { file: changed, server } = ctx;
-      if (isInside(vDir, changed)) {
-        overrides.clear();
-        const hit = overrideSourcePath(vopts, changed);
-        if (!hit || hit.file === MANIFEST) return [];
-        if (!currentActive().includes(hit.id)) return [];
-        const source = normalizePath(join(vopts.root, hit.file));
-        return [...server.moduleGraph.getModulesByFile(source) ?? []];
-      }
-      if (swapping.delete(changed)) return;
-      if (overridable(changed) && overrideFor(currentActive(), changed)) return [];
-      return;
+      const { server } = ctx;
+      return hotModules(ctx.file, (f) => server.moduleGraph.getModulesByFile(f), null);
     },
     configureServer(server) {
       if (!isDev) return;
@@ -167,13 +767,32 @@ function iteration(options = {}) {
       });
       if (variantsOptions) {
         activeIds = readActive(vopts);
+        live = (variantsOptions.live ?? hasReact) && server.environments !== void 0;
+        const clientGraph = () => server.environments?.client?.moduleGraph ?? server.moduleGraph;
+        const signature = () => JSON.stringify(readManifests().map((v) => [v.id, v.group ?? "", Object.keys(v.files).sort()]));
+        let listed = live ? signature() : "";
+        reloadPage = () => {
+          if (reloadTimer) clearTimeout(reloadTimer);
+          reloadTimer = setTimeout(() => {
+            reloadTimer = null;
+            const graph = clientGraph();
+            const paths = /* @__PURE__ */ new Set([...dispatched.keys(), ...versionsByFile().keys()]);
+            for (const path of paths) {
+              for (const mod of graph.getModulesByFile(path) ?? []) graph.invalidateModule(mod);
+            }
+            const runtime = graph.getModuleById(RESOLVED_LIVE_MODULE);
+            if (runtime) graph.invalidateModule(runtime);
+            dispatched.clear();
+            server.ws.send({ type: "full-reload", path: "*" });
+          }, 50);
+        };
         const activate = (next, removedFiles = []) => {
           const prev = currentActive();
           const changed = [
             ...prev.filter((id) => !next.includes(id)),
             ...next.filter((id) => !prev.includes(id))
           ];
-          if (changed.length === 0 && removedFiles.length === 0) return;
+          if (changed.length === 0 && removedFiles.length === 0) return Promise.resolve();
           activeIds = next;
           overrides.clear();
           const sources = new Set(removedFiles.map((file2) => join(vopts.root, file2)));
@@ -183,12 +802,39 @@ function iteration(options = {}) {
               sources.add(join(vopts.root, key));
             }
           }
+          const emitted = [];
           for (const source of sources) {
             const loaded = server.moduleGraph.getModulesByFile(normalizePath(source));
             if (!loaded || loaded.size === 0) continue;
-            swapping.add(source);
+            swapping.set(source, /* @__PURE__ */ new Set());
+            emitted.push(source);
             server.watcher.emit("change", source);
           }
+          const settled = serverSawSwap(emitted);
+          if (live) void settled.then(() => server.ws.send({ type: "custom", event: ACTIVE_EVENT, data: { active: next } }));
+          return settled;
+        };
+        const serverSawSwap = (files) => {
+          const envs = Object.keys(server.environments ?? {}).filter((name) => name !== "client");
+          if (!live || files.length === 0 || envs.length === 0) return Promise.resolve();
+          return new Promise((done) => {
+            const check = () => {
+              const seen = files.every((file2) => {
+                const by = swapping.get(file2);
+                return !by || envs.every((env) => by.has(env));
+              });
+              if (!seen) return;
+              finish();
+            };
+            const timer = setTimeout(() => finish(), 1e3);
+            const finish = () => {
+              clearTimeout(timer);
+              swapWaiters.delete(check);
+              setTimeout(done, 30);
+            };
+            swapWaiters.add(check);
+            check();
+          });
         };
         mkdirSync(dirname(activeFile), { recursive: true });
         ensureFileIgnored(activeFile);
@@ -210,13 +856,21 @@ function iteration(options = {}) {
             return;
           }
           (method === "POST" ? readNodeJson(req) : Promise.resolve(void 0)).then((body) => {
-            const result = answer(
-              res,
-              () => variantsResponse(vopts, { method, url: req.url, body })
-            );
-            if (result?.status === 200 && method === "POST") {
+            let result;
+            try {
+              result = variantsResponse(vopts, { method, url: req.url, body });
+            } catch (error) {
+              sendFailure(res, error);
+              return;
+            }
+            const send = () => {
+              answer(res, () => result);
+            };
+            if (result.status === 200 && method === "POST") {
               const updated = result.body;
-              activate(updated.active, updated.changedFiles);
+              activate(updated.active, updated.changedFiles).then(send, send);
+            } else {
+              send();
             }
           }).catch((error) => sendFailure(res, error));
         });
@@ -225,13 +879,34 @@ function iteration(options = {}) {
         server.watcher.on("all", (_event, changed) => {
           const path = resolve(changed);
           if (path === activeFile) {
-            activate(readActive(vopts));
+            void activate(readActive(vopts));
           } else if (isInside(vDir, path)) {
-            overrides.clear();
+            forgetManifests();
+            if (live) {
+              const now = signature();
+              if (now !== listed) {
+                listed = now;
+                reloadPage();
+              }
+            }
           }
         });
       }
-      if (options.panel === false) return;
+      const liveScript = () => live ? liveStoreScript(liveConfig()) : null;
+      if (options.panel === false) {
+        if (!live) return;
+        server.middlewares.use((req, res, next) => {
+          if (!(req.headers.accept ?? "").includes("text/html")) {
+            next();
+            return;
+          }
+          delete req.headers["if-none-match"];
+          delete req.headers["if-modified-since"];
+          injectHtmlResponse(res, null, liveScript);
+          next();
+        });
+        return;
+      }
       server.middlewares.use(BUNDLE_PATH, (_req, res) => {
         res.setHeader("content-type", "text/javascript; charset=utf-8");
         res.setHeader("cache-control", "no-store");
@@ -245,7 +920,7 @@ function iteration(options = {}) {
         }
         delete req.headers["if-none-match"];
         delete req.headers["if-modified-since"];
-        injectHtmlResponse(res, mountCode);
+        injectHtmlResponse(res, mountCode, liveScript);
         next();
       });
     }
@@ -286,7 +961,7 @@ function mountModuleSource(rule, key, variants, shortcut, theme) {
     else window.addEventListener('load', start, { once: true });
   `;
 }
-function injectHtmlResponse(res, code) {
+function injectHtmlResponse(res, code, head = () => null) {
   if (INJECTED.has(res)) return;
   INJECTED.add(res);
   const originalWrite = res.write.bind(res);
@@ -336,9 +1011,11 @@ function injectHtmlResponse(res, code) {
     buffering = false;
     const body = Buffer.concat(chunks).toString("utf8");
     if (body.includes("<html") && (body.includes("<head") || body.includes("</body>"))) {
-      const script = `<script type="module" data-isotone-inject>${code}</script>`;
+      const script = code === null ? "" : `<script type="module" data-isotone-inject>${code}</script>`;
+      const store = head();
+      const early = store ? `<script data-isotone-live>${store.replace(/<\/script/gi, "<\\/script")}</script>` : "";
       if (!res.headersSent) originalSetHeader("Cache-Control", "no-store");
-      return originalEnd(withNativeFetch(injectIntoHead(body, script)), cb);
+      return originalEnd(withNativeFetch(injectIntoHead(body, `${early}${script}`)), cb);
     }
     return originalEnd(Buffer.concat(chunks), cb);
   });