@bastani/atomic 0.9.13 → 0.9.14-alpha.2

package/dist/builtin/workflows/skills/impeccable/scripts/live/svelte-component.mjs

@@ -10,9 +10,38 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { createHash } from 'node:crypto';
-
+import {
+  analyzeSvelteMarkup,
+  buildPropsScriptV2,
+  loadSvelteCompiler,
+  restoreSvelteMarkup,
+} from './svelte-ast.mjs';
+import {
+  bakeParamValues,
+  collectAllSelectors,
+  collectUnusedSelectors,
+  normalizeSelector,
+  parseStylesheet,
+  pruneUnusedSelectors,
+  reconcileCss,
+  serializeNodes,
+  splitSelectorList,
+} from './accept-css.mjs';
+import { verifyAcceptedSource } from './accept-verify.mjs';
+
+// Preview modules stay under node_modules on purpose: SvelteKit restricts
+// vite's server.fs.allow to src/lib, src/routes, .svelte-kit, and
+// node_modules, so an .impeccable/ tree under the app root 403s (verified
+// against a real SvelteKit dev server). Staleness from node_modules being
+// unwatched is solved by REVISIONED module paths instead: every publish
+// snapshots the variant files into a fresh r<N>/ directory and the browser
+// imports from there, so a republished fix can never be pinned by a
+// transform cache keyed on the old path.
 export const SVELTE_COMPONENT_ROOT = 'node_modules/.impeccable-live';
+// A short-lived interim location; swept so no project keeps a stray tree.
+export const LEGACY_SVELTE_COMPONENT_ROOT = '.impeccable/live/previews';
 export const SVELTE_RUNTIME_FILE = `${SVELTE_COMPONENT_ROOT}/__runtime.js`;
+export const SVELTE_PROBE_FILE = `${SVELTE_COMPONENT_ROOT}/__probe.js`;
 export const DEFERRED_ACCEPTS_FILE = '.impeccable/live/deferred-svelte-component-accepts.json';
 
 const MUSTACHE_RE = /\{([^{}]+)\}/g;
@@ -32,9 +61,18 @@ export function manifestPathForSession(id, cwd = process.cwd()) {
 
 export function ensureRuntimeHelper(cwd = process.cwd()) {
   const file = path.join(cwd, SVELTE_RUNTIME_FILE);
-  if (fs.existsSync(file)) return file;
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `export { mount, unmount } from 'svelte';\n`, 'utf-8');
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, `export { mount, unmount } from 'svelte';\n`, 'utf-8');
+  }
+  // Attach-time probe: the browser imports this through the dev server before
+  // the first mount. A 404 here means the resolved app root and the dev
+  // server's root disagree, and the session fails with a named error instead
+  // of a silent fall-back to the picker at first variant.
+  const probe = path.join(cwd, SVELTE_PROBE_FILE);
+  if (!fs.existsSync(probe)) {
+    fs.writeFileSync(probe, `export const impeccableLivePreviewProbe = true;\n`, 'utf-8');
+  }
   return file;
 }
 
@@ -147,13 +185,19 @@ export function parseSvelteComponentFile(content) {
   return { markup, cssLines, styleBlock };
 }
 
