elcrm 1.0.0 → 1.1.2

package/dist/index.js

@@ -1,5 +1,742 @@
 #!/usr/bin/env bun
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/latest.ts
+async function fetchLatestVersion(name) {
+  if (CACHE.has(name))
+    return CACHE.get(name);
+  const url = `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    if (!data.version)
+      return null;
+    CACHE.set(name, data.version);
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+async function fetchLatestMap(names) {
+  const map = new Map;
+  const results = await Promise.all(names.map(async (name) => {
+    const v = await fetchLatestVersion(name);
+    return [name, v];
+  }));
+  for (const [name, v] of results) {
+    if (v)
+      map.set(name, v);
+  }
+  return map;
+}
+async function fetchCorePinnedVersions() {
+  const url = "https://registry.npmjs.org/@elcrm%2Fcore/latest";
+  const map = new Map;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok)
+      return map;
+    const data = await res.json();
+    if (data.version)
+      map.set("@elcrm/core", data.version);
+    for (const [name, ver] of Object.entries(data.dependencies ?? {})) {
+      if (name.startsWith("@elcrm/")) {
+        map.set(name, ver.replace(/^[\^~]/, ""));
+      }
+    }
+  } catch {}
+  return map;
+}
+var CACHE;
+var init_latest = __esm(() => {
+  CACHE = new Map;
+});
+
+// src/lib/pkg.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function packageJsonPath(cwd = process.cwd()) {
+  return join2(cwd, "package.json");
+}
+function readPackageJson(cwd = process.cwd()) {
+  const path = packageJsonPath(cwd);
+  if (!existsSync2(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writePackageJson(pkg, cwd = process.cwd()) {
+  writeFileSync(packageJsonPath(cwd), JSON.stringify(pkg, null, 2) + `
+`, "utf8");
+}
+var init_pkg = () => {};
+
+// src/lib/migrate/socket-server.ts
+import {
+  existsSync as existsSync3,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join3 } from "path";
+function walkFiles(dir, out = []) {
+  if (!existsSync3(dir))
+    return out;
+  for (const name of readdirSync(dir)) {
+    if (SKIP_DIRS.has(name))
+      continue;
+    const full = join3(dir, name);
+    const st = statSync(full);
+    if (st.isDirectory())
+      walkFiles(full, out);
+    else {
+      const ext = name.includes(".") ? `.${name.split(".").pop()}` : "";
+      if (TEXT_EXT.has(ext))
+        out.push(full);
+    }
+  }
+  return out;
+}
+function rewriteImports(source) {
+  let hits = 0;
+  let next = source;
+  const patterns = [
+    [
+      /from\s+["']@elcrm\/socket\/server["']/g,
+      'from "@elcrm/server"'
+    ],
+    [
+      /from\s+["']@elcrm\/socket-server["']/g,
+      'from "@elcrm/server"'
+    ],
+    [
+      /require\s*\(\s*["']@elcrm\/socket\/server["']\s*\)/g,
+      'require("@elcrm/server")'
+    ],
+    [
+      /require\s*\(\s*["']@elcrm\/socket-server["']\s*\)/g,
+      'require("@elcrm/server")'
+    ]
+  ];
+  for (const [re, repl] of patterns) {
+    const before = next;
+    next = next.replace(re, () => {
+      hits++;
+      return repl;
+    });
+  }
+  return { next, hits };
+}
+async function migrateSocketServer(cwd, dry) {
+  const changes = [];
+  const pkg = readPackageJson(cwd);
+  let removedSocketServer = false;
+  if (pkg) {
+    for (const section of [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies"
+    ]) {
+      const map = pkg[section];
+      if (!map)
+        continue;
+      if (map["@elcrm/socket-server"]) {
+        removedSocketServer = true;
+        changes.push({
+          file: "package.json",
+          detail: `\u0443\u0434\u0430\u043B\u0438\u0442\u044C ${section}["@elcrm/socket-server"]`
+        });
+        if (!dry)
+          delete map["@elcrm/socket-server"];
+      }
+    }
+    const hasServer = Boolean(pkg.dependencies?.["@elcrm/server"]) || Boolean(pkg.devDependencies?.["@elcrm/server"]);
+    if (removedSocketServer && !hasServer) {
+      const latest = dry ? null : await fetchLatestVersion("@elcrm/server");
+      const ver = latest ? `^${latest}` : "^0.5.3";
+      changes.push({
+        file: "package.json",
+        detail: `\u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C dependencies["@elcrm/server"] = ${ver}`
+      });
+      if (!dry) {
+        if (!pkg.dependencies)
+          pkg.dependencies = {};
+        pkg.dependencies["@elcrm/server"] = ver;
+      }
+    }
+    if (!dry && changes.some((c2) => c2.file === "package.json")) {
+      writePackageJson(pkg, cwd);
+    }
+  }
+  const roots = ["src", "app", "server", "lib"].map((d) => join3(cwd, d));
+  const files = roots.flatMap((r) => walkFiles(r));
+  for (const file of files) {
+    const raw = readFileSync2(file, "utf8");
+    const { next, hits } = rewriteImports(raw);
+    if (hits > 0) {
+      changes.push({
+        file: file.replace(cwd + "/", ""),
+        detail: `${hits} \u0437\u0430\u043C\u0435\u043D(\u044B) \u0438\u043C\u043F\u043E\u0440\u0442\u043E\u0432 \u2192 @elcrm/server`
+      });
+      if (!dry)
+        writeFileSync2(file, next, "utf8");
+    }
+  }
+  return changes;
+}
+var SKIP_DIRS, TEXT_EXT;
+var init_socket_server = __esm(() => {
+  init_latest();
+  init_pkg();
+  SKIP_DIRS = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    "coverage",
+    ".turbo"
+  ]);
+  TEXT_EXT = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts"
+  ]);
+});
+
+// src/lib/migrate/walk.ts
+import {
+  existsSync as existsSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join4, relative } from "path";
+function walkCodeFiles(dir, out = []) {
+  if (!existsSync4(dir))
+    return out;
+  for (const name of readdirSync2(dir)) {
+    if (SKIP_DIRS2.has(name))
+      continue;
+    const full = join4(dir, name);
+    let st;
+    try {
+      st = statSync2(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory())
+      walkCodeFiles(full, out);
+    else if (/\.(tsx?|jsx?|mjs|cjs|css)$/.test(name))
+      out.push(full);
+  }
+  return out;
+}
+function projectCodeRoots(cwd) {
+  return ["src", "app", "web/src", "lib", "modules"].map((d) => join4(cwd, d)).filter((p) => existsSync4(p));
+}
+function rel(cwd, file) {
+  return relative(cwd, file) || file;
+}
+function writeIfChanged(file, next, dry) {
+  const prev = readFileSync3(file, "utf8");
+  if (prev === next)
+    return false;
+  if (!dry)
+    writeFileSync3(file, next, "utf8");
+  return true;
+}
+var SKIP_DIRS2;
+var init_walk = __esm(() => {
+  SKIP_DIRS2 = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    "coverage",
+    ".turbo",
+    ".next",
+    "build"
+  ]);
+});
+
+// src/lib/migrate/size-sml.ts
+import { readFileSync as readFileSync4 } from "fs";
+function rewrite(source) {
+  let next = source;
+  let hits = 0;
+  for (const [re, repl] of PATTERNS) {
+    next = next.replace(re, () => {
+      hits++;
+      return repl;
+    });
+  }
+  return { next, hits };
+}
+async function migrateSizeSml(cwd, dry) {
+  const changes = [];
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r));
+  for (const file of files) {
+    if (file.endsWith(".css"))
+      continue;
+    const raw = readFileSync4(file, "utf8");
+    const { next, hits } = rewrite(raw);
+    if (hits === 0)
+      continue;
+    if (writeIfChanged(file, next, dry) || dry) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: `${hits}\xD7 size sm/md \u2192 s/m`
+      });
+    }
+  }
+  return changes;
+}
+var PATTERNS;
+var init_size_sml = __esm(() => {
+  init_walk();
+  PATTERNS = [
+    [/size\s*=\s*"sm"/g, 'size="s"'],
+    [/size\s*=\s*'sm'/g, "size='s'"],
+    [/size\s*=\s*\{\s*"sm"\s*\}/g, 'size={"s"}'],
+    [/size\s*=\s*\{\s*'sm'\s*\}/g, "size={'s'}"],
+    [/size\s*=\s*"md"/g, 'size="m"'],
+    [/size\s*=\s*'md'/g, "size='m'"],
+    [/size\s*=\s*\{\s*"md"\s*\}/g, 'size={"m"}'],
+    [/size\s*=\s*\{\s*'md'\s*\}/g, "size={'m'}"]
+  ];
+});
+
+// src/lib/migrate/field-border.ts
+import { readFileSync as readFileSync5 } from "fs";
+function extractColor(value) {
+  const v = value.trim().replace(/;$/, "");
+  const m = v.match(/^(?:\d+(?:\.\d+)?(?:px|em|rem)?\s+)?(?:solid|dashed|dotted|double)\s+(.+)$/i);
+  if (m)
+    return m[1].trim();
+  if (/^(#|rgb|hsl|var\(|color-mix|transparent|currentColor)/i.test(v)) {
+    return null;
+  }
+  return null;
+}
+function rewriteCss(source) {
+  let hits = 0;
+  let next = source;
+  for (const name of VARS) {
+    const re = new RegExp(`(${name.replace(/-/g, "\\-")}\\s*:\\s*)([^;\\n}]+)`, "g");
+    next = next.replace(re, (full, prefix, rawVal) => {
+      const color = extractColor(rawVal);
+      if (!color)
+        return full;
+      hits++;
+      return `${prefix}${color}`;
+    });
+  }
+  return { next, hits };
+}
+async function migrateFieldBorder(cwd, dry) {
+  const changes = [];
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r)).filter((f) => f.endsWith(".css"));
+  for (const file of files) {
+    const raw = readFileSync5(file, "utf8");
+    const { next, hits } = rewriteCss(raw);
+    if (hits === 0)
+      continue;
+    if (writeIfChanged(file, next, dry) || dry) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: `${hits}\xD7 border hover/focus \u2192 \u0442\u043E\u043B\u044C\u043A\u043E \u0446\u0432\u0435\u0442`
+      });
+    }
+  }
+  return changes;
+}
+var VARS;
+var init_field_border = __esm(() => {
+  init_walk();
+  VARS = [
+    "--field-border-focus",
+    "--field-border-hover",
+    "--field-border-error",
+    "--field-border-disabled"
+  ];
+});
+
+// src/lib/migrate/modal-create.ts
+import { readFileSync as readFileSync6 } from "fs";
+async function migrateModalCreate(cwd, dry) {
+  const changes = [];
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r)).filter((f) => /\.(tsx|jsx)$/.test(f));
+  const addRe = /Modal\.Add\s*\(\s*<([A-Za-z_][\w.]*)\s+key=\{Date\.now\(\)\}/;
+  for (const file of files) {
+    const raw = readFileSync6(file, "utf8");
+    if (!addRe.test(raw) && !/Modal\.Add\s*\(/.test(raw))
+      continue;
+    if (/export\s+default\s+Modal\.Create\s*\(/.test(raw)) {
+      if (/Modal\.Add\s*\(/.test(raw)) {
+        changes.push({
+          file: rel(cwd, file),
+          detail: "\u043E\u0441\u0442\u0430\u043B\u0441\u044F Modal.Add \u0440\u044F\u0434\u043E\u043C \u0441 Create \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 Add \u0432\u0440\u0443\u0447\u043D\u0443\u044E"
+        });
+      }
+      continue;
+    }
+    const simple = /function\s+Screen\b/.test(raw) || /const\s+Screen\s*=/.test(raw) || /function\s+\w+\s*\([^)]*\)\s*\{[\s\S]*Modal\.Main/.test(raw);
+    const openWrapper = /(?:const|function)\s+Open\s*=\s*(?:\([^)]*\)|[A-Za-z_]\w*)\s*=>\s*\{?\s*Modal\.Add/;
+    if (simple && openWrapper.test(raw) && /export\s+default/.test(raw)) {
+      let next = raw;
+      next = next.replace(/\n(?:const|function)\s+Open\s*=\s*[\s\S]*?(?=\n(?:const|function|export)\s)/, `
+`);
+      next = next.replace(/\n(?:const|function)\s+Icon\s*=\s*[\s\S]*?(?=\n(?:const|function|export)\s)/, `
+`);
+      next = next.replace(/\nconst\s+Add\s*=\s*\{[\s\S]*?\};\s*\nexport\s+default\s+Add\s*;?/, `
+export default Modal.Create(Screen);
+`);
+      next = next.replace(/export\s+default\s+\{\s*Open\s*,?\s*Icon?\s*,?\s*\}\s*;?/, "export default Modal.Create(Screen);");
+      next = next.replace(/export\s+function\s+open\w+\s*\([^)]*\)\s*\{[\s\S]*?Modal\.Add\([\s\S]*?\);\s*\}/, (block) => {
+        return `/* TODO: \u0437\u0430\u043C\u0435\u043D\u0438\u0442\u0435 \u0432\u044B\u0437\u043E\u0432\u044B \u043D\u0430 Modal.Open("Module","Name", props) \u0438\u043B\u0438 Create.Open */
+${block}`;
+      });
+      if (next !== raw && !/Modal\.Add/.test(next)) {
+        if (writeIfChanged(file, next, dry) || dry) {
+          changes.push({
+            file: rel(cwd, file),
+            detail: "Modal.Add \u2192 Modal.Create(Screen)"
+          });
+        }
+        continue;
+      }
+    }
+    const count = (raw.match(/Modal\.Add\s*\(/g) || []).length;
+    changes.push({
+      file: rel(cwd, file),
+      detail: `${count}\xD7 Modal.Add \u2014 \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0438\u0442\u0435 \u043D\u0430 Modal.Create + Open (\u0441\u043C. Projects/modal/Create)`
+    });
+  }
+  return changes;
+}
+var init_modal_create = __esm(() => {
+  init_walk();
+});
+
+// src/lib/migrate/legacy-hacks.ts
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join5 } from "path";
+async function migrateLegacyReactHack(cwd, dry) {
+  const changes = [];
+  const files = new Set(projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r)).filter((f) => /(^|\/)(main|bootstrap)\.(tsx?|jsx?)$/.test(f)));
+  for (const name of ["main.tsx", "main.ts", "src/main.tsx", "src/main.ts"]) {
+    const full = join5(cwd, name);
+    if (existsSync5(full))
+      files.add(full);
+  }
+  for (const file of files) {
+    const raw = readFileSync7(file, "utf8");
+    if (!HACK_RE.test(raw))
+      continue;
+    const next = raw.replace(/\/\*\s*@elcrm\/modal[\s\S]*?\*\/\s*/m, "").replace(/\(globalThis\s+as\s+typeof\s+globalThis\s+&\s+\{\s*React:\s*typeof\s+React\s*\}\)\.React\s*=\s*React\s*;\s*/g, "").replace(/globalThis\.React\s*=\s*React\s*;\s*/g, "");
+    if (next === raw) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: "globalThis.React \u2014 \u0443\u0434\u0430\u043B\u0438\u0442\u0435 \u0432\u0440\u0443\u0447\u043D\u0443\u044E \u043F\u043E\u0441\u043B\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F @elcrm/modal"
+      });
+      continue;
+    }
+    if (writeIfChanged(file, next, dry) || dry) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: "\u0443\u0434\u0430\u043B\u0451\u043D globalThis.React \u0445\u0430\u043A"
+      });
+    }
+  }
+  return changes;
+}
+var HACK_RE;
+var init_legacy_hacks = __esm(() => {
+  init_walk();
+  HACK_RE = /\(globalThis\s+as\s+[^)]+\)\.React\s*=\s*React\s*;?|globalThis\.React\s*=\s*React\s*;?/;
+});
+
+// src/lib/migrate/form-aliases.ts
+import { readFileSync as readFileSync8 } from "fs";
+function rewrite2(source) {
+  let next = source;
+  const labels = [];
+  for (const [re, repl, label] of REPLACEMENTS) {
+    let n = 0;
+    next = next.replace(re, () => {
+      n++;
+      return repl;
+    });
+    if (n > 0)
+      labels.push(`${n}\xD7 ${label}`);
+  }
+  return { next, labels };
+}
+async function migrateFormAliases(cwd, dry) {
+  const changes = [];
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r));
+  for (const file of files) {
+    if (file.endsWith(".css"))
+      continue;
+    const raw = readFileSync8(file, "utf8");
+    const { next, labels } = rewrite2(raw);
+    if (labels.length === 0)
+      continue;
+    if (writeIfChanged(file, next, dry) || dry) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: labels.join(", ")
+      });
+    }
+  }
+  return changes;
+}
+var REPLACEMENTS;
+var init_form_aliases = __esm(() => {
+  init_walk();
+  REPLACEMENTS = [
+    [/\bProgressField\b/g, "RangeField", "ProgressField\u2192RangeField"],
+    [/\bReadonlyField\b/g, "DisplayField", "ReadonlyField\u2192DisplayField"],
+    [/\bOtpField\b/g, "CodeField", "OtpField\u2192CodeField"],
+    [/\bSegmentField\b/g, "TabsField", "SegmentField\u2192TabsField"],
+    [/\bDragonDropField\b/g, "DragDropField", "DragonDropField\u2192DragDropField"],
+    [/\bTProgress\b/g, "TRange", "TProgress\u2192TRange"]
+  ];
+});
+
+// src/lib/migrate/form-tokens.ts
+import { readFileSync as readFileSync9 } from "fs";
+function removeDecl(css, name) {
+  const re = new RegExp(`\\n?[ \\t]*${name.replace(/-/g, "\\-")}\\s*:[^;\\n}]+;?[ \\t]*`, "g");
+  let n = 0;
+  const next = css.replace(re, () => {
+    n++;
+    return "";
+  });
+  return { next: next.replace(/\n{3,}/g, `
+
+`), n };
+}
+function migrateDatePopupShadowDecl(css) {
+  let n = 0;
+  let next = css;
+  const hasPopup = /--popup-shadow\s*:/.test(next);
+  const re = /(--date-popup-shadow\s*:\s*)(?!var\(\s*--popup-shadow)([^;\n}]+)/gi;
+  next = next.replace(re, (full, prefix, value) => {
+    n++;
+    const v = value.trim();
+    if (hasPopup) {
+      return `${prefix}var(--popup-shadow)`;
+    }
+    return `/*__POPUP_SHADOW__*/${v}/*__END__*/${prefix}var(--popup-shadow)`;
+  });
+  if (next.includes("/*__POPUP_SHADOW__*/")) {
+    next = next.replace(/\/\*__POPUP_SHADOW__\*\/([\s\S]*?)\/\*__END__\*\//, (_m, v) => `--popup-shadow: ${v.trim()};
+  `);
+  }
+  return { next, n };
+}
+function expandFieldPaddingShorthand(css) {
+  let n = 0;
+  if (/--field-padding-block\s*:/.test(css)) {
+    return { next: css, n: 0 };
+  }
+  const re = /(--field-padding\s*:\s*)(?!var\(\s*--field-padding-block)(\S+)\s+(\S+)\s*;/g;
+  const next = css.replace(re, (full, prefix, block, inline) => {
+    if (block.includes("(") || inline.includes("("))
+      return full;
+    n++;
+    return `--field-padding-block: ${block};
+` + `  --field-padding-inline: ${inline};
+` + `  ${prefix}var(--field-padding-block) var(--field-padding-inline);`;
+  });
+  return { next, n };
+}
+function rewriteFormTokens(source) {
+  let next = source;
+  let hits = 0;
+  for (const [re, to] of VAR_REPLACEMENTS) {
+    next = next.replace(re, () => {
+      hits++;
+      return to;
+    });
+  }
+  const shadow = migrateDatePopupShadowDecl(next);
+  next = shadow.next;
+  hits += shadow.n;
+  const pad = expandFieldPaddingShorthand(next);
+  next = pad.next;
+  hits += pad.n;
+  for (const name of DECL_REMOVE) {
+    const stillUsed = new RegExp(`var\\(\\s*${name.replace(/-/g, "\\-")}\\s*`, "i").test(next);
+    if (stillUsed)
+      continue;
+    const rem = removeDecl(next, name);
+    next = rem.next;
+    hits += rem.n;
+  }
+  return { next, hits };
+}
+async function migrateFormTokens(cwd, dry) {
+  const pkg = readPackageJson(cwd);
+  if (pkg?.name === "@elcrm/form")
+    return [];
+  const changes = [];
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r)).filter((f) => f.endsWith(".css"));
+  for (const file of files) {
+    const raw = readFileSync9(file, "utf8");
+    const { next, hits } = rewriteFormTokens(raw);
+    if (hits === 0 || next === raw)
+      continue;
+    if (writeIfChanged(file, next, dry) || dry) {
+      changes.push({
+        file: rel(cwd, file),
+        detail: `${hits}\xD7 form-tokens (padding / popup-shadow / cleanup)`
+      });
+    }
+  }
+  return changes;
+}
+function lineHasDeprecatedFormToken(line) {
+  const t = line.trim();
+  if (!t || t.startsWith("/*") || t.startsWith("*"))
+    return false;
+  if (DEPRECATED_VAR_RE.test(t))
+    return true;
+  if (!DEPRECATED_DECL_RE.test(t))
+    return false;
+  if (/:\s*var\(\s*--(?:field-padding|popup-shadow)/.test(t))
+    return false;
+  return true;
+}
+var VAR_REPLACEMENTS, DECL_REMOVE, FORM_TOKEN_DEPRECATED, DEPRECATED_VAR_RE, DEPRECATED_DECL_RE;
+var init_form_tokens = __esm(() => {
+  init_pkg();
+  init_walk();
+  VAR_REPLACEMENTS = [
+    [
+      /var\(\s*--field-note-padding-top\s*(?:,[^)]+)?\)/gi,
+      "var(--field-padding-block)"
+    ],
+    [
+      /var\(\s*--field-note-padding\s*(?:,[^)]+)?\)/gi,
+      "var(--field-padding-block)"
+    ],
+    [
+      /var\(\s*--field-side-padding\s*(?:,[^)]+)?\)/gi,
+      "var(--field-padding-inline)"
+    ],
+    [
+      /var\(\s*--control-side-padding\s*(?:,[^)]+)?\)/gi,
+      "var(--field-padding-inline)"
+    ],
+    [
+      /var\(\s*--control-inner-padding\s*(?:,[^)]+)?\)/gi,
+      "var(--field-padding)"
+    ],
+    [
+      /var\(\s*--date-popup-shadow\s*(?:,[^)]+)?\)/gi,
+      "var(--popup-shadow)"
+    ]
+  ];
+  DECL_REMOVE = [
+    "--field-note-padding-top",
+    "--field-note-padding",
+    "--control-inner-padding",
+    "--control-side-padding",
+    "--field-side-padding",
+    "--date-popup-shadow"
+  ];
+  FORM_TOKEN_DEPRECATED = [
+    "--field-note-padding",
+    "--field-note-padding-top",
+    "--control-inner-padding",
+    "--control-side-padding",
+    "--field-side-padding",
+    "--date-popup-shadow"
+  ];
+  DEPRECATED_VAR_RE = new RegExp(`var\\(\\s*(?:${FORM_TOKEN_DEPRECATED.map((n) => n.replace(/-/g, "\\-")).join("|")})\\s*`, "i");
+  DEPRECATED_DECL_RE = new RegExp(`(?:${FORM_TOKEN_DEPRECATED.map((n) => n.replace(/-/g, "\\-")).join("|")})\\s*:`);
+});
+
+// src/lib/migrate/front.ts
+var exports_front = {};
+__export(exports_front, {
+  migrateFrontAll: () => migrateFrontAll,
+  FRONT_MIGRATIONS: () => FRONT_MIGRATIONS,
+  FRONT_MIGRATE_ORDER: () => FRONT_MIGRATE_ORDER
+});
+async function migrateFrontAll(cwd, dry) {
+  const all = [];
+  for (const name of FRONT_MIGRATE_ORDER) {
+    const part = await FRONT_MIGRATIONS[name](cwd, dry);
+    for (const c2 of part) {
+      all.push({ file: c2.file, detail: `[${name}] ${c2.detail}` });
+    }
+  }
+  return all;
+}
+var FRONT_MIGRATIONS, FRONT_MIGRATE_ORDER;
+var init_front = __esm(() => {
+  init_socket_server();
+  init_size_sml();
+  init_field_border();
+  init_modal_create();
+  init_legacy_hacks();
+  init_form_aliases();
+  init_form_tokens();
+  FRONT_MIGRATIONS = {
+    "size-sml": migrateSizeSml,
+    "field-border": migrateFieldBorder,
+    "modal-create": migrateModalCreate,
+    "form-aliases": migrateFormAliases,
+    "form-tokens": migrateFormTokens,
+    "legacy-hacks": migrateLegacyReactHack,
+    "socket-server": migrateSocketServer
+  };
+  FRONT_MIGRATE_ORDER = [
+    "form-aliases",
+    "form-tokens",
+    "size-sml",
+    "field-border",
+    "modal-create",
+    "socket-server"
+  ];
+});
+
+// src/index.ts
+import { readFileSync as readFileSync19 } from "fs";
+import { dirname as dirname4, join as join18 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/parseArgs.ts
 function parseArgs(argv = process.argv.slice(2)) {
@@ -38,156 +775,1362 @@ function parseArgs(argv = process.argv.slice(2)) {
           continue;
         }
       }
-      if (body && !flags.includes(body))
-        flags.push(body);
+      if (body && !flags.includes(body))
+        flags.push(body);
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      const short = arg.slice(1);
+      if (short === "t" && argv[i + 1] && !argv[i + 1].startsWith("-")) {
+        options.template = argv[i + 1];
+        i++;
+        continue;
+      }
+      if (short && !flags.includes(short))
+        flags.push(short);
+      continue;
+    }
+    positionals.push(arg);
+  }
+  const [command = "", ...rest] = positionals;
+  return {
+    command,
+    positionals: rest,
+    options,
+    flags
+  };
+}
+function hasFlag(parsed, ...names) {
+  return names.some((n) => parsed.flags.includes(n));
+}
+
+// src/lib/elcrmDeps.ts
+var SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+function listElcrmDeps(pkg) {
+  const out = [];
+  for (const section of SECTIONS) {
+    const map = pkg[section];
+    if (!map || typeof map !== "object")
+      continue;
+    for (const [name, version] of Object.entries(map)) {
+      if (name.startsWith("@elcrm/") && typeof version === "string") {
+        out.push({ name, version, section });
+      }
+    }
+  }
+  return out;
+}
+function uniqueElcrmNames(deps) {
+  return [...new Set(deps.map((d) => d.name))].sort();
+}
+
+// src/commands/update.ts
+init_latest();
+
+// src/lib/install.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  const bun = spawnSync("bun", ["--version"], { encoding: "utf8" });
+  if (bun.status === 0)
+    return "bun";
+  return "npm";
+}
+function installDeps(cwd = process.cwd()) {
+  const pm = detectPackageManager(cwd);
+  console.log(`\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 (${pm} install)\u2026`);
+  const r = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit",
+    env: process.env
+  });
+  return r.status === 0;
+}
+
+// src/commands/update.ts
+init_pkg();
+
+// src/lib/ansi.ts
+var enabled = process.env.NO_COLOR == null && process.env.FORCE_COLOR !== "0" && Boolean(process.stdout.isTTY);
+function wrap(code, text) {
+  if (!enabled)
+    return text;
+  return `\x1B[${code}m${text}\x1B[0m`;
+}
+var c = {
+  gray: (t) => wrap("90", t),
+  green: (t) => wrap("32", t),
+  blue: (t) => wrap("34", t),
+  yellow: (t) => wrap("33", t),
+  red: (t) => wrap("31", t),
+  cyan: (t) => wrap("36", t),
+  dim: (t) => wrap("2", t)
+};
+
+// src/commands/update.ts
+init_front();
+
+// src/lib/cssSync.ts
+init_form_tokens();
+import {
+  existsSync as existsSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync10,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { createRequire } from "module";
+import { dirname, join as join6 } from "path";
+var COLOR_VALUE = /#|rgba?\(|hsla?\(|oklch|oklab|color-mix|lab\(|lch\(|hwb\(/i;
+var COLOR_NAME = /(?:^|-)(bg|fg|color|fill|track|thumb|overlay|shadow|border|ring|background|placeholder)(?:-|$)/i;
+var GEOM_VALUE = /(?:^|\s)(\d*\.?\d+)(px|em|rem|%|vh|vw|dvh|ch|ex|s|ms|deg|fr|pt)\b|^[0-9.]+$|ease|linear|none/i;
+function stripComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function parseCustomProps(body) {
+  const out = new Map;
+  const src = stripComments(body);
+  const re = /(--[a-zA-Z0-9-]+)\s*:/g;
+  let m;
+  while (m = re.exec(src)) {
+    let depth = 0;
+    let end = re.lastIndex;
+    while (end < src.length) {
+      const ch = src[end];
+      if (ch === "(")
+        depth++;
+      else if (ch === ")")
+        depth--;
+      else if ((ch === ";" || ch === "}") && depth <= 0)
+        break;
+      end++;
+    }
+    const value = src.slice(re.lastIndex, end).trim().replace(/\s+/g, " ");
+    if (value)
+      out.set(m[1], value);
+    re.lastIndex = end;
+  }
+  return out;
+}
+function walkRules(css, fn) {
+  const s = stripComments(css);
+  let i = 0;
+  while (i < s.length) {
+    const open = s.indexOf("{", i);
+    if (open < 0)
+      break;
+    const sel = s.slice(i, open).trim();
+    let depth = 1;
+    let j = open + 1;
+    while (j < s.length && depth > 0) {
+      if (s[j] === "{")
+        depth++;
+      else if (s[j] === "}")
+        depth--;
+      j++;
+    }
+    const body = s.slice(open + 1, j - 1);
+    if (sel.startsWith("@"))
+      walkRules(body, fn);
+    else
+      fn(sel, body);
+    i = j;
+  }
+}
+function fileKind(file) {
+  const base = file.replace(/\\/g, "/").toLowerCase();
+  if (base.endsWith("light.css") || /\/light\.css$/.test(base))
+    return "light";
+  if (base.endsWith("dark.css") || /\/dark\.css$/.test(base))
+    return "dark";
+  if (base.endsWith("tokens.css") || base.endsWith("theme.css") || /\/tokens\.css$/.test(base)) {
+    return "geometry";
+  }
+  return "mixed";
+}
+function selectorBucket(sel) {
+  const s = sel.toLowerCase();
+  if (/data-theme\s*=\s*["']?light/.test(s))
+    return "light";
+  if (/data-theme\s*=\s*["']?dark/.test(s))
+    return "dark";
+  if (/(^|,)\s*:root\b/.test(s) || /(^|,)\s*html\b/.test(s))
+    return "geometry";
+  return null;
+}
+function isColorToken(name, value) {
+  if (COLOR_VALUE.test(value))
+    return true;
+  if (COLOR_NAME.test(name) && /transparent|currentcolor|var\(|\bnone\b/i.test(value)) {
+    return true;
+  }
+  if (COLOR_NAME.test(name) && !GEOM_VALUE.test(value))
+    return true;
+  return false;
+}
+function listCssFiles(dir, acc = []) {
+  if (!existsSync6(dir))
+    return acc;
+  for (const name of readdirSync3(dir)) {
+    if (name === "node_modules")
+      continue;
+    const full = join6(dir, name);
+    let st;
+    try {
+      st = statSync3(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory())
+      listCssFiles(full, acc);
+    else if (name.endsWith(".css"))
+      acc.push(full);
+  }
+  return acc;
+}
+function resolvePkgRoot(pkgName, cwd) {
+  try {
+    const req = createRequire(join6(cwd, "package.json"));
+    const pkgJson = req.resolve(`${pkgName}/package.json`);
+    return dirname(pkgJson);
+  } catch {
+    const fallback = join6(cwd, "node_modules", ...pkgName.split("/"));
+    return existsSync6(join6(fallback, "package.json")) ? fallback : null;
+  }
+}
+function readPkgJson(dir) {
+  try {
+    return JSON.parse(readFileSync10(join6(dir, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function exportPath(exportsMap, key) {
+  if (!exportsMap || typeof exportsMap !== "object")
+    return;
+  const ent = exportsMap[key];
+  if (typeof ent === "string")
+    return ent;
+  if (ent && typeof ent === "object") {
+    const o = ent;
+    const v = o.import ?? o.default ?? o.require;
+    return typeof v === "string" ? v : undefined;
+  }
+  return;
+}
+function inspectPkgCss(pkgName, cwd) {
+  const root = resolvePkgRoot(pkgName, cwd);
+  if (!root)
+    return null;
+  const pkg = readPkgJson(root);
+  const exp = pkg?.exports;
+  const styleRel = exportPath(exp, "./style.css");
+  const lightRel = exportPath(exp, "./light.css");
+  const darkRel = exportPath(exp, "./dark.css");
+  const abs = (rel2) => rel2 ? join6(root, rel2.replace(/^\.\//, "")) : undefined;
+  return {
+    name: pkgName,
+    root,
+    style: abs(styleRel) && existsSync6(abs(styleRel)) ? abs(styleRel) : undefined,
+    light: abs(lightRel) && existsSync6(abs(lightRel)) ? abs(lightRel) : undefined,
+    dark: abs(darkRel) && existsSync6(abs(darkRel)) ? abs(darkRel) : undefined
+  };
+}
+function addDef(acc, seen, pkg, bucket, name, value) {
+  const key = `${bucket}:${name}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  acc.push({ name, value, bucket, pkg });
+}
+function collectPkgTokens(pkgName, cwd) {
+  const root = resolvePkgRoot(pkgName, cwd);
+  if (!root)
+    return [];
+  const files = [
+    ...listCssFiles(join6(root, "dist")),
+    ...listCssFiles(join6(root, "src/lib/styles")),
+    ...listCssFiles(join6(root, "src/style")),
+    join6(root, "test/main.css")
+  ].filter((f) => existsSync6(f));
+  const acc = [];
+  const seen = new Set;
+  for (const file of files) {
+    const css = readFileSync10(file, "utf8");
+    const kind = fileKind(file);
+    if (kind !== "mixed") {
+      for (const [name, value] of parseCustomProps(css)) {
+        const color = isColorToken(name, value);
+        if (kind === "geometry") {
+          if (color) {
+            addDef(acc, seen, pkgName, "light", name, value);
+            addDef(acc, seen, pkgName, "dark", name, value);
+          } else {
+            addDef(acc, seen, pkgName, "geometry", name, value);
+          }
+          continue;
+        }
+        addDef(acc, seen, pkgName, color ? kind : "geometry", name, value);
+      }
       continue;
     }
-    if (arg.startsWith("-") && arg.length > 1) {
-      const short = arg.slice(1);
-      if (short === "t" && argv[i + 1] && !argv[i + 1].startsWith("-")) {
-        options.template = argv[i + 1];
-        i++;
-        continue;
+    walkRules(css, (sel, body) => {
+      const bucket = selectorBucket(sel);
+      if (!bucket)
+        return;
+      for (const [name, value] of parseCustomProps(body)) {
+        const color = isColorToken(name, value);
+        if (bucket === "geometry") {
+          if (color) {
+            addDef(acc, seen, pkgName, "light", name, value);
+            addDef(acc, seen, pkgName, "dark", name, value);
+          } else {
+            addDef(acc, seen, pkgName, "geometry", name, value);
+          }
+          continue;
+        }
+        addDef(acc, seen, pkgName, color ? bucket : "geometry", name, value);
       }
-      if (short && !flags.includes(short))
-        flags.push(short);
-      continue;
+    });
+  }
+  return acc;
+}
+function existingTokenNames(css) {
+  return new Set(parseCustomProps(css).keys());
+}
+function detectIndent(css) {
+  const m = css.match(/\n([ \t]+)--[a-zA-Z]/);
+  return m?.[1] ?? "    ";
+}
+function prefixOf(name) {
+  const parts = name.slice(2).split("-");
+  return parts[0] || "misc";
+}
+function formatTokenBlock(defs, indent) {
+  const byPrefix = new Map;
+  for (const d of defs) {
+    const p = prefixOf(d.name);
+    const list = byPrefix.get(p) ?? [];
+    list.push(d);
+    byPrefix.set(p, list);
+  }
+  const prefixes = [...byPrefix.keys()].sort();
+  const lines = [];
+  for (const p of prefixes) {
+    const list = byPrefix.get(p);
+    const pkgs = [...new Set(list.map((x) => x.pkg))].sort();
+    const label = pkgs.map((n) => n.replace(/^@elcrm\//, "")).join(", ");
+    lines.push("");
+    lines.push(`${indent}/* \u2014\u2014 ${p} (${label}) \u2014\u2014 */`);
+    list.sort((a, b) => a.name.localeCompare(b.name));
+    for (const d of list) {
+      lines.push(`${indent}${d.name}: ${d.value};`);
     }
-    positionals.push(arg);
   }
-  const [command = "", ...rest] = positionals;
-  return {
-    command,
-    positionals: rest,
-    options,
-    flags
-  };
+  lines.push("");
+  return lines.join(`
+`);
 }
-function hasFlag(parsed, ...names) {
-  return names.some((n) => parsed.flags.includes(n));
+function insertIntoRule(css, selectorTest, snippet) {
+  const s = css;
+  let i = 0;
+  while (i < s.length) {
+    const open = s.indexOf("{", i);
+    if (open < 0)
+      break;
+    const sel = stripComments(s.slice(i, open)).trim();
+    let depth = 1;
+    let j = open + 1;
+    while (j < s.length && depth > 0) {
+      if (s[j] === "{")
+        depth++;
+      else if (s[j] === "}")
+        depth--;
+      j++;
+    }
+    if (selectorTest(sel)) {
+      const before = s.slice(0, j - 1).replace(/\s*$/, "");
+      const after = s.slice(j - 1);
+      return `${before}
+${snippet}${after}`;
+    }
+    i = j;
+  }
+  return null;
+}
+function findStyleDir(cwd) {
+  for (const d of [join6(cwd, "src/style"), join6(cwd, "web/src/style")]) {
+    if (existsSync6(join6(d, "theme-light.css")) || existsSync6(join6(d, "elcrm.css")) || existsSync6(join6(d, "theme.css"))) {
+      return d;
+    }
+  }
+  return null;
+}
+function ensureImport(css, spec) {
+  const needle = `@import "${spec}"`;
+  const alt = `@import '${spec}'`;
+  if (css.includes(needle) || css.includes(alt)) {
+    return { css, added: false };
+  }
+  const line = `${needle};`;
+  const imports = [...css.matchAll(/@import[^;]+;/g)];
+  if (imports.length) {
+    const themeIdx = imports.findIndex((m) => /theme\.css/.test(m[0]));
+    const anchor = themeIdx >= 0 ? imports[themeIdx] : imports[imports.length - 1];
+    const idx = themeIdx >= 0 ? anchor.index : anchor.index + anchor[0].length;
+    const pad = themeIdx >= 0 ? line + `
+` : `
+` + line;
+    return {
+      css: css.slice(0, idx) + pad + css.slice(idx),
+      added: true
+    };
+  }
+  return { css: line + `
+` + css, added: true };
+}
+function syncElcrmCss(options) {
+  const styleDir = findStyleDir(options.cwd);
+  if (!styleDir) {
+    throw new Error("\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D src/style (theme.css / theme-light.css / elcrm.css).");
+  }
+  const paths = {
+    geometry: join6(styleDir, "theme.css"),
+    light: join6(styleDir, "theme-light.css"),
+    dark: join6(styleDir, "theme-dark.css"),
+    elcrm: join6(styleDir, "elcrm.css")
+  };
+  const allDefs = [];
+  const skippedPkgs = [];
+  const cssExports = [];
+  for (const name of options.pkgNames) {
+    const exp = inspectPkgCss(name, options.cwd);
+    if (exp)
+      cssExports.push(exp);
+    const defs = collectPkgTokens(name, options.cwd);
+    if (defs.length === 0)
+      skippedPkgs.push(name);
+    allDefs.push(...defs);
+  }
+  const added = {
+    "theme.css": [],
+    "theme-light.css": [],
+    "theme-dark.css": []
+  };
+  const imports = [];
+  const fileFor = (bucket) => bucket === "geometry" ? paths.geometry : bucket === "light" ? paths.light : paths.dark;
+  const labelFor = (bucket) => bucket === "geometry" ? "theme.css" : bucket === "light" ? "theme-light.css" : "theme-dark.css";
+  for (const bucket of ["geometry", "light", "dark"]) {
+    const file = fileFor(bucket);
+    if (!existsSync6(file))
+      continue;
+    let css = readFileSync10(file, "utf8");
+    const have = existingTokenNames(css);
+    const missing = allDefs.filter((d) => d.bucket === bucket && !have.has(d.name) && !FORM_TOKEN_DEPRECATED.includes(d.name));
+    const uniq = [];
+    const seen = new Set;
+    for (const d of missing) {
+      if (seen.has(d.name))
+        continue;
+      seen.add(d.name);
+      uniq.push(d);
+    }
+    if (!uniq.length)
+      continue;
+    const indent = detectIndent(css);
+    const snippet = formatTokenBlock(uniq, indent);
+    const test = bucket === "geometry" ? (sel) => /(^|,)\s*:root\b/.test(sel) : bucket === "light" ? (sel) => /data-theme\s*=\s*["']?light/.test(sel.toLowerCase()) : (sel) => /data-theme\s*=\s*["']?dark/.test(sel.toLowerCase());
+    const next = insertIntoRule(css, test, snippet);
+    if (!next) {
+      throw new Error(`\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0431\u043B\u043E\u043A \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440\u0430 \u0432 ${labelFor(bucket)}`);
+    }
+    added[labelFor(bucket)] = uniq.map((d) => d.name);
+    if (!options.dry)
+      writeFileSync4(file, next, "utf8");
+  }
+  if (existsSync6(paths.elcrm)) {
+    let css = readFileSync10(paths.elcrm, "utf8");
+    for (const exp of cssExports) {
+      const specs = [];
+      if (exp.light)
+        specs.push(`${exp.name}/light.css`);
+      if (exp.dark)
+        specs.push(`${exp.name}/dark.css`);
+      const tokens = join6(exp.root, "dist/tokens.css");
+      if (existsSync6(tokens))
+        specs.push(`${exp.name}/tokens.css`);
+      for (const spec of specs) {
+        const r = ensureImport(css, spec);
+        css = r.css;
+        if (r.added)
+          imports.push(spec);
+      }
+    }
+    if (imports.length && !options.dry)
+      writeFileSync4(paths.elcrm, css, "utf8");
+  }
+  return { styleDir, added, imports, skippedPkgs };
 }
 
-// src/lib/elcrmDeps.ts
-var SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies"
-];
-function listElcrmDeps(pkg) {
-  const out = [];
-  for (const section of SECTIONS) {
+// src/commands/test.ts
+import { resolve } from "path";
+
+// src/lib/test/detect.ts
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
+import { join as join7 } from "path";
+function hasElcrmServer(pkg) {
+  for (const section of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies"
+  ]) {
     const map = pkg[section];
-    if (!map || typeof map !== "object")
+    if (map && typeof map === "object" && "@elcrm/server" in map)
+      return true;
+  }
+  return false;
+}
+function detectTestMode(pkg, force) {
+  if (force === "server" || force === "front")
+    return force;
+  return hasElcrmServer(pkg) ? "server" : "front";
+}
+function listWorkspaceDirs(cwd, pkg) {
+  const raw = pkg.workspaces;
+  let patterns = [];
+  if (Array.isArray(raw)) {
+    patterns = raw.filter((p) => typeof p === "string");
+  } else if (raw && typeof raw === "object" && Array.isArray(raw.packages)) {
+    patterns = raw.packages.filter((p) => typeof p === "string");
+  }
+  if (!patterns.length)
+    return [];
+  const out = [];
+  for (const pat of patterns) {
+    if (!pat.includes("*")) {
+      const dir = join7(cwd, pat);
+      if (existsSync7(join7(dir, "package.json")))
+        out.push(dir);
       continue;
-    for (const [name, version] of Object.entries(map)) {
-      if (name.startsWith("@elcrm/") && typeof version === "string") {
-        out.push({ name, version, section });
+    }
+    const base = pat.replace(/\/\*$/, "").replace(/\*$/, "");
+    const parent = join7(cwd, base);
+    if (!existsSync7(parent) || !statSync4(parent).isDirectory())
+      continue;
+    for (const name of readdirSync4(parent)) {
+      const dir = join7(parent, name);
+      if (statSync4(dir).isDirectory() && existsSync7(join7(dir, "package.json"))) {
+        out.push(dir);
       }
     }
   }
   return out;
 }
-function uniqueElcrmNames(deps) {
-  return [...new Set(deps.map((d) => d.name))].sort();
-}
-
-// src/lib/latest.ts
-var CACHE = new Map;
-async function fetchLatestVersion(name) {
-  if (CACHE.has(name))
-    return CACHE.get(name);
-  const url = `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
+function readPkgAt(dir) {
+  const path = join7(dir, "package.json");
+  if (!existsSync7(path))
+    return null;
   try {
-    const res = await fetch(url, {
-      headers: { Accept: "application/json" }
-    });
-    if (!res.ok)
-      return null;
-    const data = await res.json();
-    if (!data.version)
-      return null;
-    CACHE.set(name, data.version);
-    return data.version;
+    return JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
 }
-async function fetchLatestMap(names) {
-  const map = new Map;
-  const results = await Promise.all(names.map(async (name) => {
-    const v = await fetchLatestVersion(name);
-    return [name, v];
-  }));
-  for (const [name, v] of results) {
-    if (v)
-      map.set(name, v);
+
+// src/lib/test/front.ts
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
+import { join as join8, relative as relative2 } from "path";
+init_form_tokens();
+var SKIP = new Set(["node_modules", "dist", ".git", "coverage", ".bun"]);
+var DEPRECATED_SOCKET_IMPORT_RE = /(?:from\s+|require\s*\(\s*)["']@elcrm\/(?:socket\/server|socket-server)["']/;
+var THEMES_CSS_IMPORT_RE = /(?:from\s+|import\s+)["']@elcrm\/[^"']+\/themes\.css["']|import\s+["']@elcrm\/[^"']+\/themes\.css["']/;
+var LEGACY_PASSKEY_IMPORT_RE = /(?:from\s+|require\s*\(\s*)["']@elcrm\/passkey["']/;
+var LEGACY_PASSKEY_SYMBOL_RE = /\b(?:createPasskey|authenticateWithPasskey)\b/;
+function walkCode(dir, out) {
+  if (!existsSync8(dir))
+    return;
+  for (const name of readdirSync5(dir)) {
+    if (SKIP.has(name))
+      continue;
+    const full = join8(dir, name);
+    let st;
+    try {
+      st = statSync5(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory())
+      walkCode(full, out);
+    else if (/\.(tsx?|jsx?|mjs|cjs|css)$/.test(name))
+      out.push(full);
+  }
+}
+function collectFrontIssues(cwd, pkg) {
+  const issues = [];
+  const isLib = Boolean(pkg.name?.startsWith("@elcrm/"));
+  const scripts = pkg.scripts ?? {};
+  if (pkg.type !== "module") {
+    issues.push({
+      level: "warn",
+      code: "type-module",
+      message: '\u041D\u0435\u0442 "type": "module"',
+      fixable: true
+    });
+  }
+  if (!pkg.engines?.node && !pkg.engines?.bun) {
+    issues.push({
+      level: "warn",
+      code: "engines",
+      message: "\u041D\u0435\u0442 engines.node (\u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F >=18) \u0438\u043B\u0438 engines.bun",
+      fixable: true
+    });
+  }
+  if (isLib) {
+    if (!scripts.build && !scripts["pack:check"]) {
+      issues.push({
+        level: "warn",
+        code: "scripts",
+        message: "\u0414\u043B\u044F \u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u0438 \u0436\u0435\u043B\u0430\u0442\u0435\u043B\u044C\u043D\u044B scripts.build \u0438/\u0438\u043B\u0438 pack:check"
+      });
+    }
+    if (!scripts["pack:check"]) {
+      issues.push({
+        level: "info",
+        code: "pack-check",
+        message: "\u041D\u0435\u0442 scripts.pack:check",
+        fixable: true
+      });
+    }
+    if (existsSync8(join8(cwd, "src/lib")) && !scripts["check:css"]) {
+      issues.push({
+        level: "info",
+        code: "check-css",
+        message: "\u041D\u0435\u0442 scripts.check:css (css-scoped) \u2014 \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F \u0434\u043B\u044F UI-lib"
+      });
+    }
+    if (existsSync8(join8(cwd, "src/lib")) && !scripts["check:tokens"]) {
+      issues.push({
+        level: "info",
+        code: "check-tokens",
+        message: "\u041D\u0435\u0442 scripts.check:tokens \u2014 \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F \u0434\u043B\u044F UI-lib \u0441 CSS Modules"
+      });
+    }
+  }
+  const deps = listElcrmDeps(pkg);
+  if (deps.some((d) => d.name === "@elcrm/socket-server")) {
+    issues.push({
+      level: "error",
+      code: "deprecated-socket-server",
+      message: "\u0417\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C @elcrm/socket-server \u0443\u0441\u0442\u0430\u0440\u0435\u043B\u0430 \u2014 elcrm migrate socket-server",
+      fixable: true
+    });
+  }
+  for (const name of ["@elcrm/db", "@elcrm/jwt", "@elcrm/cron", "@elcrm/tb"]) {
+    if (deps.some((d) => d.name === name)) {
+      issues.push({
+        level: "error",
+        code: `pkg-${name}`,
+        message: `${name} \u2014 \u0441\u0435\u0440\u0432\u0435\u0440\u043D\u044B\u0439 \u043F\u0430\u043A\u0435\u0442; \u043D\u0430 \u0444\u0440\u043E\u043D\u0442\u0435 \u043D\u0435 \u043D\u0443\u0436\u0435\u043D (server: @elcrm/server/\u2026)`
+      });
+    }
+  }
+  const umbrella = pkg.dependencies?.elcrm || pkg.devDependencies?.elcrm;
+  if (umbrella && /^[\^~]?0\.9\./.test(umbrella)) {
+    issues.push({
+      level: "warn",
+      code: "legacy-umbrella",
+      message: `\u0423\u0441\u0442\u0430\u0440\u0435\u0432\u0448\u0438\u0439 \u043F\u0430\u043A\u0435\u0442 elcrm@${umbrella} \u2014 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u0438\u0442\u0435 \u043D\u0430 @elcrm/* / @elcrm/core`
+    });
+  }
+  if (deps.length === 0 && !isLib) {
+    issues.push({
+      level: "info",
+      code: "no-elcrm",
+      message: "\u041D\u0435\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 @elcrm/*"
+    });
+  }
+  const files = [];
+  walkCode(join8(cwd, "src"), files);
+  walkCode(join8(cwd, "style"), files);
+  for (const name of ["bootstrap.tsx", "bootstrap.ts", "main.tsx", "main.ts", "index.tsx", "index.ts", "App.tsx"]) {
+    const full = join8(cwd, name);
+    if (existsSync8(full))
+      files.push(full);
+    const inSrc = join8(cwd, "src", name);
+    if (existsSync8(inSrc) && !files.includes(inSrc))
+      files.push(inSrc);
+  }
+  for (const file of files) {
+    const text = readFileSync12(file, "utf8");
+    const rel2 = relative2(cwd, file);
+    if (DEPRECATED_SOCKET_IMPORT_RE.test(text)) {
+      issues.push({
+        level: "error",
+        code: "deprecated-import",
+        message: "\u0438\u043C\u043F\u043E\u0440\u0442 @elcrm/socket/server \u0438\u043B\u0438 socket-server",
+        file: rel2,
+        fixable: true
+      });
+    }
+    const themesRe = new RegExp(THEMES_CSS_IMPORT_RE.source, "g");
+    let tm;
+    while (tm = themesRe.exec(text)) {
+      const line = text.slice(0, tm.index).split(/\r?\n/).length;
+      issues.push({
+        level: "error",
+        code: "themes-css",
+        message: "import \u2026/themes.css \u0443\u0441\u0442\u0430\u0440\u0435\u043B \u2014 \u0442\u043E\u043A\u0435\u043D\u044B \u0437\u0430\u0434\u0430\u0451\u0442 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 (elcrm-theme / theme.css)",
+        file: rel2,
+        line
+      });
+    }
+    if (LEGACY_PASSKEY_IMPORT_RE.test(text) && LEGACY_PASSKEY_SYMBOL_RE.test(text)) {
+      const lines2 = text.split(/\r?\n/);
+      lines2.forEach((line, i) => {
+        if (/\bcreatePasskey\b/.test(line) || /\bauthenticateWithPasskey\b/.test(line)) {
+          if (pkg.name === "@elcrm/passkey")
+            return;
+          issues.push({
+            level: "error",
+            code: "legacy-passkey-api",
+            message: "createPasskey / authenticateWithPasskey \u043D\u0435 \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u0443\u044E\u0442\u0441\u044F \u2014 createPasskeyClient",
+            file: rel2,
+            line: i + 1
+          });
+        }
+      });
+    }
+    const lines = text.split(/\r?\n/);
+    lines.forEach((line, i) => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) {
+        return;
+      }
+      if (/<(?:input|textarea|select)\b/.test(line)) {
+        if (pkg.name === "@elcrm/form")
+          return;
+        issues.push({
+          level: "error",
+          code: "native-html-input",
+          message: "\u043D\u0430\u0442\u0438\u0432\u043D\u044B\u0439 <input|textarea|select> \u2014 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 @elcrm/form (StringField, Select, \u2026)",
+          file: rel2,
+          line: i + 1
+        });
+      }
+      if (/(?:^|\s)native(?:\s|$|=|\/|>)/.test(line) && !/\bnavigator\b|\bnativeEvent\b|\bcreateNative/.test(line)) {
+        if (pkg.name === "@elcrm/form")
+          return;
+        issues.push({
+          level: "warn",
+          code: "form-native-prop",
+          message: "prop native \u0443 \u043F\u043E\u043B\u044F \u0444\u043E\u0440\u043C\u044B \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435; \u0441\u0442\u0438\u043B\u0438 \u0447\u0435\u0440\u0435\u0437 \u0442\u043E\u043A\u0435\u043D\u044B @elcrm/form",
+          file: rel2,
+          line: i + 1
+        });
+      }
+      if (/size\s*=\s*["'](?:sm|md)["']/.test(line) && !/titleSize/.test(line)) {
+        issues.push({
+          level: "warn",
+          code: "size-legacy",
+          message: 'size="sm"|"md" \u0443\u0441\u0442\u0430\u0440\u0435\u043B\u043E \u2014 "s"|"m" (elcrm migrate size-sml)',
+          file: rel2,
+          line: i + 1,
+          fixable: true
+        });
+      }
+      if (/Modal\.Add\s*\(/.test(line)) {
+        issues.push({
+          level: "warn",
+          code: "modal-add",
+          message: "Modal.Add \u2014 Modal.Create + Open (elcrm migrate modal-create)",
+          file: rel2,
+          line: i + 1,
+          fixable: true
+        });
+      }
+      if (/--field-border-(?:focus|hover|error|disabled)\s*:\s*\d/.test(line) && /solid|dashed|dotted/i.test(line)) {
+        issues.push({
+          level: "error",
+          code: "field-border-shorthand",
+          message: "field-border hover/focus/disabled \u2014 \u0442\u043E\u043B\u044C\u043A\u043E \u0446\u0432\u0435\u0442 (elcrm migrate field-border)",
+          file: rel2,
+          line: i + 1,
+          fixable: true
+        });
+      }
+      if (lineHasDeprecatedFormToken(line)) {
+        issues.push({
+          level: "warn",
+          code: "form-token-legacy",
+          message: "legacy padding/shadow-\u0442\u043E\u043A\u0435\u043D \u2192 --field-padding* / --popup-shadow (elcrm migrate form-tokens)",
+          file: rel2,
+          line: i + 1,
+          fixable: true
+        });
+      }
+    });
+  }
+  return issues;
+}
+async function runPkgScript(cwd, script) {
+  const pkg = JSON.parse(readFileSync12(join8(cwd, "package.json"), "utf8"));
+  if (!pkg.scripts?.[script])
+    return { ran: false, ok: true };
+  console.log(`\u2192 bun run ${script}`);
+  const proc = Bun.spawn(["bun", "run", script], {
+    cwd,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const code = await proc.exited;
+  return { ran: true, ok: code === 0 };
+}
+async function runFrontScripts(cwd) {
+  let failed = 0;
+  for (const name of ["check:css", "check:tokens", "test"]) {
+    const r = await runPkgScript(cwd, name);
+    if (r.ran && !r.ok)
+      failed++;
+  }
+  return failed;
+}
+
+// src/lib/test/print.ts
+function printIssues(issues, title) {
+  if (title)
+    console.log(title);
+  if (issues.length === 0) {
+    console.log(c.green("ok \u2014 \u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0439 \u043D\u0435\u0442"));
+    return 0;
+  }
+  let errors = 0;
+  for (const issue of issues) {
+    const mark = issue.level === "error" ? "E" : issue.level === "warn" ? "W" : "I";
+    if (issue.level === "error")
+      errors++;
+    const loc = issue.file != null ? ` ${issue.file}${issue.line != null ? `:${issue.line}` : ""}` : "";
+    const color = issue.level === "error" ? c.yellow : issue.level === "warn" ? c.yellow : c.gray;
+    console.log(color(`[${mark}] ${issue.code}${loc}: ${issue.message}`));
+  }
+  return errors;
+}
+
+// src/lib/test/serverScan.ts
+import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync13, statSync as statSync6 } from "fs";
+import { join as join9, relative as relative3 } from "path";
+
+// src/lib/test/serverRules.ts
+var CODE_RULES = [
+  {
+    id: "import-elcrm-db",
+    severity: "error",
+    test: /from\s+["']@elcrm\/db["']/,
+    message: "\u041F\u0430\u043A\u0435\u0442 @elcrm/db \u0432\u043B\u0438\u0442 \u0432 @elcrm/server/db",
+    fix: `import { \u2026 } from "@elcrm/server/db"`,
+    auto: true,
+    replace: [
+      {
+        from: /from\s+["']@elcrm\/db["']/g,
+        to: 'from "@elcrm/server/db"'
+      }
+    ]
+  },
+  {
+    id: "import-elcrm-jwt",
+    severity: "error",
+    test: /from\s+["']@elcrm\/jwt["']/,
+    message: "\u041F\u0430\u043A\u0435\u0442 @elcrm/jwt \u0432\u043B\u0438\u0442 \u0432 @elcrm/server/jwt",
+    fix: `import { \u2026 } from "@elcrm/server/jwt"`,
+    auto: true,
+    replace: [
+      {
+        from: /from\s+["']@elcrm\/jwt["']/g,
+        to: 'from "@elcrm/server/jwt"'
+      }
+    ]
+  },
+  {
+    id: "import-elcrm-cron",
+    severity: "error",
+    test: /from\s+["']@elcrm\/cron["']/,
+    message: "\u041F\u0430\u043A\u0435\u0442 @elcrm/cron \u0432\u043B\u0438\u0442 \u0432 @elcrm/server/cron",
+    fix: `import { cron, createCron } from "@elcrm/server/cron"`,
+    auto: true,
+    replace: [
+      {
+        from: /from\s+["']@elcrm\/cron["']/g,
+        to: 'from "@elcrm/server/cron"'
+      }
+    ]
+  },
+  {
+    id: "import-elcrm-tb",
+    severity: "error",
+    test: /from\s+["']@elcrm\/tb["']/,
+    message: "\u041F\u0430\u043A\u0435\u0442 @elcrm/tb \u0432\u043B\u0438\u0442 \u0432 @elcrm/server/tb",
+    fix: `import { tb, createTb } from "@elcrm/server/tb"`,
+    auto: true,
+    replace: [
+      {
+        from: /from\s+["']@elcrm\/tb["']/g,
+        to: 'from "@elcrm/server/tb"'
+      }
+    ]
+  },
+  {
+    id: "createWsHub",
+    severity: "error",
+    test: /\bcreateWsHub\b/,
+    message: "createWsHub \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: 'createSocket("ws").use(\u2026) + sendSocket \u2014 \u0441\u043C. MPC.md',
+    auto: false
+  },
+  {
+    id: "serverConnect",
+    severity: "error",
+    test: /\bserverConnect\b/,
+    message: "serverConnect \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: 'createSocket("ws").use("auth"|name, handler) \u2014 \u0441\u043C. MPC.md',
+    auto: false
+  },
+  {
+    id: "sendListen",
+    severity: "error",
+    test: /\.sendListen\b/,
+    message: "hub.sendListen \u2192 sendSocket",
+    fix: `import { sendSocket } from "@elcrm/server/ws"; sendSocket(uid, listen, data)`,
+    auto: true,
+    replace: [
+      {
+        from: /(\w+)\.sendListen\(/g,
+        to: "sendSocket("
+      },
+      {
+        from: /(\w+)\.sendListenAll\(/g,
+        to: "sendSocketAll("
+      }
+    ]
+  },
+  {
+    id: "sendListenAll",
+    severity: "error",
+    test: /\.sendListenAll\b/,
+    message: "hub.sendListenAll \u2192 sendSocketAll",
+    fix: `import { sendSocketAll } from "@elcrm/server/ws"`,
+    auto: true,
+    replace: [
+      {
+        from: /(\w+)\.sendListenAll\(/g,
+        to: "sendSocketAll("
+      }
+    ]
+  },
+  {
+    id: "createServerFromEnv",
+    severity: "error",
+    test: /\bcreateServerFromEnv\b/,
+    message: "createServerFromEnv \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: "createServer() \u2014 env \u0432\u043D\u0443\u0442\u0440\u0438",
+    auto: true,
+    replace: [
+      {
+        from: /\bcreateServerFromEnv\b/g,
+        to: "createServer"
+      }
+    ]
+  },
+  {
+    id: "manual-loadEnvAtStartup",
+    severity: "error",
+    test: /\bloadEnvAtStartup\s*\(/,
+    message: "\u0440\u0443\u0447\u043D\u043E\u0439 loadEnvAtStartup() \u2014 \u043B\u0435\u0433\u0430\u0441\u0438; \u0434\u043E createServer \u2014 ensureEnvAutoLoaded()",
+    fix: "await ensureEnvAutoLoaded() (\u043E\u0434\u0438\u043D \u0440\u0430\u0437 \u0432 start); createServer/mail \u0441\u0430\u043C\u0438 \u0434\u043E\u0433\u0440\u0443\u0436\u0430\u044E\u0442. \u041D\u0435 top-level await \u0432 \u043F\u0430\u043A\u0435\u0442\u0435 (bun build \u043B\u043E\u043C\u0430\u0435\u0442)",
+    auto: false
+  },
+  {
+    id: "createJwtFromEnv",
+    severity: "warn",
+    test: /\bcreateJwtFromEnv\b/,
+    message: "createJwtFromEnv \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: "createJWT()",
+    auto: true,
+    replace: [{ from: /\bcreateJwtFromEnv\b/g, to: "createJWT" }]
+  },
+  {
+    id: "createCronFromEnv",
+    severity: "warn",
+    test: /\bcreateCronFromEnv\b/,
+    message: "createCronFromEnv \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: "createCron() \u0438\u043B\u0438 cron",
+    auto: true,
+    replace: [{ from: /\bcreateCronFromEnv\b/g, to: "createCron" }]
+  },
+  {
+    id: "createTbFromEnv",
+    severity: "warn",
+    test: /\bcreateTbFromEnv\b/,
+    message: "createTbFromEnv \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: "createTb() \u0438\u043B\u0438 TELEGRAM= + createServer()",
+    auto: true,
+    replace: [{ from: /\bcreateTbFromEnv\b/g, to: "createTb" }]
+  },
+  {
+    id: "registerOpsRouters",
+    severity: "warn",
+    test: /\bregisterOpsRouters\b/,
+    message: "registerOpsRouters \u0443\u0434\u0430\u043B\u0451\u043D",
+    fix: 'createRouter("health"|"system"|"logs").use(\u2026)',
+    auto: false
+  },
+  {
+    id: "Cron-useJob",
+    severity: "info",
+    test: /\.useJob\s*\(/,
+    message: "useJob \u0443\u0441\u0442\u0430\u0440\u0435\u043B",
+    fix: "cron.use(\u2026)",
+    auto: true,
+    replace: [{ from: /\.useJob\s*\(/g, to: ".use(" }]
+  },
+  {
+    id: "WsHubApi-type",
+    severity: "warn",
+    test: /\bWsHubApi\b/,
+    message: "\u0442\u0438\u043F WsHubApi \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435 \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u0443\u0435\u0442\u0441\u044F",
+    fix: "sendSocket / getSocket(); \u0442\u0438\u043F \u043D\u0435 \u043D\u0443\u0436\u0435\u043D",
+    auto: false
+  },
+  {
+    id: "homemade-smtp-auth-login",
+    severity: "error",
+    test: /\bAUTH LOGIN\b/,
+    message: "\u0421\u0430\u043C\u043E\u043F\u0438\u0441\u043D\u044B\u0439 SMTP (AUTH LOGIN) \u2014 \u043B\u0435\u0433\u0430\u0441\u0438",
+    fix: 'createMailer / sendMail \u0438\u0437 "@elcrm/server/mail" \u2014 \u0441\u043C. MPC.md',
+    auto: false
+  },
+  {
+    id: "import-nodemailer",
+    severity: "error",
+    test: /from\s+["']nodemailer["']|require\s*\(\s*["']nodemailer["']\s*\)/,
+    message: "nodemailer \u2192 @elcrm/server/mail",
+    fix: 'import { createMailer, sendMail } from "@elcrm/server/mail"',
+    auto: false
+  },
+  {
+    id: "import-web-push",
+    severity: "error",
+    test: /from\s+["']web-push["']|require\s*\(\s*["']web-push["']\s*\)/,
+    message: "web-push \u2192 @elcrm/server/notifications",
+    fix: 'import { \u2026 } from "@elcrm/server/notifications"',
+    auto: false
+  },
+  {
+    id: "cors-origin-singular",
+    severity: "warn",
+    test: /process\.env\.CORS_ORIGIN\b(?!S)/,
+    message: "process.env.CORS_ORIGIN \u2192 CORS_ORIGINS (\u043F\u0430\u043A\u0435\u0442 createServer)",
+    fix: "CORS_ORIGINS=https://a.example,https://b.example \u2014 \u0431\u0435\u0437 path; \u0441\u0432\u043E\u0439 cors({ origin }) \u2014 \u043E\u043A",
+    auto: false
+  },
+  {
+    id: "rest-path-equals-api",
+    severity: "error",
+    test: /path\s*===\s*["']\/api\//,
+    message: 'REST if (path === "/api/\u2026") \u2014 \u043B\u0435\u0433\u0430\u0441\u0438',
+    fix: 'createRouter("name").use("method", handler) + rpcOk/rpcErr \u2014 \u0441\u043C. MPC.md',
+    auto: false
+  },
+  {
+    id: "rest-handle-export",
+    severity: "error",
+    test: /export\s+async\s+function\s+handle\w+\s*\([^)]*\)\s*:\s*Promise<\s*Response\b/,
+    message: "export handle*(ctx): Promise<Response> \u2014 REST-\u043B\u0435\u0433\u0430\u0441\u0438",
+    fix: "\u043B\u043E\u0433\u0438\u043A\u0430 \u0432 createRouter(\u2026).use(\u2026); Response \u0442\u043E\u043B\u044C\u043A\u043E \u0434\u043B\u044F git/hooks/static",
+    auto: false
+  },
+  {
+    id: "rpc-bridge-invoke-handle",
+    severity: "warn",
+    test: /invoke(?:Authed|Public|Repo)\s*\(\s*handle\w+/,
+    message: "RPC-\u043C\u043E\u0441\u0442 invoke*(handle*) \u043F\u043E\u0432\u0435\u0440\u0445 REST \u2014 \u043F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043E\u0447\u043D\u044B\u0439 \u043B\u0435\u0433\u0430\u0441\u0438",
+    fix: "\u043F\u0435\u0440\u0435\u043D\u0435\u0441\u0442\u0438 \u0442\u0435\u043B\u043E handler \u0432 createRouter().use(); \u0443\u0431\u0440\u0430\u0442\u044C routes/api",
+    auto: false
+  },
+  {
+    id: "routes-api-import",
+    severity: "warn",
+    test: /from\s+["'][^"']*\/routes\/api\/[^"']+["']/,
+    message: "\u0438\u043C\u043F\u043E\u0440\u0442 \u0438\u0437 routes/api \u2014 REST-\u043B\u0435\u0433\u0430\u0441\u0438",
+    fix: "createRouter \u0432 src/rpc (\u0438\u043B\u0438 \u0440\u044F\u0434\u043E\u043C \u0441 createServer); \u0431\u0435\u0437 handle* \u043C\u043E\u0441\u0442\u0430",
+    auto: false
+  },
+  {
+    id: "cron-useJob",
+    severity: "warn",
+    test: /\b(?:Cron\.)?useJob\s*\(/,
+    message: "Cron.useJob deprecated",
+    fix: 'import { cron } from "@elcrm/server/cron"; cron.use(fn, interval?, name?)',
+    auto: false
+  },
+  {
+    id: "cron-namespace",
+    severity: "info",
+    test: /import\s*\{[^}]*\bCron\b[^}]*\}\s*from\s*["']@elcrm\/server\/cron["']/,
+    message: "namespace Cron deprecated \u2014 singleton cron",
+    fix: 'import { cron } from "@elcrm/server/cron"',
+    auto: false
+  },
+  {
+    id: "manual-jwt-init-handler",
+    severity: "warn",
+    test: /\bjwt\.init\s*\(/,
+    message: "jwt.init \u0432 handler \u2014 createServer \u0443\u0436\u0435 \u043A\u043B\u0430\u0434\u0451\u0442 user; \u043D\u0435 \u043F\u0430\u0440\u0441\u0438\u0442\u044C ssid \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u043E",
+    fix: "\u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 params.user; \u0434\u043B\u044F \u0433\u0435\u0439\u0442\u0430 \u2014 middleware (if (!user?.id) return rpcLogout())",
+    auto: false
+  },
+  {
+    id: "createSessionMiddleware-reparse",
+    severity: "info",
+    test: /createSessionMiddleware\s*\(\s*\{[^}]*resolve\s*:\s*async/,
+    message: "createSessionMiddleware \u0441 resolve \u0447\u0430\u0441\u0442\u043E \u0441\u043D\u043E\u0432\u0430 \u0437\u043E\u0432\u0451\u0442 jwt.init \u2014 \u0434\u0443\u0431\u043B\u044C",
+    fix: "\u0435\u0441\u043B\u0438 createServer({ jwt }) \u0443\u0436\u0435 \u0435\u0441\u0442\u044C: middleware \u0442\u043E\u043B\u044C\u043A\u043E if (!user?.id) return rpcLogout()",
+    auto: false
+  },
+  {
+    id: "node-fs-import",
+    severity: "warn",
+    test: /from\s+["'](?:node:)?fs(?:\/promises)?["']/,
+    message: "import node:fs / fs \u2014 \u0432 Bun-\u0441\u0435\u0440\u0432\u0435\u0440\u0435 \u043D\u0435 \u043D\u0443\u0436\u0435\u043D \u0434\u043B\u044F \u0442\u0438\u043F\u043E\u0432\u044B\u0445 \u0437\u0430\u0434\u0430\u0447",
+    fix: "SQLite: initDB \u0441\u0430\u043C \u0441\u043E\u0437\u0434\u0430\u0451\u0442 \u043A\u0430\u0442\u0430\u043B\u043E\u0433; \u0444\u0430\u0439\u043B\u044B \u2014 Bun.file / Bun.write; \u043F\u0443\u0442\u0438 \u2014 \u0431\u0435\u0437 node:path",
+    auto: false
+  },
+  {
+    id: "node-path-import",
+    severity: "warn",
+    test: /from\s+["'](?:node:)?path["']/,
+    message: "import node:path / path \u2014 \u0438\u0437\u0431\u0435\u0433\u0430\u0439\u0442\u0435 \u0432 app \u043D\u0430 @elcrm/server",
+    fix: "\u043E\u0442\u043D\u043E\u0441\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u0441\u0442\u0440\u043E\u043A\u0438 / URL; mkdir \u0434\u043B\u044F sqlite \u0434\u0435\u043B\u0430\u0435\u0442 @elcrm/server/db",
+    auto: false
+  }
+];
+var PKG_LEGACY = [
+  "@elcrm/db",
+  "@elcrm/jwt",
+  "@elcrm/cron",
+  "@elcrm/tb",
+  "nodemailer",
+  "web-push"
+];
+
+// src/lib/test/serverScan.ts
+var SKIP2 = new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  "coverage",
+  ".bun",
+  "vendor"
+]);
+function walkFiles2(root, dir, out) {
+  if (!existsSync9(dir))
+    return;
+  for (const name of readdirSync6(dir)) {
+    if (SKIP2.has(name))
+      continue;
+    const full = join9(dir, name);
+    let st;
+    try {
+      st = statSync6(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory())
+      walkFiles2(root, full, out);
+    else if (/\.(tsx?|jsx?|mjs|cjs)$/.test(name) || name === "package.json") {
+      out.push(full);
+    }
+  }
+}
+function scanCodeFile(root, file, text) {
+  const findings = [];
+  const lines = text.split(/\r?\n/);
+  const rel2 = relative3(root, file) || file;
+  for (const rule of CODE_RULES) {
+    lines.forEach((line, i) => {
+      rule.test.lastIndex = 0;
+      if (!rule.test.test(line))
+        return;
+      rule.test.lastIndex = 0;
+      const m = line.match(rule.test);
+      findings.push({
+        ruleId: rule.id,
+        severity: rule.severity,
+        file: rel2,
+        line: i + 1,
+        match: (m?.[0] ?? line).trim().slice(0, 120),
+        message: rule.message,
+        fix: rule.fix,
+        auto: rule.auto
+      });
+    });
   }
-  return map;
+  return findings;
 }
-async function fetchCorePinnedVersions() {
-  const url = "https://registry.npmjs.org/@elcrm%2Fcore/latest";
-  const map = new Map;
+function scanPackageJson(root, file, text) {
+  const findings = [];
+  const rel2 = relative3(root, file) || file;
+  let pkg;
   try {
-    const res = await fetch(url, {
-      headers: { Accept: "application/json" }
-    });
-    if (!res.ok)
-      return map;
-    const data = await res.json();
-    if (data.version)
-      map.set("@elcrm/core", data.version);
-    for (const [name, ver] of Object.entries(data.dependencies ?? {})) {
-      if (name.startsWith("@elcrm/")) {
-        map.set(name, ver.replace(/^[\^~]/, ""));
-      }
+    pkg = JSON.parse(text);
+  } catch {
+    return findings;
+  }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  for (const name of PKG_LEGACY) {
+    if (deps[name]) {
+      findings.push({
+        ruleId: `pkg-${name}`,
+        severity: "error",
+        file: rel2,
+        line: 1,
+        match: `"${name}": "${deps[name]}"`,
+        message: `\u0417\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C ${name} \u2192 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 @elcrm/server (+ subpath)`,
+        fix: `\u0423\u0434\u0430\u043B\u0438\u0442\u044C ${name}, \u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C/\u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C "@elcrm/server": ">=0.6.0"`,
+        auto: true
+      });
     }
-  } catch {}
-  return map;
+  }
+  if ((deps["@elcrm/db"] || deps["@elcrm/jwt"] || deps["@elcrm/cron"] || deps["@elcrm/tb"]) && !deps["@elcrm/server"]) {
+    findings.push({
+      ruleId: "pkg-need-server",
+      severity: "error",
+      file: rel2,
+      line: 1,
+      match: "missing @elcrm/server",
+      message: "\u041D\u0443\u0436\u043D\u0430 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C @elcrm/server",
+      fix: `"@elcrm/server": ">=0.6.0"`,
+      auto: true
+    });
+  }
+  return findings;
 }
-
-// src/lib/install.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { spawnSync } from "child_process";
-function detectPackageManager(cwd = process.cwd()) {
-  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) {
-    return "bun";
+function scanServerProject(root) {
+  const files = [];
+  walkFiles2(root, root, files);
+  const findings = [];
+  for (const file of files) {
+    const text = readFileSync13(file, "utf8");
+    if (file.endsWith("package.json")) {
+      findings.push(...scanPackageJson(root, file, text));
+    } else {
+      findings.push(...scanCodeFile(root, file, text));
+    }
   }
-  const bun = spawnSync("bun", ["--version"], { encoding: "utf8" });
-  if (bun.status === 0)
-    return "bun";
-  return "npm";
+  return { root, findings, filesScanned: files.length };
 }
-function installDeps(cwd = process.cwd()) {
-  const pm = detectPackageManager(cwd);
-  console.log(`\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 (${pm} install)\u2026`);
-  const r = spawnSync(pm, ["install"], {
-    cwd,
-    stdio: "inherit",
-    env: process.env
-  });
-  return r.status === 0;
+function printServerFindings(result) {
+  const { findings, filesScanned, root } = result;
+  const errors = findings.filter((f) => f.severity === "error");
+  const warns = findings.filter((f) => f.severity === "warn");
+  const infos = findings.filter((f) => f.severity === "info");
+  console.log(`
+elcrm test (server) \u2014 ${root}`);
+  console.log(`\u0444\u0430\u0439\u043B\u043E\u0432: ${filesScanned}, \u043F\u0440\u043E\u0431\u043B\u0435\u043C: ${findings.length}`);
+  console.log(`  error: ${errors.length}  warn: ${warns.length}  info: ${infos.length}
+`);
+  const byFile = new Map;
+  for (const f of findings) {
+    const list = byFile.get(f.file) ?? [];
+    list.push(f);
+    byFile.set(f.file, list);
+  }
+  for (const [file, list] of [...byFile.entries()].sort()) {
+    console.log(`${file}`);
+    for (const f of list) {
+      const tag = f.severity === "error" ? "ERR " : f.severity === "warn" ? "WARN" : "INFO";
+      console.log(`  ${tag} L${f.line} [${f.ruleId}] ${f.message}`);
+      console.log(`       ${f.match}`);
+      if (f.fix)
+        console.log(`       \u2192 ${f.fix}`);
+      if (f.auto)
+        console.log(`       (auto: bunx elcrm-server update)`);
+      else
+        console.log(`       (\u0432\u0440\u0443\u0447\u043D\u0443\u044E \u2014 MPC.md \u0432 @elcrm/server)`);
+    }
+    console.log("");
+  }
+  if (findings.length === 0) {
+    console.log(`ok \u2014 \u0441\u0435\u0440\u0432\u0435\u0440\u043D\u043E\u0435 \u043B\u0435\u0433\u0430\u0441\u0438 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E
+`);
+  }
+  return errors.length;
 }
 
-// src/lib/pkg.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
-function packageJsonPath(cwd = process.cwd()) {
-  return join2(cwd, "package.json");
-}
-function readPackageJson(cwd = process.cwd()) {
-  const path = packageJsonPath(cwd);
-  if (!existsSync2(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
+// src/commands/test.ts
+async function testOneDir(cwd, force, runScripts) {
+  const pkg = readPkgAt(cwd);
+  if (!pkg) {
+    console.error(`package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${cwd}`);
+    return 1;
   }
+  const mode = detectTestMode(pkg, force);
+  console.log(c.blue(`
+elcrm test \u2014 ${cwd}
+\u0440\u0435\u0436\u0438\u043C: ${mode}${force ? " (\u0444\u043B\u0430\u0433)" : " (\u043F\u043E package.json)"}`));
+  if (mode === "server") {
+    const result = scanServerProject(cwd);
+    return printServerFindings(result);
+  }
+  const issues = collectFrontIssues(cwd, pkg);
+  let errors = printIssues(issues, `
+\u0441\u0442\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u0439 \u0430\u043D\u0430\u043B\u0438\u0437:`);
+  if (runScripts) {
+    console.log("");
+    const scriptFails = await runFrontScripts(cwd);
+    errors += scriptFails;
+  } else {
+    console.log(c.gray(`
+(--no-scripts: check:css / check:tokens / test \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D\u044B)`));
+  }
+  return errors;
 }
-function writePackageJson(pkg, cwd = process.cwd()) {
-  writeFileSync(packageJsonPath(cwd), JSON.stringify(pkg, null, 2) + `
-`, "utf8");
+async function cmdTest(parsed) {
+  const target = resolve(parsed.positionals[0] ?? process.cwd());
+  const force = hasFlag(parsed, "server") ? "server" : hasFlag(parsed, "front") ? "front" : null;
+  const runScripts = !hasFlag(parsed, "no-scripts");
+  const rootPkg = readPkgAt(target);
+  if (!rootPkg) {
+    console.error("package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D.");
+    process.exit(1);
+  }
+  const workspaces = listWorkspaceDirs(target, rootPkg);
+  let totalErrors = 0;
+  if (workspaces.length > 0 && !force) {
+    console.log(c.dim(`workspaces: ${workspaces.map((d) => d.replace(target + "/", "")).join(", ")}`));
+    const rootHasElcrm = Boolean(rootPkg.dependencies && Object.keys(rootPkg.dependencies).some((k) => k.startsWith("@elcrm/"))) || Boolean(rootPkg.devDependencies && Object.keys(rootPkg.devDependencies).some((k) => k.startsWith("@elcrm/")));
+    if (rootHasElcrm || hasFlag(parsed, "root")) {
+      totalErrors += await testOneDir(target, force, runScripts);
+    }
+    for (const dir of workspaces) {
+      totalErrors += await testOneDir(dir, force, runScripts);
+    }
+  } else {
+    totalErrors += await testOneDir(target, force, runScripts);
+  }
+  if (totalErrors > 0) {
+    console.log(c.yellow(`
+elcrm test: ${totalErrors} error(s)`));
+    process.exit(1);
+  }
+  console.log(c.green(`
+elcrm test: ok`));
 }
 
 // src/commands/update.ts
@@ -206,6 +2149,8 @@ async function cmdUpdate(parsed) {
   const dry = hasFlag(parsed, "dry");
   const useCore = hasFlag(parsed, "core");
   const noInstall = hasFlag(parsed, "no-install");
+  const doFix = hasFlag(parsed, "fix");
+  const doTest = hasFlag(parsed, "test");
   const names = uniqueElcrmNames(deps);
   console.log(`\u041D\u0430\u0439\u0434\u0435\u043D\u043E @elcrm/*: ${names.length}`);
   let versions;
@@ -227,17 +2172,17 @@ async function cmdUpdate(parsed) {
   for (const dep of deps) {
     const latest = versions.get(dep.name);
     if (!latest) {
-      rows.push(`  ? ${dep.name}: ${dep.version} \u2192 (\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043D\u0430 npm)`);
+      rows.push(`  ${c.yellow("?")} ${dep.name}: ${c.gray(dep.version)} \u2192 ${c.yellow("(\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043D\u0430 npm)")}`);
       continue;
     }
     const current = dep.version.replace(/^[\^~]/, "");
     if (current === latest) {
-      rows.push(`  = ${dep.name}: ${dep.version}`);
+      rows.push(`  ${c.gray("=")} ${dep.name}: ${c.gray(dep.version)}`);
       continue;
     }
     const prefix = dep.version.startsWith("^") ? "^" : dep.version.startsWith("~") ? "~" : "";
     const next = `${prefix}${latest}`;
-    rows.push(`  \u2191 ${dep.name}: ${dep.version} \u2192 ${next}`);
+    rows.push(`  ${c.blue("\u2191")} ${dep.name}: ${c.gray(dep.version)} \u2192 ${c.green(next)}`);
     if (!dry) {
       const section = pkg[dep.section];
       section[dep.name] = next;
@@ -251,100 +2196,172 @@ async function cmdUpdate(parsed) {
   if (dry) {
     console.log(`
 --dry: \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E (\u043A \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044E: ${changed}).`);
+    if (doFix) {
+      console.log(`
+--fix + --dry: \u043F\u0440\u0435\u0432\u044C\u044E migrate front\u2026`);
+      const front = await migrateFrontAll(cwd, true);
+      if (front.length === 0)
+        console.log("  \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0439 \u043A\u043E\u0434\u0430 \u043D\u0435 \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F.");
+      else
+        for (const c2 of front)
+          console.log(`  ${c2.file}: ${c2.detail}`);
+      console.log(`
+--fix + --dry: \u043F\u0440\u0435\u0432\u044C\u044E CSS-\u0442\u043E\u043A\u0435\u043D\u043E\u0432\u2026`);
+      try {
+        const css = syncElcrmCss({ cwd, pkgNames: names, dry: true });
+        let n = 0;
+        for (const [file, tokens] of Object.entries(css.added)) {
+          if (!tokens.length)
+            continue;
+          n += tokens.length;
+          console.log(`  ${file}: ${tokens.join(", ")}`);
+        }
+        if (n === 0)
+          console.log("  \u041D\u043E\u0432\u044B\u0445 \u0442\u043E\u043A\u0435\u043D\u043E\u0432 \u043D\u0435\u0442.");
+      } catch (e) {
+        console.log(`  ${c.gray("css:")} ${e instanceof Error ? e.message : e}`);
+      }
+    }
     return;
   }
   if (changed === 0) {
     console.log(`
 \u0412\u0441\u0435 @elcrm/* \u0443\u0436\u0435 \u043D\u0430 \u0430\u043A\u0442\u0443\u0430\u043B\u044C\u043D\u044B\u0445 \u0432\u0435\u0440\u0441\u0438\u044F\u0445.`);
-    return;
-  }
-  writePackageJson(pkg, cwd);
-  console.log(`
+  } else {
+    writePackageJson(pkg, cwd);
+    console.log(`
 package.json \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D (${changed}).`);
-  if (!noInstall) {
-    const ok = installDeps(cwd);
-    if (!ok) {
-      console.error("\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430\u0441\u044C \u0441 \u043E\u0448\u0438\u0431\u043A\u043E\u0439.");
-      process.exit(1);
+    if (!noInstall) {
+      const ok = installDeps(cwd);
+      if (!ok) {
+        console.error("\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430\u0441\u044C \u0441 \u043E\u0448\u0438\u0431\u043A\u043E\u0439.");
+        process.exit(1);
+      }
+    } else {
+      console.log("\u041F\u0440\u043E\u043F\u0443\u0441\u043A install (--no-install). \u0417\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 bun/npm install \u0432\u0440\u0443\u0447\u043D\u0443\u044E.");
     }
-  } else {
-    console.log("\u041F\u0440\u043E\u043F\u0443\u0441\u043A install (--no-install). \u0417\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 bun/npm install \u0432\u0440\u0443\u0447\u043D\u0443\u044E.");
+  }
+  if (doFix) {
+    console.log(`
+--fix: migrate front (form-aliases, size, \u2026)\u2026`);
+    const front = await migrateFrontAll(cwd, false);
+    if (front.length === 0) {
+      console.log("  \u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u043A\u043E\u0434\u0430 \u043D\u0435 \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F.");
+    } else {
+      for (const ch of front)
+        console.log(`  ${ch.file}: ${ch.detail}`);
+      console.log(`  \u041F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u043E: ${front.length}.`);
+    }
+    console.log(`
+--fix: sync CSS-\u0442\u043E\u043A\u0435\u043D\u043E\u0432 (elcrm css)\u2026`);
+    try {
+      const pkgAfter = readPackageJson(cwd) ?? pkg;
+      const cssNames = uniqueElcrmNames(listElcrmDeps(pkgAfter));
+      const css = syncElcrmCss({ cwd, pkgNames: cssNames, dry: false });
+      let added = 0;
+      for (const [file, tokens] of Object.entries(css.added)) {
+        if (!tokens.length)
+          continue;
+        added += tokens.length;
+        console.log(`  ${c.green("+")} ${file}: ${tokens.join(", ")}`);
+      }
+      if (css.imports.length) {
+        console.log(`  ${c.green("+")} elcrm.css @import: ${css.imports.join(", ")}`);
+      }
+      if (added === 0 && css.imports.length === 0) {
+        console.log("  \u0422\u043E\u043A\u0435\u043D\u044B \u0443\u0436\u0435 \u043D\u0430 \u043C\u0435\u0441\u0442\u0435.");
+      }
+    } catch (e) {
+      console.log(`  ${c.gray("css sync \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D:")} ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  if (doTest) {
+    console.log(`
+--test: elcrm test\u2026`);
+    await cmdTest(parseArgs(["test"]));
+  } else if (doFix) {
+    console.log(`
+\u0414\u0430\u043B\u044C\u0448\u0435: elcrm test   (\u0438\u043B\u0438 elcrm update --fix --test)`);
+  } else if (changed > 0) {
+    console.log(`
+\u041F\u043E\u0441\u043B\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F @elcrm/form: elcrm update --fix --test`);
+    console.log("  (\u0430\u043B\u0438\u0430\u0441\u044B \u043F\u043E\u043B\u0435\u0439 + form-tokens + \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 CSS-\u0442\u043E\u043A\u0435\u043D\u044B)");
   }
 }
 
 // src/lib/copyTemplate.ts
 import {
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync11,
   mkdirSync,
-  readdirSync,
-  readFileSync as readFileSync2,
-  statSync,
-  writeFileSync as writeFileSync2
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync14,
+  statSync as statSync7,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { join as join4, resolve } from "path";
+import { join as join11, resolve as resolve2 } from "path";
 
 // src/lib/paths.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname, join as join3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname2, join as join10 } from "path";
 import { fileURLToPath } from "url";
 function packageRoot() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const candidates = [here, join3(here, ".."), join3(here, "..", "..")];
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [here, join10(here, ".."), join10(here, "..", "..")];
   for (const dir of candidates) {
-    if (existsSync3(join3(dir, "package.json")) && existsSync3(join3(dir, "templates"))) {
+    if (existsSync10(join10(dir, "package.json")) && existsSync10(join10(dir, "templates"))) {
       return dir;
     }
   }
   for (const dir of candidates) {
-    if (existsSync3(join3(dir, "package.json")))
+    if (existsSync10(join10(dir, "package.json")))
       return dir;
   }
-  return join3(here, "..");
+  return join10(here, "..");
 }
 function templatesDir() {
-  return join3(packageRoot(), "templates");
+  return join10(packageRoot(), "templates");
 }
 
 // src/lib/copyTemplate.ts
-var SKIP = new Set(["node_modules", "dist", ".git"]);
+var SKIP3 = new Set(["node_modules", "dist", ".git"]);
 function folderToPackageName(projectPath) {
   const base = projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() ?? "app";
   const slug = base.toLowerCase().replace(/[^a-z0-9-._~/]/g, "-").replace(/^[-_.]+|[-_.]+$/g, "");
   return slug || "app";
 }
 function isEmptyDir(dir) {
-  if (!existsSync4(dir))
+  if (!existsSync11(dir))
     return true;
-  const entries = readdirSync(dir).filter((e) => e !== ".git" && e !== ".DS_Store");
+  const entries = readdirSync7(dir).filter((e) => e !== ".git" && e !== ".DS_Store");
   return entries.length === 0;
 }
 function writePkgName(pkgPath, name) {
-  if (!existsSync4(pkgPath))
+  if (!existsSync11(pkgPath))
     return;
-  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
   pkg.name = name;
   pkg.version = pkg.version ?? "0.0.0";
-  writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + `
+  writeFileSync5(pkgPath, JSON.stringify(pkg, null, 2) + `
 `, "utf8");
 }
 function finalizePanelNames(targetDir, baseName) {
-  writePkgName(join4(targetDir, "package.json"), baseName);
-  writePkgName(join4(targetDir, "web", "package.json"), `${baseName}-web`);
-  writePkgName(join4(targetDir, "api", "package.json"), `${baseName}-api`);
+  writePkgName(join11(targetDir, "package.json"), baseName);
+  writePkgName(join11(targetDir, "web", "package.json"), `${baseName}-web`);
+  writePkgName(join11(targetDir, "api", "package.json"), `${baseName}-api`);
 }
 function copyTemplate(templateName, targetDir, packageName) {
-  const src = join4(templatesDir(), templateName);
-  if (!existsSync4(src) || !statSync(src).isDirectory()) {
+  const src = join11(templatesDir(), templateName);
+  if (!existsSync11(src) || !statSync7(src).isDirectory()) {
     throw new Error(`\u0428\u0430\u0431\u043B\u043E\u043D \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${templateName}
 \u041E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433: ${src}`);
   }
   mkdirSync(targetDir, { recursive: true });
-  for (const entry of readdirSync(src)) {
-    if (SKIP.has(entry))
+  for (const entry of readdirSync7(src)) {
+    if (SKIP3.has(entry))
       continue;
-    const from = join4(src, entry);
-    const to = join4(targetDir, entry);
+    const from = join11(src, entry);
+    const to = join11(targetDir, entry);
     cpSync(from, to, { recursive: true });
   }
   const name = packageName ?? folderToPackageName(targetDir);
@@ -352,19 +2369,19 @@ function copyTemplate(templateName, targetDir, packageName) {
     finalizePanelNames(targetDir, name);
     return;
   }
-  writePkgName(join4(targetDir, "package.json"), name);
+  writePkgName(join11(targetDir, "package.json"), name);
 }
 function listTemplates() {
   const dir = templatesDir();
-  if (!existsSync4(dir))
+  if (!existsSync11(dir))
     return [];
-  return readdirSync(dir).filter((name) => {
-    const p = join4(dir, name);
-    return statSync(p).isDirectory() && !SKIP.has(name);
+  return readdirSync7(dir).filter((name) => {
+    const p = join11(dir, name);
+    return statSync7(p).isDirectory() && !SKIP3.has(name);
   });
 }
 function resolveTarget(pathOrName, cwd = process.cwd()) {
-  return resolve(cwd, pathOrName);
+  return resolve2(cwd, pathOrName);
 }
 
 // src/commands/create.ts
@@ -426,165 +2443,40 @@ async function cmdInit(parsed) {
   const cwd = process.cwd();
   const force = hasFlag(parsed, "force");
   const noInstall = hasFlag(parsed, "no-install");
-  if (!force && !isEmptyDir(cwd)) {
-    console.error("\u0422\u0435\u043A\u0443\u0449\u0438\u0439 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043F\u0443\u0441\u0442. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 --force \u0438\u043B\u0438 elcrm create <name>.");
-    process.exit(1);
-  }
-  const pkgName = template === "lib" ? libPackageName(cwd) : folderToPackageName(cwd);
-  console.log(`\u0428\u0430\u0431\u043B\u043E\u043D: ${template}`);
-  console.log(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433: ${cwd}`);
-  copyTemplate(template, cwd, pkgName);
-  console.log("\u041F\u0440\u043E\u0435\u043A\u0442 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D.");
-  if (!noInstall) {
-    const ok = installDeps(cwd);
-    if (!ok)
-      process.exit(1);
-  }
-  doneHint(template);
-}
-
-// src/lib/migrate/socket-server.ts
-import {
-  existsSync as existsSync5,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
-  statSync as statSync2,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { join as join5 } from "path";
-var SKIP_DIRS = new Set([
-  "node_modules",
-  "dist",
-  ".git",
-  "coverage",
-  ".turbo"
-]);
-var TEXT_EXT = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".mts",
-  ".cts"
-]);
-function walkFiles(dir, out = []) {
-  if (!existsSync5(dir))
-    return out;
-  for (const name of readdirSync2(dir)) {
-    if (SKIP_DIRS.has(name))
-      continue;
-    const full = join5(dir, name);
-    const st = statSync2(full);
-    if (st.isDirectory())
-      walkFiles(full, out);
-    else {
-      const ext = name.includes(".") ? `.${name.split(".").pop()}` : "";
-      if (TEXT_EXT.has(ext))
-        out.push(full);
-    }
-  }
-  return out;
-}
-function rewriteImports(source) {
-  let hits = 0;
-  let next = source;
-  const patterns = [
-    [
-      /from\s+["']@elcrm\/socket\/server["']/g,
-      'from "@elcrm/server"'
-    ],
-    [
-      /from\s+["']@elcrm\/socket-server["']/g,
-      'from "@elcrm/server"'
-    ],
-    [
-      /require\s*\(\s*["']@elcrm\/socket\/server["']\s*\)/g,
-      'require("@elcrm/server")'
-    ],
-    [
-      /require\s*\(\s*["']@elcrm\/socket-server["']\s*\)/g,
-      'require("@elcrm/server")'
-    ]
-  ];
-  for (const [re, repl] of patterns) {
-    const before = next;
-    next = next.replace(re, () => {
-      hits++;
-      return repl;
-    });
-  }
-  return { next, hits };
-}
-async function migrateSocketServer(cwd, dry) {
-  const changes = [];
-  const pkg = readPackageJson(cwd);
-  let removedSocketServer = false;
-  if (pkg) {
-    for (const section of [
-      "dependencies",
-      "devDependencies",
-      "peerDependencies"
-    ]) {
-      const map = pkg[section];
-      if (!map)
-        continue;
-      if (map["@elcrm/socket-server"]) {
-        removedSocketServer = true;
-        changes.push({
-          file: "package.json",
-          detail: `\u0443\u0434\u0430\u043B\u0438\u0442\u044C ${section}["@elcrm/socket-server"]`
-        });
-        if (!dry)
-          delete map["@elcrm/socket-server"];
-      }
-    }
-    const hasServer = Boolean(pkg.dependencies?.["@elcrm/server"]) || Boolean(pkg.devDependencies?.["@elcrm/server"]);
-    if (removedSocketServer && !hasServer) {
-      const latest = dry ? null : await fetchLatestVersion("@elcrm/server");
-      const ver = latest ? `^${latest}` : "^0.5.3";
-      changes.push({
-        file: "package.json",
-        detail: `\u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C dependencies["@elcrm/server"] = ${ver}`
-      });
-      if (!dry) {
-        if (!pkg.dependencies)
-          pkg.dependencies = {};
-        pkg.dependencies["@elcrm/server"] = ver;
-      }
-    }
-    if (!dry && changes.some((c) => c.file === "package.json")) {
-      writePackageJson(pkg, cwd);
-    }
+  if (!force && !isEmptyDir(cwd)) {
+    console.error("\u0422\u0435\u043A\u0443\u0449\u0438\u0439 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043F\u0443\u0441\u0442. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 --force \u0438\u043B\u0438 elcrm create <name>.");
+    process.exit(1);
   }
-  const roots = ["src", "app", "server", "lib"].map((d) => join5(cwd, d));
-  const files = roots.flatMap((r) => walkFiles(r));
-  for (const file of files) {
-    const raw = readFileSync3(file, "utf8");
-    const { next, hits } = rewriteImports(raw);
-    if (hits > 0) {
-      changes.push({
-        file: file.replace(cwd + "/", ""),
-        detail: `${hits} \u0437\u0430\u043C\u0435\u043D(\u044B) \u0438\u043C\u043F\u043E\u0440\u0442\u043E\u0432 \u2192 @elcrm/server`
-      });
-      if (!dry)
-        writeFileSync3(file, next, "utf8");
-    }
+  const pkgName = template === "lib" ? libPackageName(cwd) : folderToPackageName(cwd);
+  console.log(`\u0428\u0430\u0431\u043B\u043E\u043D: ${template}`);
+  console.log(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433: ${cwd}`);
+  copyTemplate(template, cwd, pkgName);
+  console.log("\u041F\u0440\u043E\u0435\u043A\u0442 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D.");
+  if (!noInstall) {
+    const ok = installDeps(cwd);
+    if (!ok)
+      process.exit(1);
   }
-  return changes;
+  doneHint(template);
 }
 
 // src/commands/migrate.ts
+init_socket_server();
+init_front();
 var MIGRATIONS = {
-  "socket-server": migrateSocketServer
+  "socket-server": migrateSocketServer,
+  ...FRONT_MIGRATIONS,
+  front: migrateFrontAll,
+  ui: migrateFrontAll
 };
 async function cmdMigrate(parsed) {
   if (hasFlag(parsed, "list") || parsed.positionals[0] === "list") {
     console.log("\u0414\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0435 \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0438:");
-    for (const name2 of Object.keys(MIGRATIONS)) {
-      console.log(`  ${name2}`);
+    console.log("  front | ui     \u043F\u0430\u043A\u0435\u0442 \u0444\u0440\u043E\u043D\u0442\u043E\u0432\u044B\u0445 \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0439:");
+    for (const name2 of FRONT_MIGRATE_ORDER) {
+      console.log(`    - ${name2}`);
     }
+    console.log("  socket-server  (\u0442\u0430\u043A\u0436\u0435 \u0432 front)");
     return;
   }
   const name = parsed.positionals[0];
@@ -608,127 +2500,51 @@ async function cmdMigrate(parsed) {
     console.log("\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u043D\u0435 \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F.");
     return;
   }
-  for (const c of changes) {
-    console.log(`  ${c.file}: ${c.detail}`);
+  for (const c2 of changes) {
+    console.log(`  ${c2.file}: ${c2.detail}`);
   }
   console.log(dry ? `
 --dry: ${changes.length} \u043F\u043E\u0442\u0435\u043D\u0446\u0438\u0430\u043B\u044C\u043D\u044B\u0445 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439.` : `
 \u041F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u043E: ${changes.length}.`);
+  if (name === "front" || name === "ui" || name === "size-sml" || name === "form-tokens") {
+    console.log("\u0414\u0430\u043B\u044C\u0448\u0435: elcrm css && elcrm audit");
+  }
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
-var DEPRECATED_IMPORT_RE = /(?:from\s+|require\s*\(\s*)["']@elcrm\/(?:socket\/server|socket-server)["']/;
-function scanDeprecatedImports(cwd) {
-  const hits = [];
-  const SKIP2 = new Set(["node_modules", "dist", ".git"]);
-  const walk = (dir) => {
-    if (!existsSync6(dir))
-      return;
-    for (const name of readdirSync3(dir)) {
-      if (SKIP2.has(name))
-        continue;
-      const full = join6(dir, name);
-      const st = statSync3(full);
-      if (st.isDirectory())
-        walk(full);
-      else if (/\.(tsx?|jsx?|mjs|cjs)$/.test(name)) {
-        const text = readFileSync4(full, "utf8");
-        if (DEPRECATED_IMPORT_RE.test(text)) {
-          hits.push(full.replace(cwd + "/", ""));
-        }
-      }
-    }
-  };
-  walk(join6(cwd, "src"));
-  return hits;
-}
+init_socket_server();
+init_pkg();
 async function cmdDoctor(parsed) {
   const cwd = process.cwd();
   const fix = hasFlag(parsed, "fix");
-  const issues = [];
   const pkg = readPackageJson(cwd);
   if (!pkg) {
     console.error("package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D.");
     process.exit(1);
   }
-  if (pkg.type !== "module") {
-    issues.push({
-      level: "warn",
-      code: "type-module",
-      message: '\u041D\u0435\u0442 "type": "module"',
-      fixable: true
-    });
-  }
-  if (!pkg.engines?.node) {
-    issues.push({
-      level: "warn",
-      code: "engines",
-      message: "\u041D\u0435\u0442 engines.node (\u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F >=18)",
-      fixable: true
-    });
-  }
-  const scripts = pkg.scripts ?? {};
-  const isLib = Boolean(pkg.name?.startsWith("@elcrm/"));
-  if (isLib) {
-    if (!scripts.build && !scripts["pack:check"]) {
-      issues.push({
-        level: "warn",
-        code: "scripts",
-        message: "\u0414\u043B\u044F \u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u0438 \u0436\u0435\u043B\u0430\u0442\u0435\u043B\u044C\u043D\u044B scripts.build \u0438/\u0438\u043B\u0438 pack:check"
-      });
-    }
-    if (!scripts["pack:check"]) {
-      issues.push({
-        level: "info",
-        code: "pack-check",
-        message: "\u041D\u0435\u0442 scripts.pack:check",
-        fixable: true
-      });
+  if (hasElcrmServer(pkg)) {
+    const result = scanServerProject(cwd);
+    const errors = printServerFindings(result);
+    if (!fix) {
+      if (result.findings.some((f) => f.auto)) {
+        console.log(`
+\u0410\u0432\u0442\u043E\u0437\u0430\u043C\u0435\u043D\u044B: bunx elcrm-server update   (\u0438\u043B\u0438 elcrm migrate \u2026)`);
+      }
+      if (errors)
+        process.exit(1);
+      return;
     }
+    console.log("doctor --fix \u043D\u0430 \u0441\u0435\u0440\u0432\u0435\u0440\u0435: \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 bunx elcrm-server update");
+    if (errors)
+      process.exit(1);
+    return;
   }
-  const deps = listElcrmDeps(pkg);
-  if (deps.some((d) => d.name === "@elcrm/socket-server")) {
-    issues.push({
-      level: "error",
-      code: "deprecated-socket-server",
-      message: "\u0417\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C @elcrm/socket-server \u0443\u0441\u0442\u0430\u0440\u0435\u043B\u0430 \u2014 elcrm migrate socket-server",
-      fixable: true
-    });
-  }
-  const umbrella = pkg.dependencies?.elcrm || pkg.devDependencies?.elcrm;
-  if (umbrella && /^[\^~]?0\.9\./.test(umbrella)) {
-    issues.push({
-      level: "warn",
-      code: "legacy-umbrella",
-      message: `\u0423\u0441\u0442\u0430\u0440\u0435\u0432\u0448\u0438\u0439 \u043F\u0430\u043A\u0435\u0442 elcrm@${umbrella} \u2014 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u0438\u0442\u0435 \u043D\u0430 @elcrm/* / @elcrm/core`
-    });
-  }
-  const importHits = scanDeprecatedImports(cwd);
-  for (const file of importHits) {
-    issues.push({
-      level: "error",
-      code: "deprecated-import",
-      message: `${file}: \u0438\u043C\u043F\u043E\u0440\u0442 @elcrm/socket/server \u0438\u043B\u0438 socket-server`,
-      fixable: true
-    });
-  }
-  if (deps.length === 0 && !isLib) {
-    issues.push({
-      level: "info",
-      code: "no-elcrm",
-      message: "\u041D\u0435\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 @elcrm/*"
-    });
-  }
+  const issues = collectFrontIssues(cwd, pkg);
   if (issues.length === 0) {
     console.log("doctor: \u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0439 \u043D\u0435\u0442.");
     return;
   }
-  for (const issue of issues) {
-    const mark = issue.level === "error" ? "E" : issue.level === "warn" ? "W" : "I";
-    console.log(`[${mark}] ${issue.code}: ${issue.message}`);
-  }
+  printIssues(issues);
   if (!fix) {
     const fixable = issues.filter((i) => i.fixable).length;
     if (fixable) {
@@ -746,10 +2562,11 @@ async function cmdDoctor(parsed) {
   }
   if (!pkg.engines)
     pkg.engines = {};
-  if (!pkg.engines.node) {
+  if (!pkg.engines.node && !pkg.engines.bun) {
     pkg.engines.node = ">=18";
     pkgDirty = true;
   }
+  const isLib = Boolean(pkg.name?.startsWith("@elcrm/"));
   if (isLib) {
     if (!pkg.scripts)
       pkg.scripts = {};
@@ -764,14 +2581,20 @@ async function cmdDoctor(parsed) {
   if (mig.length) {
     console.log(`\u041C\u0438\u0433\u0440\u0430\u0446\u0438\u044F socket-server: ${mig.length} \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439.`);
   }
+  const { migrateFrontAll: migrateFrontAll2 } = await Promise.resolve().then(() => (init_front(), exports_front));
+  const front = await migrateFrontAll2(cwd, false);
+  if (front.length) {
+    console.log(`migrate front: ${front.length} \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439.`);
+  }
   console.log("doctor --fix: \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u044B\u0435 \u043F\u0440\u0430\u0432\u043A\u0438 \u043F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u044B.");
-  console.log("\u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F: elcrm update");
+  console.log("\u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F: elcrm update --fix --test");
 }
 
 // src/commands/build.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 
 // src/lib/nextVersion.ts
+init_pkg();
 async function nextVersion() {
   const pkg = readPackageJson();
   if (!pkg?.version) {
@@ -792,9 +2615,9 @@ async function nextVersion() {
 
 // src/commands/build.ts
 function resolveEntrypoint() {
-  if (existsSync7("./src/index.js"))
+  if (existsSync12("./src/index.js"))
     return "./src/index.js";
-  if (existsSync7("./src/index.ts"))
+  if (existsSync12("./src/index.ts"))
     return "./src/index.ts";
   return "./src/index.js";
 }
@@ -871,7 +2694,521 @@ async function cmdUuid() {
   console.log(crypto.randomUUID());
 }
 
+// src/commands/postbuild.ts
+import { resolve as resolve3 } from "path";
+
+// src/vite/postbuild.ts
+import {
+  existsSync as existsSync13,
+  readdirSync as readdirSync9,
+  readFileSync as readFileSync16,
+  rmSync,
+  statSync as statSync8,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { join as join13 } from "path";
+
+// src/vite/concat-css.ts
+import { readdirSync as readdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { join as join12 } from "path";
+function concatDistCss(options) {
+  const outFile = options.outFile ?? "index.css";
+  const files = readdirSync8(options.distDir).filter((f) => f.endsWith(".css") && f !== outFile).sort();
+  const css = files.map((f) => readFileSync15(join12(options.distDir, f), "utf8")).join(`
+`);
+  const outPath = join12(options.distDir, outFile);
+  writeFileSync6(outPath, css);
+  console.log(`[concat-css] ${files.length} \u0444\u0430\u0439\u043B\u043E\u0432 \u2192 ${outFile}`);
+  return outPath;
+}
+
+// src/vite/postbuild.ts
+function postbuildLib(options) {
+  const dist = options.distDir;
+  const keep = new Set([
+    "chunks",
+    "assets",
+    ...options.keepDirs ?? []
+  ]);
+  concatDistCss({
+    distDir: dist,
+    outFile: options.cssOutFile ?? "index.css"
+  });
+  for (const name of readdirSync9(dist)) {
+    const dir = join13(dist, name);
+    if (!statSync8(dir).isDirectory())
+      continue;
+    if (keep.has(name))
+      continue;
+    const impl = join13(dir, `${name}.d.ts`);
+    const nestedIndex = join13(dir, "index.d.ts");
+    const flat = join13(dist, `${name}.d.ts`);
+    const src = existsSync13(impl) ? impl : existsSync13(nestedIndex) ? nestedIndex : null;
+    if (src) {
+      const text = readFileSync16(src, "utf8").replace(/from ['"]\.\.\/([^'"]+)['"]/g, `from './$1'`);
+      writeFileSync7(flat, text);
+      console.log(`[postbuild] types \u2192 ${name}.d.ts`);
+    }
+    rmSync(dir, { recursive: true, force: true });
+    console.log(`[postbuild] removed nested dir: ${name}/`);
+  }
+}
+
+// src/commands/postbuild.ts
+async function cmdPostbuild(parsed) {
+  const dir = parsed.options.dir || "./dist";
+  const distDir = resolve3(process.cwd(), dir);
+  postbuildLib({ distDir });
+  console.log(`[postbuild] \u0433\u043E\u0442\u043E\u0432\u043E: ${distDir}`);
+}
+
+// src/commands/css.ts
+init_pkg();
+async function cmdCss(parsed) {
+  const cwd = parsed.options.dir || process.cwd();
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    console.error("package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D.");
+    process.exit(1);
+  }
+  const names = uniqueElcrmNames(listElcrmDeps(pkg));
+  if (!names.length) {
+    console.log("\u0417\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 @elcrm/* \u043D\u0435\u0442.");
+    return;
+  }
+  const dry = hasFlag(parsed, "dry");
+  console.log(`${dry ? "[dry] " : ""}\u041F\u0430\u043A\u0435\u0442\u044B: ${names.join(", ")}`);
+  try {
+    const result = syncElcrmCss({ cwd, pkgNames: names, dry });
+    console.log(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u0441\u0442\u0438\u043B\u0435\u0439: ${result.styleDir}`);
+    let total = 0;
+    for (const [file, tokens] of Object.entries(result.added)) {
+      if (!tokens.length) {
+        console.log(`  ${c.gray(file)}: \u0431\u0435\u0437 \u043D\u043E\u0432\u044B\u0445 \u0442\u043E\u043A\u0435\u043D\u043E\u0432`);
+        continue;
+      }
+      total += tokens.length;
+      console.log(`  ${c.green("+")} ${file}: ${tokens.length}`);
+      for (const t of tokens)
+        console.log(`      ${c.dim(t)}`);
+    }
+    if (result.imports.length) {
+      console.log(`  ${c.green("+")} elcrm.css @import:`);
+      for (const spec of result.imports)
+        console.log(`      ${c.dim(spec)}`);
+    }
+    if (result.skippedPkgs.length) {
+      console.log(`  ${c.gray("\u0431\u0435\u0437 CSS-\u0442\u043E\u043A\u0435\u043D\u043E\u0432:")} ${result.skippedPkgs.join(", ")}`);
+    }
+    if (total === 0 && result.imports.length === 0) {
+      console.log("\u0412\u0441\u0451 \u0443\u0436\u0435 \u043D\u0430 \u043C\u0435\u0441\u0442\u0435.");
+    } else if (dry) {
+      console.log("\u0417\u0430\u043F\u0438\u0441\u044C \u043D\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u043B\u0430\u0441\u044C (--dry).");
+    }
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : e);
+    process.exit(1);
+  }
+}
+
+// src/commands/audit.ts
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
+import { join as join14, relative as relative4 } from "path";
+init_pkg();
+init_walk();
+init_front();
+init_form_tokens();
+function scan(cwd) {
+  const out = [];
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    out.push({
+      level: "error",
+      code: "no-pkg",
+      message: "package.json \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D"
+    });
+    return out;
+  }
+  for (const section of ["dependencies", "devDependencies"]) {
+    const map = pkg[section];
+    if (!map)
+      continue;
+    for (const [name, ver] of Object.entries(map)) {
+      if (!name.startsWith("@elcrm/"))
+        continue;
+      if (typeof ver === "string" && ver.startsWith("file:")) {
+        out.push({
+          level: "warn",
+          code: "file-dep",
+          message: `${section}["${name}"] = ${ver} \u2014 \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u0443\u0439\u0442\u0435 \u0438\u043B\u0438 \u0437\u0430\u0444\u0438\u043A\u0441\u0438\u0440\u0443\u0439\u0442\u0435 sibling \u0432 README`,
+          fix: "elcrm update / publish \u043F\u0430\u043A\u0435\u0442\u0430"
+        });
+      }
+    }
+  }
+  const files = projectCodeRoots(cwd).flatMap((r) => walkCodeFiles(r));
+  for (const file of files) {
+    const text = readFileSync17(file, "utf8");
+    const rel2 = relative4(cwd, file);
+    const lines = text.split(/\r?\n/);
+    lines.forEach((line, i) => {
+      const n = i + 1;
+      if (/size\s*=\s*["']sm["']/.test(line) || /size\s*=\s*["']md["']/.test(line)) {
+        if (/titleSize/.test(line))
+          return;
+        out.push({
+          level: "warn",
+          code: "size-legacy",
+          message: 'size="sm"|"md" \u2192 "s"|"m"',
+          file: rel2,
+          line: n,
+          fix: "elcrm migrate size-sml"
+        });
+      }
+      if (/Modal\.Add\s*\(/.test(line)) {
+        out.push({
+          level: "warn",
+          code: "modal-add",
+          message: "Modal.Add \u2014 \u043F\u0440\u0435\u0434\u043F\u043E\u0447\u0442\u0438\u0442\u0435\u043B\u0435\u043D Modal.Create + Open",
+          file: rel2,
+          line: n,
+          fix: "elcrm migrate modal-create"
+        });
+      }
+      if (/key=\{Date\.now\(\)\}/.test(line) && /Modal/.test(text)) {
+        out.push({
+          level: "info",
+          code: "modal-date-key",
+          message: "key={Date.now()} \u0443 \u043C\u043E\u0434\u0430\u043B\u043A\u0438 \u2014 Create \u0437\u0430\u0434\u0430\u0451\u0442 \u0441\u0442\u0430\u0431\u0438\u043B\u044C\u043D\u044B\u0439 name",
+          file: rel2,
+          line: n
+        });
+      }
+      if (/--field-border-(?:focus|hover|error|disabled)\s*:\s*\d/.test(line) && /solid|dashed|dotted/i.test(line)) {
+        out.push({
+          level: "error",
+          code: "field-border-shorthand",
+          message: "hover/focus border \u2014 \u0442\u043E\u043B\u044C\u043A\u043E \u0446\u0432\u0435\u0442, \u043D\u0435 shorthand",
+          file: rel2,
+          line: n,
+          fix: "elcrm migrate field-border"
+        });
+      }
+      if (/!important/.test(line) && /drag|file-upload|DragDrop/i.test(rel2 + line)) {
+        out.push({
+          level: "info",
+          code: "dragdrop-important",
+          message: '!important \u0443 DragDrop \u2014 layout="fill"|"overlay" \u0432 @elcrm/form',
+          file: rel2,
+          line: n
+        });
+      }
+      if (/globalThis\.React\s*=/.test(line)) {
+        out.push({
+          level: "warn",
+          code: "react-global",
+          message: "globalThis.React \u0445\u0430\u043A \u2014 migrate legacy-hacks / \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u0435 modal",
+          file: rel2,
+          line: n,
+          fix: "elcrm migrate legacy-hacks"
+        });
+      }
+      if (/\b(ProgressField|ReadonlyField|OtpField|SegmentField|DragonDropField|TProgress)\b/.test(line)) {
+        out.push({
+          level: "error",
+          code: "form-alias",
+          message: "\u0443\u0441\u0442\u0430\u0440\u0435\u0432\u0448\u0438\u0439 \u0430\u043B\u0438\u0430\u0441 @elcrm/form (ProgressField/OtpField/\u2026) \u2192 \u043A\u0430\u043D\u043E\u043D",
+          file: rel2,
+          line: n,
+          fix: "elcrm migrate form-aliases"
+        });
+      }
+    });
+  }
+  const toolbarMarkers = files.filter((f) => {
+    if (!f.endsWith(".css"))
+      return false;
+    if (/theme(-light|-dark)?\.css$/.test(f))
+      return false;
+    const t = readFileSync17(f, "utf8");
+    return t.includes("--search-border:") && t.includes("--button-secondary-bg:") && t.includes("transparent");
+  });
+  if (toolbarMarkers.length > 1) {
+    out.push({
+      level: "info",
+      code: "toolbar-dup",
+      message: `\u043E\u0434\u0438\u043D\u0430\u043A\u043E\u0432\u044B\u0435 toolbar-\u0442\u043E\u043A\u0435\u043D\u044B \u0432 ${toolbarMarkers.length} \u0444\u0430\u0439\u043B\u0430\u0445 \u2014 \u043A\u043B\u0430\u0441\u0441 .el-toolbar-controls`,
+      fix: "\u043E\u0431\u0449\u0438\u0439 \u043A\u043B\u0430\u0441\u0441 + theme tokens"
+    });
+  }
+  const styleDir = ["src/style", "src/styles", "style"].map((d) => join14(cwd, d)).find(existsSync14);
+  if (styleDir && !existsSync14(join14(styleDir, "elcrm.css"))) {
+    out.push({
+      level: "info",
+      code: "elcrm-css",
+      message: "\u043D\u0435\u0442 elcrm.css \u2014 elcrm css \u0441\u043E\u0437\u0434\u0430\u0441\u0442 imports + \u0442\u043E\u043A\u0435\u043D\u044B",
+      fix: "elcrm css"
+    });
+  }
+  const depsForm = pkg.dependencies?.["@elcrm/form"] || pkg.devDependencies?.["@elcrm/form"];
+  if (depsForm && styleDir) {
+    const themeFiles = [
+      "theme-light.css",
+      "theme-dark.css",
+      "theme.css"
+    ].map((f) => join14(styleDir, f));
+    const themeText = themeFiles.filter(existsSync14).map((f) => readFileSync17(f, "utf8")).join(`
+`);
+    if (themeText && !/--popup-shadow\s*:/.test(themeText) && /--date-popup-shadow\s*:|--select-background\s*:/.test(themeText)) {
+      out.push({
+        level: "info",
+        code: "popup-shadow",
+        message: "\u043D\u0435\u0442 --popup-shadow \u0432 theme-* (\u043E\u0431\u0449\u0430\u044F \u0442\u0435\u043D\u044C \u043F\u043E\u043F\u0430\u043F\u043E\u0432 Date/Select/Color/Time)",
+        fix: "elcrm css   \u0438\u043B\u0438 elcrm update --fix"
+      });
+    }
+    if (themeText && !/--field-padding-block\s*:/.test(themeText) && /--field-note-padding\s*:|--control-inner-padding\s*:/.test(themeText)) {
+      out.push({
+        level: "warn",
+        code: "field-padding",
+        message: "\u0443\u0441\u0442\u0430\u0440\u0435\u0432\u0448\u0438\u0435 padding-\u0442\u043E\u043A\u0435\u043D\u044B \u2014 \u0435\u0434\u0438\u043D\u044B\u0439 --field-padding / --field-padding-block",
+        fix: "elcrm migrate form-tokens"
+      });
+    }
+  }
+  for (const file of files) {
+    if (!file.endsWith(".css"))
+      continue;
+    const text = readFileSync17(file, "utf8");
+    const relPath = relative4(cwd, file);
+    const lines = text.split(/\r?\n/);
+    lines.forEach((line, i) => {
+      if (/:\s*var\(\s*--field-padding/.test(line))
+        return;
+      if (lineHasDeprecatedFormToken(line)) {
+        out.push({
+          level: "warn",
+          code: "form-token-legacy",
+          message: "legacy form-\u0442\u043E\u043A\u0435\u043D \u2192 --field-padding* / --popup-shadow",
+          file: relPath,
+          line: i + 1,
+          fix: "elcrm migrate form-tokens"
+        });
+      }
+    });
+  }
+  return out;
+}
+function printFindings(findings) {
+  if (!findings.length) {
+    console.log(`${c.green("audit")}: \u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0439 \u043D\u0435\u0442.`);
+    return;
+  }
+  const icon = { error: c.red("\u2715"), warn: c.yellow("!"), info: c.cyan("i") };
+  for (const f of findings) {
+    const loc = f.file ? f.line ? `${f.file}:${f.line}` : f.file : "";
+    console.log(`${icon[f.level]} [${f.code}] ${f.message}${loc ? `  ${c.dim(loc)}` : ""}`);
+    if (f.fix)
+      console.log(`    ${c.dim("\u2192 " + f.fix)}`);
+  }
+  const err = findings.filter((f) => f.level === "error").length;
+  const warn = findings.filter((f) => f.level === "warn").length;
+  console.log(`
+\u0418\u0442\u043E\u0433\u043E: ${findings.length} (${err} error, ${warn} warn). \u0418\u0441\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435: elcrm audit --fix / elcrm migrate front`);
+}
+async function cmdAudit(parsed) {
+  const cwd = parsed.options.dir || process.cwd();
+  const fix = hasFlag(parsed, "fix");
+  const findings = scan(cwd);
+  printFindings(findings);
+  if (!fix) {
+    if (findings.some((f) => f.level === "error"))
+      process.exit(1);
+    return;
+  }
+  console.log(`
+${c.cyan("\u2192")} elcrm migrate front${hasFlag(parsed, "dry") ? " --dry" : ""}`);
+  const changes = await migrateFrontAll(cwd, hasFlag(parsed, "dry"));
+  if (!changes.length) {
+    console.log("\u0410\u0432\u0442\u043E\u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0439 \u043D\u0435 \u043F\u043E\u0442\u0440\u0435\u0431\u043E\u0432\u0430\u043B\u043E\u0441\u044C.");
+  } else {
+    for (const ch of changes) {
+      console.log(`  ${ch.file}: ${ch.detail}`);
+    }
+    console.log(hasFlag(parsed, "dry") ? `
+--dry: ${changes.length} \u043F\u043E\u0442\u0435\u043D\u0446\u0438\u0430\u043B\u044C\u043D\u044B\u0445 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439.` : `
+\u041F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u043E: ${changes.length}.`);
+  }
+  console.log("\u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F: elcrm css && elcrm doctor");
+}
+
+// src/commands/docs.ts
+import { join as join16, resolve as resolve4 } from "path";
+
+// src/lib/projectKind.ts
+function detectProjectKind(cwd) {
+  const pkg = readPkgAt(cwd);
+  if (!pkg)
+    return "front";
+  const workspaces = listWorkspaceDirs(cwd, pkg);
+  if (workspaces.length) {
+    const modes = new Set;
+    for (const dir of workspaces) {
+      const w = readPkgAt(dir);
+      if (w)
+        modes.add(detectTestMode(w));
+    }
+    if (modes.has("front") && modes.has("server"))
+      return "mixed";
+    if (modes.has("server") && !modes.has("front"))
+      return "server";
+    if (modes.has("front"))
+      return "front";
+  }
+  return hasElcrmServer(pkg) ? "server" : "front";
+}
+function isElcrmLibPackage(cwd) {
+  const pkg = readPkgAt(cwd);
+  const name = pkg?.name;
+  return typeof name === "string" && name.startsWith("@elcrm/");
+}
+
+// src/lib/elcrmDocsCatalog.ts
+var ALL_ELCRM_DOCS = [
+  "CLI.elCRM.md",
+  "API.elCRM.md",
+  "ALERT.elCRM.md",
+  "BUTTON.elCRM.md",
+  "MODAL.elCRM.md",
+  "NOTICE.elCRM.md",
+  "NOTIFICATIONS.elCRM.md",
+  "PASSKEY.elCRM.md",
+  "ROUTER.elCRM.md",
+  "SOCKET.elCRM.md",
+  "TOOLTIP.elCRM.md",
+  "ICONS.elCRM.md",
+  "FORM.elCRM.md",
+  "COMPONENTS.elCRM.md",
+  "SERVER.elCRM.md"
+];
+var SERVER_DOCS = [
+  "SERVER.elCRM.md",
+  "CLI.elCRM.md",
+  "API.elCRM.md",
+  "SOCKET.elCRM.md"
+];
+function docsForProject(kind, lib) {
+  if (lib || kind === "front" || kind === "mixed")
+    return ALL_ELCRM_DOCS;
+  return SERVER_DOCS;
+}
+
+// src/lib/scaffoldFiles.ts
+import {
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync10,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { dirname as dirname3, join as join15 } from "path";
+function writeScaffoldFile(dest, body, opts) {
+  if (opts.dry)
+    return "dry";
+  if (!opts.force && existsSync15(dest))
+    return "skip";
+  mkdirSync2(dirname3(dest), { recursive: true });
+  writeFileSync8(dest, body, "utf8");
+  return "write";
+}
+function readBundled(relPath) {
+  const full = join15(packageRoot(), "templates", relPath);
+  if (!existsSync15(full)) {
+    throw new Error(`\u0428\u0430\u0431\u043B\u043E\u043D \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${relPath}`);
+  }
+  return readFileSync18(full, "utf8");
+}
+
+// src/commands/docs.ts
+async function cmdDocs(parsed) {
+  const cwd = resolve4(parsed.options.dir || process.cwd());
+  const dry = hasFlag(parsed, "dry");
+  const force = hasFlag(parsed, "force") || !hasFlag(parsed, "keep");
+  const lib = hasFlag(parsed, "lib") || isElcrmLibPackage(cwd);
+  const kind = detectProjectKind(cwd);
+  const names = docsForProject(kind, lib);
+  console.log(`${dry ? "[dry] " : ""}elcrm docs \u2192 ${cwd}/docs  (${kind}${lib ? ", lib" : ""})`);
+  for (const name of names) {
+    const body = readBundled(join16("elcrm-docs", name));
+    const dest = join16(cwd, "docs", name);
+    const action = writeScaffoldFile(dest, body, { dry, force });
+    const mark = action === "write" ? c.green("+") : action === "skip" ? c.gray("=") : c.cyan("~");
+    console.log(`  ${mark} docs/${name}`);
+  }
+  if (kind === "server" && !lib) {
+    console.log(c.gray("\u0441\u0435\u0440\u0432\u0435\u0440: SERVER, CLI, API, SOCKET"));
+  }
+  console.log("\u0414\u0430\u043B\u044C\u0448\u0435: elcrm cursor \u2014 \u043F\u0440\u0430\u0432\u0438\u043B\u0430 \u0432 .cursor/rules (+ .cursor/docs)");
+}
+
+// src/commands/cursor.ts
+import { join as join17, resolve as resolve5 } from "path";
+var ALWAYS = ["elcrm.mdc", "elcrm-packages.mdc"];
+var UI = ["elcrm-ui.mdc", "elcrm-module.mdc", "elcrm-theme.mdc"];
+var SERVER = ["elcrm-server.mdc", "elcrm-rpc.mdc"];
+var LIB = ["elcrm-lib.mdc"];
+function writeOne(dest, body, dry, force, label) {
+  const action = writeScaffoldFile(dest, body, { dry, force });
+  const mark = action === "write" ? c.green("+") : action === "skip" ? c.gray("=") : c.cyan("~");
+  console.log(`  ${mark} ${label}`);
+}
+async function cmdCursor(parsed) {
+  const cwd = resolve5(parsed.options.dir || process.cwd());
+  const dry = hasFlag(parsed, "dry");
+  const force = hasFlag(parsed, "force") || !hasFlag(parsed, "keep");
+  const lib = hasFlag(parsed, "lib") || isElcrmLibPackage(cwd);
+  const kind = detectProjectKind(cwd);
+  const ruleNames = [
+    ...ALWAYS,
+    ...kind === "server" ? [] : UI,
+    ...kind === "front" ? [] : SERVER,
+    ...lib ? LIB : []
+  ];
+  console.log(`${dry ? "[dry] " : ""}elcrm cursor \u2192 ${cwd}/.cursor  (${kind}${lib ? ", lib" : ""})`);
+  for (const name of ruleNames) {
+    let body = readBundled(join17("elcrm-cursor", "rules", name));
+    if (kind === "server" && (name === "elcrm-server.mdc" || name === "elcrm-rpc.mdc")) {
+      body = body.replace("alwaysApply: false", "alwaysApply: true").replace(/^globs:.*\n/m, "");
+    }
+    writeOne(join17(cwd, ".cursor", "rules", name), body, dry, force, `.cursor/rules/${name}`);
+  }
+  const docs = docsForProject(kind, lib);
+  for (const name of docs) {
+    const body = readBundled(join17("elcrm-docs", name));
+    writeOne(join17(cwd, ".cursor", "docs", name), body, dry, force, `.cursor/docs/${name}`);
+  }
+  writeOne(join17(cwd, "AGENTS.md"), readBundled(join17("elcrm-cursor", "AGENTS.md")), dry, force, "AGENTS.md");
+  console.log(c.gray("\u0410\u0433\u0435\u043D\u0442: AGENTS.md + rules (\u0443\u0437\u043A\u0438\u0435 glob) + .cursor/docs. \u0421\u0434\u0430\u0447\u0430: elcrm test."));
+}
+
 // src/index.ts
+function cliVersion() {
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  for (const p of [
+    join18(here, "..", "package.json"),
+    join18(here, "package.json")
+  ]) {
+    try {
+      const v = JSON.parse(readFileSync19(p, "utf8")).version;
+      if (typeof v === "string" && v)
+        return v;
+    } catch {}
+  }
+  return "0.0.0";
+}
+function showVersion() {
+  console.log(`elcrm ${cliVersion()}`);
+}
 function showHelp() {
   console.log(`elcrm \u2014 CLI \u0434\u043B\u044F \u044D\u043A\u043E\u0441\u0438\u0441\u0442\u0435\u043C\u044B @elcrm/*
 
@@ -879,8 +3216,9 @@ function showHelp() {
   elcrm <\u043A\u043E\u043C\u0430\u043D\u0434\u0430> [\u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\u044B] [\u0444\u043B\u0430\u0433\u0438]
 
 \u041A\u043E\u043C\u0430\u043D\u0434\u044B:
-  update [--dry] [--core] [--no-install]
-      \u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0432\u0441\u0435 @elcrm/* \u0432 package.json \u0434\u043E latest (\u0438\u043B\u0438 pinned \u0438\u0437 @elcrm/core)
+  update [--dry] [--core] [--no-install] [--fix] [--test]
+      \u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0432\u0441\u0435 @elcrm/* \u0434\u043E latest; --fix = migrate front; --test = elcrm test
+      \u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0443\u0435\u0442\u0441\u044F: elcrm update --fix --test
 
   create <name> [--template app|lib|panel] [--no-install]
       \u0421\u043E\u0437\u0434\u0430\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442 \u0438\u0437 \u0448\u0430\u0431\u043B\u043E\u043D\u0430 (\u043A\u0430\u043A create-react-app)
@@ -891,33 +3229,80 @@ function showHelp() {
 
   migrate <name> [--dry]
   migrate --list
-      \u041C\u0438\u0433\u0440\u0430\u0446\u0438\u0438 \u043A\u043E\u0434\u0430/\u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439 (\u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 socket-server)
+      \u041C\u0438\u0433\u0440\u0430\u0446\u0438\u0438: front|ui, form-aliases, form-tokens, size-sml, field-border, modal-create, legacy-hacks, socket-server
+
+      audit [--fix] [--dry] [--dir=\u2026]
+      \u0423\u0441\u0442\u0430\u0440\u0435\u0432\u0448\u0438\u0439 API + CSS-\u0442\u043E\u043A\u0435\u043D\u044B form (padding-\u0430\u043B\u0438\u0430\u0441\u044B, popup-shadow, border shorthand)
+      --fix \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0435\u0442 migrate front
 
   doctor [--fix]
       \u041F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442 \u0438 \u043F\u0440\u0438 \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E\u0441\u0442\u0438 \u043F\u0440\u0438\u0432\u0435\u0441\u0442\u0438 \u043A \u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u0443
 
+  test [dir] [--front|--server] [--no-scripts]
+      \u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0438: @elcrm/server \u0432 package.json \u2192 server, \u0438\u043D\u0430\u0447\u0435 \u2192 front
+      (workspaces \u2014 \u043A\u0430\u0436\u0434\u044B\u0439 \u043F\u0430\u043A\u0435\u0442 \u0441\u0432\u043E\u0438\u043C \u0440\u0435\u0436\u0438\u043C\u043E\u043C)
+
   build [--client] [--url=\u2026] [--name=\u2026] [--dir=\u2026] [--folder=\u2026]
       \u0421\u0431\u043E\u0440\u043A\u0430 \u0438 \u0434\u0435\u043F\u043B\u043E\u0439 (\u0438\u0437 @elcrm/deploy)
 
+  postbuild [--dir=./dist]
+      \u041F\u043E\u0441\u043B\u0435 vite build lib-\u043F\u0430\u043A\u0435\u0442\u0430: \u0441\u043A\u043B\u0435\u0438\u0442\u044C CSS + \u0441\u043F\u043B\u044E\u0449\u0438\u0442\u044C .d.ts
+      (package.json: "build": "vite build && elcrm postbuild")
+
+  css [--dry] [--dir=\u2026]
+      \u0414\u0435\u0444\u043E\u043B\u0442\u043D\u044B\u0435 \u0442\u043E\u043A\u0435\u043D\u044B @elcrm/* \u2192 src/style/theme.css, theme-light/dark, elcrm.css
+      \u0423\u0436\u0435 \u0437\u0430\u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435 \u043D\u0435 \u0437\u0430\u0442\u0438\u0440\u0430\u044E\u0442\u0441\u044F, \u0442\u043E\u043B\u044C\u043A\u043E \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 (\u0433\u0440\u0443\u043F\u043F\u044B \u0447\u0435\u0440\u0435\u0437 \u043F\u0443\u0441\u0442\u0443\u044E \u0441\u0442\u0440\u043E\u043A\u0443)
+
+  docs [--dry] [--keep] [--dir=\u2026] [--lib]
+      docs/*.elCRM.md \u043F\u043E \u043F\u0430\u043A\u0435\u0442\u0430\u043C (cli, api, alert, button, modal, notice, \u2026)
+      \u0441\u0435\u0440\u0432\u0435\u0440-only \u2192 SERVER, CLI, API, SOCKET; --lib \u0438\u043B\u0438 \u043F\u0430\u043A\u0435\u0442 @elcrm/* \u2192 \u0432\u0441\u0435 \u0444\u0430\u0439\u043B\u044B
+
+  cursor [--dry] [--keep] [--dir=\u2026] [--lib|-lib]
+      .cursor/rules + .cursor/docs + AGENTS.md
+      --lib: \u0447\u0435\u043A\u043B\u0438\u0441\u0442 \u0430\u0432\u0442\u043E\u0440\u0430 \u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u0438 (\u043F\u043E\u0441\u043B\u0435 \u043F\u0440\u0430\u0432\u043E\u043A src \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C CLI-\u0448\u043F\u0430\u0440\u0433\u0430\u043B\u043A\u0438)
+
   uuid
       \u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C UUID
 
   help
       \u042D\u0442\u0430 \u0441\u043F\u0440\u0430\u0432\u043A\u0430
 
+\u0424\u043B\u0430\u0433\u0438:
+  -v, --version    \u0412\u0435\u0440\u0441\u0438\u044F CLI
+  -h, --help       \u0421\u043F\u0440\u0430\u0432\u043A\u0430
+
 \u041F\u0440\u0438\u043C\u0435\u0440\u044B:
+  elcrm -v
   elcrm update
   elcrm update --dry
+  elcrm update --fix --test
+  elcrm migrate form-aliases --dry
+  elcrm migrate form-tokens --dry
   elcrm create my-app --template app
   elcrm init --template panel
   elcrm init --template lib
-  elcrm migrate socket-server --dry
+  elcrm migrate front --dry
+  elcrm migrate size-sml
+  elcrm audit
+  elcrm audit --fix
   elcrm doctor --fix
+  elcrm test
+  elcrm test --server
   elcrm build --client --url=https://example.com/deploy
+  elcrm postbuild
+  elcrm css
+  elcrm css --dry
+  elcrm docs
+  elcrm cursor
+  elcrm cursor --lib
 `);
 }
 async function main() {
   const parsed = parseArgs();
+  if (hasFlag(parsed, "version", "v") || parsed.command === "version") {
+    showVersion();
+    return;
+  }
   if (hasFlag(parsed, "help", "h") || parsed.command === "help" || !parsed.command) {
     showHelp();
     return;
@@ -941,9 +3326,27 @@ async function main() {
     case "doctor":
       await cmdDoctor(parsed);
       break;
+    case "test":
+      await cmdTest(parsed);
+      break;
     case "build":
       await cmdBuild(parsed);
       break;
+    case "postbuild":
+      await cmdPostbuild(parsed);
+      break;
+    case "css":
+      await cmdCss(parsed);
+      break;
+    case "audit":
+      await cmdAudit(parsed);
+      break;
+    case "docs":
+      await cmdDocs(parsed);
+      break;
+    case "cursor":
+      await cmdCursor(parsed);
+      break;
     case "uuid":
       await cmdUuid();
       break;