diff --git a/CLAUDE.md b/CLAUDE.md
index 86b94f7..6d34365 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -51,3 +51,16 @@ git push origin master
 - Node.js/Express backend, SQLite (better-sqlite3, sync)
 - Frontend: vanilla JS, без бандлера
 - ast-index проиндексирован: `ast-index rebuild` при добавлении новых файлов
+
+## Feature: Конструктор симуляций (SimForge)
+
+Движок авторинга интерактивных 2D-симуляций из JSON-спеки (данные, НЕ код). План: `plans/sim-builder/`.
+
+### Phase 0 — Learnings
+
+- **Спека = данные.** Любое числовое свойство объекта = число ИЛИ строка-выражение. Выражения шарятся между людьми → движок безопасный, ⛔ без `eval`/`new Function`.
+- **`window.SimExpr`** (`frontend/js/labs/_sim_expr.js`): токенайзер → AST → evaluate. `compile(src)->{ast,fn,error}`; `fn(env)` НИКОГДА не бросает (NaN/∞/деление на 0 → 0). Whitelist: `+ - * / ^ %`, унарный `- + !`, сравнения `< <= > >= == !=`, логика `&& ||`, тернарник `?:`, функции `sin cos tan tg ctg cot asin..arctg sqrt abs exp ln log log2 log10 floor ceil round sign min max mod atan2 pow hypot`, константы `pi e tau`. Идентификаторы (вкл. точечные `obj.x`) — только из `env`. Парсер — расширение `y=f(x)` из `graph.js`; `-2^2 == 4` (парити). Также `evalSafe`, `compileValue`, `parse`, `tokenize`, `FUNCTIONS`, `CONSTANTS`.
+- **`window.SimEngine.mount(host, spec)`** (`_sim_engine.js`) → `{ play, pause, reset, setParam, getParam, isRunning, destroy, el }`. Canvas (мир→экран, равные оси, Y вверх) + KaTeX-оверлей подписей (`katex.renderToString`, как graph.js) + слайдеры из `params[]`. Выражения компилируются 1 раз в mount; в rAF — только evaluate. `env = { t, <params>, w, h, xmin..ymax, <objId>.x, <objId>.y }`. Объекты: `point segment vector circle rect polyline path label`. **Формат спеки v1 — в шапке `_sim_engine.js`.**
+- **`window.registerSpecSim(spec)`** (`_sim_adapter.js`): спека → манифест LabRegistry (ленивый хост `#sim-spec-host-<id>` в `#lab-sim`; `stop` прячет, `destroy` уничтожает). Так спек-сим открывается тем же путём, что рукописные ~40 (через `openSim` → реестр).
+- Демо `customdemo` — `_sim_demo.js`, за флагом `?simdemo=1` / `?sim=customdemo` / `LAB_SHOW_SPEC_DEMO` / localStorage `lab-spec-demo=1` (ученикам не светится).
+- Подключение: 3 каркасных `<script>` eager после `_graph_panel.js` в `lab.html`, демо — после `_register-all.js`. `_sim_deps.js` не трогать (каркас грузится до диспетчера).
diff --git a/frontend/js/labs/_sim_adapter.js b/frontend/js/labs/_sim_adapter.js
new file mode 100644
index 0000000..d3f21d0
--- /dev/null
+++ b/frontend/js/labs/_sim_adapter.js
@@ -0,0 +1,149 @@
+'use strict';
+/* ════════════════════════════════════════════════════════════════════════
+   registerSpecSim — адаптер: JSON-спека -> манифест LabRegistry (Фаза 0).
+
+   Строит манифест и регистрирует его в window.LabRegistry, чтобы спек-симуляция
+   открывалась тем же путём, что и ~40 рукописных симуляций (через openSim ->
+   реестр). Никаких правок чужих манифестов — только register().
+
+   Контракт LabRegistry-манифеста (см. _registry.js): { id, cat, title, desc,
+   preview, theory?, open(ctx), stop(), destroy() }.
+
+   Особенности интеграции с /lab:
+   - openSim() прячет все ИЗВЕСТНЫЕ ему тела (ALL_SIM_BODIES) и зовёт _pauseAllSims()
+     -> LabRegistry.stopActive() (наш stop спрячет наш хост). Спек-хосты openSim не
+     знает, поэтому при switch именно stop() прошлой активной спек-симуляции прячет её.
+   - Каждая спек-симуляция получает собственный хост-div внутри #lab-sim, создаётся
+     лениво при первом open и переиспользуется.
+   - Заголовок топбара ставим как делают рукописные _openX (sim-topbar-title).
+   ════════════════════════════════════════════════════════════════════════ */
+(function (global) {
+
+  var HOST_PREFIX = 'sim-spec-host-';
+
+  // Найти контейнер для тел симуляций (#lab-sim) — туда вставляем хост.
+  function simContainer() {
+    return document.getElementById('lab-sim') || document.body;
+  }
+
+  // Лениво создать/получить хост-элемент для данного id.
+  function ensureHost(id) {
+    var hid = HOST_PREFIX + id;
+    var el = document.getElementById(hid);
+    if (el) return el;
+    el = document.createElement('div');
+    el.id = hid;
+    el.className = 'sim-spec-host';
+    // занимает то же место, что .sim-body-wrap у рукописных симуляций
+    el.style.cssText = 'flex:1;min-height:0;display:none';
+    var cont = simContainer();
+    // вставить перед панелью теории, если она есть, иначе в конец
+    var theory = document.getElementById('theory-panel');
+    if (theory && theory.parentNode === cont) cont.insertBefore(el, theory);
+    else cont.appendChild(el);
+    return el;
+  }
+
+  // Спрятать все спек-хосты (на случай переключения с одной спеки на другую,
+  // когда openSim не знает наших хостов).
+  function hideAllSpecHosts() {
+    var nodes = document.querySelectorAll('.sim-spec-host');
+    for (var i = 0; i < nodes.length; i++) nodes[i].style.display = 'none';
+  }
+
+  function setTitle(spec) {
+    var t = document.getElementById('sim-topbar-title');
+    if (t) t.textContent = (spec.meta && spec.meta.title) || spec.title || 'Симуляция';
+  }
+
+  /* preview из спеки: если задана строка/функция — использовать; иначе
+     сгенерировать простой SVG-плейсхолдер с названием. */
+  function buildPreview(spec) {
+    if (spec.preview) return spec.preview;
+    var title = (spec.meta && spec.meta.title) || spec.title || 'Симуляция';
+    var bg = (spec.viewport && spec.viewport.bg) || '#0D0D1A';
+    return function () {
+      return '<svg class="sim-preview" viewBox="0 0 300 140" preserveAspectRatio="xMidYMid slice" xmlns="http://www.w3.org/2000/svg">' +
+        '<rect width="300" height="140" fill="' + _esc(bg) + '"/>' +
+        '<line x1="20" y1="120" x2="280" y2="120" stroke="rgba(255,255,255,0.25)" stroke-width="1.5"/>' +
+        '<line x1="30" y1="20" x2="30" y2="130" stroke="rgba(255,255,255,0.25)" stroke-width="1.5"/>' +
+        '<path d="M30 120 Q120 30 270 110" fill="none" stroke="#06D6E0" stroke-width="2.5"/>' +
+        '<circle cx="150" cy="64" r="5" fill="#9B5DE5"/>' +
+        '<text x="150" y="135" text-anchor="middle" fill="rgba(255,255,255,0.5)" font-size="10" font-family="Manrope,sans-serif">' +
+        _esc(title) + '</text></svg>';
+    };
+  }
+
+  function _esc(s) {
+    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;');
+  }
+
+  /* ── Главная функция ── */
+  function registerSpecSim(spec) {
+    if (!global.LabRegistry) {
+      if (global.console) console.warn('[registerSpecSim] LabRegistry недоступен');
+      return null;
+    }
+    if (!spec || !spec.id) {
+      if (global.console) console.warn('[registerSpecSim] спека без id');
+      return null;
+    }
+    var id = spec.id;
+    var _inst = null;  // активный SimEngine-инстанс этой симуляции
+
+    var manifest = {
+      id: id,
+      cat: spec.cat || 'phys',
+      title: (spec.meta && spec.meta.title) || spec.title || id,
+      desc: (spec.meta && spec.meta.desc) || spec.desc || '',
+      preview: buildPreview(spec),
+      theory: spec.theory || null,
+      subject: spec.subject,
+      grade: spec.grade,
+      topics: spec.topics,
+      _spec: spec, // храним исходную спеку (билдеру/доске пригодится)
+
+      open: function (ctx) {
+        hideAllSpecHosts();
+        var host = ensureHost(id);
+        host.style.display = 'flex';
+        setTitle(spec);
+        // пере-смонтировать заново на каждый open (чистое состояние)
+        if (_inst) { try { _inst.destroy(); } catch (e) {} _inst = null; }
+        host.innerHTML = '';
+        if (global.SimEngine) {
+          _inst = global.SimEngine.mount(host, spec);
+          manifest._instance = _inst;
+        } else if (global.console) {
+          console.warn('[registerSpecSim] SimEngine недоступен для', id);
+        }
+      },
+
+      stop: function () {
+        if (_inst) { try { _inst.pause(); } catch (e) {} }
+        var host = document.getElementById(HOST_PREFIX + id);
+        if (host) host.style.display = 'none';
+      },
+
+      destroy: function () {
+        if (_inst) { try { _inst.destroy(); } catch (e) {} _inst = null; }
+        manifest._instance = null;
+        var host = document.getElementById(HOST_PREFIX + id);
+        if (host) host.style.display = 'none';
+      },
+
+      // доступ к живому инстансу (доска онлайн-урока, билдер — Фазы 4/7)
+      instance: function () { return _inst; }
+    };
+
+    return global.LabRegistry.register(manifest);
+  }
+
+  global.registerSpecSim = registerSpecSim;
+  global.SimAdapter = {
+    register: registerSpecSim,
+    ensureHost: ensureHost,
+    hideAllSpecHosts: hideAllSpecHosts
+  };
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/frontend/js/labs/_sim_demo.js b/frontend/js/labs/_sim_demo.js
new file mode 100644
index 0000000..25e6765
--- /dev/null
+++ b/frontend/js/labs/_sim_demo.js
@@ -0,0 +1,112 @@
+'use strict';
+/* ════════════════════════════════════════════════════════════════════════
+   _sim_demo — рукописная демо-спека «Бросок тела» (projectile) для проверки
+   рантайма Фазы 0. Регистрируется как id 'customdemo' ТОЛЬКО за флагом — не
+   светится ученикам в каталоге (карточка не добавляется в SIMS).
+
+   Включение для проверки (любой из вариантов):
+     - URL:  /lab?simdemo=1   (или ?sim=customdemo прямой deep-link)
+     - глоб: window.LAB_SHOW_SPEC_DEMO = true (до загрузки labs-скриптов)
+     - localStorage.setItem('lab-spec-demo','1')
+
+   Проверка: открыть /lab?simdemo=1 -> карточка появится; либо открыть
+   /lab?sim=customdemo напрямую. Слайдеры угла/скорости меняют траекторию,
+   play/pause/reset работают. Это ВРЕМЕННЫЙ раздел (удалить после Фазы 4).
+   ════════════════════════════════════════════════════════════════════════ */
+(function (global) {
+  function demoEnabled() {
+    try {
+      var qs = (global.location && global.location.search) || '';
+      if (/[?&]simdemo=1\b/.test(qs)) return true;
+      if (/[?&]sim=customdemo\b/.test(qs)) return true;
+      if (global.LAB_SHOW_SPEC_DEMO === true) return true;
+      if (global.localStorage && global.localStorage.getItem('lab-spec-demo') === '1') return true;
+    } catch (e) { /* noop */ }
+    return false;
+  }
+
+  // Спека v1: бросок тела. g фиксирован 10 -> y = v*sin(θ)*t - 5*t^2.
+  var PROJECTILE_DEMO = {
+    id: 'customdemo',
+    cat: 'phys',
+    meta: { title: 'Демо: бросок тела', desc: 'Спек-симуляция (Фаза 0). Угол и скорость — слайдеры.' },
+    viewport: { xmin: 0, xmax: 60, ymin: 0, ymax: 30, grid: true, axes: true, bg: '#0D0D1A' },
+    time: { autoplay: false, loop: true, duration: 8, speed: 1 },
+    params: [
+      { name: 'theta', label: 'Угол θ', min: 0, max: 90, step: 1, value: 45, unit: '°' },
+      { name: 'v', label: 'Скорость v', min: 0, max: 30, step: 0.5, value: 20, unit: 'м/с' }
+    ],
+    objects: [
+      // снаряд: x = v*cos(θ)*t, y = v*sin(θ)*t - 5 t^2 (но не ниже 0)
+      {
+        id: 'ball', type: 'point',
+        x: 'v*cos(theta*pi/180)*t',
+        y: 'max(0, v*sin(theta*pi/180)*t - 5*t^2)',
+        r: 7, color: '#06D6E0', trail: true, trailColor: '#9B5DE5'
+      },
+      // вектор начальной скорости из старта
+      {
+        type: 'vector', x1: 0, y1: 0,
+        x2: 'cos(theta*pi/180)*v*0.4',
+        y2: 'sin(theta*pi/180)*v*0.4',
+        color: '#FFD166', width: 3
+      },
+      // земля
+      { type: 'segment', x1: 0, y1: 0, x2: 60, y2: 0, color: 'rgba(255,255,255,0.35)', width: 2 },
+      // подпись над снарядом
+      {
+        type: 'label', latex: true,
+        x: 'ball.x', y: 'ball.y + 2.5',
+        text: 'v_0', color: '#06D6E0', size: 15
+      }
+    ]
+  };
+
+  function tryRegister() {
+    if (!demoEnabled()) return;
+    if (typeof global.registerSpecSim !== 'function') {
+      if (global.console) console.warn('[sim-demo] registerSpecSim недоступен');
+      return;
+    }
+    global.registerSpecSim(PROJECTILE_DEMO);
+
+    // Если каталог уже отрисован, добавить карточку демо вручную (минимально-
+    // инвазивно: только когда флаг включён; не трогаем SIMS/каталожный рендер).
+    addDemoCardIfNeeded();
+  }
+
+  function addDemoCardIfNeeded() {
+    var grid = document.getElementById('sim-grid');
+    if (!grid) return;
+    if (document.getElementById('sim-card-customdemo')) return;
+    var m = global.LabRegistry && global.LabRegistry.get('customdemo');
+    if (!m) return;
+    var preview = global.LabRegistry.resolvePreview(m);
+    var card = document.createElement('div');
+    card.id = 'sim-card-customdemo';
+    card.className = 'sim-card';
+    card.setAttribute('onclick', "openSim('customdemo')");
+    card.innerHTML = preview +
+      '<div class="sim-body">' +
+      '<span class="sim-cat ' + (m.cat || 'phys') + '">демо</span>' +
+      '<div class="sim-title">' + esc(m.title) + '</div>' +
+      '<div class="sim-desc">' + esc(m.desc || '') + '</div>' +
+      '</div>';
+    grid.appendChild(card);
+  }
+
+  function esc(s) {
+    return String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+
+  // Зарегистрировать после готовности DOM/реестра. _register-all.js грузится
+  // последним (defer); этот файл — после него, поэтому LabRegistry уже есть.
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', tryRegister);
+  } else {
+    tryRegister();
+  }
+
+  // экспонируем для ручной проверки из консоли
+  global.LAB_SPEC_DEMO = PROJECTILE_DEMO;
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/frontend/js/labs/_sim_engine.js b/frontend/js/labs/_sim_engine.js
new file mode 100644
index 0000000..507ae65
--- /dev/null
+++ b/frontend/js/labs/_sim_engine.js
@@ -0,0 +1,616 @@
+'use strict';
+/* ════════════════════════════════════════════════════════════════════════
+   SimEngine — рантайм спек-симуляций конструктора (Фаза 0).
+
+   Берёт JSON-спеку (данные, не код) и монтирует интерактивную сцену в host:
+     - canvas для геометрии/объектов (мир→экран по viewport, ось Y вверх);
+     - оверлей-слой <div> для подписей с LaTeX (рендер через KaTeX — тем же путём,
+       что graph.js: katex.renderToString);
+     - панель контролов: слайдеры из spec.params[] + кнопки play/pause/reset.
+
+   Любое числовое свойство объекта может быть числом ИЛИ строкой-выражением.
+   Выражения компилируются ОДИН РАЗ при mount (через SimExpr), в rAF-цикле — только
+   evaluate по окружению env = { t, ...params, <obj>.x, <obj>.y, w, h }.
+
+   Никакого eval/new Function. Кривая формула не роняет цикл (SimExpr.evaluate -> 0).
+
+   ── ФОРМАТ СПЕКИ v1 ──────────────────────────────────────────────────────
+   {
+     specVersion: 1,
+     meta:   { title, desc },                       // подпись топбара/каталога
+     viewport: { xmin, xmax, ymin, ymax,            // мировые границы (мат. оси)
+                 grid?:true, axes?:true,
+                 bg?:'#0D0D1A' },
+     params: [                                       // слайдеры -> переменные env
+       { name:'v', label:'Скорость', min:0, max:30, step:0.5, value:18, unit:'м/с' },
+       { name:'theta', label:'Угол', min:0, max:90, step:1, value:45, unit:'°' }
+     ],
+     time:   { autoplay?:false, loop?:true, duration?:0, speed?:1 },  // t-цикл
+     objects: [                                      // числа ИЛИ строки-выражения
+       { id:'p', type:'point', x:'v*cos(theta*pi/180)*t', y:'...', r:6, color:'#06D6E0',
+         trail?:true, trailColor?:'#06D6E0' },
+       { type:'segment', x1:0,y1:0, x2:'p.x', y2:'p.y', color:'#fff', width:2 },
+       { type:'vector',  x1:..,y1:.., x2:..,y2:.., color, width },
+       { type:'circle',  x, y, r, color, fill?, width },
+       { type:'rect',    x, y, w, h, color, fill?, width },     // x,y = центр
+       { type:'polyline', points:[[x,y],...], color, width, closed? },
+       { type:'path',     points:[[x,y],...], ... },            // alias polyline
+       { type:'label',    x, y, text:'LaTeX', latex?:true, color, size?:14 }
+     ]
+   }
+   Выражения видят: t, все params по имени, w/h (мир-размер вьюпорта), а также
+   <objId>.x / <objId>.y для объектов, у которых заданы числовые/выраж. x,y.
+
+   ── API инстанса ──────────────────────────────────────────────────────────
+   var inst = SimEngine.mount(host, spec);
+     inst.play()  inst.pause()  inst.reset()
+     inst.setParam(name, value)
+     inst.getParam(name) -> number
+     inst.isRunning() -> bool
+     inst.destroy()
+     inst.el   -> корневой DOM-узел (для скрытия/показа адаптером)
+   ════════════════════════════════════════════════════════════════════════ */
+(function (global) {
+
+  var DEFAULT_BG = '#0D0D1A';
+
+  function num(v, dflt) { return typeof v === 'number' && isFinite(v) ? v : dflt; }
+
+  /* Компилятор свойства: число/строка -> { ev(env) } (всегда число). */
+  function bind(value, dflt) {
+    if (value === undefined || value === null) {
+      var d = dflt;
+      return { ev: function () { return d; }, constant: true };
+    }
+    var c = global.SimExpr ? global.SimExpr.compileValue(value)
+                           : { fn: function () { return num(value, dflt); }, constant: true };
+    return { ev: c.fn, constant: !!c.constant, error: c.error || null };
+  }
+
+  /* ════════════════════ Instance ════════════════════ */
+
+  function SimEngineInstance(host, spec) {
+    this.host = host;
+    this.spec = spec || {};
+    this.params = {};       // name -> текущее значение (number)
+    this._sliders = {};     // name -> input element
+    this._objs = [];        // подготовленные объекты с привязками
+    this._trails = {};      // objId -> [[x,y],...] (мир-координаты)
+    this._t = 0;
+    this._running = false;
+    this._raf = 0;
+    this._last = 0;
+    this._dpr = 1;
+    this._cw = 0; this._ch = 0;
+    this._destroyed = false;
+    this._ro = null;
+    this._build();
+  }
+
+  SimEngineInstance.prototype._vp = function () {
+    var v = this.spec.viewport || {};
+    return {
+      xmin: num(v.xmin, -1), xmax: num(v.xmax, 10),
+      ymin: num(v.ymin, -1), ymax: num(v.ymax, 10),
+      grid: v.grid !== false,
+      axes: v.axes !== false,
+      bg: v.bg || DEFAULT_BG
+    };
+  };
+
+  SimEngineInstance.prototype._build = function () {
+    var self = this;
+    var spec = this.spec;
+
+    // корень
+    var root = document.createElement('div');
+    root.className = 'sim-spec-root';
+    root.style.cssText = 'flex:1;min-height:0;display:flex;width:100%;height:100%;background:' +
+      (this._vp().bg) + ';color:#fff;font-family:Manrope,system-ui,sans-serif';
+    this.el = root;
+
+    // ── панель контролов слева ──
+    var panel = document.createElement('div');
+    panel.className = 'sim-spec-panel';
+    panel.style.cssText = 'width:260px;flex-shrink:0;background:rgba(13,13,26,0.92);' +
+      'border-right:1px solid rgba(255,255,255,0.08);display:flex;flex-direction:column;' +
+      'gap:10px;padding:16px 14px;overflow-y:auto';
+
+    // заголовок + кнопки play/pause/reset
+    var ctrlRow = document.createElement('div');
+    ctrlRow.style.cssText = 'display:flex;gap:6px;align-items:center';
+    var btnPlay = this._btn(this._playIcon(true), 'Запустить / пауза');
+    var btnReset = this._btn(this._resetIcon(), 'Сброс');
+    this._btnPlay = btnPlay;
+    btnPlay.addEventListener('click', function () { self._running ? self.pause() : self.play(); });
+    btnReset.addEventListener('click', function () { self.reset(); });
+    ctrlRow.appendChild(btnPlay);
+    ctrlRow.appendChild(btnReset);
+    panel.appendChild(ctrlRow);
+
+    // слайдеры параметров
+    var params = Array.isArray(spec.params) ? spec.params : [];
+    params.forEach(function (p) {
+      if (!p || !p.name) return;
+      var min = num(p.min, 0), max = num(p.max, 100), step = num(p.step, 1);
+      var val = num(p.value, min);
+      self.params[p.name] = val;
+
+      var wrap = document.createElement('div');
+      wrap.style.cssText = 'display:flex;flex-direction:column;gap:4px';
+
+      var lblRow = document.createElement('div');
+      lblRow.style.cssText = 'display:flex;justify-content:space-between;font-size:.74rem;color:rgba(255,255,255,.6)';
+      var lblName = document.createElement('span');
+      lblName.textContent = p.label || p.name;
+      var lblVal = document.createElement('span');
+      lblVal.style.cssText = 'color:#06D6E0;font-weight:700;font-variant-numeric:tabular-nums';
+      lblVal.textContent = _fmt(val) + (p.unit ? ' ' + p.unit : '');
+      lblRow.appendChild(lblName); lblRow.appendChild(lblVal);
+
+      var slider = document.createElement('input');
+      slider.type = 'range';
+      slider.min = String(min); slider.max = String(max); slider.step = String(step);
+      slider.value = String(val);
+      slider.style.cssText = 'width:100%;accent-color:#9B5DE5;cursor:pointer';
+      slider.addEventListener('input', function () {
+        var v = parseFloat(slider.value);
+        self.params[p.name] = v;
+        lblVal.textContent = _fmt(v) + (p.unit ? ' ' + p.unit : '');
+        if (!self._running) self._renderFrame(); // живой предпросмотр на паузе
+      });
+
+      wrap.appendChild(lblRow);
+      wrap.appendChild(slider);
+      panel.appendChild(wrap);
+      self._sliders[p.name] = slider;
+    });
+
+    // ── сцена справа (canvas + оверлей подписей) ──
+    var stage = document.createElement('div');
+    stage.className = 'sim-spec-stage';
+    stage.style.cssText = 'flex:1;min-width:0;position:relative;overflow:hidden';
+
+    var canvas = document.createElement('canvas');
+    canvas.style.cssText = 'position:absolute;inset:0;width:100%;height:100%;display:block';
+    stage.appendChild(canvas);
+    this.canvas = canvas;
+    this.ctx = canvas.getContext('2d');
+
+    var labels = document.createElement('div');
+    labels.className = 'sim-spec-labels';
+    labels.style.cssText = 'position:absolute;inset:0;pointer-events:none';
+    stage.appendChild(labels);
+    this._labelLayer = labels;
+
+    root.appendChild(panel);
+    root.appendChild(stage);
+    this.host.appendChild(root);
+
+    // подготовить объекты (компиляция привязок один раз)
+    this._prepareObjects();
+
+    // resize
+    if (global.ResizeObserver) {
+      this._ro = new ResizeObserver(function () { self._fit(); self._renderFrame(); });
+      this._ro.observe(stage);
+    }
+
+    // первичная подгонка после layout
+    requestAnimationFrame(function () {
+      self._fit();
+      self.reset();
+      var time = spec.time || {};
+      if (time.autoplay) self.play();
+    });
+  };
+
+  /* кнопка контрола (inline SVG, без эмодзи) */
+  SimEngineInstance.prototype._btn = function (innerSvg, title) {
+    var b = document.createElement('button');
+    b.title = title || '';
+    b.innerHTML = innerSvg;
+    b.style.cssText = 'min-width:34px;height:34px;border-radius:10px;border:1.5px solid rgba(255,255,255,.18);' +
+      'background:transparent;color:rgba(255,255,255,.75);cursor:pointer;display:flex;align-items:center;' +
+      'justify-content:center;padding:0 9px;transition:all .15s';
+    b.addEventListener('mouseenter', function () { b.style.borderColor = '#9B5DE5'; b.style.color = '#9B5DE5'; });
+    b.addEventListener('mouseleave', function () { b.style.borderColor = 'rgba(255,255,255,.18)'; b.style.color = 'rgba(255,255,255,.75)'; });
+    return b;
+  };
+  SimEngineInstance.prototype._playIcon = function (play) {
+    return play
+      ? '<svg viewBox="0 0 24 24" width="15" height="15" fill="currentColor"><polygon points="5 3 19 12 5 21 5 3"/></svg>'
+      : '<svg viewBox="0 0 24 24" width="15" height="15" fill="currentColor"><rect x="6" y="5" width="4" height="14"/><rect x="14" y="5" width="4" height="14"/></svg>';
+  };
+  SimEngineInstance.prototype._resetIcon = function () {
+    return '<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2.2"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>';
+  };
+  SimEngineInstance.prototype._syncPlayBtn = function () {
+    if (this._btnPlay) this._btnPlay.innerHTML = this._playIcon(!this._running);
+  };
+
+  /* Компиляция привязок объектов один раз. */
+  SimEngineInstance.prototype._prepareObjects = function () {
+    var raw = Array.isArray(this.spec.objects) ? this.spec.objects : [];
+    var out = [];
+    for (var i = 0; i < raw.length; i++) {
+      var o = raw[i] || {};
+      var type = o.type || 'point';
+      var prep = { id: o.id || ('obj' + i), type: type, raw: o, b: {} };
+
+      // общие визуальные поля (не привязки)
+      prep.color = o.color || '#06D6E0';
+      prep.fillColor = o.fill || o.fillColor || null;
+      prep.width = num(o.width, 2);
+      prep.trail = !!o.trail;
+      prep.trailColor = o.trailColor || prep.color;
+      prep.latex = o.latex !== false; // подписи по умолчанию рендерятся KaTeX
+      prep.size = num(o.size, 14);
+      prep.text = o.text != null ? String(o.text) : '';
+
+      // числовые/выражения-привязки по типу
+      var B = prep.b;
+      function bp(key, dflt) { B[key] = bind(o[key], dflt); }
+
+      if (type === 'point') { bp('x', 0); bp('y', 0); B.r = bind(o.r, 6); }
+      else if (type === 'segment' || type === 'vector') { bp('x1', 0); bp('y1', 0); bp('x2', 1); bp('y2', 1); }
+      else if (type === 'circle') { bp('x', 0); bp('y', 0); bp('r', 1); }
+      else if (type === 'rect') { bp('x', 0); bp('y', 0); bp('w', 1); bp('h', 1); }
+      else if (type === 'polyline' || type === 'path') {
+        prep.pts = (Array.isArray(o.points) ? o.points : []).map(function (pt) {
+          return { x: bind(pt[0], 0), y: bind(pt[1], 0) };
+        });
+        prep.closed = !!o.closed;
+      } else if (type === 'label') {
+        bp('x', 0); bp('y', 0);
+      }
+
+      // привязки для центра объекта (для obj.x/obj.y в env): point/circle/rect/label
+      if (B.x && B.y) { prep.hasCenter = true; }
+
+      out.push(prep);
+    }
+    this._objs = out;
+  };
+
+  /* Окружение для evaluate: t, params, w/h, и центры объектов (obj.x/obj.y). */
+  SimEngineInstance.prototype._buildEnv = function () {
+    var env = {};
+    var p = this.params;
+    for (var k in p) if (Object.prototype.hasOwnProperty.call(p, k)) env[k] = p[k];
+    env.t = this._t;
+    var vp = this._vp();
+    env.w = vp.xmax - vp.xmin;
+    env.h = vp.ymax - vp.ymin;
+    env.xmin = vp.xmin; env.xmax = vp.xmax; env.ymin = vp.ymin; env.ymax = vp.ymax;
+
+    // двухпроходно: центры объектов могут ссылаться друг на друга (одношагово,
+    // без рекурсии — для большинства сцен достаточно одного прохода).
+    for (var i = 0; i < this._objs.length; i++) {
+      var o = this._objs[i];
+      if (o.hasCenter) {
+        var x = o.b.x.ev(env);
+        var y = o.b.y.ev(env);
+        env[o.id + '.x'] = x;
+        env[o.id + '.y'] = y;
+      }
+    }
+    return env;
+  };
+
+  /* ── трансформация мир→экран (ось Y вверх) с сохранением пропорций ── */
+  SimEngineInstance.prototype._fit = function () {
+    var c = this.canvas; if (!c) return;
+    var dpr = Math.min(global.devicePixelRatio || 1, 2);
+    var stage = c.parentElement || c;
+    var r = stage.getBoundingClientRect();
+    var w = Math.max(1, Math.round(r.width));
+    var h = Math.max(1, Math.round(r.height));
+    this._dpr = dpr; this._cw = w; this._ch = h;
+    c.width = w * dpr; c.height = h * dpr;
+    if (this.ctx) this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+
+    // вычислить масштаб «вписать viewport, равные оси»
+    var vp = this._vp();
+    var vw = vp.xmax - vp.xmin || 1;
+    var vh = vp.ymax - vp.ymin || 1;
+    var pad = 16;
+    var sx = (w - pad * 2) / vw;
+    var sy = (h - pad * 2) / vh;
+    var s = Math.min(sx, sy);
+    this._scale = s;
+    // центр мира в центре canvas
+    var cxWorld = (vp.xmin + vp.xmax) / 2;
+    var cyWorld = (vp.ymin + vp.ymax) / 2;
+    this._offX = w / 2 - cxWorld * s;
+    this._offY = h / 2 + cyWorld * s; // +: т.к. Y инвертируется
+  };
+
+  SimEngineInstance.prototype._toPx = function (mx, my) {
+    return [this._offX + mx * this._scale, this._offY - my * this._scale];
+  };
+
+  /* ════════════════════ Рендер кадра ════════════════════ */
+  SimEngineInstance.prototype._renderFrame = function () {
+    var ctx = this.ctx; if (!ctx) return;
+    var W = this._cw, H = this._ch;
+    if (!W || !H) return;
+    var vp = this._vp();
+
+    ctx.fillStyle = vp.bg;
+    ctx.fillRect(0, 0, W, H);
+
+    if (vp.grid) this._drawGrid(ctx, W, H, vp);
+    if (vp.axes) this._drawAxes(ctx, W, H, vp);
+
+    var env = this._buildEnv();
+
+    // обновить трассы
+    for (var i = 0; i < this._objs.length; i++) {
+      var o = this._objs[i];
+      if (o.trail && o.hasCenter) {
+        var tx = env[o.id + '.x'], ty = env[o.id + '.y'];
+        if (typeof tx === 'number' && typeof ty === 'number') {
+          var arr = this._trails[o.id] || (this._trails[o.id] = []);
+          arr.push([tx, ty]);
+          if (arr.length > 2000) arr.shift();
+        }
+      }
+    }
+
+    // нарисовать трассы под объектами
+    for (var ti = 0; ti < this._objs.length; ti++) {
+      var ot = this._objs[ti];
+      if (ot.trail && this._trails[ot.id] && this._trails[ot.id].length > 1) {
+        this._drawTrail(ctx, this._trails[ot.id], ot.trailColor);
+      }
+    }
+
+    // объекты
+    this._labelLayer.innerHTML = '';
+    for (var j = 0; j < this._objs.length; j++) {
+      this._drawObject(ctx, this._objs[j], env);
+    }
+  };
+
+  SimEngineInstance.prototype._drawTrail = function (ctx, pts, color) {
+    ctx.save();
+    ctx.strokeStyle = color;
+    ctx.globalAlpha = 0.55;
+    ctx.lineWidth = 1.6;
+    ctx.lineJoin = 'round';
+    ctx.beginPath();
+    for (var i = 0; i < pts.length; i++) {
+      var px = this._toPx(pts[i][0], pts[i][1]);
+      i === 0 ? ctx.moveTo(px[0], px[1]) : ctx.lineTo(px[0], px[1]);
+    }
+    ctx.stroke();
+    ctx.restore();
+  };
+
+  SimEngineInstance.prototype._drawObject = function (ctx, o, env) {
+    var B = o.b;
+    switch (o.type) {
+      case 'point': {
+        var p = this._toPx(B.x.ev(env), B.y.ev(env));
+        // r точки — экранный радиус в пикселях (выражение допустимо)
+        var r = Math.max(1, B.r.ev(env) || 6);
+        ctx.save();
+        ctx.fillStyle = o.color;
+        ctx.shadowColor = o.color; ctx.shadowBlur = 8;
+        ctx.beginPath(); ctx.arc(p[0], p[1], r, 0, Math.PI * 2); ctx.fill();
+        ctx.restore();
+        break;
+      }
+      case 'segment':
+      case 'vector': {
+        var a = this._toPx(B.x1.ev(env), B.y1.ev(env));
+        var b = this._toPx(B.x2.ev(env), B.y2.ev(env));
+        ctx.save();
+        ctx.strokeStyle = o.color; ctx.lineWidth = o.width; ctx.lineCap = 'round';
+        ctx.beginPath(); ctx.moveTo(a[0], a[1]); ctx.lineTo(b[0], b[1]); ctx.stroke();
+        if (o.type === 'vector') this._arrowHead(ctx, a, b, o.color);
+        ctx.restore();
+        break;
+      }
+      case 'circle': {
+        var c0 = this._toPx(B.x.ev(env), B.y.ev(env));
+        var rad = Math.abs(B.r.ev(env)) * this._scale;
+        ctx.save();
+        ctx.strokeStyle = o.color; ctx.lineWidth = o.width;
+        if (o.fillColor) { ctx.fillStyle = o.fillColor; }
+        ctx.beginPath(); ctx.arc(c0[0], c0[1], rad, 0, Math.PI * 2);
+        if (o.fillColor) ctx.fill();
+        ctx.stroke();
+        ctx.restore();
+        break;
+      }
+      case 'rect': {
+        var cx = B.x.ev(env), cy = B.y.ev(env);
+        var rw = Math.abs(B.w.ev(env)), rh = Math.abs(B.h.ev(env));
+        var tl = this._toPx(cx - rw / 2, cy + rh / 2); // верх-лево (Y вверх)
+        var pw = rw * this._scale, ph = rh * this._scale;
+        ctx.save();
+        ctx.strokeStyle = o.color; ctx.lineWidth = o.width;
+        if (o.fillColor) { ctx.fillStyle = o.fillColor; ctx.fillRect(tl[0], tl[1], pw, ph); }
+        ctx.strokeRect(tl[0], tl[1], pw, ph);
+        ctx.restore();
+        break;
+      }
+      case 'polyline':
+      case 'path': {
+        if (!o.pts || !o.pts.length) break;
+        ctx.save();
+        ctx.strokeStyle = o.color; ctx.lineWidth = o.width; ctx.lineJoin = 'round'; ctx.lineCap = 'round';
+        if (o.fillColor) ctx.fillStyle = o.fillColor;
+        ctx.beginPath();
+        for (var k = 0; k < o.pts.length; k++) {
+          var pp = this._toPx(o.pts[k].x.ev(env), o.pts[k].y.ev(env));
+          k === 0 ? ctx.moveTo(pp[0], pp[1]) : ctx.lineTo(pp[0], pp[1]);
+        }
+        if (o.closed) ctx.closePath();
+        if (o.fillColor) ctx.fill();
+        ctx.stroke();
+        ctx.restore();
+        break;
+      }
+      case 'label': {
+        var lp = this._toPx(B.x.ev(env), B.y.ev(env));
+        this._drawLabel(o, lp[0], lp[1]);
+        break;
+      }
+    }
+  };
+
+  SimEngineInstance.prototype._arrowHead = function (ctx, a, b, color) {
+    var ang = Math.atan2(b[1] - a[1], b[0] - a[0]);
+    var s = 9;
+    ctx.save();
+    ctx.fillStyle = color;
+    ctx.translate(b[0], b[1]); ctx.rotate(ang);
+    ctx.beginPath();
+    ctx.moveTo(0, 0); ctx.lineTo(-s * 1.6, -s * 0.55); ctx.lineTo(-s * 1.6, s * 0.55);
+    ctx.closePath(); ctx.fill();
+    ctx.restore();
+  };
+
+  /* Подпись: KaTeX (тем же путём, что graph.js) с фолбэком на текст. */
+  SimEngineInstance.prototype._drawLabel = function (o, px, py) {
+    var el = document.createElement('div');
+    el.style.cssText = 'position:absolute;transform:translate(-50%,-50%);font-size:' + o.size +
+      'px;color:' + o.color + ';white-space:nowrap;text-shadow:0 1px 4px rgba(0,0,0,.6)';
+    el.style.left = px + 'px';
+    el.style.top = py + 'px';
+    var txt = o.text || '';
+    if (o.latex && typeof global.katex !== 'undefined' && txt) {
+      try {
+        el.innerHTML = global.katex.renderToString(txt, { throwOnError: false, strict: false, displayMode: false });
+      } catch (e) { el.textContent = txt; }
+    } else {
+      el.textContent = txt;
+    }
+    this._labelLayer.appendChild(el);
+  };
+
+  /* ── сетка/оси (мат. координаты, Y вверх) ── */
+  SimEngineInstance.prototype._drawGrid = function (ctx, W, H, vp) {
+    var step = this._niceStep(vp);
+    ctx.save();
+    ctx.strokeStyle = 'rgba(255,255,255,0.065)';
+    ctx.lineWidth = 1;
+    var x;
+    var x0 = Math.ceil(vp.xmin / step) * step;
+    for (x = x0; x <= vp.xmax + 1e-9; x += step) {
+      var pxv = this._toPx(x, 0)[0];
+      ctx.beginPath(); ctx.moveTo(pxv, 0); ctx.lineTo(pxv, H); ctx.stroke();
+    }
+    var y0 = Math.ceil(vp.ymin / step) * step, y;
+    for (y = y0; y <= vp.ymax + 1e-9; y += step) {
+      var pyv = this._toPx(0, y)[1];
+      ctx.beginPath(); ctx.moveTo(0, pyv); ctx.lineTo(W, pyv); ctx.stroke();
+    }
+    ctx.restore();
+  };
+
+  SimEngineInstance.prototype._niceStep = function (vp) {
+    var span = Math.max(vp.xmax - vp.xmin, vp.ymax - vp.ymin);
+    var raw = span / 10;
+    var p = Math.pow(10, Math.floor(Math.log10(raw || 1)));
+    var arr = [1, 2, 5, 10];
+    for (var i = 0; i < arr.length; i++) if (arr[i] * p >= raw) return arr[i] * p;
+    return p * 10;
+  };
+
+  SimEngineInstance.prototype._drawAxes = function (ctx, W, H, vp) {
+    var o = this._toPx(0, 0);
+    ctx.save();
+    ctx.strokeStyle = 'rgba(255,255,255,0.4)';
+    ctx.lineWidth = 1.5;
+    // ось X (если 0 в диапазоне Y)
+    if (0 >= vp.ymin && 0 <= vp.ymax) {
+      ctx.beginPath(); ctx.moveTo(0, o[1]); ctx.lineTo(W, o[1]); ctx.stroke();
+    }
+    // ось Y (если 0 в диапазоне X)
+    if (0 >= vp.xmin && 0 <= vp.xmax) {
+      ctx.beginPath(); ctx.moveTo(o[0], 0); ctx.lineTo(o[0], H); ctx.stroke();
+    }
+    ctx.restore();
+  };
+
+  /* ════════════════════ Жизненный цикл ════════════════════ */
+  SimEngineInstance.prototype.play = function () {
+    if (this._running || this._destroyed) return;
+    this._running = true;
+    this._syncPlayBtn();
+    var self = this;
+    var time = this.spec.time || {};
+    var speed = num(time.speed, 1);
+    var dur = num(time.duration, 0);
+    var loop = time.loop !== false;
+    this._last = (global.performance || Date).now();
+    function frame(now) {
+      if (!self._running) return;
+      var dt = Math.min((now - self._last) / 1000, 0.05) * speed;
+      self._last = now;
+      self._t += dt;
+      if (dur > 0 && self._t > dur) {
+        if (loop) { self._t = 0; self._trails = {}; }
+        else { self._t = dur; self._renderFrame(); self.pause(); return; }
+      }
+      self._renderFrame();
+      self._raf = global.requestAnimationFrame(frame);
+    }
+    this._raf = global.requestAnimationFrame(frame);
+  };
+
+  SimEngineInstance.prototype.pause = function () {
+    this._running = false;
+    if (this._raf) { global.cancelAnimationFrame(this._raf); this._raf = 0; }
+    this._syncPlayBtn();
+  };
+
+  SimEngineInstance.prototype.reset = function () {
+    this.pause();
+    this._t = 0;
+    this._trails = {};
+    this._renderFrame();
+  };
+
+  SimEngineInstance.prototype.setParam = function (name, value) {
+    var v = parseFloat(value);
+    if (!isFinite(v)) return;
+    this.params[name] = v;
+    var sl = this._sliders[name];
+    if (sl) { sl.value = String(v); sl.dispatchEvent(new Event('input')); }
+    else if (!this._running) this._renderFrame();
+  };
+
+  SimEngineInstance.prototype.getParam = function (name) { return this.params[name]; };
+  SimEngineInstance.prototype.isRunning = function () { return this._running; };
+
+  SimEngineInstance.prototype.destroy = function () {
+    this.pause();
+    this._destroyed = true;
+    if (this._ro) { try { this._ro.disconnect(); } catch (e) {} this._ro = null; }
+    if (this.el && this.el.parentNode) this.el.parentNode.removeChild(this.el);
+    this.el = null; this.canvas = null; this.ctx = null;
+  };
+
+  /* ── format helper ── */
+  function _fmt(v) {
+    if (!isFinite(v)) return '—';
+    if (Number.isInteger(v)) return String(v);
+    return parseFloat(v.toFixed(3)).toString();
+  }
+
+  /* ════════════════════ public ════════════════════ */
+  function mount(host, spec) {
+    if (!host) throw new Error('SimEngine.mount: нет host-элемента');
+    return new SimEngineInstance(host, spec || {});
+  }
+
+  global.SimEngine = {
+    mount: mount,
+    _Instance: SimEngineInstance   // экспонируем для тестов/билдера (Фаза 4)
+  };
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/frontend/js/labs/_sim_expr.js b/frontend/js/labs/_sim_expr.js
new file mode 100644
index 0000000..f397228
--- /dev/null
+++ b/frontend/js/labs/_sim_expr.js
@@ -0,0 +1,423 @@
+'use strict';
+/* ════════════════════════════════════════════════════════════════════════
+   SimExpr — безопасный движок выражений для конструктора симуляций (Фаза 0).
+
+   Спека симуляции — это ДАННЫЕ, которые шарятся между людьми, поэтому код
+   выражений НИКОГДА не исполняется через eval/new Function. Здесь — собственный
+   конвейер: токенайзер → AST → evaluate(ast, env). Логика расширяет парсер
+   y=f(x) из graph.js (тот же подход к токенам и неявному умножению), но:
+     - окружение многопеременное: любой идентификатор берётся из env (params, t,
+       значения объектов), а не только x;
+     - добавлены сравнения (< <= > >= == !=), логика (&& ||), тернарник ?:,
+       функции min/max/mod/log(base,x) и константы pi/e;
+     - результат компиляции — AST + замыкание fn(env), считается детерминированно.
+
+   Ошибки времени выполнения (деление на 0, NaN, неизвестный идентификатор) НЕ
+   кидаются из fn(env): они дают 0 (или флаг через evalSafe), чтобы один кривой
+   кадр не ронял весь рантайм. Ошибки КОМПИЛЯЦИИ (синтаксис) возвращаются строкой
+   в compile(src).error и не бросаются.
+
+   API:
+     SimExpr.compile(src) -> { ast, fn, error }
+         fn(env) -> number      (никогда не бросает; при сбое -> 0)
+     SimExpr.evaluate(ast, env) -> number   (никогда не бросает; при сбое -> 0)
+     SimExpr.evalSafe(ast, env) -> { value, error }   (для отладки/билдера)
+     SimExpr.FUNCTIONS  -> Set имён whitelisted-функций (для подсветки/билдера)
+     SimExpr.CONSTANTS  -> Set имён констант (pi, e)
+
+   env — простой объект { имя: number }. Имена объектов спеки удобно передавать
+   как "obj.x"/"obj.y" — для этого допускается точка в идентификаторе.
+   ════════════════════════════════════════════════════════════════════════ */
+(function (global) {
+
+  /* ── whitelist функций (имя -> арность: 1, 2 или -1 для переменной) ── */
+  // -1 => принимает >=1 аргумент (min/max). log: 1 арг = ln по основанию e? нет —
+  // log(x) трактуем как десятичный (как в graph.js log===log10), log(b,x)=log_b(x).
+  var FN_ARITY = {
+    sin: 1, cos: 1, tan: 1, tg: 1, ctg: 1, cot: 1,
+    asin: 1, acos: 1, atan: 1, arcsin: 1, arccos: 1, arctan: 1, arctg: 1,
+    sqrt: 1, abs: 1, exp: 1, ln: 1, log: -2, log2: 1, log10: 1,
+    floor: 1, ceil: 1, round: 1, sign: 1,
+    min: -1, max: -1, mod: 2, atan2: 2, pow: 2, hypot: -1
+  };
+
+  // Реализации. Все защищены от исключений на уровне evaluate (домены проверяются
+  // там, где можно дать NaN -> наружу станет 0).
+  var FN_IMPL = {
+    sin: Math.sin, cos: Math.cos, tan: Math.tan, tg: Math.tan,
+    ctg: function (x) { return 1 / Math.tan(x); },
+    cot: function (x) { return 1 / Math.tan(x); },
+    asin: Math.asin, acos: Math.acos, atan: Math.atan,
+    arcsin: Math.asin, arccos: Math.acos, arctan: Math.atan, arctg: Math.atan,
+    sqrt: Math.sqrt, abs: Math.abs, exp: Math.exp,
+    ln: Math.log,
+    log: function (a, b) {
+      // log(x) -> log10(x); log(base, x) -> log_base(x)
+      if (b === undefined) return Math.log(a) / Math.LN10;
+      return Math.log(b) / Math.log(a);
+    },
+    log2: Math.log2, log10: Math.log10,
+    floor: Math.floor, ceil: Math.ceil, round: Math.round, sign: Math.sign,
+    min: Math.min, max: Math.max,
+    mod: function (a, b) { return b === 0 ? 0 : a % b; },
+    atan2: Math.atan2, pow: Math.pow, hypot: Math.hypot
+  };
+
+  var CONSTANTS = { pi: Math.PI, PI: Math.PI, e: Math.E, E: Math.E, tau: Math.PI * 2 };
+
+  /* ════════════════════ TOKENIZER ════════════════════ */
+
+  function tokenize(src) {
+    var out = [];
+    var i = 0, n = src.length;
+    while (i < n) {
+      var ch = src[i];
+      if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') { i++; continue; }
+
+      /* число */
+      if ((ch >= '0' && ch <= '9') || (ch === '.' && src[i + 1] >= '0' && src[i + 1] <= '9')) {
+        var j = i;
+        while (j < n && src[j] >= '0' && src[j] <= '9') j++;
+        if (j < n && src[j] === '.') { j++; while (j < n && src[j] >= '0' && src[j] <= '9') j++; }
+        if (j < n && (src[j] === 'e' || src[j] === 'E')) {
+          var k = j + 1;
+          if (k < n && (src[k] === '+' || src[k] === '-')) k++;
+          if (k < n && src[k] >= '0' && src[k] <= '9') {
+            j = k; while (j < n && src[j] >= '0' && src[j] <= '9') j++;
+          }
+        }
+        out.push({ t: 'num', v: parseFloat(src.slice(i, j)) });
+        i = j; continue;
+      }
+
+      /* идентификатор (буквы/цифры/_/.) — точка допускает obj.x */
+      if (isIdentStart(ch)) {
+        var p = i + 1;
+        while (p < n && isIdentPart(src[p])) p++;
+        out.push({ t: 'id', v: src.slice(i, p) });
+        i = p; continue;
+      }
+
+      /* двухсимвольные операторы */
+      var two = src.substr(i, 2);
+      if (two === '<=' || two === '>=' || two === '==' || two === '!=' ||
+          two === '&&' || two === '||') {
+        out.push({ t: 'op', v: two }); i += 2; continue;
+      }
+
+      /* односимвольные операторы / скобки / запятая / ?: */
+      if ('+-*/^%()<>?:,'.indexOf(ch) !== -1) {
+        out.push({ t: 'op', v: ch }); i++; continue;
+      }
+      // одиночный '=' трактуем как сравнение (часто пишут a=b по привычке)
+      if (ch === '=') { out.push({ t: 'op', v: '==' }); i++; continue; }
+      // одиночный '!' — логическое НЕ
+      if (ch === '!') { out.push({ t: 'op', v: '!' }); i++; continue; }
+
+      throw new Error('Неизвестный символ: «' + ch + '»');
+    }
+    return out;
+  }
+
+  function isIdentStart(ch) {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
+  }
+  function isIdentPart(ch) {
+    return isIdentStart(ch) || (ch >= '0' && ch <= '9') || ch === '.';
+  }
+
+  /* Вставка неявного умножения: 2x -> 2*x, 2(.. -> 2*(.., )( -> )*(, )x -> )*x.
+     Функция перед '(' умножение НЕ получает. */
+  function insertImplicitMul(tokens) {
+    var out = [];
+    for (var i = 0; i < tokens.length; i++) {
+      out.push(tokens[i]);
+      var cur = tokens[i], nxt = tokens[i + 1];
+      if (!nxt) continue;
+      var curIsFn = cur.t === 'id' && Object.prototype.hasOwnProperty.call(FN_ARITY, cur.v);
+      var curEnds = cur.t === 'num' ||
+                    (cur.t === 'id' && !curIsFn) ||
+                    (cur.t === 'op' && cur.v === ')');
+      var nxtStarts = nxt.t === 'num' ||
+                      nxt.t === 'id' ||
+                      (nxt.t === 'op' && nxt.v === '(');
+      // не вставляем '*' если cur — функция (тогда дальше идёт её '(')
+      if (curEnds && nxtStarts) out.push({ t: 'op', v: '*' });
+    }
+    return out;
+  }
+
+  /* ════════════════════ PARSER (рекурсивный спуск -> AST) ════════════════════
+
+     Грамматика (по убыванию приоритета связывания):
+       ternary  := logicOr ('?' ternary ':' ternary)?
+       logicOr  := logicAnd ('||' logicAnd)*
+       logicAnd := compare ('&&' compare)*
+       compare  := addSub (('<'|'<='|'>'|'>='|'=='|'!=') addSub)?
+       addSub   := mulDiv (('+'|'-') mulDiv)*
+       mulDiv   := power (('*'|'/'|'%') power)*
+       power    := unary ('^' power)?            // правоассоциативно
+       unary    := ('-'|'+'|'!') unary | primary
+       primary  := num | ident | const | fn(args...) | '(' ternary ')'
+
+     Узлы AST:
+       { k:'num', v }
+       { k:'var', name }
+       { k:'const', v }
+       { k:'bin', op, a, b }
+       { k:'un', op, a }
+       { k:'cmp', op, a, b }
+       { k:'logic', op, a, b }
+       { k:'not', a }
+       { k:'cond', c, a, b }
+       { k:'call', name, args:[...] }
+  */
+
+  function parse(tokens) {
+    var pos = 0;
+    function peek() { return tokens[pos]; }
+    function next() { return tokens[pos++]; }
+    function expect(v) {
+      var t = peek();
+      if (!t || t.v !== v) throw new Error('Ожидалось «' + v + '»');
+      pos++;
+    }
+    function isOp(v) { var t = peek(); return t && t.t === 'op' && t.v === v; }
+
+    function ternary() {
+      var c = logicOr();
+      if (isOp('?')) {
+        next();
+        var a = ternary();
+        expect(':');
+        var b = ternary();
+        return { k: 'cond', c: c, a: a, b: b };
+      }
+      return c;
+    }
+    function logicOr() {
+      var l = logicAnd();
+      while (isOp('||')) { next(); l = { k: 'logic', op: '||', a: l, b: logicAnd() }; }
+      return l;
+    }
+    function logicAnd() {
+      var l = compare();
+      while (isOp('&&')) { next(); l = { k: 'logic', op: '&&', a: l, b: compare() }; }
+      return l;
+    }
+    function compare() {
+      var l = addSub();
+      var t = peek();
+      if (t && t.t === 'op' && (t.v === '<' || t.v === '<=' || t.v === '>' ||
+          t.v === '>=' || t.v === '==' || t.v === '!=')) {
+        var op = next().v;
+        return { k: 'cmp', op: op, a: l, b: addSub() };
+      }
+      return l;
+    }
+    function addSub() {
+      var l = mulDiv();
+      while (isOp('+') || isOp('-')) { var op = next().v; l = { k: 'bin', op: op, a: l, b: mulDiv() }; }
+      return l;
+    }
+    function mulDiv() {
+      var l = power();
+      while (isOp('*') || isOp('/') || isOp('%')) { var op = next().v; l = { k: 'bin', op: op, a: l, b: power() }; }
+      return l;
+    }
+    function power() {
+      var base = unary();
+      if (isOp('^')) { next(); return { k: 'bin', op: '^', a: base, b: power() }; }
+      return base;
+    }
+    function unary() {
+      if (isOp('-')) { next(); return { k: 'un', op: '-', a: unary() }; }
+      if (isOp('+')) { next(); return unary(); }
+      if (isOp('!')) { next(); return { k: 'not', a: unary() }; }
+      return primary();
+    }
+    function primary() {
+      var t = peek();
+      if (!t) throw new Error('Неожиданный конец выражения');
+
+      if (t.t === 'num') { next(); return { k: 'num', v: t.v }; }
+
+      if (t.t === 'id') {
+        next();
+        var name = t.v;
+        if (Object.prototype.hasOwnProperty.call(FN_ARITY, name)) {
+          expect('(');
+          var args = [];
+          if (!isOp(')')) {
+            args.push(ternary());
+            while (isOp(',')) { next(); args.push(ternary()); }
+          }
+          expect(')');
+          checkArity(name, args.length);
+          return { k: 'call', name: name, args: args };
+        }
+        if (Object.prototype.hasOwnProperty.call(CONSTANTS, name)) {
+          return { k: 'const', v: CONSTANTS[name] };
+        }
+        // переменная окружения
+        return { k: 'var', name: name };
+      }
+
+      if (t.t === 'op' && t.v === '(') {
+        next();
+        var e = ternary();
+        expect(')');
+        return e;
+      }
+
+      throw new Error('Неожиданный токен: «' + t.v + '»');
+    }
+
+    var ast = ternary();
+    if (pos !== tokens.length) throw new Error('Лишние токены после выражения');
+    return ast;
+  }
+
+  function checkArity(name, got) {
+    var ar = FN_ARITY[name];
+    if (ar === -1) { // >=1
+      if (got < 1) throw new Error('Функции «' + name + '» нужен хотя бы 1 аргумент');
+      return;
+    }
+    if (ar === -2) { // 1..2 (log)
+      if (got < 1 || got > 2) throw new Error('Функция «' + name + '» принимает 1 или 2 аргумента');
+      return;
+    }
+    if (got !== ar) throw new Error('Функция «' + name + '» принимает ' + ar + ' арг., дано ' + got);
+  }
+
+  /* ════════════════════ EVALUATE ════════════════════
+     Чистый интерпретатор AST по окружению env. НЕ бросает наружу (см. evaluate).
+     Внутренний _ev может вернуть NaN/Infinity — нормализуется в evaluate. */
+
+  function _ev(node, env) {
+    switch (node.k) {
+      case 'num': return node.v;
+      case 'const': return node.v;
+      case 'var': {
+        var val = env ? env[node.name] : undefined;
+        return typeof val === 'number' ? val : 0; // неизвестная переменная -> 0
+      }
+      case 'un': // только '-'
+        return -_ev(node.a, env);
+      case 'not':
+        return _ev(node.a, env) ? 0 : 1;
+      case 'bin': {
+        var a = _ev(node.a, env), b = _ev(node.b, env);
+        switch (node.op) {
+          case '+': return a + b;
+          case '-': return a - b;
+          case '*': return a * b;
+          case '/': return b === 0 ? 0 : a / b;       // деление на 0 -> 0
+          case '%': return b === 0 ? 0 : a % b;
+          case '^': return Math.pow(a, b);
+        }
+        return 0;
+      }
+      case 'cmp': {
+        var x = _ev(node.a, env), y = _ev(node.b, env);
+        switch (node.op) {
+          case '<': return x < y ? 1 : 0;
+          case '<=': return x <= y ? 1 : 0;
+          case '>': return x > y ? 1 : 0;
+          case '>=': return x >= y ? 1 : 0;
+          case '==': return x === y ? 1 : 0;
+          case '!=': return x !== y ? 1 : 0;
+        }
+        return 0;
+      }
+      case 'logic': {
+        if (node.op === '&&') return (_ev(node.a, env) && _ev(node.b, env)) ? 1 : 0;
+        return (_ev(node.a, env) || _ev(node.b, env)) ? 1 : 0;
+      }
+      case 'cond':
+        return _ev(node.c, env) ? _ev(node.a, env) : _ev(node.b, env);
+      case 'call': {
+        var fn = FN_IMPL[node.name];
+        var args = node.args;
+        if (args.length === 1) return fn(_ev(args[0], env));
+        if (args.length === 2) return fn(_ev(args[0], env), _ev(args[1], env));
+        // переменное число (min/max/hypot)
+        var vals = new Array(args.length);
+        for (var i = 0; i < args.length; i++) vals[i] = _ev(args[i], env);
+        return fn.apply(null, vals);
+      }
+    }
+    return 0;
+  }
+
+  // Никогда не бросает; NaN/Infinity -> 0.
+  function evaluate(ast, env) {
+    if (!ast) return 0;
+    var v;
+    try { v = _ev(ast, env); } catch (e) { return 0; }
+    return (typeof v === 'number' && isFinite(v)) ? v : 0;
+  }
+
+  // Для отладки/билдера: возвращает значение + флаг (NaN/Infinity -> error).
+  function evalSafe(ast, env) {
+    if (!ast) return { value: 0, error: 'нет выражения' };
+    var v;
+    try { v = _ev(ast, env); } catch (e) { return { value: 0, error: String(e.message || e) }; }
+    if (typeof v !== 'number' || !isFinite(v)) return { value: 0, error: 'не число (NaN/∞)' };
+    return { value: v, error: null };
+  }
+
+  /* ════════════════════ COMPILE ════════════════════
+     Возвращает { ast, fn, error }. Синтаксическая ошибка -> error:строка, fn:()=>0. */
+
+  function compile(src) {
+    if (src == null) return { ast: null, fn: function () { return 0; }, error: 'пустое выражение' };
+    var raw = String(src).trim();
+    // допускаем ведущее "y=" / "name=" (привычка), срезаем как в graph.js
+    raw = raw.replace(/^\s*[a-zA-Z_][a-zA-Z_0-9.]*\s*=(?![=])\s*/, '');
+    if (!raw) return { ast: null, fn: function () { return 0; }, error: 'пустое выражение' };
+    var ast;
+    try {
+      var toks = insertImplicitMul(tokenize(raw));
+      ast = parse(toks);
+    } catch (e) {
+      return { ast: null, fn: function () { return 0; }, error: String(e.message || e) };
+    }
+    var fn = function (env) { return evaluate(ast, env); };
+    return { ast: ast, fn: fn, error: null };
+  }
+
+  /* Хелпер: значение — число вернуть как есть; строка — скомпилировать и вернуть
+     { fn(env), error, constant }. Используется движком для свойств-привязок. */
+  function compileValue(value) {
+    if (typeof value === 'number') {
+      var c = value;
+      return { fn: function () { return c; }, error: null, constant: true, ast: { k: 'num', v: c } };
+    }
+    if (typeof value === 'string') {
+      var r = compile(value);
+      return { fn: r.fn, error: r.error, constant: false, ast: r.ast };
+    }
+    // прочие типы -> 0
+    return { fn: function () { return 0; }, error: null, constant: true, ast: { k: 'num', v: 0 } };
+  }
+
+  var FUNCTIONS = {}; // имя -> true (как «множество» без ES6 Set ради совместимости)
+  Object.keys(FN_ARITY).forEach(function (k) { FUNCTIONS[k] = true; });
+  var CONSTSET = {};
+  Object.keys(CONSTANTS).forEach(function (k) { CONSTSET[k] = true; });
+
+  global.SimExpr = {
+    compile: compile,
+    compileValue: compileValue,
+    evaluate: evaluate,
+    evalSafe: evalSafe,
+    tokenize: tokenize,           // экспортируем для тестов/билдера
+    parse: function (src) {       // удобный helper: строка -> AST (бросает при ошибке)
+      return parse(insertImplicitMul(tokenize(String(src).trim())));
+    },
+    FUNCTIONS: FUNCTIONS,
+    CONSTANTS: CONSTSET
+  };
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/plans/sim-builder/CONTEXT.md b/plans/sim-builder/CONTEXT.md
index 0430b1e..065b009 100644
--- a/plans/sim-builder/CONTEXT.md
+++ b/plans/sim-builder/CONTEXT.md
@@ -1,7 +1,13 @@
 # Feature Context: Конструктор симуляций (SimForge)
 
 ## Current State
-- Фаза 0 не начата. Ветка `feature/sim-builder` от `master`.
+- **Фаза 0 РЕАЛИЗОВАНА** (в рабочем дереве, не закоммичено — коммит за оркестратором). Ветка `feature/sim-builder` от `master`.
+  - `frontend/js/labs/_sim_expr.js` → `window.SimExpr` (безопасный движок выражений, без eval/Function; `compile/evaluate/evalSafe/compileValue/parse/tokenize`, whitelist + сравнения/логика/тернарник/multi-var env).
+  - `frontend/js/labs/_sim_engine.js` → `window.SimEngine.mount(host, spec) -> { play, pause, reset, setParam, getParam, isRunning, destroy, el }`. Canvas (мир→экран, Y вверх) + KaTeX-оверлей подписей + слайдеры/play/pause/reset. Формат спеки v1 задокументирован в шапке файла.
+  - `frontend/js/labs/_sim_adapter.js` → `window.registerSpecSim(spec)` / `window.SimAdapter` — строит манифест LabRegistry (ленивый хост `#sim-spec-host-<id>` в `#lab-sim`).
+  - `frontend/js/labs/_sim_demo.js` — демо `customdemo` (бросок тела) за флагом `?simdemo=1` / `?sim=customdemo` / `LAB_SHOW_SPEC_DEMO` / localStorage `lab-spec-demo=1`. Ученикам не светится.
+  - Подключение в `frontend/lab.html`: 3 каркасных модуля eager после `_graph_panel.js`, демо после `_register-all.js`. `_sim_deps.js` НЕ тронут.
+  - Верификация: `node --check` все 4 файла OK; eval/Function отсутствуют (только в комментариях); эмодзи нет; SimExpr self-test 29/30 (единственный «FAIL» `-2^2=4` — это парити с graph.js).
 - Лаборатория уже декларативна на уровне регистрации: `frontend/js/labs/_registry.js`
   (`LabRegistry.register/get/all/setActive/stop/destroy/resolvePreview`), манифест с
   `open(ctx)/mount(host)/stop/destroy`. ~40 симуляций — рукописные JS-модули в `frontend/js/labs/`.
@@ -37,6 +43,7 @@
 - Reuse > переписывание: сначала смотреть `_fx_motion`, `_graph_panel`, `graph.js`.
 
 ## RESUME STATE
-- Последний коммит фичи: — (ещё нет)
-- Текущая фаза: Phase 0 — Runtime core (Not Started)
+- Последний коммит фичи: — (Ф0 реализована, но ещё не закоммичена — ждёт оркестратора)
+- Текущая фаза: Phase 0 — Runtime core (✅ Implemented, pending commit) → дальше Phase 1 — Plots & interactions
 - Режим: Automated / Orchestrator / Incremental
+- Новые публичные API для следующих фаз: `window.SimExpr`, `window.SimEngine.mount`, `window.registerSpecSim` / `window.SimAdapter`. Формат спеки v1 — в шапке `_sim_engine.js` и в handoff phase-0.
diff --git a/plans/sim-builder/PLAN.md b/plans/sim-builder/PLAN.md
index 0e60784..26a6b9e 100644
--- a/plans/sim-builder/PLAN.md
+++ b/plans/sim-builder/PLAN.md
@@ -39,7 +39,7 @@
 
 ## Phases
 
-- [ ] Phase 0: Спека v1 + рантайм (формульные сцены) [domain: frontend] → [subplan](./phase-0-runtime-core.md)
+- [x] Phase 0: Спека v1 + рантайм (формульные сцены) [domain: frontend] → [subplan](./phase-0-runtime-core.md)
 - [ ] Phase 1: Графики + интеракции [domain: frontend] → [subplan](./phase-1-plots-interactions.md)
 - [ ] Phase 2: Физический интегратор [domain: frontend] → [subplan](./phase-2-physics.md)
 - [ ] Phase 3: БД + API (custom_sims) [domain: backend] → [subplan](./phase-3-persistence-api.md)
@@ -52,7 +52,7 @@
 
 | Phase | Domain | Status | Review | Build | Committed |
 |-------|--------|--------|--------|-------|-----------|
-| Phase 0: Runtime core | frontend | ⬜ Not Started | ⬜ | ⬜ | ⬜ |
+| Phase 0: Runtime core | frontend | ✅ Done | ✅ | ✅ | ✅ |
 | Phase 1: Plots & interactions | frontend | ⬜ Not Started | ⬜ | ⬜ | ⬜ |
 | Phase 2: Physics | frontend | ⬜ Not Started | ⬜ | ⬜ | ⬜ |
 | Phase 3: Persistence + API | backend | ⬜ Not Started | ⬜ | ⬜ | ⬜ |
diff --git a/plans/sim-builder/phase-0-runtime-core.md b/plans/sim-builder/phase-0-runtime-core.md
index 6bc6fdf..0a3e19e 100644
--- a/plans/sim-builder/phase-0-runtime-core.md
+++ b/plans/sim-builder/phase-0-runtime-core.md
@@ -1,6 +1,6 @@
 # Phase 0: Спека v1 + рантайм (формульные сцены)
 
-**Status:** ⬜ Not Started
+**Status:** ✅ Implemented (не закоммичено — коммит за оркестратором)
 **Parent plan:** [PLAN.md](./PLAN.md)
 **Domain:** frontend
 
@@ -9,16 +9,16 @@
 адаптер регистрации в `LabRegistry`. После фазы рукописная спека «брошенное тело» играет в /lab.
 
 ## Tasks
-- [ ] Задокументировать формат спеки v1 в шапке нового файла + в CONTEXT.md (params, objects, viewport, controls).
-- [ ] `frontend/js/labs/_sim_expr.js` — безопасный движок выражений: токенайзер → AST → `evaluate(ast, env)`. Whitelist математики (см. CONTEXT.md). Парсер расширяет логику `y=f(x)` из `graph.js` (посмотреть и переиспользовать, не дублировать). ⛔ без `eval`/`Function`. `compile(src) -> {fn(env), error}`.
-- [ ] `frontend/js/labs/_sim_engine.js` — `window.SimEngine.mount(host, spec)`:
-  - создаёт canvas (мир→экран трансформация по `viewport`) + оверлей-слой для подписей (KaTeX через существующий путь рендера формул);
-  - объекты: point|segment|vector|circle|rect|polyline|path|label (числовые свойства = число или строка-выражение, компилируются один раз);
-  - игровой цикл `requestAnimationFrame`: пересчёт `t`, перевычисление привязок, перерисовка;
-  - контролы: слайдеры-параметры (из `params[]`), кнопки play/pause/reset; API инстанса `{ play, pause, reset, setParam, destroy }`.
-- [ ] `frontend/js/labs/_sim_adapter.js` — `registerSpecSim(spec)` строит манифест LabRegistry (`open(ctx)` → `SimEngine.mount`, `stop/destroy`, `preview` из спеки) и регистрирует.
-- [ ] Фикстура-демо: рукописная спека «projectile» (угол/скорость слайдеры, точка x=v·cosθ·t, y=v·sinθ·t−5t²) — зарегистрировать как `customdemo` для проверки в /lab (за временным флагом/разделом, не светить ученикам).
-- [ ] Подключить новые файлы в /lab (lazy через существующий `_loader`/`_sim_deps` или прямыми тегами — выбрать минимально-инвазивно, не ломая старт).
+- [x] Задокументировать формат спеки v1 в шапке нового файла + в CONTEXT.md (params, objects, viewport, controls). → шапка `_sim_engine.js` (полный JSON-формат) + CONTEXT.md.
+- [x] `frontend/js/labs/_sim_expr.js` — безопасный движок выражений: токенайзер → AST → `evaluate(ast, env)`. Whitelist математики (см. CONTEXT.md). Парсер расширяет логику `y=f(x)` из `graph.js` (тот же подход к токенам/неявному умножению; добавлены сравнения, логика, тернарник, multi-var env, min/max/mod/log(b,x)). ⛔ без `eval`/`Function`. `compile(src) -> {ast, fn(env), error}`.
+- [x] `frontend/js/labs/_sim_engine.js` — `window.SimEngine.mount(host, spec)`:
+  - canvas с мир→экран (равные оси, вписан в viewport, Y вверх) + оверлей-слой `<div>` для подписей (KaTeX `renderToString`, как в graph.js);
+  - объекты: point|segment|vector|circle|rect|polyline|path|label (числовые свойства = число или строка-выражение, компилируются один раз в mount);
+  - rAF-цикл: `t += dt*speed`, loop/duration, перевычисление привязок, перерисовка, трассы (`trail`);
+  - контролы: слайдеры из `params[]` + play/pause/reset; API `{ play, pause, reset, setParam, getParam, isRunning, destroy, el }`.
+- [x] `frontend/js/labs/_sim_adapter.js` — `registerSpecSim(spec)` строит манифест LabRegistry (`open(ctx)` → ленивый собственный хост-div + `SimEngine.mount`; `stop` прячет хост+pause; `destroy` уничтожает инстанс; `preview` из спеки или авто-SVG) и регистрирует.
+- [x] Фикстура-демо: рукописная спека «projectile» (слайдеры θ 0..90 / v 0..30, точка x=v·cosθ·t, y=max(0, v·sinθ·t−5t²), вектор v0, земля, подпись) — зарегистрирована как `customdemo` за флагом `?simdemo=1` / `?sim=customdemo` / `LAB_SHOW_SPEC_DEMO` / localStorage `lab-spec-demo=1`. Ученикам не светится (карточки в SIMS нет; добавляется только при включённом флаге).
+- [x] Подключить новые файлы в /lab прямыми `<script>` (минимально-инвазивно): `_sim_expr/_sim_engine/_sim_adapter` — eager после `_graph_panel.js`; `_sim_demo` — после `_register-all.js`. Lazy-схема `_sim_deps` не тронута (каркасные модули должны быть до диспетчера). Старт /lab и ~40 симуляций не затронуты.
 
 ## Files to Modify/Create
 - `frontend/js/labs/_sim_expr.js` — движок выражений (new)
@@ -38,11 +38,40 @@
 - Производительность: компилировать выражения один раз при mount, в цикле только evaluate.
 
 ## Review Checklist
-- [ ] Все задачи выполнены
-- [ ] Нет eval/new Function в движке выражений
-- [ ] Нет эмодзи (только SVG .ic)
-- [ ] Старт /lab и существующие симуляции не регрессировали
-- [ ] Код в стиле проекта (vanilla, IIFE-модули labs/)
+- [x] Все задачи выполнены
+- [x] Нет eval/new Function в движке выражений (grep -nE "eval\(|new Function|Function\(" → только упоминания в комментариях, ни одного call-site)
+- [x] Нет эмодзи (скан: только ASCII + кириллица + θ/∞/box-drawing — те же баннеры, что в graph.js)
+- [x] Старт /lab и существующие симуляции не регрессировали (не тронуты SIMS/OPEN/манифесты; добавлены только новые `<script>` + register())
+- [x] Код в стиле проекта (vanilla, IIFE с экспортом в window.*, как _registry/_simbase/_graph_panel)
 
 ## Handoff to Next Phase
-<!-- Заполняет реализатор -->
+
+### Что готово (Phase 0)
+- **Движок выражений** `frontend/js/labs/_sim_expr.js` → `window.SimExpr`:
+  - `compile(src) -> { ast, fn, error }`. `fn(env) -> number`, НИКОГДА не бросает (NaN/∞/деление на 0 → 0). `error` — строка при синтаксической ошибке (не бросается).
+  - `evaluate(ast, env) -> number` (то же, безопасно), `evalSafe(ast, env) -> { value, error }` (для билдера/отладки — отличает NaN от валидного 0).
+  - `compileValue(value) -> { fn, error, constant, ast }` — число вернёт константу, строку скомпилирует (используется движком для свойств-привязок).
+  - `parse(src) -> ast` (бросает при ошибке), `tokenize(src)`, `FUNCTIONS` / `CONSTANTS` (объекты-«множества» имён, для подсветки в билдере).
+  - Whitelist: `+ - * / ^ %`, унарный `-`/`+`/`!`, скобки, сравнения `< <= > >= == !=`, логика `&& ||`, тернарник `?:`; функции `sin cos tan tg ctg cot asin acos atan arcsin arccos arctan arctg sqrt abs exp ln log(x|base,x) log2 log10 floor ceil round sign min max mod atan2 pow hypot`; константы `pi e tau`. Идентификаторы (вкл. точечные `obj.x`) берутся ТОЛЬКО из `env`.
+  - ⚠️ Степень право-ассоциативна, базой служит unary → `-2^2 == 4` (паритет с graph.js, задокументировано). Для `-(2^2)` писать скобки.
+  - Самопроверка: 29/30 логических кейсов PASS (единственный «FAIL» — `-2^2`, это и есть парити-поведение, не баг).
+- **Рантайм** `frontend/js/labs/_sim_engine.js` → `window.SimEngine`:
+  - `mount(host, spec) -> instance`. `instance`: `play() pause() reset() setParam(name,val) getParam(name) isRunning() destroy()` + поле `el` (корневой DOM для скрытия/показа).
+  - Сцена: панель слайдеров+play/pause/reset слева, `<canvas>` + оверлей `<div>` подписей справа. Мир→экран: равные оси, центрирование, Y вверх. Выражения компилируются 1 раз в mount; в rAF — только evaluate. `env` = `{ t, <params>, w, h, xmin/xmax/ymin/ymax, <objId>.x, <objId>.y }`.
+  - Объекты: `point segment vector circle rect polyline path label`. Подписи — KaTeX (фолбэк на текст). Трассы (`trail:true`).
+- **Адаптер** `frontend/js/labs/_sim_adapter.js` → `window.registerSpecSim(spec)` / `window.SimAdapter`:
+  - Строит манифест LabRegistry из спеки, кладёт `_spec`/`_instance`/`instance()` для будущих фаз. Каждая спек-симуляция получает ленивый хост `#sim-spec-host-<id>` внутри `#lab-sim`. `stop` прячет хост (важно при switch — openSim не знает наших хостов), `destroy` уничтожает инстанс.
+- **Демо** `frontend/js/labs/_sim_demo.js` — `customdemo` за флагом, для приёмки.
+- **Подключение** в `frontend/lab.html`: 3 каркасных `<script>` после `_graph_panel.js`, демо после `_register-all.js`.
+
+### Формат спеки v1 (поддержан фактически)
+`{ specVersion?, id, cat?, meta:{title,desc}, viewport:{xmin,xmax,ymin,ymax,grid?,axes?,bg?}, time:{autoplay?,loop?,duration?,speed?}, params:[{name,label,min,max,step,value,unit?}], objects:[{id?,type,...числа|строки-выражения, color?,fill?,width?,trail?,trailColor?,latex?,size?,text?,points?,closed?}], theory?, subject?,grade?,topics? }`
+Полная спецификация полей по типам объектов — в шапке `_sim_engine.js`.
+
+### Осталось на Фазу 1 / временные решения / риски
+- **Drag-интеракции, графики, оси-подписи с числами** — Фаза 1 (сейчас оси без числовых меток, есть сетка). `GraphPanelUI` из `_graph_panel.js` готов к переиспользованию для plots.
+- **Физика** (`body`/`physics`) — Фаза 2, объекты сейчас чисто кинематические (формульные).
+- **Однопроходный env для `obj.x/obj.y`**: центры объектов вычисляются в порядке объявления за один проход — взаимные ссылки «вперёд» (объект ссылается на тот, что объявлен ниже) дадут значение предыдущего кадра (или 0 на первом). Достаточно для типовых сцен; при необходимости в Ф1 сделать топосортировку/итерации.
+- **`r` точки** трактуется как экранный радиус в пикселях (не мир-единицы) — намеренно, чтобы точки не «таяли» при масштабе; для circle радиус мировой.
+- **Демо `customdemo`** — временный раздел, удалить/спрятать после билдера (Фаза 4). Карточка добавляется в каталог только при включённом флаге.
+- **Санитизация подписей/валидация спеки на сервере** — Фаза 3 (сейчас спеки только рукописные/локальные, в БД не идут).