+// A JSDoc `@type` directly before a destructuring declaration is JSDoc cast
+// syntax, and Svelte 5.50+ re-emits it onto the template's own declaration as
+// `var /** @type {...} */ (h1) = root()`, which does not parse. The browser's
+// import of the variant then fails with "Unexpected token '('" and the session
+// shows nothing. `@typedef` documents the same shape without being a cast.
+// tests/live-svelte-props-script.test.mjs compiles and parses what this emits.
 function buildPropsScript(contract) {
   if (contract.length === 0) {
-    return '<script>\n  /** @type {Record<string, never>} */\n  let {} = $props();\n</script>\n';
+    return '<script>\n  /** @typedef {Record<string, never>} Props */\n  let {} = $props();\n</script>\n';
   }
   const names = contract.map((c) => c.prop).join(', ');
   const typeFields = contract.map((c) => `    ${c.prop}: string;`).join('\n');
-  return `<script>\n  /** @type {{\n${typeFields}\n  }} */\n  let { ${names} } = $props();\n</script>\n`;
+  return `<script>\n  /** @typedef {{\n${typeFields}\n  }} Props */\n  let { ${names} } = $props();\n</script>\n`;
 }
 
 function buildVariantStub(variantNum, originalWithProps, contract) {
@@ -167,6 +211,14 @@ function buildInsertVariantStub(variantNum) {
   return `${buildPropsScript([])}<div class="impeccable-insert-preview">Insert variant ${variantNum}</div>\n\n<style>\n  .impeccable-insert-preview { display: block; }\n</style>\n`;
 }
 
+/**
+ * Scaffold a component-preview session. The scaffold is AST-based: the app's
+ * own svelte compiler parses the selected markup, control-flow blocks are
+ * preserved (an each collection crosses the prop contract as ONE structured
+ * prop, its loop body verbatim), and constructs a detached preview cannot
+ * support return `{ fallback: 'source-preview', reason }` so the caller keeps
+ * the markup inside the route file instead of shipping a wrong preview.
+ */
 export function scaffoldSvelteComponentSession({
   id,
   count,
@@ -176,25 +228,55 @@ export function scaffoldSvelteComponentSession({
   originalLines,
   cwd = process.cwd(),
 }) {
+  const originalMarkup = originalLines.join('\n');
+
+  const compiler = loadSvelteCompiler(cwd);
+  if (!compiler) {
+    return { fallback: 'source-preview', reason: 'svelte 5 compiler not resolvable from the app root' };
+  }
+  const analysis = analyzeSvelteMarkup(originalMarkup, compiler.parse);
+  if (!analysis.ok) {
+    return { fallback: 'source-preview', reason: analysis.reason };
+  }
+
   ensureRuntimeHelper(cwd);
   const dir = componentSessionDir(id, cwd);
   fs.mkdirSync(dir, { recursive: true });
 
-  const originalMarkup = originalLines.join('\n');
-  const contract = buildPropContract(extractMustacheExpressions(originalMarkup));
-  const originalWithProps = substituteExprsWithProps(originalMarkup, contract);
+  const contract = analysis.contract;
+  const seeded = extractMatchingSourceCss(
+    safeReadSource(path.resolve(cwd, sourceFile)),
+    originalMarkup,
+  );
+  const seededCss = seeded.css;
+  // The preview compiles in isolation, so NONE of these source rules applied
+  // to what the user approved. Accept enforces that preview truth: any of
+  // them the variant does not re-declare is superseded and removed, instead
+  // of re-attaching to the accepted markup through kept class names (the
+  // ".decisions grid grabs the new board" failure). Only the CLASS-matched
+  // selectors are candidates; tag rules style shared route elements.
+  const seededSelectors = [...seeded.supersedable];
 
   const manifest = {
     id,
     previewMode: 'svelte-component',
+    contractVersion: 2,
     sourceFile: sourceFile.split(path.sep).join('/'),
     sourceStartLine,
     sourceEndLine,
     count,
     propContract: contract,
     originalMarkup,
+    seededSelectors,
     componentDir: path.relative(cwd, dir).split(path.sep).join('/'),
+    // Absolute paths let the browser fall back to /@fs/ imports when the dev
+    // server's base or root makes root-relative URLs miss, and probe whether
+    // the preview tree is reachable at all before blaming a variant.
+    componentDirAbs: dir.split(path.sep).join('/'),
     runtimeModule: `/${SVELTE_RUNTIME_FILE}`,
+    runtimeModuleAbs: path.join(cwd, SVELTE_RUNTIME_FILE).split(path.sep).join('/'),
+    probeModule: `/${SVELTE_PROBE_FILE}`,
+    probeModuleAbs: path.join(cwd, SVELTE_PROBE_FILE).split(path.sep).join('/'),
   };
 
   fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
@@ -202,7 +284,7 @@ export function scaffoldSvelteComponentSession({
   for (let n = 1; n <= count; n++) {
     const variantFile = path.join(dir, `v${n}.svelte`);
     if (!fs.existsSync(variantFile)) {
-      fs.writeFileSync(variantFile, buildVariantStub(n, originalWithProps, contract), 'utf-8');
+      fs.writeFileSync(variantFile, buildVariantStubV2(n, analysis.markupWithProps, contract, seededCss), 'utf-8');
     }
   }
 
@@ -211,7 +293,98 @@ export function scaffoldSvelteComponentSession({
     manifestFile: path.relative(cwd, path.join(dir, 'manifest.json')).split(path.sep).join('/'),
     componentDir: manifest.componentDir,
     propContract: contract,
+    // Inlined so the generate event's scaffold payload carries the stub
+    // shape; the agent edits vN.svelte in place instead of spending reads on
+    // the manifest and stub files (or deleting and recreating them).
+    stubMarkup: analysis.markupWithProps,
+    seededCss,
+  };
+}
+
+function safeReadSource(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return ''; }
+}
+
+function escapeSelectorToken(token) {
+  return String(token).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Seed variant stubs with the source component's rules that already style the
+ * selected markup, so variants start from the real cascade (a detached
+ * preview inherits none of the route's compile-scoped CSS) instead of
+ * reimplementing it blind.
+ *
+ * Returns { css, supersedable }. `css` is every matching rule (class OR tag
+ * matched). `supersedable` holds only the CLASS-matched selectors: those are
+ * the accept-time removal candidates. Tag selectors (h1, a, p) style shared
+ * elements across the whole route, so they seed the preview but are never
+ * candidates for removal.
+ */
+export function extractMatchingSourceCss(routeSource, originalMarkup) {
+  const empty = { css: '', supersedable: new Set() };
+  const styleMatch = String(routeSource || '').match(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/i);
+  if (!styleMatch) return empty;
+  const classNames = new Set();
+  const classRe = /class\s*=\s*(["'])(.*?)\1/g;
+  let m;
+  while ((m = classRe.exec(originalMarkup))) {
+    for (const cls of m[2].split(/\s+/)) if (cls && !cls.includes('{')) classNames.add(cls);
+  }
+  const tagRe = /<([a-z][a-z0-9-]*)/gi;
+  const tags = new Set();
+  while ((m = tagRe.exec(originalMarkup))) tags.add(m[1].toLowerCase());
+  if (classNames.size === 0 && tags.size === 0) return empty;
+
+  // Token-boundary matching, never substring: `.btn` must not match
+  // `.btn-primary`, and `.stage` must not match `.stages`. A substring hit
+  // seeds a rule that never styled the pick, and a falsely seeded selector
+  // becomes an accept-time DELETION of a hand-written rule.
+  const classRes = [...classNames].map((cls) => new RegExp('\\.' + escapeSelectorToken(cls) + '(?![A-Za-z0-9_-])'));
+  const tagRes = [...tags].map((tag) => new RegExp('(^|[\\s>+~,(])' + escapeSelectorToken(tag) + '(?![A-Za-z0-9_-])', 'i'));
+  const classMatches = (selector) => classRes.some((re) => re.test(selector));
+  const tagMatches = (selector) => tagRes.some((re) => re.test(selector));
+
+  const supersedable = new Set();
+  const ruleMatches = (prelude) => {
+    let matched = false;
+    for (const selector of splitSelectorList(prelude)) {
+      if (classMatches(selector)) {
+        matched = true;
+        supersedable.add(normalizeSelector(selector));
+      } else if (tagMatches(selector)) {
+        matched = true;
+      }
+    }
+    return matched;
+  };
+
+  const pick = (nodes) => {
+    const kept = [];
+    for (const node of nodes) {
+      if (node.type === 'rule' && ruleMatches(node.prelude)) kept.push(node);
+      else if (node.type === 'at' && node.children) {
+        const children = pick(node.children);
+        if (children.length) kept.push({ ...node, children });
+      }
+    }
+    return kept;
   };
+  return { css: serializeNodes(pick(parseStylesheet(styleMatch[1]))), supersedable };
+}
+
+function buildVariantStubV2(variantNum, markupWithProps, contract, seededCss) {
+  const propsComment = contract.length > 0
+    ? `\n<!-- Props: ${contract.map((c) => `${c.prop} (${c.kind}) <- {${c.expr}}`).join(', ')} -->\n`
+    : '';
+  // The guard comments must never contain the literal "<style" character
+  // sequence: agents (and the fake test agent) locate the style block with
+  // string searches, and a mention inside a comment truncates their surgery
+  // mid-comment.
+  const css = seededCss
+    ? `\n<style>\n  /* Variant ${variantNum}: seeded from the route's current rules; restyle or delete freely.\n     ALL rules go inside THIS block. Svelte allows exactly one top-level style\n     element per component; appending a second one is a compile error. */\n${seededCss.split('\n').map((l) => (l.trim() ? '  ' + l : '')).join('\n')}\n</style>\n`
+    : `\n<style>\n  /* Variant ${variantNum}: add all CSS inside THIS block. Svelte allows exactly\n     one top-level style element; a second one is a compile error. */\n</style>\n`;
+  return `${buildPropsScriptV2(contract)}${propsComment}${markupWithProps.trim()}\n${css}`;
 }
 
 export function scaffoldSvelteComponentInsertSession({
@@ -244,7 +417,11 @@ export function scaffoldSvelteComponentInsertSession({
     count,
     propContract: [],
     componentDir: path.relative(cwd, dir).split(path.sep).join('/'),
+    componentDirAbs: dir.split(path.sep).join('/'),
     runtimeModule: `/${SVELTE_RUNTIME_FILE}`,
+    runtimeModuleAbs: path.join(cwd, SVELTE_RUNTIME_FILE).split(path.sep).join('/'),
+    probeModule: `/${SVELTE_PROBE_FILE}`,
+    probeModuleAbs: path.join(cwd, SVELTE_PROBE_FILE).split(path.sep).join('/'),
   };
 
   fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
@@ -269,16 +446,24 @@ export function findSvelteComponentManifest(id, cwd = process.cwd()) {
   if (fs.existsSync(direct)) {
     return readManifest(direct);
   }
-  const root = path.join(cwd, SVELTE_COMPONENT_ROOT);
-  if (!fs.existsSync(root)) return null;
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const candidate = path.join(root, entry.name, 'manifest.json');
-    if (!fs.existsSync(candidate)) continue;
-    try {
-      const manifest = readManifest(candidate);
-      if (manifest?.id === id) return { ...manifest, manifestPath: candidate };
-    } catch { /* skip */ }
+  // Legacy location: a session scaffolded by an older version can still be
+  // accepted after an upgrade.
+  const legacyDirect = path.join(cwd, LEGACY_SVELTE_COMPONENT_ROOT, id, 'manifest.json');
+  if (fs.existsSync(legacyDirect)) {
+    return readManifest(legacyDirect);
+  }
+  for (const rootRel of [SVELTE_COMPONENT_ROOT, LEGACY_SVELTE_COMPONENT_ROOT]) {
+    const root = path.join(cwd, rootRel);
+    if (!fs.existsSync(root)) continue;
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const candidate = path.join(root, entry.name, 'manifest.json');
+      if (!fs.existsSync(candidate)) continue;
+      try {
+        const manifest = readManifest(candidate);
+        if (manifest?.id === id) return { ...manifest, manifestPath: candidate };
+      } catch { /* skip */ }
+    }
   }
   return null;
 }
@@ -482,35 +667,6 @@ function rewriteParamSelectors(selector, paramValues) {
   return { keep, selector: next };
 }
 
-function splitSelectorList(prelude) {
-  const selectors = [];
-  let start = 0;
-  let bracket = 0;
-  let paren = 0;
-  let quote = null;
-  for (let i = 0; i < prelude.length; i++) {
-    const ch = prelude[i];
-    if (quote) {
-      if (ch === '\\') i++;
-      else if (ch === quote) quote = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      continue;
-    }
-    if (ch === '[') bracket++;
-    else if (ch === ']') bracket = Math.max(0, bracket - 1);
-    else if (ch === '(') paren++;
-    else if (ch === ')') paren = Math.max(0, paren - 1);
-    else if (ch === ',' && bracket === 0 && paren === 0) {
-      selectors.push(prelude.slice(start, i));
-      start = i + 1;
-    }
-  }
-  selectors.push(prelude.slice(start));
-  return selectors;
-}
 
 function selectorHasVariant(selector, variantNum) {
   return variantSelectorRegex(variantNum).test(selector);
@@ -558,10 +714,24 @@ export function inlineSvelteComponentAccept(manifest, variantNum, paramValues =
 
   const rootTag = matchOpeningTag(markup)?.tag || 'div';
   const contract = manifest.propContract || [];
+  const compiler = loadSvelteCompiler(cwd);
   const mergedMarkup = mergeOriginalTopLevelAttrs(markup, manifest.originalMarkup || '');
-  const restoredMarkup = substitutePropsWithExprs(mergedMarkup, contract)
-    .split('\n')
-    .map((line) => line.trimEnd());
+
+  // Restore props back to route expressions. Contract v2 restores through the
+  // AST so a prop used without braces (each headers, attribute positions)
+  // still maps back to its original expression; v1 falls back to the textual
+  // placeholder swap.
+  let restoredText;
+  if (Number(manifest.contractVersion) === 2 && compiler) {
+    const restored = restoreSvelteMarkup(mergedMarkup, contract, compiler.parse);
+    if (!restored.ok) {
+      return { handled: false, error: 'Accepted variant does not parse: ' + restored.reason, ...resultBase };
+    }
+    restoredText = restored.markup;
+  } else {
+    restoredText = substitutePropsWithExprs(mergedMarkup, contract);
+  }
+  const restoredMarkup = restoredText.split('\n').map((line) => line.trimEnd());
 
   const sourceContent = fs.readFileSync(sourceFile, 'utf-8');
   const sourceLines = sourceContent.split('\n');
@@ -572,10 +742,7 @@ export function inlineSvelteComponentAccept(manifest, variantNum, paramValues =
   }
 
   const indent = sourceLines[start].match(/^(\s*)/)?.[1] || '';
-  const indentedMarkup = restoredMarkup.map((line) => {
-    if (line.trim() === '') return '';
-    return indent + line.trimStart();
-  });
+  const indentedMarkup = reindentPreservingStructure(restoredMarkup, indent);
 
   let newLines = [
     ...sourceLines.slice(0, start),
@@ -583,25 +750,242 @@ export function inlineSvelteComponentAccept(manifest, variantNum, paramValues =
     ...sourceLines.slice(end + 1),
   ];
 
-  const sanitizedCss = sanitizeAcceptedSvelteCss(cssLines, variantNum, paramValues, rootTag);
-  const bakedCss = bakeParamValuesInCss(sanitizedCss, paramValues);
-  if (bakedCss.length > 0) {
-    newLines = appendCssToSvelteStyle(newLines, bakedCss);
+  // Selectors that were already unused before this accept are the user's
+  // pre-existing code; the pruning pass must not touch them.
+  const preUnused = compiler ? collectUnusedSelectors(sourceContent, compiler.compile) : new Set();
+
+  // Bake params (declared kinds from params.json drive branch pruning), then
+  // MERGE into the component's existing style block: matching selectors are
+  // replaced, new ones appended. Appending alone is how superseded rules used
+  // to survive their own replacement.
+  const declaredParams = readDeclaredParams(manifest, variantNum, cwd);
+  let variantCss = cssLines.join('\n');
+  if (/data-impeccable-variant|impeccable-variant-ready/.test(variantCss)) {
+    // Defensive: strip preview-wrapper selectors that authoring rules forbid
+    // on this path but an off-spec agent may still emit.
+    variantCss = sanitizeAcceptedSvelteCss(cssLines, variantNum, paramValues, rootTag).join('\n');
+  }
+  const bakedCss = bakeParamValues(variantCss, declaredParams, paramValues || {});
+  const cssStats = { replaced: 0, appended: 0, pruned: [], superseded: [] };
+  if (bakedCss.trim()) {
+    const merged = mergeCssIntoSvelteSource(newLines.join('\n'), bakedCss);
+    newLines = merged.text.split('\n');
+    cssStats.replaced = merged.replaced;
+    cssStats.appended = merged.appended;
+  }
+
+  let finalText = newLines.join('\n');
+
+  // Preview truth: the detached preview never applied the source rules that
+  // styled the replaced selection, so the user approved a design without
+  // them. Any seeded selector the variant did not re-declare is superseded;
+  // left in place it re-attaches through kept class names (the accepted root
+  // keeps its original classes) and re-layouts markup it no longer owns.
+  //
+  // Removal is bounded by ownership: a selector whose classes are still used
+  // by route markup OUTSIDE the replaced region does not belong to the pick
+  // alone, and removing it would strip styling from markup this accept never
+  // touched. Keeping it risks a visible re-attachment quirk on the accepted
+  // region; deleting it breaks the rest of the route. Keep it.
+  // Atomic hardening: a single-pass regex cannot strip `<style>` blocks safely.
+  // One replacement over nested or malformed openers leaves style text behind,
+  // and that text then feeds the class scan below as if it were live markup
+  // (CodeQL js/incomplete-multi-character-sanitization). Reuse the scanner that
+  // already backs parseSvelteComponentFile: it consumes each block to its real
+  // closer and repeats until none remain, so partial matches cannot survive.
+  const outsideMarkup = stripNamedBlocks(
+    [...sourceLines.slice(0, start), ...sourceLines.slice(end + 1)].join('\n'),
+    ['style'],
+  );
+  const outsideClasses = new Set();
+  {
+    const attrRe = /class\s*=\s*(["'])(.*?)\1/g;
+    let cm;
+    while ((cm = attrRe.exec(outsideMarkup))) {
+      for (const cls of cm[2].split(/\s+/)) if (cls && !cls.includes('{')) outsideClasses.add(cls);
+    }
+    const directiveRe = /class:([A-Za-z0-9_-]+)/g;
+    while ((cm = directiveRe.exec(outsideMarkup))) outsideClasses.add(cm[1]);
+  }
+  const usedOutsideReplacedRegion = (selector) => {
+    const classTokenRe = /\.([A-Za-z0-9_-]+)/g;
+    let tm;
+    while ((tm = classTokenRe.exec(selector))) {
+      if (outsideClasses.has(tm[1])) return true;
+    }
+    return false;
+  };
+  const incomingSelectors = collectAllSelectors(bakedCss);
+  const superseded = (manifest.seededSelectors || [])
+    .map((selector) => normalizeSelector(selector))
+    .filter((selector) => selector && !incomingSelectors.has(selector) && !usedOutsideReplacedRegion(selector));
+  if (superseded.length > 0) {
+    const scrubbed = removeSelectorsFromSvelteSource(finalText, new Set(superseded));
+    finalText = scrubbed.text;
+    cssStats.superseded = scrubbed.removed;
+  }
+
+  if (compiler) {
+    const pruned = pruneUnusedSelectors(finalText, compiler.compile, { skipSelectors: preUnused });
+    finalText = pruned.source;
+    cssStats.pruned = pruned.removed;
+  }
+
+  // Postcondition: no selector from the user's pre-accept CSS may vanish
+  // unless the compiler-driven prune or the preview-truth supersession
+  // deliberately removed it. This turns any parser or reconciler defect into
+  // a loud refusal instead of silent damage to a hand-written style block.
+  const lostSelectors = findLostSelectors(sourceContent, finalText, [
+    ...cssStats.pruned,
+    ...cssStats.superseded,
+  ]);
+  if (lostSelectors.length > 0) {
+    return {
+      handled: false,
+      error: 'CSS reconciliation would lose selectors from the existing style block: '
+        + lostSelectors.join(', ')
+        + '. Source not modified; accept the variant manually.',
+      mode: 'error',
+      ...resultBase,
+    };
   }
 
   try {
-    fs.writeFileSync(sourceFile, newLines.join('\n'), 'utf-8');
+    fs.writeFileSync(sourceFile, finalText, 'utf-8');
   } catch (err) {
     return { handled: false, error: 'Failed to write Svelte source: ' + err.message, ...resultBase };
   }
   removeSvelteComponentSession(manifest.id, cwd);
 
+  const verify = verifyAcceptedSource(finalText);
   return {
     handled: true,
+    css: cssStats,
+    verify,
     ...resultBase,
   };
 }
 
+/** Re-indent a block onto `indent` while preserving its internal structure. */
+export function reindentPreservingStructure(lines, indent) {
+  const nonEmpty = lines.filter((line) => line.trim() !== '');
+  if (nonEmpty.length === 0) return lines.map(() => '');
+  const minIndent = Math.min(...nonEmpty.map((line) => (line.match(/^\s*/) || [''])[0].length));
+  return lines.map((line) => {
+    if (line.trim() === '') return '';
+    const current = (line.match(/^\s*/) || [''])[0].length;
+    return indent + line.slice(Math.min(minIndent, current));
+  });
+}
+
+function styleBlockText(sourceText) {
+  const match = String(sourceText || '').match(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/i);
+  return match ? match[1] : '';
+}
+
+/**
+ * Remove every rule whose (normalized) selector list is fully contained in
+ * `selectors` from the component's style block, at any at-rule nesting depth.
+ * Rules that mix doomed and surviving selectors keep the survivors.
+ */
+export function removeSelectorsFromSvelteSource(sourceText, selectors) {
+  const text = String(sourceText || '');
+  const styleRe = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi;
+  let lastMatch = null;
+  let m;
+  while ((m = styleRe.exec(text))) lastMatch = m;
+  if (!lastMatch) return { text, removed: [] };
+
+  const removed = [];
+  const transform = (nodes) => {
+    const kept = [];
+    for (const node of nodes) {
+      if (node.type === 'rule') {
+        const survivors = [];
+        for (const selector of splitSelectorList(node.prelude)) {
+          if (selectors.has(normalizeSelector(selector))) removed.push(normalizeSelector(selector));
+          else survivors.push(selector);
+        }
+        if (survivors.length > 0) kept.push({ ...node, prelude: survivors.join(', ') });
+      } else if (node.type === 'at' && node.children) {
+        const children = transform(node.children);
+        if (children.length > 0) kept.push({ ...node, children });
+      } else {
+        kept.push(node);
+      }
+    }
+    return kept;
+  };
+
+  const nodes = transform(parseStylesheet(lastMatch[1]));
+  if (removed.length === 0) return { text, removed };
+  const openTag = lastMatch[0].slice(0, lastMatch[0].indexOf('>') + 1);
+  const rebuilt = `${openTag}\n${serializeNodes(nodes).split('\n').map((l) => (l.trim() ? '  ' + l : '')).join('\n')}\n</style>`;
+  return {
+    text: text.slice(0, lastMatch.index) + rebuilt + text.slice(lastMatch.index + lastMatch[0].length),
+    removed,
+  };
+}
+
+export function findLostSelectors(beforeSource, afterSource, prunedSelectors = []) {
+  const before = collectAllSelectors(styleBlockText(beforeSource));
+  const after = collectAllSelectors(styleBlockText(afterSource));
+  const pruned = new Set((prunedSelectors || []).map((s) => normalizeSelector(s)));
+  const lost = [];
+  for (const selector of before) {
+    if (!after.has(selector) && !pruned.has(selector)) lost.push(selector);
+  }
+  return lost;
+}
+
+function readDeclaredParams(manifest, variantNum, cwd) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(cwd, manifest.componentDir, 'params.json'), 'utf-8'));
+    const list = raw?.[String(variantNum)];
+    return Array.isArray(list) ? list : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Merge CSS into a svelte component's top-level style block (created when
+ * absent), replacing rules whose selectors match and appending the rest.
+ */
+export function mergeCssIntoSvelteSource(sourceText, incomingCss) {
+  const text = String(sourceText || '');
+  const styleRe = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi;
+  let lastMatch = null;
+  let m;
+  while ((m = styleRe.exec(text))) lastMatch = m;
+
+  if (!lastMatch) {
+    const { css, replaced, appended } = reconcileCss('', incomingCss);
+    return {
+      text: `${text.replace(/\s*$/, '')}\n\n<style>\n${indentCssBlock(css)}\n</style>\n`,
+      replaced,
+      appended,
+    };
+  }
+
+  const inner = lastMatch[1];
+  const { css, replaced, appended } = reconcileCss(inner, incomingCss);
+  const openTag = lastMatch[0].slice(0, lastMatch[0].indexOf('>') + 1);
+  const replacedBlock = `${openTag}\n${indentCssBlock(css)}\n</style>`;
+  return {
+    text: text.slice(0, lastMatch.index) + replacedBlock + text.slice(lastMatch.index + lastMatch[0].length),
+    replaced,
+    appended,
+  };
+}
+
+function indentCssBlock(css) {
+  return String(css || '')
+    .split('\n')
+    .map((line) => (line.trim() === '' ? '' : '  ' + line))
+    .join('\n');
+}
+
 function inlineSvelteComponentInsertAccept({
   manifest,
   markup,
@@ -632,10 +1016,7 @@ function inlineSvelteComponentInsertAccept({
 
   const nearbyLine = sourceLines[insertIndex] ?? sourceLines[insertIndex - 1] ?? '';
   const indent = nearbyLine.match(/^(\s*)/)?.[1] || '';
-  const indentedMarkup = restoredMarkup.map((line) => {
-    if (line.trim() === '') return '';
-    return indent + line.trimStart();
-  });
+  const indentedMarkup = reindentPreservingStructure(restoredMarkup, indent);
 
   let newLines = [
     ...sourceLines.slice(0, insertIndex),
@@ -643,10 +1024,15 @@ function inlineSvelteComponentInsertAccept({
     ...sourceLines.slice(insertIndex),
   ];
 
-  const sanitizedCss = sanitizeAcceptedSvelteCss(cssLines, variantNum, paramValues, rootTag);
-  const bakedCss = bakeParamValuesInCss(sanitizedCss, paramValues);
-  if (bakedCss.length > 0) {
-    newLines = appendCssToSvelteStyle(newLines, bakedCss);
+  let variantCss = cssLines.join('\n');
+  if (/data-impeccable-variant|impeccable-variant-ready/.test(variantCss)) {
+    variantCss = sanitizeAcceptedSvelteCss(cssLines, variantNum, paramValues, rootTag).join('\n');
+  }
+  const declaredParams = readDeclaredParams(manifest, variantNum, cwd);
+  const bakedCss = bakeParamValues(variantCss, declaredParams, paramValues || {});
+  if (bakedCss.trim()) {
+    const merged = mergeCssIntoSvelteSource(newLines.join('\n'), bakedCss);
+    newLines = merged.text.split('\n');
   }
 
   try {
@@ -656,8 +1042,10 @@ function inlineSvelteComponentInsertAccept({
   }
   removeSvelteComponentSession(manifest.id, cwd);
 
+  const verify = verifyAcceptedSource(newLines.join('\n'));
   return {
     handled: true,
+    verify,
     ...resultBase,
   };
 }
@@ -757,18 +1145,177 @@ export function removeSvelteComponentSession(id, cwd = process.cwd()) {
   } catch { /* non-fatal */ }
 }
 
+/**
+ * Compile-check every variant component of a session with the app's own
+ * compiler, BEFORE the browser ever imports them. A variant that does not
+ * compile (the classic: a second top-level <style> appended next to the
+ * seeded one) used to surface as a red Vite overlay in the user's page plus
+ * a mount-failure round trip; bounced at publish time it is a private
+ * agent-side fix with the exact file and line.
+ *
+ * What this deliberately does NOT prove is that the emitted module is valid
+ * JavaScript, and issue #580 was exactly that gap: valid .svelte source whose
+ * generated JS did not parse, so this check passed and the browser's import
+ * failed with "Unexpected token '('". Two reasons it cannot close the gap, both
+ * structural rather than oversights:
+ *
+ *   - `generate: false` produces no JS to inspect, and generating it here would
+ *     spend a full codegen per variant on the publish path.
+ *   - `loadSvelteCompiler` reaches the compiler through createRequire, which
+ *     Svelte's export map routes to a prebuilt CJS build. The dev server
+ *     imports `src/compiler` instead, and only that path uses the app's
+ *     installed printer (esrap). The two can disagree, so even a generated
+ *     check here would be checking a different compiler than the one whose
+ *     output the browser runs.
+ *
+ * tests/live-svelte-props-script.test.mjs covers the emitted JS, importing the
+ * compiler as ESM so it sees what the dev server sees.
+ */
+export function compileCheckVariants(id, cwd = process.cwd()) {
+  const manifest = findSvelteComponentManifest(id, cwd);
+  if (!manifest || !manifest.manifestPath) return { ok: true, failures: [], checked: 0 };
+  const compiler = loadSvelteCompiler(cwd);
+  if (!compiler || typeof compiler.compile !== 'function') return { ok: true, failures: [], checked: 0 };
+  const sessionDir = path.dirname(manifest.manifestPath);
+  const failures = [];
+  let checked = 0;
+  let entries = [];
+  try { entries = fs.readdirSync(sessionDir); } catch { return { ok: true, failures: [], checked: 0 }; }
+  for (const name of entries) {
+    if (!/^v\d+\.svelte$/.test(name)) continue;
+    checked++;
+    try {
+      compiler.compile(fs.readFileSync(path.join(sessionDir, name), 'utf-8'), { generate: false });
+    } catch (err) {
+      failures.push({
+        file: `${manifest.componentDir}/${name}`,
+        line: err?.start?.line ?? null,
+        column: err?.start?.column ?? null,
+        message: String(err?.message || err).split('\n')[0].slice(0, 300),
+      });
+    }
+  }
+  return { ok: failures.length === 0, failures, checked };
+}
+
+/**
+ * Snapshot the agent-authored variant files into a fresh revision directory
+ * and stamp the manifest. Called by the server on every publish (`done`
+ * reply) for a component session; the browser imports from the revision dir,
+ * so the dev server can never serve a stale compile of a republished file.
+ */
+export function bumpSvelteComponentPreviewRevision(id, cwd = process.cwd()) {
+  const manifest = findSvelteComponentManifest(id, cwd);
+  if (!manifest || !manifest.manifestPath) return null;
+  const sessionDir = path.dirname(manifest.manifestPath);
+  const revision = Number(manifest.revision || 0) + 1;
+  const revDirName = `r${revision}`;
+  const revDir = path.join(sessionDir, revDirName);
+  try {
+    fs.mkdirSync(revDir, { recursive: true });
+    let entries = [];
+    try { entries = fs.readdirSync(sessionDir, { withFileTypes: true }); } catch { /* empty */ }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (entry.name === 'manifest.json') continue;
+      fs.copyFileSync(path.join(sessionDir, entry.name), path.join(revDir, entry.name));
+    }
+    // Previous revision dirs are dead the moment a new one exists.
+    for (const entry of entries) {
+      if (entry.isDirectory() && /^r\d+$/.test(entry.name) && entry.name !== revDirName) {
+        try { fs.rmSync(path.join(sessionDir, entry.name), { recursive: true, force: true }); } catch { /* non-fatal */ }
+      }
+    }
+    const relSessionDir = path.relative(cwd, sessionDir).split(path.sep).join('/');
+    const updated = {
+      ...manifest,
+      revision,
+      revisionDir: `${relSessionDir}/${revDirName}`,
+      revisionDirAbs: revDir.split(path.sep).join('/'),
+    };
+    delete updated.manifestPath;
+    fs.writeFileSync(manifest.manifestPath, JSON.stringify(updated, null, 2) + '\n', 'utf-8');
+    return { revision, revisionDir: updated.revisionDir };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Stop-path sweep. The whole `node_modules/.impeccable-live` tree is
+ * impeccable-owned and gitignored, so once no session should survive there is
+ * nothing left worth keeping: the per-session dirs, the generated
+ * `__runtime.js`, and the parent directory all go. The old per-entry loop
+ * skipped `__*` entries and the parent, which left the runtime shim and an
+ * empty directory in every project that ever ran live mode once.
+ */
 export function removeAllSvelteComponentSessions(cwd = process.cwd()) {
-  const root = path.join(cwd, SVELTE_COMPONENT_ROOT);
-  if (!fs.existsSync(root)) return;
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    if (entry.name.startsWith('__')) continue;
+  for (const rootRel of [SVELTE_COMPONENT_ROOT, LEGACY_SVELTE_COMPONENT_ROOT]) {
+    const root = path.join(cwd, rootRel);
+    if (!fs.existsSync(root)) continue;
     try {
-      fs.rmSync(path.join(root, entry.name), { recursive: true, force: true });
+      fs.rmSync(root, { recursive: true, force: true });
     } catch { /* non-fatal */ }
   }
 }
 
+/**
+ * Boot-path sweep. A restart must not delete the tree wholesale: sessions
+ * recorded in the session store may still be mid-generation. Remove only the
+ * session dirs whose id has no active snapshot, then drop `__runtime.js` and
+ * the parent directory when nothing is left to serve.
+ *
+ * @param {Iterable<string>} activeIds session ids that must be preserved
+ * @returns {{ removed: string[], removedRoot: boolean, kept: string[] }}
+ */
+export function sweepInactiveSvelteComponentSessions(activeIds = [], cwd = process.cwd()) {
+  const result = { removed: [], removedRoot: false, kept: [] };
+  const active = new Set();
+  for (const id of activeIds || []) {
+    if (typeof id === 'string' && id) active.add(id);
+  }
+
+  for (const rootRel of [SVELTE_COMPONENT_ROOT, LEGACY_SVELTE_COMPONENT_ROOT]) {
+    const root = path.join(cwd, rootRel);
+    if (!fs.existsSync(root)) continue;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    let keptHere = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('__')) continue;
+      if (active.has(entry.name)) {
+        result.kept.push(entry.name);
+        keptHere++;
+        continue;
+      }
+      try {
+        fs.rmSync(path.join(root, entry.name), { recursive: true, force: true });
+        result.removed.push(entry.name);
+      } catch {
+        // Could not remove it, so it still occupies the tree; treat it as kept
+        // so the parent directory is not torn out from under it.
+        result.kept.push(entry.name);
+        keptHere++;
+      }
+    }
+
+    if (keptHere === 0) {
+      try {
+        fs.rmSync(root, { recursive: true, force: true });
+        result.removedRoot = true;
+      } catch { /* non-fatal */ }
+    }
+  }
+  return result;
+}
+
 export function deferredAcceptsPath(cwd = process.cwd()) {
   const key = createHash('sha1').update(path.resolve(cwd)).digest('hex').slice(0, 16);
   return path.join(os.tmpdir(), 'impeccable-live', key, 'deferred-svelte-component-accepts.json');