diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7d1bc8a0f..fa747bfc2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,6 +6,11 @@ on: pull_request: merge_group: workflow_dispatch: + inputs: + profile_baseline: + description: 'Снять зарегистрированный размерный baseline PROFILE-01' + type: boolean + default: false permissions: contents: read @@ -21,6 +26,12 @@ env: COREPACK_DEFAULT_TO_LATEST: "0" jobs: + # Только явный baseline-запрос: обычный кандидат может менять runtime и + # не обязан совпадать с зарегистрированным старым источником PROFILE-01. + profile-baseline: + if: ${{ github.event_name == 'workflow_dispatch' && inputs.profile_baseline }} + uses: ./.github/workflows/profile-01.yml + verify: name: typecheck · build · size · package runs-on: ubuntu-latest @@ -180,6 +191,16 @@ jobs: - name: Fuzz · finiteness gate (virtual-time, seeded LCG, zero-dep) run: pnpm vitest run --reporter=verbose test/*finiteness-fuzz.test.ts + # Проверяем настоящий C/header/API на зарегистрированном Node, сохраняя + # обычный suite выше на текущем Node24. Это не performance calibration. + - name: Setup registered native-clock Node + uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v6 + with: + node-version: "24.19.0" + + - name: Native CPU clock · actual source and refusal controls + run: node test/fixtures/server-thread-cpu-clock-check.mjs + mutation: name: driver mutation runs-on: ubuntu-latest diff --git a/.github/workflows/profile-01.yml b/.github/workflows/profile-01.yml new file mode 100644 index 000000000..a5b4fe92f --- /dev/null +++ b/.github/workflows/profile-01.yml @@ -0,0 +1,121 @@ +name: PROFILE-01 — проверка размерного протокола + +# Размерный вектор вызывается вручную через ci.yml в той же среде, что обычный CI +# публичного репозитория. Время/GPU/энергия этой машины не являются device proof. +on: + workflow_call: + +permissions: + contents: read + +env: + COREPACK_ENABLE_DOWNLOAD_PROMPT: '0' + COREPACK_DEFAULT_TO_LATEST: '0' + PROFILE_SOURCE_SHA: ${{ github.event.pull_request.head.sha || github.sha }} + +jobs: + probe: + runs-on: ubuntu-latest + timeout-minutes: 45 + steps: + - name: Получить точный источник измерителя + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + ref: ${{ github.event.pull_request.head.sha || github.sha }} + persist-credentials: false + fetch-depth: 0 + + - name: Настроить Node + uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v6 + with: + node-version: '24' + + - name: Активировать закреплённый pnpm + run: | + corepack enable + corepack install --global pnpm@11.11.0 + + - name: Проверить точную версию протокола + shell: bash + run: | + set -euo pipefail + test "$(git rev-parse HEAD)" = "$PROFILE_SOURCE_SHA" + node --input-type=module <<'NODE' + import { PROFILE_01, preregistrationDigest, verifyPreregistration } from './bench/profile/profile-01-preregistration.mjs'; + verifyPreregistration(PROFILE_01); + if (PROFILE_01.candidateSamplesObservedAtRegistration !== false) { + throw new Error('preregistration обязана предшествовать samples'); + } + console.log(`preregistration digest: ${preregistrationDigest(PROFILE_01)}`); + NODE + + - name: Установить зависимости + run: pnpm install --frozen-lockfile + + - name: Измерить прежний размерный вектор + id: probe + shell: bash + run: | + set -euo pipefail + mkdir -p "$RUNNER_TEMP/profile-01-raw" + node bench/profile/probe-profile-01.mjs \ + --mode old-vector \ + --cells all \ + --out "$RUNNER_TEMP/profile-01-raw" + + - name: Независимо перепроверить raw-артефакт + if: ${{ !cancelled() && steps.probe.outcome != 'skipped' }} + shell: bash + run: | + set -euo pipefail + for raw in "$RUNNER_TEMP"/profile-01-raw/*.json; do + test -f "$raw" + node bench/profile/validate-profile-01.mjs --raw "$raw" + done + + - name: Проверить отказ внешнего validator на подменах настоящего результата + if: ${{ !cancelled() && steps.probe.outcome == 'success' }} + shell: bash + run: | + set -euo pipefail + node --input-type=module <<'NODE' + import assert from 'node:assert/strict'; + import { spawnSync } from 'node:child_process'; + import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'; + import { tmpdir } from 'node:os'; + import { join } from 'node:path'; + const rawDirectory = join(process.env.RUNNER_TEMP, 'profile-01-raw'); + const files = readdirSync(rawDirectory).filter(name => name.endsWith('.json')); + assert.equal(files.length, 1); + const original = JSON.parse(readFileSync(join(rawDirectory, files[0]), 'utf8')); + const directory = mkdtempSync(join(tmpdir(), 'profile-replay-mutations-')); + try { + const cases = [ + ['число', value => { value.costVector.scenarios[0].gzBytes += 1; }, 'scenarios не воспроизводится'], + ['identity', value => { value.head = '0'.repeat(40); }, 'baseProof не покрывает'], + ['клетки', value => { value.cellsUnproven = []; }, 'неизмеренные клетки потеряны'], + ]; + for (const [name, mutate, rejection] of cases) { + const value = structuredClone(original); + mutate(value); + const path = join(directory, 'mutated.json'); + writeFileSync(path, JSON.stringify(value)); + const run = spawnSync(process.execPath, ['bench/profile/validate-profile-01.mjs', '--raw', path], + { encoding: 'utf8', timeout: 180_000, maxBuffer: 8 * 1024 * 1024 }); + assert.equal(run.status, 1, `${name}: ${run.error ?? run.stderr}`); + assert.ok(run.stderr.includes(rejection), `${name}: неверная причина отказа: ${run.stderr}`); + console.log(`${name}: ожидаемый предметный отказ подтверждён`); + } + } finally { + rmSync(directory, { recursive: true, force: true }); + } + NODE + + - name: Опубликовать raw-артефакт + # Отрицательный результат сохраняется даже после отказа измерителя. + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + with: + name: profile-01-raw-${{ env.PROFILE_SOURCE_SHA }} + path: ${{ runner.temp }}/profile-01-raw/ + retention-days: 90 diff --git a/.gitignore b/.gitignore index 05445d57f..bb36dba18 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,7 @@ blob-report .playwright browser/.artifacts site/dist +examples/reading-shelf/.artifacts +examples/itinerary-sheet/.artifacts +examples/call-sheet/.artifacts +examples/audio-cue/.artifacts diff --git a/CHANGELOG.md b/CHANGELOG.md index 1bd2df642..424b0a001 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,28 @@ ## [Unreleased] ### Исправлено +- `CompositorSpring`: синхронный callback во время передачи движения композитору + сохраняет новую цель, остановку или уничтожение. Устаревшая передача больше + не подменяет новое состояние живого движения. +- `animate`: завершённые controls освобождают исполнителей, а завершённый + compositor-слот освобождает кривую и live-delegate даже при активном sibling. + Вложенный handoff из getter `requestFrame` сохраняет один кадровый цикл + после частичного host-отказа и в минифицированном npm-пакете. +- `MotionValue` и подписки `./behaviors`: уничтожение освобождает внедрённый + scheduler и callback компонента даже при сохранённых controller/off handles. + Живые подписки сохраняют дедупликацию callback; `stop()` остаётся возобновляемым. +- `MotionValue`: отзыв подписки освобождает callback; старая отписка не удаляет + повторную регистрацию. Callback нового запуска не теряется при перезапуске + из getter или слушателя до возврата прежнего tick. +- `./svelte`: повторная подписка использует текущую регистрацию; отписка и + `destroy()` освобождают её callback, а старый handle не затрагивает преемника. +- `MotionValue` после `destroy()` освобождает пользовательские `spring` и `requestFrame`, + не принимает новые подписки и не продолжает кадр или планирование после уничтожения + из getter или callback `requestFrame`. `CompositorSpring` и follow-контроллер освобождают + исходный `spring`; инертный handoff больше не читает его getters. +- `./vue`: остановка `effectScope` освобождает активные `useMotionValue` и + `useSpring`, включая уже поставленные кадры. Уборка при unmount в Vue 3.0/3.1 + и явный `MotionValue.destroy()` вне scope сохранены. - `./behaviors`: изменение snap-точек или размеров страниц сохраняет текущего владельца движения. Отмена и уничтожение из подписчика прекращают последующую доводку, планирование кадров и внешнее уведомление о закрытии. @@ -18,6 +40,10 @@ публичные типы не расширены. ### Добавлено +- `CompositorSpring.handoffToCompositor(target)` завершает интерактивную live-фазу + автономным переходом с текущей позиции и скорости. Старый MotionValue становится + инертным после успешного native commit; неподдержанная форма продолжает live-путь. + Исполняемые примеры sheet и pager оставляют выбор snap/page и геометрию компоненту. - Управляемое присутствие: `createPresenceTransition` связывает одну цель видимости с группой анимаций, отменяет устаревший уход и освобождает исполнителей при очистке. Рабочий пример диалога поддерживает повторное открытие и Escape без ручного `done`. diff --git a/README.md b/README.md index 68d9cd563..97ad79cea 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,8 @@ spring-солвер, кейфреймы, инерция, FLIP) отделена pnpm add @labpics/motion ``` -Node ≥ 22, ESM и CJS, типы в комплекте. Фреймворк для биндинга — optional +Серверная среда — Node ≥ 22; браузерная — ES2022 со встроенным `WeakRef`. +ESM и CJS, типы в комплекте. Фреймворк для биндинга — optional peer. Git-установка не поддерживается (`dist/` собирается, в репозитории его нет) — установка из тарбола описана в [справочнике](docs/api.md). @@ -111,11 +112,11 @@ pnpm site:preview # отдаёт site/dist на локальном серве ## Карта пакета Импорт — `@labpics/motion` (ядро) или `@labpics/motion/<субпуть>`. -Корневой экспорт + 43 субпути (входов `exports` в `package.json` — 44): +Корневой экспорт + 44 субпути (входов `exports` в `package.json` — 45): | Группа | Субпути | | --- | --- | -| Ядро анимации | `./nano` (WAAPI ≤ 1 КБ), `./animate` (one-liner фасад), `./frame`, `./driver`, `./compositor`, `./compositor/stagger`, `./waapi`, `./auto` | +| Ядро анимации | `./nano` (WAAPI ≤ 1 КБ), `./animate` (one-liner фасад), `./frame`, `./driver`, `./compositor`, `./compositor/stagger`, `./compositor/follow`, `./waapi`, `./auto` | | Значения и физика | `./value`, `./spring`, `./decay`, `./easing`, `./keyframes`, `./stagger`, `./timeline`, `./presets`, `./tokens`, `./utils` | | Доменные эффекты | `./bindings`, `./flip`, `./projection`, `./smart`, `./gestures`, `./behaviors`, `./behaviors/reorder`, `./scroll`, `./in-view`, `./presence`, `./svg`, `./svg-morph`, `./a11y`, `./compiler/surface` (приватный executor compiled-поверхности) | | Биндинги | `./react`, `./preact`, `./vue`, `./svelte`, `./solid`, `./angular`, `./qwik`, `./lit`, `./wc` | @@ -200,7 +201,7 @@ springFromDurationBounce(0.35, 0); // восприятие (duration, bounce) | Раздел | Что внутри | | --- | --- | | [Рецепты](docs/recipes.md) | Runnable-интеграции: drag, FLIP, presence, скролл, bottom sheet | -| [Справочник API](docs/api.md) | Все 43 субпути: что даёт каждый вход | +| [Справочник API](docs/api.md) | Все 44 субпути: что даёт каждый вход | | [Архитектура](docs/architecture.md) | Слои движка, фазовая модель, инварианты, отвергнутые пути | | [Compositor](docs/compositor.md) | WAAPI-план, ретаргет, хендофф, fallback-матрица, поддержка браузеров | | [Projection](docs/projection.md) | Вложенный FLIP: дерево узлов, C¹-перехваты, не-цели v1 | diff --git a/bench/compare/bench.mjs b/bench/compare/bench.mjs index ce87c13b9..33f37e096 100644 --- a/bench/compare/bench.mjs +++ b/bench/compare/bench.mjs @@ -29,11 +29,9 @@ import { } from 'node:fs'; import os from 'node:os'; import { createServer } from 'node:http'; +import { createRequire } from 'node:module'; import path from 'node:path'; import { fileURLToPath, pathToFileURL } from 'node:url'; -import esbuild from 'esbuild'; -import { chromium } from 'playwright'; -import { PNG } from 'pngjs'; import { canonicalGzip, observationalBrotli, @@ -83,6 +81,9 @@ import { S5_MOTION_CONTRACT } from './motion-conformance.mjs'; const __dirname = path.dirname(fileURLToPath(import.meta.url)); const ROOT = path.resolve(__dirname, '..', '..'); +// Чистые проверки семантики не требуют отдельной установки браузерного стенда. +// Его зависимости остаются обязательными при фактической сборке и измерениях. +const requireBenchmark = createRequire(import.meta.url); const RUNS = parseBenchCount('BENCH_RUNS', process.env.BENCH_RUNS, 20, { min: 20, max: 60 }); const ORDER_SEED = 0x51f15e; const BOOTSTRAP_ITERATIONS = 10_000; @@ -140,7 +141,7 @@ function libVersion(lib, rootPkg) { function buildAdapter(lib) { const outfile = path.join(__dirname, 'results', `.${lib.id}.iife.js`); - esbuild.buildSync({ + requireBenchmark('esbuild').buildSync({ ...PRODUCTION_ADAPTER_PROFILE, entryPoints: [path.join(__dirname, lib.entry)], format: 'iife', @@ -153,7 +154,7 @@ function buildAdapter(lib) { /** import-cost: один ESM+minify артефакт, затем gzip-9 и Brotli-11. */ function measureSize(lib) { - const res = esbuild.buildSync({ + const res = requireBenchmark('esbuild').buildSync({ ...PRODUCTION_ADAPTER_PROFILE, entryPoints: [path.join(__dirname, lib.entry)], format: 'esm', @@ -438,51 +439,110 @@ async function runColdStartCost(page, scenario) { } /** Untimed oracle проверяет всю топологию, а не одного выжившего target. */ -async function runSemanticStartCheck(page, scenario, calls) { +export async function runSemanticStartCheck(page, scenario, calls) { const evidence = await page.evaluate(async ({ config, calls: expectedCalls }) => { const A = window.__adapterModule; - const groups = Array.from({ length: expectedCalls }, () => ( - Array.from({ length: config.targetsPerCall }, () => { - const element = document.createElement('div'); - element.className = 'box'; - document.body.appendChild(element); - return element; - }) - )); - const epoch = performance.now(); - const callStartedAtMs = []; - const controls = groups.map((elements) => { - callStartedAtMs.push(performance.now() - epoch); - return config.staggerGapMs > 0 - ? A.startStagger(elements, config.toPx, config.durationMs, config.staggerGapMs) - : A.start(elements, config.toPx, config.durationMs); - }); + const groups = [], callStartedAtMs = [], controls = [], checkpoints = [], terminal = [], failures = []; + const onset = config.requireFreshStart ? { before: [], after: [] } : undefined; + let phase = 'setup', epoch; + const failed = (error, location) => failures.push({ phase: location, name: error?.name ?? typeof error, message: String(error?.message ?? error) }); const delaySpan = config.staggerGapMs * (config.targetsPerCall - 1); const checkpointTimes = config.staggerGapMs > 0 - ? [0.2, 0.5, 0.8].map((fraction) => delaySpan * fraction) - : [config.durationMs * 0.25]; - const checkpoints = []; - for (const checkpointTime of checkpointTimes) { - const remaining = checkpointTime - (performance.now() - epoch); + ? [0.2, 0.5, 0.8].map((fraction) => Math.min(config.durationMs, delaySpan) * fraction) + : [config.durationMs * 0.25, config.durationMs * 0.5, config.durationMs * 0.625]; + try { + for (let call = 0; call < expectedCalls; call++) { + const elements = []; groups.push(elements); + for (let target = 0; target < config.targetsPerCall; target++) { + const element = document.createElement('div'); elements.push(element); + element.className = 'box'; document.body.appendChild(element); + } + } + epoch = performance.now(); + if (onset) { + phase = 'onset-before'; + for (const elements of groups) { + const group = { readStartedMs: performance.now() - epoch, positions: [] }; onset.before.push(group); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame = { beforeMs: typeof value === 'number' ? value - epoch : value ?? null }; + } + for (const element of elements) group.positions.push(new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame.afterMs = typeof value === 'number' ? value - epoch : value ?? null; + } + group.readEndedMs = performance.now() - epoch; + } + } + for (const elements of groups) { + phase = 'start'; + callStartedAtMs.push(performance.now() - epoch); + controls.push(config.staggerGapMs > 0 + ? A.startStagger(elements, config.toPx, config.durationMs, config.staggerGapMs) + : A.start(elements, config.toPx, config.durationMs)); + if (onset) { + phase = 'onset-after'; + const group = { readStartedMs: performance.now() - epoch, positions: [] }; onset.after.push(group); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame = { beforeMs: typeof value === 'number' ? value - epoch : value ?? null }; + } + for (const element of elements) group.positions.push(new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame.afterMs = typeof value === 'number' ? value - epoch : value ?? null; + } + group.readEndedMs = performance.now() - epoch; + } + } + if (onset && config.requireDocumentFrame) { + phase = 'onset-first-frame'; + const frameTimestampMs = await new Promise((resolve) => requestAnimationFrame((timestamp) => resolve(timestamp - epoch))); + onset.firstFrame = { frameTimestampMs, groups: [] }; + for (const elements of groups) { + const group = { readStartedMs: performance.now() - epoch, positions: [] }; onset.firstFrame.groups.push(group); + const before = document.timeline?.currentTime; + group.documentFrame = { beforeMs: typeof before === 'number' ? before - epoch : before ?? null }; + for (const element of elements) group.positions.push(new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + const after = document.timeline?.currentTime; + group.documentFrame.afterMs = typeof after === 'number' ? after - epoch : after ?? null; + group.readEndedMs = performance.now() - epoch; + } + } + phase = 'checkpoint'; + for (const checkpointTime of checkpointTimes) { + const remaining = checkpointTime - (performance.now() - epoch); + if (remaining > 0) await new Promise((resolve) => setTimeout(resolve, remaining)); + // CSS после обновления кадра соотносится с его наблюдаемым timestamp, + // а не с предположением о частоте экрана или фазе первого callback. + const frameTimestampMs = await new Promise((resolve) => requestAnimationFrame((timestamp) => resolve(timestamp - epoch))); + const checkpoint = { frameTimestampMs, groups: [] }; checkpoints.push(checkpoint); + for (const elements of groups) { + const group = { readStartedMs: performance.now() - epoch, positions: [] }; checkpoint.groups.push(group); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame = { beforeMs: typeof value === 'number' ? value - epoch : value ?? null }; + } + for (const element of elements) group.positions.push(new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + if (config.requireDocumentFrame) { + const value = document.timeline?.currentTime; + group.documentFrame.afterMs = typeof value === 'number' ? value - epoch : value ?? null; + } + group.readEndedMs = performance.now() - epoch; + } + } + phase = 'terminal'; + const remaining = config.durationMs + delaySpan + 100 - (performance.now() - epoch); if (remaining > 0) await new Promise((resolve) => setTimeout(resolve, remaining)); - checkpoints.push({ - groups: groups.map((elements) => { - const readStartedMs = performance.now() - epoch; - const positions = elements.map((element) => ( - new DOMMatrixReadOnly(getComputedStyle(element).transform).e - )); - return { readStartedMs, readEndedMs: performance.now() - epoch, positions }; - }), - }); + for (const elements of groups) { + const positions = []; terminal.push(positions); + for (const element of elements) positions.push(new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + } + } catch (error) { failed(error, phase); } finally { + for (const control of controls) { try { control.cancel(); } catch (error) { failed(error, 'cancel-cleanup'); } } + for (const elements of groups) for (const element of elements) { try { element.remove(); } catch (error) { failed(error, 'target-cleanup'); } } } - const terminalAt = config.durationMs + delaySpan + 100; - const remaining = terminalAt - (performance.now() - epoch); - if (remaining > 0) await new Promise((resolve) => setTimeout(resolve, remaining)); - const terminal = groups.map((elements) => elements.map((element) => ( - new DOMMatrixReadOnly(getComputedStyle(element).transform).e - ))); - for (const control of controls) { try { control.cancel(); } catch { /* семантика уже снята */ } } - for (const elements of groups) for (const element of elements) element.remove(); return { topology: { calls: expectedCalls, @@ -494,11 +554,13 @@ async function runSemanticStartCheck(page, scenario, calls) { callStartedAtMs, checkpoints, terminal, + ...(onset ? { onset } : {}), + ...(failures.length ? { failures, acquiredOwners: controls.length, createdTargets: groups.map((elements) => elements.length) } : {}), }; }, { config: scenario, calls }); return { ...evidence, - valid: evaluateStartSemanticEvidence(evidence, scenario, calls), + valid: !evidence.failures?.length && evaluateStartSemanticEvidence(evidence, scenario, calls), }; } @@ -507,7 +569,7 @@ async function runSemanticStartCheck(page, scenario, calls) { function colorLeftEdge(pngBuf, channel) { // Полный скан: кадры скринкаста — целый вьюпорт (возможен и letterbox), // привязываться к конкретной строке нельзя. Ищем левейший пиксель канала. - const img = PNG.sync.read(pngBuf); + const img = requireBenchmark('pngjs').PNG.sync.read(pngBuf); let left = null; for (let y = 0; y < img.height; y++) { for (let x = 0; x < img.width; x++) { @@ -855,6 +917,7 @@ async function main() { mkdirSync(path.join(__dirname, 'results'), { recursive: true }); const rootPkg = JSON.parse(readFileSync(path.join(ROOT, 'package.json'), 'utf8')); + const { chromium } = requireBenchmark('playwright'); const chromiumInstall = await resolveChromiumInstall(); const chromiumTreeBefore = hashFileTree(chromiumInstall.directory); const benchmarkOrigin = await startBenchmarkOrigin(); diff --git a/bench/compare/methodology.mjs b/bench/compare/methodology.mjs index 37b4072fb..393c0f589 100644 --- a/bench/compare/methodology.mjs +++ b/bench/compare/methodology.mjs @@ -16,6 +16,58 @@ export const BENCHMARK_TIMER_ISOLATION_POLICY = Object.freeze({ originAgentCluster: '?1', }); +/** Упорядоченные исходы stock C без потерь; RLE строится после CPU интервала. */ +export function compactStockMotionValueOutcomes(values, frames) { + if (!Array.isArray(values) || !Array.isArray(frames) || values.length !== frames.length) { + throw new Error('stock C: потеряны приобретённые outcomes'); + } + const runs = []; + const preserve = (value) => value === undefined ? { type: 'undefined' } + : Object.is(value, -0) ? { number: '-0' } + : typeof value === 'number' && !Number.isFinite(value) ? { nonfinite: String(value) } : value; + for (let index = 0; index < values.length; index++) { + const previous = runs.at(-1); + if (previous && Object.is(values[index - 1], values[index]) && Object.is(frames[index - 1], frames[index])) previous.count++; + else runs.push({ from: index, count: 1, value: preserve(values[index]), frames: preserve(frames[index]) }); + } + return { encoding: 'runs', count: values.length, runs }; +} + +/** Каждый whole macro должен завершить47frames и endpoint100; среднее не является oracle. */ +export function validateStockMotionValueBatch(batch, scene, workMultiplier = 1, timed = true) { + const require = (condition, message) => { if (!condition) throw new Error(`stock C: ${message}`); }; + const expectedCalls = scene.callsPerRepetition * workMultiplier; + require(batch?.raw?.schemaVersion === 1 && batch.raw.scene === scene.id && batch.raw.phase === (timed ? 'timed' : 'warmup') && + batch.raw.calls === expectedCalls && batch.raw.completed === expectedCalls && batch.raw.denominator === scene.callsPerRepetition, + 'неполный whole macro или изменённый знаменатель'); + const outcomes = batch.raw.outcomes; + require(outcomes?.encoding === 'runs' && outcomes.count === expectedCalls && Array.isArray(outcomes.runs), 'потеряны per-operation outcomes'); + let next = 0; + for (const run of outcomes.runs) { + require(run?.from === next && Number.isSafeInteger(run.count) && run.count > 0 && run.count <= expectedCalls - next, + 'RLE потерял или повторил operation identity'); + require(run.value === scene.target && run.frames === scene.expectedFrames, 'отдельная операция не завершила полезный47-frame/100 результат'); + next += run.count; + } + require(next === expectedCalls, 'потерян acquired suffix'); + if (!timed) { + require(batch.operationNs === null && batch.raw.clockReads.length === 0 && batch.raw.cpuReads.length === 0, 'warmup превратился в timing'); + return { operationNs: null }; + } + const reads = batch.raw.clockReads; + require(Array.isArray(reads) && reads.length === 2, 'потеряны CPU interval endpoints'); + const endpoints = reads.map((read, sequence) => { + require(read?.sequence === sequence && read.metric === 'operationNs' && read.frame === null && + read.edge === ['before', 'after'][sequence] && typeof read.valueNs === 'string' && /^(?:0|[1-9]\d*)$/.test(read.valueNs), 'нарушен CPU clock order/grid'); + return BigInt(read.valueNs); + }); + const duration = endpoints[1] - endpoints[0]; + require(duration >= 0n && duration <= BigInt(Number.MAX_SAFE_INTEGER), 'CPU interval вне safe range'); + const operationNs = Number(duration) / scene.callsPerRepetition; + require(batch.operationNs === operationNs, 'metric не пересчитывается из raw/2000'); + return { operationNs, batchNs: Number(duration) }; +} + /** Warm-floor использует шаг моды; superiority-порог — максимум всех дельт. */ export const WARM_TIMER_CALIBRATION_POLICY = Object.freeze({ practicalRelativeThreshold: 0.05, @@ -247,22 +299,65 @@ export function deriveTimerStep(values) { return stepUpper; } -function nextUp(value) { +// Операция синхронна, не отдаёт view наружу и сохраняет только примитивный +// результат. Один scratch word устраняет allocation на каждом округлении. +const binary64Scratch = new DataView(new ArrayBuffer(8)); + +export function nextUp(value) { if (Number.isNaN(value) || value === Infinity) return value; if (value === 0) return Number.MIN_VALUE; - const buffer = new ArrayBuffer(8); - const view = new DataView(buffer); - view.setFloat64(0, value); - const bits = view.getBigUint64(0); - view.setBigUint64(0, bits + (value > 0 ? 1n : -1n)); - return view.getFloat64(0); + binary64Scratch.setFloat64(0, value); + const bits = binary64Scratch.getBigUint64(0); + binary64Scratch.setBigUint64(0, bits + (value > 0 ? 1n : -1n)); + return binary64Scratch.getFloat64(0); +} + +export function nextDown(value) { + return -nextUp(-value); } -function binary64Ulp(value) { +export function binary64Ulp(value) { const magnitude = Math.abs(value); return nextUp(magnitude) - magnitude; } +// Точная биномиальная масса для рациональных q/alpha. Наблюдаемая единица, +// семейство и admission принадлежат регистрации потребителя, не этому helper. +export function exactBinomialOrderStatisticBounds(values, probabilityFraction, alphaFraction) { + if (!Array.isArray(values) || values.length === 0 || values.some((x) => !Number.isFinite(x) || x < 0)) { + throw new Error('exact order statistics: невалидные observations'); + } + const [numerator, denominator] = probabilityFraction.map(BigInt); + const [alphaNumerator, alphaDenominator] = alphaFraction.map(BigInt); + if (numerator <= 0n || numerator >= denominator || alphaNumerator <= 0n || alphaNumerator * 2n >= alphaDenominator) { + throw new Error('exact order statistics: невалидные rational probabilities'); + } + const sorted = [...values].sort((a, b) => a - b), n = sorted.length; + const populationDenominator = denominator ** BigInt(n), pmf = []; + let mass = (denominator - numerator) ** BigInt(n); + for (let count = 0; count <= n; count++) { + pmf.push(mass); + if (count < n) mass = mass * BigInt(n - count) * numerator / (BigInt(count + 1) * (denominator - numerator)); + } + const cumulative = [], survival = []; + let total = 0n; + for (let i = 0; i <= n; i++) { total += pmf[i]; cumulative[i] = total; } + if (total !== populationDenominator) throw new Error('exact order statistics: биномиальная масса повреждена'); + total = 0n; + for (let i = n; i >= 0; i--) { total += pmf[i]; survival[i] = total; } + let lowRank = 0, highRank = null; + for (let rank = 1; rank <= n; rank++) { + if (cumulative[rank - 1] * alphaDenominator <= populationDenominator * alphaNumerator) lowRank = rank; + if (highRank === null && survival[rank] * alphaDenominator <= populationDenominator * alphaNumerator) highRank = rank; + } + const probability = Number(numerator) / Number(denominator), alphaPerTail = Number(alphaNumerator) / Number(alphaDenominator); + const estimateRank = Number((BigInt(n) * numerator + denominator - 1n) / denominator); + return { estimate: sorted[Math.min(n - 1, estimateRank - 1)], + low: lowRank === 0 ? 0 : sorted[lowRank - 1], high: highRank === null ? null : sorted[highRank - 1], + lowRank, highRank, observations: n, probability, alphaPerTail, + minimumFiniteUpperBlocks: Math.ceil(Math.log(alphaPerTail) / Math.log(probability)), noTailObservationProbability: probability ** n }; +} + function deriveRealmTimerBounds(name, evidence) { if ( evidence?.crossOriginIsolated !== true || @@ -558,14 +653,14 @@ export function evaluateStartSemanticEvidence(evidence, expected, calls) { !Array.isArray(evidence.callStartedAtMs) || evidence.callStartedAtMs.length !== calls || evidence.callStartedAtMs.some((value) => !Number.isFinite(value) || value < 0) || - !Array.isArray(evidence.checkpoints) || evidence.checkpoints.length === 0 || + !Array.isArray(evidence.checkpoints) || evidence.checkpoints.length < 2 || !Array.isArray(evidence.terminal) || evidence.terminal.length !== calls ) return false; const shape = (positions) => ( Array.isArray(positions) && positions.length === expected.targetsPerCall && - positions.every(Number.isFinite) + Array.from(positions).every(Number.isFinite) ); const terminalValid = evidence.terminal.every((positions) => ( shape(positions) && positions.every((value) => ( @@ -575,6 +670,71 @@ export function evaluateStartSemanticEvidence(evidence, expected, calls) { if (!terminalValid) return false; let provedPartialStagger = expected.staggerGapMs === 0; + const observations = Array.from({ length: calls }, () => []); + const phases = Array.from({ length: calls }, () => ({ low: -Infinity, high: Infinity })); + const resolved = Array.from({ length: calls }, () => Array(expected.targetsPerCall).fill(false)); + const clockErrorMs = expected.semanticClockErrorMs ?? 0; + if (!Number.isFinite(clockErrorMs) || clockErrorMs < 0 || + !Number.isFinite(expected.durationMs) || expected.durationMs <= 0) return false; + const slope = expected.toPx / expected.durationMs; + const coordinateError = 2 * expected.movementThresholdPx; + const interior = (value) => value >= expected.movementThresholdPx && value < expected.toPx - expected.finalTolerancePx; + const publicationFrameValid = (group) => Number.isFinite(group.documentFrame?.beforeMs) && + group.documentFrame.beforeMs === group.documentFrame.afterMs && + group.documentFrame.beforeMs <= group.readStartedMs + clockErrorMs && + group.documentFrame.afterMs <= group.readEndedMs + clockErrorMs; + const includePositions = (phase, group, observationStartedMs, observationEndedMs = group.readEndedMs) => { + for (let target = 0; target < group.positions.length; target++) { + const value = group.positions[target], delay = target * expected.staggerGapMs; + if (value < -expected.movementThresholdPx || value > expected.toPx + expected.finalTolerancePx) return false; + if (expected.staggerGapMs === 0 && target > 0 && value === group.positions[target - 1]) continue; + // Clamp и interior связывает одна фаза на весь вызов и все observations. + if (value < expected.toPx - expected.finalTolerancePx) phase.low = Math.max(phase.low, + nextDown(nextDown(observationStartedMs - clockErrorMs - delay) - nextUp((value + expected.movementThresholdPx) / slope))); + if (value >= expected.movementThresholdPx) phase.high = Math.min(phase.high, + nextUp(nextUp(observationEndedMs + clockErrorMs - delay) - nextDown((value - + (interior(value) ? expected.movementThresholdPx : expected.finalTolerancePx)) / slope))); + if (phase.low > phase.high) return false; + } + return true; + }; + if (expected.requireFreshStart) { + const onset = evidence.onset; + if (expected.fromPx !== 0 || !Array.isArray(onset?.before) || !Array.isArray(onset?.after) || + onset.before.length !== calls || onset.after.length !== calls) return false; + for (let call = 0; call < calls; call++) { + const before = onset.before[call], after = onset.after[call], startedMs = evidence.callStartedAtMs[call]; + if (![before, after].every((group) => Number.isFinite(group?.readStartedMs) && Number.isFinite(group?.readEndedMs) && + group.readStartedMs >= 0 && group.readEndedMs >= group.readStartedMs && shape(group.positions)) || + before.readEndedMs > startedMs + clockErrorMs || after.readStartedMs < startedMs - clockErrorMs || + before.positions.some((value) => Math.abs(value - expected.fromPx) > expected.movementThresholdPx)) return false; + // API chronology и CSS publication используют разные clock domains. + // До API наблюдается ноль; phase не предшествует его publication origin. + // Прежний perf oracle сохраняет свой start clock без смены контракта. + if (expected.requireDocumentFrame) { + // В одном task document clock одинаков до/после синхронного API; + // timestamp следующего rAF может предшествовать его execution wall. + if (!publicationFrameValid(before) || !publicationFrameValid(after) || + after.documentFrame.beforeMs !== before.documentFrame.beforeMs) return false; + phases[call].low = nextDown(before.documentFrame.beforeMs - clockErrorMs - nextUp(expected.movementThresholdPx / slope)); + if (!includePositions(phases[call], after, after.documentFrame.beforeMs, after.documentFrame.afterMs)) return false; + const first = onset.firstFrame, group = first?.groups?.[call]; + // Старый document clock и поздний slope не различают первый quarter + // jump. Первая acquired публикация обязана сохранить весь fresh ноль; + // с её frame clock начинается полезная полная траектория. + if (!Number.isFinite(first?.frameTimestampMs) || !Array.isArray(first.groups) || first.groups.length !== calls || + !Number.isFinite(group?.readStartedMs) || !Number.isFinite(group.readEndedMs) || + group.readStartedMs < after.readEndedMs - clockErrorMs || group.readEndedMs < group.readStartedMs || + !shape(group.positions) || group.positions.some((value) => Math.abs(value - expected.fromPx) > expected.movementThresholdPx) || + !publicationFrameValid(group) || Math.abs(group.documentFrame.beforeMs - first.frameTimestampMs) > clockErrorMs || + group.documentFrame.beforeMs < after.documentFrame.beforeMs - clockErrorMs) return false; + if (!includePositions(phases[call], group, group.documentFrame.beforeMs, group.documentFrame.afterMs)) return false; + } else { + phases[call].low = nextDown(startedMs - clockErrorMs - nextUp(expected.movementThresholdPx / slope)); + if (!includePositions(phases[call], after, after.readStartedMs)) return false; + } + } + } for (const checkpoint of evidence.checkpoints) { if (!Array.isArray(checkpoint?.groups) || checkpoint.groups.length !== calls) return false; for (let call = 0; call < calls; call++) { @@ -586,13 +746,47 @@ export function evaluateStartSemanticEvidence(evidence, expected, calls) { group.readEndedMs < group.readStartedMs || !shape(group.positions) ) return false; - if (expected.staggerGapMs === 0) { - if (group.positions.some((value) => ( - value < expected.movementThresholdPx || - value >= expected.toPx - expected.finalTolerancePx - ))) return false; - continue; + let observationStartedMs = checkpoint.frameTimestampMs ?? group.readStartedMs; + let observationEndedMs = group.readEndedMs; + if (!Number.isFinite(observationStartedMs) || observationStartedMs < evidence.callStartedAtMs[call] - clockErrorMs || + observationStartedMs > group.readStartedMs + clockErrorMs) return false; + if (expected.requireFreshStart && group.readStartedMs < evidence.onset.after[call].readEndedMs - clockErrorMs) return false; + if (expected.requireDocumentFrame) { + const frame = group.documentFrame; + // DocumentTimeline фиксирован в одном rendering/task; CSS чтение не + // превращает время исполнения getter в elapsed движения. Связь с rAF + // проверяется по обоим clocks, без свободного смещения новой фазы. + if (!publicationFrameValid(group) || Math.abs(frame.beforeMs - checkpoint.frameTimestampMs) > clockErrorMs) return false; + observationStartedMs = frame.beforeMs; observationEndedMs = frame.afterMs; } + const history = observations[call]; + if (history.length && observationStartedMs <= history.at(-1).startedMs) return false; + for (const prior of history) { + const elapsedLow = Math.max(0, nextDown(observationStartedMs - prior.endedMs - 2 * clockErrorMs)); + const elapsedHigh = nextUp(observationEndedMs - prior.startedMs + 2 * clockErrorMs); + const displacementLow = nextDown(slope * elapsedLow); + const displacementHigh = nextUp(slope * elapsedHigh); + let previousDelta = NaN, withinTolerance = false; + for (let target = 0; target < group.positions.length; target++) { + const before = prior.positions[target], after = group.positions[target]; + // Пересечение широкого интервала не доказывает скорость. Полный + // диапазон перемещения должен укладываться в прежний CSS допуск. + if (interior(before) && interior(after) && elapsedLow > 0) { + const delta = after - before; + // Совпавший скаляр задаёт то же неравенство; raw identity и обе + // координаты каждого target всё равно проходят общий обход. + if (delta !== previousDelta) { + previousDelta = delta; + withinTolerance = displacementLow >= nextDown(delta - coordinateError) && + displacementHigh <= nextUp(delta + coordinateError); + } + if (withinTolerance) resolved[call][target] = true; + } + } + } + history.push({ startedMs: observationStartedMs, endedMs: observationEndedMs, positions: group.positions }); + if (!includePositions(phases[call], group, observationStartedMs, observationEndedMs)) return false; + if (expected.staggerGapMs === 0) continue; for (let target = 1; target < group.positions.length; target++) { if (group.positions[target] > group.positions[target - 1] + expected.movementThresholdPx) { @@ -600,18 +794,16 @@ export function evaluateStartSemanticEvidence(evidence, expected, calls) { } } const leadingPosition = group.positions[0]; - if ( - leadingPosition < expected.movementThresholdPx || - leadingPosition >= expected.toPx - expected.finalTolerancePx - ) return false; const staggerStepPx = ( expected.toPx * expected.staggerGapMs / expected.durationMs ); - for (let target = 1; target < group.positions.length; target++) { - const relativeExpected = Math.max(0, leadingPosition - staggerStepPx * target); - if ( - Math.abs(group.positions[target] - relativeExpected) > expected.movementThresholdPx - ) return false; + if (interior(leadingPosition)) { + for (let target = 1; target < group.positions.length; target++) { + const relativeExpected = Math.max(0, leadingPosition - staggerStepPx * target); + if ( + Math.abs(group.positions[target] - relativeExpected) > expected.movementThresholdPx + ) return false; + } } let lastMoved = -1; for (let target = 0; target < group.positions.length; target++) { @@ -620,7 +812,8 @@ export function evaluateStartSemanticEvidence(evidence, expected, calls) { if (lastMoved >= 0 && lastMoved < expected.targetsPerCall - 1) provedPartialStagger = true; } } - return provedPartialStagger; + return provedPartialStagger && resolved.every((targets) => expected.staggerGapMs === 0 + ? targets.every(Boolean) : targets[0]); } /** Publish-run не имеет права сохранять sample с недоказанной топологией. */ diff --git a/bench/profile/native-clock/LICENSE b/bench/profile/native-clock/LICENSE new file mode 100644 index 000000000..2873b3b2e --- /dev/null +++ b/bench/profile/native-clock/LICENSE @@ -0,0 +1,47 @@ +Node.js is licensed for use as follows: + +""" +Copyright Node.js contributors. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. +""" + +This license applies to parts of Node.js originating from the +https://github.com/joyent/node repository: + +""" +Copyright Joyent, Inc. and other Node contributors. All rights reserved. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. +""" diff --git a/bench/profile/native-clock/README.md b/bench/profile/native-clock/README.md new file mode 100644 index 000000000..81401d9d3 --- /dev/null +++ b/bench/profile/native-clock/README.md @@ -0,0 +1,17 @@ +# Исходники частного CPU-счётчика + +Роль: справка (Diátaxis). + +`include/` содержит четыре неизменённых заголовка Node-API из Node.js `v24.19.0`, +[официальный каталог `src`](https://github.com/nodejs/node/tree/v24.19.0/src). +Уведомление об авторских правах участников Node.js и Joyent сохранено в +[LICENSE](./LICENSE). Заголовки нужны для сборки частного инструмента измерения; +npm-пакет библиотеки их не включает. + +Команды запуска — в [руководстве по измерению](../../../docs/server-profile.md). +SHA-256 каждого заголовка и исходника C закреплён в +[`SERVER_PROFILE.clockError.nativeSourceFiles`](../server-profile-registration.mjs). +Счётчик собирается до регистрации. Сведения о полученном бинарном файле, +компиляторе, флагах, libc и PID/TID сохраняются в `engineClock`. +Обычный импорт модуля не требует компилятора. Номинальное разрешение `clock_getres` +не удостоверяет физическую точность счётчика. diff --git a/bench/profile/native-clock/include/js_native_api.h b/bench/profile/native-clock/include/js_native_api.h new file mode 100644 index 000000000..d2375ecd3 --- /dev/null +++ b/bench/profile/native-clock/include/js_native_api.h @@ -0,0 +1,634 @@ +#ifndef SRC_JS_NATIVE_API_H_ +#define SRC_JS_NATIVE_API_H_ + +// This file needs to be compatible with C compilers. +#include // NOLINT(modernize-deprecated-headers) +#include // NOLINT(modernize-deprecated-headers) + +#include "js_native_api_types.h" + +// If you need __declspec(dllimport), either include instead, or +// define NAPI_EXTERN as __declspec(dllimport) on the compiler's command line. +#ifndef NAPI_EXTERN +#ifdef _WIN32 +#define NAPI_EXTERN __declspec(dllexport) +#elif defined(__wasm__) +#define NAPI_EXTERN \ + __attribute__((visibility("default"))) \ + __attribute__((__import_module__("napi"))) +#else +#define NAPI_EXTERN __attribute__((visibility("default"))) +#endif +#endif + +#define NAPI_AUTO_LENGTH SIZE_MAX + +#ifdef __cplusplus +#define EXTERN_C_START extern "C" { +#define EXTERN_C_END } +#else +#define EXTERN_C_START +#define EXTERN_C_END +#endif + +EXTERN_C_START + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info( + node_api_basic_env env, const napi_extended_error_info** result); + +// Getters for defined singletons +NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_null(napi_env env, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_global(napi_env env, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env, + bool value, + napi_value* result); + +// Methods to create Primitive types/Objects +NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env, + napi_value* result); +#ifdef NAPI_EXPERIMENTAL +#define NODE_API_EXPERIMENTAL_HAS_CREATE_OBJECT_WITH_PROPERTIES +NAPI_EXTERN napi_status NAPI_CDECL +node_api_create_object_with_properties(napi_env env, + napi_value prototype_or_null, + napi_value* property_names, + napi_value* property_values, + size_t property_count, + napi_value* result); +#endif // NAPI_EXPERIMENTAL + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_array(napi_env env, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_array_with_length(napi_env env, size_t length, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_double(napi_env env, + double value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_int32(napi_env env, + int32_t value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_uint32(napi_env env, + uint32_t value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_int64(napi_env env, + int64_t value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_latin1( + napi_env env, const char* str, size_t length, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf8(napi_env env, + const char* str, + size_t length, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env, + const char16_t* str, + size_t length, + napi_value* result); +#if NAPI_VERSION >= 10 +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1( + napi_env env, + char* str, + size_t length, + node_api_basic_finalize finalize_callback, + void* finalize_hint, + napi_value* result, + bool* copied); +NAPI_EXTERN napi_status NAPI_CDECL +node_api_create_external_string_utf16(napi_env env, + char16_t* str, + size_t length, + node_api_basic_finalize finalize_callback, + void* finalize_hint, + napi_value* result, + bool* copied); + +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1( + napi_env env, const char* str, size_t length, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8( + napi_env env, const char* str, size_t length, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16( + napi_env env, const char16_t* str, size_t length, napi_value* result); +#endif // NAPI_VERSION >= 10 + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env, + napi_value description, + napi_value* result); +#if NAPI_VERSION >= 9 +NAPI_EXTERN napi_status NAPI_CDECL +node_api_symbol_for(napi_env env, + const char* utf8description, + size_t length, + napi_value* result); +#endif // NAPI_VERSION >= 9 +NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(napi_env env, + const char* utf8name, + size_t length, + napi_callback cb, + void* data, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_error(napi_env env, + napi_value code, + napi_value msg, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_type_error(napi_env env, + napi_value code, + napi_value msg, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_range_error(napi_env env, + napi_value code, + napi_value msg, + napi_value* result); +#if NAPI_VERSION >= 9 +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_syntax_error( + napi_env env, napi_value code, napi_value msg, napi_value* result); +#endif // NAPI_VERSION >= 9 + +// Methods to get the native napi_value from Primitive type +NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(napi_env env, + napi_value value, + napi_valuetype* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_double(napi_env env, + napi_value value, + double* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int32(napi_env env, + napi_value value, + int32_t* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_uint32(napi_env env, + napi_value value, + uint32_t* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int64(napi_env env, + napi_value value, + int64_t* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bool(napi_env env, + napi_value value, + bool* result); + +// Copies LATIN-1 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_latin1( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); + +// Copies UTF-8 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf8( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); + +// Copies UTF-16 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env, + napi_value value, + char16_t* buf, + size_t bufsize, + size_t* result); + +// Methods to coerce values +// These APIs may execute user scripts +NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_bool(napi_env env, + napi_value value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_number(napi_env env, + napi_value value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_object(napi_env env, + napi_value value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_string(napi_env env, + napi_value value, + napi_value* result); + +// Methods to work with Objects +#ifdef NAPI_EXPERIMENTAL +#define NODE_API_EXPERIMENTAL_HAS_SET_PROTOTYPE +NAPI_EXTERN napi_status NAPI_CDECL node_api_set_prototype(napi_env env, + napi_value object, + napi_value value); +#endif +NAPI_EXTERN napi_status NAPI_CDECL napi_get_prototype(napi_env env, + napi_value object, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_property_names(napi_env env, + napi_value object, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_set_property(napi_env env, + napi_value object, + napi_value key, + napi_value value); +NAPI_EXTERN napi_status NAPI_CDECL napi_has_property(napi_env env, + napi_value object, + napi_value key, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_property(napi_env env, + napi_value object, + napi_value key, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_property(napi_env env, + napi_value object, + napi_value key, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_has_own_property(napi_env env, + napi_value object, + napi_value key, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_set_named_property(napi_env env, + napi_value object, + const char* utf8name, + napi_value value); +NAPI_EXTERN napi_status NAPI_CDECL napi_has_named_property(napi_env env, + napi_value object, + const char* utf8name, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_named_property(napi_env env, + napi_value object, + const char* utf8name, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_set_element(napi_env env, + napi_value object, + uint32_t index, + napi_value value); +NAPI_EXTERN napi_status NAPI_CDECL napi_has_element(napi_env env, + napi_value object, + uint32_t index, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_element(napi_env env, + napi_value object, + uint32_t index, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_element(napi_env env, + napi_value object, + uint32_t index, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_define_properties(napi_env env, + napi_value object, + size_t property_count, + const napi_property_descriptor* properties); + +// Methods to work with Arrays +NAPI_EXTERN napi_status NAPI_CDECL napi_is_array(napi_env env, + napi_value value, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_array_length(napi_env env, + napi_value value, + uint32_t* result); + +// Methods to compare values +NAPI_EXTERN napi_status NAPI_CDECL napi_strict_equals(napi_env env, + napi_value lhs, + napi_value rhs, + bool* result); + +// Methods to work with Functions +NAPI_EXTERN napi_status NAPI_CDECL napi_call_function(napi_env env, + napi_value recv, + napi_value func, + size_t argc, + const napi_value* argv, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_new_instance(napi_env env, + napi_value constructor, + size_t argc, + const napi_value* argv, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_instanceof(napi_env env, + napi_value object, + napi_value constructor, + bool* result); + +// Methods to work with napi_callbacks + +// Gets all callback info in a single call. (Ugly, but faster.) +NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info( + napi_env env, // [in] Node-API environment handle + napi_callback_info cbinfo, // [in] Opaque callback-info handle + size_t* argc, // [in-out] Specifies the size of the provided argv array + // and receives the actual count of args. + napi_value* argv, // [out] Array of values + napi_value* this_arg, // [out] Receives the JS 'this' arg for the call + void** data); // [out] Receives the data pointer for the callback. + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_new_target( + napi_env env, napi_callback_info cbinfo, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_define_class(napi_env env, + const char* utf8name, + size_t length, + napi_callback constructor, + void* data, + size_t property_count, + const napi_property_descriptor* properties, + napi_value* result); + +// Methods to work with external data objects +NAPI_EXTERN napi_status NAPI_CDECL +napi_wrap(napi_env env, + napi_value js_object, + void* native_object, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_ref* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env, + napi_value js_object, + void** result); +NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env, + napi_value js_object, + void** result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_external(napi_env env, + void* data, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env, + napi_value value, + void** result); + +// Methods to control object lifespan + +// Set initial_refcount to 0 for a weak reference, >0 for a strong reference. +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_reference(napi_env env, + napi_value value, + uint32_t initial_refcount, + napi_ref* result); + +// Deletes a reference. The referenced value is released, and may +// be GC'd unless there are other references to it. +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(node_api_basic_env env, + napi_ref ref); + +// Increments the reference count, optionally returning the resulting count. +// After this call the reference will be a strong reference because its +// refcount is >0, and the referenced object is effectively "pinned". +// Calling this when the refcount is 0 and the object is unavailable +// results in an error. +NAPI_EXTERN napi_status NAPI_CDECL napi_reference_ref(napi_env env, + napi_ref ref, + uint32_t* result); + +// Decrements the reference count, optionally returning the resulting count. +// If the result is 0 the reference is now weak and the object may be GC'd +// at any time if there are no other references. Calling this when the +// refcount is already 0 results in an error. +NAPI_EXTERN napi_status NAPI_CDECL napi_reference_unref(napi_env env, + napi_ref ref, + uint32_t* result); + +// Attempts to get a referenced value. If the reference is weak, +// the value might no longer be available, in that case the call +// is still successful but the result is NULL. +NAPI_EXTERN napi_status NAPI_CDECL napi_get_reference_value(napi_env env, + napi_ref ref, + napi_value* result); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_open_handle_scope(napi_env env, napi_handle_scope* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_close_handle_scope(napi_env env, napi_handle_scope scope); +NAPI_EXTERN napi_status NAPI_CDECL napi_open_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_close_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope scope); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_escape_handle(napi_env env, + napi_escapable_handle_scope scope, + napi_value escapee, + napi_value* result); + +// Methods to support error handling +NAPI_EXTERN napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error); +NAPI_EXTERN napi_status NAPI_CDECL napi_throw_error(napi_env env, + const char* code, + const char* msg); +NAPI_EXTERN napi_status NAPI_CDECL napi_throw_type_error(napi_env env, + const char* code, + const char* msg); +NAPI_EXTERN napi_status NAPI_CDECL napi_throw_range_error(napi_env env, + const char* code, + const char* msg); +#if NAPI_VERSION >= 9 +NAPI_EXTERN napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env, + const char* code, + const char* msg); +#endif // NAPI_VERSION >= 9 +NAPI_EXTERN napi_status NAPI_CDECL napi_is_error(napi_env env, + napi_value value, + bool* result); + +// Methods to support catching exceptions +NAPI_EXTERN napi_status NAPI_CDECL napi_is_exception_pending(napi_env env, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_and_clear_last_exception(napi_env env, napi_value* result); + +// Methods to work with array buffers and typed arrays +NAPI_EXTERN napi_status NAPI_CDECL napi_is_arraybuffer(napi_env env, + napi_value value, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env, + size_t byte_length, + void** data, + napi_value* result); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_external_arraybuffer(napi_env env, + void* external_data, + size_t byte_length, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_value* result); +#ifdef NAPI_EXPERIMENTAL +#define NODE_API_EXPERIMENTAL_HAS_CREATE_EXTERNAL_SHAREDARRAYBUFFER +NAPI_EXTERN napi_status NAPI_CDECL +node_api_create_external_sharedarraybuffer(napi_env env, + void* external_data, + size_t byte_length, + node_api_noenv_finalize finalize_cb, + void* finalize_hint, + napi_value* result); +#endif // NAPI_EXPERIMENTAL +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info( + napi_env env, napi_value arraybuffer, void** data, size_t* byte_length); +NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(napi_env env, + napi_value value, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_typedarray(napi_env env, + napi_typedarray_type type, + size_t length, + napi_value arraybuffer, + size_t byte_offset, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_typedarray_info(napi_env env, + napi_value typedarray, + napi_typedarray_type* type, + size_t* length, + void** data, + napi_value* arraybuffer, + size_t* byte_offset); + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_dataview(napi_env env, + size_t length, + napi_value arraybuffer, + size_t byte_offset, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_is_dataview(napi_env env, + napi_value value, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_dataview_info(napi_env env, + napi_value dataview, + size_t* bytelength, + void** data, + napi_value* arraybuffer, + size_t* byte_offset); + +#ifdef NAPI_EXPERIMENTAL +#define NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER +NAPI_EXTERN napi_status NAPI_CDECL +node_api_is_sharedarraybuffer(napi_env env, napi_value value, bool* result); +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_sharedarraybuffer( + napi_env env, size_t byte_length, void** data, napi_value* result); +#endif // NAPI_EXPERIMENTAL + +// version management +NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env, + uint32_t* result); + +// Promises +NAPI_EXTERN napi_status NAPI_CDECL napi_create_promise(napi_env env, + napi_deferred* deferred, + napi_value* promise); +NAPI_EXTERN napi_status NAPI_CDECL napi_resolve_deferred(napi_env env, + napi_deferred deferred, + napi_value resolution); +NAPI_EXTERN napi_status NAPI_CDECL napi_reject_deferred(napi_env env, + napi_deferred deferred, + napi_value rejection); +NAPI_EXTERN napi_status NAPI_CDECL napi_is_promise(napi_env env, + napi_value value, + bool* is_promise); + +// Running a script +NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env, + napi_value script, + napi_value* result); + +// Memory management +NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory( + node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value); + +#if NAPI_VERSION >= 5 + +// Dates +NAPI_EXTERN napi_status NAPI_CDECL napi_create_date(napi_env env, + double time, + napi_value* result); + +NAPI_EXTERN napi_status NAPI_CDECL napi_is_date(napi_env env, + napi_value value, + bool* is_date); + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_date_value(napi_env env, + napi_value value, + double* result); + +// Add finalizer for pointer +NAPI_EXTERN napi_status NAPI_CDECL +napi_add_finalizer(napi_env env, + napi_value js_object, + void* finalize_data, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_ref* result); + +#endif // NAPI_VERSION >= 5 + +#ifdef NAPI_EXPERIMENTAL +#define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER + +NAPI_EXTERN napi_status NAPI_CDECL +node_api_post_finalizer(node_api_basic_env env, + napi_finalize finalize_cb, + void* finalize_data, + void* finalize_hint); + +#endif // NAPI_EXPERIMENTAL + +#if NAPI_VERSION >= 6 + +// BigInt +NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_int64(napi_env env, + int64_t value, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_bigint_words(napi_env env, + int sign_bit, + size_t word_count, + const uint64_t* words, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_int64(napi_env env, + napi_value value, + int64_t* result, + bool* lossless); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_uint64( + napi_env env, napi_value value, uint64_t* result, bool* lossless); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_value_bigint_words(napi_env env, + napi_value value, + int* sign_bit, + size_t* word_count, + uint64_t* words); + +// Object +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_all_property_names(napi_env env, + napi_value object, + napi_key_collection_mode key_mode, + napi_key_filter key_filter, + napi_key_conversion key_conversion, + napi_value* result); + +// Instance data +NAPI_EXTERN napi_status NAPI_CDECL +napi_set_instance_data(node_api_basic_env env, + void* data, + napi_finalize finalize_cb, + void* finalize_hint); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_instance_data(node_api_basic_env env, void** data); +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 7 +// ArrayBuffer detaching +NAPI_EXTERN napi_status NAPI_CDECL +napi_detach_arraybuffer(napi_env env, napi_value arraybuffer); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_is_detached_arraybuffer(napi_env env, napi_value value, bool* result); +#endif // NAPI_VERSION >= 7 + +#if NAPI_VERSION >= 8 +// Type tagging +NAPI_EXTERN napi_status NAPI_CDECL napi_type_tag_object( + napi_env env, napi_value value, const napi_type_tag* type_tag); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_check_object_type_tag(napi_env env, + napi_value value, + const napi_type_tag* type_tag, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_object_freeze(napi_env env, + napi_value object); +NAPI_EXTERN napi_status NAPI_CDECL napi_object_seal(napi_env env, + napi_value object); +#endif // NAPI_VERSION >= 8 + +EXTERN_C_END + +#endif // SRC_JS_NATIVE_API_H_ diff --git a/bench/profile/native-clock/include/js_native_api_types.h b/bench/profile/native-clock/include/js_native_api_types.h new file mode 100644 index 000000000..ddbbb82e1 --- /dev/null +++ b/bench/profile/native-clock/include/js_native_api_types.h @@ -0,0 +1,232 @@ +#ifndef SRC_JS_NATIVE_API_TYPES_H_ +#define SRC_JS_NATIVE_API_TYPES_H_ + +// Use INT_MAX, this should only be consumed by the pre-processor anyway. +#define NAPI_VERSION_EXPERIMENTAL 2147483647 +#ifndef NAPI_VERSION +#ifdef NAPI_EXPERIMENTAL +#define NAPI_VERSION NAPI_VERSION_EXPERIMENTAL +#else +// The baseline version for Node-API. +// NAPI_VERSION controls which version is used by default when compiling +// a native addon. If the addon developer wants to use functions from a +// newer Node-API version not yet available in all LTS versions, they can +// set NAPI_VERSION to explicitly depend on that version. +#define NAPI_VERSION 8 +#endif +#endif + +// This file needs to be compatible with C compilers. +// This is a public include file, and these includes have essentially +// become part of its API. +#include // NOLINT(modernize-deprecated-headers) +#include // NOLINT(modernize-deprecated-headers) + +#if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900) +typedef uint16_t char16_t; +#endif + +#ifndef NAPI_CDECL +#ifdef _WIN32 +#define NAPI_CDECL __cdecl +#else +#define NAPI_CDECL +#endif +#endif + +// JSVM API types are all opaque pointers for ABI stability +// typedef undefined structs instead of void* for compile time type safety +typedef struct napi_env__* napi_env; + +// We need to mark APIs which can be called during garbage collection (GC), +// meaning that they do not affect the state of the JS engine, and can +// therefore be called synchronously from a finalizer that itself runs +// synchronously during GC. Such APIs can receive either a `napi_env` or a +// `node_api_basic_env` as their first parameter, because we should be able to +// also call them during normal, non-garbage-collecting operations, whereas +// APIs that affect the state of the JS engine can only receive a `napi_env` as +// their first parameter, because we must not call them during GC. In lieu of +// inheritance, we use the properties of the const qualifier to accomplish +// this, because both a const and a non-const value can be passed to an API +// expecting a const value, but only a non-const value can be passed to an API +// expecting a non-const value. +// +// In conjunction with appropriate CFLAGS to warn us if we're passing a const +// (basic) environment into an API that expects a non-const environment, and +// the definition of basic finalizer function pointer types below, which +// receive a basic environment as their first parameter, and can thus only call +// basic APIs (unless the user explicitly casts the environment), we achieve +// the ability to ensure at compile time that we do not call APIs that affect +// the state of the JS engine from a synchronous (basic) finalizer. +#if !defined(NAPI_EXPERIMENTAL) || \ + (defined(NAPI_EXPERIMENTAL) && \ + (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \ + defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) +typedef struct napi_env__* node_api_nogc_env; +#else +typedef const struct napi_env__* node_api_nogc_env; +#endif +typedef node_api_nogc_env node_api_basic_env; + +typedef struct napi_value__* napi_value; +typedef struct napi_ref__* napi_ref; +typedef struct napi_handle_scope__* napi_handle_scope; +typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope; +typedef struct napi_callback_info__* napi_callback_info; +typedef struct napi_deferred__* napi_deferred; + +typedef enum { + napi_default = 0, + napi_writable = 1 << 0, + napi_enumerable = 1 << 1, + napi_configurable = 1 << 2, + + // Used with napi_define_class to distinguish static properties + // from instance properties. Ignored by napi_define_properties. + napi_static = 1 << 10, + +#if NAPI_VERSION >= 8 + // Default for class methods. + napi_default_method = napi_writable | napi_configurable, + + // Default for object properties, like in JS obj[prop]. + napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable, +#endif // NAPI_VERSION >= 8 +} napi_property_attributes; + +typedef enum { + // ES6 types (corresponds to typeof) + napi_undefined, + napi_null, + napi_boolean, + napi_number, + napi_string, + napi_symbol, + napi_object, + napi_function, + napi_external, + napi_bigint, +} napi_valuetype; + +typedef enum { + napi_int8_array, + napi_uint8_array, + napi_uint8_clamped_array, + napi_int16_array, + napi_uint16_array, + napi_int32_array, + napi_uint32_array, + napi_float32_array, + napi_float64_array, + napi_bigint64_array, + napi_biguint64_array, +#define NODE_API_HAS_FLOAT16_ARRAY + napi_float16_array, +} napi_typedarray_type; + +typedef enum { + napi_ok, + napi_invalid_arg, + napi_object_expected, + napi_string_expected, + napi_name_expected, + napi_function_expected, + napi_number_expected, + napi_boolean_expected, + napi_array_expected, + napi_generic_failure, + napi_pending_exception, + napi_cancelled, + napi_escape_called_twice, + napi_handle_scope_mismatch, + napi_callback_scope_mismatch, + napi_queue_full, + napi_closing, + napi_bigint_expected, + napi_date_expected, + napi_arraybuffer_expected, + napi_detachable_arraybuffer_expected, + napi_would_deadlock, // unused + napi_no_external_buffers_allowed, + napi_cannot_run_js, +} napi_status; +// Note: when adding a new enum value to `napi_status`, please also update +// * `const int last_status` in the definition of `napi_get_last_error_info()' +// in file js_native_api_v8.cc. +// * `const char* error_messages[]` in file js_native_api_v8.cc with a brief +// message explaining the error. +// * the definition of `napi_status` in doc/api/n-api.md to reflect the newly +// added value(s). + +typedef napi_value(NAPI_CDECL* napi_callback)(napi_env env, + napi_callback_info info); +typedef void(NAPI_CDECL* napi_finalize)(napi_env env, + void* finalize_data, + void* finalize_hint); + +#if !defined(NAPI_EXPERIMENTAL) || \ + (defined(NAPI_EXPERIMENTAL) && \ + (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \ + defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) +typedef napi_finalize node_api_nogc_finalize; +#else +typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env, + void* finalize_data, + void* finalize_hint); +#endif +typedef node_api_nogc_finalize node_api_basic_finalize; + +// A finalizer that can be called from any thread and at any time. +typedef void(NAPI_CDECL* node_api_noenv_finalize)(void* finalize_data, + void* finalize_hint); + +typedef struct { + // One of utf8name or name should be NULL. + const char* utf8name; + napi_value name; + + napi_callback method; + napi_callback getter; + napi_callback setter; + napi_value value; + + napi_property_attributes attributes; + void* data; +} napi_property_descriptor; + +typedef struct { + const char* error_message; + void* engine_reserved; + uint32_t engine_error_code; + napi_status error_code; +} napi_extended_error_info; + +#if NAPI_VERSION >= 6 +typedef enum { + napi_key_include_prototypes, + napi_key_own_only +} napi_key_collection_mode; + +typedef enum { + napi_key_all_properties = 0, + napi_key_writable = 1, + napi_key_enumerable = 1 << 1, + napi_key_configurable = 1 << 2, + napi_key_skip_strings = 1 << 3, + napi_key_skip_symbols = 1 << 4 +} napi_key_filter; + +typedef enum { + napi_key_keep_numbers, + napi_key_numbers_to_strings +} napi_key_conversion; +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 8 +typedef struct { + uint64_t lower; + uint64_t upper; +} napi_type_tag; +#endif // NAPI_VERSION >= 8 + +#endif // SRC_JS_NATIVE_API_TYPES_H_ diff --git a/bench/profile/native-clock/include/node_api.h b/bench/profile/native-clock/include/node_api.h new file mode 100644 index 000000000..46dbb02b4 --- /dev/null +++ b/bench/profile/native-clock/include/node_api.h @@ -0,0 +1,265 @@ +#ifndef SRC_NODE_API_H_ +#define SRC_NODE_API_H_ + +#if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN) +#ifdef _WIN32 +// Building native addon against node +#define NAPI_EXTERN __declspec(dllimport) +#elif defined(__wasm__) +#define NAPI_EXTERN __attribute__((__import_module__("napi"))) +#endif +#endif +#include "js_native_api.h" +#include "node_api_types.h" + +struct uv_loop_s; // Forward declaration. + +#ifdef _WIN32 +#define NAPI_MODULE_EXPORT __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#define NAPI_MODULE_EXPORT \ + __attribute__((visibility("default"))) __attribute__((used)) +#else +#define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) +#endif +#endif + +#if defined(__GNUC__) +#define NAPI_NO_RETURN __attribute__((noreturn)) +#elif defined(_WIN32) +#define NAPI_NO_RETURN __declspec(noreturn) +#else +#define NAPI_NO_RETURN +#endif + +// Used by deprecated registration method napi_module_register. +typedef struct napi_module { + int nm_version; + unsigned int nm_flags; + const char* nm_filename; + napi_addon_register_func nm_register_func; + const char* nm_modname; + void* nm_priv; + void* reserved[4]; +} napi_module; + +#define NAPI_MODULE_VERSION 1 + +#define NAPI_MODULE_INITIALIZER_X(base, version) \ + NAPI_MODULE_INITIALIZER_X_HELPER(base, version) +#define NAPI_MODULE_INITIALIZER_X_HELPER(base, version) base##version + +#ifdef __wasm__ +#define NAPI_MODULE_INITIALIZER_BASE napi_register_wasm_v +#else +#define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v +#endif + +#define NODE_API_MODULE_GET_API_VERSION_BASE node_api_module_get_api_version_v + +#define NAPI_MODULE_INITIALIZER \ + NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION) + +#define NODE_API_MODULE_GET_API_VERSION \ + NAPI_MODULE_INITIALIZER_X(NODE_API_MODULE_GET_API_VERSION_BASE, \ + NAPI_MODULE_VERSION) + +#define NAPI_MODULE_INIT() \ + EXTERN_C_START \ + NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION(void) { \ + return NAPI_VERSION; \ + } \ + NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ + napi_value exports); \ + EXTERN_C_END \ + napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports) + +#define NAPI_MODULE(modname, regfunc) \ + NAPI_MODULE_INIT() { return regfunc(env, exports); } + +// Deprecated. Use NAPI_MODULE. +#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ + NAPI_MODULE(modname, regfunc) + +EXTERN_C_START + +// Deprecated. Replaced by symbol-based registration defined by NAPI_MODULE +// and NAPI_MODULE_INIT macros. +NAPI_EXTERN void NAPI_CDECL +napi_module_register(napi_module* mod); + +NAPI_EXTERN NAPI_NO_RETURN void NAPI_CDECL +napi_fatal_error(const char* location, + size_t location_len, + const char* message, + size_t message_len); + +// Methods for custom handling of async operations +NAPI_EXTERN napi_status NAPI_CDECL +napi_async_init(napi_env env, + napi_value async_resource, + napi_value async_resource_name, + napi_async_context* result); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_async_destroy(napi_env env, napi_async_context async_context); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_make_callback(napi_env env, + napi_async_context async_context, + napi_value recv, + napi_value func, + size_t argc, + const napi_value* argv, + napi_value* result); + +// Methods to provide node::Buffer functionality with napi types +NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer(napi_env env, + size_t length, + void** data, + napi_value* result); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_external_buffer(napi_env env, + size_t length, + void* data, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_value* result); +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + +#if NAPI_VERSION >= 10 + +NAPI_EXTERN napi_status NAPI_CDECL +node_api_create_buffer_from_arraybuffer(napi_env env, + napi_value arraybuffer, + size_t byte_offset, + size_t byte_length, + napi_value* result); +#endif // NAPI_VERSION >= 10 + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env, + size_t length, + const void* data, + void** result_data, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_is_buffer(napi_env env, + napi_value value, + bool* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_buffer_info(napi_env env, + napi_value value, + void** data, + size_t* length); + +// Methods to manage simple async operations +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_async_work(napi_env env, + napi_value async_resource, + napi_value async_resource_name, + napi_async_execute_callback execute, + napi_async_complete_callback complete, + void* data, + napi_async_work* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env, + napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL +napi_cancel_async_work(node_api_basic_env env, napi_async_work work); + +// version management +NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version( + node_api_basic_env env, const napi_node_version** version); + +#if NAPI_VERSION >= 2 + +// Return the current libuv event loop for a given environment +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop); + +#endif // NAPI_VERSION >= 2 + +#if NAPI_VERSION >= 3 + +NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env, + napi_value err); + +NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook( + node_api_basic_env env, napi_cleanup_hook fun, void* arg); + +NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook( + node_api_basic_env env, napi_cleanup_hook fun, void* arg); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_open_callback_scope(napi_env env, + napi_value resource_object, + napi_async_context context, + napi_callback_scope* result); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_close_callback_scope(napi_env env, napi_callback_scope scope); + +#endif // NAPI_VERSION >= 3 + +#if NAPI_VERSION >= 4 + +// Calling into JS from other threads +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_threadsafe_function(napi_env env, + napi_value func, + napi_value async_resource, + napi_value async_resource_name, + size_t max_queue_size, + size_t initial_thread_count, + void* thread_finalize_data, + napi_finalize thread_finalize_cb, + void* context, + napi_threadsafe_function_call_js call_js_cb, + napi_threadsafe_function* result); + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context( + napi_threadsafe_function func, void** result); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_call_threadsafe_function(napi_threadsafe_function func, + void* data, + napi_threadsafe_function_call_mode is_blocking); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_acquire_threadsafe_function(napi_threadsafe_function func); + +NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function( + napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); + +NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function( + node_api_basic_env env, napi_threadsafe_function func); + +NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function( + node_api_basic_env env, napi_threadsafe_function func); + +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 8 + +NAPI_EXTERN napi_status NAPI_CDECL +napi_add_async_cleanup_hook(node_api_basic_env env, + napi_async_cleanup_hook hook, + void* arg, + napi_async_cleanup_hook_handle* remove_handle); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle); + +#endif // NAPI_VERSION >= 8 + +#if NAPI_VERSION >= 9 + +NAPI_EXTERN napi_status NAPI_CDECL +node_api_get_module_file_name(node_api_basic_env env, const char** result); + +#endif // NAPI_VERSION >= 9 + +EXTERN_C_END + +#endif // SRC_NODE_API_H_ diff --git a/bench/profile/native-clock/include/node_api_types.h b/bench/profile/native-clock/include/node_api_types.h new file mode 100644 index 000000000..79123f042 --- /dev/null +++ b/bench/profile/native-clock/include/node_api_types.h @@ -0,0 +1,58 @@ +#ifndef SRC_NODE_API_TYPES_H_ +#define SRC_NODE_API_TYPES_H_ + +#include "js_native_api_types.h" + +typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env, + napi_value exports); +// False positive: https://github.com/cpplint/cpplint/issues/409 +// NOLINTNEXTLINE (readability/casting) +typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void); + +typedef struct napi_callback_scope__* napi_callback_scope; +typedef struct napi_async_context__* napi_async_context; +typedef struct napi_async_work__* napi_async_work; + +#if NAPI_VERSION >= 3 +typedef void(NAPI_CDECL* napi_cleanup_hook)(void* arg); +#endif // NAPI_VERSION >= 3 + +#if NAPI_VERSION >= 4 +typedef struct napi_threadsafe_function__* napi_threadsafe_function; +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 4 +typedef enum { + napi_tsfn_release, + napi_tsfn_abort +} napi_threadsafe_function_release_mode; + +typedef enum { + napi_tsfn_nonblocking, + napi_tsfn_blocking +} napi_threadsafe_function_call_mode; +#endif // NAPI_VERSION >= 4 + +typedef void(NAPI_CDECL* napi_async_execute_callback)(napi_env env, void* data); +typedef void(NAPI_CDECL* napi_async_complete_callback)(napi_env env, + napi_status status, + void* data); +#if NAPI_VERSION >= 4 +typedef void(NAPI_CDECL* napi_threadsafe_function_call_js)( + napi_env env, napi_value js_callback, void* context, void* data); +#endif // NAPI_VERSION >= 4 + +typedef struct { + uint32_t major; + uint32_t minor; + uint32_t patch; + const char* release; +} napi_node_version; + +#if NAPI_VERSION >= 8 +typedef struct napi_async_cleanup_hook_handle__* napi_async_cleanup_hook_handle; +typedef void(NAPI_CDECL* napi_async_cleanup_hook)( + napi_async_cleanup_hook_handle handle, void* data); +#endif // NAPI_VERSION >= 8 + +#endif // SRC_NODE_API_TYPES_H_ diff --git a/bench/profile/probe-profile-01.mjs b/bench/profile/probe-profile-01.mjs new file mode 100644 index 000000000..47e3ea3e9 --- /dev/null +++ b/bench/profile/probe-profile-01.mjs @@ -0,0 +1,145 @@ +// PROFILE-01 probe: исполняемый измерительный стенд. +// Измерение размера использует обычную среду CI публичного репозитория. +// Оно не доказывает задержку, частоту кадров или свойства физического устройства. +// Недействительная калибровка или расхождение с протоколом запрещают допуск. +// Использование: node bench/profile/probe-profile-01.mjs --mode old-vector|aa|ab --cells desktop|all --out + +import { createHash } from 'node:crypto'; +import { mkdirSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { + PROFILE_01, + preregistrationDigest, + verifyPreregistration, + unmeasuredCells, +} from './profile-01-preregistration.mjs'; +import { PREREG_OWN_PATHS, makeGit } from './profile-git-proof.mjs'; +import { measureOldVector } from './profile-measurement.mjs'; + +function fail(message) { + throw new Error(`PROFILE-01 probe (fail-closed): ${message}`); +} + +function arg(name) { + const index = process.argv.indexOf(name); + if (index === -1) return undefined; + for (let occurrence = index; occurrence !== -1; occurrence = process.argv.indexOf(name, occurrence + 1)) { + const value = process.argv[occurrence + 1]; + if (value === undefined || value.length === 0 || value.startsWith('-')) fail(`флаг ${name} требует значение`); + } + return process.argv[index + 1]; +} + +const git = makeGit(fail); + +function writeArtifact(outDir, artifact, head, digest) { + const rawPath = join(outDir, `profile-01-${artifact.mode}-${head.slice(0, 12)}.json`); + const rawBytes = `${JSON.stringify(artifact, null, 2)}\n`; + writeFileSync(rawPath, rawBytes); + const rawDigest = createHash('sha256').update(rawBytes).digest('hex'); + // eslint-disable-next-line no-console + console.log(JSON.stringify({ rawPath, rawDigest, preregistrationDigest: digest, admission: artifact.admission })); +} + +// Отказ после измерения сохраняет артефакт с причиной и хешем. +// Отказ до измерения ещё не создаёт данных для сохранения. +function persistAndFail(outDir, artifact, head, digest, reason) { + artifact.finishedAtUtc = new Date().toISOString(); + artifact.admission = 'NOT-GRANTED'; + artifact.rejection = reason; + writeArtifact(outDir, artifact, head, digest); + fail(reason); +} + +async function main() { + const repoRoot = fileURLToPath(new URL('../../', import.meta.url)); + const mode = arg('--mode') ?? fail('требуется --mode old-vector|aa|ab'); + if (!['old-vector', 'aa', 'ab'].includes(mode)) fail(`неизвестный --mode ${mode}`); + const cells = arg('--cells') ?? 'desktop'; + if (!['desktop', 'all'].includes(cells)) fail(`неизвестный --cells ${cells}`); + const outDir = resolve(arg('--out') ?? join(tmpdir(), 'profile-01-raw')); + mkdirSync(outDir, { recursive: true }); + + // Протокол проверяется до любых измерений. + verifyPreregistration(PROFILE_01); + const digest = preregistrationDigest(PROFILE_01); + + // 2. Точный base/provenance. + const head = git.head(repoRoot); + const artifact = { + node: 'PROFILE-01', + revision: 'r11', + mode, + cells, + preregistrationDigest: digest, + candidateSamplesObservedAtRegistration: false, + head, + sizeGateBlob: null, + baseProof: null, + seed: 20260929, + startedAtUtc: new Date().toISOString(), + cellsMeasured: [], + cellsUnproven: unmeasuredCells(cells), + rawControls: {}, + calibration: {}, + costVector: null, + admission: 'NOT-GRANTED', + rejection: null, + }; + + if (mode === 'old-vector') { + const base = PROFILE_01.productBase.sourceSha; + if (!git.ancestor(repoRoot, base)) fail(`old-vector требует HEAD, выросший из PRODUCT_BASE ${base}`); + const sizeGateBlob = git.blob(repoRoot, 'HEAD', 'scripts/size-gate.mjs'); + if (sizeGateBlob !== PROFILE_01.productBase.sizeGateBlob) { + fail(`size-gate provenance drifted: ${sizeGateBlob}`); + } + // Рабочая копия обязана совпадать с коммитом: иначе измеритель + // исполнит непроверенный файл, а baseProof этого не покажет. + const workingSizeGateBlob = git.workingBlob(repoRoot, 'scripts/size-gate.mjs'); + if (workingSizeGateBlob !== sizeGateBlob) { + fail(`рабочая копия size-gate.mjs отличается от коммита: working ${workingSizeGateBlob}, committed ${sizeGateBlob}`); + } + const diffPaths = head === base ? [] : git.diffNames(repoRoot, base, head); + const foreign = diffPaths.filter((path) => !PREREG_OWN_PATHS.includes(path)); + if (foreign.length > 0) fail(`измеряемое дерево отличается от PRODUCT_BASE вне prereg-пакета: ${foreign.join(', ')}`); + artifact.sizeGateBlob = sizeGateBlob; + artifact.baseProof = { productBase: base, head, diffPaths }; + try { + artifact.costVector = await measureOldVector(repoRoot); + } catch (error) { + persistAndFail(outDir, artifact, head, digest, `незавершённое измерение: ${error.message}`); + } + if (artifact.costVector.exitCode !== 0) { + persistAndFail(outDir, artifact, head, digest, `старый cost vector не зелёный на PRODUCT_BASE (exit ${artifact.costVector.exitCode})`); + } + for (const name of Object.keys(PROFILE_01.oldCostVectorGzipBytes.scenarios)) { + if (!artifact.costVector.scenarios.some((row) => row.name === name)) { + persistAndFail(outDir, artifact, head, digest, `size-gate не содержит сценарий ${name}`); + } + } + artifact.cellsMeasured.push('desktop-size-vector'); + } + + // 4. Калибровка: A/A и deliberate 2×work обязаны быть явными. + // Детализация timing-калибровки — в отдельной browser-фазе; + // без пройденной калибровки admission не выдаётся (см. ниже). + artifact.calibration = { aa: 'PENDING', positive2x: 'PENDING' }; + + // Без калибровки aa/ab сохраняют отказ до завершения процесса. + if (mode !== 'old-vector') { + persistAndFail(outDir, artifact, head, digest, 'aa/ab режимы требуют отдельной зелёной browser-калибровки'); + } + const ready = mode === 'old-vector' && artifact.costVector !== null; + artifact.finishedAtUtc = new Date().toISOString(); + artifact.admission = ready ? 'OLD-VECTOR-ONLY' : 'NOT-GRANTED'; + if (!ready) { + persistAndFail(outDir, artifact, head, digest, 'old-vector не готов: costVector отсутствует'); + } + + writeArtifact(outDir, artifact, head, digest); +} + +await main(); diff --git a/bench/profile/profile-01-preregistration.mjs b/bench/profile/profile-01-preregistration.mjs new file mode 100644 index 000000000..71329e1f2 --- /dev/null +++ b/bench/profile/profile-01-preregistration.mjs @@ -0,0 +1,216 @@ +// Исполняемый контракт PROFILE-01. Версия закрепляется до измерений кандидата. +// Неизмеренные клетки сохраняют UNPROVEN и не дают допуска A/B. + +import { createHash } from 'node:crypto'; +import { isDeepStrictEqual } from 'node:util'; + +function deepFreeze(value) { + if (value !== null && typeof value === 'object') { + for (const child of Object.values(value)) deepFreeze(child); + Object.freeze(value); + } + return value; +} + +function invariant(condition, message) { + if (!condition) throw new Error(`PROFILE-01 preregistration: ${message}`); +} + +// Точный main после исправления зависимостей тестов. +// Runtime, размерный измеритель и потолки прежнего baseline сохранены. +export const PRODUCT_BASE = Object.freeze({ + repo: 'Labpics-Team/lab-motion', + sourceSha: '7d3ed42e5b054a06e4f6ca7f0c2efc02484e20fd', + upstreamMainSha: '7d3ed42e5b054a06e4f6ca7f0c2efc02484e20fd', + sizeGateBlob: '4b0f181212b65a881e750e84564778f5828448a3', + reason: 'исправление безопасности зависимостей; runtime и размерные потолки сохранены', +}); + +// Полный старый cost vector: потолки кода, а не новые оценки. +// Происхождение: scripts/size-gate.mjs, PRODUCT_BASE.sizeGateBlob. +// Архивные фактические размеры новым измерением не являются: +// метод повторного снятия — node scripts/size-gate.mjs на exact base. +export const OLD_COST_VECTOR_GZIP_BYTES = Object.freeze({ + core: 2220, + subpath: 4608, + fullCoreConsumer: 2330, + nano: 1024, + compiledRuntime: 341, + compilerSurface: 1024, + inView: 1839, + inViewConsumer: 1908, + compositorCapability: 6600, + fullAnimate: 15600, + animateCompositorMixed: 17500, + bespoke: Object.freeze({ + './behaviors/reorder': 1518, + './utils': 1400, + './compiler/vite': 9163, + './compiler/runtime': 341, + './compositor': 6450, + './compositor/stagger': 6450, + './tokens': 1650, + './projection': 5750, + './smart': 7450, + './presets': 5600, + './animate': 15600, + './nano': 1024, + './compiler/surface': 1024, + './in-view': 1839, + './behaviors': 4600, + }), + scenarios: Object.freeze({ + 'reorder-controlled': 1522, + 'nano spring-to': 1024, + 'surface executor': 1024, + 'in-view one-liner': 1908, + 'only-spring': 920, + 'projection-core-only': 720, + 'projection-dom-one-liner': 5750, + 'only-MotionValue': 1660, + 'full-core': 2330, + 'compositor-stagger capability': 6600, + 'animate + compositor': 17500, + 'only-clamp (utils tree-shake)': 340, + 'animate-one-liner (фасад)': 15600, + 'animate component scope': 15700, + 'behaviors-sheet-one-liner': 3700, + }), + brotliAndTotals: 'initial+reachable total, CSS/data/lazy chunks и Brotli снимаются тем же прогоном size-gate на exact base; знаменатели не смешиваются', +}); + +// Классы устройств по r11 §PROFILE-01. Конкретные модели и версии выбираются +// до измерений кандидата; флагман не заменяет устройство среднего класса. +export const ROSTER = Object.freeze({ + classes: Object.freeze([ + Object.freeze({ id: 'android-mid-60', device: 'физический Android среднего класса', refreshHz: 60, browsers: ['chromium-webview-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'android-mid-120', device: 'физический Android среднего класса с экраном 120 Гц', refreshHz: 120, browsers: ['chromium-webview-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'ios-60', device: 'физическое устройство iOS', refreshHz: 60, browsers: ['webkit-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'ios-120', device: 'физическое устройство iOS с ProMotion', refreshHz: 120, browsers: ['webkit-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'desktop-chromium', device: 'настольный Linux на собственном runner', refreshHz: null, browsers: ['chromium-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'desktop-firefox', device: 'настольный Linux на собственном runner', refreshHz: null, browsers: ['firefox-stable'], status: 'UNPROVEN' }), + Object.freeze({ id: 'desktop-webkit', device: 'настольный Linux на собственном runner', refreshHz: null, browsers: ['webkit-stable'], status: 'UNPROVEN' }), + ]), + selectionRule: 'модели и версии ОС — первые доступные репрезентативные устройства собственного парка; выбор фиксируется до измерений кандидата', + no120HzRule: 'когда device не умеет 120 Hz, 120 Hz target ему не приписывается, но 60 Hz задача остаётся', + cpuThrottleNote: 'CPU-throttle desktop — диагностический контроль, не mobile proof; порог M-04 не выводится из быстрого сервера', + fixedConditions: Object.freeze([ + 'температура, питание и состояние экрана', 'нагрузка', 'фоновые процессы', 'viewport/DPR/content', + 'источники времени', 'warm/cold режимы', 'единицы выборки', 'N/iterations/seed', 'все знаменатели', + ]), +}); + +// Отсутствие оборудования затрагивает отдельные клетки. Клетка без устройства остаётся +// UNPROVEN и блокирует A/B admission своей клетки; unit/browser подготовка +// при этом не останавливается, платная закупка без допуска запрещена. +export const AFFECTED_CELLS_MISSING_HW = Object.freeze([ + Object.freeze({ cell: 'android-mid-120', blocks: 'A/B admission 120 Hz Android-клетки; 60 Hz задача независима' }), + Object.freeze({ cell: 'ios-120', blocks: 'A/B admission 120 Hz iOS-клетки; 60 Hz задача независима' }), + Object.freeze({ cell: 'whole-page energy/GPU', blocks: 'выводы M-04/M-05 о полной стоимости устройства; frame CPU-time клетки независимы' }), +]); + +// Замороженные сцены измерения (выбор ДО samples, смена выбора = новая регистрация). +// M-04: 100 активных скалярных каналов, p99 собственного CPU-time Lab Motion ≤0,5 ms/frame; +// полный 120 Hz сценарий: верхняя 95% граница доли пропущенных кадров ≤0,1%. +// M-05: две тяжёлые сцены разных семейств, верхняя 95% граница candidate/best ≤0,50. +export const SCENES = Object.freeze({ + m04channels: Object.freeze({ + id: 'm04-100-scalar-channels', + channels: 100, + fixture: 'behaviors-sheet heavy scene (createBottomSheet, snapPoints [0, 300, 600])', + acceptance: 'p99 собственного CPU-time Lab Motion ≤0,5 ms/frame; OS/browser/render отдельно; deliberate extra work различается стендом', + }), + m04full120: Object.freeze({ + id: 'm04-full-120hz', + acceptance: 'верхняя 95% граница доли пропущенных кадров ≤0,1% выбранного 120 Hz сценария', + }), + m05a: Object.freeze({ + id: 'm05-sheet', + family: 'непосредственное управление (sheet)', + fixture: 'behaviors-sheet-one-liner consumer (gate 3700 B gzip)', + acceptance: 'верхняя 95% граница candidate/best ≤0,50 по доминирующей устранимой стоимости; protected клетки не хуже', + }), + m05b: Object.freeze({ + id: 'm05-list', + family: 'изменяемая коллекция (фильтруемый/переставляемый список)', + fixture: 'reorder-controlled consumer (gate 1522 B gzip)', + acceptance: 'верхняя 95% граница candidate/best ≤0,50 по доминирующей устранимой стоимости; protected клетки не хуже', + }), + rawControlRule: 'для raw control с нулевой стоимостью отношение не вычисляется: требуется совпадение границы и выигрыш другой содержательной метрики', +}); + +// Каждый A/B сопровождается полным набором контрольных измерений. +export const RAW_CONTROLS = Object.freeze({ + noMotion: 'статический кадр без движения обязан совпадать попиксельно с точностью оракула', + reducedMotion: 'при reduced-motion частые действия имеют путь без движения', + waapi: 'платформенный контроль bench/compare/waapi-control.entry', + oldLab: 'old-Lab profile на том же стенде (PRODUCT_BASE без кандидата)', + bestComparator: 'best-comparator: Motion, Anime Animatable/Layout и raw platform; Rive только в совпадающих authoring/handoff задачах', + aa: 'A/A: тот же build дважды; обязан различить отсутствие изменения в non-inferiority полосе', + positive: 'deliberate 2×work положительный контроль обязан детектироваться', +}); + +// Статистика и MDE. Единица независимости — прогон (run); кадры/каналы внутри +// прогона зависимы и не создают фиктивное число участников. +export const STATS_MDE = Object.freeze({ + independenceUnit: 'run (device × build × scene × mode блок)', + design: 'парный/блочный дизайн, warm+cold режимы', + sampleSize: 'N из заранее выбранных MDE/power и null-pilot оценки дисперсии; N замораживается до A/B', + seed: 'фиксированный seed публикуется в артефакте', + stoppingRule: 'правило остановки фиксировано заранее; добор samples после просмотра запрещён', + coverage: 'family-wise 95% coverage либо заранее утверждённая multiplicity correction', + noRepeatToGreen: 'повтор того же опыта до green не допускается; failed A/A = UNPROVEN + baseline RCA, не NO-GO идеи', +}); + +// Неудачные измерения сохраняются вместе с успешными. +export const OBSERVATION_POLICY = Object.freeze({ + preserve: Object.freeze(['все samples', 'отказы', 'зависания', 'GC/JIT/context switches', 'повреждённые квитанции']), + rawAndDigest: 'сырые данные + внешний digest (sha256) в артефакте; команды и метод позволяют независимый replay', + retention: 'истечение Actions artifact не удаляет единственную копию proof: компактный witness у research owner, raw по durable artifact policy', + forcedGc: 'forced GC допустим только в выделенном retention proof, не в timing', + denominators: 'initial, reachable total, cold/warm-compile, startup, interruption, frame, teardown, import/build, peak/retained — свои знаменатели', +}); + +// Недействительная калибровка запрещает допуск кандидата. +export const CALIBRATION = Object.freeze({ + aaBand: 'A/A обязан показать отсутствие изменения в исходной non-inferiority полосе; старый p95 admission upper ≤1,05 и остальные условия не меняются', + positiveDetection: 'deliberate 2×work обязан детектироваться стендом', + failClosed: 'invalid calibration → candidate admission не запускается; baseline-only RCA меняет метод лишь с конкретным дефектом/новой предпосылкой', + staleProfile: 'профиль, снятый не на зарегистрированном roster/base, к admission не допускается', +}); + +export const PROFILE_01 = deepFreeze({ + node: 'PROFILE-01', + revision: 'r11', + productBase: PRODUCT_BASE, + oldCostVectorGzipBytes: OLD_COST_VECTOR_GZIP_BYTES, + roster: ROSTER, + affectedCellsMissingHw: AFFECTED_CELLS_MISSING_HW, + scenes: SCENES, + rawControls: RAW_CONTROLS, + statsMde: STATS_MDE, + observationPolicy: OBSERVATION_POLICY, + calibration: CALIBRATION, + candidateSamplesObservedAtRegistration: false, +}); + +export function preregistrationDigest(value = PROFILE_01) { + return createHash('sha256').update(JSON.stringify(value)).digest('hex'); +} + +// Размер пакета не измеряет временные клетки roster. Имя runner и переменная +// среды не превращают отсутствие измерения в доказательство. +export function unmeasuredCells(cells) { + invariant(cells === 'desktop' || cells === 'all', 'неизвестный набор клеток'); + return PROFILE_01.roster.classes + .filter((cell) => cells === 'all' || cell.id.startsWith('desktop-')) + .map((cell) => ({ cell: cell.id, reason: 'временные метрики и калибровка устройства не измерены', blocks: 'допуск A/B для этой клетки' })) + .concat([{ cell: 'whole-page energy/GPU', reason: 'энергия и GPU устройства не измерены', blocks: 'выводы M-04/M-05 о полной стоимости устройства' }]); +} + +// Вход сравнивается целиком с одним неизменяемым протоколом. Его версию +// закрепляют commit, независимое ревью и CI; копия констант рядом не нужна. +export function verifyPreregistration(value = PROFILE_01) { + invariant(isDeepStrictEqual(value, PROFILE_01), 'контракт отличается от зарегистрированного протокола'); + return true; +} diff --git a/bench/profile/profile-git-proof.mjs b/bench/profile/profile-git-proof.mjs new file mode 100644 index 000000000..87d28efbd --- /dev/null +++ b/bench/profile/profile-git-proof.mjs @@ -0,0 +1,65 @@ +// PROFILE-01 git-proof: общие git-доказательства provenance для probe и validator. +// Один источник PREREG_OWN_PATHS исключает дрейф allowlist между файлами. +// Недоступность Git запрещает допуск через переданный обработчик отказа. + +import { execFileSync } from 'node:child_process'; +import { readCheckoutState } from '../compare/provenance.mjs'; + +// Измеряемое дерево обязано совпадать с PRODUCT_BASE везде, кроме самих +// файлов preregistration-пакета. Это позволяет снимать old-vector на +// PR-ветке, выросшей из PRODUCT_BASE, с доказанной эквивалентностью. +export const PREREG_OWN_PATHS = Object.freeze([ + 'bench/profile/profile-01-preregistration.mjs', + 'bench/profile/probe-profile-01.mjs', + 'bench/profile/validate-profile-01.mjs', + 'bench/profile/profile-git-proof.mjs', + 'bench/profile/profile-measurement.mjs', + 'test/profile-measurement.test.ts', + '.github/workflows/profile-01.yml', + '.github/workflows/ci.yml', + 'test/ci-workflow-contract.test.ts', +]); + +export function makeGit(fail) { + const head = (cwd) => { + let state; + try { + state = readCheckoutState(cwd); + } catch { + fail('git недоступен для доказательства provenance'); + } + if (state.dirty) fail('измерение требует clean checkout'); + return state.revision; + }; + const blob = (cwd, rev, path) => { + try { + return execFileSync('git', ['--no-replace-objects', 'rev-parse', `${rev}:${path}`], { cwd, encoding: 'utf8' }).trim(); + } catch { + fail(`git не смог доказать blob ${path}@${rev}`); + } + }; + const workingBlob = (cwd, path) => { + try { + return execFileSync('git', ['hash-object', '--', path], { cwd, encoding: 'utf8' }).trim(); + } catch { + fail(`git не смог доказать рабочий blob ${path}`); + } + }; + const diffNames = (cwd, base, headRef) => { + try { + const output = execFileSync('git', ['--no-replace-objects', 'diff', '--no-renames', '--name-only', `${base}`, `${headRef}`], { cwd, encoding: 'utf8' }); + return output.split('\n').map((line) => line.trim()).filter(Boolean); + } catch { + fail(`git не смог доказать эквивалентность дерева ${base}..${headRef}`); + } + }; + const ancestor = (cwd, base) => { + try { + execFileSync('git', ['--no-replace-objects', 'merge-base', '--is-ancestor', base, 'HEAD'], { cwd, stdio: 'ignore' }); + return true; + } catch { + return false; + } + }; + return { head, blob, workingBlob, diffNames, ancestor }; +} diff --git a/bench/profile/profile-measurement.mjs b/bench/profile/profile-measurement.mjs new file mode 100644 index 000000000..d2dcba38f --- /dev/null +++ b/bench/profile/profile-measurement.mjs @@ -0,0 +1,51 @@ +import { isDeepStrictEqual } from 'node:util'; +import { readFileSync } from 'node:fs'; +import { join } from 'node:path'; +import { CANONICAL_GZIP_PACKAGE } from '../../scripts/compression-policy.mjs'; +import { + prepareBenchmarkCheckout, + assertCheckoutUnchanged, + assertInstalledPackageTreesUnchanged, +} from '../compare/provenance.mjs'; + +// Сборка и identity принадлежат общему стенду; числа и потолки — size-gate. +// Адаптер сохраняет структурированный результат тех же измерений, что pnpm size. +export async function measureOldVector(root) { + const provenance = prepareBenchmarkCheckout({ + root, + benchDirectory: root, + requiredRootPackages: ['esbuild', CANONICAL_GZIP_PACKAGE], + }); + const gate = await import('../../scripts/size-gate.mjs'); + const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + const entries = gate.measureEntries(gate.deriveEntriesFromExports(pkg), root); + const scenarios = []; + for (const scenario of gate.IMPORT_COST_SCENARIOS) { + scenarios.push(await gate.measureScenario(scenario, join(root, 'dist/index.js'))); + } + const failed = entries.hasWarnings || scenarios.some((row) => row.error || gate.evaluateScenarioBudget(row).exceeded); + assertCheckoutUnchanged(root, provenance); + assertInstalledPackageTreesUnchanged(root, provenance.environment.rootPackages); + return { exitCode: failed ? 1 : 0, entries, scenarios, provenance }; +} + +export function validateReplayedVector(recorded, replayed) { + if (recorded?.exitCode !== 0 || replayed?.exitCode !== 0) { + throw new Error('PROFILE-01: старый cost vector не прошёл независимое измерение'); + } + if (!recorded.entries || !Array.isArray(recorded.scenarios) || recorded.scenarios.length === 0) { + throw new Error('PROFILE-01: отсутствуют структурированные измерения'); + } + for (const field of ['entries', 'scenarios']) { + if (!isDeepStrictEqual(recorded[field], replayed[field])) { + throw new Error(`PROFILE-01: ${field} не воспроизводится независимым измерением`); + } + } + // Время новой сборки отличается; исходники, inputs, dist и инструменты должны совпасть. + for (const field of ['revision', 'trackedRevisionSha256', 'inputs', 'distRuntime', 'environment']) { + if (recorded.provenance?.[field] === undefined || + !isDeepStrictEqual(recorded.provenance[field], replayed.provenance?.[field])) { + throw new Error(`PROFILE-01: provenance.${field} не совпадает при воспроизведении`); + } + } +} diff --git a/bench/profile/server-profile-artifact.mjs b/bench/profile/server-profile-artifact.mjs new file mode 100644 index 000000000..0c2c57f3e --- /dev/null +++ b/bench/profile/server-profile-artifact.mjs @@ -0,0 +1,39 @@ +import { closeSync, openSync, readFileSync, writeSync } from 'node:fs'; +import { createHash } from 'node:crypto'; +import path from 'node:path'; +import { pathToFileURL } from 'node:url'; +import { sha256Bytes } from '../compare/provenance.mjs'; +import { parseServerJsonBytes, parseServerJournalBytes, serverArtifactChunks, + validateServerArtifact, validateServerJournal } from './server-profile-contract.mjs'; + +// Файловый адаптер использует тот же carrier и проверки, что и контракт профиля. +// Эксклюзивное создание сохраняет уже записанный результат при повторном запуске. +export function writeServerArtifact(file, artifact) { + const descriptor = openSync(file, 'wx'), hash = createHash('sha256'); + let bytes = 0; + try { + for (const chunk of serverArtifactChunks(artifact)) { + const buffer = Buffer.from(chunk); hash.update(buffer); bytes += buffer.length; + let offset = 0; + while (offset < buffer.length) offset += writeSync(descriptor, buffer, offset, buffer.length - offset); + } + } finally { closeSync(descriptor); } + return { sha256: hash.digest('hex'), bytes }; +} + +if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) { + try { + const args = process.argv.slice(2); + if (args.length !== 6 || args[0] !== '--raw' || args[2] !== '--digest' || args[4] !== '--journal') { + throw new Error('server profile: нужны --raw --digest <внешний sha256> --journal '); + } + const raw = readFileSync(args[1]); + if (!/^[a-f0-9]{64}$/.test(args[3]) || sha256Bytes(raw) !== args[3]) { + throw new Error('server profile: не совпал внешний digest raw'); + } + const artifact = parseServerJsonBytes(raw); + const records = parseServerJournalBytes(readFileSync(args[5])); + const chronology = validateServerJournal(artifact, records, args[3]); + process.stdout.write(`${JSON.stringify({ ...validateServerArtifact(artifact), ...chronology })}\n`); + } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; } +} diff --git a/bench/profile/server-profile-contract.mjs b/bench/profile/server-profile-contract.mjs new file mode 100644 index 000000000..ebafc842e --- /dev/null +++ b/bench/profile/server-profile-contract.mjs @@ -0,0 +1,933 @@ +import { isDeepStrictEqual, types } from 'node:util'; +import { createHash } from 'node:crypto'; +import { assertBalancedRunBlocks, assertRealmTimerStep, binary64Ulp, deriveRealmTimerStep, evaluateStartSemanticEvidence, + exactBinomialOrderStatisticBounds, makeRoundRobinOrders, nextDown, nextUp, summarizeSamples } from '../compare/methodology.mjs'; +import { validateStockMotionValueBatch } from '../compare/methodology.mjs'; +import { TRANSFORM_PAIR_PROFILE, createTransformLifecycleValidator, validateTransformLifecycleSample } from '../../scripts/bench-transform-support.mjs'; +import { SERVER_PROFILE, planServerSampleSize, serverProfileDigest, serverTailPolicy, verifyServerProfile } from './server-profile-registration.mjs'; + +const SHA256 = /^[a-f0-9]{64}$/; +const SHA1 = /^[a-f0-9]{40}$/; +const IDS = ['left', 'right']; +function invariant(value, message) { + if (!value) throw new Error(`server profile: ${message}`); +} +function positive(value) { return Number.isFinite(value) && value > 0; } + +function meanBounds(bounds, denominator) { + let low = 0, high = 0; + for (const bound of bounds) { + low = Math.max(0, nextDown(low + bound.low)); high = nextUp(high + bound.high); + } + return { low: Math.max(0, nextDown(low / denominator)), high: nextUp(high / denominator) }; +} + +function errorBounds(value, error) { + invariant(Number.isFinite(value) && value >= 0 && positive(error), 'невалидная clock error boundary'); + return { low: Math.max(0, nextDown(value - error)), high: nextUp(value + error) }; +} + +// Observed quantum не удостоверяет error model. Error берётся из закреплённого +// upstream TimeClamper/TimeTicks и учитывает float conversion обеих reads. +export function serverBrowserClockBounds(clock, monotonicHostUpperNs) { + invariant(/^\d+$/.test(monotonicHostUpperNs ?? ''), 'нет общего CLOCK_MONOTONIC bound'); + const ns = BigInt(monotonicHostUpperNs); + invariant(ns > 0n && ns < BigInt(SERVER_PROFILE.clockError.monotonicCounterLimitMs) * 1_000_000n, 'CLOCK_MONOTONIC вне safe модели'); + // Запас1ms превышает conversion error Number(ns)/1e6 при limit2^42ms. + const upperMs = nextUp(Number(ns) / 1e6 + 1); + invariant(Number.isFinite(clock?.beginMs) && Number.isFinite(clock?.endMs) && clock.beginMs >= 0 && + clock.endMs >= clock.beginMs && clock.endMs <= upperMs, 'невалидные clock reads'); + const measuredMs = clock.endMs - clock.beginMs; + const endpointError = SERVER_PROFILE.clockError.browserClampErrorPerTimestampMs + SERVER_PROFILE.clockError.browserTickTruncationPerTimestampMs; + // Две conversions(now/origin) и subtraction на каждую read; ещё одна + // subtraction интервала. Origin одинаков, но его ошибка включена консервативно. + const errorMs = nextUp(nextUp(2 * endpointError) + nextUp(6 * binary64Ulp(upperMs) + binary64Ulp(measuredMs))); + return { ...errorBounds(measuredMs, errorMs), measuredMs, errorMs }; +} + +// В perf интервале общий origin сокращается. Сопоставление document frame +// с perf API включает три coarsened timestamps: frame, now и origin. +// Та же закреплённая модель даёт три endpoint envelopes и девять ULP; +// это semantic relation, не изменение uncertainty измеряемых API costs. +export function serverBrowserSemanticClockErrorMs(monotonicHostUpperNs) { + return nextUp(1.5 * serverBrowserClockBounds({ beginMs: 0, endMs: 0 }, monotonicHostUpperNs).errorMs); +} + +function compactCoordinates(values) { + if (!Array.isArray(values)) return values; + const runs = []; + for (const value of values) { + if (runs.length && Object.is(runs.at(-1)[1], value)) runs.at(-1)[0]++; + else runs.push([1, value]); + } + return { encoding: 'rle', count: values.length, runs }; +} + +function expandCoordinates(values, count) { + if (Array.isArray(values)) { invariant(values.length === count && Array.from(values).every(Number.isFinite), 'неполные normal-motion coordinates'); return values; } + invariant(values?.encoding === 'rle' && values.count === count && Array.isArray(values.runs) && + isDeepStrictEqual(Object.keys(values).sort(), ['count', 'encoding', 'runs']), 'неполные normal-motion RLE coordinates'); + const expanded = []; + for (const run of values.runs) { + invariant(Array.isArray(run) && run.length === 2 && Number.isSafeInteger(run[0]) && run[0] > 0 && + Number.isFinite(run[1]) && expanded.length + run[0] <= count, 'невалидный normal-motion RLE run'); + for (let i = 0; i < run[0]; i++) expanded.push(run[1]); + } + invariant(expanded.length === count, 'normal-motion RLE потерял targets'); + return expanded; +} + +function compactSemanticGroups(groups) { + if (!Array.isArray(groups)) return groups; + return groups.map((group) => group && typeof group === 'object' && !Array.isArray(group) && Object.hasOwn(group, 'positions') + ? { ...group, positions: compactCoordinates(group.positions) } : group); +} + +export function compactServerSemanticEvidence(evidence) { + if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return evidence; + // Отказ сохраняет приобретённый prefix и дополнительные поля, без создания отсутствующих наблюдений. + const compact = { ...evidence }; + if (Array.isArray(evidence.checkpoints)) compact.checkpoints = evidence.checkpoints.map((checkpoint) => + checkpoint && typeof checkpoint === 'object' && !Array.isArray(checkpoint) && Object.hasOwn(checkpoint, 'groups') + ? { ...checkpoint, groups: compactSemanticGroups(checkpoint.groups) } : checkpoint); + if (Array.isArray(evidence.terminal)) compact.terminal = evidence.terminal.map(compactCoordinates); + if (evidence.onset && typeof evidence.onset === 'object' && !Array.isArray(evidence.onset)) { + compact.onset = { ...evidence.onset }; + for (const phase of ['before', 'after']) { + if (Object.hasOwn(evidence.onset, phase)) compact.onset[phase] = compactSemanticGroups(evidence.onset[phase]); + } + if (Object.hasOwn(evidence.onset, 'firstFrame')) { + const first = evidence.onset.firstFrame; + compact.onset.firstFrame = first && typeof first === 'object' && !Array.isArray(first) && Object.hasOwn(first, 'groups') + ? { ...first, groups: compactSemanticGroups(first.groups) } : first; + } + } + return compact; +} + +function validateNormalMotion(evidence, scene, monotonicHostUpperNs) { + invariant(evidence?.valid === true && Array.isArray(evidence.checkpoints) && Array.isArray(evidence.terminal), 'нет normal-motion oracle'); + invariant(!evidence.failures?.length, 'normal-motion control потерял failure'); + const calls = SERVER_PROFILE.browserSemanticCalls; + invariant(evidence.terminal.length === calls && evidence.checkpoints.length === 3, 'потерян normal-motion checkpoint/call'); + invariant(evidence.onset && typeof evidence.onset === 'object' && !Array.isArray(evidence.onset), 'нет normal-motion onset observations'); + const onset = { ...evidence.onset }; + for (const phase of ['before', 'after']) { + invariant(Array.isArray(onset[phase]) && onset[phase].length === calls, `потеряна normal-motion onset ${phase} группа`); + onset[phase] = Array.from(onset[phase], (group) => { + invariant(group && typeof group === 'object' && !Array.isArray(group), `невалидная normal-motion onset ${phase} группа`); + return { ...group, positions: expandCoordinates(group.positions, scene.targetsPerCall) }; + }); + } + invariant(Number.isFinite(onset.firstFrame?.frameTimestampMs) && Array.isArray(onset.firstFrame.groups) && + onset.firstFrame.groups.length === calls, 'нет normal-motion first publication'); + onset.firstFrame = { ...onset.firstFrame, groups: onset.firstFrame.groups.map((group) => ({ ...group, + positions: expandCoordinates(group?.positions, scene.targetsPerCall) })) }; + // Clock/zero/phase law принадлежит общему oracle; decoder восстанавливает каждый target. + const expanded = { ...evidence, onset, checkpoints: evidence.checkpoints.map((checkpoint) => { + invariant(Number.isFinite(checkpoint.frameTimestampMs), 'нет observed normal-motion frame timestamp'); + invariant(Array.isArray(checkpoint.groups) && checkpoint.groups.length === calls, 'потеряна normal-motion группа'); + return { ...checkpoint, groups: checkpoint.groups.map((group) => ({ ...group, positions: expandCoordinates(group.positions, scene.targetsPerCall) })) }; + }), terminal: evidence.terminal.map((values) => expandCoordinates(values, scene.targetsPerCall)) }; + const semanticClockErrorMs = serverBrowserSemanticClockErrorMs(monotonicHostUpperNs); + const observedTimes = [...expanded.callStartedAtMs, expanded.onset.firstFrame.frameTimestampMs, + ...expanded.onset.firstFrame.groups.flatMap((group) => [group.readStartedMs, group.readEndedMs, group.documentFrame?.beforeMs, group.documentFrame?.afterMs]), + ...['before', 'after'].flatMap((phase) => expanded.onset[phase] + .flatMap((group) => [group.readStartedMs, group.readEndedMs, group.documentFrame?.beforeMs, group.documentFrame?.afterMs])), ...expanded.checkpoints.flatMap((checkpoint) => + [checkpoint.frameTimestampMs, ...checkpoint.groups.flatMap((group) => [group.readStartedMs, group.readEndedMs, + group.documentFrame?.beforeMs, group.documentFrame?.afterMs])])]; + invariant(observedTimes.every(Number.isFinite), 'неполные normal-motion clock observations'); + serverBrowserClockBounds({ beginMs: 0, endMs: Math.max(...observedTimes.map(Math.abs)) }, monotonicHostUpperNs); + invariant(evaluateStartSemanticEvidence(expanded, { ...scene, ...SERVER_PROFILE.browserSemantics, semanticClockErrorMs, + durationMs: SERVER_PROFILE.durationMs, toPx: SERVER_PROFILE.toPx }, calls), 'normal-motion oracle отверг intermediate/stagger/topology'); +} + +export function verifyServerClockRegistration(registration) { + const model = SERVER_PROFILE.clockError; + invariant(registration.browser === model.browser && registration.browserVersion === model.browserVersion && + registration.browserExecutableSha256 === model.browserExecutableSha256 && registration.clockModelDigest === serverProfileDigest(model), + 'browser binary/clock model не сертифицированы этим протоколом'); + const identity = registration.machine?.identity; + invariant(identity?.platform === 'linux' && identity.release === model.kernelRelease && identity.node === model.nodeVersion && identity.nodeExecutableSha256 === model.nodeExecutableSha256, + 'Node binary/platform не сертифицированы clock model'); + for (const provenance of Object.values(registration.provenance ?? {})) invariant(provenance.environment?.node === model.nodeVersion && + provenance.environment.nodeExecutableSha256 === model.nodeExecutableSha256, 'source toolchain не совпадает с clock model'); + const clock = registration.engineClock; + verifyThreadCpuIdentity(clock); + invariant(clock.schema === 1 && clock.napiVersion === 8 && clock.node?.version === model.nodeVersion && + clock.node.executableSha256 === model.nodeExecutableSha256, 'native CPU clock не соответствует Node/NAPI'); + invariant(isDeepStrictEqual(clock.nativeSources, model.nativeSourceFiles) && + clock.nativeSourceDigest === serverProfileDigest(Object.fromEntries(Object.entries(clock.nativeSources).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))), + 'native CPU clock source/header qualification не совпадает с регистрацией'); + invariant(typeof clock.nativeBinary?.path === 'string' && clock.nativeBinary.path.length > 0 && + Number.isSafeInteger(clock.nativeBinary.bytes) && clock.nativeBinary.bytes > 0 && SHA256.test(clock.nativeBinary.sha256), + 'неполное native CPU binary qualification'); + invariant(typeof clock.compiler?.path === 'string' && clock.compiler.path.length > 0 && + typeof clock.compiler.version === 'string' && clock.compiler.version.length > 0 && SHA256.test(clock.compiler.binarySha256) && + Array.isArray(clock.compiler.flags) && clock.compiler.flags.length > 0 && clock.compiler.flags.every((flag) => typeof flag === 'string' && flag.length > 0) && + typeof clock.libc?.path === 'string' && clock.libc.path.length > 0 && SHA256.test(clock.libc.sha256), 'неполное native CPU compiler/libc qualification'); + invariant(typeof clock.nominalResolutionNs === 'string' && /^[1-9]\d*$/.test(clock.nominalResolutionNs) && + clock.nominalResolutionIsNotErrorCertificate === true, 'nominal CPU resolution ошибочно выдана за error certificate'); +} + +function verifyThreadCpuIdentity(identity) { + invariant(identity?.clock === SERVER_PROFILE.clockError.engineClock && Number.isSafeInteger(identity.pid) && identity.pid > 0 && + Number.isSafeInteger(identity.tid) && identity.tid === identity.pid, 'невалидная native CPU clock main-thread identity'); +} + +const CPU_FIELDS = ['sequence', 'clock', 'pid', 'tid', 'seconds', 'nanoseconds', 'valueNs']; + +/** Метаданные объединяются в run; каждый приобретённый timespec остаётся отдельным. */ +export function compactServerCpuEvidence(reads) { + invariant(Array.isArray(reads) && !types.isProxy(reads), 'невалидный native CPU source array'); + if (reads.length === 0) return reads; + const keys = Reflect.ownKeys(reads); + invariant(Object.getPrototypeOf(reads) === Array.prototype && keys.length === reads.length + 1 && keys.at(-1) === 'length', + 'native CPU source array содержит лишние поля/prototype'); + const runs = []; + for (let sequence = 0; sequence < reads.length; sequence++) { + const descriptor = Object.getOwnPropertyDescriptor(reads, String(sequence)); + invariant(descriptor && Object.hasOwn(descriptor, 'value'), 'native CPU source потерял endpoint'); + const read = descriptor.value; + invariant(read && typeof read === 'object' && !types.isProxy(read) && + Object.getPrototypeOf(read) === Object.prototype && + isDeepStrictEqual(Reflect.ownKeys(read), CPU_FIELDS), 'неполные canonical native CPU fields'); + const fields = Object.getOwnPropertyDescriptors(read); + invariant(CPU_FIELDS.every((key) => Object.hasOwn(fields[key], 'value') && fields[key].enumerable), 'native CPU source содержит accessor/скрытое поле'); + invariant(read.sequence === sequence && !Object.is(read.sequence, -0) && read.clock === SERVER_PROFILE.clockError.engineClock && + Number.isSafeInteger(read.pid) && read.pid > 0 && read.tid === read.pid && + typeof read.seconds === 'string' && /^(0|[1-9]\d*)$/.test(read.seconds) && read.seconds.length <= 19 && + BigInt(read.seconds) <= 9_223_372_036_854_775_807n && Number.isSafeInteger(read.nanoseconds) && + read.nanoseconds >= 0 && !Object.is(read.nanoseconds, -0) && read.nanoseconds < 1_000_000_000, + 'невалидные canonical native CPU endpoint fields'); + // Производные поля проверяются до сжатия: ошибочный ordinal/valueNs не исправляется. + invariant(read.valueNs === String(BigInt(read.seconds) * 1_000_000_000n + BigInt(read.nanoseconds)), + 'native CPU source value не пересчитывается из timespec'); + let run = runs.at(-1); + if (!run || run.clock !== read.clock || run.pid !== read.pid || run.tid !== read.tid) { + run = { from: sequence, count: 0, clock: read.clock, pid: read.pid, tid: read.tid, values: [] }; + runs.push(run); + } + run.count++; run.values.push([read.seconds, read.nanoseconds]); + } + return { encoding: 'native-cpu-rle-v1', count: reads.length, runs }; +} + +/** Legacy arrays сохраняются; RLE восстанавливает все семь полей без Number conversion. */ +export function expandServerCpuEvidence(value, expectedCount) { + if (Array.isArray(value)) return value; + invariant(value?.encoding === 'native-cpu-rle-v1' && value.count === expectedCount && + Number.isSafeInteger(value.count) && value.count > 0 && Array.isArray(value.runs) && + isDeepStrictEqual(Object.keys(value).sort(), ['count', 'encoding', 'runs']), 'неполный native CPU RLE'); + const reads = []; + let previous; + for (const run of value.runs) { + invariant(run?.from === reads.length && !Object.is(run.from, -0) && Number.isSafeInteger(run.count) && run.count > 0 && + run.count <= expectedCount - reads.length && Array.isArray(run.values) && run.values.length === run.count && + isDeepStrictEqual(Object.keys(run).sort(), ['clock', 'count', 'from', 'pid', 'tid', 'values']), 'native CPU RLE потерял endpoint/run'); + invariant(!previous || previous.clock !== run.clock || previous.pid !== run.pid || previous.tid !== run.tid, + 'native CPU RLE содержит соседние дубликаты run'); + for (const fields of run.values) { + invariant(Array.isArray(fields) && fields.length === 2 && Object.hasOwn(fields, 0) && Object.hasOwn(fields, 1) && + typeof fields[0] === 'string' && /^(0|[1-9]\d*)$/.test(fields[0]) && fields[0].length <= 19 && + BigInt(fields[0]) <= 9_223_372_036_854_775_807n && Number.isSafeInteger(fields[1]) && fields[1] >= 0 && + !Object.is(fields[1], -0) && fields[1] < 1_000_000_000, 'native CPU RLE потерял canonical timespec tuple'); + reads.push({ sequence: reads.length, clock: run.clock, pid: run.pid, tid: run.tid, + seconds: fields[0], nanoseconds: fields[1], valueNs: String(BigInt(fields[0]) * 1_000_000_000n + BigInt(fields[1])) }); + } + previous = run; + } + invariant(reads.length === expectedCount, 'native CPU RLE потерял acquired suffix'); + return reads; +} + +export function serverOrders(runs, seed = SERVER_PROFILE.seed) { + const orders = makeRoundRobinOrders(IDS, runs, seed); + assertBalancedRunBlocks('server profile', orders, IDS); + return orders; +} + +export function serverMetricCells() { + return [ + ...SERVER_PROFILE.engineScenes.flatMap((scene) => (scene.metrics ?? SERVER_PROFILE.metrics.engine).map((metric) => ({ id: `${scene.id}:${metric}`, scene: scene.id, kind: 'engine', metric }))), + ...SERVER_PROFILE.browserScenes.flatMap((scene) => SERVER_PROFILE.metrics.browser.map((metric) => ({ id: `${scene.id}:${metric}`, scene: scene.id, kind: 'browser', metric }))), + ]; +} + +// Кадры/повторы остаются в raw. Admission использует один нормированный batch +// на run; независимая порядковая статистика использует среднее двух runs блока. +export function serverCellPairs(stage, runs, expectedStage, registeredClock) { + invariant(['warmup', 'pilot', 'aa', 'positive', 'ab'].includes(expectedStage) && stage?.name === expectedStage, 'имя стадии не соответствует владельцу artifact'); + if (registeredClock !== undefined) verifyThreadCpuIdentity(registeredClock); + invariant(stage?.rows?.length === runs * (SERVER_PROFILE.engineScenes.length + SERVER_PROFILE.browserScenes.length), 'неполная серия измерений'); + const expectedOrders = serverOrders(runs); + const seen = new Set(); + // Один sample имеет несколько проекций метрик. Проверка приобретённого raw + // принадлежит sample/scene/work, а не повторяется для каждой проекции. + const validationCache = new WeakMap(), validateTransform = createTransformLifecycleValidator(); + for (const row of stage.rows) { + const key = `${row.scene}:${row.run}`; + invariant(!seen.has(key), 'повторный run'); seen.add(key); + invariant(Number.isSafeInteger(row.run) && row.run >= 0 && row.run < runs && + isDeepStrictEqual(row.order, expectedOrders[row.run]), 'нарушен зарегистрированный порядок'); + invariant(isDeepStrictEqual(Object.keys(row.samples ?? {}).sort(), IDS), 'потерян участник'); + } + return serverMetricCells().map((cell) => { + const rows = stage.rows.filter((row) => row.scene === cell.scene).sort((a, b) => a.run - b.run); + invariant(rows.length === runs, 'потеряна сцена'); + invariant(rows.every((row) => row.kind === cell.kind), 'подменён вид сцены'); + const read = Object.fromEntries(IDS.map((id) => [id, rows.map((row) => readServerSample(row.samples[id], cell, + expectedStage === 'positive' && id === 'right' ? 2 : 1, validationCache, validateTransform, registeredClock))])); + return { ...cell, left: read.left.map((row) => row.value), right: read.right.map((row) => row.value), + leftBounds: read.left.map((row) => row.bounds), rightBounds: read.right.map((row) => row.bounds) }; + }); +} + +function readServerSample(sample, cell, workMultiplier, validationCache = new WeakMap(), validateTransform = validateTransformLifecycleSample, registeredClock) { + const stockScene = cell.kind === 'engine' && SERVER_PROFILE.engineScenes.find((scene) => scene.id === cell.scene && scene.workload === 'stock-c'); + invariant(sample?.semantic === true && positive(sample[cell.metric]), `${cell.id}: неверный sample или semantics`); + invariant(sample.workMultiplier === workMultiplier, 'подменён знаменатель положительного контроля'); + invariant(sample.denominator === SERVER_PROFILE.denominator && sample.repetitions === SERVER_PROFILE.repetitions, 'изменён знаменатель'); + invariant(Array.isArray(sample.raw) && sample.raw.length === sample.repetitions * (cell.kind === 'engine' && !stockScene ? sample.workMultiplier : 1), 'потеряны raw повторы'); + const validationKey = `${cell.kind}:${cell.scene}:${workMultiplier}`; + if (!validationCache.get(sample)?.has(validationKey)) { + if (cell.kind === 'engine') { + verifyThreadCpuIdentity(sample.cpuClock); + if (registeredClock) invariant(sample.cpuClock.clock === registeredClock.clock && sample.cpuClock.pid === registeredClock.pid && + sample.cpuClock.tid === registeredClock.tid, 'native CPU sample не связан с зарегистрированным main-thread'); + const scene = SERVER_PROFILE.engineScenes.find((scene) => scene.id === cell.scene); + let previousCpuNs = -1n; + if (stockScene) { + invariant(sample.cpuScope === SERVER_PROFILE.stockCpuScope && Array.isArray(sample.warmup) && sample.warmup.length === scene.warmupBatches, + 'stock C потерял canonical warmup или CPU scope'); + for (const batch of sample.warmup) validateStockMotionValueBatch(batch, scene, 1, false); + } + for (const raw of sample.raw) { + if (stockScene) { + validateStockMotionValueBatch(raw, scene, workMultiplier); + previousCpuNs = validateThreadCpuFields(raw.raw.cpuReads, raw.raw.clockReads, sample.cpuClock, previousCpuNs); + continue; + } + invariant(Array.isArray(raw.frameNs) && raw.frameNs.length === TRANSFORM_PAIR_PROFILE.frameOffsetsMs.length && + raw.frameNs.every((x) => Number.isSafeInteger(x) && x >= 0) && Number.isSafeInteger(raw.operationNs) && raw.operationNs >= 0 && + Number.isSafeInteger(raw.cancelDrainNs) && raw.cancelDrainNs >= 0, 'потеряны frame samples или safe CPU counter'); + validateTransform(raw, scene); + previousCpuNs = validateThreadCpuFields(raw.raw.cpuReads, raw.raw.clockReads, sample.cpuClock, previousCpuNs); + const semantic = raw.semantic; + invariant(semantic?.valid === true && semantic.targets === scene.count && semantic.frames === raw.frameNs.length && + semantic.finished === true && semantic.pending === 0 && semantic.onCompleteCalls === 0 && + semantic.previousFinished === (scene.lifecycle === 'fresh' ? null : true) && semantic.previousCompleteCalls === 0 && + validTraceHashes(semantic.targetTraceHashes, scene.count), 'невалидный lifecycle witness'); + } + } else { + const step = deriveRealmTimerStep('server sample', sample.timerEvidence); + assertRealmTimerStep('server sample', sample.timerEvidence, sample.measurementTimeOriginMs); + invariant(sample.timerStepMs === step && sample.clockModelDigest === serverProfileDigest(SERVER_PROFILE.clockError), 'clock evidence/model не совпадают'); + const scene = SERVER_PROFILE.browserScenes.find((scene) => scene.id === cell.scene); + validateNormalMotion(sample.semanticEvidence, scene, sample.monotonicHostUpperNs); + invariant(Array.isArray(sample.endpoints) && sample.endpoints.length === scene.targetsPerCall && + sample.endpoints.every((x) => Number.isFinite(x) && Math.abs(x - SERVER_PROFILE.toPx) <= 2), 'невалидный endpoint witness'); + invariant(Array.isArray(sample.warmup) && sample.warmup.length === 1, 'потерян warmup batch'); + for (const raw of [...sample.raw, ...sample.warmup]) { + const calls = SERVER_PROFILE.browserBatchCalls * workMultiplier; + invariant(raw.calls === calls && raw.ownersStarted === calls && raw.ownersCancelled === calls, 'batch потерял полезные owner outcomes'); + const start = serverBrowserClockBounds(raw.startClock, sample.monotonicHostUpperNs), cancel = serverBrowserClockBounds(raw.cancelClock, sample.monotonicHostUpperNs); + invariant(raw.batchStartMs === start.measuredMs && raw.batchCancelMs === cancel.measuredMs && + raw.startMs === raw.batchStartMs / SERVER_PROFILE.browserBatchCalls && raw.cancelMs === raw.batchCancelMs / SERVER_PROFILE.browserBatchCalls && + raw.cancelClock.beginMs >= raw.startClock.endMs, 'batch clock reads/знаменатель не воспроизводятся'); + validateStartWitness(raw, scene, sample.monotonicHostUpperNs); + validateCancellationWitness(raw, calls * scene.targetsPerCall); + } + validateCancellationWitness({ cancelMs: sample.controlCancelMs, cancelWitness: sample.controlCancelWitness }, scene.targetsPerCall); + } + const checked = validationCache.get(sample) ?? new Set(); checked.add(validationKey); validationCache.set(sample, checked); + } + const rawValues = sample.raw.map((value) => cell.metric === 'meanFrameNs' + ? value.frameNs?.reduce((a, b) => a + b, 0) / value.frameNs?.length : value[cell.metric]); + invariant(rawValues.every(positive), 'некорректные raw timing'); + const recomputed = rawValues.reduce((a, b) => a + b, 0) / sample.repetitions; + invariant(recomputed === sample[cell.metric], 'timing не пересчитывается из raw / знаменателя'); + const pointwise = sample.raw.map((raw) => { + if (stockScene) { + const durationNs = Number(BigInt(raw.raw.clockReads[1].valueNs) - BigInt(raw.raw.clockReads[0].valueNs)); + return meanBounds([errorBounds(durationNs, SERVER_PROFILE.clockError.engineCounterOutwardPaddingNs)], stockScene.callsPerRepetition); + } + if (cell.kind === 'engine') return cell.metric === 'meanFrameNs' + ? meanBounds(raw.frameNs.map((value) => errorBounds(value, SERVER_PROFILE.clockError.engineCounterOutwardPaddingNs)), raw.frameNs.length) + : errorBounds(raw[cell.metric], SERVER_PROFILE.clockError.engineCounterOutwardPaddingNs); + const interval = serverBrowserClockBounds(cell.metric === 'startMs' ? raw.startClock : raw.cancelClock, sample.monotonicHostUpperNs); + return meanBounds([interval], SERVER_PROFILE.browserBatchCalls); + }); + return { value: sample[cell.metric], bounds: meanBounds(pointwise, sample.repetitions) }; +} + +function validateThreadCpuFields(cpuReads, clockReads, identity, previous = -1n) { + cpuReads = expandServerCpuEvidence(cpuReads, clockReads.length); + invariant(Array.isArray(cpuReads) && cpuReads.length === clockReads.length, 'потеряны actual thread CPU fields'); + for (let sequence = 0; sequence < cpuReads.length; sequence++) { + const read = cpuReads[sequence]; + invariant(read?.sequence === sequence && read.clock === identity.clock && read.pid === identity.pid && read.tid === identity.tid && + typeof read.seconds === 'string' && /^(0|[1-9]\d*)$/.test(read.seconds) && read.seconds.length <= 19 && + BigInt(read.seconds) <= 9_223_372_036_854_775_807n && Number.isSafeInteger(read.nanoseconds) && read.nanoseconds >= 0 && !Object.is(read.nanoseconds, -0) && + read.nanoseconds < 1_000_000_000, 'невалидные native CPU timespec/identity/sequence fields'); + const valueNs = BigInt(read.seconds) * 1_000_000_000n + BigInt(read.nanoseconds); + invariant(read.valueNs === String(valueNs) && clockReads[sequence].valueNs === read.valueNs, 'native CPU endpoint не пересчитывается из timespec'); + invariant(valueNs >= previous, 'native CPU endpoints идут назад'); + previous = valueNs; + } + return previous; +} + +export function validateServerBrowserSample(sample, scene, workMultiplier = 1) { + const validationCache = new WeakMap(); + for (const metric of SERVER_PROFILE.metrics.browser) readServerSample(sample, + { id: `${scene.id}:${metric}`, kind: 'browser', scene: scene.id, metric }, workMultiplier, validationCache); +} + +export function validateServerEngineSample(sample, scene, workMultiplier = 1) { + const validationCache = new WeakMap(), validateTransform = createTransformLifecycleValidator(); + for (const metric of scene.metrics ?? SERVER_PROFILE.metrics.engine) readServerSample(sample, + { id: `${scene.id}:${metric}`, kind: 'engine', scene: scene.id, metric }, workMultiplier, validationCache, validateTransform); +} + +function coordinateReader(values, count, label) { + if (Array.isArray(values)) { + invariant(values.length === count && Array.from(values).every(Number.isFinite), `неполные ${label} coordinates`); + return { at: (index) => values[index], runs: null }; + } + if (values?.encoding === 'repeat') { + invariant(values.count === count && Number.isFinite(values.value) && + isDeepStrictEqual(Object.keys(values).sort(), ['count', 'encoding', 'value']), `неполные ${label} RLE coordinates`); + return { at: () => values.value, runs: [[count, values.value]] }; + } + invariant(values?.encoding === 'rle' && values.count === count && Array.isArray(values.runs) && + isDeepStrictEqual(Object.keys(values).sort(), ['count', 'encoding', 'runs']), `неполные ${label} RLE coordinates`); + let expanded = 0; + const ends = values.runs.map((run) => { + invariant(Array.isArray(run) && run.length === 2 && Number.isSafeInteger(run[0]) && run[0] > 0 && Number.isFinite(run[1]) && + expanded + run[0] <= count, `невалидный ${label} RLE run`); + expanded += run[0]; return expanded; + }); + invariant(expanded === count, `${label} RLE потерял targets`); + return { runs: values.runs, at: (index) => { + let low = 0, high = ends.length - 1; + while (low < high) { const middle = Math.floor((low + high) / 2); if (index < ends[middle]) high = middle; else low = middle + 1; } + return values.runs[low][1]; + } }; +} + +function validateStartWitness(raw, scene, monotonicHostUpperNs) { + const witness = raw.startWitness; + invariant(witness?.connectedTargets === raw.calls * scene.targetsPerCall && Number.isSafeInteger(witness.activeWaapi) && witness.activeWaapi >= 0, + 'start batch потерял attached targets'); + const leading = coordinateReader(witness.leadingPositions, raw.calls, 'start'); + invariant(witness.readClock?.beginMs >= raw.startClock.endMs && witness.readClock.endMs >= witness.readClock.beginMs && + raw.cancelClock.beginMs >= witness.readClock.endMs, 'start observation не соответствует clock chronology'); + const window = serverBrowserClockBounds({ beginMs: raw.startClock.beginMs, endMs: witness.readClock.endMs }, monotonicHostUpperNs); + invariant(window.high < SERVER_PROFILE.durationMs * (1 - SERVER_PROFILE.browserSemantics.finalTolerancePx / SERVER_PROFILE.toPx), + 'start batch не разрешил окно до линейного endpoint'); + // Каждый свежий owner вызван после batch begin, а CSS прочитан до read end. + // Общая верхняя граница elapsed учитывает обе clock reads и float roundoff. + const maximumPosition = nextUp(nextUp(nextUp(SERVER_PROFILE.toPx / SERVER_PROFILE.durationMs) * window.high) + + SERVER_PROFILE.browserSemantics.movementThresholdPx); + for (let call = 0; call < raw.calls; call++) { + const position = leading.at(call); + invariant(position >= -SERVER_PROFILE.browserSemantics.finalTolerancePx && + position < SERVER_PROFILE.toPx - SERVER_PROFILE.browserSemantics.finalTolerancePx, 'timed owner мгновенно достиг endpoint до duration'); + invariant(position >= SERVER_PROFILE.browserSemantics.fromPx - SERVER_PROFILE.browserSemantics.movementThresholdPx && + position <= maximumPosition, 'timed onset не соответствует свежему началу и actual clock окну'); + } +} + +function validateCancellationWitness(raw, targets) { + const witness = raw.cancelWitness; + invariant(witness?.connectedTargets === targets && witness.activeWaapiBefore === 0 && positive(witness.cancelDrainMs) && + witness.cancelDrainMs >= (raw.batchCancelMs ?? raw.cancelMs) && Array.isArray(witness.frames) && + witness.frames.length === SERVER_PROFILE.browserCancellationWitness.frames, 'невалидный cancel/drain witness'); + const before = coordinateReader(witness.transformsBefore, targets, 'cancel'); + for (const frame of witness.frames) { + invariant(frame.connectedTargets === targets && frame.activeWaapi === 0, 'cancel не достиг attached-target quiescence'); + const after = coordinateReader(frame.transforms, targets, 'cancel'); + if (before.runs && after.runs) { + let left = 0, right = 0, leftRemaining = before.runs[0][0], rightRemaining = after.runs[0][0]; + while (left < before.runs.length && right < after.runs.length) { + invariant(Math.abs(after.runs[right][1] - before.runs[left][1]) <= SERVER_PROFILE.browserCancellationWitness.transformTolerancePx, + 'cancel не достиг наблюдаемой неподвижности attached targets'); + const step = Math.min(leftRemaining, rightRemaining); leftRemaining -= step; rightRemaining -= step; + if (leftRemaining === 0 && ++left < before.runs.length) leftRemaining = before.runs[left][0]; + if (rightRemaining === 0 && ++right < after.runs.length) rightRemaining = after.runs[right][0]; + } + } else for (let target = 0; target < targets; target++) invariant(Math.abs(after.at(target) - before.at(target)) <= SERVER_PROFILE.browserCancellationWitness.transformTolerancePx, + 'cancel не достиг наблюдаемой неподвижности attached targets'); + } +} + +function unsupportedComparator(scene, id) { + return scene.staggerGapMs > 0 && ['motion-mini', 'anime-waapi'].includes(id); +} + +export function serverComparatorPlan(runs) { + return SERVER_PROFILE.browserScenes.flatMap((scene) => SERVER_PROFILE.comparators.flatMap((id) => unsupportedComparator(scene, id) ? [] + : Array.from({ length: runs }, (_, run) => ({ scene: scene.id, id, run })))); +} + +function validateSupplementalSamples(artifact) { + const validationCache = new WeakMap(); + invariant(Array.isArray(artifact.comparators) && artifact.comparators.length === SERVER_PROFILE.browserScenes.length * SERVER_PROFILE.comparators.length, + 'потеряны обязательные comparator cells'); + let index = 0; + for (const scene of SERVER_PROFILE.browserScenes) for (const id of SERVER_PROFILE.comparators) { + const comparator = artifact.comparators[index++]; + invariant(comparator?.scene === scene.id && comparator.id === id, 'comparator cells не соответствуют плану'); + if (unsupportedComparator(scene, id)) { + invariant(comparator.status === 'UNPROVEN' && typeof comparator.reason === 'string' && comparator.reason.length > 0 && !comparator.rows, + 'несуществующий stagger API объявлен измеренным'); + continue; + } + invariant(Array.isArray(comparator.rows) && comparator.rows.length === artifact.samplePlan.runs, 'потеряны raw comparator samples'); + for (const sample of comparator.rows) for (const metric of SERVER_PROFILE.metrics.browser) readServerSample(sample, + { id: `${id}:${scene.id}:${metric}`, kind: 'browser', scene: scene.id, metric }, 1, validationCache); + } + invariant(isDeepStrictEqual(Object.keys(artifact.retention ?? {}).sort(), ['baseline', 'candidate']), 'потерян отдельный retention child'); + for (const report of Object.values(artifact.retention)) { + invariant(report.verdict === 'COMPLETE' && report.failure === null && Array.isArray(report.rows) && report.rows.length === SERVER_PROFILE.engineScenes.length, + 'retention child не завершён'); + report.rows.forEach((row, index) => { + invariant(row.scene === SERVER_PROFILE.engineScenes[index].id && Number.isSafeInteger(row.before?.heapUsed) && row.before.heapUsed >= 0 && + Number.isSafeInteger(row.after?.heapUsed) && row.after.heapUsed >= 0 && row.retainedHeapDeltaBytes === row.after.heapUsed - row.before.heapUsed, + 'retained heap delta не воспроизводится'); + }); + } +} + +function validTraceHashes(hashes, expectedCount) { + if (Array.isArray(hashes)) return hashes.length === expectedCount && hashes.every((hash) => SHA256.test(hash)); + return hashes?.encoding === 'repeat' && hashes.count === expectedCount && SHA256.test(hashes.value) && + isDeepStrictEqual(Object.keys(hashes).sort(), ['count', 'encoding', 'value']); +} + +// Для зарегистрированных q=1/2,19/20 и alpha=1/1760 ranks сравниваются +// точно в BigInt. Float underflow и погрешность суммирования не дают admission. +export function serverOrderStatisticBounds(values, probability, alphaPerTail) { + invariant(Array.isArray(values) && values.length > 0 && values.every((x) => Number.isFinite(x) && x >= 0) && + probability > 0 && probability < 1 && alphaPerTail > 0 && alphaPerTail < 0.5, 'невалидная порядковая статистика'); + invariant(probability === 0.5 || probability === 0.95, 'вероятность вне зарегистрированных exact квантилей'); + const [numerator, denominator] = probability === 0.5 ? [1n, 2n] : [19n, 20n]; + const alphaDenominator = BigInt(SERVER_PROFILE.familySize * 2 * 2 * 2 * 20); + invariant(alphaPerTail === 1 / Number(alphaDenominator), 'alpha вне зарегистрированного exact семейства'); + return exactBinomialOrderStatisticBounds(values, [numerator, denominator], [1n, alphaDenominator]); +} + +export function serverFamilyIntervals(pairs) { + invariant(Array.isArray(pairs) && pairs.length === SERVER_PROFILE.familySize, 'неполное семейство CI'); + const policy = serverTailPolicy(); + return pairs.map(({ id, left, right, leftBounds, rightBounds }) => { + invariant(Array.isArray(left) && left.length >= 8 && left.length % 2 === 0 && right?.length === left.length && + [...left, ...right].every(positive), 'некорректные парные CI данные'); + for (const [values, bounds] of [[left, leftBounds], [right, rightBounds]]) invariant(Array.isArray(bounds) && bounds.length === values.length && + bounds.every((bound, index) => Number.isFinite(bound?.low) && Number.isFinite(bound?.high) && bound.low >= 0 && + bound.low <= values[index] && bound.high >= values[index]), 'нет pointwise clock uncertainty до CI'); + const blockMeans = (values) => Array.from({ length: values.length / 2 }, (_, block) => (values[block * 2] + values[block * 2 + 1]) / 2); + const blockBounds = (bounds) => Array.from({ length: bounds.length / 2 }, (_, block) => meanBounds(bounds.slice(block * 2, block * 2 + 2), 2)); + const l = blockMeans(left), r = blockMeans(right), lb = blockBounds(leftBounds), rb = blockBounds(rightBounds); + const boundedStatistics = (values, bounds, p) => ({ ...serverOrderStatisticBounds(values, p, policy.alphaPerTail), + low: serverOrderStatisticBounds(bounds.map((bound) => bound.low), p, policy.alphaPerTail).low, + high: serverOrderStatisticBounds(bounds.map((bound) => bound.high), p, policy.alphaPerTail).high }); + return { id, blocks: left.length / 2, runs: left.length, unit: SERVER_PROFILE.samplingUnit, + correction: policy.correction, method: 'pointwise-clock-bounds+exact-binomial-order-statistics', assumption: SERVER_PROFILE.stationarityAssumption, + ...Object.fromEntries([['p50', 0.5], ['p95', 0.95]].map(([key, p]) => { + const baseline = boundedStatistics(l, lb, p); + const candidate = boundedStatistics(r, rb, p); + return [key, { ratio: candidate.estimate / baseline.estimate, + low: baseline.high === null ? 0 : Math.max(0, nextDown(candidate.low / baseline.high)), + high: candidate.high === null || baseline.low === 0 ? null : nextUp(candidate.high / baseline.low), + bounded: candidate.high !== null && baseline.high !== null && baseline.low > 0 && candidate.low > 0, + baseline, candidate }]; + })) }; + }); +} + +export function serverCalibrationVerdict(aa, positiveControl, samplePlan) { + const reasons = []; + if (!samplePlan.feasible) reasons.push(`null-pilot требует ${samplePlan.requiredRuns} run, предел ${SERVER_PROFILE.maxRuns}`); + for (const cell of aa) { + if (!cell.p95.bounded || !cell.p50.bounded || cell.p95.high > SERVER_PROFILE.nonInferiorityUpper || cell.p95.low < 1 / SERVER_PROFILE.nonInferiorityUpper || + cell.p50.high > SERVER_PROFILE.nonInferiorityUpper || cell.p50.low < 1 / SERVER_PROFILE.nonInferiorityUpper) { + reasons.push(`${cell.id}: A/A не удержал двустороннюю полосу 1/1.05…1.05`); + } + } + for (const cell of positiveControl) if (!cell.p50.bounded || cell.p50.low <= SERVER_PROFILE.positiveLower) reasons.push(`${cell.id}: 2×work не различён`); + return { verdict: reasons.length ? 'UNPROVEN' : 'PASS', reasons }; +} + +export function serverResourceReasons(stages, identity) { + const reasons = []; + invariant(/^\d+$/.test(identity?.affinity) && typeof identity.cgroupCpuMax === 'string' && identity.cgroupCpuMax.length > 0, + 'ресурсные observations не связаны с зарегистрированным machine'); + for (const stage of stages) { + const rowsPerBlock = (SERVER_PROFILE.engineScenes.length + SERVER_PROFILE.browserScenes.length) * 2; + invariant(Array.isArray(stage.blocks) && stage.blocks.length === stage.rows.length / rowsPerBlock, 'нет наблюдений ресурсов каждого парного блока'); + for (let index = 0; index < stage.blocks.length; index++) { + const block = stage.blocks[index]; + invariant(block.block === index && block.before?.cpuStat && block.after?.cpuStat && /^\d+$/.test(block.before.affinity), 'невалидный ресурсный блок'); + if (block.before.affinity !== block.after.affinity || block.before.cpuMax !== block.after.cpuMax) reasons.push(`${stage.name}: affinity/quota изменились`); + if ([block.before, block.after].some((snapshot) => snapshot.affinity !== identity.affinity || snapshot.cpuMax !== identity.cgroupCpuMax)) { + reasons.push(`${stage.name}: block ${index} отличается от зарегистрированных affinity/quota`); + } + for (const key of ['usage_usec', 'user_usec', 'system_usec', 'nr_periods', 'nr_throttled', 'throttled_usec']) { + const before = block.before.cpuStat[key], after = block.after.cpuStat[key]; + invariant(Number.isSafeInteger(before) && Number.isSafeInteger(after) && before >= 0 && after >= before && block.delta[key] === after - before, + 'resource delta не воспроизводится'); + } + if (block.delta.nr_throttled !== 0 || block.delta.throttled_usec !== 0) reasons.push(`${stage.name}: block ${index} содержит cgroup CPU throttling`); + } + } + return reasons; +} + +export function validateServerArtifact(artifact) { + invariant(artifact?.schema === 1, 'неизвестная schema'); + verifyServerProfile(artifact.protocol); + invariant(Array.isArray(artifact.failures), 'потеряны отказы'); + if (artifact.registration === null) { + invariant(artifact.registrationDigest === null && artifact.verdict === 'UNPROVEN' && artifact.failures.length > 0 && + !artifact.pilot && !artifact.aa && !artifact.ab, 'неполная регистрация допустила измерения'); + return { verification: 'preparation-refused', verdict: 'UNPROVEN' }; + } + invariant(SHA256.test(artifact.registrationDigest) && artifact.registrationDigest === serverProfileDigest(artifact.registration), 'подменён digest регистрации'); + invariant(artifact.registration?.candidateSamplesObserved === false, 'кандидат наблюдался до регистрации'); + invariant(artifact.registration.candidateSamplesObservedScope === SERVER_PROFILE.candidateSamplesObservedScope, + 'не указан scope регистрации с сохранённой exploratory prehistory'); + invariant(artifact.registration.protocolDigest === serverProfileDigest(SERVER_PROFILE), 'неверный digest протокола'); + invariant(SERVER_PROFILE.browsers.includes(artifact.registration.browser), 'неизвестный browser'); + for (const id of ['baseline', 'candidate']) { + const provenance = artifact.registration.provenance?.[id]; + invariant(SHA1.test(provenance?.revision) && provenance.dirty === false && SHA256.test(provenance.trackedRevisionSha256) && + SHA256.test(provenance.worktreeSha256) && SHA256.test(provenance.distRuntime?.sha256), 'неполное source provenance'); + invariant(/^v24\./.test(provenance.environment?.node) && provenance.environment.pnpm === '11.11.0' && + SHA256.test(provenance.environment.nodeExecutableSha256), 'неполное toolchain provenance'); + for (const key of ['root/package.json', 'root/pnpm-lock.yaml', 'bench/package.json', 'bench/pnpm-lock.yaml']) invariant(SHA256.test(provenance.inputs?.[key]), 'потерян input hash'); + for (const [field, names] of [['packages', ['esbuild', 'playwright', 'motion', 'gsap', 'animejs']], ['rootPackages', ['tsup', 'typescript', 'esbuild']]]) { + for (const name of names) { + const pkg = provenance.environment[field]?.[name]; + invariant(/^\d+\.\d+\.\d+$/.test(pkg?.version) && SHA256.test(pkg.sha256) && Number.isSafeInteger(pkg.files) && pkg.files > 0, 'потерян установленный package hash'); + } + } + invariant(SHA256.test(artifact.registration.packages?.[id]?.tarballSha256) && SHA256.test(artifact.registration.packages?.[id]?.treeSha256), 'неполное package provenance'); + } + invariant(artifact.registration.provenance.baseline.revision === SERVER_PROFILE.baselineRevision, 'неверный baseline'); + invariant(SHA256.test(artifact.registration.machine?.sha256) && SHA256.test(artifact.registration.browserExecutableSha256) && + typeof artifact.registration.browserVersion === 'string' && artifact.registration.browserVersion.length > 0, 'неполное machine/browser provenance'); + invariant(artifact.registration.machine.sha256 === serverProfileDigest(artifact.registration.machine.identity) && + /^\d+$/.test(artifact.registration.machine.identity.affinity) && artifact.registration.machine.identity.platform === 'linux' && + typeof artifact.registration.machine.identity.cgroupCpuMax === 'string' && artifact.registration.machine.identity.cgroupCpuMax.length > 0 && + SHA256.test(artifact.registration.machine.identity.nodeExecutableSha256), 'machine identity не закреплена'); + invariant(SHA256.test(artifact.registration.browserTree?.sha256) && Number.isSafeInteger(artifact.registration.browserTree?.files) && + artifact.registration.browserTree.files > 0, 'потерян browser tree hash'); + verifyServerClockRegistration(artifact.registration); + // Привязка identity охватывает также завершённый префикс отказавшей стадии. + for (const name of ['warmup', 'pilot', 'aa', 'positive', 'ab']) for (const row of artifact[name]?.rows ?? []) { + if (row.kind !== 'engine') continue; + for (const sample of Object.values(row.samples ?? {})) { + verifyThreadCpuIdentity(sample.cpuClock); + invariant(sample.cpuClock.clock === artifact.registration.engineClock.clock && sample.cpuClock.pid === artifact.registration.engineClock.pid && + sample.cpuClock.tid === artifact.registration.engineClock.tid, 'native CPU stage sample не связан с зарегистрированным main-thread'); + } + } + invariant(Object.keys(artifact.registration.harness ?? {}).length >= 6 && Object.values(artifact.registration.harness).every((x) => SHA256.test(x.sha256)), 'неполное harness provenance'); + for (const id of SERVER_PROFILE.comparators.filter((id) => !id.startsWith('waapi'))) invariant(SHA256.test(artifact.registration.packages[id]?.treeSha256) && + SHA256.test(artifact.registration.packages[id]?.tarballSha256), 'потерян comparator package'); + invariant(Object.keys(artifact.registration.transitivePackages ?? {}).length >= 3 && + Object.values(artifact.registration.transitivePackages).every((pkg) => SHA256.test(pkg.treeSha256) && SHA256.test(pkg.tarballSha256)), 'потеряны transitive tarballs'); + if (!artifact.pilot || !artifact.calibration) { + invariant(artifact.verdict === 'UNPROVEN' && artifact.failures.length > 0 && !artifact.ab, 'незавершённое измерение объявлено успехом'); + return { verification: 'recorded-refusal-only', verdict: 'UNPROVEN' }; + } + // Identity стадий проверяется до дорогих raw проекций. Их подробная + // проверка по-прежнему принадлежит serverCellPairs каждой полной серии. + for (const name of ['pilot', 'aa', 'positive', ...(artifact.ab ? ['ab'] : [])]) { + invariant(artifact[name]?.name === name, 'имя стадии не соответствует владельцу artifact'); + } + for (const id of artifact.ab ? ['baseline', 'candidate'] : ['baseline']) { + const control = artifact.rawControls?.[id]; + invariant(control?.noMotion?.equal === true && SHA256.test(control.noMotion.beforeSha256) && + control.noMotion.beforeSha256 === control.noMotion.afterSha256 && control.reduced?.prefersReducedMotion === true && + Math.abs(control.reduced.x - SERVER_PROFILE.toPx) <= 2 && control.reduced.rafRequests === 0 && control.reduced.activeWaapi === 0, + 'потерян raw no-motion/reduced-motion control'); + } + const pilotPairs = serverCellPairs(artifact.pilot, SERVER_PROFILE.pilotRuns, 'pilot', artifact.registration.engineClock); + invariant(isDeepStrictEqual(artifact.samplePlan, planServerSampleSize(pilotPairs)), 'N не воспроизводится из baseline-only pilot'); + invariant(artifact.frozenPlanDigest === serverProfileDigest({ registrationDigest: artifact.registrationDigest, samplePlan: artifact.samplePlan }), 'не закреплён N до A/A и A/B'); + const aa = serverFamilyIntervals(serverCellPairs(artifact.aa, artifact.samplePlan.runs, 'aa', artifact.registration.engineClock)); + const positiveControl = serverFamilyIntervals(serverCellPairs(artifact.positive, artifact.samplePlan.runs, 'positive', artifact.registration.engineClock)); + const calibration = serverCalibrationVerdict(aa, positiveControl, artifact.samplePlan); + calibration.reasons.push(...serverResourceReasons([artifact.warmup, artifact.pilot, artifact.aa, artifact.positive], artifact.registration.machine.identity)); + calibration.verdict = calibration.reasons.length ? 'UNPROVEN' : 'PASS'; + invariant(isDeepStrictEqual(artifact.calibration, { ...calibration, aa, positive: positiveControl }), 'вердикт контроля не воспроизводится'); + if (calibration.verdict !== 'PASS') { + invariant(!artifact.ab && artifact.verdict === 'UNPROVEN', 'негодная калибровка допустила A/B'); + return { verification: 'calibration-refused', ...calibration }; + } + if (!artifact.ab) { + invariant(artifact.verdict === 'UNPROVEN' && artifact.failures.length > 0, 'отсутствие A/B скрыто'); + return { verification: 'post-calibration-refused', verdict: 'UNPROVEN' }; + } + if (artifact.failures.length > 0 && (artifact.ab.rows?.length !== artifact.samplePlan.runs * + (SERVER_PROFILE.engineScenes.length + SERVER_PROFILE.browserScenes.length) || + artifact.ab.rows.some((row) => Object.keys(row.samples ?? {}).length !== IDS.length))) { + invariant(artifact.verdict === 'UNPROVEN', 'частичный A/B объявлен успехом'); + return { verification: 'partial-samples-refused', verdict: 'UNPROVEN' }; + } + const ab = serverFamilyIntervals(serverCellPairs(artifact.ab, artifact.samplePlan.runs, 'ab', artifact.registration.engineClock)); + const resourceReasons = serverResourceReasons([artifact.ab], artifact.registration.machine.identity); + invariant(resourceReasons.length === 0 || (artifact.verdict === 'UNPROVEN' && artifact.failures.length > 0), 'условия A/B нарушены, отказ потерян'); + if (artifact.failures.length > 0) { + invariant(artifact.verdict === 'UNPROVEN', 'отказ скрыт успешным вердиктом'); + return { verification: 'completed-samples-refused', verdict: 'UNPROVEN' }; + } + validateSupplementalSamples(artifact); + const expected = ab.every((cell) => cell.p95.bounded && cell.p95.high <= SERVER_PROFILE.nonInferiorityUpper) ? 'PASS' : 'NO-GO'; + invariant(isDeepStrictEqual(artifact.comparison, ab) && artifact.verdict === expected, 'A/B вердикт не воспроизводится'); + return { verification: 'server-cell-only', verdict: expected, unproven: SERVER_PROFILE.unproven }; +} + +// Hash-chain хранит порядок preregistration → baseline-only pilot → N → +// calibration → A/B. Raw rows должны совпасть с каждой сохранённой квитанцией. +export function serverArtifactDigest(artifact) { + const hash = createHash('sha256'); + let pending = [], length = 0; + const flush = () => { if (length) hash.update(pending.join('')); pending = []; length = 0; }; + for (const chunk of serverArtifactChunks(artifact)) { + // Ограниченная склейка сокращает вызовы native hash для разделителей JSON. + // Внешний lazy iterator и чтения входа остаются прежними; кеша между вызовами нет. + if (typeof chunk !== 'string' || chunk.length >= 65_536) { flush(); hash.update(chunk); } + else { + if (length + chunk.length > 65_536) flush(); + pending.push(chunk); length += chunk.length; + } + } + flush(); return hash.digest('hex'); +} + +// Массивы делятся между полными native JSON values. Верхние rows дают один run; +// элемент comparators включает всю серию rows и должен помещаться в строку V8. +// Общему документу это не требуется; зарегистрированный max N проверен отдельно. +export function* serverArtifactChunks(artifact) { + function* valueChunks(value) { + if (Array.isArray(value)) { + yield '['; + for (let index = 0; index < value.length; index++) { + if (index) yield ','; + yield JSON.stringify(value[index]) ?? 'null'; + } + yield ']'; + } else if (value !== null && typeof value === 'object' && typeof value.toJSON !== 'function') { + yield '{'; let first = true; + for (const [key, child] of Object.entries(value)) { + if (child === undefined || typeof child === 'function' || typeof child === 'symbol') continue; + if (!first) yield ','; first = false; + yield `${JSON.stringify(key)}:`; yield* valueChunks(child); + } + yield '}'; + } else yield JSON.stringify(value); + } + yield* valueChunks(artifact); yield '\n'; +} + +// JSON carrier делится только между полными values. Строки, escape sequences +// и числа разбирает native JSON.parse; весь artifact не становится строкой V8. +export function parseServerJsonBytes(bytes, chunkBytes = 32 * 1024 * 1024) { + invariant(Buffer.isBuffer(bytes) && Number.isSafeInteger(chunkBytes) && chunkBytes > 0, 'невалидный JSON carrier'); + const whitespace = (code) => code === 32 || code === 9 || code === 10 || code === 13; + const skip = (index, end) => { while (index < end && whitespace(bytes[index])) index++; return index; }; + const stringEnd = (start, end) => { + let escaped = false; + for (let index = start + 1; index < end; index++) { + if (escaped) escaped = false; + else if (bytes[index] === 92) escaped = true; + else if (bytes[index] === 34) return index + 1; + } + throw new Error('server profile: оборван JSON string'); + }; + const valueEnd = (start, end) => { + let depth = 0; + for (let index = start; index < end; index++) { + const code = bytes[index]; + if (code === 34) { index = stringEnd(index, end) - 1; continue; } + if (code === 123 || code === 91) depth++; + else if (code === 125 || code === 93) { if (!depth) return index; depth--; } + else if (code === 44 && !depth) return index; + } + return end; + }; + const parse = (start, end) => { + start = skip(start, end); while (end > start && whitespace(bytes[end - 1])) end--; + const first = bytes[start]; + if (end - start <= chunkBytes || (first !== 123 && first !== 91)) return JSON.parse(bytes.toString('utf8', start, end)); + const object = first === 123, close = object ? 125 : 93, result = object ? {} : []; + invariant(bytes[end - 1] === close, 'оборван JSON container'); + let cursor = skip(start + 1, end); + if (cursor === end - 1) return result; + for (;;) { + let key; + if (object) { + invariant(bytes[cursor] === 34, 'JSON object потерял key'); + const keyEnd = stringEnd(cursor, end); key = JSON.parse(bytes.toString('utf8', cursor, keyEnd)); + cursor = skip(keyEnd, end); invariant(bytes[cursor] === 58, 'JSON object потерял colon'); cursor = skip(cursor + 1, end); + } + const childEnd = valueEnd(cursor, end - 1), value = parse(cursor, childEnd); + // defineProperty сохраняет JSON.parse semantics для __proto__ и duplicate keys. + if (object) Object.defineProperty(result, key, { value, enumerable: true, configurable: true, writable: true }); + else result.push(value); + cursor = skip(childEnd, end); + if (cursor === end - 1) return result; + invariant(bytes[cursor] === 44, 'JSON container потерял separator'); + cursor = skip(cursor + 1, end); invariant(cursor < end - 1, 'JSON container содержит trailing comma'); + } + }; + return parse(0, bytes.length); +} + +export function parseServerJournalBytes(bytes) { + invariant(Buffer.isBuffer(bytes), 'невалидный journal carrier'); + const records = []; + let start = 0, end = bytes.length; + const whitespace = (code) => code === 32 || code === 9 || code === 10 || code === 13; + while (start < end && whitespace(bytes[start])) start++; + while (end > start && whitespace(bytes[end - 1])) end--; + invariant(start < end, 'нет журнала регистрации и samples'); + for (let index = start; index < end; index++) if (bytes[index] === 10) { + records.push(parseServerJsonBytes(bytes.subarray(start, index))); start = index + 1; + } + records.push(parseServerJsonBytes(bytes.subarray(start, end))); + return records; +} + +export function serverStagePlan(stage, runs) { + const orders = serverOrders(runs), plan = []; + for (let run = 0; run < runs; run++) { + for (const [kind, scenes] of [['engine', SERVER_PROFILE.engineScenes], ['browser', SERVER_PROFILE.browserScenes]]) { + for (const scene of scenes) for (const participant of orders[run]) plan.push({ stage, kind, scene: scene.id, run, participant, + build: stage === 'ab' && participant === 'right' ? 'candidate' : 'baseline' }); + } + } + return plan; +} + +export function validateServerJournal(artifact, records, rawDigest) { + invariant(Array.isArray(records) && records.length > 0, 'нет журнала регистрации и samples'); + if (artifact.samplePlan) invariant(Number.isSafeInteger(artifact.samplePlan.runs) && artifact.samplePlan.runs % 2 === 0 && + artifact.samplePlan.runs >= SERVER_PROFILE.minRuns && artifact.samplePlan.runs <= SERVER_PROFILE.maxRuns, 'N журнала вне зарегистрированного ресурса'); + let previous = '0'.repeat(64), registration = false, frozen = false, calibration = false, calibrationRecorded = false, stopped = false; + let baselineControl = false, candidateControl = false; + const phases = ['warmup', 'pilot', 'aa', 'positive', 'ab']; + const runsFor = (name) => name === 'warmup' ? SERVER_PROFILE.warmupRuns : name === 'pilot' ? SERVER_PROFILE.pilotRuns : artifact.samplePlan?.runs; + const plans = Object.fromEntries(phases.map((name) => [name, runsFor(name) ? serverStagePlan(name, runsFor(name)) : []])); + const counts = Object.fromEntries(phases.map((name) => [name, 0])); + const resourceCounts = Object.fromEntries(phases.map((name) => [name, 0])); + const complete = (name) => counts[name] === plans[name].length && resourceCounts[name] === runsFor(name) / 2; + const comparatorPlan = artifact.samplePlan ? serverComparatorPlan(artifact.samplePlan.runs) : []; + let comparatorCount = 0, retentionFinished = false, finishedDigest; + const seen = new Map(), comparatorSamples = new Map(), retentionSamples = new Map(), failures = [], failedSamples = []; + for (let recordIndex = 0; recordIndex < records.length; recordIndex++) { + const record = records[recordIndex]; + const { digest } = record; + invariant(record.sequenceDigest === previous && SHA256.test(digest), 'повреждена цепь журнала'); + previous = digest; + if (record.type === 'registration-before-any-sample') { + invariant(!registration && !stopped && artifact.registration !== null && seen.size === 0 && isDeepStrictEqual(record.value.registration, artifact.registration) && + record.value.digest === artifact.registrationDigest, 'регистрация не предшествует samples'); registration = true; + } else if (record.type === 'raw-controls-baseline') { + invariant(registration && !baselineControl && seen.size === 0 && isDeepStrictEqual(record.value, artifact.rawControls?.baseline), 'baseline raw control не предшествует timing'); baselineControl = true; + } else if (record.type === 'N-frozen-before-calibration-and-AB') { + invariant(registration && !stopped && !frozen && complete('warmup') && complete('pilot') && isDeepStrictEqual(record.value.samplePlan, artifact.samplePlan) && + record.value.digest === artifact.frozenPlanDigest, + 'N изменён или заморожен без полного baseline-only pilot'); frozen = true; + } else if (record.type === 'calibration') { + invariant(frozen && !stopped && !calibrationRecorded && complete('aa') && complete('positive') && isDeepStrictEqual(record.value, artifact.calibration), 'calibration выдана до завершения A/A и 2×work'); + calibrationRecorded = true; + calibration = record.value.verdict === 'PASS'; + } else if (record.type === 'sample' || record.type === 'failed-sample') { + const sample = record.value; + invariant(registration && !stopped, 'sample получен до preregistration или после отказа'); + invariant(baselineControl, 'sample получен без baseline raw controls'); + invariant(phases.includes(sample.stage), 'неизвестная стадия sample'); + for (const earlier of phases.slice(0, phases.indexOf(sample.stage))) invariant(complete(earlier), 'стадии исполняются не по плану'); + if (['aa', 'positive', 'ab'].includes(sample.stage)) invariant(frozen, 'sample получен до замораживания N'); + if (sample.stage === 'ab') invariant(calibration && candidateControl, 'A/B запущен при негодной calibration/raw controls'); + const expected = plans[sample.stage][counts[sample.stage]]; + invariant(expected && Object.entries(expected).every(([key, value]) => sample[key] === value), 'фактический порядок/tuple sample отличается от preregistration'); + const key = `${sample.stage}:${sample.scene}:${sample.run}:${sample.participant}`; + invariant(!seen.has(key), 'sample журнала повторён'); + if (record.type === 'failed-sample') { failedSamples.push(sample); stopped = true; } + else { seen.set(key, sample.value); counts[sample.stage]++; } + } else if (record.type === 'resources-block') { + const { stage, ...block } = record.value; + invariant(phases.includes(stage) && block.block === resourceCounts[stage] && + counts[stage] === (block.block + 1) * (SERVER_PROFILE.engineScenes.length + SERVER_PROFILE.browserScenes.length) * 4 && + isDeepStrictEqual(block, artifact[stage]?.blocks?.[block.block]), 'ресурсная квитанция не соответствует завершённому блоку'); + resourceCounts[stage]++; + } else if (record.type === 'raw-controls-candidate-after-calibration') { + invariant(!stopped && calibration && !candidateControl && isDeepStrictEqual(record.value, artifact.rawControls?.candidate), 'candidate raw control получен до годной calibration'); candidateControl = true; + } else if (record.type === 'failure') { + failures.push(record.value); stopped = true; + } else if (record.type === 'finished') { + invariant(recordIndex === records.length - 1 && record.value.verdict === artifact.verdict && SHA256.test(record.value.digest), + 'финальная квитанция не связана с raw/вердиктом'); + finishedDigest = record.value.digest; + } else if (record.type === 'comparator-sample' || record.type === 'failed-comparator-sample') { + invariant(!stopped && calibration && complete('ab'), 'дополнительное измерение получено до годного A/B'); + const value = record.value; + const expected = comparatorPlan[comparatorCount]; + invariant(expected && Object.entries(expected).every(([key, expectedValue]) => value[key] === expectedValue), 'comparator sample не соответствует порядку плана'); + if (record.type === 'failed-comparator-sample') { failedSamples.push(value); stopped = true; } + else { + const key = `${value.scene}:${value.id}:${value.run}`; + invariant(!comparatorSamples.has(key), 'повторный comparator sample'); comparatorSamples.set(key, value.sample); comparatorCount++; + } + } else if (record.type === 'retention-sample') { + invariant(!stopped && calibration && complete('ab') && comparatorCount === comparatorPlan.length && + record.value.id === IDS.map((id) => id === 'left' ? 'baseline' : 'candidate')[retentionSamples.size] && + isDeepStrictEqual(record.value.value, artifact.retention?.[record.value.id]), 'retention sample не соответствует плану/raw'); + retentionSamples.set(record.value.id, record.value.value); + } else if (record.type === 'retention-separate-forced-GC') { + invariant(!stopped && !retentionFinished && calibration && complete('ab') && retentionSamples.size === 2, 'retention child не завершён'); + invariant(isDeepStrictEqual(record.value, artifact.retention), 'retention не совпадает с квитанцией'); + retentionFinished = true; + } else invariant(false, 'неизвестная квитанция журнала'); + } + invariant(records.at(-1).type === 'finished', 'журнал оборван до финальной квитанции'); + invariant(isDeepStrictEqual(failures, artifact.failures), 'failures потеряны или добавлены вне журнала'); + for (const failed of failedSamples) invariant(failures.some((failure) => failure.stage === failed.stage && isDeepStrictEqual(failure.error, failed.error)), 'failed sample исключён из failure union'); + if (stopped) invariant(artifact.verdict === 'UNPROVEN', 'сохранённый отказ объявлен PASS'); + for (const stage of ['warmup', 'pilot', 'aa', 'positive', 'ab']) { + for (const row of artifact[stage]?.rows ?? []) for (const [id, sample] of Object.entries(row.samples)) { + const key = `${stage}:${row.scene}:${row.run}:${id}`; + invariant(isDeepStrictEqual(seen.get(key), sample), 'raw sample расходится с журналом'); seen.delete(key); + } + } + invariant(seen.size === 0, 'samples журнала исключены из результата'); + for (const comparator of artifact.comparators ?? []) for (let run = 0; run < (comparator.rows ?? []).length; run++) { + const key = `${comparator.scene}:${comparator.id}:${run}`; + invariant(isDeepStrictEqual(comparatorSamples.get(key), comparator.rows[run]), 'comparator sample расходится с журналом'); comparatorSamples.delete(key); + } + invariant(comparatorSamples.size === 0, 'comparator samples исключены из результата'); + invariant(isDeepStrictEqual(Object.fromEntries(retentionSamples), artifact.retention ?? {}), 'retention samples исключены из результата'); + if (artifact.verdict !== 'UNPROVEN') invariant(comparatorCount === comparatorPlan.length && retentionFinished, + 'обязательные comparator/retention measurements не завершены'); + // Полный raw хешируется после проверки хронологии, failure union и полноты. + // Отказ на этих границах не сериализует заведомо негодную историю повторно. + invariant(finishedDigest === (rawDigest ?? serverArtifactDigest(artifact)), 'финальная квитанция не связана с raw/вердиктом'); + // Каждая допущенная история заново проверяет все тела квитанций. Структурный + // отказ не повторяет сериализацию raw, не участвующего в успешном admission. + for (const record of records) { + const { digest, ...payload } = record; + invariant(digest === serverProfileDigest(payload), 'повреждена цепь журнала'); + } + return { journalFinalDigest: previous }; +} + +export function serverDescriptiveTiming(stage) { + return serverMetricCells().map(({ id, scene, metric }) => ({ id, ...summarizeSamples(stage.rows.filter((x) => x.scene === scene) + .flatMap((row) => IDS.map((id) => row.samples[id][metric])), { strict: true }) })); +} diff --git a/bench/profile/server-profile-registration.mjs b/bench/profile/server-profile-registration.mjs new file mode 100644 index 000000000..a707eebda --- /dev/null +++ b/bench/profile/server-profile-registration.mjs @@ -0,0 +1,183 @@ +// Серверная диагностическая клетка PROFILE-01. Устройства, энергия, GPU и +// частота физического экрана требуют отдельного evidence и здесь не выводятся. +import { isDeepStrictEqual } from 'node:util'; +import { sha256Bytes } from '../compare/provenance.mjs'; + +function freeze(value) { + if (value && typeof value === 'object') { + Object.values(value).forEach(freeze); + Object.freeze(value); + } + return value; +} + +export const SERVER_PROFILE = freeze({ + schema: 1, + rawEncoding: 'compact-json-stream-v1/native-cpu-rle-v1; every sample and exact reconstructed CPU field preserved; external digest and journal bind exact file bytes', + id: 'PROFILE-01-server', + baselineRevision: '0b6f537e148b7dadadfb9e3ce7c446d014975958', + candidateSamplesObservedScope: 'на момент регистрации ещё нет registered CPU/API cost samples текущего protocol epoch; historical exploratory stock wall и semantic/memory controls candidate уже известны', + exploratoryPrehistory: { + kind: 'existing stock C wall bench; exploratory scope-trigger до нового CPU protocol, не registered CPU samples', + baselineReportedMedian: '7.2k ns', candidateReportedMedian: '8.3k ns', + baselineStdoutSha256: '28b5cdb758254fba1c49b658541a2ecfe0e840e0ed53d108cfe03f82e8ca205b', + candidateStdoutSha256: '1ccde5b80240f0abdf9806d0543a6782fe4b5799af80083b933775e578973b73', + helperSemanticReceiptSha256: '010140351e9b3e2f17b1be6bd632a9ee21be67cf41220adcb86f1aec51010686', + selectionScope: 'N выводится только из нового baseline-only pilot по прежнему закону; 1.05/MDE/power/counts не подгоняются к exploratory effect', + }, + browsers: ['chromium', 'firefox', 'webkit'], + viewport: { width: 800, height: 200 }, + deviceScaleFactor: 1, + headless: true, + cpuThrottle: 1, + engineScenes: [ + { id: 'scalar-live-100', lifecycle: 'live', count: 100, channels: 1 }, + { id: 'transform-fresh-1000', lifecycle: 'fresh', count: 1000, channels: 7 }, + { id: 'motion-value-default-stock-c', workload: 'stock-c', callsPerRepetition: 2000, warmupBatches: 2, + expectedFrames: 47, initial: 0, target: 100, spring: { mass: 1, stiffness: 170, damping: 26 }, metrics: ['operationNs'] }, + ], + browserScenes: [ + { id: 's2', targetsPerCall: 100, staggerGapMs: 0 }, + { id: 's3', targetsPerCall: 200, staggerGapMs: 5 }, + ], + comparators: ['motion', 'gsap', 'anime', 'waapi-ctl', 'motion-mini', 'anime-waapi'], + durationMs: 128, + toPx: 300, + repetitions: 8, + browserBatchCalls: 32, + browserSemanticCalls: 1, + browserSemantics: { movementThresholdPx: 0.5, finalTolerancePx: 2, requireFreshStart: true, fromPx: 0, requireDocumentFrame: true, + temporalOracle: 'наблюдаемый свежий onset 0→300 до/после API; фаза связана с началом вызова; полный displacement interval разрешающей пары внутри прежнего CSS допуска; timed onset ограничен actual batch/read часами; CSS в actual стабильном document frame, связанном с rAF; perf chronology сохранена, без расширения при uncertainty' }, + warmupRuns: 4, + pilotRuns: 8, + minRuns: 292, + maxRuns: 1024, + seed: 0x53525652, + statistics: 'точные биномиальные интервалы порядковых статистик по среднему стоимости двух противоположных runs', + familyAlpha: 0.05, + familySize: 11, + nonInferiorityUpper: 1.05, + positiveLower: 1.5, + positiveWorkMultiplier: 2, + mdeRelative: 0.05, + power: 0.8, + zPower: 0.8416212335729143, + // Bonferroni: 11 клеток × p50/p95, двухсторонняя family-wise 95% полоса. + zFamily: 3.052065201864885, + metrics: { + engine: ['operationNs', 'meanFrameNs', 'cancelDrainNs'], + browser: ['startMs', 'cancelMs'], + }, + clock: { engine: 'Linux CLOCK_THREAD_CPUTIME_ID: reported scheduled-runtime текущего потока, наносекунды', browser: 'realm-local performance.now, миллисекунды' }, + engineRawLineage: 'все native CLOCK_THREAD_CPUTIME_ID seconds/nanoseconds/PID/TID и ordered scheduler/CSS traces сохраняются lossless; legacy16 endpoints, stockC2 endpoints + каждый фактический47-frame/endpoint100 исход; BigInt endpoints, интервалы и denominator пересчитываются существующим owner', + samplingUnit: 'средняя стоимость парного блока двух противоположных runs; повторы/кадры зависимы; p95 относится к распределению средних блоков', + denominator: 'стоимость полезного вызова с зарегистрированными targets: browser batch/32; positive64actualcalls; legacyengine unchanged; stockC batch/2000, positive4000actualcalls/2000 без деления на два', + stockCpuScope: 'штатный whole stockC macro main-entry MotionValue: factory+2×2000warmups внеCPU; clock/drain/construct/onChange/setTarget/destroy вCPU, preallocated per-operation last+getFrameCount recording вCPU одинаков обеимролям; RLE/oracle внеCPU. Не per-framep99/100channels.', + stoppingRule: 'один baseline-only pilot → замороженный N; невозможная мощность немедленно сохраняет UNPROVEN без A/A, 2×work и A/B; иначе один A/A и 2×work → A/B только при годной калибровке; добор и повтор к green запрещены', + preservedGuards: 'size-gate, численные/семантические допуски и protected p95 upper ≤1.05 не меняются', + scope: 'headless server: CPU потока engine и API browser при duration=128 ms; counts/stagger закреплены; endpoint/start/frame/retarget/cancel отдельно; canonical 1200 ms guards независимы', + unproven: ['mobile Android/iOS', 'physical 60/120 Hz', 'whole-page energy', 'GPU', 'M-04 physical-device envelope', 'M-05 product scene families'], + forcedGc: 'только отдельный retention child process после host turn, затем два GC у каждого heap snapshot; в timing отсутствует', + rawControls: 'baseline no-motion: два одинаковых PNG; reduced-motion: endpoint без rAF/WAAPI; candidate controls только после PASS calibration', + resourcePolicy: 'весь cgroup: до/после каждого парного блока; affinity неизменна, nr_throttled/throttled_usec delta=0; все samples сохраняются, нарушение даёт UNPROVEN без post-hoc исключений', + browserOperationTimeoutMs: 30_000, + clockError: { + id: 'linux-thread-scheduled-runtime-node24.19-chromium149-isolated', + kernelRelease: '6.18.44', + nodeVersion: 'v24.19.0', + nodeExecutableSha256: 'bc17c508ffeed0ec622934f9b7fa72f8e78da65350e63c3eceb56fa688aa5e12', + browser: 'chromium', + browserVersion: '149.0.7827.55', + browserExecutableSha256: '2d18db9d8608b052b6a552ee00ec1e830f93692e928b65ecc67d693bd33fe801', + browserClampErrorPerTimestampMs: 0.005, + browserTickTruncationPerTimestampMs: 0.001, + monotonicCounterLimitMs: 2 ** 42, + engineClock: 'CLOCK_THREAD_CPUTIME_ID', + engineCounterOutwardPaddingNs: 2_000, + engineCounterScope: 'сообщённый Linux scheduled-runtime текущего main-thread; 2us — прежнее консервативное outward padding reported counter, без гарантии физической точности или выводов из nominal clock_getres; getter overhead не вычитается', + nativeSourceFiles: { + 'bench/profile/server-thread-cpu-clock.c': '4f32f23c2409c3e83943121a587c8d9f5e19af7f308ac987323ff4189ddd14c0', + 'bench/profile/native-clock/include/js_native_api.h': '8808ef8899a1691411928ef5dd7dae0537aedc93d3a34e223b2d89692e79c788', + 'bench/profile/native-clock/include/js_native_api_types.h': '4f19cb90d240765cc0961d92a1ee20f65fdc50db7de1ab0a5cb6bc227224e1a0', + 'bench/profile/native-clock/include/node_api.h': '2d4560831e525b47b060ec8a0864ab73993df9e20215ce9f0fe7b24cd31af32a', + 'bench/profile/native-clock/include/node_api_types.h': 'a25356630d3058f0a0c8937d9f297e9471e037fda58c2696d8a505c2bd99cb00', + }, + sources: { + timeClamper: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/timing/time_clamper.cc', sha256: '2491cb64f50a54ccd10f778c058f0960ad4d9fa0861e39212bc27b8343bd103c' }, + timeClamperHeader: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/timing/time_clamper.h', sha256: 'f8065edb3ba8da66d58eb7042523fba44b6d515c04d482614670a5414a684944' }, + performance: { url: 'https://raw.githubusercontent.com/chromium/chromium/149.0.7827.55/third_party/blink/renderer/core/timing/performance.cc', sha256: '62de6788c9361958757f47a173369cc668f3691ec58f27e2d2edfab780efe200' }, + windowPerformance: { url: 'https://raw.githubusercontent.com/chromium/chromium/149.0.7827.55/third_party/blink/renderer/core/timing/window_performance.cc', sha256: '5916501d9960c6355f1b2b0cee7cbc10091bf63ac64b0bf6397d96e495f71983' }, + timeTicks: { url: 'https://raw.githubusercontent.com/chromium/chromium/149.0.7827.55/base/time/time_now_posix.cc', sha256: '6a7b898ec4a2eedbfcc2173ca3cac17b188829b9531ba3febcfe942925ed5796' }, + documentTimeline: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/animation/document_timeline.cc', sha256: 'e8e405492b4f49f6be850e68c3431d1e2107ac032ea4ff11c433cc726642c702' }, + animationClock: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/animation/animation_clock.cc', sha256: 'f3290008c81dab4f17c7ae8439de25c1c95d0204be6dbb16dada0fd1a8e584eb' }, + animationTimeline: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/animation/animation_timeline.cc', sha256: '6745f06a855d19691098929b29a5d28331d814c6ae21f1cdf12368eeb7ab5c90' }, + documentAnimations: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/animation/document_animations.cc', sha256: '6b20e0668cc740d1e2c9a9828b5316c81b7c43f2eb907af686729e51d10855d2' }, + pageAnimator: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/page/page_animator.cc', sha256: 'ba6157ecdc92b5e3375e0239c3b79f39050f5ea3a84d27f65e60b03f1b676e03' }, + cssComputedStyle: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/css/css_computed_style_declaration.cc', sha256: 'fc8f9580c1fd1bc2c28d753083925118c38134c37406dcd2f55d98a8ea2bbfb6' }, + documentStyle: { url: 'https://chromium.googlesource.com/chromium/src/+/149.0.7827.55/third_party/blink/renderer/core/dom/document.cc', sha256: '8a09dd50bdbbca54b11af849376c4f76df2fd62b14ae665c4c208553b4941dd6' }, + nodeProcess: { url: 'https://raw.githubusercontent.com/nodejs/node/v24.19.0/src/node_process_methods.cc', sha256: '6f2d27513a933dd3d076c0ffe2f95a1846ba1d1060f7ccfbc6eb2df6692a34eb' }, + libuvCore: { url: 'https://raw.githubusercontent.com/nodejs/node/v24.19.0/deps/uv/src/unix/core.c', sha256: '18bfd5f2045417f8ace5d76e222bf7441b31ead5fc2cbaf6225965e0afea8767' }, + libuvLinux: { url: 'https://raw.githubusercontent.com/nodejs/node/v24.19.0/deps/uv/src/unix/linux.c', sha256: '215185d94697e05cd75ba9466bb9ea93076769a7767218d4183eaf0723ccf2d2' }, + linuxRusage: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/sys.c', sha256: '0b656f8809d781b7e684a1a4c4144d925684c69e9f6050c41c6374c5206d2c8d' }, + linuxTimeval: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/time/time.c', sha256: 'e757e825d72489c929a273f22aba8fa31487c29738960aea2683ac0274a58e6a' }, + linuxPosixCpuTimers: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/time/posix-cpu-timers.c', sha256: '23255e35526f6582c00ad0c88438c378bfa45d49316019fa76cacd6be1983621' }, + linuxSchedulerCore: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/sched/core.c', sha256: '5b510e027f1a6236165f26da4b1195530264dc0013ff8883bf49d03114ea26c2' }, + linuxSchedulerCpuTime: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/sched/cputime.c', sha256: 'eabd7ccf5bafd87ccd686829b1192e56dafb8c213f10f12aec619405246977a6' }, + linuxSchedulerClock: { url: 'https://raw.githubusercontent.com/gregkh/linux/v6.18.44/kernel/sched/clock.c', sha256: '043618ff56eb333bd7c3a243bc9597387f8e9bb7b240c7383712a4643d196118' }, + }, + documentFrame: 'Chromium149 PageAnimator coarsens frame TimeTicks тем же isolated TimeClamper; DocumentTimeline origin совпадает с навигацией; AnimationClock стабилен в rendering/task; CSS recalc обновляет animation timing этим clock. До/после onset API observed publication clock одинаков и связывает origin свежего движения; checkpoint clock одинаков до/после CSS и связан с observed rAF. Frame timestamp может предшествовать execution wall, wall chronology отдельна. Сопоставление frame/perf включает три coarsened timestamps(frame/now/origin): upward(1.5×прежний2-endpoint envelope), без изменения API-cost bounds. Нет qualification или clocks противоречат — отказ. Это clock публикации CSS, а не атрибуция внутреннего таймера JS/native API.', + scope: 'Linux CLOCK_THREAD_CPUTIME_ID: разность exact seconds/nanoseconds reported scheduled-runtime с прежним2us outward padding; Chromium isolated TimeClamper может округлять в обе стороны на5us, TimeTicks truncates1us; обе browser clockreads и binary64 roundoff входят в pointwise bounds до CI, без shrink по repeats/N', + assumption: 'закреплённые official browser/Node binaries, private native getter и Linux6.18.44 исполняют указанную upstream clock model; Node hrtime и browser TimeTicks используют общий Linux CLOCK_MONOTONIC без namespace/clock override; reported scheduled-runtime не является физическим elapsed временем, nominal resolution/observed quantum не являются сертификатами error; другие binary/model/небезопасные counters дают отказ', + }, + browserCancellationWitness: { frames: 2, transformTolerancePx: 0.000001, + scope: 'attached targets после cancel: нет WAAPI, transform неизменен два rAF; sync cancelMs и elapsed cancel→drain раздельно; swallowed vendor exceptions нормализованного adapter не наблюдаются' }, + stationarityAssumption: 'независимые одинаково распределённые средние paired blocks при закреплённой среде; A/A и ресурсные controls проверяют разрешимость, перенос за пределы этой клетки не доказан', +}); + +export function serverProfileDigest(value) { + const text = JSON.stringify(value); + // Native SHA читает UTF-8 string без отдельной Buffer копии. Undefined + // сохраняет прежний TypeError после того же однократного чтения JSON. + return sha256Bytes(text === undefined ? Buffer.from(text) : text); +} + +export function verifyServerProfile(value) { + if (!isDeepStrictEqual(value, SERVER_PROFILE)) throw new Error('server profile: изменён зарегистрированный протокол'); +} + +export function serverTailPolicy() { + // Family alpha = 1/20; rational denominator предотвращает лишнюю float + // операцию, дающую соседний binary64 к точному1/1760. + const alphaPerTail = 1 / (SERVER_PROFILE.familySize * 2 * 2 * 2 * 20); + return { alphaPerTail, quantiles: [0.5, 0.95], minimumBlocks: Math.ceil(Math.log(alphaPerTail) / Math.log(0.95)), + correction: 'Bonferroni: 11 cells × 2 quantiles × 2 participants × 2 tails; family-wise 95%' }; +} + +// Требуемый N выводится только из baseline A/A pilot, до любых candidate samples. +// Формула планирует средний парный log-contrast; tail admission остаётся отдельным +// строгим гейтом и не получает гарантии мощности от этой приближённой оценки. +export function planServerSampleSize(pilotPairs) { + if (!Array.isArray(pilotPairs) || pilotPairs.length !== SERVER_PROFILE.familySize) { + throw new Error('server profile: неполное семейство null-pilot'); + } + const cells = pilotPairs.map(({ id, left, right }) => { + if (typeof id !== 'string' || !Array.isArray(left) || !Array.isArray(right) || + left.length !== SERVER_PROFILE.pilotRuns || right.length !== left.length || + [...left, ...right].some((x) => !Number.isFinite(x) || x <= 0)) { + throw new Error('server profile: некорректные baseline-only pilot samples'); + } + const differences = Array.from({ length: left.length / 2 }, (_, block) => + (Math.log(left[block * 2]) - Math.log(right[block * 2]) + Math.log(left[block * 2 + 1]) - Math.log(right[block * 2 + 1])) / 2); + const mean = differences.reduce((a, b) => a + b, 0) / differences.length; + const variance = differences.reduce((a, b) => a + (b - mean) ** 2, 0) / (differences.length - 1); + const requiredRuns = 2 * Math.ceil(((SERVER_PROFILE.zFamily + SERVER_PROFILE.zPower) * Math.sqrt(variance) / + Math.log(1 + SERVER_PROFILE.mdeRelative)) ** 2); + return { id, logContrastSd: Math.sqrt(variance), requiredRuns }; + }); + if (new Set(cells.map(({ id }) => id)).size !== cells.length) throw new Error('server profile: повторная pilot cell'); + const tail = serverTailPolicy(); + const requiredRuns = Math.max(SERVER_PROFILE.minRuns, tail.minimumBlocks * 2, ...cells.map(({ requiredRuns: n }) => n)); + const runs = Math.min(SERVER_PROFILE.maxRuns, Math.ceil(requiredRuns / 2) * 2); + return { runs, requiredRuns, feasible: requiredRuns <= SERVER_PROFILE.maxRuns, cells, tail, + method: 'baseline-only paired block log-contrast normal approximation; power 0.8, MDE 5%, Bonferroni family 11×2; N в runs, блок содержит два run' }; +} diff --git a/bench/profile/server-profile-retention.mjs b/bench/profile/server-profile-retention.mjs new file mode 100644 index 000000000..d553e65a9 --- /dev/null +++ b/bench/profile/server-profile-retention.mjs @@ -0,0 +1,44 @@ +// Forced GC изолирован от timing. Отрицательная delta не превращается в ноль. +import { readFileSync } from 'node:fs'; +import path from 'node:path'; +import { pathToFileURL } from 'node:url'; +import { runTransformLifecycleSample } from '../../scripts/bench-transform-support.mjs'; +import { createMotionValueDefaultBenchmark } from '../../scripts/bench-support.mjs'; +import { SERVER_PROFILE } from './server-profile-registration.mjs'; + +if (typeof globalThis.gc !== 'function' || process.argv.length !== 3) throw new Error('retention: нужен отдельный --expose-gc процесс и один package directory'); +const directory = process.argv[2]; +const metadata = JSON.parse(readFileSync(path.join(directory, 'package.json'), 'utf8')); +const { animate } = await import(pathToFileURL(path.join(directory, metadata.exports['./animate'].import.default)).href); +const { MotionValue } = await import(pathToFileURL(path.join(directory, metadata.exports['.'].import.default)).href); +const rows = []; +let failure = null; +try { + for (const scene of SERVER_PROFILE.engineScenes) { + const macro = scene.workload === 'stock-c' ? createMotionValueDefaultBenchmark(MotionValue, scene.spring) : null; + const run = async () => { + if (!macro) return runTransformLifecycleSample({ animate, ...scene }); + for (let operation = 0; operation < scene.callsPerRepetition; operation++) { + const value = macro.run(), frames = macro.getFrameCount(); + if (value !== scene.target || frames !== scene.expectedFrames) throw Object.assign(new Error('retention: stock C отдельная операция неверна'), + { raw: { operation, completed: operation, value, frames } }); + } + }; + for (let warmup = 0; warmup < (scene.warmupBatches ?? 1); warmup++) await run(); + // Микрозадача Promise не освобождает временно удерживаемые цели WeakRef в зафиксированном Node. + // Новый оборот очереди отделяет это удержание от оставшейся памяти. + await new Promise((resolve) => setImmediate(resolve)); + globalThis.gc(); globalThis.gc(); + const before = process.memoryUsage(); + for (let repeat = 0; repeat < SERVER_PROFILE.repetitions; repeat++) await run(); + await new Promise((resolve) => setImmediate(resolve)); + globalThis.gc(); globalThis.gc(); + const after = process.memoryUsage(); + rows.push({ scene: scene.id, before, after, retainedHeapDeltaBytes: after.heapUsed - before.heapUsed }); + } +} catch (error) { + failure = { name: error.name, message: error.message, ...(error.raw ? { raw: error.raw } : {}) }; + process.exitCode = 1; +} +process.stdout.write(`${JSON.stringify({ verdict: failure ? 'UNPROVEN' : 'COMPLETE', failure, + scope: 'пакет + oracle; observational retained heap после host turn и двух GC; не тайминг и не точная атрибуция утечки', rows })}\n`); diff --git a/bench/profile/server-profile-runner.mjs b/bench/profile/server-profile-runner.mjs new file mode 100644 index 000000000..a95ec7f5d --- /dev/null +++ b/bench/profile/server-profile-runner.mjs @@ -0,0 +1,746 @@ +// Расширение существующего bench owner: общие сборка, origin, адаптеры и законы +// round-robin. Ни одного вывода о физическом мобильном устройстве здесь нет. +import { execFileSync, spawnSync } from 'node:child_process'; +import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, symlinkSync, writeFileSync } from 'node:fs'; +import { createRequire } from 'node:module'; +import { arch, cpus, hostname, loadavg, platform, release, totalmem } from 'node:os'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import { PerformanceObserver } from 'node:perf_hooks'; +import { runTransformLifecycleSample } from '../../scripts/bench-transform-support.mjs'; +import { createMotionValueDefaultBenchmark } from '../../scripts/bench-support.mjs'; +import { runSemanticStartCheck, startBenchmarkOrigin } from '../compare/bench.mjs'; +import { compactStockMotionValueOutcomes, deriveRealmTimerStep, PRODUCTION_ADAPTER_PROFILE, validateStockMotionValueBatch } from '../compare/methodology.mjs'; +import { assertCheckoutUnchanged, assertFileHashesUnchanged, assertInstalledPackageTreesUnchanged, + hashFileTree, prepareBenchmarkCheckout, sha256File } from '../compare/provenance.mjs'; +import { SERVER_PROFILE, planServerSampleSize, serverProfileDigest } from './server-profile-registration.mjs'; +import { prepareServerThreadCpuClock, readServerThreadCpuEndpoint } from './server-thread-cpu-clock.mjs'; +import { compactServerCpuEvidence, compactServerSemanticEvidence, serverBrowserSemanticClockErrorMs, serverCalibrationVerdict, serverCellPairs, + serverFamilyIntervals, serverOrders, serverResourceReasons, validateServerBrowserSample, validateServerEngineSample, verifyServerClockRegistration } from './server-profile-contract.mjs'; +import { writeServerArtifact } from './server-profile-artifact.mjs'; + +const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..'); +const BENCH = path.join(ROOT, 'bench/compare'); +const requireBench = createRequire(path.join(BENCH, 'package.json')); +const HARNESS_FILES = ['bench/profile/server-profile-registration.mjs', 'bench/profile/server-profile-contract.mjs', + 'bench/profile/server-profile-artifact.mjs', + 'bench/profile/server-profile-runner.mjs', 'bench/profile/server-profile-retention.mjs', + 'bench/profile/server-thread-cpu-clock.mjs', ...Object.keys(SERVER_PROFILE.clockError.nativeSourceFiles), + 'scripts/bench-transform-support.mjs', 'scripts/bench-support.mjs', 'scripts/bench.mjs', 'bench/compare/bench.mjs', + 'bench/compare/methodology.mjs', 'bench/compare/provenance.mjs']; +const ENTRIES = ['lab', ...SERVER_PROFILE.comparators]; +const PACKAGES = { motion: 'motion', gsap: 'gsap', anime: 'animejs', 'motion-mini': 'motion', 'anime-waapi': 'animejs' }; + +function preserveRawNumbers(value) { + if (typeof value === 'number' && !Number.isFinite(value)) return { nonfinite: String(value) }; + if (Array.isArray(value)) return value.map(preserveRawNumbers); + if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, preserveRawNumbers(child)])); + return value; +} + +function errorRecord(error) { + const code = error == null ? undefined : Object.getOwnPropertyDescriptor(error, 'code')?.value; + return { name: error?.name ?? typeof error, message: String(error?.message ?? error), + ...(typeof code === 'string' ? { code } : {}), + ...(error?.errors ? { errors: error.errors.map(errorRecord) } : {}), + ...(error?.raw ? { raw: preserveRawNumbers(error.raw) } : {}), ...(error?.timerEvidence ? { timerEvidence: preserveRawNumbers(error.timerEvidence) } : {}) }; +} +function readOptional(file) { return existsSync(file) ? readFileSync(file, 'utf8').trim() : null; } +function contextSwitches() { + const status = readFileSync('/proc/self/status', 'utf8'); + return Object.fromEntries(['voluntary_ctxt_switches', 'nonvoluntary_ctxt_switches'].map((name) => + [name, Number(new RegExp(`^${name}:\\s*(\\d+)$`, 'm').exec(status)?.[1])])); +} +function captureServerLoad() { + const raw = readFileSync('/sys/fs/cgroup/cpu.stat', 'utf8'); + const cpuStat = Object.fromEntries(raw.trim().split('\n').map((line) => { const [key, value] = line.split(/\s+/); return [key, Number(value)]; })); + return { at: new Date().toISOString(), affinity: /^Cpus_allowed_list:\s*(.+)$/m.exec(readFileSync('/proc/self/status', 'utf8'))?.[1], + cpuMax: readOptional('/sys/fs/cgroup/cpu.max'), cpuStat, loadavg: loadavg(), contextSwitches: contextSwitches(), scope: 'весь cgroup, включая возможные фоновые процессы' }; +} +async function withBrowserTimeout(promise, label) { + let timeout; + try { + return await Promise.race([promise, new Promise((_, reject) => { + timeout = setTimeout(() => reject(new Error(`server profile: ${label} превысил ${SERVER_PROFILE.browserOperationTimeoutMs} ms`)), SERVER_PROFILE.browserOperationTimeoutMs); + })]); + } finally { clearTimeout(timeout); } +} +export function captureServerMachine() { + const affinity = /^Cpus_allowed_list:\s*(.+)$/m.exec(readFileSync('/proc/self/status', 'utf8'))?.[1]; + if (!/^\d+$/.test(affinity ?? '')) throw new Error('server profile: нужен один CPU через taskset, общий scheduler не закреплён'); + const cgroupCpuMax = readOptional('/sys/fs/cgroup/cpu.max'); + if (typeof cgroupCpuMax !== 'string' || cgroupCpuMax.length === 0) { + throw Object.assign(new Error('server profile: нет cgroup v2 cpu.max; ресурсный контракт невыполним до samples'), + { raw: { affinity, cgroupCpuMax } }); + } + const resource = captureServerLoad(); + const resourceKeys = ['usage_usec', 'user_usec', 'system_usec', 'nr_periods', 'nr_throttled', 'throttled_usec']; + if (!resourceKeys.every((key) => Number.isSafeInteger(resource.cpuStat[key]) && resource.cpuStat[key] >= 0)) { + throw Object.assign(new Error('server profile: cpu.stat не содержит шесть безопасных неотрицательных счётчиков; ресурсный контракт невыполним до samples'), + { raw: { resource } }); + } + const identity = { platform: platform(), release: release(), arch: arch(), host: hostname(), + cpu: cpus()[Number(affinity)]?.model, logicalCpus: cpus().length, totalMemoryBytes: totalmem(), affinity, + cgroupCpuMax, cgroupMemoryMax: readOptional('/sys/fs/cgroup/memory.max'), + governor: readOptional(`/sys/devices/system/cpu/cpu${affinity}/cpufreq/scaling_governor`), + display: 'headless; физический экран отсутствует', power: 'среда сервера; не устройство', thermal: 'не измеряется', + node: process.version, nodeExecutableSha256: sha256File(process.execPath), execArgv: process.execArgv }; + return { identity, sha256: serverProfileDigest(identity), observation: { at: new Date().toISOString(), loadavg: loadavg(), memory: process.memoryUsage() } }; +} + +export function createServerJournal(out) { + mkdirSync(out, { recursive: false }); + let previous = '0'.repeat(64); + const file = path.join(out, 'journal.ndjson'); + return (type, value) => { + const payload = { sequenceDigest: previous, type, value }; + const digest = serverProfileDigest(payload); + appendFileSync(file, `${JSON.stringify({ ...payload, digest })}\n`, { flag: 'a' }); + previous = digest; + return digest; + }; +} + +export async function withServerProfileSignals(run) { + const controller = new AbortController(); + const stop = (signal) => { + if (controller.signal.aborted) return; + controller.abort(Object.assign(new Error(`server profile: оператор запросил ${signal}`), { + name: 'AbortError', code: 'OPERATOR_INTERRUPTION', raw: { signal, receivedAt: new Date().toISOString() }, + })); + }; + const interrupt = () => stop('SIGINT'), terminate = () => stop('SIGTERM'); + process.on('SIGINT', interrupt); process.on('SIGTERM', terminate); + try { return await run(controller.signal); } + finally { process.off('SIGINT', interrupt); process.off('SIGTERM', terminate); } +} + +export async function runServerProfileCalibration(artifact, runStage, journal) { + artifact.warmup = await runStage('warmup', SERVER_PROFILE.warmupRuns); + artifact.pilot = await runStage('pilot', SERVER_PROFILE.pilotRuns); + artifact.samplePlan = planServerSampleSize(serverCellPairs(artifact.pilot, SERVER_PROFILE.pilotRuns, 'pilot', artifact.registration.engineClock)); + artifact.frozenPlanDigest = serverProfileDigest({ registrationDigest: artifact.registrationDigest, samplePlan: artifact.samplePlan }); + journal('N-frozen-before-calibration-and-AB', { samplePlan: artifact.samplePlan, digest: artifact.frozenPlanDigest }); + if (!artifact.samplePlan.feasible) throw Object.assign(new Error(`server profile: pilot требует ${artifact.samplePlan.requiredRuns} runs, предел ${SERVER_PROFILE.maxRuns}`), { + code: 'UNPROVEN_POWER', raw: { samplePlan: artifact.samplePlan, frozenPlanDigest: artifact.frozenPlanDigest }, + }); + artifact.aa = await runStage('aa', artifact.samplePlan.runs); + artifact.positive = await runStage('positive', artifact.samplePlan.runs); + const aa = serverFamilyIntervals(serverCellPairs(artifact.aa, artifact.samplePlan.runs, 'aa', artifact.registration.engineClock)); + const positiveControl = serverFamilyIntervals(serverCellPairs(artifact.positive, artifact.samplePlan.runs, 'positive', artifact.registration.engineClock)); + const calibrated = serverCalibrationVerdict(aa, positiveControl, artifact.samplePlan); + calibrated.reasons.push(...serverResourceReasons([artifact.warmup, artifact.pilot, artifact.aa, artifact.positive], artifact.registration.machine.identity)); + calibrated.verdict = calibrated.reasons.length ? 'UNPROVEN' : 'PASS'; + artifact.calibration = { ...calibrated, aa, positive: positiveControl }; + journal('calibration', artifact.calibration); + return artifact.calibration.verdict === 'PASS'; +} + +function buildToStderr(root) { + execFileSync('pnpm', ['run', 'build'], { cwd: root, stdio: ['ignore', 'ignore', 'inherit'], + shell: process.platform === 'win32', timeout: 180_000 }); +} + +// Игнорирование publish scripts запрещает vendor prepack rebuild другим toolchain. +// Фактический npm-consumer получает именно unpacked архив; workspace dist не импортируется. +function packConsumer(packageRoot, directory, nodeModules) { + mkdirSync(directory, { recursive: true }); + const metadata = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8')); + const tarball = path.join(directory, 'consumer.tgz'); + execFileSync('pnpm', ['--config.ignore-scripts=true', 'pack', '--out', tarball], { + cwd: packageRoot, stdio: ['ignore', 'ignore', 'pipe'], timeout: 60_000 }); + execFileSync('tar', ['-xzf', tarball, '-C', directory], { stdio: 'pipe', timeout: 30_000 }); + const packageDirectory = path.join(directory, 'package'); + const consumerName = path.join(nodeModules, metadata.name); + mkdirSync(path.dirname(consumerName), { recursive: true }); + symlinkSync(packageDirectory, consumerName, 'dir'); + const tree = hashFileTree(packageDirectory); + return { name: metadata.name, version: metadata.version, tarball, tarballSha256: sha256File(tarball), + directory: packageDirectory, treeSha256: tree.sha256, files: tree.files }; +} + +function packageClosure(name, out, nodeModules, packed = new Map()) { + const packageRoot = realpathSync(path.join(BENCH, 'node_modules', name)); + return packDependency(packageRoot); + function packDependency(directory) { + const metadata = JSON.parse(readFileSync(path.join(directory, 'package.json'), 'utf8')); + if (packed.has(metadata.name)) return packed.get(metadata.name); + const consumer = packConsumer(directory, path.join(out, metadata.name.replaceAll('/', '__')), nodeModules); + packed.set(metadata.name, consumer); + const resolver = createRequire(path.join(directory, 'package.json')); + for (const dependency of Object.keys(metadata.dependencies ?? {})) { + const entry = resolver.resolve(dependency); + let cursor = path.dirname(realpathSync(entry)); + while (!existsSync(path.join(cursor, 'package.json')) || JSON.parse(readFileSync(path.join(cursor, 'package.json'), 'utf8')).name !== dependency) { + const parent = path.dirname(cursor); if (parent === cursor) throw new Error('server profile: не разрешён transitive package'); cursor = parent; + } + packDependency(cursor); + } + return consumer; + } +} + +function buildAdapter(id, consumerRoot, esbuild, out) { + const owner = id === 'baseline' || id === 'candidate' ? 'lab' : id; + const entry = path.join(BENCH, `entries/${owner === 'waapi-ctl' ? 'waapi-control' : owner}.entry.mjs`); + const original = readFileSync(entry, 'utf8'); + const contents = owner === 'lab' ? original.replace("'../../../dist/animate/index.js'", "'@labpics/motion/animate'") : original; + const artifact = path.join(out, `${id}.iife.js`); + esbuild.buildSync({ ...PRODUCTION_ADAPTER_PROFILE, stdin: { contents, resolveDir: consumerRoot, sourcefile: path.basename(entry) }, + nodePaths: [path.join(consumerRoot, 'node_modules')], format: 'iife', globalName: '__adapterModule', outfile: artifact, logLevel: 'silent' }); + return { path: artifact, sha256: sha256File(artifact), ownerEntry: entry, ownerEntrySha256: sha256File(entry) }; +} + +function threadCpuNs(reads) { + const endpoint = readServerThreadCpuEndpoint(); + const acquired = { sequence: reads.length, ...endpoint }; + reads.push(acquired); + if (acquired.clock !== 'CLOCK_THREAD_CPUTIME_ID' || acquired.pid !== process.pid || acquired.tid !== process.pid || + typeof acquired.seconds !== 'string' || !/^(0|[1-9]\d*)$/.test(acquired.seconds) || + !Number.isSafeInteger(acquired.nanoseconds) || acquired.nanoseconds < 0 || acquired.nanoseconds >= 1_000_000_000) { + throw Object.assign(new Error('server profile: unsafe native scheduled CPU endpoint вне clock model'), { raw: acquired }); + } + const valueNs = BigInt(acquired.seconds) * 1_000_000_000n + BigInt(acquired.nanoseconds); + if (acquired.valueNs !== String(valueNs)) throw Object.assign(new Error('server profile: native CPU value не пересчитывается из sec/nsec'), { raw: acquired }); + return valueNs; +} + +function sampleCpuClock(raw) { + const endpoint = raw[0]?.raw?.cpuReads?.[0]; + return { clock: endpoint?.clock, pid: endpoint?.pid, tid: endpoint?.tid }; +} + +function compactSampleCpuEvidence(sample) { + // Никакой частичной замены при отказе encoder: исходные массивы остаются в error.raw. + let encoded; + try { encoded = sample.raw.map((measured) => compactServerCpuEvidence(measured.raw.cpuReads)); } + catch (error) { throw Object.assign(new AggregateError([error], 'server profile: native CPU carrier не завершён'), { raw: sample }); } + for (let index = 0; index < sample.raw.length; index++) sample.raw[index].raw.cpuReads = encoded[index]; +} + +export async function measureServerEngine(animate, scene, workMultiplier = 1) { + if (scene.workload === 'stock-c') return measureServerStockC(animate, scene, workMultiplier); + const raw = []; + const before = process.memoryUsage(); + const contextBefore = contextSwitches(); + let cpuReads = []; + let sampleResult; + try { + for (let repetition = 0; repetition < SERVER_PROFILE.repetitions; repetition++) { + for (let extra = 0; extra < workMultiplier; extra++) { + cpuReads = []; + const measured = await runTransformLifecycleSample({ animate, + count: scene.count, lifecycle: scene.lifecycle, channels: scene.channels, nowNs: () => threadCpuNs(cpuReads) }); + measured.raw.cpuReads = cpuReads; + const hashes = measured.semantic.targetTraceHashes; + if (hashes.every((hash) => hash === hashes[0])) measured.semantic.targetTraceHashes = { encoding: 'repeat', count: hashes.length, value: hashes[0] }; + raw.push(measured); + } + } + const aggregate = (read) => raw.reduce((sum, sample) => sum + read(sample), 0) / SERVER_PROFILE.repetitions; + sampleResult = { operationNs: aggregate((sample) => sample.operationNs), + meanFrameNs: aggregate((sample) => sample.frameNs.reduce((a, b) => a + b, 0) / sample.frameNs.length), + cancelDrainNs: aggregate((sample) => sample.cancelDrainNs), semantic: raw.every((sample) => sample.semantic.valid), + repetitions: SERVER_PROFILE.repetitions, workMultiplier, denominator: SERVER_PROFILE.denominator, + cpuClock: sampleCpuClock(raw), + contextSwitchObservation: { before: contextBefore, after: contextSwitches(), scope: 'Node process; timing использует только CPU текущего потока' }, + allocationObservation: { before, after: process.memoryUsage(), scope: 'пакет + независимый oracle + harness; allocator/GC не разложены' }, raw }; + validateServerEngineSample(sampleResult, scene, workMultiplier); + return sampleResult; + } catch (error) { + throw Object.assign(new AggregateError([error], 'server profile: engine sample не завершён'), { raw: sampleResult ?? { + completed: raw, failedRepetition: preserveRawNumbers(error?.raw ? { ...error.raw, cpuReads } : { cpuReads }), before, after: process.memoryUsage() } }); + } +} + +/** Штатный stock C: per-call evidence stores внутри CPU, oracle/RLE снаружи. */ +export async function measureServerStockC(MotionValue, scene, workMultiplier = 1) { + const raw = [], warmup = []; + const before = process.memoryUsage(), contextBefore = contextSwitches(); + let current = null; + let sampleResult; + try { + if (typeof MotionValue !== 'function' || ![1, 2].includes(workMultiplier)) throw new Error('stock C: неизвестный constructor/work multiplier'); + const macro = createMotionValueDefaultBenchmark(MotionValue, scene.spring); + const batch = (timed, multiplier) => { + const calls = scene.callsPerRepetition * multiplier; + const values = new Array(calls), frames = new Array(calls); + const cpuReads = [], clockReads = []; + current = { raw: { schemaVersion: 1, scene: scene.id, phase: timed ? 'timed' : 'warmup', calls, + denominator: scene.callsPerRepetition, completed: 0, clockReads, cpuReads, values, frames, unfinishedOperation: null } }; + const read = (edge) => { + const valueNs = threadCpuNs(cpuReads); + clockReads.push({ sequence: clockReads.length, metric: 'operationNs', frame: null, edge, valueNs: String(valueNs) }); + return valueNs; + }; + const start = timed ? read('before') : null; + for (let operation = 0; operation < calls; operation++) { + // Чтение frame count необходимо для каждого вызова: среднее47 + // не отличает две неправильные операции0/94. Два массива выделены + // до CPU, а преобразование в RLE и oracle выполняются после него. + const value = macro.run(); + values[operation] = value; + frames[operation] = macro.getFrameCount(); + current.raw.completed++; + } + const end = timed ? read('after') : null; + const result = { operationNs: timed ? Number(end - start) / scene.callsPerRepetition : null, + raw: { schemaVersion: 1, scene: scene.id, phase: timed ? 'timed' : 'warmup', calls, + denominator: scene.callsPerRepetition, completed: calls, clockReads, cpuReads, + outcomes: compactStockMotionValueOutcomes(values, frames) } }; + current = result; + validateStockMotionValueBatch(result, scene, multiplier, timed); + return result; + }; + // Штатные две warmup batches до первой измеренной работы; candidate + // попадает сюда только после общей calibration и frozen N. + for (let index = 0; index < scene.warmupBatches; index++) warmup.push(batch(false, 1)); + for (let repetition = 0; repetition < SERVER_PROFILE.repetitions; repetition++) raw.push(batch(true, workMultiplier)); + sampleResult = { operationNs: raw.reduce((sum, result) => sum + result.operationNs, 0) / SERVER_PROFILE.repetitions, + semantic: true, repetitions: SERVER_PROFILE.repetitions, workMultiplier, denominator: SERVER_PROFILE.denominator, + cpuScope: SERVER_PROFILE.stockCpuScope, warmup, raw, + cpuClock: sampleCpuClock(raw), + contextSwitchObservation: { before: contextBefore, after: contextSwitches(), scope: 'Node process; CPU только текущего потока' }, + allocationObservation: { before, after: process.memoryUsage(), scope: 'whole macro + recorder + oracle + harness; retained отдельно' } }; + validateServerEngineSample(sampleResult, scene, workMultiplier); + return sampleResult; + } catch (error) { + if (current?.raw?.values) { + const completed = current.raw.completed; + const valueAcquired = Object.hasOwn(current.raw.values, completed); + const frameAcquired = Object.hasOwn(current.raw.frames, completed); + current.raw.unfinishedOperation = { index: completed, valueAcquired, frameAcquired }; + const acquired = (values, count) => values.slice(0, count).map((value) => value === undefined ? { type: 'undefined' } + : Object.is(value, -0) ? { number: '-0' } : value); + current.raw.values = acquired(current.raw.values, completed + Number(valueAcquired)); + current.raw.frames = acquired(current.raw.frames, completed + Number(frameAcquired)); + } + throw Object.assign(new AggregateError([error], 'server profile: stock C sample не завершён'), { raw: sampleResult ?? preserveRawNumbers({ + warmup, completed: raw, failedRepetition: current, before, after: process.memoryUsage() }) }); + } +} + +async function browserTimerProbe(page, phase) { + const raw = await withBrowserTimeout(page.evaluate(() => { + const deltas = []; + for (let i = 0; i < 64; i++) { + const begin = performance.now(); let end = begin; + for (let attempts = 0; attempts < 1_000_000 && end === begin; attempts++) end = performance.now(); + if (end > begin) deltas.push(end - begin); + } + return { timeOriginMs: performance.timeOrigin, performanceNowDeltasMs: deltas }; + }), 'browser timer probe'); + return { phase, ...raw }; +} + +export async function measureServerBrowser(browser, origin, adapter, scene, workMultiplier = 1) { + const context = await withBrowserTimeout(browser.newContext({ viewport: SERVER_PROFILE.viewport, deviceScaleFactor: SERVER_PROFILE.deviceScaleFactor }), 'browser context'); + const partial = []; + let before, sampleResult, failure; + try { + const page = await context.newPage(); await page.goto(origin.url, { waitUntil: 'load' }); + await page.exposeFunction('__serverSavePartial', (value) => { partial.push(preserveRawNumbers(value)); }); + if (!(await page.evaluate(() => crossOriginIsolated))) throw new Error('server profile: отсутствует изоляция realm часов'); + const source = readFileSync(adapter.path, 'utf8'); + const coldImportMs = await withBrowserTimeout(page.evaluate((source) => { + const begin = performance.now(); (0, eval)(source); return performance.now() - begin; + }, source), 'browser cold import'); + partial.push({ phase: 'cold-import', coldImportMs }); + const semanticClockErrorMs = serverBrowserSemanticClockErrorMs(process.hrtime.bigint().toString()); + const semanticConfig = { ...scene, ...SERVER_PROFILE.browserSemantics, semanticClockErrorMs, + durationMs: SERVER_PROFILE.durationMs, toPx: SERVER_PROFILE.toPx }; + const semanticEvidence = compactServerSemanticEvidence(await withBrowserTimeout( + runSemanticStartCheck(page, semanticConfig, SERVER_PROFILE.browserSemanticCalls), 'browser normal-motion semantic control')); + partial.push({ phase: 'normal-motion', evidence: semanticEvidence }); + if (!semanticEvidence.valid) throw Object.assign(new Error('server profile: normal motion/topology не доказаны существующим oracle'), { raw: { partial, semanticEvidence } }); + before = await browserTimerProbe(page, 'before'); + const result = await withBrowserTimeout(page.evaluate(async (config) => { + const A = window.__adapterModule; + const drain = () => new Promise((resolve) => requestAnimationFrame(resolve)); + const compact = (values) => { + if (values.every((value) => Object.is(value, values[0]))) return { encoding: 'repeat', count: values.length, value: values[0] }; + const runs = []; + for (const value of values) { + if (runs.length && Object.is(runs.at(-1)[1], value)) runs.at(-1)[0]++; + else runs.push([1, value]); + } + return { encoding: 'rle', count: values.length, runs }; + }; + const expand = (values) => Array.isArray(values) ? values : values.encoding === 'repeat' ? Array(values.count).fill(values.value) + : values.runs.flatMap(([length, value]) => Array(length).fill(value)); + const snapshot = (els) => ({ connectedTargets: els.filter((element) => element.isConnected).length, + activeWaapi: els.reduce((sum, element) => sum + element.getAnimations().length, 0), + transforms: compact(els.map((element) => new DOMMatrixReadOnly(getComputedStyle(element).transform).e)) }); + const cancellationWitness = async (els, cancelBegin) => { + const before = snapshot(els), frames = []; + for (let frame = 0; frame < config.cancellation.frames; frame++) { await drain(); frames.push(snapshot(els)); } + return { connectedTargets: before.connectedTargets, activeWaapiBefore: before.activeWaapi, + transformsBefore: before.transforms, frames, cancelDrainMs: performance.now() - cancelBegin }; + }; + const assertCancellation = (witness, targets) => { + const before = expand(witness.transformsBefore); + if (witness.connectedTargets !== targets || witness.activeWaapiBefore !== 0 || + witness.frames.some((frame) => frame.connectedTargets !== targets || frame.activeWaapi !== 0 || + expand(frame.transforms).some((value, index) => !Number.isFinite(value) || Math.abs(value - before[index]) > config.cancellation.transformTolerancePx))) { + throw new Error('cancel не достиг наблюдаемой неподвижности attached targets после двух rAF'); + } + }; + const create = () => Array.from({ length: config.scene.targetsPerCall }, () => { + const el = document.createElement('div'); el.className = 'box'; document.body.appendChild(el); return el; + }); + const start = (els) => config.scene.staggerGapMs > 0 + ? A.startStagger(els, config.toPx, config.durationMs, config.scene.staggerGapMs) + : A.start(els, config.toPx, config.durationMs); + if (typeof start !== 'function' || !A?.start || (config.scene.staggerGapMs > 0 && !A.startStagger)) throw new Error('нет общего API сцены'); + // Независимый CSS matrix oracle подтверждает реальный линейный endpoint. + const witness = create(); + const controlStartBegin = performance.now(); const control = start(witness); const controlStartMs = performance.now() - controlStartBegin; + await new Promise((resolve) => setTimeout(resolve, config.durationMs + (witness.length - 1) * config.scene.staggerGapMs + 100)); + const endpoints = witness.map((element) => new DOMMatrixReadOnly(getComputedStyle(element).transform).e); + await window.__serverSavePartial({ phase: 'endpoint-observed-before-cancel', controlStartMs, endpoints }); + const controlCancelBegin = performance.now(); control.cancel(); const controlCancelMs = performance.now() - controlCancelBegin; + await window.__serverSavePartial({ phase: 'endpoint-before-cleanup', controlStartMs, controlCancelMs, endpoints }); + const controlCancelWitness = await cancellationWitness(witness, controlCancelBegin); + await window.__serverSavePartial({ phase: 'endpoint', controlStartMs, controlCancelMs, endpoints, controlCancelWitness }); + assertCancellation(controlCancelWitness, config.scene.targetsPerCall); + witness.forEach((element) => element.remove()); + if (endpoints.some((value) => !Number.isFinite(value) || Math.abs(value - config.toPx) > 2)) throw new Error('не совпал endpoint oracle'); + const raw = [], warmup = []; + for (let repetition = -1; repetition < config.repetitions; repetition++) { + const calls = config.batchCalls * config.workMultiplier; + const groups = Array.from({ length: calls }, create), owners = []; + const beginMs = performance.now(); + try { for (const targets of groups) owners.push(start(targets)); } catch (error) { + await window.__serverSavePartial({ phase: 'batch-start-failed', repetition, calls, ownersStarted: owners.length, + unfinishedStartClock: { beginMs, endMs: performance.now() }, error: { name: error?.name ?? typeof error, message: String(error?.message ?? error) } }); + throw error; + } + const startClock = { beginMs, endMs: performance.now() }; + const batchStartMs = startClock.endMs - startClock.beginMs; + const readBeginMs = performance.now(); + const targets = groups.flat(); + const startWitness = { connectedTargets: targets.filter((element) => element.isConnected).length, + activeWaapi: targets.reduce((sum, element) => sum + element.getAnimations().length, 0), + leadingPositions: compact(groups.map((elements) => new DOMMatrixReadOnly(getComputedStyle(elements[0]).transform).e)), + readClock: { beginMs: readBeginMs, endMs: performance.now() } }; + await window.__serverSavePartial({ phase: 'batch-started-before-cancel', repetition, calls, startClock, startWitness, + acquiredBatchStartMs: batchStartMs, ownersStarted: owners.length }); + let ownersCancelled = 0; + const cancelBegin = performance.now(); + try { for (const owner of owners) { owner.cancel(); ownersCancelled++; } } catch (error) { + await window.__serverSavePartial({ phase: 'batch-cancel-failed', repetition, calls, startClock, startWitness, + batchStartMs, ownersStarted: owners.length, ownersCancelled, unfinishedCancelClock: { beginMs: cancelBegin, endMs: performance.now() }, + error: { name: error?.name ?? typeof error, message: String(error?.message ?? error) } }); + throw error; + } + const cancelClock = { beginMs: cancelBegin, endMs: performance.now() }; + const batchCancelMs = cancelClock.endMs - cancelClock.beginMs; + const row = { startMs: batchStartMs / config.batchCalls, cancelMs: batchCancelMs / config.batchCalls, + batchStartMs, batchCancelMs, calls, ownersStarted: owners.length, ownersCancelled, startClock, cancelClock, startWitness }; + if (repetition < 0) warmup.push(row); else raw.push(row); + await window.__serverSavePartial({ phase: 'timing-before-cleanup', repetition, ...row }); + row.cancelWitness = await cancellationWitness(targets, cancelBegin); + await window.__serverSavePartial({ phase: repetition < 0 ? 'warmup' : 'timing', repetition, ...row }); + assertCancellation(row.cancelWitness, calls * config.scene.targetsPerCall); + if (expand(startWitness.leadingPositions).some((value) => !Number.isFinite(value) || value < -2 || value >= config.toPx - 2)) { + throw new Error('timed owner не сохранил окно до endpoint'); + } + targets.forEach((element) => element.remove()); await Promise.resolve(); + } + return { raw, warmup, endpoints, controlStartMs, controlCancelMs, controlCancelWitness, measurementTimeOriginMs: performance.timeOrigin, + heapObservation: performance.memory ? { usedJSHeapSize: performance.memory.usedJSHeapSize, totalJSHeapSize: performance.memory.totalJSHeapSize } : null }; + }, { scene, workMultiplier, repetitions: SERVER_PROFILE.repetitions, durationMs: SERVER_PROFILE.durationMs, toPx: SERVER_PROFILE.toPx, + batchCalls: SERVER_PROFILE.browserBatchCalls, cancellation: SERVER_PROFILE.browserCancellationWitness }), 'browser API sample'); + const after = await browserTimerProbe(page, 'after'); + const timerEvidence = { crossOriginIsolated: true, probes: [before, after] }; + const timerStepMs = deriveRealmTimerStep('server browser', timerEvidence); + const monotonicHostUpperNs = process.hrtime.bigint().toString(); + sampleResult = { ...result, coldImportMs, semanticEvidence, timerEvidence, timerStepMs, monotonicHostUpperNs, + clockModelDigest: serverProfileDigest(SERVER_PROFILE.clockError), + startMs: result.raw.reduce((sum, row) => sum + row.startMs, 0) / SERVER_PROFILE.repetitions, + cancelMs: result.raw.reduce((sum, row) => sum + row.cancelMs, 0) / SERVER_PROFILE.repetitions, + repetitions: SERVER_PROFILE.repetitions, workMultiplier, denominator: SERVER_PROFILE.denominator, semantic: true }; + validateServerBrowserSample(sampleResult, scene, workMultiplier); + } catch (error) { + failure = Object.assign(new AggregateError([error], 'server profile: browser sample не завершён'), { + raw: sampleResult ?? error?.raw ?? { partial, timerBefore: before, scene, workMultiplier }, timerEvidence: error?.timerEvidence }); + } finally { + try { await withBrowserTimeout(context.close(), 'browser context cleanup'); } catch (error) { + failure = Object.assign(new AggregateError([...(failure ? [failure] : []), error], 'server profile: browser cleanup не завершён'), + { raw: sampleResult ?? failure?.raw ?? { partial, timerBefore: before, scene, workMultiplier } }); + } + } + if (failure) throw failure; + return sampleResult; +} + +async function measureBrowserRawControls(browser, origin, adapter, out, id) { + const context = await withBrowserTimeout(browser.newContext({ viewport: SERVER_PROFILE.viewport, deviceScaleFactor: SERVER_PROFILE.deviceScaleFactor, reducedMotion: 'reduce' }), 'raw-control browser context'); + let result, failure; + const partial = {}; + try { + await context.addInitScript(() => { + window.__serverRafCount = 0; + const request = globalThis.requestAnimationFrame.bind(globalThis); + globalThis.requestAnimationFrame = (callback) => { window.__serverRafCount++; return request(callback); }; + }); + const page = await context.newPage(); await page.goto(origin.url); + await page.addScriptTag({ path: adapter.path }); + await page.evaluate(() => { + const el = document.createElement('div'); el.className = 'box'; el.id = 'static-control'; document.body.appendChild(el); + }); + const first = await page.screenshot(); const second = await page.screenshot(); + const firstFile = path.join(out, `${id}-no-motion-before.png`), secondFile = path.join(out, `${id}-no-motion-after.png`); + writeFileSync(firstFile, first, { flag: 'wx' }); writeFileSync(secondFile, second, { flag: 'wx' }); + partial.noMotion = { firstFile, secondFile, beforeSha256: sha256File(firstFile), afterSha256: sha256File(secondFile), equal: first.equals(second) }; + if (!first.equals(second)) throw Object.assign(new Error('server profile: no-motion PNG различаются'), { + raw: { firstFile, secondFile, beforeSha256: sha256File(firstFile), afterSha256: sha256File(secondFile) } }); + const reduced = await withBrowserTimeout(page.evaluate(async (config) => { + const el = document.getElementById('static-control'); const before = window.__serverRafCount; + const owner = window.__adapterModule.start([el], config.toPx, config.durationMs); + await Promise.resolve(); + const x = new DOMMatrixReadOnly(getComputedStyle(el).transform).e; + const rafRequests = window.__serverRafCount - before; const activeWaapi = el.getAnimations().length; + owner.cancel(); return { x, rafRequests, activeWaapi, prefersReducedMotion: matchMedia('(prefers-reduced-motion: reduce)').matches }; + }, SERVER_PROFILE), 'browser reduced-motion control'); + partial.reduced = reduced; + if (!reduced.prefersReducedMotion || Math.abs(reduced.x - SERVER_PROFILE.toPx) > 2 || reduced.rafRequests !== 0 || reduced.activeWaapi !== 0) { + throw Object.assign(new Error('server profile: reduced-motion не выполнил snap без движущего владельца'), { raw: reduced }); + } + result = partial; + } catch (error) { + failure = Object.assign(new AggregateError([error], 'server profile: raw control не завершён'), { raw: { ...partial, failureRaw: error.raw ?? null } }); + } finally { + try { await withBrowserTimeout(context.close(), 'raw-control context cleanup'); } catch (error) { + failure = Object.assign(new AggregateError([...(failure ? [failure] : []), error], 'server profile: raw-control cleanup не завершён'), { raw: result ?? failure?.raw ?? partial }); + } + } + if (failure) throw failure; + return result; +} + +function makeRetention(packageDirectory) { + const result = spawnSync(process.execPath, ['--expose-gc', path.join(ROOT, 'bench/profile/server-profile-retention.mjs'), packageDirectory], + { encoding: 'utf8', timeout: 60_000 }); + let report; + try { report = JSON.parse(result.stdout); } catch { /* Даже malformed stdout сохраняется при отказе child. */ } + if (result.status !== 0 || report?.verdict !== 'COMPLETE') throw Object.assign(new Error(`server profile retention: ${result.stderr || result.error?.message || result.status}`), + { raw: { report, stdout: result.stdout, stderr: result.stderr, status: result.status, signal: result.signal } }); + return report; +} + +export async function runServerProfile({ baseline, candidate, browser: browserName, out }, dependencies = {}) { + const journal = createServerJournal(out); + const artifact = { schema: 1, protocol: SERVER_PROFILE, registration: null, registrationDigest: null, + verdict: 'UNPROVEN', failures: [], warmup: [], gc: [], stages: [], + jitObservation: { status: 'UNPROVEN', reason: 'GC events наблюдаются; точная JIT attribution требует отдельного intrusive trace и не подменяется гипотезой' } }; + let browser, origin, observer, engineClock, interruptionRecorded = false; + const checkpoint = () => dependencies.signal?.throwIfAborted(); + let prepared = {}, roots = {}, harness = {}, packages = {}; + const verify = () => { + engineClock?.assertUnchanged(); + if (artifact.registration) { + const current = captureServerLoad(), registered = artifact.registration.machine.identity; + if (current.affinity !== registered.affinity || current.cpuMax !== registered.cgroupCpuMax) { + throw Object.assign(new Error('server profile: machine affinity/quota изменились после регистрации'), { raw: { current, registered } }); + } + } + for (const [id, provenance] of Object.entries(prepared)) { + assertCheckoutUnchanged(roots[id], provenance); + assertInstalledPackageTreesUnchanged(roots[id], provenance.environment.rootPackages); + assertInstalledPackageTreesUnchanged(BENCH, provenance.environment.packages); + } + assertFileHashesUnchanged(harness); + for (const consumer of [...Object.values(packages), ...Object.values(artifact.registration?.transitivePackages ?? {})]) { + if (sha256File(consumer.tarball) !== consumer.tarballSha256 || hashFileTree(consumer.directory).sha256 !== consumer.treeSha256) throw new Error('server profile: изменились consumer bytes'); + } + if (artifact.registration?.browserTree && hashFileTree(artifact.registration.browserTree.directory).sha256 !== artifact.registration.browserTree.sha256) throw new Error('server profile: изменились browser bytes'); + }; + try { + checkpoint(); + if (!SERVER_PROFILE.browsers.includes(browserName)) throw new Error('server profile: неизвестный browser'); + if (browserName !== SERVER_PROFILE.clockError.browser) throw new Error('server profile: clock model этого browser пока UNPROVEN'); + roots = { baseline: realpathSync(baseline), candidate: realpathSync(candidate) }; + if (roots.baseline === roots.candidate) throw new Error('server profile: baseline/candidate требуют разных checkout'); + engineClock = prepareServerThreadCpuClock({ directory: out }); + artifact.engineClockPreparation = engineClock.metadata; + const machine = captureServerMachine(); + const esbuild = requireBench('esbuild'); const playwright = requireBench('playwright'); + const browserType = playwright[browserName]; + const executable = browserType.executablePath(); + const browserExecutableSha256 = sha256File(executable); + const browserTree = { directory: path.dirname(executable), ...hashFileTree(path.dirname(executable)) }; + harness = Object.fromEntries([...HARNESS_FILES, ...ENTRIES.map((id) => `bench/compare/entries/${id === 'waapi-ctl' ? 'waapi-control' : id}.entry.mjs`)] + .map((file) => [file, { path: path.join(ROOT, file), sha256: sha256File(path.join(ROOT, file)) }])); + for (const id of ['baseline', 'candidate']) { + prepared[id] = prepareBenchmarkCheckout({ root: roots[id], benchDirectory: BENCH, build: buildToStderr, + requiredDist: ['dist/animate/index.js', 'dist/index.js'], requiredPackages: ['esbuild', 'playwright', 'motion', 'gsap', 'animejs'], + requiredRootPackages: ['tsup', 'typescript', 'esbuild'], requiredInputs: Object.entries(harness).map(([key, info]) => [key, info.path]) }); + } + if (prepared.baseline.revision !== SERVER_PROFILE.baselineRevision) throw new Error('server profile: baseline отличается от регистрации'); + const consumers = {}; + for (const id of ['baseline', 'candidate', 'comparators']) { + consumers[id] = path.join(out, 'consumers', id); mkdirSync(path.join(consumers[id], 'node_modules'), { recursive: true }); + } + for (const id of ['baseline', 'candidate']) packages[id] = packConsumer(roots[id], path.join(out, 'packages', id), path.join(consumers[id], 'node_modules')); + const closure = new Map(); + for (const [id, name] of Object.entries(PACKAGES)) packages[id] = packageClosure(name, path.join(out, 'packages', 'vendors'), path.join(consumers.comparators, 'node_modules'), closure); + const adapters = {}; + for (const id of ['baseline', 'candidate', ...SERVER_PROFILE.comparators]) adapters[id] = buildAdapter(id, consumers[id] ?? consumers.comparators, esbuild, out); + Object.entries(adapters).forEach(([id, value]) => { harness[`adapter:${id}`] = value; }); + origin = await startBenchmarkOrigin(); checkpoint(); + browser = await browserType.launch({ headless: SERVER_PROFILE.headless, executablePath: executable }); checkpoint(); + artifact.registration = { protocolDigest: serverProfileDigest(SERVER_PROFILE), candidateSamplesObserved: false, + candidateSamplesObservedScope: SERVER_PROFILE.candidateSamplesObservedScope, + clockModelDigest: serverProfileDigest(SERVER_PROFILE.clockError), + registeredAt: new Date().toISOString(), browser: browserName, browserVersion: browser.version(), browserExecutableSha256, browserTree, + machine, engineClock: engineClock.metadata, provenance: prepared, packages, transitivePackages: Object.fromEntries(closure), harness, + allocationScope: 'observational heap + GC; retained отдельным процессом после timing' }; + verifyServerClockRegistration(artifact.registration); + artifact.registrationDigest = serverProfileDigest(artifact.registration); + journal('registration-before-any-sample', { registration: artifact.registration, digest: artifact.registrationDigest }); + checkpoint(); + verify(); + artifact.rawControls = { baseline: await measureBrowserRawControls(browser, origin, adapters.baseline, out, 'baseline') }; + journal('raw-controls-baseline', artifact.rawControls.baseline); + checkpoint(); + const implementations = {}; + const loadImplementation = async (id) => { + const metadata = JSON.parse(readFileSync(path.join(packages[id].directory, 'package.json'), 'utf8')); + const entry = metadata.exports['./animate'].import.default; + implementations[id] = (await import(pathToFileURL(path.join(packages[id].directory, entry)).href)).animate; + const main = metadata.exports['.'].import.default; + implementations[`${id}:stock-c`] = (await import(pathToFileURL(path.join(packages[id].directory, main)).href)).MotionValue; + }; + await loadImplementation('baseline'); + observer = new PerformanceObserver((list) => { for (const entry of list.getEntries()) artifact.gc.push({ startTime: entry.startTime, duration: entry.duration, detail: entry.detail }); }); + observer.observe({ entryTypes: ['gc'] }); + const engineMeasure = dependencies.engineMeasure ?? measureServerEngine; + const browserMeasure = dependencies.browserMeasure ?? measureServerBrowser; + const runStage = async (name, runs) => { + checkpoint(); + const stage = { name, rows: [], blocks: [] }; artifact[name] = stage; artifact.stages.push(name); + let resourceBefore; + for (let run = 0; run < runs; run++) { + if (run % 2 === 0) resourceBefore = captureServerLoad(); + for (const [kind, scenes] of [['engine', SERVER_PROFILE.engineScenes], ['browser', SERVER_PROFILE.browserScenes]]) { + const row = { kind, scene: scenes[0]?.id, run, order: serverOrders(runs)[run], samples: {} }; + for (const scene of scenes) { + const current = { ...row, scene: scene.id, samples: {} }; + stage.rows.push(current); + for (const id of current.order) { + checkpoint(); + const build = name === 'ab' && id === 'right' ? 'candidate' : 'baseline'; + const multiplier = name === 'positive' && id === 'right' ? SERVER_PROFILE.positiveWorkMultiplier : 1; + try { + const sample = kind === 'engine' ? await engineMeasure(implementations[scene.workload === 'stock-c' ? `${build}:stock-c` : build], scene, multiplier) + : await browserMeasure(browser, origin, adapters[build], scene, multiplier); + if (kind === 'engine') compactSampleCpuEvidence(sample); + current.samples[id] = sample; + journal('sample', { stage: name, kind, scene: scene.id, run, participant: id, build, value: current.samples[id] }); + } catch (error) { + journal('failed-sample', { stage: name, kind, scene: scene.id, run, participant: id, build, error: errorRecord(error), + partial: error.raw ?? null, timerEvidence: error.timerEvidence ?? null }); + throw error; + } + checkpoint(); + } + } + } + if (run % 2 === 1) { + const after = captureServerLoad(); + const block = { block: Math.floor(run / 2), before: resourceBefore, after, + delta: Object.fromEntries(['usage_usec', 'user_usec', 'system_usec', 'nr_periods', 'nr_throttled', 'throttled_usec'].map((key) => [key, after.cpuStat[key] - resourceBefore.cpuStat[key]])) }; + stage.blocks.push(block); journal('resources-block', { stage: name, ...block }); + } + process.stderr.write(`server profile ${name}: ${run + 1}/${runs}\n`); + } + verify(); return stage; + }; + if (!await runServerProfileCalibration(artifact, runStage, journal)) return artifact; + checkpoint(); + await loadImplementation('candidate'); + checkpoint(); + artifact.rawControls.candidate = await measureBrowserRawControls(browser, origin, adapters.candidate, out, 'candidate'); + journal('raw-controls-candidate-after-calibration', artifact.rawControls.candidate); + checkpoint(); + artifact.ab = await runStage('ab', artifact.samplePlan.runs); + artifact.comparison = serverFamilyIntervals(serverCellPairs(artifact.ab, artifact.samplePlan.runs, 'ab', artifact.registration.engineClock)); + const abResourceReasons = serverResourceReasons([artifact.ab], artifact.registration.machine.identity); + if (abResourceReasons.length) throw new Error(`server profile: условия A/B нарушены: ${abResourceReasons.join('; ')}`); + artifact.comparators = []; + for (const scene of SERVER_PROFILE.browserScenes) for (const id of SERVER_PROFILE.comparators) { + checkpoint(); + if (scene.staggerGapMs > 0 && ['motion-mini', 'anime-waapi'].includes(id)) { + artifact.comparators.push({ scene: scene.id, id, status: 'UNPROVEN', reason: 'existing owner entry не реализует общий stagger API' }); continue; + } + const comparison = { scene: scene.id, id, rows: [], claim: 'raw API cost; descriptive only, без рейтинга и M-05 superiority' }; + artifact.comparators.push(comparison); + for (let run = 0; run < artifact.samplePlan.runs; run++) { + checkpoint(); + try { + const sample = await browserMeasure(browser, origin, adapters[id], scene); + comparison.rows.push(sample); journal('comparator-sample', { scene: scene.id, id, run, sample }); + } catch (error) { + journal('failed-comparator-sample', { stage: 'ab', scene: scene.id, id, run, error: errorRecord(error) }); throw error; + } + checkpoint(); + } + } + artifact.retention = {}; + for (const id of ['baseline', 'candidate']) { + checkpoint(); + artifact.retention[id] = makeRetention(packages[id].directory); + journal('retention-sample', { id, value: artifact.retention[id] }); + checkpoint(); + } + journal('retention-separate-forced-GC', artifact.retention); + artifact.verdict = artifact.comparison.every((cell) => cell.p95.bounded && cell.p95.high <= SERVER_PROFILE.nonInferiorityUpper) ? 'PASS' : 'NO-GO'; + return artifact; + } catch (error) { + interruptionRecorded = dependencies.signal?.aborted && error === dependencies.signal.reason; + artifact.failures.push({ stage: artifact.stages.at(-1) ?? 'preparation', at: new Date().toISOString(), error: errorRecord(error) }); + journal('failure', artifact.failures.at(-1)); return artifact; + } finally { + if (observer) { + for (const entry of observer.takeRecords()) artifact.gc.push({ startTime: entry.startTime, duration: entry.duration, detail: entry.detail }); + observer.disconnect(); + } + try { verify(); } catch (error) { + artifact.verdict = 'UNPROVEN'; const failure = { stage: 'final-provenance', error: errorRecord(error) }; + artifact.failures.push(failure); journal('failure', failure); + } + for (const [resource, close] of [['browser', () => browser?.close()], ['origin', () => origin?.close()]]) { + try { await withBrowserTimeout(close(), `${resource} cleanup`); } catch (error) { + artifact.verdict = 'UNPROVEN'; const failure = { stage: 'cleanup', resource, error: errorRecord(error) }; + artifact.failures.push(failure); journal('failure', failure); + } + } + if (dependencies.signal?.aborted && !interruptionRecorded) { + artifact.verdict = 'UNPROVEN'; + const failure = { stage: 'operator-interruption', error: errorRecord(dependencies.signal.reason) }; + artifact.failures.push(failure); journal('failure', failure); + } + artifact.finishedAt = new Date().toISOString(); + const { sha256: digest } = writeServerArtifact(path.join(out, 'server-profile.json'), artifact); + writeFileSync(path.join(out, 'server-profile.sha256'), `${digest} server-profile.json\n`, { flag: 'wx' }); + journal('finished', { verdict: artifact.verdict, digest }); + } +} + +export function parseServerProfileArgs(args) { + if (args.length !== 8 || args[0] !== '--baseline' || args[2] !== '--candidate' || args[4] !== '--browser' || args[6] !== '--out' || + args.filter((_, i) => i % 2 === 1).some((x) => !x || x.startsWith('--'))) { + throw new Error('server profile: нужны ровно --baseline --candidate --browser chromium|firefox|webkit --out <новый каталог>'); + } + return { baseline: args[1], candidate: args[3], browser: args[5], out: path.resolve(args[7]) }; +} + +if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) { + try { + const artifact = await withServerProfileSignals((signal) => runServerProfile(parseServerProfileArgs(process.argv.slice(2)), { signal })); + process.stdout.write(`${JSON.stringify({ verdict: artifact.verdict, registrationDigest: artifact.registrationDigest, failures: artifact.failures, + artifact: path.join(parseServerProfileArgs(process.argv.slice(2)).out, 'server-profile.json') })}\n`); + process.exitCode = artifact.verdict === 'PASS' ? 0 : 1; + } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; } +} diff --git a/bench/profile/server-thread-cpu-clock.c b/bench/profile/server-thread-cpu-clock.c new file mode 100644 index 000000000..8a6aa76e6 --- /dev/null +++ b/bench/profile/server-thread-cpu-clock.c @@ -0,0 +1,78 @@ +#define _GNU_SOURCE +#include "node_api.h" +#include +#include +#include +#include +#include +#include +#include + +/* Частный getter стенда: счётчик scheduler текущего Linux-потока. + * CLOCK_THREAD_CPUTIME_ID обновляет pending runtime, в отличие от stale + * RUSAGE_THREAD на CPU без active vtime. Номинальный clock_getres не + * является сертификатом физической точности. Getter overhead не вычитается. */ +static napi_value fail(napi_env env, const char *code, const char *message) { + napi_throw_error(env, code, message); + return NULL; +} + +static int field(napi_env env, napi_value object, const char *name, napi_value value) { + return napi_set_named_property(env, object, name, value) == napi_ok; +} + +static int integer_field(napi_env env, napi_value object, const char *name, int64_t number) { + napi_value value; + return napi_create_int64(env, number, &value) == napi_ok && field(env, object, name, value); +} + +static int string_field(napi_env env, napi_value object, const char *name, const char *text) { + napi_value value; + return napi_create_string_utf8(env, text, NAPI_AUTO_LENGTH, &value) == napi_ok && field(env, object, name, value); +} + +static napi_value read_thread_cpu(napi_env env, napi_callback_info info) { + (void)info; + const pid_t pid = getpid(); + const long tid = syscall(SYS_gettid); + struct timespec value; + if (pid <= 0 || tid <= 0) return fail(env, "CLOCK_IDENTITY", "Недопустимый PID/TID CPU getter"); + if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &value) != 0) return fail(env, "CLOCK_READ", strerror(errno)); + if (value.tv_sec < 0 || value.tv_nsec < 0 || value.tv_nsec >= 1000000000L) return fail(env, "CLOCK_VALUE", "Недопустимый timespec CPU getter"); + char seconds[32]; + if (snprintf(seconds, sizeof(seconds), "%lld", (long long)value.tv_sec) <= 0) return fail(env, "CLOCK_VALUE", "Не удалось записать секунды CPU getter"); + napi_value result; + if (napi_create_object(env, &result) != napi_ok || + !string_field(env, result, "seconds", seconds) || + !integer_field(env, result, "nanoseconds", value.tv_nsec) || + !integer_field(env, result, "pid", pid) || !integer_field(env, result, "tid", tid)) { + return fail(env, "CLOCK_NAPI", "Не удалось сохранить acquired CPU endpoint"); + } + return result; +} + +static napi_value clock_info(napi_env env, napi_callback_info info) { + (void)info; + struct timespec resolution; + if (clock_getres(CLOCK_THREAD_CPUTIME_ID, &resolution) != 0) return fail(env, "CLOCK_RESOLUTION", strerror(errno)); + if (resolution.tv_sec < 0 || resolution.tv_nsec < 0 || resolution.tv_nsec >= 1000000000L || + (resolution.tv_sec == 0 && resolution.tv_nsec == 0)) return fail(env, "CLOCK_RESOLUTION", "Недопустимое номинальное clock_getres"); + char nominal[40]; + const uint64_t value = (uint64_t)resolution.tv_sec * UINT64_C(1000000000) + (uint64_t)resolution.tv_nsec; + if (snprintf(nominal, sizeof(nominal), "%llu", (unsigned long long)value) <= 0) return fail(env, "CLOCK_RESOLUTION", "Не удалось записать номинальное clock_getres"); + napi_value result; + if (napi_create_object(env, &result) != napi_ok || + !integer_field(env, result, "pid", getpid()) || !integer_field(env, result, "tid", syscall(SYS_gettid)) || + !string_field(env, result, "nominalResolutionNs", nominal)) return fail(env, "CLOCK_NAPI", "Не удалось сохранить CPU clock identity"); + return result; +} + +NAPI_MODULE_INIT() { + napi_value read, info; + if (napi_create_function(env, "read", NAPI_AUTO_LENGTH, read_thread_cpu, NULL, &read) != napi_ok || + napi_create_function(env, "info", NAPI_AUTO_LENGTH, clock_info, NULL, &info) != napi_ok || + !field(env, exports, "read", read) || !field(env, exports, "info", info)) { + return fail(env, "CLOCK_NAPI", "Не удалось инициализировать частный CPU getter"); + } + return exports; +} diff --git a/bench/profile/server-thread-cpu-clock.mjs b/bench/profile/server-thread-cpu-clock.mjs new file mode 100644 index 000000000..7057fd7fb --- /dev/null +++ b/bench/profile/server-thread-cpu-clock.mjs @@ -0,0 +1,121 @@ +/** Частный CPU clock владельца server-profile; пакет библиотеки его не включает. */ +import { execFileSync } from 'node:child_process'; +import { createRequire } from 'node:module'; +import { accessSync, constants, existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { isMainThread } from 'node:worker_threads'; +import { isDeepStrictEqual } from 'node:util'; +import { sha256File } from '../compare/provenance.mjs'; +import { SERVER_PROFILE, serverProfileDigest } from './server-profile-registration.mjs'; + +const ROOT = fileURLToPath(new URL('../..', import.meta.url)); +const CLOCK = 'CLOCK_THREAD_CPUTIME_ID'; +const SOURCE_FILES = [ + 'bench/profile/server-thread-cpu-clock.c', + 'bench/profile/native-clock/include/js_native_api.h', + 'bench/profile/native-clock/include/js_native_api_types.h', + 'bench/profile/native-clock/include/node_api.h', + 'bench/profile/native-clock/include/node_api_types.h', +]; +const FLAGS = ['-std=c11', '-O2', '-Wall', '-Wextra', '-Werror', '-shared', '-fPIC', '-fvisibility=hidden', '-DNAPI_VERSION=8']; +let prepared; + +function refuse(message, raw) { + return Object.assign(new Error(`server CPU clock: ${message}`), { raw }); +} + +function sourceHashes() { + return Object.fromEntries(SOURCE_FILES.map((name) => [name, sha256File(path.join(ROOT, name))]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)); +} + +function compilerPath() { + for (const directory of (process.env.PATH ?? '').split(path.delimiter)) { + if (!directory) continue; + const file = path.join(directory, 'cc'); + try { accessSync(file, constants.X_OK); return realpathSync(file); } catch { /* Следующий конкретный PATH entry. */ } + } + throw refuse('нет C compiler для частного getter', { path: process.env.PATH }); +} + +function libcPath() { + const lines = readFileSync('/proc/self/maps', 'utf8').split('\n'); + const names = new Set(lines.flatMap((line) => { + const match = /\s(\/[^\n]*\/libc\.so\.6)$/.exec(line); + return match ? [realpathSync(match[1])] : []; + })); + if (names.size !== 1) throw refuse('не удалось связать одну фактическую libc', { libraries: [...names] }); + return [...names][0]; +} + +/** Подготавливает бинарный getter до регистрации и любых SUT samples. */ +export function prepareServerThreadCpuClock({ directory }) { + if (prepared) throw refuse('getter уже подготовлен; повторная registration в том же процессе запрещена'); + if (process.platform !== 'linux' || process.arch !== 'x64' || !isMainThread || process.version !== SERVER_PROFILE.clockError.nodeVersion) { + throw refuse('нужны зарегистрированные Linux x64/main-thread/Node', { platform: process.platform, arch: process.arch, isMainThread, node: process.version }); + } + const nativeSources = sourceHashes(); + if (!isDeepStrictEqual(nativeSources, SERVER_PROFILE.clockError.nativeSourceFiles)) { + throw refuse('native source/header bytes не совпадают с clock model', { observed: nativeSources, registered: SERVER_PROFILE.clockError.nativeSourceFiles }); + } + const nativeDirectory = path.join(directory, 'native-clock'); + mkdirSync(nativeDirectory, { recursive: true }); + const binary = path.join(nativeDirectory, 'thread-cpu-clock.node'); + if (existsSync(binary)) throw refuse('native binary уже существует; stale/replay запрещён', { binary }); + const compiler = compilerPath(); + const compilerVersion = execFileSync(compiler, ['--version'], { encoding: 'utf8', timeout: 10_000 }).trim(); + const binarySha256 = sha256File(compiler); + const flags = [...FLAGS, '-I', path.join(ROOT, 'bench/profile/native-clock/include'), '-o', binary, path.join(ROOT, SOURCE_FILES[0])]; + try { execFileSync(compiler, flags, { encoding: 'utf8', timeout: 30_000 }); } catch (error) { + throw refuse('сборка native getter отказала', { compiler, flags, status: error.status, signal: error.signal, + stdout: error.stdout?.toString(), stderr: error.stderr?.toString() }); + } + const native = createRequire(import.meta.url)(binary); + if (typeof native.read !== 'function' || typeof native.info !== 'function') throw refuse('native getter не содержит зарегистрированный ABI'); + const info = native.info(); + if (!Number.isSafeInteger(info.pid) || info.pid !== process.pid || info.tid !== info.pid || !/^[1-9]\d*$/.test(info.nominalResolutionNs)) { + throw refuse('native getter не связан с текущим main thread', info); + } + const libc = libcPath(); + const metadata = { schema: 1, clock: CLOCK, pid: info.pid, tid: info.tid, napiVersion: 8, + node: { version: process.version, executableSha256: sha256File(process.execPath) }, + nativeBinary: { path: binary, bytes: readFileSync(binary).length, sha256: sha256File(binary) }, + nativeSources, nativeSourceDigest: serverProfileDigest(nativeSources), + compiler: { path: compiler, version: compilerVersion, binarySha256, flags }, + libc: { path: libc, sha256: sha256File(libc) }, nominalResolutionNs: info.nominalResolutionNs, + nominalResolutionIsNotErrorCertificate: true }; + const binaryRead = native.read; + let previous; + const read = () => { + const acquired = binaryRead(); + const raw = { clock: CLOCK, pid: acquired.pid, tid: acquired.tid, seconds: acquired.seconds, + nanoseconds: acquired.nanoseconds, valueNs: null }; + if (!isMainThread || raw.pid !== process.pid || raw.pid !== metadata.pid || raw.tid !== metadata.tid || + typeof raw.seconds !== 'string' || !/^(0|[1-9]\d*)$/.test(raw.seconds) || + !Number.isSafeInteger(raw.nanoseconds) || raw.nanoseconds < 0 || raw.nanoseconds >= 1_000_000_000) { + throw refuse('недопустимый actual native endpoint/worker/fork', raw); + } + const value = BigInt(raw.seconds) * 1_000_000_000n + BigInt(raw.nanoseconds); + raw.valueNs = String(value); + if (previous !== undefined && value < previous) throw refuse('native CPU counter пошёл назад', { acquired: raw, previous: String(previous) }); + previous = value; + return raw; + }; + const assertUnchanged = () => { + const currentSources = sourceHashes(); + if (!isMainThread || process.pid !== metadata.pid || + serverProfileDigest(currentSources) !== metadata.nativeSourceDigest || + sha256File(binary) !== metadata.nativeBinary.sha256 || sha256File(compiler) !== metadata.compiler.binarySha256 || + sha256File(libc) !== metadata.libc.sha256 || sha256File(process.execPath) !== metadata.node.executableSha256) { + throw refuse('native getter/source/compiler/libc/runtime identity изменились', { metadata }); + } + }; + prepared = { metadata, read, assertUnchanged }; + return { metadata, assertUnchanged }; +} + +/** Pure import не требует compiler/native binary; actual read без подготовки запрещён. */ +export function readServerThreadCpuEndpoint() { + if (!prepared) throw refuse('actual getter не подготовлен до регистрации'); + return prepared.read(); +} diff --git a/bench/profile/validate-profile-01.mjs b/bench/profile/validate-profile-01.mjs new file mode 100644 index 000000000..998f61097 --- /dev/null +++ b/bench/profile/validate-profile-01.mjs @@ -0,0 +1,119 @@ +// PROFILE-01 validate: независимая перепроверка raw-артефакта пробы. +// Повторяет размерные измерения; не удостоверяет время исторического запуска +// и не выдаёт допуска производительности или человеческой оценки. +// Использование: node bench/profile/validate-profile-01.mjs --raw + +import { readFileSync } from 'node:fs'; +import { resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { isDeepStrictEqual } from 'node:util'; +import { + PROFILE_01, + preregistrationDigest, + verifyPreregistration, + unmeasuredCells, +} from './profile-01-preregistration.mjs'; +import { PREREG_OWN_PATHS, makeGit } from './profile-git-proof.mjs'; +import { measureOldVector, validateReplayedVector } from './profile-measurement.mjs'; + +function fail(message) { + throw new Error(`PROFILE-01 validate (fail-closed): ${message}`); +} + +function arg(name) { + const index = process.argv.indexOf(name); + if (index === -1) return undefined; + for (let occurrence = index; occurrence !== -1; occurrence = process.argv.indexOf(name, occurrence + 1)) { + const value = process.argv[occurrence + 1]; + if (value === undefined || value.length === 0 || value.startsWith('-')) fail(`флаг ${name} требует значение`); + } + return process.argv[index + 1]; +} + +async function main() { + const rawPath = resolve(arg('--raw') ?? fail('требуется --raw ')); + const artifact = JSON.parse(readFileSync(rawPath, 'utf8')); + if (artifact.node !== 'PROFILE-01' || artifact.revision !== 'r11' || + !['old-vector', 'aa', 'ab'].includes(artifact.mode)) fail('неверный вид артефакта'); + if (!isDeepStrictEqual(artifact.cellsUnproven, unmeasuredCells(artifact.cells))) { + fail('неизмеренные клетки потеряны или подменены'); + } + const expectedMeasured = artifact.admission === 'OLD-VECTOR-ONLY' ? ['desktop-size-vector'] : []; + if (!isDeepStrictEqual(artifact.cellsMeasured, expectedMeasured)) fail('неверный набор измеренных клеток'); + + // 1. Замороженный контракт не менялся. + verifyPreregistration(PROFILE_01); + const frozen = preregistrationDigest(PROFILE_01); + if (artifact.preregistrationDigest !== frozen) { + fail(`preregistration не совпадает: artifact ${artifact.preregistrationDigest}, frozen ${frozen}`); + } + if (artifact.candidateSamplesObservedAtRegistration !== false) { + fail('preregistration обязана предшествовать samples'); + } + + // Происхождение исходников пересчитывается независимо через Git. + // Валидатор не доверяет полям raw JSON: HEAD, ancestry, diff и blob + // пересчитываются из checkout, в котором запущен валидатор. + // Записанный exitCode не удостоверяет измерение. После проверки Git повторяем + // сборку и существующий size-gate; сравниваем данные, а не формат console.log. + if (artifact.mode === 'old-vector') { + const base = PROFILE_01.productBase.sourceSha; + const proof = artifact.baseProof ?? {}; + if (proof.productBase !== base || proof.head !== artifact.head) fail('baseProof не покрывает artifact head'); + if (!Array.isArray(proof.diffPaths)) fail('baseProof.diffPaths отсутствует'); + const repoRoot = fileURLToPath(new URL('../../', import.meta.url)); + const git = makeGit(fail); + const currentHead = git.head(repoRoot); + if (currentHead !== artifact.head) { + fail(`валидатор запущен не на artifact head: checkout ${currentHead}, artifact ${artifact.head}`); + } + if (!git.ancestor(repoRoot, base)) fail(`artifact head не вырос из PRODUCT_BASE ${base}`); + const recomputed = currentHead === base ? [] : git.diffNames(repoRoot, base, currentHead); + const asSet = (paths) => JSON.stringify([...paths].sort()); + if (asSet(recomputed) !== asSet(proof.diffPaths)) { + fail(`baseProof.diffPaths не совпадает с git: artifact [${proof.diffPaths.join(', ')}], git [${recomputed.join(', ')}]`); + } + const foreign = recomputed.filter((path) => !PREREG_OWN_PATHS.includes(path)); + if (foreign.length > 0) fail(`дерево отличается от PRODUCT_BASE вне prereg-пакета: ${foreign.join(', ')}`); + const committed = git.blob(repoRoot, artifact.head, 'scripts/size-gate.mjs'); + if (committed !== PROFILE_01.productBase.sizeGateBlob || committed !== artifact.sizeGateBlob) { + fail(`size-gate provenance drifted: artifact ${artifact.sizeGateBlob}, git ${committed}`); + } + if (artifact.admission === 'OLD-VECTOR-ONLY') { + validateReplayedVector(artifact.costVector, await measureOldVector(repoRoot)); + } + } + + // 3. A/B без калибровки не существует. + if (artifact.mode !== 'old-vector' && artifact.admission !== 'NOT-GRANTED') { + fail('некалиброванный A/B не может нести admission'); + } + if (artifact.admission !== 'NOT-GRANTED' && artifact.admission !== 'OLD-VECTOR-ONLY') { + fail(`неизвестный admission ${artifact.admission}`); + } + // Отклонённый артефакт обязан нести причину: NOT-GRANTED без rejection + // означает потерянный failure (OBSERVATION_POLICY нарушена). + if (artifact.admission === 'NOT-GRANTED') { + if (typeof artifact.rejection !== 'string' || artifact.rejection.length === 0) { + fail('NOT-GRANTED артефакт обязан содержать непустой rejection'); + } + } else if (artifact.rejection !== null && artifact.rejection !== undefined) { + fail('успешный артефакт не должен нести rejection'); + } + + // 4. Affected cells обязаны быть перечислены, а не молча пропущены. + if (!Array.isArray(artifact.cellsUnproven)) fail('cellsUnproven обязан быть списком'); + if (!Array.isArray(artifact.cellsMeasured)) fail('cellsMeasured обязан быть списком'); + + // 5. Времена и seed фиксированы. + if (!Number.isFinite(Date.parse(artifact.startedAtUtc ?? ''))) fail('startedAtUtc отсутствует'); + if (!Number.isFinite(Date.parse(artifact.finishedAtUtc ?? ''))) fail('finishedAtUtc отсутствует'); + if (Date.parse(artifact.finishedAtUtc) < Date.parse(artifact.startedAtUtc)) fail('время окончания предшествует началу'); + if (artifact.seed !== 20260929) fail('seed drifted'); + + // eslint-disable-next-line no-console + console.log(JSON.stringify({ valid: true, mode: artifact.mode, admission: artifact.admission, + verification: artifact.admission === 'OLD-VECTOR-ONLY' ? 'independent-size-remeasurement' : 'recorded-refusal-only' })); +} + +await main(); diff --git a/browser/compositor-follow.spec.ts b/browser/compositor-follow.spec.ts new file mode 100644 index 000000000..42743adc8 --- /dev/null +++ b/browser/compositor-follow.spec.ts @@ -0,0 +1,169 @@ +import { expect, test } from './fixtures/harness'; +import { createHash } from 'node:crypto'; +import { readFileSync } from 'node:fs'; + +type PackageReceipt = { + tarball: { sha256: string }; + outputs: { file: string; sha256: string }[]; +}; + +type ProbeWindow = Window & { + followProbe: { animations: Animation[]; frames: number; cleanup: () => void }; +}; + +test.beforeEach(async ({ page }) => { + const manifest = await page.request.get('/browser/.artifacts/compositor-follow-package.json'); + expect(manifest.ok()).toBe(true); + const receipt: PackageReceipt = await manifest.json(); + const tarball = process.env.LAB_MOTION_TARBALL ?? new URL('./.artifacts/compositor-follow-package.tgz', import.meta.url); + expect(createHash('sha256').update(readFileSync(tarball)).digest('hex')).toBe(receipt.tarball.sha256); + const bundle = await page.request.get('/browser/.artifacts/compositor-follow-recipes.js'); + expect(bundle.ok()).toBe(true); + expect(createHash('sha256').update(await bundle.body()).digest('hex')) + .toBe(receipt.outputs.find((output) => output.file === 'compositor-follow-recipes.js')?.sha256); + test.info().annotations.push({ type: 'package-sha256', description: receipt.tarball.sha256 }); + await test.info().attach('shipped-recipe', { body: JSON.stringify(receipt), contentType: 'application/json' }); + await page.evaluate(() => { + const probe = { animations: [] as Animation[], frames: 0, cleanup: () => {} }; + (window as unknown as ProbeWindow).followProbe = probe; + const animate = Element.prototype.animate; + Element.prototype.animate = function (...args) { + const animation = animate.apply(this, args); + animation.pause(); + animation.currentTime = 0; + probe.animations.push(animation); + return animation; + }; + const raf = window.requestAnimationFrame; + window.requestAnimationFrame = (callback) => { probe.frames++; return raf.call(window, callback); }; + }); +}); + +test('рецепт панели: повторный pickup, native settle, focus и cleanup', async ({ page }) => { + await page.setContent(`
+
Потяните панель
+
`); + await page.evaluate(async () => { + // @ts-expect-error Модуль собирается из буквального кода docs/recipes.md. + const { mountSnapPanel } = await import('/browser/.artifacts/compositor-follow-recipes.js'); + (window as unknown as ProbeWindow).followProbe.cleanup = mountSnapPanel(document.getElementById('panel-root')); + }); + await page.locator('[data-open]').click(); + await expect(page.locator('[data-close]')).toBeFocused(); + await page.evaluate(() => { + const animation = (window as unknown as ProbeWindow).followProbe.animations.at(-1)!; + animation.currentTime = Number(animation.effect!.getComputedTiming().duration); + }); + const handle = await page.locator('[data-handle]').boundingBox(); + await page.mouse.move(handle!.x + 30, handle!.y + 20); + await page.mouse.down(); + await page.mouse.move(handle!.x + 30, handle!.y + 130, { steps: 5 }); + await page.mouse.up(); + await expect(page.locator('#panel-root')).toHaveAttribute('data-snap', '160'); + expect(await page.locator('[data-panel]').evaluate((el) => el.getAnimations().length)).toBe(1); + + await page.evaluate(() => { (window as unknown as ProbeWindow).followProbe.animations.at(-1)!.currentTime = 40; }); + const before = await page.locator('[data-panel]').evaluate((el) => new DOMMatrix(getComputedStyle(el).transform).m42); + const second = await page.locator('[data-handle]').boundingBox(); + await page.mouse.move(second!.x + 30, second!.y + 20); + await page.mouse.down(); + const after = await page.locator('[data-panel]').evaluate((el) => new DOMMatrix(getComputedStyle(el).transform).m42); + expect(Math.abs(after - before)).toBeLessThan(0.01); + expect(await page.locator('[data-panel]').evaluate((el) => el.getAnimations().length)).toBe(0); + await page.mouse.move(second!.x + 30, second!.y - 25, { steps: 3 }); + await page.mouse.up(); + expect(await page.locator('[data-panel]').evaluate((el) => el.getAnimations().length)).toBe(1); + await page.locator('[data-close]').click(); + await expect(page.locator('[data-open]')).toBeFocused(); + await expect(page.locator('[data-open]')).toHaveAttribute('aria-expanded', 'false'); + const result = await page.evaluate(() => { + const probe = (window as unknown as ProbeWindow).followProbe; + probe.cleanup(); + return { count: probe.animations.length, frames: probe.frames, idle: probe.animations.every((a) => a.playState === 'idle') }; + }); + expect(result.frames).toBe(0); + expect(result.idle).toBe(true); + await page.locator('[data-open]').click(); + expect(await page.evaluate(() => (window as unknown as ProbeWindow).followProbe.animations.length)).toBe(result.count); +}); + +test('рецепт карусели: локальная страница, повторный захват, кнопки и cleanup', async ({ page }) => { + await page.setContent(``); + await page.evaluate(async () => { + // @ts-expect-error Модуль собирается из буквального кода docs/recipes.md. + const { mountPagedCarousel } = await import('/browser/.artifacts/compositor-follow-recipes.js'); + (window as unknown as ProbeWindow).followProbe.cleanup = mountPagedCarousel(document.getElementById('carousel-root')); + }); + const viewport = await page.locator('[data-viewport]').boundingBox(); + const x = viewport!.x + 190; + const y = viewport!.y + 30; + await page.mouse.move(x, y); + await page.mouse.down(); + await page.mouse.move(x - 145, y, { steps: 5 }); + await page.mouse.up(); + await expect(page.locator('[data-page-status]')).toHaveText('Страница 2 из 3'); + expect(await page.locator('[data-track]').evaluate((el) => el.getAnimations().length)).toBe(1); + // Финальная поза отличается от исходной и не зависит от скорости указателя. + await page.evaluate(() => { + const animation = (window as unknown as ProbeWindow).followProbe.animations.at(-1)!; + animation.currentTime = Number(animation.effect!.getComputedTiming().duration); + }); + const before = await page.locator('[data-track]').evaluate((el) => new DOMMatrix(getComputedStyle(el).transform).m41); + expect(before).toBeCloseTo(-240, 2); + await page.mouse.move(x, y); + await page.mouse.down(); + const after = await page.locator('[data-track]').evaluate((el) => new DOMMatrix(getComputedStyle(el).transform).m41); + expect(Math.abs(after - before)).toBeLessThan(0.01); + await page.mouse.move(x - 40, y, { steps: 3 }); + const releasedFrom = await page.locator('[data-track]').evaluate((el) => new DOMMatrix(getComputedStyle(el).transform).m41); + expect(releasedFrom).toBeCloseTo(-280, 2); + await page.mouse.up(); + await expect(page.locator('[data-page-status]')).toHaveText('Страница 2 из 3'); + expect(await page.locator('[data-track]').evaluate((el) => el.getAnimations().length)).toBe(1); + await page.locator('[data-next]').focus(); + await page.keyboard.press('Enter'); + await expect(page.locator('[data-page-status]')).toHaveText('Страница 3 из 3'); + await expect(page.locator('[data-next]')).toBeDisabled(); + const result = await page.evaluate(() => { + const probe = (window as unknown as ProbeWindow).followProbe; + probe.cleanup(); + return { count: probe.animations.length, frames: probe.frames, idle: probe.animations.every((a) => a.playState === 'idle') }; + }); + expect(result.frames).toBe(0); + expect(result.idle).toBe(true); + await page.locator('[data-previous]').click(); + expect(await page.evaluate(() => (window as unknown as ProbeWindow).followProbe.animations.length)).toBe(result.count); +}); + + +test('рецепт панели: принятый pointer сохраняет mouse focus и клавиатуру', async ({ page }) => { + await page.setContent(`
+
Потяните панель
+
`); + await page.evaluate(async () => { + // @ts-expect-error Модуль собирается из буквального кода docs/recipes.md. + const { mountSnapPanel } = await import('/browser/.artifacts/compositor-follow-recipes.js'); + (window as unknown as ProbeWindow).followProbe.cleanup = mountSnapPanel(document.getElementById('panel-root')); + }); + await page.locator('[data-open]').click(); + await page.evaluate(() => { + const animation = (window as unknown as ProbeWindow).followProbe.animations.at(-1)!; + animation.currentTime = Number(animation.effect!.getComputedTiming().duration); + }); + await page.locator('[data-handle]').click(); + await expect(page.locator('[data-handle]')).toBeFocused(); + await page.keyboard.press('Tab'); + await expect(page.locator('[data-close]')).toBeFocused(); + await page.evaluate(() => (window as unknown as ProbeWindow).followProbe.cleanup()); +}); diff --git a/browser/compositor-recipes.spec.ts b/browser/compositor-recipes.spec.ts new file mode 100644 index 000000000..8d4ad9b06 --- /dev/null +++ b/browser/compositor-recipes.spec.ts @@ -0,0 +1,407 @@ +import type { Page } from '@playwright/test'; +import { expect, packedJourneyTest as test } from './fixtures/harness'; + +const recipeUrl = '/browser/.artifacts/scope-recipes.js'; +type Family = 'sheet' | 'pager'; + +async function mount(page: Page, family: Family, quiet = false) { + await page.evaluate(async ({ url, family, quiet }) => { + const recipes = await import(url); + const w = window as unknown as { + consumer: any; root: HTMLElement; handle: HTMLButtonElement; target: HTMLElement; + frame: (time: number) => void; pending: () => number; issued: number; changes: number; oldLive: any; pointer?: number; + }; + document.body.innerHTML = '
'; + document.querySelector('#previous-focus')!.focus(); + const root = document.querySelector('#consumer')!; + root.innerHTML = family === 'sheet' + ? '' + + '
' + + '' + : '' + + '
' + + '
' + + '
Вторая
Третья
' + + '
'; + let queue: Array<(time?: number) => void> = []; + w.issued = 0; w.changes = 0; + w.frame = time => { const batch = queue; queue = []; for (const callback of batch) callback(time); }; + w.pending = () => queue.length; + const options = { + motion: quiet ? 'none' : 'auto', onSelect: () => { w.changes++; }, + requestFrame: (callback: (time?: number) => void) => { queue.push(callback); return ++w.issued; }, + }; + w.consumer = family === 'sheet' + ? recipes.mountCompositorSheet(root, { ...options, snapPoints: [0, 120, 240] }) + : recipes.mountCompositorPager(root, options); + w.root = root; + root.addEventListener('pointerdown', event => { w.pointer = event.pointerId; }, { capture: true }); + w.handle = root.querySelector(family === 'sheet' ? '[data-sheet-handle]' : '[data-pager-handle]')!; + w.target = root.querySelector(family === 'sheet' ? '[data-sheet-panel]' : '[data-pager-track]')!; + }, { url: recipeUrl, family, quiet }); +} + +test('literal recipes используют manifest и байты фактического npm tarball', async ({ page }, testInfo) => { + const response = await page.request.get('/browser/.artifacts/scope-recipes.package.json'); + expect(response.ok()).toBe(true); + const receipt = await response.json(); + expect(receipt.schema).toBe('scope-recipes-package-v1'); + expect(receipt.package.name).toBe('@labpics/motion'); + expect(receipt.tarball.sha256).toMatch(/^[a-f0-9]{64}$/); + expect(receipt.tarball.integrity).toMatch(/^sha512-[A-Za-z0-9+/]+=*$/); + expect(receipt.recipesSha256).toMatch(/^[a-f0-9]{64}$/); + expect(receipt.bundleSha256).toMatch(/^[a-f0-9]{64}$/); + expect(receipt.manifest.fileCount).toBeGreaterThan(100); + expect(receipt.motionInputs).toContain('dist/compositor/index.js'); + expect(receipt.motionInputs).toContain('dist/animate/index.js'); + expect(receipt.motionInputs.every((path: string) => path.startsWith('dist/'))).toBe(true); + await testInfo.attach('actual-package-receipt', { body: JSON.stringify(receipt), contentType: 'application/json' }); +}); + +test('actual tarball: React SSR → hydration сохраняет DOM, StrictMode cleanup и поздний click', async ({ page }) => { + await page.emulateMedia({ reducedMotion: 'no-preference' }); + const ssr = await page.request.get('/browser/.artifacts/scope-react.ssr.html'); + expect(ssr.ok()).toBe(true); + const html = await ssr.text(); + const errors: string[] = []; + page.on('console', message => { if (message.type() === 'error') errors.push(message.text()); }); + await page.evaluate(async ({ url, html }) => { + const recipes = await import(url); + document.body.innerHTML = '
Сосед
'; + const host = document.querySelector('#hydration')!; host.innerHTML = html; + const w = window as any; w.serverNode = host.firstElementChild; w.starts = 0; + const original = Element.prototype.animate; + Element.prototype.animate = function (...args) { w.starts++; return original.apply(this, args); }; + w.hydrated = recipes.mountReact(host, true); + }, { url: recipeUrl, html }); + await expect.poll(() => page.locator('#hydration .motion-target').evaluate(el => el.getAnimations().length)).toBe(2); + const result = await page.evaluate(() => { + const w = window as any; + const target = document.querySelector('#hydration .motion-target')!; + const button = document.querySelector('#hydration button')!; + const same = document.querySelector('#hydration')!.firstElementChild === w.serverNode; + const outside = document.querySelector('#outside')!.getAnimations().length; + const starts = w.starts; + w.hydrated.destroy(); button.click(); + return { same, outside, starts, effects: target.getAnimations().length }; + }); + expect(result).toEqual({ same: true, outside: 0, starts: 4, effects: 0 }); + expect(errors).toEqual([]); +}); + +for (const family of ['sheet', 'pager'] as const) { + for (const initial of ['important', 'plain', 'none', 'absent'] as const) { + test(`${family}: destroy восстанавливает исходный inline transform (${initial})`, async ({ page }) => { + const result = await page.evaluate(async ({ url, family, initial }) => { + const recipes = await import(url); + document.body.innerHTML = '
'; + const root = document.querySelector('section')!; + root.innerHTML = family === 'sheet' + ? '
' + : '
Первая
Вторая
'; + const target = root.querySelector(family === 'sheet' ? '[data-sheet-panel]' : '[data-pager-track]')!; + target.id = 'transform-owner'; + const translate = (value: number) => `translate${family === 'sheet' ? 'Y' : 'X'}(${value}px)`; + if (initial !== 'absent') target.style.setProperty('transform', + initial === 'none' ? 'none' : translate(17), initial === 'important' ? 'important' : ''); + const read = () => { + const transform = getComputedStyle(target).transform; + const matrix = transform === 'none' ? new DOMMatrixReadOnly() : new DOMMatrixReadOnly(transform); + return { value: target.style.getPropertyValue('transform'), priority: target.style.getPropertyPriority('transform'), + present: Array.from(target.style).includes('transform'), pixel: family === 'sheet' ? matrix.m42 : matrix.m41 }; + }; + const before = read(); + const consumer = family === 'sheet' + ? recipes.mountCompositorSheet(root, { snapPoints: [0, 120], motion: 'none' }) + : recipes.mountCompositorPager(root, { motion: 'none' }); + consumer.select(1); + const moved = { ...read(), selected: consumer.selected }; + // Конкурирующее правило появляется после здорового движения: потеря + // исходного !important меняет видимую позу именно при cleanup. + const stylesheet = document.createElement('style'); + stylesheet.textContent = `#transform-owner { transform: ${translate(99)}${initial === 'important' ? ' !important' : ''}; }`; + document.head.append(stylesheet); + consumer.destroy(); consumer.destroy(); + const after = read(); + const effects = target.getAnimations().length; + stylesheet.remove(); root.remove(); + return { before, moved, after, effects }; + }, { url: recipeUrl, family, initial }); + expect(result.before).toEqual({ value: initial === 'absent' ? '' : initial === 'none' ? 'none' + : `translate${family === 'sheet' ? 'Y' : 'X'}(17px)`, priority: initial === 'important' ? 'important' : '', + present: initial !== 'absent', pixel: initial === 'none' || initial === 'absent' ? 0 : 17 }); + expect(result.moved.selected).toBe(1); + expect(result.moved.pixel).toBe(family === 'sheet' ? 120 : -240); + expect(result.after).toEqual({ ...result.before, pixel: initial === 'absent' ? 99 : result.before.pixel }); + expect(result.effects).toBe(0); + }); + } + + for (const intent of ['healthy', 'destroy', 'select'] as const) { + test(`${family}: getter onSelect сохраняет ${intent} intent до внешнего эффекта`, async ({ page }) => { + const result = await page.evaluate(async ({ url, family, intent }) => { + const recipes = await import(url); + document.body.innerHTML = '
'; + const root = document.querySelector('section')!; + root.innerHTML = family === 'sheet' + ? '
' + : '
Первая
Вторая
'; + let consumer: any, nested = false, reads = 0; + const calls: number[] = [], receivers: unknown[] = []; + const callback = function (this: unknown, index: number) { calls.push(index); receivers.push(this); }; + Object.defineProperty(callback, 'call', { get() { throw new Error('Не читать callback.call'); } }); + const options = { + motion: 'none', snapPoints: [0, 120], + get onSelect() { + reads++; + if (intent === 'destroy') consumer.destroy(); + if (intent === 'select' && !nested) { nested = true; consumer.select(1); } + return callback; + }, + }; + consumer = family === 'sheet' ? recipes.mountCompositorSheet(root, options) : recipes.mountCompositorPager(root, options); + consumer.select(0); consumer.destroy(); + return { reads, calls, correctReceiver: receivers.every(receiver => receiver === options) }; + }, { url: recipeUrl, family, intent }); + expect(result).toEqual({ reads: intent === 'select' ? 2 : 1, + calls: intent === 'destroy' ? [] : intent === 'select' ? [1] : [0], correctReceiver: true }); + }); + } + + for (const tree of ['light', 'shadow', 'nested', 'child-shadow', + 'outside-shadow', 'outside-nested', 'parent-shadow', 'closed-shadow', + 'parent-closed-shadow', 'ancestor-closed-shadow'] as const) { + test(`${family}: destroy восстанавливает прежний focus owner в ${tree}`, async ({ page }) => { + const result = await page.evaluate(async ({ url, family, tree }) => { + const recipes = await import(url); + document.body.replaceChildren(); + let owner: HTMLElement | ShadowRoot = document.body; + if (tree !== 'light' && tree !== 'child-shadow') { + const host = document.createElement('div'); document.body.append(host); + owner = host.attachShadow({ mode: tree === 'closed-shadow' + || tree === 'parent-closed-shadow' || tree === 'ancestor-closed-shadow' ? 'closed' : 'open' }); + } + let previousOwner = owner; + if (tree === 'outside-shadow' || tree === 'outside-nested') previousOwner = document.body; + if (tree === 'ancestor-closed-shadow') { + const host = document.createElement('div'); owner.append(host); + owner = host.attachShadow({ mode: 'closed' }); + } + if (tree === 'outside-nested' || tree === 'parent-shadow' + || tree === 'parent-closed-shadow' || tree === 'ancestor-closed-shadow') { + const host = document.createElement('div'); owner.append(host); + owner = host.attachShadow({ mode: 'open' }); + } + const previous = document.createElement('button'); previous.textContent = 'Назад'; + if (tree === 'nested') { + const host = document.createElement('div'); owner.append(host); + host.attachShadow({ mode: 'open' }).append(previous); + } else previousOwner.append(previous); + const root = document.createElement('section'); owner.append(root); + root.innerHTML = family === 'sheet' + ? '
' + : '
Первая
'; + previous.focus(); + // Oracle проверяет известный элемент через нативного владельца дерева, + // не повторяя поиск прежнего фокуса из публичного рецепта. + const hasFocus = (element: HTMLElement) => + (element.getRootNode() as Document | ShadowRoot).activeElement === element; + const before = hasFocus(previous); + const consumer = family === 'sheet' + ? recipes.mountCompositorSheet(root, { snapPoints: [0, 120], motion: 'none' }) + : recipes.mountCompositorPager(root, { motion: 'none' }); + let handle = root.querySelector('button')!; + if (tree === 'child-shadow') { + const widget = document.createElement('div'); root.append(widget); + handle = document.createElement('button'); handle.textContent = 'Вложенный ввод'; + widget.attachShadow({ mode: 'open' }).append(handle); + } + handle.focus(); const activeControl = hasFocus(handle); + consumer.destroy(); consumer.destroy(); + return { before, activeControl, restored: hasFocus(previous) }; + }, { url: recipeUrl, family, tree }); + expect(result).toEqual({ before: true, activeControl: true, restored: true }); + }); + } + + for (const quiet of ['none', 'reduced'] as const) { + test(`${family}: ${quiet} pause сохраняет текущую quiet drag позу`, async ({ page }) => { + await page.emulateMedia({ reducedMotion: quiet === 'reduced' ? 'reduce' : 'no-preference' }); + await mount(page, family, quiet === 'none'); + await page.mouse.move(50, 35); await page.mouse.down(); + await page.mouse.move(family === 'pager' ? 10 : 50, family === 'sheet' ? 115 : 35); + const result = await page.evaluate(family => { + const w = window as any; + const pixel = () => { + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + return family === 'sheet' ? matrix.m42 : matrix.m41; + }; + const before = pixel(); + const issued = w.issued; + w.consumer.pause(); w.frame(0); w.frame(80); + const paused = { pixel: pixel(), issued: w.issued, pending: w.pending(), + effects: w.target.getAnimations().length, capture: w.handle.hasPointerCapture(w.pointer), selected: w.consumer.selected }; + w.consumer.resume(); + const resumed = pixel(); + w.consumer.destroy(); + return { before, issued, paused, resumed }; + }, family); + await page.mouse.up(); + expect(Math.abs(result.before)).toBeGreaterThan(1); + expect(result.paused.pixel).toBeCloseTo(result.before, 3); + expect(result.paused).toMatchObject({ issued: result.issued, pending: 0, effects: 0, capture: false, selected: 0 }); + expect(result.issued).toBe(0); + expect(result.resumed).toBe(0); + }); + } + + test(`${family}: native interruption → live follow → native release; один inert callback`, async ({ page }) => { + await page.emulateMedia({ reducedMotion: 'no-preference' }); + await mount(page, family); + const before = await page.evaluate(family => { + const w = window as any; + w.consumer.select(2); + const animations = w.target.getAnimations(); + if (animations.length !== 1) throw new Error('Здоровый native control не достигнут'); + animations[0].pause(); animations[0].currentTime = 75; + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + return { pixel: family === 'sheet' ? matrix.m42 : matrix.m41, issued: w.issued, mode: w.consumer.motion.mode }; + }, family); + expect(before.mode).toBe('compositor'); + expect(before.issued).toBe(0); + await page.mouse.move(50, 35); await page.mouse.down(); + const pickup = await page.evaluate(family => { + const w = window as any; + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + return { pixel: family === 'sheet' ? matrix.m42 : matrix.m41, effects: w.target.getAnimations().length, + mode: w.consumer.motion.mode, capture: w.handle.hasPointerCapture(w.pointer) }; + }, family); + expect(pickup.pixel).toBeCloseTo(before.pixel, 3); + expect(pickup.effects).toBe(0); expect(pickup.mode).toBe('fallback'); expect(pickup.capture).toBe(true); + await page.mouse.move(family === 'pager' ? 180 : 50, family === 'sheet' ? 155 : 35); + const follow = await page.evaluate(() => { + const w = window as any; + w.frame(0); w.frame(80); + w.oldLive = w.consumer.motion.handoffToLive(); + return { value: w.oldLive.value, velocity: w.oldLive.velocity, effects: w.target.getAnimations().length, + pending: w.pending(), issued: w.issued }; + }); + expect(follow.effects).toBe(0); expect(follow.pending).toBe(1); + expect(Number.isFinite(follow.velocity)).toBe(true); expect(Math.abs(follow.velocity)).toBeGreaterThan(0); + await page.mouse.up(); + const release = await page.evaluate(family => { + const w = window as any; + const animations = w.target.getAnimations(); + if (animations.length !== 1) throw new Error('Release не вернулся в native'); + animations[0].pause(); animations[0].currentTime = 0; + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const issued = w.issued; + w.oldLive.setTarget(100_000); + w.frame(160); w.frame(240); + return { pixel: family === 'sheet' ? matrix.m42 : matrix.m41, mode: w.consumer.motion.mode, + pending: w.pending(), issued: w.issued, issuedAtRelease: issued, effects: w.target.getAnimations().length }; + }, family); + expect(release.pixel).toBeCloseTo(follow.value, 3); + expect(release.mode).toBe('compositor'); expect(release.effects).toBe(1); + expect(release.pending).toBe(0); expect(release.issued).toBe(release.issuedAtRelease); + const terminal = await page.evaluate(() => { + const w = window as any; + w.consumer.destroy(); w.consumer.destroy(); w.handle.click(); + w.consumer.select(Number.NaN); w.consumer.resume(); w.frame(400); + return { effects: w.target.getAnimations().length, pending: w.pending(), focus: document.activeElement?.id }; + }); + expect(terminal).toEqual({ effects: 0, pending: 0, focus: 'previous-focus' }); + }); + + test(`${family}: pointercancel не меняет выбранную цель, pause сохраняет позу`, async ({ page }) => { + await page.emulateMedia({ reducedMotion: 'no-preference' }); + await mount(page, family); + await page.evaluate(() => { const w = window as any; w.consumer.select(1); w.target.getAnimations()[0].pause(); w.target.getAnimations()[0].currentTime = 90; }); + await page.mouse.move(50, 35); await page.mouse.down(); + await page.mouse.move(family === 'pager' ? 110 : 50, family === 'sheet' ? 75 : 35); + const result = await page.evaluate(family => { + const w = window as any; + w.frame(0); w.frame(50); + w.handle.dispatchEvent(new PointerEvent('pointercancel', { pointerId: w.pointer, bubbles: true })); + const afterCancel = { selected: w.consumer.selected, effects: w.target.getAnimations().length, capture: w.handle.hasPointerCapture(w.pointer) }; + const animation = w.target.getAnimations()[0]; animation.pause(); animation.currentTime = 50; + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const beforePause = family === 'sheet' ? matrix.m42 : matrix.m41; + w.consumer.pause(); w.frame(120); w.frame(240); + const pausedMatrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const paused = { pixel: family === 'sheet' ? pausedMatrix.m42 : pausedMatrix.m41, + effects: w.target.getAnimations().length, pending: w.pending() }; + w.consumer.resume(); + const resumed = { selected: w.consumer.selected, effects: w.target.getAnimations().length, mode: w.consumer.motion.mode }; + w.consumer.destroy(); + return { afterCancel, beforePause, paused, resumed }; + }, family); + await page.mouse.up(); + expect(result.afterCancel).toEqual({ selected: 1, effects: 1, capture: false }); + expect(result.paused.pixel).toBeCloseTo(result.beforePause, 3); + expect(result.paused.effects).toBe(0); expect(result.paused.pending).toBe(0); + expect(result.resumed).toEqual({ selected: 1, effects: 1, mode: 'compositor' }); + }); + + test(`${family}: no-motion, keyboard, IME и явный resize/reparent`, async ({ page }) => { + await page.emulateMedia({ reducedMotion: 'no-preference' }); + await mount(page, family, true); + const result = await page.evaluate(family => { + const w = window as any; + w.handle.focus(); + w.handle.dispatchEvent(new KeyboardEvent('keydown', { key: 'End', bubbles: true, cancelable: true })); + const selected = w.consumer.selected; + const input = w.root.querySelector('input'); input.focus(); + const composing = new KeyboardEvent('keydown', { key: 'ArrowRight', isComposing: true, bubbles: true, cancelable: true }); + input.dispatchEvent(composing); input.value = 'Привет 世界'; + const inputResult = { selected: w.consumer.selected, prevented: composing.defaultPrevented, value: input.value, focused: document.activeElement === input }; + const shadowHost = document.createElement('div'); document.body.append(shadowHost); + const shadow = shadowHost.attachShadow({ mode: 'open' }); shadow.append(w.root); + if (family === 'sheet') w.consumer.resize([0, 80, 160]); + else { + const viewport = w.root.querySelector('[data-pager-viewport]'); viewport.style.width = '360px'; viewport.style.direction = 'rtl'; + w.consumer.resize(); + } + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const resized = family === 'sheet' ? matrix.m42 : matrix.m41; + if (family === 'pager') { + w.handle.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true, cancelable: true })); + } + const afterRtlKey = w.consumer.selected; + w.handle.focus(); w.consumer.destroy(); + return { selected, inputResult, resized, afterRtlKey, effects: w.target.getAnimations().length, + pending: w.pending(), issued: w.issued, focus: document.activeElement?.id }; + }, family); + expect(result.selected).toBe(2); + expect(result.inputResult).toEqual({ selected: 2, prevented: false, value: 'Привет 世界', focused: true }); + expect(result.resized).toBe(family === 'sheet' ? 160 : 720); + expect(result.afterRtlKey).toBe(family === 'sheet' ? 2 : 1); + expect(result.effects).toBe(0); expect(result.pending).toBe(0); expect(result.issued).toBe(0); + expect(result.focus).toBe('previous-focus'); + }); + + test(`${family}: reduced-motion при mount и при смене предпочтения`, async ({ page }) => { + await page.emulateMedia({ reducedMotion: 'reduce' }); + await mount(page, family); + const reduced = await page.evaluate(family => { + const w = window as any; w.consumer.select(2); + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const result = { value: family === 'sheet' ? matrix.m42 : matrix.m41, effects: w.target.getAnimations().length, issued: w.issued }; + w.consumer.destroy(); return result; + }, family); + expect(reduced).toEqual({ value: family === 'sheet' ? 240 : -480, effects: 0, issued: 0 }); + await page.emulateMedia({ reducedMotion: 'no-preference' }); + await mount(page, family); + await page.evaluate(() => { const w = window as any; w.consumer.select(2); }); + expect(await page.evaluate(() => (window as any).target.getAnimations().length)).toBe(1); + await page.emulateMedia({ reducedMotion: 'reduce' }); + await expect.poll(() => page.evaluate(() => (window as any).target.getAnimations().length)).toBe(0); + const changed = await page.evaluate(family => { + const w = window as any; w.frame(0); w.frame(80); + const matrix = new DOMMatrixReadOnly(getComputedStyle(w.target).transform); + const result = { value: family === 'sheet' ? matrix.m42 : matrix.m41, pending: w.pending() }; + w.consumer.destroy(); return result; + }, family); + expect(changed).toEqual({ value: family === 'sheet' ? 240 : -480, pending: 0 }); + }); +} diff --git a/browser/fixtures/compile-artifacts.mjs b/browser/fixtures/compile-artifacts.mjs index 9effa0f62..00788f43c 100644 --- a/browser/fixtures/compile-artifacts.mjs +++ b/browser/fixtures/compile-artifacts.mjs @@ -14,11 +14,15 @@ * surface-executor живёт под приватным путём `@labpics/motion/compiler/surface` * (горячий фикс наблюдаемой эквивалентности перевёл его из публичного * `./surface` в приватный compiler-неймспейс). + * Literal lifecycle/sheet/pager recipes собираются отдельно из полного npm + * tarball без motion aliases; scope-recipes.package.json связывает его bytes, + * cookbook и браузерный bundle. */ import { build } from 'vite'; -import { buildReorderRecipe } from './reorder-recipe.mjs'; import { buildScopeRecipes } from './scope-recipes.mjs'; +import { buildPackagedCompositorFollowRecipes } from './compositor-follow-recipes.mjs'; +import { buildPresenceScopeResource } from './presence-scope-resource.mjs'; import { readCompilerNanoRecipe } from '../../scripts/compiler-doc-recipe.mjs'; import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'; import { dirname, resolve } from 'node:path'; @@ -117,12 +121,20 @@ export default async function globalSetup() { if (!/layout:\s*"project"|layout:\s*'project'/.test(surfaceReturn) || /w0:\s*240,\s*w1:\s*360/.test(surfaceReturn)) { throw new Error('compile-artifacts: return-форма ошибочно понижена — нарушена наблюдаемая эквивалентность'); } - await buildReorderRecipe(ROOT, OUT); + const followReceipt = await buildPackagedCompositorFollowRecipes(ROOT, OUT, process.env.LAB_MOTION_TARBALL); writeFileSync(resolve(OUT, 'compiled.js'), compiled); writeFileSync(resolve(OUT, 'uncompiled.js'), uncompiled); writeFileSync(resolve(OUT, 'surface-compiled.js'), surfaceCompiled); writeFileSync(resolve(OUT, 'surface-uncompiled.js'), surfaceUncompiled); - await buildScopeRecipes(ROOT, OUT, TMP); + const scopeReceipt = await buildScopeRecipes(ROOT, OUT, TMP, resolve(OUT, followReceipt.tarball.file)); + if (scopeReceipt.tarball.sha256 !== followReceipt.tarball.sha256) { + throw new Error('compile-artifacts: browser journeys consumed different package bytes'); + } + const resourceReceipt = await buildPresenceScopeResource(ROOT, OUT, resolve(TMP, 'resource-owners'), + resolve(OUT, followReceipt.tarball.file)); + if (resourceReceipt.tarball.sha256 !== followReceipt.tarball.sha256) { + throw new Error('compile-artifacts: presence/scope resource consumed different package bytes'); + } } finally { rmSync(TMP, { recursive: true, force: true }); } diff --git a/browser/fixtures/compositor-follow-recipes.mjs b/browser/fixtures/compositor-follow-recipes.mjs new file mode 100644 index 000000000..f57a53ae2 --- /dev/null +++ b/browser/fixtures/compositor-follow-recipes.mjs @@ -0,0 +1,103 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { basename, join, relative, resolve, sep } from 'node:path'; +import { build } from 'esbuild'; +import { measureScenarioOutputGraph } from '../../scripts/size-gate.mjs'; + +const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex'); + +/** Буквальный UI-код документации собирается и из установленного пакета. */ +export function compositorFollowRecipes(root) { + const text = readFileSync(resolve(root, 'docs/recipes.md'), 'utf8').replaceAll('\r\n', '\n'); + const section = text.split('')[1] + ?.split('')[0]; + const source = section?.match(/```typescript\n([\s\S]*?)\n```/)?.[1]; + if (!source) throw new Error('compositor follow recipes are missing'); + return source; +} + +export async function buildCompositorFollowRecipes(root, out, consumerRoot = root) { + const packageRoot = realpathSync(root); + const absWorkingDir = realpathSync(consumerRoot); + const entryPoint = resolve(absWorkingDir, 'compositor-follow-recipes.ts'); + const outdir = resolve(out); + const source = compositorFollowRecipes(packageRoot); + const result = await build({ + absWorkingDir, + stdin: { contents: source, loader: 'ts', resolveDir: absWorkingDir, sourcefile: entryPoint }, + bundle: true, format: 'esm', platform: 'browser', target: 'es2022', + minify: true, splitting: true, metafile: true, write: false, + outdir, entryNames: 'compositor-follow-recipes', + }); + const inputs = Object.keys(result.metafile.inputs).map((path) => resolve(absWorkingDir, path)); + for (const input of inputs) { + if (input !== entryPoint && !input.startsWith(packageRoot + sep)) { + throw new Error('recipe dependency escaped installed package: ' + input); + } + } + const measurement = measureScenarioOutputGraph(result, { absWorkingDir, outdir, entryPoint }); + const outputs = result.outputFiles.map((file) => { + writeFileSync(file.path, file.contents); + return { file: relative(outdir, file.path).split(sep).join('/'), sha256: sha256(file.contents) }; + }); + return { + documentSha256: sha256(readFileSync(resolve(packageRoot, 'docs/recipes.md'))), + sourceSha256: sha256(source), + packageInputs: inputs.filter((input) => input !== entryPoint) + .map((input) => relative(packageRoot, input).split(sep).join('/')).sort(), + outputs, measurement, + }; +} + +/** Тот же tgz обслуживает package checks и реальные browser journeys. */ +export async function buildPackagedCompositorFollowRecipes(root, out, suppliedTarball) { + const windows = process.platform === 'win32'; + const run = (args, cwd) => { + // cmd запускает .cmd-shim; кавычки сохраняют пробелы, expansion запрещён. + const commandArgs = windows ? args.map((arg) => { + if (/[\"%!\r\n]/.test(arg)) throw new Error('unsupported cmd argument in recipe package path'); + return '\"' + arg + '\"'; + }) : args; + return execFileSync(windows ? 'pnpm.cmd' : 'pnpm', commandArgs, { + cwd, shell: windows, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], + }); + }; + const pkg = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8')); + const work = mkdtempSync(join(tmpdir(), 'motion-follow-package-')); + try { + const tarball = resolve(out, 'compositor-follow-package.tgz'); + if (suppliedTarball) { + if (!suppliedTarball.endsWith('.tgz')) throw new Error('supplied recipe package must be a tgz'); + copyFileSync(resolve(suppliedTarball), tarball); + } else { + run(['pack', '--pack-destination', work], root); + const archives = readdirSync(work).filter((name) => name.endsWith('.tgz')); + if (archives.length !== 1) throw new Error('expected one packed recipe candidate'); + copyFileSync(join(work, archives[0]), tarball); + } + const consumer = join(work, 'consumer'); + mkdirSync(consumer); + writeFileSync(join(consumer, 'package.json'), JSON.stringify({ + name: 'motion-follow-consumer', private: true, type: 'module', packageManager: pkg.packageManager, + })); + run(['add', '--ignore-scripts', '--offline', '--config.auto-install-peers=false', + '--store-dir', join(work, 'store'), tarball], consumer); + const installed = resolve(consumer, 'node_modules', ...pkg.name.split('/')); + const shipped = JSON.parse(readFileSync(join(installed, 'package.json'), 'utf8')); + if (shipped.name !== pkg.name || shipped.version !== pkg.version) { + throw new Error('packed recipe identity differs from the candidate'); + } + const recipe = await buildCompositorFollowRecipes(installed, out, consumer); + const receipt = { + package: shipped.name + '@' + shipped.version, + tarball: { file: basename(tarball), sha256: sha256(readFileSync(tarball)) }, + ...recipe, + }; + writeFileSync(resolve(out, 'compositor-follow-package.json'), JSON.stringify(receipt, null, 2) + '\n'); + return receipt; + } finally { + rmSync(work, { recursive: true, force: true }); + } +} diff --git a/browser/fixtures/harness.ts b/browser/fixtures/harness.ts index 127e26d52..5a99f7ae3 100644 --- a/browser/fixtures/harness.ts +++ b/browser/fixtures/harness.ts @@ -14,6 +14,7 @@ import { test as base, expect } from '@playwright/test'; import { readFileSync } from 'node:fs'; import { fileURLToPath } from 'node:url'; +import { verifyJourneyTuple } from './journey-tuple'; const HARNESS_PATH = '/browser/fixtures/harness.html'; @@ -64,4 +65,12 @@ export const test = base.extend({ }, }); +/** Шесть journey consumers разделяют один actual tarball до каждого outcome. */ +export const packedJourneyTest = test.extend({ + page: async ({ page }, use, info) => { + await verifyJourneyTuple(page, info); + await use(page); + }, +}); + export { expect }; diff --git a/browser/fixtures/journey-tuple.ts b/browser/fixtures/journey-tuple.ts new file mode 100644 index 000000000..48d7f8759 --- /dev/null +++ b/browser/fixtures/journey-tuple.ts @@ -0,0 +1,52 @@ +import { createHash } from 'node:crypto'; +import { readFileSync } from 'node:fs'; +import type { Page, TestInfo } from '@playwright/test'; +import { expect } from '@playwright/test'; + +/** Каждый outcome привязан к полученным bytes; чужой receipt с тем же именем не проходит. */ +export async function verifyJourneyTuple(page: Page, info: TestInfo): Promise { + const digest = (bytes: Buffer): string => createHash('sha256').update(bytes).digest('hex'); + const scopeResponse = await page.request.get('/browser/.artifacts/scope-recipes.package.json'); + const followResponse = await page.request.get('/browser/.artifacts/compositor-follow-package.json'); + expect(scopeResponse.ok()).toBe(true); expect(followResponse.ok()).toBe(true); + const scope = await scopeResponse.json(); + const follow = await followResponse.json(); + expect(scope.schema).toBe('scope-recipes-package-v1'); + expect(scope.package.name).toBe('@labpics/motion'); + expect(follow.package).toBe(`${scope.package.name}@${scope.package.version}`); + // Эти имена задаёт fixture, не произвольное поле receipt. + const archive = await page.request.get('/browser/.artifacts/scope-recipes-package.tgz'); + const followArchive = await page.request.get('/browser/.artifacts/compositor-follow-package.tgz'); + const bundle = await page.request.get('/browser/.artifacts/scope-recipes.js'); + const followBundle = await page.request.get('/browser/.artifacts/compositor-follow-recipes.js'); + expect(archive.ok()).toBe(true); expect(followArchive.ok()).toBe(true); + expect(bundle.ok()).toBe(true); expect(followBundle.ok()).toBe(true); + const bytes = await archive.body(); + const sha256 = digest(bytes); + // Local globalSetup владеет expected bytes и при PW_REUSE_SERVER=1: + // взаимно согласованный foreign server не может удостоверить сам себя. + const expectedArchiveSha256 = digest(readFileSync( + new URL('../.artifacts/compositor-follow-package.tgz', import.meta.url))); + expect(sha256).toBe(expectedArchiveSha256); + expect(sha256).toBe(scope.tarball.sha256); + expect(`sha512-${createHash('sha512').update(bytes).digest('base64')}`).toBe(scope.tarball.integrity); + // Два receipt могут ошибочно сообщить один hash; реальные архивы должны совпасть. + const followBytes = await followArchive.body(); + expect(followBytes.equals(bytes)).toBe(true); + expect(digest(followBytes)).toBe(follow.tarball.sha256); + expect(digest(await bundle.body())).toBe(scope.bundleSha256); + expect(digest(await followBundle.body())).toBe(follow.outputs.find((output: { file: string }) => + output.file === 'compositor-follow-recipes.js')?.sha256); + expect(follow.documentSha256).toBe(scope.recipesSha256); + expect(scope.motionInputs.length).toBeGreaterThan(0); + expect(scope.motionInputs.every((path: string) => path.startsWith('dist/'))).toBe(true); + expect(Object.keys(scope.motionInputSha256).sort()).toEqual(scope.motionInputs); + expect(Object.values(scope.motionInputSha256).every(value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value))).toBe(true); + if (process.env.LAB_MOTION_TARBALL) { + expect(sha256).toBe(digest(readFileSync(process.env.LAB_MOTION_TARBALL))); + } + info.annotations.push({ type: 'package-sha256', description: sha256 }); + await info.attach('journey-package-tuple', { contentType: 'application/json', body: JSON.stringify({ + scope, follow, expectedArchiveSha256, browser: page.context().browser()?.version(), project: info.project.name, + }) }); +} diff --git a/browser/fixtures/packed-recipes.d.ts b/browser/fixtures/packed-recipes.d.ts new file mode 100644 index 000000000..c65147f01 --- /dev/null +++ b/browser/fixtures/packed-recipes.d.ts @@ -0,0 +1,40 @@ +/** Только type boundary артефакта globalSetup; runtime загружает actual tarball. */ +export declare const captureSmart: typeof import('../../src/smart/index.js').captureSmart; +export declare const createPresenceTransition: typeof import('../../src/presence/index.js').createPresenceTransition; +export declare const animate: typeof import('../../src/animate/index.js').animate; +export declare const createReorder: typeof import('../../src/behaviors/reorder/index.js').createReorder; +export declare const CompositorSpring: typeof import('../../src/compositor/index.js').CompositorSpring; +export declare function bindAnimatedDialog(dialog: HTMLDialogElement): { + setPresent(present: boolean): Promise; + readonly finished: Promise; + readonly state: string; + destroy(): void; + }; + +interface CompositorRecipeOptions { + motion?: 'auto' | 'none'; + onSelect?: (index: number) => void; + requestFrame?: NonNullable[0]['requestFrame']>; +} + +interface CompositorRecipeControls { + motion: InstanceType; + select(index: number): void; + readonly selected: number; + pause(): void; + resume(): void; + destroy(): void; +} + +export declare function mountCardMotion(root: HTMLElement): () => void; +export declare function mountCompositorSheet(root: HTMLElement, options: CompositorRecipeOptions & { + snapPoints: readonly number[]; +}): CompositorRecipeControls & { resize(next: readonly number[]): void }; +export declare function mountCompositorPager(root: HTMLElement, options?: CompositorRecipeOptions): + CompositorRecipeControls & { resize(): void }; +export declare function mountReorder(root: HTMLElement, status: HTMLElement): () => void; +export declare function mountReact(container: Element | Document | DocumentFragment, hydrate?: boolean): { + destroy(): void; + commits(): number; +}; +export declare function mountSolid(container: Parameters[1]): () => void; diff --git a/browser/fixtures/presence-scope-resource.mjs b/browser/fixtures/presence-scope-resource.mjs new file mode 100644 index 000000000..7fbb03e37 --- /dev/null +++ b/browser/fixtures/presence-scope-resource.mjs @@ -0,0 +1,34 @@ +import { createHash } from 'node:crypto'; +import { readFileSync, writeFileSync } from 'node:fs'; +import { join, relative, resolve, sep } from 'node:path'; +import { build } from 'esbuild'; +import { packScopeRecipePackage } from './scope-recipes.mjs'; + +const hash = value => createHash('sha256').update(value).digest('hex'); + +/** RESOURCE consumes the same full archive as the existing browser consumers. */ +export async function buildPresenceScopeResource(root, out, tmp, suppliedTarball) { + const { packageRoot, receipt } = packScopeRecipePackage(root, tmp, suppliedTarball); + const entry = join(tmp, 'resource-owners-entry.ts'); + writeFileSync(entry, ` + export { createPresenceTransition } from '@labpics/motion/presence'; + export { createAnimateScope } from '@labpics/motion/animate'; + `); + const bundle = join(out, 'presence-scope-resource.js'); + const result = await build({ absWorkingDir: root, entryPoints: [entry], outfile: bundle, + bundle: true, platform: 'browser', format: 'esm', target: 'es2022', metafile: true }); + const inputs = Object.keys(result.metafile.inputs).map(path => resolve(root, path)); + const motionInputs = inputs.filter(path => path.startsWith(packageRoot + sep)); + if (!motionInputs.length || inputs.some(path => path.startsWith(join(root, 'dist') + sep) + || path.startsWith(join(root, 'src') + sep))) { + throw new Error('presence-scope-resource: bundle bypassed the actual tarball'); + } + const resultReceipt = { ...receipt, + schema: 'presence-scope-resource-package-v1', + motionInputSha256: Object.fromEntries(motionInputs.sort().map(path => + [relative(packageRoot, path).split(sep).join('/'), hash(readFileSync(path))])), + bundleSha256: hash(readFileSync(bundle)), + }; + writeFileSync(join(out, 'presence-scope-resource.package.json'), JSON.stringify(resultReceipt, null, 2) + '\n'); + return resultReceipt; +} diff --git a/browser/fixtures/reorder-recipe.mjs b/browser/fixtures/reorder-recipe.mjs index b89a00d11..13b1f3218 100644 --- a/browser/fixtures/reorder-recipe.mjs +++ b/browser/fixtures/reorder-recipe.mjs @@ -1,17 +1,11 @@ import { readFileSync } from 'node:fs'; import { resolve } from 'node:path'; -import { build } from 'esbuild'; /** Один исходник прикладного примера: документация является исполняемым consumer. */ export function reorderRecipe(root) { const text = readFileSync(resolve(root, 'docs/recipes.md'), 'utf8'); const section = text.split('')[1]?.split('')[0]; - const source = section?.match(/```typescript\n([\s\S]*?)\n```/)?.[1]; + const source = section?.match(/```typescript\r?\n([\s\S]*?)\r?\n```/)?.[1]; if (!source) throw new Error('reorder recipe is missing'); return source; } -export async function buildReorderRecipe(root, out) { - await build({ stdin: { contents: reorderRecipe(root), loader: 'ts', resolveDir: root }, - bundle: true, format: 'esm', platform: 'browser', target: 'es2022', - outfile: resolve(out, 'reorder-recipe.js') }); -} diff --git a/browser/fixtures/scope-recipes.mjs b/browser/fixtures/scope-recipes.mjs index 094762921..8f0c99add 100644 --- a/browser/fixtures/scope-recipes.mjs +++ b/browser/fixtures/scope-recipes.mjs @@ -1,44 +1,169 @@ /** Исполняемые примеры берутся из docs/recipes.md, не копируются в стенд. */ -import { readFileSync, writeFileSync } from 'node:fs'; -import { join } from 'node:path'; -import { build } from 'esbuild'; +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'; +import { basename, dirname, join, relative, resolve, sep } from 'node:path'; +import { build, version as esbuildVersion } from 'esbuild'; +import { reorderRecipe } from './reorder-recipe.mjs'; + +const hash = (value) => createHash('sha256').update(value).digest('hex'); + +// Исполняем CLI через Node на Windows: .cmd-shell не должен интерпретировать +// пробелы, кавычки или метасимволы пути временного consumer. +function npmPack(root, directory) { + const windows = process.platform === 'win32'; + const shim = windows ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }) + .split(/\r?\n/).find(Boolean) : undefined; + const cli = shim && join(dirname(shim), 'node_modules', 'npm', 'bin', 'npm-cli.js'); + if (windows && (!cli || !existsSync(cli))) throw new Error('scope-recipes: npm CLI рядом с npm.cmd отсутствует'); + return JSON.parse(execFileSync(windows ? process.execPath : 'npm', [ + ...(windows ? [cli] : []), 'pack', '--ignore-scripts', '--json', '--pack-destination', directory, + ], { cwd: root, encoding: 'utf8', timeout: 120_000 })); +} + +function fileCount(directory) { + return readdirSync(directory, { withFileTypes: true }).reduce((count, entry) => + count + (entry.isDirectory() ? fileCount(join(directory, entry.name)) : entry.isFile() ? 1 : 0), 0); +} + +/** Пакуем полный publish manifest; никакие source/dist aliases не участвуют. */ +export function packScopeRecipePackage(root, directory, suppliedTarball) { + mkdirSync(directory, { recursive: true }); + // Ближайший package boundary исключает self-reference исходного checkout: + // без него bare import внутри root разрешается назад в root/dist. + writeFileSync(join(directory, 'package.json'), JSON.stringify({ name: 'scope-recipes-consumer', private: true, type: 'module' })); + let packed; + let tarball; + if (suppliedTarball) { + if (!suppliedTarball.endsWith('.tgz')) throw new Error('scope-recipes: supplied package must be a tgz'); + tarball = join(directory, 'supplied-package.tgz'); + copyFileSync(resolve(suppliedTarball), tarball); + } else { + const receipts = npmPack(root, directory); + if (receipts.length !== 1) throw new Error('scope-recipes: expected one npm pack receipt'); + [packed] = receipts; + if (!packed?.filename || basename(packed.filename) !== packed.filename) { + throw new Error('scope-recipes: npm pack не вернул одно имя архива'); + } + tarball = join(directory, packed.filename); + } + const bytes = readFileSync(tarball); + const integrity = `sha512-${createHash('sha512').update(bytes).digest('base64')}`; + if (packed && packed.integrity !== integrity) throw new Error('scope-recipes: tarball integrity расходится с npm receipt'); + const packageRoot = join(directory, 'node_modules', '@labpics', 'motion'); + rmSync(packageRoot, { recursive: true, force: true }); + mkdirSync(packageRoot, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', tarball, '-C', packageRoot, '--strip-components=1'], { timeout: 120_000 }); + const manifest = readFileSync(join(packageRoot, 'package.json')); + const pkg = JSON.parse(manifest); + const candidate = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + if (pkg.name !== candidate.name || pkg.version !== candidate.version) { + throw new Error('scope-recipes: packed identity differs from the candidate'); + } + const cookbook = readFileSync(join(packageRoot, 'docs/recipes.md')); + if (!cookbook.equals(readFileSync(join(root, 'docs/recipes.md')))) { + throw new Error('scope-recipes: cookbook изменился между pack и readback'); + } + return { packageRoot, tarball, receipt: { + schema: 'scope-recipes-package-v1', package: { name: pkg.name, version: pkg.version }, + tarball: { filename: basename(tarball), sha256: hash(bytes), integrity }, + manifest: { sha256: hash(manifest), fileCount: fileCount(packageRoot) }, + recipesSha256: hash(cookbook), runtime: { node: process.version, esbuild: esbuildVersion }, + } }; +} export function writeScopeRecipeSources(root, directory) { const book = readFileSync(join(root, 'docs/recipes.md'), 'utf8'); - for (const [id, file] of [['vanilla', 'card-motion.ts'], ['react', 'react-card.ts'], ['solid', 'solid-card.ts']]) { - const marker = ``; + for (const [id, file] of [['animate-scope-vanilla', 'card-motion.ts'], + ['animate-scope-react', 'react-card.ts'], ['animate-scope-solid', 'solid-card.ts'], + ['compositor-sheet', 'compositor-sheet.ts'], ['compositor-pager', 'compositor-pager.ts'], + ['presence-dialog', 'presence-dialog.ts']]) { + const marker = ``; const parts = book.split(marker); if (parts.length !== 2) throw new Error(`Ожидается ровно один ${marker}`); - const match = parts[1].match(/^\s*```typescript\n([\s\S]*?)\n```/); + const match = parts[1].match(/^\s*```typescript\r?\n([\s\S]*?)\r?\n```/); if (!match) throw new Error(`Нет исполнимого TypeScript после ${marker}`); writeFileSync(join(directory, file), match[1]); } + writeFileSync(join(directory, 'reorder-component.ts'), reorderRecipe(root)); } -export async function buildScopeRecipes(root, out, tmp) { - writeScopeRecipeSources(root, tmp); +export async function buildScopeRecipes(root, out, tmp, suppliedTarball) { + const { packageRoot, tarball, receipt } = packScopeRecipePackage(root, tmp, suppliedTarball); + writeScopeRecipeSources(packageRoot, tmp); const entry = join(tmp, 'scope-entry.ts'); writeFileSync(entry, ` import { createElement, StrictMode, Profiler } from 'react'; - import { createRoot } from 'react-dom/client'; + import { createRoot, hydrateRoot } from 'react-dom/client'; import { render } from 'solid-js/web'; import { ScopedCard } from './react-card.js'; import { SolidScopedCard } from './solid-card.js'; export { mountCardMotion } from './card-motion.js'; - export function mountReact(container) { + export { mountCompositorSheet } from './compositor-sheet.js'; + export { mountCompositorPager } from './compositor-pager.js'; + export { bindAnimatedDialog } from './presence-dialog.js'; + export { mountReorder } from './reorder-component.js'; + export { CompositorSpring } from '@labpics/motion/compositor'; + export { captureSmart } from '@labpics/motion/smart'; + export { createPresenceTransition } from '@labpics/motion/presence'; + export { animate } from '@labpics/motion/animate'; + export { createReorder } from '@labpics/motion/behaviors/reorder'; + export function mountReact(container, hydrate = false) { let commits = 0; - const root = createRoot(container); - root.render(createElement(StrictMode, null, - createElement(Profiler, {id: 'scope', onRender: () => { commits++; }}, createElement(ScopedCard)))); + const element = createElement(StrictMode, null, + createElement(Profiler, {id: 'scope', onRender: () => { commits++; }}, createElement(ScopedCard))); + const root = hydrate ? hydrateRoot(container, element) : createRoot(container); + if (!hydrate) root.render(element); return { destroy: () => root.unmount(), commits: () => commits }; } export function mountSolid(container) { return render(SolidScopedCard, container); } `); - await build({ absWorkingDir: root, entryPoints: [entry], outfile: join(out, 'scope-recipes.js'), + const result = await build({ absWorkingDir: root, entryPoints: [entry], outfile: join(out, 'scope-recipes.js'), bundle: true, platform: 'browser', format: 'esm', target: 'es2022', - alias: { '@labpics/motion/animate': join(root, 'dist/animate/index.js') }, + metafile: true, // StrictMode rehearsal работает только в development React. Это среда // проверки lifecycle, не размерный/performance benchmark production. define: { 'process.env.NODE_ENV': '"development"' }, }); + const inputs = Object.keys(result.metafile.inputs).map(path => resolve(root, path)); + const motionInputs = inputs.filter(path => path.startsWith(packageRoot + sep)); + if (!motionInputs.length || inputs.some(path => path.startsWith(join(root, 'dist') + sep) + || path.startsWith(join(root, 'src') + sep))) { + throw new Error('scope-recipes: сборка обошла actual tarball'); + } + const serverEntry = join(tmp, 'scope-ssr-entry.ts'); + const serverBundle = join(tmp, 'scope-ssr.cjs'); + writeFileSync(serverEntry, ` + import { createElement } from 'react'; + import { renderToString } from 'react-dom/server'; + import { ScopedCard } from './react-card.js'; + if (typeof document !== 'undefined') throw new Error('SSR fixture получил DOM'); + process.stdout.write(renderToString(createElement(ScopedCard))); + `); + const serverResult = await build({ absWorkingDir: root, entryPoints: [serverEntry], outfile: serverBundle, + bundle: true, platform: 'node', format: 'cjs', target: 'node22', metafile: true, + define: { 'process.env.NODE_ENV': '"development"' }, + }); + const serverInputs = Object.keys(serverResult.metafile.inputs).map(path => resolve(root, path)); + if (!serverInputs.some(path => path.startsWith(packageRoot + sep)) + || serverInputs.some(path => path.startsWith(join(root, 'dist') + sep) || path.startsWith(join(root, 'src') + sep))) { + throw new Error('scope-recipes: SSR сборка обошла actual tarball'); + } + const serverHtml = execFileSync(process.execPath, [serverBundle], { encoding: 'utf8', timeout: 30_000 }); + writeFileSync(join(out, 'scope-react.ssr.html'), serverHtml); + const archivedTarball = 'scope-recipes-package.tgz'; + copyFileSync(tarball, join(out, archivedTarball)); + const resultReceipt = { ...receipt, + tarball: { ...receipt.tarball, file: archivedTarball }, + motionInputs: motionInputs.map(path => relative(packageRoot, path).split(sep).join('/')).sort(), + motionInputSha256: Object.fromEntries(motionInputs.sort().map(path => + [relative(packageRoot, path).split(sep).join('/'), hash(readFileSync(path))])), + bundleSha256: hash(readFileSync(join(out, 'scope-recipes.js'))), + ssrHtmlSha256: hash(serverHtml), + ssrMotionInputs: serverInputs.filter(path => path.startsWith(packageRoot + sep)) + .map(path => relative(packageRoot, path).split(sep).join('/')).sort(), + }; + writeFileSync(join(out, 'scope-recipes.package.json'), JSON.stringify(resultReceipt, null, 2) + '\n'); + return resultReceipt; } diff --git a/browser/journey-grid.spec.ts b/browser/journey-grid.spec.ts new file mode 100644 index 000000000..7d55ad3f8 --- /dev/null +++ b/browser/journey-grid.spec.ts @@ -0,0 +1,92 @@ +import { expect, packedJourneyTest as test } from './fixtures/harness'; + +test('grid: приложение подтверждает keyboard reorder и отзывает pointer proposal после фильтра', async ({ page }) => { + await page.evaluate(async () => { + const { createReorder } = await import('/browser/.artifacts/scope-recipes.js'); + document.body.innerHTML = '
'; + const root = document.querySelector('#grid')!; + let keys = ['a', 'b', 'c', 'd']; + let accept = true; + let pending: { keys: string[]; proposal: any } | undefined; + let session: ReturnType>['start']> | undefined; + const paint = () => { + for (const node of root.querySelectorAll('button')) { + if (!keys.includes(node.dataset.key!)) node.remove(); + } + keys.forEach((key, i) => { + let button = [...root.querySelectorAll('button')].find(node => node.dataset.key === key); + if (!button) { + button = document.createElement('button'); + button.textContent = key; + button.dataset.key = key; + root.append(button); + } + button.style.cssText = `position:absolute;left:${i % 2 * 60}px;top:${Math.floor(i / 2) * 60}px;width:40px;height:40px`; + }); + }; + const measure = () => keys.map(key => { + const node = [...root.querySelectorAll('button')].find(item => item.dataset.key === key)!; + const rect = node.getBoundingClientRect(); + return { key, rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } }; + }); + paint(); + const resolver = createReorder({ items: measure(), axis: 'both', direction: 'rtl', onReorder(next, proposal) { + pending = { keys: [...next], proposal }; + if (accept && resolver.isCurrent(proposal)) { + keys = [...next]; paint(); resolver.update(measure()); + } + } }); + root.addEventListener('keydown', event => { + if (!(event.target instanceof HTMLElement) || event.key !== 'ArrowDown') return; + event.preventDefault(); + session = resolver.start(event.target.dataset.key!)!; + session?.step('down'); + session?.end(); + }); + root.addEventListener('pointerdown', event => { + if (!(event.target instanceof HTMLElement)) return; + session = resolver.start(event.target.dataset.key!)!; + }); + root.addEventListener('pointermove', event => session?.move({ x: event.clientX, y: event.clientY })); + root.addEventListener('pointerup', () => { session?.end(); session = undefined; }); + (window as any).grid = { + read: () => ({ keys: [...keys], pending: pending?.keys, current: pending && resolver.isCurrent(pending.proposal), + activeKey: resolver.activeKey, active: session?.active ?? false }), + hold: () => { accept = false; pending = undefined; }, + filter: () => { keys = ['b', 'c', 'd', 'e']; paint(); resolver.update(measure()); }, + commitPending: () => { + if (pending && resolver.isCurrent(pending.proposal)) { keys = pending.keys; paint(); resolver.update(measure()); } + }, + destroy: () => resolver.destroy(), + }; + }); + + await page.getByRole('button', { name: 'a' }).focus(); + await page.keyboard.press('ArrowDown'); + expect(await page.evaluate(() => (window as any).grid.read().keys)).toEqual(['b', 'c', 'a', 'd']); + expect(await page.evaluate(() => (document.activeElement as HTMLElement).dataset.key)).toBe('a'); + await page.evaluate(() => (window as any).grid.hold()); + const from = await page.getByRole('button', { name: 'a' }).boundingBox(); + const to = await page.getByRole('button', { name: 'd' }).boundingBox(); + expect(from).not.toBeNull(); expect(to).not.toBeNull(); + await page.mouse.move(from!.x + 20, from!.y + 20); + await page.mouse.down(); + await page.mouse.move(to!.x + 20, to!.y + 20); + expect(await page.evaluate(() => (window as any).grid.read())).toMatchObject({ + keys: ['b', 'c', 'a', 'd'], pending: ['b', 'c', 'd', 'a'], current: true, active: true, + }); + await page.evaluate(() => (window as any).grid.filter()); + await page.mouse.up(); + await page.evaluate(() => (window as any).grid.commitPending()); + expect(await page.evaluate(() => (window as any).grid.read())).toMatchObject({ + keys: ['b', 'c', 'd', 'e'], current: false, active: false, + }); + const remaining = await page.getByRole('button', { name: 'b' }).boundingBox(); + expect(remaining).not.toBeNull(); + await page.mouse.move(remaining!.x + 20, remaining!.y + 20); + await page.mouse.down(); + expect(await page.evaluate(() => (window as any).grid.read().activeKey)).toBe('b'); + await page.mouse.up(); + expect(await page.evaluate(() => (window as any).grid.read().activeKey)).toBeUndefined(); + await page.evaluate(() => (window as any).grid.destroy()); +}); diff --git a/browser/journey-live-view.spec.ts b/browser/journey-live-view.spec.ts index 811044b76..0aadb972a 100644 --- a/browser/journey-live-view.spec.ts +++ b/browser/journey-live-view.spec.ts @@ -1,13 +1,13 @@ /** * JOURNEY-01: два реальных браузерных потребителя ./smart. * Пакетный импорт отдельно запинен test/journey-package-consumers.test.ts; - * здесь собранный dist проходит настоящий DOM, фокус, ввод и визуальную C0-границу. + * здесь установленный production tarball проходит настоящий DOM, фокус, ввод и визуальную C0-границу. */ -import { expect, test } from './fixtures/harness'; +import { expect, packedJourneyTest as test } from './fixtures/harness'; test('card↔details: вложенная геометрия, перенацеливание в полёте, фокус и режимы без движения', async ({ page }) => { const result = await page.evaluate(async () => { - const { captureSmart } = await import('/dist/smart/index.js'); + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); document.body.innerHTML = `
@@ -124,7 +124,7 @@ test('card↔details: вложенная геометрия, перенацел test('panel↔source: пересоздание узла, обратный ход, повторное открытие и интерактивность', async ({ page }) => { const result = await page.evaluate(async () => { - const { captureSmart } = await import('/dist/smart/index.js'); + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); document.body.innerHTML = `
@@ -232,7 +232,7 @@ test('panel↔source: пересоздание узла, обратный ход test('движущийся элемент управления принимает настоящий указатель и клавиатуру, сохраняя фокус', async ({ page }) => { await page.evaluate(async () => { - const { captureSmart } = await import('/dist/smart/index.js'); + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); document.body.innerHTML = `
@@ -297,7 +297,7 @@ test('движущийся элемент управления принимае )).toBe(2); const focusedAtRetarget = await page.evaluate(async () => { - const { captureSmart } = await import('/dist/smart/index.js'); + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); const root = document.querySelector('#root')!; const card = document.querySelector('#card')!; const action = document.querySelector('#action')!; @@ -341,3 +341,74 @@ test('движущийся элемент управления принимае }); expect(settled).toEqual({ activations: 3, focused: true, pending: 0 }); }); + +test('card↔details: выделение и ввод в том же input переживают retarget', async ({ page }) => { + await page.evaluate(async () => { + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); + document.body.innerHTML = ` +
+
+ +
+
`; + const root = document.querySelector('#root')!; + const card = document.querySelector('#card')!; + const input = document.querySelector('#title')!; + const queue: Array<(time?: number) => void> = []; + let now = 0; + const state = { + input, + requestFrame(callback: (time?: number) => void): number { queue.push(callback); return queue.length; }, + step(): void { now += 16; for (const callback of queue.splice(0)) callback(now); }, + drain(): void { + let steps = 0; + while (queue.length) { + if (++steps > 4000) throw new Error('переход не завершился'); + state.step(); + } + }, + first: Promise.resolve(), second: Promise.resolve(), + }; + input.focus(); input.setSelectionRange(6, 10); + const first = captureSmart(root, { requestFrame: state.requestFrame, radius: false }); + card.style.cssText += ';left:80px;top:90px;width:360px;height:260px'; + state.first = first.animate().finished; + for (let i = 0; i < 4; i++) state.step(); + (window as any).__journeyInput = state; + }); + + const before = await page.evaluate(() => { + const state = (window as any).__journeyInput; + const input = document.querySelector('#title')!; + return { same: input === state.input, focused: document.activeElement === input, + start: input.selectionStart, end: input.selectionEnd, value: input.value }; + }); + expect(before).toEqual({ same: true, focused: true, start: 6, end: 10, value: 'alpha beta' }); + + const atRetarget = await page.evaluate(async () => { + const { captureSmart } = await import('/browser/.artifacts/scope-recipes.js'); + const root = document.querySelector('#root')!; + const card = document.querySelector('#card')!; + const state = (window as any).__journeyInput; + const second = captureSmart(root, { requestFrame: state.requestFrame, radius: false }); + card.style.cssText += ';left:40px;top:120px;width:420px;height:300px'; + state.second = second.animate().finished; + const input = document.querySelector('#title')!; + return { same: input === state.input, focused: document.activeElement === input, + start: input.selectionStart, end: input.selectionEnd }; + }); + expect(atRetarget).toEqual({ same: true, focused: true, start: 6, end: 10 }); + + await page.keyboard.insertText('世界'); + const result = await page.evaluate(async () => { + const state = (window as any).__journeyInput; + await state.first; + state.drain(); + await state.second; + const input = document.querySelector('#title')!; + return { same: input === state.input, focused: document.activeElement === input, + value: input.value, start: input.selectionStart, end: input.selectionEnd, + transform: document.querySelector('#card')!.style.transform }; + }); + expect(result).toEqual({ same: true, focused: true, value: 'alpha 世界', start: 8, end: 8, transform: '' }); +}); diff --git a/browser/presence-scope-resource-actual-package.spec.ts b/browser/presence-scope-resource-actual-package.spec.ts new file mode 100644 index 000000000..1cd5a5340 --- /dev/null +++ b/browser/presence-scope-resource-actual-package.spec.ts @@ -0,0 +1,201 @@ +import { createHash } from 'node:crypto'; +import { readFileSync } from 'node:fs'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { expect, test } from './fixtures/harness'; + +const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..'); +type OwnersPackage = Pick + & Pick; +type Owner = { destroy(): void }; +type DomControls = { + owners: unknown[]; + terminal: { presence: Array>; scope: Array> }; + live: { presence: WeakRef; scope: WeakRef }; + liveOwners: Owner[]; + dropped: { presence: WeakRef; scope: WeakRef }; + deliberate: WeakRef; + deliberateOwner: HTMLElement | undefined; +}; +type ResourcePage = typeof globalThis & { __presenceScopeResource?: DomControls }; + +test('RESOURCE-01: packed presence/scope освобождают реальные DOM roots при сохранённых terminal controls', async ({ page, browserName }, info) => { + test.setTimeout(120_000); + await page.emulateMedia({ reducedMotion: 'no-preference' }); + const receiptBytes = readFileSync(join(ROOT, 'browser/.artifacts/presence-scope-resource.package.json')); + const receipt = JSON.parse(receiptBytes.toString('utf8')) as { + schema: string; tarball: { sha256: string }; bundleSha256: string; + }; + const shared = JSON.parse(readFileSync(join(ROOT, 'browser/.artifacts/scope-recipes.package.json'), 'utf8')) as { + tarball: { file: string; sha256: string }; + }; + expect(receipt.schema).toBe('presence-scope-resource-package-v1'); + expect(receipt.tarball.sha256).toBe(shared.tarball.sha256); + expect(createHash('sha256').update(readFileSync(join(ROOT, 'browser/.artifacts', shared.tarball.file))).digest('hex')) + .toBe(receipt.tarball.sha256); + expect(createHash('sha256').update(readFileSync(join(ROOT, 'browser/.artifacts/presence-scope-resource.js'))).digest('hex')) + .toBe(receipt.bundleSha256); + const fetched = await page.evaluate(async ({ archive }) => { + const digest = async (path: string): Promise => { + const response = await fetch(path); + if (!response.ok) throw new Error(`resource artifact fetch failed: ${path}`); + const bytes = await response.arrayBuffer(); + return [...new Uint8Array(await crypto.subtle.digest('SHA-256', bytes))] + .map(value => value.toString(16).padStart(2, '0')).join(''); + }; + return { archive: await digest(`/browser/.artifacts/${archive}`), + bundle: await digest('/browser/.artifacts/presence-scope-resource.js') }; + }, { archive: shared.tarball.file }); + expect(fetched.archive).toBe(receipt.tarball.sha256); + expect(fetched.bundle).toBe(receipt.bundleSha256); + await info.attach('installed-package-tuple', { body: receiptBytes, contentType: 'application/json' }); + + const report = await page.evaluate(async () => { + const url = '/browser/.artifacts/presence-scope-resource.js'; + const { createAnimateScope, createPresenceTransition } = await import(url) as OwnersPackage; + const spring = Object.freeze({ mass: 1, stiffness: 170, damping: 26 }); + const timers = new Map void>(); + let timerId = 0, effects = 0, naturalCompletions = 0; + const assert = (condition: boolean, message: string): void => { if (!condition) throw new Error(message); }; + const ownTimers = () => { + const tokens = new Set(); + return { + setTimer(callback: () => void): (() => void) { + const token = ++timerId; tokens.add(token); timers.set(token, callback); + return () => { tokens.delete(token); timers.delete(token); }; + }, + finish(): void { + const pending = [...tokens].map(token => timers.get(token)!); + for (const token of tokens) timers.delete(token); + tokens.clear(); + for (const callback of pending) callback(); + }, + }; + }; + const target = (): HTMLDivElement => { + const element = document.createElement('div'); + element.style.cssText = 'opacity:0;width:20px;height:20px'; + const animate = element.animate; + element.animate = (keyframes, options) => { + effects++; + const effect = Reflect.apply(animate, element, [keyframes, options]) as Animation; + effect.pause(); effect.currentTime = 32; + assert(effect.effect instanceof KeyframeEffect && effect.effect.target === element, + 'positive control requires an actual native target/effect'); + return effect; + }; + return element; + }; + const factory = (element: HTMLElement) => () => element.animate([{ opacity: 0 }, { opacity: 1 }], + { duration: 1000, fill: 'both' }); + const completed = (root: HTMLElement) => () => { root.dataset.completed = 'yes'; naturalCompletions++; }; + const presence = (terminal: boolean) => { + const element = target(); document.body.append(element); + const phase = factory(element); + const owner = createPresenceTransition({ enter: phase, exit: phase }); + const first = owner.setPresent(true); + assert(owner.setPresent(true) === first, 'same presence target restarted its phase'); + const middle = owner.setPresent(false), pending = owner.setPresent(true); + assert(element.getAnimations().length === 1, 'healthy current presence lost native ownership'); + if (terminal) { + owner.destroy(); + assert(element.getAnimations().length === 0, 'terminal presence kept native ownership'); + } + element.remove(); + return { owner, ref: new WeakRef(element), retained: [owner, first, middle, pending], + pending: terminal ? Promise.all([first, middle, pending]).then(results => { + assert(results[0]!.status === 'superseded' && results[0]!.present, + 'native presence enter lost superseded outcome'); + assert(results[1]!.status === 'superseded' && !results[1]!.present, + 'native presence exit lost superseded outcome'); + assert(results[2]!.status === 'destroyed' && results[2]!.present, + 'native presence terminal outcome changed'); + }) : undefined }; + }; + const scope = (terminal: boolean) => { + const root = document.createElement('section'); + const elements = [target(), target(), target()]; root.append(...elements); document.body.append(root); + const owner = createAnimateScope(root); + const timer = ownTimers(); + const options = { spring, setTimer: timer.setTimer, now: () => 0, onComplete: completed(root) }; + const initial = owner.animate('div', { opacity: [0, 1] }, options); + assert(elements.every(element => element.getAnimations().length === 1), 'healthy scope is not native'); + timer.finish(); + assert(elements.every(element => element.getAnimations().length === 0), 'natural terminal kept native effects'); + const active = owner.animate(elements[0]!, { opacity: [0, .8] }, options); + const paused = owner.animate(elements[1]!, { opacity: [0, .6] }, options); paused.pause(); + const delayed = owner.animate(elements[2]!, { opacity: [0, .4] }, { ...options, delay: 1000 }); + assert(elements[0]!.getAnimations().length === 1 && elements[1]!.getAnimations().length === 0 + && elements[2]!.getAnimations().length === 1, 'current/paused/delayed ownership denominator'); + if (terminal) { + owner.destroy(); + for (const controls of [initial, active, paused, delayed]) { + controls.play(); controls.pause(); controls.seek(32); controls.cancel(); controls.stop(); + } + assert(elements.every(element => element.getAnimations().length === 0), 'terminal controls restarted native ownership'); + } + root.remove(); + return { owner, refs: [root, ...elements].map(element => new WeakRef(element)), + retained: [owner, initial, active, paused, delayed], + pending: terminal ? Promise.all([initial.finished, active.finished, paused.finished, delayed.finished]) : undefined }; + }; + const terminal: DomControls['terminal'] = { presence: [], scope: [] }; + const owners: unknown[] = []; + let cycles = 0, hostTurns = 0; + for (; cycles < 10_000; cycles++) { + const p = presence(true), s = scope(true); + terminal.presence.push(p.ref); terminal.scope.push(...s.refs); + owners.push(p.retained, s.retained); + await p.pending; await s.pending; + assert(timers.size === 0 && document.getAnimations().length === 0, 'terminal boundary kept jobs/native effects'); + if ((cycles + 1) % 100 === 0) { + await new Promise(resolve => requestAnimationFrame(() => resolve())); hostTurns++; + assert(timers.size === 0 && document.getAnimations().length === 0, 'host turn revived terminal resources'); + } + } + const livePresence = presence(false), liveScope = scope(false); + const droppedPresence = presence(true), droppedScope = scope(true); + await droppedPresence.pending; await droppedScope.pending; + const deliberate = document.createElement('div'); + (globalThis as ResourcePage).__presenceScopeResource = { + owners, terminal, + live: { presence: livePresence.ref, scope: liveScope.refs[0]! }, + liveOwners: [livePresence.owner, liveScope.owner], + dropped: { presence: droppedPresence.ref, scope: droppedScope.refs[0]! }, + deliberate: new WeakRef(deliberate), deliberateOwner: deliberate, + }; + return { cyclesPerOwner: cycles, hostTurns, effects, naturalCompletions, + terminalTargets: { presence: terminal.presence.length, scope: terminal.scope.length }, + retainedTerminalOwnerGroups: owners.length, + claim: 'actual DOM reachability only; heap/raster/GPU bytes and probabilities are not measured' }; + }); + expect(report.cyclesPerOwner).toBe(10_000); + expect(report.hostTurns).toBe(100); + expect(report.terminalTargets).toEqual({ presence: 10_000, scope: 40_000 }); + expect(report.retainedTerminalOwnerGroups).toBe(20_000); + expect(report.naturalCompletions).toBe(10_002); + const collect = async () => { + for (let round = 0; round < 4; round++) await page.requestGC(); + return page.evaluate(() => { + const refs = (globalThis as ResourcePage).__presenceScopeResource!; + const count = (list: Array>) => list.filter(ref => ref.deref() !== undefined).length; + return { terminal: { presence: count(refs.terminal.presence), scope: count(refs.terminal.scope) }, + live: { presence: Number(refs.live.presence.deref() !== undefined), scope: Number(refs.live.scope.deref() !== undefined) }, + dropped: { presence: Number(refs.dropped.presence.deref() !== undefined), scope: Number(refs.dropped.scope.deref() !== undefined) }, + deliberate: Number(refs.deliberate.deref() !== undefined) }; + }); + }; + const beforeRelease = await collect(); + expect(beforeRelease).toEqual({ terminal: { presence: 0, scope: 0 }, live: { presence: 1, scope: 1 }, + dropped: { presence: 0, scope: 0 }, deliberate: 1 }); + await page.evaluate(() => { + const refs = (globalThis as ResourcePage).__presenceScopeResource!; + for (const owner of refs.liveOwners) owner.destroy(); + refs.deliberateOwner = undefined; + }); + const afterRelease = await collect(); + expect(afterRelease).toEqual({ terminal: { presence: 0, scope: 0 }, live: { presence: 0, scope: 0 }, + dropped: { presence: 0, scope: 0 }, deliberate: 0 }); + await info.attach('resource-presence-scope-dom', { body: JSON.stringify({ browserName, ...report, + beforeRelease, afterRelease }, null, 2), contentType: 'application/json' }); +}); diff --git a/browser/presence-transition.spec.ts b/browser/presence-transition.spec.ts index 5b42d613e..b77bcb1f7 100644 --- a/browser/presence-transition.spec.ts +++ b/browser/presence-transition.spec.ts @@ -1,25 +1,15 @@ -import { readFileSync } from 'node:fs'; -import { transformSync } from 'esbuild'; -import { test, expect } from './fixtures/harness'; +import { packedJourneyTest as test, expect } from './fixtures/harness'; -const docs = readFileSync(new URL('../docs/recipes.md', import.meta.url), 'utf8'); -const recipe = docs.match(/```typescript\n([^`]*?export function bindAnimatedDialog[^]*?)\n```/)?.[1]; -if (!recipe) throw new Error('Рабочий рецепт отсутствует'); -const code = transformSync(recipe, { loader: 'ts', format: 'esm', target: 'es2022' }).code; - -// Исполняется буквальный пример документации, не его копия в test fixture. +// Буквальный пример и runtime взяты из полного production tarball globalSetup. async function mount(page: import('@playwright/test').Page) { - await page.evaluate(async source => { + await page.evaluate(async () => { document.body.innerHTML = '
'; const opener = document.querySelector('#open')!; opener.focus(); - const text = source.replaceAll('@labpics/motion/animate', location.origin + '/dist/animate/index.js') - .replaceAll('@labpics/motion/presence', location.origin + '/dist/presence/index.js'); - const url = URL.createObjectURL(new Blob([text], { type: 'text/javascript' })); - const module = await import(url); URL.revokeObjectURL(url); + const module = await import('/browser/.artifacts/scope-recipes.js'); const dialog = document.querySelector('dialog')!; (window as unknown as { binding: Binding }).binding = module.bindAnimatedDialog(dialog); - }, code); + }); } interface Binding { setPresent(value: boolean): Promise; @@ -86,7 +76,7 @@ test('повторное открытие не скрывает диалог п test('вся группа native Animation завершена прежде onGone, не первый элемент', async ({ page }) => { const result = await page.evaluate(async () => { - const { createPresenceTransition } = await import('/dist/presence/index.js'); + const { createPresenceTransition } = await import('/browser/.artifacts/scope-recipes.js'); const a = document.createElement('div'), b = document.createElement('div'); document.body.append(a, b); let gone = 0; const effects = [a, b].map(el => el.animate({ opacity: [1, 0] }, { duration: 10_000, fill: 'both' })); @@ -106,8 +96,7 @@ test('вся группа native Animation завершена прежде onGon test('native pickup равен прямому animate, cancel-before-start является различителем', async ({ page }) => { const result = await page.evaluate(async () => { - const { createPresenceTransition } = await import('/dist/presence/index.js'); - const { animate } = await import('/dist/animate/index.js'); + const { createPresenceTransition, animate } = await import('/browser/.artifacts/scope-recipes.js'); const els = [0, 1, 2].map(() => { const el = document.createElement('div'); document.body.append(el); return el; }); const [managed, raw, wrong] = els as [HTMLDivElement, HTMLDivElement, HTMLDivElement]; const options = { spring: { mass: 1, stiffness: 170, damping: 20 }, now: () => 0 }; diff --git a/browser/reorder.spec.ts b/browser/reorder.spec.ts index 7895585f2..f6b4654b8 100644 --- a/browser/reorder.spec.ts +++ b/browser/reorder.spec.ts @@ -1,4 +1,4 @@ -import { expect, test } from './fixtures/harness'; +import { expect, packedJourneyTest as test } from './fixtures/harness'; import type { Page } from '@playwright/test'; async function mount(page: Page, grid = false, rtl = false): Promise { @@ -9,13 +9,38 @@ async function mount(page: Page, grid = false, rtl = false): Promise {
    ${['a', 'b', 'c', 'd'].map(key => `
    • `).join('')}

  • Другой компонент
`); await page.evaluate(async () => { // Артефакт globalSetup построен из буквального кода docs/recipes.md. - // @ts-expect-error generated browser-only fixture - const { mountReorder } = await import('/browser/.artifacts/reorder-recipe.js'); - (window as unknown as { cleanup: () => void }).cleanup = mountReorder(document.getElementById('list'), document.getElementById('status')); + const { mountReorder } = await import('/browser/.artifacts/scope-recipes.js'); + (window as unknown as { cleanup: () => void }).cleanup = mountReorder(document.getElementById('list')!, document.getElementById('status')!); }); } const order = (page: Page) => page.locator('#list > li').evaluateAll(nodes => nodes.map(n => (n as HTMLElement).dataset.key)); +for (const scope of ['ancestor', 'root'] as const) test(`data-move на ${scope} не управляет дочерней карточкой`, async ({ page }) => { + await mount(page); + await page.evaluate(scope => { + const root = document.getElementById('list')!; + const outer = scope === 'root' ? root : document.createElement('div'); + if (outer !== root) { root.before(outer); outer.append(root); } + outer.dataset.move = 'next'; outer.tabIndex = -1; + const label = document.createElement('span'); label.id = 'plain-label'; label.textContent = 'Название'; + root.querySelector('[data-key=b] .reorder-card')!.append(label); + const actionLabel = document.createElement('span'); actionLabel.id = 'action-label'; actionLabel.textContent = 'Переместить'; + root.querySelector('[data-key=b] [data-move=next]')!.append(actionLabel); + }, scope); + const focused = page.locator('[data-key=c] [data-grip]'); + await focused.focus(); + // Только обработчик клика: нативный pointer focus не должен скрыть его эффект. + await page.locator('#plain-label').dispatchEvent('click'); + expect(await order(page)).toEqual(['a', 'b', 'c', 'd']); + await expect(focused).toBeFocused(); + await expect(page.locator('#status')).toHaveText(''); + + await page.locator('#action-label').click(); + expect(await order(page)).toEqual(['a', 'c', 'b', 'd']); + await expect(page.locator('[data-key=b] [data-move=next]')).toBeFocused(); + await expect(page.locator('#status')).toHaveText('b: 3 из 4'); +}); + test('реальный pointer reorder: scoped list, подтверждённый DOM, focus и cleanup', async ({ page }) => { await mount(page); const first = await page.locator('[data-key=a] [data-grip]').boundingBox(); @@ -86,9 +111,9 @@ test('повторная перестановка mid-flight сохраняет expect(result.afterCleanup).toEqual(result.clean); }); -test('actual dist: no rAF/listener в headless resolver; stale proposal после внешнего snapshot', async ({ page }) => { +test('actual tarball: no rAF/listener в headless resolver; stale proposal после внешнего snapshot', async ({ page }) => { const result = await page.evaluate(async () => { - const { createReorder } = await import('/dist/behaviors/reorder/index.js'); + const { createReorder } = await import('/browser/.artifacts/scope-recipes.js'); let calls = 0, raf = 0; const original = window.requestAnimationFrame; window.requestAnimationFrame = cb => { raf++; return original(cb); }; const rect = (y: number) => ({ x: 0, y, width: 10, height: 10 }); diff --git a/browser/resource-actual-package.spec.ts b/browser/resource-actual-package.spec.ts new file mode 100644 index 000000000..8f874e055 --- /dev/null +++ b/browser/resource-actual-package.spec.ts @@ -0,0 +1,214 @@ +import { readFileSync } from 'node:fs'; +import { createHash } from 'node:crypto'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { expect, test } from './fixtures/harness'; + +const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..'); +type CompositorPackage = Pick; +type ResourceReachability = { + terminal: Array>; + live: WeakRef; + dropped: WeakRef; + droppedOwner: WeakRef>; + deliberate: WeakRef; + liveOwner: InstanceType; + deliberateOwner: HTMLElement | undefined; +}; +type ResourcePage = typeof globalThis & { + __resourceTerminalOwners?: unknown[]; + __resourceReachability?: ResourceReachability; +}; + +test('RESOURCE-01: 10 000 native/live/serialized циклов фактического tarball освобождают Animation, jobs и DOM-цели', async ({ page, browserName }, info) => { + test.setTimeout(90_000); + await page.emulateMedia({ reducedMotion: 'no-preference' }); + const tuple = readFileSync(join(ROOT, 'browser/.artifacts/scope-recipes.package.json')); + const manifest = JSON.parse(tuple.toString('utf8')) as { + schema: string; tarball: { sha256: string }; bundleSha256: string; + }; + expect(manifest.schema).toBe('scope-recipes-package-v1'); + expect(manifest.tarball.sha256).toMatch(/^[0-9a-f]{64}$/); + expect(createHash('sha256').update(readFileSync(join(ROOT, 'browser/.artifacts/scope-recipes.js'))).digest('hex')) + .toBe(manifest.bundleSha256); + await info.attach('installed-package-tuple', { body: tuple, contentType: 'application/json' }); + + const report = await page.evaluate(async () => { + const moduleUrl = '/browser/.artifacts/scope-recipes.js'; + const { CompositorSpring } = await import(moduleUrl) as CompositorPackage; + const spring = Object.freeze({ mass: 1, stiffness: 170, damping: 26 }); + const queue: Array<(timestamp?: number) => void> = []; + let now = 0, requests = 0, writes = 0, createdEffects = 0; + const requestFrame = (callback: (timestamp?: number) => void): number => { + queue.push(callback); return ++requests; + }; + const step = (): void => { + now += 16; + const batch = queue.splice(0); + for (const callback of batch) callback(now); + }; + const assert = (condition: boolean, message: string): void => { + if (!condition) throw new Error(message); + }; + const target = (): HTMLDivElement => { + const element = document.createElement('div'); + element.style.cssText = 'width:20px;height:20px;opacity:0'; + const animate = element.animate; + element.animate = (keyframes, options): Animation => { + createdEffects++; + // Монитор считает реальные Animation, сохраняет native receiver и не + // хранит history handles/targets. Замены исполнителя здесь нет. + return Reflect.apply(animate, element, [keyframes, options]) as Animation; + }; + document.body.append(element); + return element; + }; + const owner = (element: HTMLElement) => new CompositorSpring({ + spring, property: 'opacity', from: 0, to: 1, target: element, + apply(value) { writes++; element.style.opacity = String(value); }, + requestFrame, now: () => now, + matchMedia: query => window.matchMedia(query), + }); + const animation = (element: HTMLElement): number => { + const effects = element.getAnimations(); + assert(effects.length === 1, 'одна поверхность должна иметь один native effect'); + const effect = effects[0]!; + assert(effect.effect instanceof KeyframeEffect && effect.effect.target === element, + 'Animation должен принадлежать исследуемой поверхности'); + effect.pause(); effect.currentTime = 32; + return effects.length; + }; + + assert(document.getAnimations().length === 0, 'стенд не начал с пустого native ownership'); + const liveTarget = target(), live = owner(liveTarget); + live.start(); animation(liveTarget); + assert(live.mode === 'compositor', 'положительный native control недоступен'); + const deliberateTarget = target(); + const deliberate = deliberateTarget.animate([{ opacity: 0 }, { opacity: 1 }], { duration: 1000, fill: 'both' }); + deliberate.pause(); deliberate.currentTime = 32; + assert(document.getAnimations().length === 2, 'deliberate/live controls не различаются'); + assert(requests === 0 && queue.length === 0, 'автономные controls создали собственный frame'); + + const retained = []; + const terminal: Array> = []; + let cycles = 0, hostTurns = 0; + let maximumCycleEffects = 0; + const beforeEffects = createdEffects; + for (let cycle = 0; cycle < 10_000; cycle++) { + const element = target(); + terminal.push(new WeakRef(element)); + const controller = owner(element); + const beforeNative = requests; + controller.start(); animation(element); + assert(controller.mode === 'compositor', 'нативный участок не принят'); + controller.retarget(0.8); const retargetEffectCount = animation(element); + assert(requests === beforeNative && queue.length === 0, 'native start/retarget создал собственный frame'); + // Число измерено при native commit; pause/currentTime семплируют тот же Animation. + maximumCycleEffects = Math.max(maximumCycleEffects, retargetEffectCount); + + const dynamic = controller.handoffToLive(0.6); + assert(element.getAnimations().length === 0, 'native donor не отменён после live commit'); + assert(queue.length > 0, 'живой положительный контроль не запросил frame'); + step(); dynamic.setTarget(0.5); step(); + controller.handoffToCompositor(0.7); animation(element); + assert(controller.mode === 'compositor', 'serialized successor не принят'); + const beforeDonor = writes; + dynamic.setTarget(0.1); step(); + assert(writes === beforeDonor && queue.length === 0, 'переданный live donor продолжает работу'); + + controller.destroy(); controller.destroy(); + const beforeTerminal = { writes, requests }; + // Contract RequestFrameFn не имеет cancel handle: единственный уже + // выданный host batch дрейнится, затем jobs должны физически отсутствовать. + step(); controller.start(); controller.retarget(1); + assert(writes === beforeTerminal.writes && requests === beforeTerminal.requests, + 'terminal controller воскресил writer/scheduler'); + assert(queue.length === 0 && element.getAnimations().length === 0, + 'terminal boundary оставила job/native effect'); + element.remove(); + retained.push(controller, dynamic); + cycles++; + if (cycles % 500 === 0) { + // Как в Node-стенде, серия заканчивается ходом хоста для отложенной + // очистки. Сразу после него проверяются прежние terminal-обязательства. + const beforeTurn = { writes, requests, createdEffects }; + await new Promise(resolve => requestAnimationFrame(() => resolve())); + hostTurns++; + assert(writes === beforeTurn.writes && requests === beforeTurn.requests, + 'после хода хоста terminal owner восстановил writer/scheduler'); + assert(createdEffects === beforeTurn.createdEffects, + 'после хода хоста terminal owner создал native effect'); + assert(queue.length === 0 && document.getAnimations().length === 2, + 'после хода хоста потерян control либо остался native/job owner'); + } + } + const observedCycleEffects = createdEffects - beforeEffects; + assert(observedCycleEffects === cycles * 3, 'неполный знаменатель start/retarget/serialized commit'); + const beforeRelease = document.getAnimations().length; + assert(beforeRelease === 2, 'живые controls были потеряны либо terminal effects остались'); + live.destroy(); liveTarget.remove(); + const deliberateRemaining = document.getAnimations().length; + assert(deliberateRemaining === 1, 'deliberate effect не обнаруживается отдельно от live owner'); + deliberate.cancel(); deliberateTarget.remove(); + const releasedRemaining = document.getAnimations().length; + assert(releasedRemaining === 0, 'контрольное native ownership не освобождено'); + (globalThis as ResourcePage).__resourceTerminalOwners = retained; + // Все цели detached: document не подменяет сильное владение библиотеки. + // Живой controller удерживается, затем destroy проверяется на том же root. + const liveDom = target(); + liveDom.remove(); + const deliberateDom = document.createElement('div'); + const droppedDom = document.createElement('div'); + const droppedOwner = owner(droppedDom); + (globalThis as ResourcePage).__resourceReachability = { + terminal, + live: new WeakRef(liveDom), liveOwner: owner(liveDom), + dropped: new WeakRef(droppedDom), droppedOwner: new WeakRef(droppedOwner), + deliberate: new WeakRef(deliberateDom), deliberateOwner: deliberateDom, + }; + + return { cycles, hostTurns, observedCycleEffects, maximumCycleEffects, retainedTerminalOwners: retained.length, + terminalAnimations: document.getAnimations().length, terminalJobs: queue.length, + controls: { beforeRelease, afterLiveRelease: deliberateRemaining, afterRelease: releasedRemaining }, + memory: { rasterGpu: 'не измерены: DOM Animation ownership не является GPU byte-измерением' } }; + }); + await info.attach('resource-native-ownership', { + body: JSON.stringify({ browserName, ...report }, null, 2), contentType: 'application/json', + }); + expect(report.cycles).toBe(10_000); + expect(report.hostTurns).toBe(20); + expect(report.observedCycleEffects).toBe(30_000); + expect(report.maximumCycleEffects).toBe(1); + expect(report.retainedTerminalOwners).toBe(20_000); + expect(report.terminalAnimations).toBe(0); + expect(report.terminalJobs).toBe(0); + + const collect = async () => { + // GC — отдельная проверка достижимости после возврата browser job; + // число собранных объектов не превращается в heap/raster/GPU bytes. + for (let round = 0; round < 4; round++) await page.requestGC(); + return page.evaluate(() => { + const refs = (globalThis as ResourcePage).__resourceReachability!; + return { + observedTargets: refs.terminal.length, + terminal: refs.terminal.filter(ref => ref.deref() !== undefined).length, + live: Number(refs.live.deref() !== undefined), + dropped: Number(refs.dropped.deref() !== undefined), + droppedOwner: Number(refs.droppedOwner.deref() !== undefined), + deliberate: Number(refs.deliberate.deref() !== undefined), + }; + }); + }; + const beforeRelease = await collect(); + expect(beforeRelease).toEqual({ observedTargets: 10_000, terminal: 0, live: 1, dropped: 0, droppedOwner: 0, deliberate: 1 }); + await page.evaluate(() => { + const refs = (globalThis as ResourcePage).__resourceReachability!; + refs.liveOwner.destroy(); + refs.deliberateOwner = undefined; + }); + const afterRelease = await collect(); + expect(afterRelease).toEqual({ observedTargets: 10_000, terminal: 0, live: 0, dropped: 0, droppedOwner: 0, deliberate: 0 }); + await info.attach('resource-dom-reachability', { + body: JSON.stringify({ browserName, beforeRelease, afterRelease }, null, 2), contentType: 'application/json', + }); +}); diff --git a/docs/NAMING.md b/docs/NAMING.md index 386ace788..0dee444f2 100644 --- a/docs/NAMING.md +++ b/docs/NAMING.md @@ -11,7 +11,7 @@ | Метрика | N | | --- | --- | -| экспорт-субпутей package.json | 44 | +| экспорт-субпутей package.json | 45 | | фреймворк-биндингов | 9 | | CSS-литералов `--lab-motion-*` в src | 0 | | CSS-литералов вне `--lab-motion-*` в src | 0 | @@ -71,10 +71,9 @@ | Группа | Субпути | | --- | --- | -| Ядро анимации | `./nano` (platform-trusted WAAPI, ≤1 KB), `./animate` (основной продуктовый вход), `./frame`, `./driver`, `./compositor`, `./compositor/stagger`, `./waapi`, `./auto` | +| Ядро анимации | `./nano` (platform-trusted WAAPI, ≤1 KB), `./animate` (основной продуктовый вход), `./frame`, `./driver`, `./compositor`, `./compositor/stagger`, `./compositor/follow`, `./waapi`, `./auto` | | Значения и физика | `./value`, `./spring`, `./decay`, `./easing`, `./keyframes`, `./stagger`, `./timeline`, `./presets`, `./tokens`, `./utils` | -| Доменные эффекты | `./flip`, `./projection`, `./smart`, `./gestures`, `./behaviors`, `./behaviors/reorder`, `./scroll`, `./in-view`, `./presence`, `./svg`, `./svg-morph`, `./a11y`, `./compiler/surface` (приватный executor compiled-поверхности, ≤1 KB gz) | -| Доменные эффекты | `./bindings`, `./flip`, `./projection`, `./smart`, `./gestures`, `./behaviors`, `./scroll`, `./in-view`, `./presence`, `./svg`, `./svg-morph`, `./a11y`, `./compiler/surface` (приватный executor compiled-поверхности, ≤1 KB gz) | +| Доменные эффекты | `./bindings`, `./flip`, `./projection`, `./smart`, `./gestures`, `./behaviors`, `./behaviors/reorder`, `./scroll`, `./in-view`, `./presence`, `./svg`, `./svg-morph`, `./a11y`, `./compiler/surface` (приватный executor compiled-поверхности, ≤1 KB gz) | | Биндинги (9) | `./react`, `./svelte`, `./vue`, `./lit`, `./solid`, `./preact`, `./angular`, `./wc`, `./qwik` | | Build-tool (не runtime-tier) | `./compiler/vite` (Vite-адаптер lowering), `./compiler/runtime` (private executor compiled-вызовов) | diff --git a/docs/api.md b/docs/api.md index 7640e5ecf..fa70bfe9a 100644 --- a/docs/api.md +++ b/docs/api.md @@ -143,6 +143,7 @@ await moves.finished; | `…/waapi` | Низкоуровневый native-мост: `compileWaapi`/`animateWaapi`; `animateScrollWaapi`/`animateViewWaapi` отдают scroll/view-progress → property нативным progress timelines без собственного покадрового JS и без скрытого fallback; capability probes явные | | `…/compositor` | Базовый compositor-компилятор: `compileSpringLinear`, `compileSpringPlan`, `CompositorSpring`, ретаргет, хендофф и fallback-матрица. Подробно — [compositor.md](compositor.md) | | `…/compositor/stagger` | Самодостаточный групповой compositor-фасад: `compileStaggerPlan`, `CompositorStaggerGroup` и связанные `compileSpringPlan`/`CompositorSpring` из одного entry | +| `…/compositor/follow` | Прямое следование за вводом, нативная доводка и повторный перехват: `createCompositorFollow`; `compileSpringPlan` для того же графа зависимостей потребителя | | `…/tokens` | Motion-токены: `duration`, `easing`, `spring`, `staggerGap`, `distanceScale`. Подробно — [tokens.md](tokens.md) | ## Build-tool @@ -159,7 +160,10 @@ await moves.finished; перенаправляет существующее значение из последней опубликованной пары `value`/`velocity`, сохраняя временную координату этого снимка. Следующий кадр учитывает уже прошедший интервал; поток новых целей перед каждым кадром не -останавливает движение. На самой границе `setTarget` значение и скорость не меняются. +останавливает движение. При таком перенаправлении на самой границе `setTarget` +значение и скорость не меняются. Исключение — возврат к уже достигнутому значению +при `|velocity| < 1e-10`: он завершает движение и обнуляет остаточную скорость +без дополнительного `onChange`. Повтор активной цели — no-op. Несколько разных целей между кадрами не эмитят промежуточные значения и не планируют дополнительные callbacks: действует последняя. @@ -189,6 +193,11 @@ Peer-фреймворк ставит потребитель; все биндин | `…/lit` | `MotionController` (ReactiveController), `LabMotionSpringElement` | | `…/wc` | Vanilla web-component `` без зависимостей — путь для Astro/Stencil/HTML-first стеков | +В Vue 3.2+ `useSpring` и `useMotionValue` освобождают движение при остановке +текущего `effectScope`, включая scope компонента. В Vue 3.0/3.1 уборка происходит +при unmount. Для `useMotionValue` вне scope нужно явно вызвать `destroy()`; +`useSpring` вызывается внутри scope или `setup()` компонента. + ## Ошибки ```typescript diff --git a/docs/behaviors.md b/docs/behaviors.md index 7d2cc3193..ba00d8b75 100644 --- a/docs/behaviors.md +++ b/docs/behaviors.md @@ -17,6 +17,12 @@ ## Четыре поведения +`createBottomSheet`, `createDragDismiss`, `createCarousel` и +`createPullToRefresh` сохраняются как ранее опубликованная совместимая +поверхность. Новые фабрики компонентов сюда не добавляются. Для нового интерфейса +используйте универсальный [контроллер следования](compositor.md) и локальную +политику компонента из [рецептов](recipes.md#прямой-ввод-панель-и-карусель). + - **`createBottomSheet`** — snap-точки, rubber-band за крайними snap, программный `snapTo(index)`, перехват новым pointer-down; `update(snapPoints)` меняет живые ограничения внутри того же владельца без сброса позиции/скорости. diff --git a/docs/compositor.md b/docs/compositor.md index 46c4d6dad..97b833f23 100644 --- a/docs/compositor.md +++ b/docs/compositor.md @@ -38,11 +38,62 @@ document.querySelector('.card')! ## CompositorSpring: ретаргет и хендофф -Публичный API один на всех тирах. В effect-space numeric/affine-канала при -default `fill:'both'` прерывание точно продолжает position и правый slope -кусочно-линейного сегмента. На самом stop-kink производная неоднозначна — выбран -правый сегмент. Это не обещание rendered-pixel C¹ для clamping, non-affine -`format`, меняющегося underlying/composite или custom fill вне active interval. +Для повторяемого цикла ввода доступен `createCompositorFollow` из +`@labpics/motion/compositor/follow`. Функция создаёт один пружинный контроллер +с методами `CompositorSpring` и тремя операциями ввода: + +```typescript +import { createCompositorFollow } from '@labpics/motion/compositor/follow'; + +const motion = createCompositorFollow({ + spring: { mass: 1, stiffness: 170, damping: 26 }, + property: 'transform', from: 0, to: 240, target: el, + format: (x) => `translateX(${x}px)`, + apply: (value) => { el.style.transform = String(value); }, +}); +motion.start(); +const origin = motion.beginFollow(pointerDown.timeStamp / 1000); +motion.follow(origin + pointerDelta, pointerMove.timeStamp / 1000); +motion.settle(destination, pointerUp.timeStamp / 1000); +``` + +`beginFollow` читает значение и правую производную нативного эффекта, записывает базовое значение свойства +перед отменой эффекта и возвращает значение для преобразования координат. +`follow` пишет абсолютное значение в единицах `from`/`to`. Значения и отметки времени +конечны; время внутри сессии не убывает. Повторная точка с тем же временем +заменяет предыдущую. `settle` требует время отпускания: удержание без движения +погашает устаревшую скорость, немедленное повторное отпускание наследует её. +Произвольный скачок входного значения не имеет гарантии C¹. + +Каждый следующий захват снова читает исполняемый нативный эффект; новый rAF для +захвата и доводки нативной анимации не нужен. Непредставимый нормализованный импульс +переводит движение на прежний путь с rAF. Режим без движения сохраняет прямой ввод +и завершает `settle` немедленной записью цели. `apply` обязателен для `beginFollow`. +Без активной сессии `follow`/`settle` дают `MotionParamError`; `stop` отзывает сессию, +а `destroy` окончательно завершает контроллер. `start`/`retarget` используют текущую +отслеживаемую скорость без новой точки; для учёта времени удержания вызывайте `settle`. +`handoffToLive` передаёт то же состояние живой пружине. + +Ошибка `format`/`apply` при захвате нативной анимации оставляет прежнего владельца, +если обработчик не выдал новое намерение. При захвате живого значения старые +обработчики отзываются до записи; её ошибка оставляет `MotionValue` остановленным, +а `retarget` может продолжить его. Уже выполненная внешняя запись не откатывается. +Ошибки отмены у среды исполнения сохраняют прежний контракт `CompositorSpring`: +после логического отсоединения они поглощаются. + +Трекер хранит точки окна 0,1 секунды и последнюю пару при редких событиях. +Память зависит от плотности различных отметок времени; жёсткого предела числа точек нет. +Положения доводки, страницы, захват указателя и фокус принадлежат приложению — +[два исполняемых рецепта](recipes.md#прямой-ввод-панель-и-карусель). + +### Автономный контроллер + +Публичный API один на всех тирах. В координатах числового или аффинного канала эффекта +при стандартном `fill:'both'` прерывание точно продолжает положение и правую производную +кусочно-линейного сегмента. В точке излома производная неоднозначна — выбран правый +сегмент. Это не обещание C¹ экранных пикселей при ограничении диапазона, неаффинном +`format`, изменении базового значения или способа композиции, а также при нестандартном +`fill` вне активного интервала. ```typescript import { CompositorSpring } from '@labpics/motion/compositor'; @@ -62,8 +113,35 @@ panel.retarget(120); // значение — follow-фаза). Снимок → живая rAF-пружина продолжает без разрыва. const live = panel.handoffToLive(); // продолжить к текущей цели, ИЛИ const live2 = panel.handoffToLive(300); // сразу к новой цели с сохранённой скоростью + +// Follow обновляет уже выданное live-значение; анимации WAAPI на вводе не создаются. +live2.setTarget(260); +// На release та же пара value/velocity возвращается в автономный путь. +panel.handoffToCompositor(240); +// Старый live2 после успешной передачи инертен. Уборка всего движения одна: +panel.destroy(); ``` +`handoffToCompositor(target?)` завершает фазу живого управления. Контроллер читает +позицию и скорость существующего `MotionValue`, создаёт один нативный эффект +и лишь после принятия этого эффекта уничтожает прежнего живого владельца. Выданный ранее +`MotionValue` затем не записывает значения и не планирует новые кадры. +Если среда исполнения отвергнет новый эффект до передачи владения, прежний живой +владелец остаётся управляемым. Новое намерение при повторном входе отзывает +возвращающийся устаревший эффект. + +Путь по-прежнему определяется возможностями среды. В режиме rAF или без движения, +а также при непредставимом сериализованном импульсе движение продолжает тот же живой +владелец; `.mode` показывает фактическое представление. Нативная анимация после +отпускания не вызывает собственных покадровых обработчиков. Ранее выданный обработчик +rAF исполняется один раз без эффекта: `RequestFrameFn` не предоставляет способ отмены. +Нативное `currentTime:null` сохраняет исходную пару положения и скорости передачи +до первого доступного времени; часы JavaScript её не заменяют. + +Положения панели, индекс страницы, границы и правила клавиатурного управления +принадлежат потребителю. Обратная передача владения не добавляет их в общий +compositor API и не меняет четыре опубликованных контроллера поведения без UI. + Число raw diagnostic-узлов выводится из бюджета реконструкции (допуск `DEFAULT_TOLERANCE`, адаптивная сетка + упрощение): жёстче пружина — короче кривая. Один exact-key bounded LRU хранит execution artifact `{ linear(), @@ -118,6 +196,10 @@ list.start(); // каскад: N Element.animate ## Fallback-матрица +Матрица предполагает поддержанную JavaScript-среду ES2022 со встроенным +`WeakRef`. Выбор запасного пути компенсирует отсутствие WAAPI или CSS +`linear()`, но не отсутствие обязательных возможностей JavaScript. + `CompositorSpring` прозрачно деградирует: публичный API один, точная effect-space гарантия ограничена условиями выше — меняется движок под капотом. Тир определяется возможностями один раз в конструкторе; отдельно форма diff --git a/docs/errors.md b/docs/errors.md index 0536e0127..f2ebbe801 100644 --- a/docs/errors.md +++ b/docs/errors.md @@ -195,3 +195,6 @@ | `LM179` | semantic binding | Некорректный рецепт, карта портов или возвращённый ресурс | Передать функцию проекции, непустую карту функций и controls с cancel либо void | active | | `LM180` | semantic binding goals | Неполный или изменившийся набор ролей/свойств, неконечное число/неподдерживаемый тип цели либо превышение суммарного предела 10 000 ролей и свойств | Вернуть стабильную карту абсолютных конечных чисел и строк | active | | `LM181` | semantic binding projection | Реентрантный update во время вычисления целей | Сделать проекцию чистой; менять модель вне проекции | active | +| `LM182` | compositor follow | Отсутствует writer прямого ввода | Передать apply до beginFollow | active | +| `LM183` | compositor follow | Неконечный или убывающий timestamp | Передать конечное неубывающее время в секундах | active | +| `LM184` | compositor follow | Нет активной сессии прямого ввода | Вызвать beginFollow перед follow или settle | active | diff --git a/docs/migration.md b/docs/migration.md index b83da35a5..da98a53bf 100644 --- a/docs/migration.md +++ b/docs/migration.md @@ -79,8 +79,10 @@ geometry. Для pointer/keyboard + layout используйте [провер ## Обновление непрерывного слежения MotionValue При `setTarget` в полёте больше нет дополнительного кадра с остановленными часами. -`value` и `velocity` на самой границе остаются прежними; следующий timestamp -продолжает движение от времени этого snapshot. Повтор неизменной активной цели +При обычном перенаправлении `value` и `velocity` на самой границе остаются прежними; +следующий timestamp продолжает движение от времени этого snapshot. Возврат к уже +достигнутому значению при `|velocity| < 1e-10` завершает движение и обнуляет +остаточную скорость без дополнительного `onChange`. Повтор неизменной активной цели теперь сохраняет текущую траекторию. Код, намеренно перезапускавший движение через повтор `setTarget(sameTarget)`, должен явно выполнить `stop()` перед новым запуском. Не используйте повтор цели как способ задерживать движение на кадр. diff --git a/docs/motion-conformance.md b/docs/motion-conformance.md index 1340ec81c..ade4a46fc 100644 --- a/docs/motion-conformance.md +++ b/docs/motion-conformance.md @@ -82,6 +82,43 @@ x(t) = target + [(from − target) + (v + 10(from − target))t] exp(−10t) для всех допустимых параметров библиотеки. Browser-проверки наблюдают DOM при управляемом `Animation.currentTime`; S5 наблюдает скринкаст-пиксели. +## Шесть потребителей одного пакета + +Браузерные проверки живых представлений, коллекций и непосредственного управления +исполняют публичные экспорты установленного архива. `globalSetup` создаёт один tgz +или принимает его через `LAB_MOTION_TARBALL`; этот же архив обслуживает рецепты +`smart`, `presence`, `reorder` и compositor. Исходники рецептов читаются из упакованной +документации. Сборка отклоняет импорты из `src`/`dist` рабочего дерева. + +| Потребитель | Проверка и наблюдаемый результат | +|---|---| +| Карточка ↔ подробности | `browser/journey-live-view.spec.ts`: вложенная геометрия, прерывание, то же поле ввода и выделение, ввод указателем и клавиатурой, конечный DOM | +| Панель ↔ источник | Тот же файл: устойчивый ключ при пересоздании, обратный ход и повторное открытие; `browser/presence-transition.spec.ts`: нативный диалог, Escape и передача фокуса | +| Изменяемый список | `browser/reorder.spec.ts`: указатель и клавиатура, фиксация порядка приложением, фокус, отзыв устаревшего предложения и очистка | +| Сетка | `browser/journey-grid.spec.ts`: подтверждение приложения, свежая 2D-геометрия, фильтр/вставка и отзыв отложенного предложения от указателя; `browser/reorder.spec.ts`: RTL/LTR и режим без движения | +| Панель | `browser/compositor-recipes.spec.ts`: слежение за вводом, нативная анимация после отпускания, новый ввод, изменение размера, клавиатура и режим без движения | +| Карусель | Тот же файл: отдельное состояние страницы, перехват, RTL, изменяемые границы и эквивалентное управление клавиатурой | + +Перед каждым результатом стенд читает реальные HTTP-байты архива и браузерных +сборок, проверяет хеш и целостность, побайтово сравнивает оба прочитанных архива +и прикладывает `journey-package-tuple` с версией браузера. Полученный архив всегда +сверяется с локальными байтами `globalSetup`, включая `PW_REUSE_SERVER=1`; +при заданном архиве дополнительно проверяется его локальный SHA-256. Квитанция об успехе +без соответствующих полученных байтов не проходит. `motionInputSha256` фиксирует файлы +исполняемого кода, действительно включённые сборщиком в потребителя. + +Прогон после `pnpm site:build` (он также собирает пакет): + +```sh +pnpm exec playwright test browser/journey-live-view.spec.ts browser/journey-grid.spec.ts browser/reorder.spec.ts browser/presence-transition.spec.ts browser/compositor-recipes.spec.ts browser/compositor-follow.spec.ts +``` + +Для проверки уже созданного кандидата выпуска задайте `LAB_MOTION_TARBALL` его +абсолютным путём. Артефакты остаются в `browser/.artifacts`, а квитанция каждого +результата — во вложении Playwright. Эти законченные сценарии потребителей не доказывают +использование в production, удобство разработки в исследовании с людьми или соблюдение +физических бюджетов CPU, GPU и времени кадра. + ## Непокрываемые свойства Эти проверки не являются доказательством всей программы в proof assistant. diff --git a/docs/recipes.md b/docs/recipes.md index be6d29f8d..a38672460 100644 --- a/docs/recipes.md +++ b/docs/recipes.md @@ -1,8 +1,8 @@ # Рецепты @labpics/motion -> Роль: практика — runnable-рецепты интеграции: связка с DOM-событиями и -> композиция субпутей. Концепты и контракты каждого пути — в -> [справочнике API](api.md) и топик-доках ([compositor.md](compositor.md), +> Роль: практика — исполняемые примеры интеграции с DOM и композиции субпутей. +> Контракты — в [справочнике API](api.md) и тематических документах +> ([compositor.md](compositor.md), > [projection.md](projection.md), [smart.md](smart.md), > [behaviors.md](behaviors.md)). @@ -43,6 +43,7 @@ function dispose() { приведите координаты указателя к исходной позиции карточки один раз на границе измерения; не вызывайте `getBoundingClientRect()` на каждом событии без необходимости. `destroy()` останавливает эффект, но не отменяет внешние CSS-изменения приложения. + ## Карточка загрузки: одна модель, разные движения Приложение владеет `status`, `progress` и `pressed`, а не фазами твинов. Три @@ -216,6 +217,7 @@ fl.play(first, el.getBoundingClientRect()); // элемент «доезжает при размонтировании нужен `binding.destroy()`. Повторное открытие во время ухода не сбрасывает позу и не позволяет старому завершению закрыть диалог. + ```typescript import { animate } from '@labpics/motion/animate'; import { createPresenceTransition } from '@labpics/motion/presence'; @@ -385,7 +387,8 @@ const toProgress = pipe(clamp(0, 300), (x) => x / 300); // композиция ## Bottom sheet (behaviors, DOM-адаптер) -Runnable DOM-адаптер: transform из headless-состояния `createBottomSheet`. +Совместимый DOM-адаптер задаёт transform по состоянию `createBottomSheet`. +Для нового компонента используйте [универсальный follow](#прямой-ввод-панель-и-карусель). ```ts import { createBottomSheet } from '@labpics/motion/behaviors'; @@ -413,17 +416,446 @@ el.addEventListener('pointercancel', () => sheet.pointerCancel()); document.querySelector('.expand')?.addEventListener('click', () => sheet.snapTo(2)); ``` -## Анимации, принадлежащие компоненту +## Sheet: живая фаза и автономный snap + +Нужны панель `[data-sheet-panel]`, кнопка `[data-sheet-handle]` с +`touch-action: none` и необязательные кнопки `[data-sheet-snap="0"]` и т. д. +Точки остановки — конечные возрастающие смещения по Y; обновляйте их при смене +высоты или содержимого. Поля ввода внутри панели сохраняют обычное поведение. +`CompositorSpring` принимает текущую позу и скорость при захвате; после отпускания +`createDecay().rest` помогает выбрать остановку, а контроллер переносит импульс. + + +```typescript +import { CompositorSpring } from '@labpics/motion/compositor'; +import { createDecay } from '@labpics/motion/decay'; + +export function mountCompositorSheet(root: HTMLElement, options: { + snapPoints: readonly number[]; + motion?: 'auto' | 'none'; + onSelect?: (index: number) => void; + requestFrame?: (callback: (time?: number) => void) => number; +}) { + const panel = root.querySelector('[data-sheet-panel]'); + const handle = root.querySelector('[data-sheet-handle]'); + if (!panel || !handle) throw new Error('Нужны panel и button handle'); + const check = (points: readonly number[]) => { + const copy = [...points]; + if (!copy.length || copy.some((v, i) => !Number.isFinite(v) || (i > 0 && v <= copy[i - 1]!))) { + throw new RangeError('Snap points должны быть конечными и строго возрастающими'); + } + return copy; + }; + let points = check(options.snapPoints), selected = 0, paused = false; + let pointer: number | undefined, anchor = 0, coordinate = 0; + let live: ReturnType | undefined; + const events = new AbortController(); + const reduced = window.matchMedia('(prefers-reduced-motion: reduce)'); + const quiet = () => options.motion === 'none' || reduced.matches; + const originalTransform = panel.style.getPropertyValue('transform'); + const originalTransformPriority = panel.style.getPropertyPriority('transform'); + const focused = () => { + let tree = root.getRootNode() as Document | ShadowRoot; + let active = tree.activeElement; + // Доступный предок может быть closed: ищем его через host, не shadowRoot. + while (!active && 'host' in tree) { + tree = tree.host.getRootNode() as Document | ShadowRoot; + active = tree.activeElement; + } + active ??= root.ownerDocument.activeElement; + while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement; + return active as HTMLElement | null; + }; + const previousFocus = focused(); + const format = (value: number) => `translateY(${value}px)`; + panel.style.transform = format(points[0]!); + const motion = new CompositorSpring({ + spring: { mass: 1, stiffness: 240, damping: 28 }, + property: 'transform', from: points[0]!, to: points[0]!, target: panel, + format, apply: value => { panel.style.transform = String(value); }, + matchMedia: () => ({ matches: quiet() }), requestFrame: options.requestFrame, + }); + const bounded = (value: number) => Math.max(points[0]!, Math.min(points.at(-1)!, value)); + const releaseCapture = () => { + const id = pointer; pointer = undefined; + if (id !== undefined && handle.hasPointerCapture(id)) handle.releasePointerCapture(id); + }; + const select = (index: number) => { + if (events.signal.aborted) return; + if (!Number.isInteger(index) || index < 0 || index >= points.length) throw new RangeError('Нет такого snap'); + releaseCapture(); live = undefined; selected = index; + if (!paused) { + if (quiet()) motion.handoffToLive(points[index]!).snapTo(points[index]!); + else motion.handoffToCompositor(points[index]!); + } + const onSelect = options.onSelect; + if (!events.signal.aborted && selected === index && onSelect != null) Reflect.apply(onSelect, options, [index]); + }; + const follow = (event: PointerEvent) => { + if (pointer !== event.pointerId || !live) return; + coordinate = event.clientY; + const goal = bounded(anchor + coordinate); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + }; + const finish = (event: PointerEvent, cancelled: boolean) => { + if (pointer !== event.pointerId || !live) return; + if (!cancelled) follow(event); + const rest = createDecay({ from: live.value, velocity: live.velocity }).rest; + const next = cancelled ? selected : points.reduce((best, value, index) => + Math.abs(value - rest) < Math.abs(points[best]! - rest) ? index : best, 0); + select(next); + }; + handle.addEventListener('pointerdown', event => { + if (paused || pointer !== undefined || !event.isPrimary || event.button !== 0) return; + event.preventDefault(); handle.focus({ preventScroll: true }); + live = motion.handoffToLive(); + coordinate = event.clientY; anchor = live.value - coordinate; pointer = event.pointerId; + handle.setPointerCapture(event.pointerId); + }, { signal: events.signal }); + handle.addEventListener('pointermove', follow, { signal: events.signal }); + handle.addEventListener('pointerup', event => finish(event, false), { signal: events.signal }); + handle.addEventListener('pointercancel', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('lostpointercapture', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('keydown', event => { + if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return; + const next = event.key === 'Home' ? 0 : event.key === 'End' ? points.length - 1 + : event.key === 'ArrowUp' ? selected - 1 : event.key === 'ArrowDown' ? selected + 1 : undefined; + if (next !== undefined) { event.preventDefault(); select(Math.max(0, Math.min(points.length - 1, next))); } + }, { signal: events.signal }); + root.addEventListener('click', event => { + const button = (event.target as Element).closest('button[data-sheet-snap]'); + if (button && root.contains(button)) select(Number(button.dataset.sheetSnap)); + }, { signal: events.signal }); + reduced.addEventListener('change', () => { + if (live && pointer !== undefined) live.snapTo(bounded(anchor + coordinate)); + else select(selected); + }, { signal: events.signal }); + return { + motion, select, get selected() { return selected; }, + resize(next: readonly number[]) { + if (events.signal.aborted) return; + points = check(next); selected = Math.min(selected, points.length - 1); + if (pointer !== undefined && live) { + anchor = live.value - coordinate; + const goal = bounded(live.value); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + } else select(selected); + }, + pause() { if (!events.signal.aborted) { releaseCapture(); paused = true; (live ?? motion.handoffToLive()).stop(); live = undefined; } }, + resume() { if (!events.signal.aborted) { paused = false; select(selected); } }, + destroy() { + if (events.signal.aborted) return; + events.abort(); releaseCapture(); live = undefined; motion.destroy(); + if (originalTransform) panel.style.setProperty('transform', originalTransform, originalTransformPriority); + else panel.style.removeProperty('transform'); + let active: Element | null = focused(); + while (active && active !== root) active = active.parentElement ?? (active.getRootNode() as ShadowRoot).host ?? null; + if (active && previousFocus?.isConnected) previousFocus.focus({ preventScroll: true }); + }, + }; +} +``` + +Кнопка захвата поддерживает Home/End и стрелки, кнопки остановок — обычный клик. +Через `onSelect` обновляйте текст, `aria-expanded` и выбранное состояние; модальность +и удержание фокуса остаются у компонента. `pause()` сохраняет позу, `resume()` +продолжает движение. `motion: 'none'` и системное уменьшенное движение применяют +цель сразу. При размонтировании вызовите `destroy()` для очистки и возврата фокуса. +Очистка возвращает исходное inline-значение `transform` вместе с приоритетом; +если свойство отсутствовало, оно удаляется. + +## Pager: страницы и RTL принадлежат компоненту + +Нужны `[data-pager-viewport]` с `overflow: hidden`, вложенный `[data-pager-track]` +с `display: flex`, прямые дети `[data-page]` с `flex: 0 0 100%` и кнопка +`[data-pager-handle]` с `touch-action: none`. Кнопки `[data-page-index="0"]` +и т. д. выбирают страницы. Текст и поля ввода сохраняют выделение и обычный ввод. +После смены размера, родителя, числа страниц или CSS `direction` вызовите `resize()`. +Индекс страницы принадлежит компоненту; контроллер управляет физической осью X. + + +```typescript +import { CompositorSpring } from '@labpics/motion/compositor'; +import { createDecay } from '@labpics/motion/decay'; + +export function mountCompositorPager(root: HTMLElement, options: { + motion?: 'auto' | 'none'; + onSelect?: (index: number) => void; + requestFrame?: (callback: (time?: number) => void) => number; +} = {}) { + const viewport = root.querySelector('[data-pager-viewport]'); + const track = root.querySelector('[data-pager-track]'); + const handle = root.querySelector('[data-pager-handle]'); + if (!viewport || !track || !handle) throw new Error('Нужны viewport, track и button handle'); + const measure = () => { + const width = viewport.clientWidth; + const count = Array.from(track.children).filter(page => page.hasAttribute('data-page')).length; + if (!Number.isFinite(width) || width <= 0 || count < 1) throw new RangeError('Pager должен быть видимым и иметь страницы'); + return { width, count, sign: getComputedStyle(viewport).direction === 'rtl' ? 1 : -1 }; + }; + let geometry = measure(), selected = 0, paused = false; + let pointer: number | undefined, anchor = 0, coordinate = 0; + let live: ReturnType | undefined; + const events = new AbortController(); + const reduced = window.matchMedia('(prefers-reduced-motion: reduce)'); + const quiet = () => options.motion === 'none' || reduced.matches; + const originalTransform = track.style.getPropertyValue('transform'); + const originalTransformPriority = track.style.getPropertyPriority('transform'); + const focused = () => { + let tree = root.getRootNode() as Document | ShadowRoot; + let active = tree.activeElement; + // Доступный предок может быть closed: ищем его через host, не shadowRoot. + while (!active && 'host' in tree) { + tree = tree.host.getRootNode() as Document | ShadowRoot; + active = tree.activeElement; + } + active ??= root.ownerDocument.activeElement; + while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement; + return active as HTMLElement | null; + }; + const previousFocus = focused(); + const offset = (index: number) => geometry.sign * geometry.width * index; + const bounded = (value: number) => Math.max(Math.min(0, offset(geometry.count - 1)), + Math.min(Math.max(0, offset(geometry.count - 1)), value)); + const format = (value: number) => `translateX(${value}px)`; + track.style.transform = format(0); + const motion = new CompositorSpring({ + spring: { mass: 1, stiffness: 240, damping: 28 }, + property: 'transform', from: 0, to: 0, target: track, + format, apply: value => { track.style.transform = String(value); }, + matchMedia: () => ({ matches: quiet() }), requestFrame: options.requestFrame, + }); + const releaseCapture = () => { + const id = pointer; pointer = undefined; + if (id !== undefined && handle.hasPointerCapture(id)) handle.releasePointerCapture(id); + }; + const select = (index: number) => { + if (events.signal.aborted) return; + if (!Number.isInteger(index) || index < 0 || index >= geometry.count) throw new RangeError('Нет такой страницы'); + releaseCapture(); live = undefined; selected = index; + if (!paused) { + if (quiet()) motion.handoffToLive(offset(index)).snapTo(offset(index)); + else motion.handoffToCompositor(offset(index)); + } + const onSelect = options.onSelect; + if (!events.signal.aborted && selected === index && onSelect != null) Reflect.apply(onSelect, options, [index]); + }; + const follow = (event: PointerEvent) => { + if (pointer !== event.pointerId || !live) return; + coordinate = event.clientX; + const goal = bounded(anchor + coordinate); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + }; + const finish = (event: PointerEvent, cancelled: boolean) => { + if (pointer !== event.pointerId || !live) return; + if (!cancelled) follow(event); + const rest = createDecay({ from: live.value, velocity: live.velocity }).rest; + select(cancelled ? selected : Math.max(0, Math.min(geometry.count - 1, + Math.round(rest / (geometry.sign * geometry.width))))); + }; + handle.addEventListener('pointerdown', event => { + if (paused || pointer !== undefined || !event.isPrimary || event.button !== 0) return; + event.preventDefault(); handle.focus({ preventScroll: true }); + live = motion.handoffToLive(); + coordinate = event.clientX; anchor = live.value - coordinate; pointer = event.pointerId; + handle.setPointerCapture(event.pointerId); + }, { signal: events.signal }); + handle.addEventListener('pointermove', follow, { signal: events.signal }); + handle.addEventListener('pointerup', event => finish(event, false), { signal: events.signal }); + handle.addEventListener('pointercancel', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('lostpointercapture', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('keydown', event => { + if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return; + const step = event.key === 'ArrowRight' ? -geometry.sign : event.key === 'ArrowLeft' ? geometry.sign + : event.key === 'PageDown' ? 1 : event.key === 'PageUp' ? -1 : undefined; + const next = event.key === 'Home' ? 0 : event.key === 'End' ? geometry.count - 1 + : step === undefined ? undefined : selected + step; + if (next !== undefined) { event.preventDefault(); select(Math.max(0, Math.min(geometry.count - 1, next))); } + }, { signal: events.signal }); + root.addEventListener('click', event => { + const button = (event.target as Element).closest('button[data-page-index]'); + if (button && root.contains(button)) select(Number(button.dataset.pageIndex)); + }, { signal: events.signal }); + reduced.addEventListener('change', () => { + if (live && pointer !== undefined) live.snapTo(bounded(anchor + coordinate)); + else select(selected); + }, { signal: events.signal }); + return { + motion, select, get selected() { return selected; }, + resize() { + if (events.signal.aborted) return; + geometry = measure(); selected = Math.min(selected, geometry.count - 1); + if (pointer !== undefined && live) { + anchor = live.value - coordinate; + const goal = bounded(live.value); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + } else select(selected); + }, + pause() { if (!events.signal.aborted) { releaseCapture(); paused = true; (live ?? motion.handoffToLive()).stop(); live = undefined; } }, + resume() { if (!events.signal.aborted) { paused = false; select(selected); } }, + destroy() { + if (events.signal.aborted) return; + events.abort(); releaseCapture(); live = undefined; motion.destroy(); + if (originalTransform) track.style.setProperty('transform', originalTransform, originalTransformPriority); + else track.style.removeProperty('transform'); + let active: Element | null = focused(); + while (active && active !== root) active = active.parentElement ?? (active.getRootNode() as ShadowRoot).host ?? null; + if (active && previousFocus?.isConnected) previousFocus.focus({ preventScroll: true }); + }, + }; +} +``` + +`onSelect` обновляет состояние страниц и `aria-current`; недоступные страницы +скрывает компонент. Home/End, PageUp/PageDown и стрелки работают на кнопке захвата; +горизонтальные стрелки учитывают RTL. Ввод в полях сохраняется. Пауза, очистка и +`motion: 'none'` работают как у панели выше. +`motion.mode` сообщает фактическое исполнение: резервный живой путь не является +исполнением через композитор браузера. +## Прямой ввод: панель и карусель + +В этих двух UI-рецептах пружина владеет скоростью и исполнением. Приложение +выбирает snap/страницу, привязывает pointer-события, управляет фокусом и очищает +свои listeners. Один вызов mount возвращает одну функцию очистки. + +Панель содержит `[data-panel]` с `[data-handle]` и `[data-close]`, а рядом +находится кнопка `[data-open]`. Это немодальная панель: размеры и snap-точки +фиксированы при mount. Карусель содержит `[data-viewport]` шириной одной страницы, +`[data-track]` с тремя страницами, кнопки `[data-previous]`, `[data-next]` и +`[data-page-status]` с `role="status"`. После изменения размеров выполняйте remount. +Задайте handle `touch-action:none`, а track — `touch-action:pan-y`. + + +```typescript +import { createCompositorFollow, type CompositorFollow } from '@labpics/motion/compositor/follow'; + +function pointerInput( + handle: HTMLElement, motion: CompositorFollow, axis: 'clientX' | 'clientY', + limit: (value: number) => number, + release: (value: number, t: number, cancelled: boolean) => void, +) { + const events = new AbortController(); + let active: { id: number; coordinate: number; origin: number } | undefined; + const cancel = () => { + const id = active?.id; + active = undefined; + if (id !== undefined && handle.hasPointerCapture(id)) handle.releasePointerCapture(id); + }; + const valueAt = (e: PointerEvent) => limit(active!.origin + e[axis] - active!.coordinate); + handle.addEventListener('pointerdown', (e) => { + if (active || !e.isPrimary || e.button !== 0) return; + active = { id: e.pointerId, coordinate: e[axis], origin: motion.beginFollow(e.timeStamp / 1000) }; + handle.setPointerCapture(e.pointerId); + }, { signal: events.signal }); + // Нативный drag не должен забирать поток у принятого pointer-жеста. + handle.addEventListener('dragstart', (e) => { + if (active) e.preventDefault(); + }, { signal: events.signal }); + handle.ownerDocument.addEventListener('pointermove', (e) => { + if (e.pointerId === active?.id) motion.follow(valueAt(e), e.timeStamp / 1000); + }, { signal: events.signal }); + const finish = (e: PointerEvent) => { + if (e.pointerId !== active?.id) return; + const value = valueAt(e); + motion.follow(value, e.timeStamp / 1000); + cancel(); + release(value, e.timeStamp / 1000, e.type !== 'pointerup'); + }; + handle.ownerDocument.addEventListener('pointerup', finish, { signal: events.signal }); + handle.ownerDocument.addEventListener('pointercancel', finish, { signal: events.signal }); + handle.addEventListener('lostpointercapture', (e) => { + if (e.pointerId !== active?.id) return; + active = undefined; + release(motion.value, e.timeStamp / 1000, true); + }, { signal: events.signal }); + return { cancel, destroy() { events.abort(); cancel(); motion.destroy(); } }; +} -`createAnimateScope` из `./animate` связывает локальные селекторы с одной уборкой. -Каждый mount создаёт свою область. Строки выбирают потомков root, включая новые -узлы при следующем вызове; для самого root передайте элемент явно. Переданный -напрямую внешний элемент тоже допустим — область не является песочницей DOM. +export function mountSnapPanel(root: HTMLElement): () => void { + const panel = root.querySelector('[data-panel]')!; + const open = root.querySelector('[data-open]')!; + const close = root.querySelector('[data-close]')!; + const handle = root.querySelector('[data-handle]')!; + const events = new AbortController(); + const snaps = [0, 160, 320]; + let target = 320; + panel.style.transform = 'translateY(320px)'; + const motion = createCompositorFollow({ + spring: { mass: 1, stiffness: 170, damping: 26 }, + property: 'transform', from: target, to: target, target: panel, + format: (y) => `translateY(${y}px)`, + apply: (value) => { panel.style.transform = String(value); }, + }); + const present = (next: number) => { + target = next; + root.dataset.snap = String(next); + open.setAttribute('aria-expanded', String(next < 320)); + if (next === 320 && panel.contains(document.activeElement)) open.focus(); + panel.inert = next === 320; + }; + present(target); + const input = pointerInput(handle, motion, 'clientY', (y) => Math.max(0, Math.min(320, y)), + (value, t, cancelled) => { + const next = cancelled ? target : snaps.reduce((a, b) => Math.abs(b - value) < Math.abs(a - value) ? b : a); + present(next); + motion.settle(next, t); + }); + open.addEventListener('click', () => { + input.cancel(); present(0); motion.retarget(0); close.focus(); + }, { signal: events.signal }); + close.addEventListener('click', () => { + input.cancel(); present(320); motion.retarget(320); + }, { signal: events.signal }); + return () => { events.abort(); input.destroy(); }; +} -В примере компонент содержит кнопку `[data-replay]` и элемент `.motion-target`. -Сохраните общий код в `card-motion.ts`. Нативная кнопка даёт мышь, touch и клавиатуру -без отдельной реализации распознавания ввода. `prefers-reduced-motion` проверяется -существующим `animate` при каждом запуске. +export function mountPagedCarousel(root: HTMLElement): () => void { + const viewport = root.querySelector('[data-viewport]')!; + const track = root.querySelector('[data-track]')!; + const previous = root.querySelector('[data-previous]')!; + const next = root.querySelector('[data-next]')!; + const status = root.querySelector('[data-page-status]')!; + const events = new AbortController(); + const width = viewport.clientWidth; + const count = track.children.length; + let page = 0; + const bounded = (index: number) => Math.max(0, Math.min(count - 1, index)); + const motion = createCompositorFollow({ + spring: { mass: 1, stiffness: 170, damping: 26 }, + property: 'transform', from: 0, to: 0, target: track, + format: (x) => `translateX(${x}px)`, + apply: (value) => { track.style.transform = String(value); }, + }); + const present = (index: number) => { + page = bounded(index); root.dataset.page = String(page); + status.textContent = `Страница ${page + 1} из ${count}`; + previous.disabled = page === 0; next.disabled = page === count - 1; + }; + present(0); + const input = pointerInput(track, motion, 'clientX', (x) => Math.max(-(count - 1) * width, Math.min(0, x)), + (value, t, cancelled) => { + present(cancelled ? page : Math.round(-value / width)); + motion.settle(-page * width, t); + }); + const go = (index: number) => { input.cancel(); present(index); motion.retarget(-page * width); }; + previous.addEventListener('click', () => go(page - 1), { signal: events.signal }); + next.addEventListener('click', () => go(page + 1), { signal: events.signal }); + return () => { events.abort(); input.destroy(); }; +} +``` + + +Тесты собирают буквальный код блока и проходят оба сценария в браузере. +В приложении вызывайте `mountSnapPanel(root)` или `mountPagedCarousel(root)`; +сохранённую функцию очистки вызовите при удалении компонента. + +## Анимации, принадлежащие компоненту + +При каждом монтировании создавайте `createAnimateScope` из `./animate`. +Селекторы выбирают текущих потомков корня; сам корень или внешний элемент передавайте +явно. В примере нужны кнопка `[data-replay]` и `.motion-target`. +Сохраните общий код в `card-motion.ts`; `animate` проверяет `prefers-reduced-motion` +при каждом запуске. ```typescript @@ -451,15 +883,13 @@ export function mountCardMotion(root: HTMLElement): () => void { } ``` -Для обычного DOM вызовите `const dispose = mountCardMotion(root)` после создания -разметки, а перед удалением компонента — `dispose()`. Область учитывает анимации, -но не произвольные listeners: их снимает владелец компонента, как в примере выше. +После создания DOM вызовите `const dispose = mountCardMotion(root)`, перед удалением — +`dispose()`. Обработчики снимает компонент; область учитывает только свои анимации. -### React: cleanup эффекта, а не render на каждый кадр +### React: очистка эффекта -`react-card.ts` использует тот же общий `card-motion.ts`. Область создаётся внутри -эффекта: повторный setup в StrictMode получает новый lifecycle, а не уничтоженный -объект из прошлого setup. Изменение DOM выполняет движок, React state на кадре нет. +`react-card.ts` использует общий `card-motion.ts`. Создавайте новую область внутри +эффекта, включая повторный запуск StrictMode; покадровый React state не требуется. ```typescript @@ -476,11 +906,10 @@ export function ScopedCard() { } ``` -### Solid: область живёт столько же, сколько owner +### Solid: область принадлежит компоненту -`solid-card.ts` также импортирует `card-motion.ts`. Этот вариант без JSX возвращает -обычный DOM-узел; компонент монтируется стандартным `render` из `solid-js/web`. -Создание области откладывается до `onMount`, cleanup регистрируется у owner. +`solid-card.ts` импортирует `card-motion.ts` и возвращает DOM-узел для `render` из +`solid-js/web`. Создание области откладывается до `onMount`, очистка — в `onCleanup`. ```typescript @@ -499,29 +928,21 @@ export function SolidScopedCard(): HTMLElement { } ``` -Для SSR используйте разметку компонента/JSX своего framework; эта конкретная -Solid-фабрика создаёт DOM и вызывается только на клиенте. Импорт `./animate` -сам по себе не читает DOM. React-пример допускает server render: эффект там -не запускается. +Solid-фабрика вызывается только на клиенте; для SSR нужна разметка вашего компонента. +React-пример допускает серверный рендеринг: эффект там не запускается. +Импорт `./animate` сам по себе не читает DOM. ### Границы уборки -`destroy()` сразу запрещает новые вызовы через эту область и пытается отменить -все её незавершённые анимации, включая paused и delayed. Поздний handler получает -завершённый no-op controls без чтения его входов. Естественно завершённые handles -удаляются из учёта после `finished`; область не копит историю переходов. - -Если destroy вызван внутри синхронной host-транзакции, один финальный проход в -микрозадаче повторяет отмену после снятия reservation. Кадровый цикл не добавляется. -Для ожидания конкретного завершения используйте исходный `controls.finished`. -Одна синхронная ошибка cleanup выбрасывается без замены, несколько — `AggregateError`; -ошибки финального прохода сообщаются через доступный `globalThis.reportError`. -У постоянно неисправного host отмена остаётся best-effort, а не обещанием отката. - -Cleanup **сохраняет текущую позу**, не восстанавливает стили до анимации. Это не -`revert`. Он также не отменяет новый переход, который другой scope или прямой -`animate` уже сделал владельцем тех же свойств. После destroy создайте новую -область для нового mount; не переиспользуйте старую. +`destroy()` запрещает новые запуски и пытается отменить незавершённые анимации, +включая паузу и задержку. Поздний вызов получает завершённый неактивный контроллер. Очистка +сохраняет текущую позу и не отменяет переход, которым уже владеет другая область. +Для нового монтирования создайте новую область. +Синхронные ошибки очистки выбрасываются; ошибки финального прохода сообщаются через +`globalThis.reportError` при его наличии. При неисправном окружении отмена не гарантирует откат. +Порядок очистки и точные исходы — в +[контракте `createAnimateScope`](api.md#область-анимаций-компонента). + ## Каскад состояний взаимодействия без гонок Наведение, нажатие и перетаскивание задают слои; масштабом управляет один @@ -695,6 +1116,7 @@ export function mountReorder(root: HTMLElement, status: HTMLElement): () => void finish(); state.update(measure()); dirty = false; session = state.start(node.dataset.key!); if (!session) return; + e.preventDefault(); const r = node.getBoundingClientRect(); startX = r.x + r.width / 2; startY = r.y + r.height / 2; pointer = e.pointerId; root.setPointerCapture(pointer); pan.pointerDown(point(e)); node.querySelector('[data-grip]')!.focus({ preventScroll: true }); @@ -721,8 +1143,11 @@ export function mountReorder(root: HTMLElement, status: HTMLElement): () => void else if (session?.active && directions[e.key]) { e.preventDefault(); refresh(); session.step(directions[e.key]!); } }); listen('click', e => { - const node = slotFor(e), action = (e.target as Element).closest('[data-move]')?.dataset.move; - if (!node || (action !== 'previous' && action !== 'next')) return; + const node = slotFor(e), button = (e.target as Element).closest('[data-move]'); + if (!node || !button || !node.contains(button)) return; + const action = button.dataset.move; + if (action !== 'previous' && action !== 'next') return; + button.focus({ preventScroll: true }); pan.pointerCancel(); finish(); state.update(measure()); dirty = false; session = state.start(node.dataset.key!); session?.step(action); finish(); }); diff --git a/docs/server-profile.md b/docs/server-profile.md new file mode 100644 index 000000000..1e790bc3e --- /dev/null +++ b/docs/server-profile.md @@ -0,0 +1,77 @@ +# Как запустить и проверить измерение PROFILE-01 + +Практическое руководство для сравнения двух checkout: время исполнения потока +Node, сообщаемое Linux, и стоимость публичного API в браузере. + +## Подготовка и запуск + +Платформу, версии инструментов и исходный checkout задаёт +[`SERVER_PROFILE`](../bench/profile/server-profile-registration.mjs). +Установите зависимости корня и `bench/compare` по зафиксированным lock-файлам; +указанные Node и pnpm должны быть первыми в `PATH`. Нужны компилятор C11 и Linux libc. +Оба checkout должны быть чистыми. На время измерений освободите хост от других проверок. + +```sh +taskset -c 0 node bench/profile/server-profile-runner.mjs \ + --baseline /path/to/baseline --candidate /path/to/candidate \ + --browser chromium --out /outside/checkout/server-chromium-registration-1 +``` + +Каталог результата должен отсутствовать и находиться вне checkout. До измерений +инструмент проверяет ресурсы хоста, исходники, часы и собранные пакеты участников. +Потребители используют упакованные пакеты. Повтор серии ради успешного исхода запрещён: +смена метода требует новой регистрации с сохранением прежних данных и отказов. + +## Проверьте сохранённый результат + +Каталог содержит `server-profile.json`, `server-profile.sha256`, `journal.ndjson`, +исходные контрольные данные, пакеты и сведения о сборке счётчика. Все приобретённые +наблюдения и частичные результаты ошибок сохраняются. Для независимой проверки +передайте отдельно сохранённый digest и журнал: + +```sh +node bench/profile/server-profile-artifact.mjs \ + --raw /outside/checkout/server-chromium-registration-1/server-profile.json \ + --digest '<64 hex из независимо сохранённого server-profile.sha256>' \ + --journal /outside/checkout/server-chromium-registration-1/journal.ndjson +``` + +Проверка связывает исходные данные с digest и журналом. При интерпретации отчёта +учитывайте его `verdict` и границы измерения ниже: сохранённый отказ остаётся отказом. + +## Определите область результата + +Числовые параметры и правила допуска принадлежат исходникам: + +- [`SERVER_PROFILE`](../bench/profile/server-profile-registration.mjs) — сцены, + объём работы, модель часов, выборка и условия остановки. +- [Контракт профиля](../bench/profile/server-profile-contract.mjs) — проверка данных, + происхождения результата, последовательности этапов и статистических границ. +- [Методология сравнения](../bench/compare/methodology.mjs) и + [владелец измерения](../scripts/bench-transform-support.mjs) — независимая проверка + полезного движения, завершения и отмены. + +`CLOCK_THREAD_CPUTIME_ID` наблюдает сообщённое ядром время исполнения главного потока. +Наружное расширение счётчика учитывается при допуске; оно не удостоверяет физическую +точность часов. Номинальное разрешение `clock_getres` также не задаёт точность. +Накладные расходы чтения включены. Требования к сборке и происхождению счётчика — +в [справочнике его исходников](../bench/profile/native-clock/README.md). + +Браузерное измерение наблюдает истекшее время вызова API через `performance.now`, +включая влияние планировщика и сборки мусора. Результат относится к агрегату блока; +он не доказывает задержку отдельного вызова, кадровую частоту, стоимость GPU, +энергопотребление или поведение физических Android/iOS. Функциональные проверки +Firefox/WebKit не заменяют измерение с зарегистрированной моделью часов. + +Неразрешимое наблюдение, ошибка или нарушение ресурсных условий дают `UNPROVEN`. +Если пилот требует выборку выше предела, инструмент сразу сохраняет отказ. +`SIGINT`/`SIGTERM` завершают текущее измерение, сохраняют полученные данные и закрывают +ресурсы; следующие измерения не запускаются. +Подавленные адаптером исключения внешнего исполнителя наблюдать невозможно. +Принудительная сборка мусора применяется только в отдельной проверке оставшейся +памяти после измерений; её стоимость не включается в измеренный интервал CPU. + +Допущенный результат действует только для зарегистрированного набора исходников, +пакетов, инструментов и метода. Планы исполнения находятся в +[agents-config](https://github.com/Labpics-Team/agents-config/tree/main/plans/lab-motion-production); +для интерпретации конкретной серии используйте её регистрацию и исходные данные. diff --git a/examples/audio-cue/README.md b/examples/audio-cue/README.md new file mode 100644 index 000000000..964671004 --- /dev/null +++ b/examples/audio-cue/README.md @@ -0,0 +1,14 @@ +# Монтажная шкала + +Черновой лист для проверки границ четырёх фрагментов интервью. Монтажёр перемещает курсор нативной шкалой, переходит между фрагментами, оставляет заметку и сохраняет или удаляет точки монтажа. Время, заметки и точки принадлежат приложению; установленный `@labpics/motion` 0.3.0 управляет визуальным переходом курсора. Пример не воспроизводит аудио и не выдаёт графические сегменты за измеренную звуковую волну. + +Из корня репозитория после `pnpm install --frozen-lockfile`: + +```sh +node examples/audio-cue/prepare.mjs +pnpm exec tsc -p examples/audio-cue/tsconfig.json +pnpm exec vite build --config examples/audio-cue/vite.config.mjs +pnpm exec vite preview --config examples/audio-cue/vite.config.mjs --host 127.0.0.1 --port 4180 +``` + +В другом терминале `node examples/audio-cue/smoke.mjs` проверяет Chromium. Для Firefox и WebKit задайте `MOTION_BROWSER=firefox` или `MOTION_BROWSER=webkit`. Проверка проходит через публичный экспорт установленного архива, клавиатурный и указательный ввод нативной шкалы, RTL, фокус, ручной и системный режимы без движения. События `pagehide/pageshow` в smoke синтетические; фактическое восстановление из bfcache ими не доказано. Квитанция архива создаётся в `.artifacts/package.json`. diff --git a/examples/audio-cue/index.html b/examples/audio-cue/index.html new file mode 100644 index 000000000..3dd1c847f --- /dev/null +++ b/examples/audio-cue/index.html @@ -0,0 +1,11 @@ +Монтажная шкала +
◉   Кадр / звукРабочий лист интервью
+

Монтаж / эпизод 04

Голос города.

Проверьте границы фрагментов интервью. Перемещайте курсор по шкале, переходите между репликами и сохраняйте точку монтажа.

+

Звуковая дорожка

Черновой монтаж

+
Положение 00:00Длительность 03:00
+
+ +
+

Текущий фрагмент

+

Точки монтажа

    Пока нет сохранённых точек.

    +
    Черновик хранится только до закрытия страницы.
    diff --git a/examples/audio-cue/package.json b/examples/audio-cue/package.json new file mode 100644 index 000000000..e3c807d47 --- /dev/null +++ b/examples/audio-cue/package.json @@ -0,0 +1 @@ +{"name":"@labpics/motion-audio-cue-example","private":true,"type":"module","dependencies":{"@labpics/motion":"0.3.0"}} diff --git a/examples/audio-cue/prepare.mjs b/examples/audio-cue/prepare.mjs new file mode 100644 index 000000000..93880a230 --- /dev/null +++ b/examples/audio-cue/prepare.mjs @@ -0,0 +1,60 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const app = dirname(fileURLToPath(import.meta.url)); +const root = resolve(app, '../..'); +const temporary = mkdtempSync(join(tmpdir(), 'motion-audio-cue-')); +const installed = join(app, 'node_modules', '@labpics', 'motion'); +const receiptPath = join(app, '.artifacts', 'package.json'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +try { + // Собранный dist игнорируется Git: повторная сборка связывает архив с текущим source. + if (process.platform === 'win32') execFileSync('cmd.exe', ['/d', '/s', '/c', 'pnpm build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + else execFileSync('pnpm', ['build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + const npmLocation = process.platform === 'win32' + ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }).split(/\r?\n/).find(Boolean) + : undefined; + const npmCli = npmLocation ? join(dirname(npmLocation), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined; + const command = process.platform === 'win32' ? process.execPath : 'npm'; + const args = process.platform === 'win32' ? [npmCli] : []; + if (process.platform === 'win32' && (!npmCli || !existsSync(npmCli))) throw new Error('Не найден npm CLI рядом с npm.cmd'); + const npmVersion = execFileSync(command, [...args, '--version'], { encoding: 'utf8' }).trim(); + process.stdout.write(`npm CLI: ${npmCli ?? command} (${npmVersion})\n`); + const [packed] = JSON.parse(execFileSync(command, + [...args, 'pack', '--ignore-scripts', '--json', '--pack-destination', temporary], + { cwd: root, encoding: 'utf8', timeout: 120_000 })); + if (!packed?.filename) throw new Error('npm pack не вернул имя архива'); + const archive = join(temporary, packed.filename); + const bytes = readFileSync(archive); + const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + if (manifest.version !== '0.3.0') throw new Error('Версия примера не совпадает с корневым пакетом'); + rmSync(installed, { recursive: true, force: true }); + mkdirSync(installed, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', archive, '-C', installed, '--strip-components=1'], { timeout: 120_000 }); + const installedManifest = readFileSync(join(installed, 'package.json')); + if (!installedManifest.equals(readFileSync(join(root, 'package.json')))) { + throw new Error('Установленный манифест не совпадает с архивом'); + } + const installedPackage = JSON.parse(installedManifest.toString('utf8')); + const exportPaths = value => typeof value === 'string' ? [value] : Object.values(value).flatMap(exportPaths); + const paths = exportPaths(installedPackage.exports); + for (const path of paths) { + if (typeof path !== 'string' || !path.startsWith('./') || !existsSync(join(installed, path))) { + throw new Error(`Не найден экспорт в архиве: ${path}`); + } + } + mkdirSync(dirname(receiptPath), { recursive: true }); + const sourceDirty = execFileSync('git', ['status', '--porcelain'], { cwd: root, encoding: 'utf8' }).trim().length > 0; + if (sourceDirty) throw new Error('Рабочее дерево изменено: архив нельзя связать с HEAD'); + writeFileSync(receiptPath, JSON.stringify({ source: execFileSync('git', ['rev-parse', 'HEAD'], + { cwd: root, encoding: 'utf8' }).trim(), sourceDirty, archiveSha256: hash(bytes), + manifestSha256: hash(installedManifest), npmVersion, package: manifest.name, version: manifest.version }, null, 2) + '\n'); + process.stdout.write(`Монтажная шкала: установлен архив ${hash(bytes)}\n`); +} finally { + rmSync(temporary, { recursive: true, force: true }); +} diff --git a/examples/audio-cue/smoke.mjs b/examples/audio-cue/smoke.mjs new file mode 100644 index 000000000..7745ae791 --- /dev/null +++ b/examples/audio-cue/smoke.mjs @@ -0,0 +1,78 @@ +import { chromium, firefox, webkit } from '@playwright/test'; + +const name = process.env.MOTION_BROWSER ?? 'chromium'; +const engine = { chromium, firefox, webkit }[name]; +if (!engine) throw new Error(`Неизвестный браузер: ${name}`); +const browser = await engine.launch({ headless: true }); +const page = await browser.newPage({ viewport: { width: 1180, height: 900 } }); +const errors = []; +page.on('pageerror', error => errors.push(error.message)); +try { + await page.goto('http://127.0.0.1:4180/', { waitUntil: 'networkidle' }); + const seek = page.locator('#seek'); + if (await page.locator('#cue-title').textContent() !== 'Вступление') throw new Error('Начальный фрагмент неверен'); + await page.locator('#quiet').click(); + for (const [at, expected] of [[142, 2], [145, 3]]) { + await seek.evaluate((element, value) => { element.value = String(value); element.dispatchEvent(new Event('input', { bubbles: true })); }, at); + const visual = await page.locator('#cursor').evaluate(cursor => { + const x = cursor.getBoundingClientRect().left + cursor.getBoundingClientRect().width / 2; + return [...document.querySelectorAll('.segments span')].findIndex(segment => { + const rect = segment.getBoundingClientRect(); return rect.left <= x && x <= rect.right; + }); + }); + if (visual !== expected) throw new Error(`В ${at} с визуальный фрагмент ${visual}, ожидался ${expected}`); + } + await page.locator('#quiet').click(); + await seek.evaluate(element => { element.value = '0'; element.dispatchEvent(new Event('input', { bubbles: true })); }); + await page.locator('#next').click(); + if (await seek.inputValue() !== '40') throw new Error('Переход не установил границу фрагмента'); + await page.locator('#note').fill('Убрать паузу после первого слова'); + await page.locator('#next').click(); + await page.locator('#previous').click(); + if (await page.locator('#note').inputValue() !== 'Убрать паузу после первого слова') throw new Error('Заметка потеряна после смены фрагмента'); + await seek.focus(); await page.keyboard.press('ArrowRight'); + if (await seek.inputValue() !== '41' || !((await seek.getAttribute('aria-valuetext')) ?? '').startsWith('00:41')) throw new Error('Клавиатура не переместила курсор'); + await page.locator('#mark').click(); + if (await page.locator('#marks li').count() !== 1) throw new Error('Точка монтажа не сохранена'); + const range = await seek.boundingBox(); + if (!range) throw new Error('Шкала не измерена'); + await page.mouse.click(range.x + range.width * .75, range.y + range.height / 2); + if (Number(await seek.inputValue()) < 100) throw new Error('Указатель не переместил курсор'); + await page.locator('#next').click(); + await page.locator('#marks li button').first().click(); + if (await seek.inputValue() !== '41' || !await page.locator('#marks li button').first().evaluate(e => e === document.activeElement)) throw new Error('Возврат к точке потерял положение или фокус'); + await page.locator('#direction').click(); + if (await seek.getAttribute('dir') !== 'rtl') throw new Error('RTL не применён'); + await page.setViewportSize({ width: 390, height: 800 }); + await page.locator('#quiet').click(); + for (const [at, expected] of [[142, 2], [145, 3]]) { + await seek.evaluate((element, value) => { element.value = String(value); element.dispatchEvent(new Event('input', { bubbles: true })); }, at); + const visual = await page.locator('#cursor').evaluate(cursor => { + const x = cursor.getBoundingClientRect().left + cursor.getBoundingClientRect().width / 2; + return [...document.querySelectorAll('.segments span')].findIndex(segment => { + const rect = segment.getBoundingClientRect(); return rect.left <= x && x < rect.right; + }); + }); + if (visual !== expected) throw new Error(`В RTL при ${at} с визуальный фрагмент ${visual}, ожидался ${expected}`); + } + await seek.focus(); await page.keyboard.press('Home'); + if (await seek.inputValue() !== '0') throw new Error('Начало шкалы недостижимо'); + const inside = await page.locator('#cursor').evaluate(e => { + const cursor = e.getBoundingClientRect(), track = e.parentElement.getBoundingClientRect(); + return cursor.left >= track.left - 1 && cursor.right <= track.right + 1; + }); + if (!inside) throw new Error('Курсор вышел из мобильной RTL шкалы'); + await page.locator('#next').click(); + if (await page.locator('#cursor').evaluate(e => e.getAnimations().length) !== 0) throw new Error('Ручной режим без движения анимировал курсор'); + await page.locator('#quiet').click(); + await page.emulateMedia({ reducedMotion: 'reduce' }); + await page.locator('#previous').click(); + if (await page.locator('#cursor').evaluate(e => e.getAnimations().length) !== 0) throw new Error('Системный reduced motion анимировал курсор'); + await page.locator('#marks li button').last().click(); + if (await page.locator('#marks li').count() || !await page.locator('#empty').isVisible()) throw new Error('Удаление точки не восстановило пустое состояние'); + await page.evaluate(() => { dispatchEvent(new PageTransitionEvent('pagehide', { persisted: true })); dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true })); }); + await page.locator('#next').click(); + if (name === 'chromium') await page.screenshot({ path: 'examples/audio-cue/.artifacts/mobile.png', fullPage: true }); + if (errors.length) throw new Error(`Ошибки страницы: ${errors.join('; ')}`); + process.stdout.write(`Audio cue smoke (${name}): PASS\n`); +} finally { await browser.close(); } diff --git a/examples/audio-cue/src/main.ts b/examples/audio-cue/src/main.ts new file mode 100644 index 000000000..e71936872 --- /dev/null +++ b/examples/audio-cue/src/main.ts @@ -0,0 +1,97 @@ +import { CompositorSpring } from '@labpics/motion/compositor'; +import './style.css'; + +type Cue = { at: number; title: string; copy: string; note: string }; +const cues: Cue[] = [ + { at: 0, title: 'Вступление', copy: 'Знакомство с героем и улицей, на которой он вырос.', note: '' }, + { at: 40, title: 'Мастерская', copy: 'История о старых инструментах и первом заказе.', note: '' }, + { at: 96, title: 'Набережная', copy: 'Звуки воды и воспоминание о вечернем городе.', note: '' }, + { at: 145, title: 'Финал', copy: 'Последняя реплика и место для завершающей паузы.', note: '' }, +]; +const duration = 180; +const marks = new Set(); +let position = 0; +let quiet = false; +let rtl = false; +const reduced = matchMedia('(prefers-reduced-motion: reduce)'); +const seek = document.querySelector('#seek')!; +const cursor = document.querySelector('#cursor')!; +const note = document.querySelector('#note')!; +const status = document.querySelector('#status')!; +const track = document.querySelector('#track')!; +const quietButton = document.querySelector('#quiet')!; +const directionButton = document.querySelector('#direction')!; +const previous = document.querySelector('#previous')!; +const next = document.querySelector('#next')!; +const marksList = document.querySelector('#marks')!; +const time = (seconds: number) => `${String(Math.floor(seconds / 60)).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`; +const cueIndex = () => cues.findLastIndex(cue => cue.at <= position); +const coordinate = () => (rtl ? 1 - position / duration : position / duration) * 100; +const cursorLeft = (value: number) => value <= 0 ? '0px' : value >= 100 ? 'calc(100% - 3px)' : `calc(${value}% - ${rtl ? 1.6 : 1.4}px)`; +const prefersQuiet = () => quiet || reduced.matches; +document.querySelector('.segments')!.style.gridTemplateColumns = cues.map((cue, index) => `${(cues[index + 1]?.at ?? duration) - cue.at}fr`).join(' '); +function makeMotion() { + return new CompositorSpring({ + spring: { mass: 1, stiffness: 230, damping: 27 }, property: 'left', + from: coordinate(), to: coordinate(), target: cursor, + format: cursorLeft, apply: value => { cursor.style.left = String(value); }, + matchMedia: () => ({ matches: prefersQuiet() }), + }); +} +let motion = makeMotion(); +function render(animate: boolean) { + const index = cueIndex(); + const cue = cues[index]!; + seek.value = String(position); + seek.setAttribute('aria-valuetext', `${time(position)}, ${cue.title}`); + document.querySelector('#position')!.textContent = time(position); + document.querySelector('#cue-title')!.textContent = cue.title; + document.querySelector('#cue-copy')!.textContent = cue.copy; + if (document.activeElement !== note) note.value = cue.note; + previous.disabled = index === 0; + next.disabled = index === cues.length - 1; + if (animate && !prefersQuiet()) motion.handoffToCompositor(coordinate()); + else motion.handoffToLive(coordinate()).snapTo(coordinate()); +} +function setPosition(value: number, animate = true) { + const bounded = Math.max(0, Math.min(duration, Math.round(value))); + const changedCue = cues[cueIndex()] !== cues.findLast(cue => cue.at <= bounded); + position = bounded; + if (changedCue && document.activeElement === note) note.blur(); + render(animate); + status.textContent = `Курсор ${time(position)}; ${cues[cueIndex()]!.title}`; +} +function renderMarks() { + marksList.replaceChildren(...[...marks].sort((a, b) => a - b).map(at => { + const item = document.createElement('li'); + const jump = document.createElement('button'); jump.type = 'button'; jump.textContent = `Перейти к ${time(at)}`; + jump.addEventListener('click', () => { setPosition(at); jump.focus({ preventScroll: true }); }); + const remove = document.createElement('button'); remove.type = 'button'; remove.textContent = 'Удалить'; + remove.setAttribute('aria-label', `Удалить точку ${time(at)}`); + remove.addEventListener('click', () => { marks.delete(at); renderMarks(); document.querySelector('#mark')!.focus({ preventScroll: true }); status.textContent = `Точка ${time(at)} удалена`; }); + item.append(jump, remove); return item; + })); + document.querySelector('#empty')!.hidden = marks.size > 0; +} +seek.addEventListener('input', () => setPosition(Number(seek.value), false)); +previous.addEventListener('click', () => setPosition(cues[Math.max(0, cueIndex() - 1)]!.at)); +next.addEventListener('click', () => setPosition(cues[Math.min(cues.length - 1, cueIndex() + 1)]!.at)); +note.addEventListener('input', () => { cues[cueIndex()]!.note = note.value; }); +document.querySelector('#mark')!.addEventListener('click', () => { + if (marks.has(position)) { status.textContent = `Точка ${time(position)} уже сохранена`; return; } + marks.add(position); renderMarks(); status.textContent = `Точка ${time(position)} сохранена`; +}); +quietButton.addEventListener('click', () => { + quiet = !quiet; quietButton.setAttribute('aria-pressed', String(quiet)); + if (prefersQuiet()) motion.handoffToLive(coordinate()).snapTo(coordinate()); +}); +reduced.addEventListener('change', () => { if (reduced.matches) motion.handoffToLive(coordinate()).snapTo(coordinate()); }); +directionButton.addEventListener('click', () => { + rtl = !rtl; + track.dir = rtl ? 'rtl' : 'ltr'; seek.dir = rtl ? 'rtl' : 'ltr'; + directionButton.setAttribute('aria-pressed', String(rtl)); + motion.destroy(); motion = makeMotion(); render(false); +}); +window.addEventListener('pagehide', event => { if (event.persisted) motion.destroy(); }); +window.addEventListener('pageshow', event => { if (event.persisted) { motion = makeMotion(); render(false); } }); +render(false); diff --git a/examples/audio-cue/src/style.css b/examples/audio-cue/src/style.css new file mode 100644 index 000000000..0f87a28b6 --- /dev/null +++ b/examples/audio-cue/src/style.css @@ -0,0 +1,60 @@ +:root{font-family:Inter,ui-sans-serif,system-ui,sans-serif;color:#26332f;background:#f6f3ed} +*{box-sizing:border-box} +body{margin:0} +button,input,textarea{font:inherit} +.app{max-width:1120px;margin:auto;padding:0 30px} +header{height:76px;border-bottom:1px solid #dcded5;display:flex;align-items:center;justify-content:space-between;color:#76827b;font-size:13px} +.brand{font-size:18px;color:#263f39} +.intro{padding:64px 0 48px;max-width:750px} +.eyebrow{text-transform:uppercase;letter-spacing:.16em;color:#aa6950;font-size:11px;font-weight:800} +h1{font:400 clamp(52px,7vw,82px)/1 Georgia,serif;letter-spacing:-.045em;margin:12px 0 18px} +h1 em{color:#a76b52} +p{line-height:1.6} +.intro>p:last-child{color:#687770;max-width:590px} +.board{background:#fffefa;border:1px solid #dadfd5;border-radius:18px;padding:34px;box-shadow:0 25px 70px #293a2b0b} +.board-head,.meta,.controls{display:flex;align-items:center;justify-content:space-between;gap:15px} +.board-head{margin-bottom:40px} +.board-head h2{font:36px Georgia,serif;margin:8px 0} +.meta{font-size:13px;color:#6d7a73;margin-bottom:18px} +.meta strong{font:32px Georgia,serif;color:#9f6248;margin-left:10px} +.track{height:122px;position:relative;padding:12px 0;border-block:1px solid #dce4da;background:repeating-linear-gradient(90deg,#f3f6ef 0 10px,#fffefa 10px 18px)} +.segments{height:100%;display:grid;grid-template-columns:repeat(4,1fr);gap:0} +.segments span{background:#dfeae1;border-radius:5px;display:grid;place-items:center;text-align:center;padding:4px;color:#486a5a;font-size:12px} +.segments span:nth-child(2){background:#d7e6df} +.segments span:nth-child(3){background:#e8e3d7} +.segments span:nth-child(4){background:#e5eadf} +#cursor{position:absolute;top:0;bottom:0;left:0;width:3px;background:#a9674e;box-shadow:0 0 0 3px #fff8;pointer-events:none} +#cursor:before{content:'';position:absolute;top:-9px;left:-6px;border-left:7px solid transparent;border-right:7px solid transparent;border-top:9px solid #a9674e} +.board>label{display:block;margin:14px 0 4px;font-size:13px;font-weight:700} +#seek{width:100%;accent-color:#a9674e;cursor:pointer} +.controls{justify-content:flex-start;flex-wrap:wrap;margin:20px 0 28px} +button{border:1px solid #ccd9cd;border-radius:7px;background:#fff;padding:11px 14px;color:#294d3b;cursor:pointer} +button:disabled{opacity:.45;cursor:default} +#mark{background:#29473b;color:white} +#quiet[aria-pressed=true]{background:#29473b;color:white} +.details{padding:20px 24px;background:#eef3ee;border-radius:10px} +.details h3{font:30px Georgia,serif;margin:8px 0} +.details p:not(.eyebrow){color:#66766b} +.details label{font-size:13px;font-weight:700;display:block;margin:14px 0 7px} +.details textarea{width:100%;border:1px solid #cbd8cd;border-radius:7px;padding:10px;resize:vertical;background:#fff} +.marks{margin-top:25px} +.marks h3{font:24px Georgia,serif} +.marks ol{padding-left:22px} +.marks li{margin:8px 0} +.marks button{margin-left:10px;padding:5px 9px} +#empty,#status{font-size:13px;color:#6d7a73} +footer{padding:28px 0 50px;color:#8b958c;font-size:12px} +:focus-visible{outline:3px solid #a9674e;outline-offset:2px} +@media(max-width:600px){.app{padding:0 14px} +header span{display:none} +.intro{padding:42px 0} +.board{padding:18px} +.board-head{align-items:start;gap:8px} +.board-head h2{font-size:29px} +.board-head button{font-size:12px;padding:8px} +.segments span{font-size:10px;overflow-wrap:anywhere} +.meta strong{font-size:24px} +.track{height:98px} +} + +:where(.board-options){display:flex;flex-wrap:wrap;gap:8px;justify-content:flex-end} diff --git a/examples/audio-cue/tsconfig.json b/examples/audio-cue/tsconfig.json new file mode 100644 index 000000000..7b88af836 --- /dev/null +++ b/examples/audio-cue/tsconfig.json @@ -0,0 +1 @@ +{"compilerOptions":{"target":"ES2023","module":"ESNext","moduleResolution":"Bundler","lib":["ES2023","DOM","DOM.Iterable"],"types":["vite/client"],"strict":true,"noEmit":true,"skipLibCheck":true},"include":["src/**/*.ts"]} diff --git a/examples/audio-cue/vite.config.mjs b/examples/audio-cue/vite.config.mjs new file mode 100644 index 000000000..d27d19e86 --- /dev/null +++ b/examples/audio-cue/vite.config.mjs @@ -0,0 +1,5 @@ +import { defineConfig } from 'vite'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +const root = dirname(fileURLToPath(import.meta.url)); +export default defineConfig({ root, build: { outDir: resolve(root, 'dist'), emptyOutDir: true } }); diff --git a/examples/call-sheet/README.md b/examples/call-sheet/README.md new file mode 100644 index 000000000..a24f602e8 --- /dev/null +++ b/examples/call-sheet/README.md @@ -0,0 +1,14 @@ +# Съёмочный день + +Расписание сцен показывает, как приложение владеет порядком и временем, а установленный `@labpics/motion` 0.3.0 отвечает за перестановку и проекцию DOM. Можно менять название и длительность, отмечать снятые сцены, фильтровать список, добавлять и удалять сцены. Перестановка доступна кнопками, клавиатурой и указателем. Escape отменяет незавершённую клавиатурную перестановку. + +Из корня репозитория после `pnpm install --frozen-lockfile`: + +```sh +node examples/call-sheet/prepare.mjs +pnpm exec tsc -p examples/call-sheet/tsconfig.json +pnpm exec vite build --config examples/call-sheet/vite.config.mjs +pnpm exec vite --config examples/call-sheet/vite.config.mjs --host 127.0.0.1 --port 4179 +``` + +В другом терминале `node examples/call-sheet/smoke.mjs` проверяет основные действия в Chromium. Для Firefox и WebKit задайте `MOTION_BROWSER=firefox` или `MOTION_BROWSER=webkit`. `prepare.mjs` собирает пакет, создаёт архив и устанавливает его в локальный `node_modules` примера; квитанция с хешем архива записывается в `.artifacts/package.json`. Этот пример и smoke проверяют один браузерный сценарий. Они не измеряют физическую память GPU, не доказывают сохранение страницы настоящим bfcache и не заменяют приёмку остальных потребителей плана. diff --git a/examples/call-sheet/index.html b/examples/call-sheet/index.html new file mode 100644 index 000000000..753c2fa32 --- /dev/null +++ b/examples/call-sheet/index.html @@ -0,0 +1,21 @@ + + + Съёмочный день — Lab Motion + +
    +
    Кадр
    План студии на один день
    +

    План съёмки / суббота

    Съёмочный день.

    Меняйте порядок сцен: время каждой следующей пересчитается. Название и длительность можно править прямо в строке.

    Начало08:30Окончание 00:00
    +
    +

    Монтажный лист

    Очередь сцен

    +
    +

    На ручке «Переместить»: Enter или пробел, затем стрелки; Enter закрепляет порядок, Escape отменяет жест. Кнопки в строке дают одиночный шаг.

    + +
    + +

    +
    +
    Данные сохраняются только до закрытия страницы.
    +
    + + + diff --git a/examples/call-sheet/package.json b/examples/call-sheet/package.json new file mode 100644 index 000000000..dbed4ad1f --- /dev/null +++ b/examples/call-sheet/package.json @@ -0,0 +1 @@ +{"name":"@labpics/motion-call-sheet-example","private":true,"type":"module","dependencies":{"@labpics/motion":"0.3.0"}} diff --git a/examples/call-sheet/prepare.mjs b/examples/call-sheet/prepare.mjs new file mode 100644 index 000000000..a36fe6b4f --- /dev/null +++ b/examples/call-sheet/prepare.mjs @@ -0,0 +1,60 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const app = dirname(fileURLToPath(import.meta.url)); +const root = resolve(app, '../..'); +const temporary = mkdtempSync(join(tmpdir(), 'motion-call-sheet-')); +const installed = join(app, 'node_modules', '@labpics', 'motion'); +const receiptPath = join(app, '.artifacts', 'package.json'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +try { + // Собранный dist игнорируется Git: повторная сборка связывает архив с текущим source. + if (process.platform === 'win32') execFileSync('cmd.exe', ['/d', '/s', '/c', 'pnpm build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + else execFileSync('pnpm', ['build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + const npmLocation = process.platform === 'win32' + ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }).split(/\r?\n/).find(Boolean) + : undefined; + const npmCli = npmLocation ? join(dirname(npmLocation), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined; + const command = process.platform === 'win32' ? process.execPath : 'npm'; + const args = process.platform === 'win32' ? [npmCli] : []; + if (process.platform === 'win32' && (!npmCli || !existsSync(npmCli))) throw new Error('Не найден npm CLI рядом с npm.cmd'); + const npmVersion = execFileSync(command, [...args, '--version'], { encoding: 'utf8' }).trim(); + process.stdout.write(`npm CLI: ${npmCli ?? command} (${npmVersion})\n`); + const [packed] = JSON.parse(execFileSync(command, + [...args, 'pack', '--ignore-scripts', '--json', '--pack-destination', temporary], + { cwd: root, encoding: 'utf8', timeout: 120_000 })); + if (!packed?.filename) throw new Error('npm pack не вернул имя архива'); + const archive = join(temporary, packed.filename); + const bytes = readFileSync(archive); + const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + const consumer = JSON.parse(readFileSync(join(app, 'package.json'), 'utf8')); + if (consumer.dependencies?.[manifest.name] !== manifest.version) throw new Error('Версия примера не совпадает с корневым пакетом'); + rmSync(installed, { recursive: true, force: true }); + mkdirSync(installed, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', archive, '-C', installed, '--strip-components=1'], { timeout: 120_000 }); + const installedManifest = readFileSync(join(installed, 'package.json')); + if (!installedManifest.equals(readFileSync(join(root, 'package.json')))) { + throw new Error('Установленный манифест не совпадает с архивом'); + } + const installedPackage = JSON.parse(installedManifest.toString('utf8')); + const exportPaths = value => typeof value === 'string' ? [value] : Object.values(value).flatMap(exportPaths); + const paths = exportPaths(installedPackage.exports); + for (const path of paths) { + if (typeof path !== 'string' || !path.startsWith('./') || !existsSync(join(installed, path))) { + throw new Error(`Не найден экспорт в архиве: ${path}`); + } + } + mkdirSync(dirname(receiptPath), { recursive: true }); + writeFileSync(receiptPath, JSON.stringify({ source: execFileSync('git', ['rev-parse', 'HEAD'], + { cwd: root, encoding: 'utf8' }).trim(), sourceDirty: execFileSync('git', ['status', '--porcelain'], + { cwd: root, encoding: 'utf8' }).trim().length > 0, archiveSha256: hash(bytes), + manifestSha256: hash(installedManifest), npmVersion, package: manifest.name, version: manifest.version }, null, 2) + '\n'); + process.stdout.write(`Съёмочный день: установлен архив ${hash(bytes)}\n`); +} finally { + rmSync(temporary, { recursive: true, force: true }); +} diff --git a/examples/call-sheet/smoke.mjs b/examples/call-sheet/smoke.mjs new file mode 100644 index 000000000..a1f85e0df --- /dev/null +++ b/examples/call-sheet/smoke.mjs @@ -0,0 +1,78 @@ +import { chromium, firefox, webkit } from '@playwright/test'; + +const engineName = process.env.MOTION_BROWSER ?? 'chromium'; +const engine = { chromium, firefox, webkit }[engineName]; +if (!engine) throw new Error(`Неизвестный браузер: ${engineName}`); +const browser = await engine.launch({ headless: true }); +const page = await browser.newPage({ viewport: { width: 1220, height: 900 } }); +const errors = []; +page.on('pageerror', error => errors.push(error.message)); +try { + await page.goto('http://127.0.0.1:4179/', { waitUntil: 'networkidle' }); + const rows = page.locator('[data-id]'); + if (await rows.count() !== 4) throw new Error('Исходные сцены не показаны'); + if (await page.locator('[data-id="portrait"] [data-time]').textContent() !== '09:15') throw new Error('Исходное расписание неверно'); + await page.locator('[data-id="quay"] [data-move="previous"]').click(); + if (await rows.nth(1).getAttribute('data-id') !== 'quay') throw new Error('Одиночный шаг не изменил порядок'); + if (await page.locator('[data-id="quay"] [data-time]').textContent() !== '09:15') throw new Error('Порядок не изменил расчёт времени'); + await page.locator('#filter').selectOption('ready'); + if (await rows.count() !== 3) throw new Error('Фильтр не скрыл снятую сцену'); + await page.locator('[data-id="portrait"] [data-grip]').focus(); + await page.keyboard.press('Enter'); await page.keyboard.press('Home'); + if (await rows.first().getAttribute('data-id') !== 'portrait') throw new Error('Клавиатура не переместила сцену'); + await page.keyboard.press('Escape'); + if (await rows.first().getAttribute('data-id') !== 'window') throw new Error('Escape не вернул порядок'); + if (await page.evaluate(() => document.activeElement?.closest('[data-id]')?.getAttribute('data-id')) !== 'portrait') throw new Error('Escape потерял фокус'); + const title = page.locator('[data-id="portrait"] [data-title]'); + await title.fill('Портрет — вечерний свет'); + if (await page.locator('[data-id="portrait"] [data-grip]').getAttribute('aria-label') !== 'Переместить «Портрет — вечерний свет»') throw new Error('Редактирование не обновило имя в управлении сценой'); + if (await page.locator('[data-id="portrait"] [data-remove]').getAttribute('aria-label') !== 'Удалить «Портрет — вечерний свет»') throw new Error('Редактирование не обновило имя в удалении'); + await page.locator('[data-id="portrait"] [data-minutes]').fill('65'); + await page.locator('[data-id="portrait"] [data-minutes]').blur(); + if (await page.locator('#finish-label').textContent() !== 'Окончание 11:45') throw new Error('Длительность не пересчитала конец дня'); + await page.waitForFunction(() => [...document.querySelectorAll('[data-id]')].every(element => !element.style.transform)); + const grip = await page.locator('[data-id="window"] [data-grip]').boundingBox(); + const target = await page.locator('[data-id="portrait"]').boundingBox(); + if (!grip || !target) throw new Error('Строки не измерены'); + await page.mouse.move(grip.x + grip.width / 2, grip.y + grip.height / 2); await page.mouse.down(); + await page.mouse.move(target.x + target.width / 2, target.y + target.height / 2, { steps: 6 }); await page.mouse.up(); + if (await rows.first().getAttribute('data-id') === 'window') throw new Error('Pointer не переместил строку'); + if (await title.inputValue() !== 'Портрет — вечерний свет') throw new Error('Правка названия потеряна после перестановки'); + if (await page.locator('[data-id="portrait"] [data-minutes]').getAttribute('aria-label') !== 'Длительность сцены Портрет — вечерний свет в минутах') throw new Error('Перестановка потеряла доступное название'); + await page.waitForFunction(() => [...document.querySelectorAll('[data-id]')].every(element => !element.style.transform)); + await page.screenshot({ path: 'examples/call-sheet/.artifacts/desktop.png', fullPage: true }); + await page.locator('#direction').click(); + if (await page.locator('#schedule').getAttribute('dir') !== 'rtl') throw new Error('RTL не применён'); + await page.locator('#quiet').click(); + if (await page.locator('#quiet').getAttribute('aria-pressed') !== 'true') throw new Error('Без движения не включено'); + await page.locator('[data-id="window"] [data-move="next"]').click(); + if (await page.locator('#schedule').evaluate(element => element.getAnimations({ subtree: true }).length) !== 0) throw new Error('Режим без движения запустил анимацию'); + await page.locator('#quiet').click(); + await page.emulateMedia({ reducedMotion: 'reduce' }); + await page.locator('[data-id="window"] [data-move="previous"]').click(); + if (await page.locator('#schedule').evaluate(element => element.getAnimations({ subtree: true }).length) !== 0) throw new Error('Системное ограничение движения запустило анимацию'); + await page.locator('#filter').selectOption('done'); + await page.locator('#filter').selectOption('ready'); + if (await page.locator('[data-id="portrait"] [data-grip]').getAttribute('aria-label') !== 'Переместить «Портрет — вечерний свет»') throw new Error('Фильтр потерял доступное название'); + await page.locator('#filter').selectOption('done'); + await page.locator('[data-id="detail"] [data-remove]').click(); + if (!await page.locator('#empty').isVisible()) throw new Error('Пустое представление не показано'); + await page.locator('#new-scene').fill('Закат у окна'); + await page.locator('#new-minutes').fill('30'); + await page.locator('#add-form button').click(); + if (await page.locator('#filter').inputValue() !== 'all') throw new Error('Новая сцена скрыта фильтром'); + if (await page.locator('[data-title]').last().inputValue() !== 'Закат у окна') throw new Error('Новая сцена не показана'); + await page.setViewportSize({ width: 390, height: 800 }); + const longTitle = 'Длинное название сцены о разговоре героев на набережной после заката'; + await page.locator('[data-id="portrait"] [data-title]').fill(longTitle); + const readable = await page.locator('[data-id="portrait"] [data-title]').evaluate(element => { + const rect = element.getBoundingClientRect(); + return element.scrollHeight <= element.clientHeight + 1 && rect.left >= 0 && rect.right <= innerWidth; + }); + if (!readable) throw new Error('Длинное название обрезано в мобильном RTL'); + await page.screenshot({ path: 'examples/call-sheet/.artifacts/mobile.png', fullPage: true }); + await page.evaluate(() => { dispatchEvent(new PageTransitionEvent('pagehide', { persisted: true })); dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true })); }); + await page.locator('[data-id="portrait"] [data-move="previous"]').click(); + if (errors.length) throw new Error(`Ошибки страницы: ${errors.join('; ')}`); + process.stdout.write(`Call sheet smoke (${engineName}): PASS\n`); +} finally { await browser.close(); } diff --git a/examples/call-sheet/src/main.ts b/examples/call-sheet/src/main.ts new file mode 100644 index 000000000..346bb2f5f --- /dev/null +++ b/examples/call-sheet/src/main.ts @@ -0,0 +1,150 @@ +import { createReorder, type ReorderSession, type ReorderStep } from '@labpics/motion/behaviors/reorder'; +import { createDomProjection } from '@labpics/motion/projection'; +import './style.css'; + +type Scene = { id: string; title: string; place: string; minutes: number; done: boolean }; +const scenes: Scene[] = [ + { id: 'window', title: 'Свет в мастерской', place: 'Павильон 2', minutes: 35, done: false }, + { id: 'portrait', title: 'Портрет архитектора', place: 'Ателье', minutes: 50, done: false }, + { id: 'quay', title: 'Разговор на набережной', place: 'Северный причал', minutes: 40, done: false }, + { id: 'detail', title: 'Детали города', place: 'Старый квартал', minutes: 25, done: true }, +]; +let order = scenes.map(scene => scene.id); +let filter: 'all' | 'ready' | 'done' = 'all'; +let noMotion = false; +let rtl = false; +let session: ReorderSession | undefined; +let keyboardStart: string[] | undefined; +let pointer: number | undefined; +let origin = { x: 0, y: 0 }; +let rendering = false; +const sceneById = new Map(scenes.map(scene => [scene.id, scene])); +const byId = (id: string) => sceneById.get(id)!; +const shown = () => order.filter(id => filter === 'all' || byId(id).done === (filter === 'done')); +const list = document.querySelector('#schedule')!; +const status = document.querySelector('#status')!; +const filterInput = document.querySelector('#filter')!; +const quietButton = document.querySelector('#quiet')!; +const direction = document.querySelector('#direction')!; +const empty = document.querySelector('#empty')!; +const finishLabel = document.querySelector('#finish-label')!; +const media = matchMedia('(prefers-reduced-motion: reduce)'); +const projection = createDomProjection({ radius: false, matchMedia: () => ({ matches: media.matches || noMotion }) }); +const rows = () => Array.from(list.querySelectorAll('[data-id]')); +const measure = () => { const rendered = new Map(rows().map(row => [row.dataset.id!, row])); return shown().map(id => ({ key: id, rect: rendered.get(id)?.getBoundingClientRect() })); }; +const formatTime = (minutes: number) => `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}`; +function times() { + let cursor = 8 * 60 + 30; + const result = new Map(); + for (const id of order) { result.set(id, formatTime(cursor)); cursor += byId(id).minutes + 10; } + finishLabel.textContent = `Окончание ${formatTime(cursor - 10)}`; + return result; +} +function updateTimes() { + const clock = times(); + for (const row of rows()) row.querySelector('[data-time]')!.textContent = clock.get(row.dataset.id!)!; +} +const announce = (id: string) => { status.textContent = `${byId(id).title}: ${shown().indexOf(id) + 1} из ${shown().length}; начало ${times().get(id)}`; }; +let controller = makeController(); +function makeController() { + return createReorder({ items: measure(), axis: 'y', direction: rtl ? 'rtl' : 'ltr', onReorder(next, proposal) { + if (!controller.isCurrent(proposal)) return; + const focused = document.activeElement as HTMLElement | null; + if (!noMotion && !media.matches) projection.capture(rows()); + const visibleKeys = new Set(shown()); + const positions = order.map((id, index) => ({ id, index })).filter(item => visibleKeys.has(item.id)).map(item => item.index); + next.forEach((id, index) => { order[positions[index]!] = id; }); + render(); + if (!noMotion && !media.matches) projection.play(); + focused?.focus({ preventScroll: true }); + announce(proposal.key); + } }); +} +function finish() { + session?.end(); session = undefined; keyboardStart = undefined; + const captured = pointer; pointer = undefined; + if (captured !== undefined && list.hasPointerCapture(captured)) list.releasePointerCapture(captured); + list.querySelectorAll('[data-grip]').forEach(node => node.setAttribute('aria-pressed', 'false')); +} +function createRow(id: string): HTMLElement { + const scene = byId(id); + const row = document.createElement('div'); row.className = 'row'; row.dataset.id = id; + const time = document.createElement('span'); time.className = 'time'; time.dataset.time = ''; + const identity = document.createElement('div'); identity.className = 'identity'; + const title = document.createElement('textarea'); title.dataset.title = ''; title.dir = 'auto'; title.value = scene.title; title.maxLength = 90; title.rows = 1; title.setAttribute('aria-label', `Название сцены ${scene.title}`); + const place = document.createElement('span'); place.className = 'place'; place.textContent = scene.place; identity.append(title, place); + const duration = document.createElement('label'); duration.className = 'duration'; duration.textContent = 'Минут '; + const minutes = document.createElement('input'); minutes.dataset.minutes = ''; minutes.type = 'number'; minutes.min = '5'; minutes.max = '240'; minutes.value = String(scene.minutes); minutes.setAttribute('aria-label', `Длительность сцены ${scene.title} в минутах`); duration.append(minutes); + const actions = document.createElement('div'); actions.className = 'actions'; + const grip = document.createElement('button'); grip.type = 'button'; grip.dataset.grip = ''; grip.textContent = 'Переместить'; grip.setAttribute('aria-label', `Переместить «${scene.title}»`); grip.setAttribute('aria-pressed', 'false'); + const previous = document.createElement('button'); previous.type = 'button'; previous.dataset.move = 'previous'; previous.textContent = 'Раньше'; + const next = document.createElement('button'); next.type = 'button'; next.dataset.move = 'next'; next.textContent = 'Позже'; + const done = document.createElement('button'); done.type = 'button'; done.dataset.done = ''; done.textContent = scene.done ? 'Снято' : 'В работе'; done.setAttribute('aria-pressed', String(scene.done)); + const remove = document.createElement('button'); remove.type = 'button'; remove.dataset.remove = ''; remove.textContent = 'Удалить'; remove.setAttribute('aria-label', `Удалить «${scene.title}»`); + actions.append(grip, previous, next, done, remove); row.append(time, identity, duration, actions); return row; +} +function render() { + const old = new Map(rows().map(row => [row.dataset.id!, row])); + const nodes = shown().map(id => { + const existing = old.get(id); + if (existing) { const done = existing.querySelector('[data-done]')!; done.textContent = byId(id).done ? 'Снято' : 'В работе'; done.setAttribute('aria-pressed', String(byId(id).done)); return existing; } + return createRow(id); + }); + rendering = true; try { list.replaceChildren(...nodes); } finally { rendering = false; } + empty.hidden = nodes.length !== 0; updateTimes(); controller.update(measure()); +} +function reset() { finish(); controller.destroy(); controller = makeController(); render(); } +const rowFor = (target: EventTarget | null) => target instanceof Element ? target.closest('[data-id]') : null; +list.addEventListener('input', event => { + const input = event.target as HTMLTextAreaElement; if (!input.matches('[data-title]')) return; + const row = rowFor(input); if (!row) return; + byId(row.dataset.id!).title = input.value; + input.setAttribute('aria-label', `Название сцены ${input.value}`); + row.querySelector('[data-grip]')!.setAttribute('aria-label', `Переместить «${input.value}»`); + row.querySelector('[data-minutes]')!.setAttribute('aria-label', `Длительность сцены ${input.value} в минутах`); + row.querySelector('[data-remove]')!.setAttribute('aria-label', `Удалить «${input.value}»`); +}); +list.addEventListener('change', event => { + const input = event.target as HTMLInputElement; if (!input.matches('[data-minutes]')) return; + const row = rowFor(input); if (!row) return; + const value = Number(input.value); if (!Number.isInteger(value) || value < 5 || value > 240) { input.value = String(byId(row.dataset.id!).minutes); status.textContent = 'Длительность должна быть от 5 до 240 минут'; return; } + byId(row.dataset.id!).minutes = value; updateTimes(); status.textContent = 'Время начала пересчитано'; +}); +list.addEventListener('click', event => { + const target = event.target as Element; const row = rowFor(target); if (!row) return; + const id = row.dataset.id!; + if (target.closest('[data-remove]')) { finish(); scenes.splice(scenes.findIndex(scene => scene.id === id), 1); sceneById.delete(id); order = order.filter(key => key !== id); render(); document.querySelector('#new-scene')!.focus(); status.textContent = 'Сцена удалена'; return; } + if (target.closest('[data-done]')) { finish(); byId(id).done = !byId(id).done; render(); if (!row.isConnected) filterInput.focus(); status.textContent = 'Состояние сцены обновлено'; return; } + const move = target.closest('[data-move]')?.dataset.move as ReorderStep | undefined; + if (move) { finish(); controller.update(measure()); session = controller.start(id); session?.step(move); finish(); } +}); +list.addEventListener('keydown', event => { + const target = event.target as Element; if (!target.matches('[data-grip]')) return; + const id = rowFor(target)?.dataset.id; if (!id) return; + if (event.key === 'Escape') { event.preventDefault(); const original = keyboardStart; finish(); if (original) { projection.cancel(); order = original; render(); list.querySelector(`[data-id="${id}"] [data-grip]`)?.focus({ preventScroll: true }); status.textContent = 'Перемещение отменено'; } return; } + if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); if (session?.active && controller.activeKey === id) finish(); else { finish(); controller.update(measure()); session = controller.start(id); if (session) keyboardStart = [...order]; target.setAttribute('aria-pressed', String(!!session)); announce(id); } return; } + const steps: Record = { ArrowUp: 'up', ArrowDown: 'down', Home: 'first', End: 'last' }; + if (session?.active && steps[event.key]) { event.preventDefault(); controller.update(measure()); session.step(steps[event.key]!); } +}); +list.addEventListener('focusout', event => { if (!rendering && (event.target as Element).matches('[data-grip]') && session?.active && pointer === undefined) finish(); }); +list.addEventListener('pointerdown', event => { + if (event.button !== 0 || pointer !== undefined || !(event.target as Element).closest('[data-grip]')) return; + const row = rowFor(event.target); if (!row) return; + finish(); controller.update(measure()); session = controller.start(row.dataset.id!); if (!session) return; + event.preventDefault(); const rect = row.getBoundingClientRect(); origin = { x: rect.x + rect.width / 2 - event.clientX, y: rect.y + rect.height / 2 - event.clientY }; + pointer = event.pointerId; list.setPointerCapture(pointer); row.querySelector('[data-grip]')!.focus({ preventScroll: true }); row.querySelector('[data-grip]')!.setAttribute('aria-pressed', 'true'); +}); +list.addEventListener('pointermove', event => { if (event.pointerId === pointer) session?.move({ x: event.clientX + origin.x, y: event.clientY + origin.y }); }); +for (const type of ['pointerup', 'pointercancel', 'lostpointercapture']) list.addEventListener(type, event => { if ((event as PointerEvent).pointerId === pointer) finish(); }); +filterInput.addEventListener('change', () => { filter = filterInput.value as typeof filter; reset(); status.textContent = `Показано ${shown().length} сцен`; }); +direction.addEventListener('click', () => { rtl = !rtl; list.dir = rtl ? 'rtl' : 'ltr'; direction.setAttribute('aria-pressed', String(rtl)); reset(); }); +quietButton.addEventListener('click', () => { noMotion = !noMotion; quietButton.setAttribute('aria-pressed', String(noMotion)); projection.cancel(); }); +media.addEventListener('change', () => { if (media.matches) projection.cancel(); }); +document.querySelector('#add-form')!.addEventListener('submit', event => { + event.preventDefault(); const title = document.querySelector('#new-scene')!; const duration = document.querySelector('#new-minutes')!; + const name = title.value.trim(), minutes = Number(duration.value); if (!name || !Number.isInteger(minutes) || minutes < 5 || minutes > 240) return; + const id = crypto.randomUUID(); const scene = { id, title: name, place: 'Новая площадка', minutes, done: false }; scenes.push(scene); sceneById.set(id, scene); order.push(id); title.value = ''; filter = 'all'; filterInput.value = 'all'; finish(); render(); list.querySelector(`[data-id="${id}"] [data-title]`)!.focus(); status.textContent = `Добавлена сцена «${name}»`; +}); +window.addEventListener('pagehide', () => { finish(); controller.destroy(); projection.cancel(); }); +window.addEventListener('pageshow', event => { if (event.persisted) { controller = makeController(); render(); } }); +render(); diff --git a/examples/call-sheet/src/style.css b/examples/call-sheet/src/style.css new file mode 100644 index 000000000..cc4824bf2 --- /dev/null +++ b/examples/call-sheet/src/style.css @@ -0,0 +1,53 @@ +:root { font-family: Inter, ui-sans-serif, system-ui, sans-serif; color: #212a2b; background: #f5f2ec; } +* { box-sizing: border-box; } +body { margin: 0; } +button, input, select { font: inherit; } +button { cursor: pointer; } +.app { max-width: 1220px; margin: auto; padding: 0 32px; } +.top { min-height: 76px; display: flex; align-items: center; justify-content: space-between; border-bottom: 1px solid #dcd8d0; color: #74807e; font-size: 13px; } +.brand { font-size: 18px; font-weight: 800; color: #253e3d; } +.brand-mark { display: inline-grid; place-items: center; width: 33px; height: 33px; border-radius: 8px; background: #253e3d; color: white; margin-right: 8px; } +.intro { display: flex; align-items: end; justify-content: space-between; gap: 30px; padding: 58px 0 52px; } +.eyebrow { text-transform: uppercase; letter-spacing: .16em; font-size: 11px; font-weight: 760; color: #a1644b; } +h1 { margin: 10px 0 12px; font: 400 clamp(52px, 6vw, 76px)/1.04 Georgia, serif; letter-spacing: -.05em; } +h1 em { color: #a3654b; font-weight: 400; } +.intro-copy { max-width: 610px; color: #687572; line-height: 1.6; } +.summary { display: flex; flex-direction: column; gap: 3px; padding: 19px 24px; min-width: 170px; border-left: 2px solid #d8ab94; color: #677571; font-size: 12px; } +.summary strong { font: 40px Georgia, serif; color: #253e3d; } +.workspace { border: 1px solid #dedfd7; border-radius: 16px; background: #fffefa; padding: 30px; box-shadow: 0 25px 65px #27342c0b; } +.workspace-head { display: flex; justify-content: space-between; gap: 20px; align-items: end; flex-wrap: wrap; } +h2 { margin: 0 0 15px; font: 34px Georgia, serif; } +.controls { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-bottom: 12px; } +.controls label { font-size: 13px; color: #5c6b67; } +.controls select, .controls button { border: 1px solid #d5ded7; border-radius: 7px; background: #fff; padding: 9px 11px; color: #29443d; } +.controls button[aria-pressed=true] { color: #fff; background: #29443d; } +#add-form { display: flex; gap: 10px; align-items: center; flex-wrap: wrap; padding: 17px; background: #edf2ee; border-radius: 10px; } +#add-form label { font-size: 13px; font-weight: 700; } +#add-form input { min-width: 0; padding: 11px; border: 1px solid #cad6cc; border-radius: 7px; background: white; } +#new-scene { flex: 1; min-width: min(100%, 240px); } +#new-minutes { width: 85px; } +#add-form button { padding: 12px 16px; border: 0; border-radius: 7px; background: #29443d; color: #fff; } +.guide { margin: 20px 0 14px; color: #74807b; font-size: 12px; line-height: 1.5; } +.column-head, .row { display: grid; grid-template-columns: 90px minmax(0, 1fr) 125px minmax(290px, auto); gap: 16px; align-items: center; } +.column-head { padding: 12px 14px; color: #7f8b84; font-size: 11px; text-transform: uppercase; letter-spacing: .09em; border-bottom: 1px solid #dfe5dd; } +.row { min-height: 111px; padding: 14px; border-bottom: 1px solid #e8ece6; background: #fffefa; } +.row:last-child { border-bottom: 0; } +.row:hover { background: #f8faf5; } +.time { font: 29px Georgia, serif; color: #a3654b; } +.identity { display: flex; flex-direction: column; gap: 6px; min-width: 0; } +.identity textarea { display: block; width: 100%; min-width: 0; min-height: 1.5em; field-sizing: content; resize: vertical; overflow-wrap: anywhere; border: 1px solid transparent; border-radius: 5px; background: transparent; padding: 4px 5px; font: 25px/1.2 Georgia, serif; color: #243530; } +.identity textarea:hover, .identity textarea:focus { border-color: #cdd9cd; background: #fff; } +.place { color: #849087; font-size: 12px; } +.duration { display: flex; gap: 6px; align-items: center; font-size: 11px; color: #728078; } +.duration input { width: 62px; border: 1px solid #d5dfd5; border-radius: 6px; padding: 7px; background: white; color: #29443d; } +.actions { display: flex; gap: 5px; align-items: center; flex-wrap: wrap; } +.actions button { border: 1px solid #d9e2d8; border-radius: 6px; background: #fff; color: #3b5346; padding: 7px; font-size: 11px; } +.actions [data-grip] { background: #e6eee5; touch-action: none; } +.actions [data-grip][aria-pressed=true] { background: #29443d; color: #fff; } +.actions [data-done][aria-pressed=true] { background: #e3ebdf; color: #557454; } +.actions [data-remove] { color: #a25b4e; } +#status, .empty { min-height: 20px; color: #557454; font-size: 13px; } +footer { padding: 26px 0 48px; font-size: 12px; color: #87928a; } +:focus-visible { outline: 3px solid #ae7454; outline-offset: 2px; } +@media(max-width: 900px) { .column-head { display: none; } .row { grid-template-columns: 86px minmax(0, 1fr); gap: 9px 14px; } .duration { grid-column: 2; } .actions { grid-column: 1 / -1; } } +@media(max-width: 600px) { .app { padding: 0 14px; } .top-meta { display: none; } .intro { display: block; padding: 40px 0; } .summary { margin-top: 25px; } .workspace { padding: 16px; } #add-form { display: grid; grid-template-columns: minmax(0, 1fr) 88px; } #add-form label[for="new-scene"] { grid-column: 1; grid-row: 1; } #new-scene { grid-column: 1; grid-row: 2; width: 100%; min-width: 0; } #add-form label[for="new-minutes"] { grid-column: 2; grid-row: 1; } #new-minutes { grid-column: 2; grid-row: 2; width: 100%; } #add-form button { grid-column: 1 / -1; grid-row: 3; justify-self: start; } .row { padding: 13px 5px; grid-template-columns: 76px minmax(0, 1fr); } .time { font-size: 24px; } .identity textarea { font-size: 21px; } .actions button { min-height: 38px; } } diff --git a/examples/call-sheet/tsconfig.json b/examples/call-sheet/tsconfig.json new file mode 100644 index 000000000..3c3567dd0 --- /dev/null +++ b/examples/call-sheet/tsconfig.json @@ -0,0 +1 @@ +{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"Bundler","lib":["ES2022","DOM","DOM.Iterable"],"types":["vite/client"],"strict":true,"noEmit":true,"skipLibCheck":true},"include":["src/**/*.ts"]} diff --git a/examples/call-sheet/vite.config.mjs b/examples/call-sheet/vite.config.mjs new file mode 100644 index 000000000..d27d19e86 --- /dev/null +++ b/examples/call-sheet/vite.config.mjs @@ -0,0 +1,5 @@ +import { defineConfig } from 'vite'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +const root = dirname(fileURLToPath(import.meta.url)); +export default defineConfig({ root, build: { outDir: resolve(root, 'dist'), emptyOutDir: true } }); diff --git a/examples/card-detail/.gitignore b/examples/card-detail/.gitignore new file mode 100644 index 000000000..9543993ef --- /dev/null +++ b/examples/card-detail/.gitignore @@ -0,0 +1 @@ +.artifacts/ diff --git a/examples/card-detail/README.md b/examples/card-detail/README.md new file mode 100644 index 000000000..2bee82287 --- /dev/null +++ b/examples/card-detail/README.md @@ -0,0 +1,17 @@ +# Атлас материалов + +Самостоятельный пример перехода карточка ↔ подробности. Открытие, закрытие, смена выбранного материала, изменение текста, размер окна, клавиатурная навигация и режим без движения сохраняют данные и фокус приложения. Проекция получает те же DOM-элементы до и после изменения геометрии; выбор и содержимое хранятся только в приложении. + +Из корня репозитория: + +```sh +pnpm install --frozen-lockfile +node examples/card-detail/prepare.mjs +pnpm exec tsc -p examples/card-detail/tsconfig.json +pnpm exec vite build --config examples/card-detail/vite.config.mjs +node examples/card-detail/test.mjs +``` + +Перед проверкой зафиксируйте изменения, затем запустите `prepare.mjs` в чистом рабочем дереве. `test.mjs` требует `sourceDirty: false` в квитанции и совпадения её `source` с текущим `HEAD`; при новом commit подготовку архива нужно повторить. + +Для просмотра: `pnpm exec vite --config examples/card-detail/vite.config.mjs`. `prepare.mjs` собирает пакет, сохраняет npm archive в `.artifacts/package.tgz` и устанавливает именно его внутрь примера. `.artifacts/package.json` фиксирует SHA-256 архива, манифеста и используемого экспорта проекции. Нажмите карточку, затем Escape или «К подборке»; попробуйте быстро открыть другую карточку, изменить текст и сузить окно. Кнопка «Без движения» служит контролем полезности перехода. diff --git a/examples/card-detail/index.html b/examples/card-detail/index.html new file mode 100644 index 000000000..23c5551f5 --- /dev/null +++ b/examples/card-detail/index.html @@ -0,0 +1,14 @@ + + +Атлас материалов — Lab Motion + +
    +
    АТЛАС / 04
    +

    Рабочая библиотека

    Материалы для внимательного взгляда.

    Откройте карточку, чтобы прочитать заметку. Закрывайте, переключайтесь между материалами и меняйте текст, не теряя место в подборке.

    +
    + +
    Содержимое и выбор материала принадлежат приложению. Движение следует за изменением геометрии.
    +
    + + + diff --git a/examples/card-detail/package.json b/examples/card-detail/package.json new file mode 100644 index 000000000..41da06ce7 --- /dev/null +++ b/examples/card-detail/package.json @@ -0,0 +1 @@ +{"name":"@labpics/motion-card-detail-example","private":true,"type":"module","dependencies":{"@labpics/motion":"0.3.0"}} diff --git a/examples/card-detail/prepare.mjs b/examples/card-detail/prepare.mjs new file mode 100644 index 000000000..46a95e7d5 --- /dev/null +++ b/examples/card-detail/prepare.mjs @@ -0,0 +1,64 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const app = dirname(fileURLToPath(import.meta.url)); +const root = resolve(app, '../..'); +const temporary = mkdtempSync(join(tmpdir(), 'motion-card-detail-')); +const installed = join(app, 'node_modules', '@labpics', 'motion'); +const receiptPath = join(app, '.artifacts', 'package.json'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +try { + // Собранный dist игнорируется Git: повторная сборка связывает архив с текущим source. + if (process.platform === 'win32') execFileSync('cmd.exe', ['/d', '/s', '/c', 'pnpm build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + else execFileSync('pnpm', ['build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + const npmLocation = process.platform === 'win32' + ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }).split(/\r?\n/).find(Boolean) + : undefined; + const npmCli = npmLocation ? join(dirname(npmLocation), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined; + const command = process.platform === 'win32' ? process.execPath : 'npm'; + const args = process.platform === 'win32' ? [npmCli] : []; + if (process.platform === 'win32' && (!npmCli || !existsSync(npmCli))) throw new Error('Не найден npm CLI рядом с npm.cmd'); + const npmVersion = execFileSync(command, [...args, '--version'], { encoding: 'utf8' }).trim(); + process.stdout.write(`npm CLI: ${npmCli ?? command} (${npmVersion})\n`); + const [packed] = JSON.parse(execFileSync(command, + [...args, 'pack', '--ignore-scripts', '--json', '--pack-destination', temporary], + { cwd: root, encoding: 'utf8', timeout: 120_000 })); + if (!packed?.filename) throw new Error('npm pack не вернул имя архива'); + const archive = join(temporary, packed.filename); + const bytes = readFileSync(archive); + const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + const consumer = JSON.parse(readFileSync(join(app, 'package.json'), 'utf8')); + if (consumer.dependencies?.[manifest.name] !== manifest.version) { + throw new Error('Версия примера не совпадает с корневым пакетом'); + } + rmSync(installed, { recursive: true, force: true }); + mkdirSync(installed, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', archive, '-C', installed, '--strip-components=1'], { timeout: 120_000 }); + const installedManifest = readFileSync(join(installed, 'package.json')); + if (!installedManifest.equals(readFileSync(join(root, 'package.json')))) { + throw new Error('Установленный манифест не совпадает с архивом'); + } + const installedPackage = JSON.parse(installedManifest.toString('utf8')); + const exportPaths = value => typeof value === 'string' ? [value] : Object.values(value).flatMap(exportPaths); + const paths = exportPaths(installedPackage.exports); + for (const path of paths) { + if (typeof path !== 'string' || !path.startsWith('./') || !existsSync(join(installed, path))) { + throw new Error(`Не найден экспорт в архиве: ${path}`); + } + } + mkdirSync(dirname(receiptPath), { recursive: true }); + copyFileSync(archive, join(dirname(receiptPath), 'package.tgz')); + const projectionSha256 = hash(readFileSync(join(installed, 'dist', 'projection', 'index.js'))); + writeFileSync(receiptPath, JSON.stringify({ source: execFileSync('git', ['rev-parse', 'HEAD'], + { cwd: root, encoding: 'utf8' }).trim(), sourceDirty: execFileSync('git', ['status', '--porcelain'], + { cwd: root, encoding: 'utf8' }).trim().length > 0, archiveSha256: hash(bytes), + manifestSha256: hash(installedManifest), projectionSha256, npmVersion, package: manifest.name, version: manifest.version }, null, 2) + '\n'); + process.stdout.write(`Атлас: установлен архив ${hash(bytes)}\n`); +} finally { + rmSync(temporary, { recursive: true, force: true }); +} diff --git a/examples/card-detail/src/main.ts b/examples/card-detail/src/main.ts new file mode 100644 index 000000000..779257626 --- /dev/null +++ b/examples/card-detail/src/main.ts @@ -0,0 +1,100 @@ +import { createDomProjection } from '@labpics/motion/projection'; +import './style.css'; + +type Material = { id: string; number: string; category: string; title: string; summary: string; body: string; tone: string }; +const materials: Material[] = [ + { id: 'light', number: '01', category: 'Наблюдение', title: 'Свет как материал', summary: 'Как меняется поверхность в течение дня.', body: 'Утренний свет обозначает фактуру, вечерний собирает предметы в силуэты. Сравните один и тот же объект при разных углах освещения и запишите, что оказалось устойчивым.', tone: 'peach' }, + { id: 'space', number: '02', category: 'Пространство', title: 'Место для паузы', summary: 'О расстоянии между предметами.', body: 'Пустое место помогает увидеть отношения между предметами. Отступ служит не украшением, а подсказкой: он отделяет действие от результата и оставляет место взгляду.', tone: 'mint' }, + { id: 'color', number: '03', category: 'Цвет', title: 'Тихая палитра', summary: 'Соседство оттенков и глубина тона.', body: 'Цвет меняется от окружения. Проверьте палитру рядом с реальным содержимым, а затем уберите один оттенок и посмотрите, стало ли чтение яснее.', tone: 'lavender' }, + { id: 'form', number: '04', category: 'Форма', title: 'Контур и ритм', summary: 'Повторение без однообразия.', body: 'Небольшое отклонение от ритма создаёт ориентир. Сначала установите повторяющийся порядок, затем нарушьте его в точке, где читателю нужно сделать выбор.', tone: 'butter' }, +]; + +const gallery = document.querySelector('#gallery')!; +const status = document.querySelector('#status')!; +const motionButton = document.querySelector('#motion')!; +const direction = document.querySelector('#direction')!; +const reduced = matchMedia('(prefers-reduced-motion: reduce)'); +let noMotion = false; +let selected: string | null = null; +let returnFocus: string | null = null; +const projection = createDomProjection({ radius: false, matchMedia: () => ({ matches: noMotion || reduced.matches }) }); +const card = (id: string) => gallery.querySelector(`[data-id="${id}"]`); +const cards = () => Array.from(gallery.querySelectorAll('[data-id]')); +let geometryFrame = 0; +function rebaseGeometry(): void { + if (geometryFrame || !projection.playing) return; + geometryFrame = requestAnimationFrame(() => { + geometryFrame = 0; + if (!projection.playing) return; + projection.capture(cards()); + projection.play(); + }); +} + +function createCard(item: Material): HTMLElement { + const article = document.createElement('article'); + article.className = `card ${item.tone}`; article.dataset.id = item.id; + const badge = document.createElement('span'); badge.className = 'badge'; badge.textContent = item.number; + const category = document.createElement('span'); category.className = 'category'; category.textContent = item.category; + const title = document.createElement('h2'); title.textContent = item.title; + const summary = document.createElement('p'); summary.className = 'summary'; summary.textContent = item.summary; + const open = document.createElement('button'); open.type = 'button'; open.dataset.open = ''; open.textContent = 'Читать заметку ↗'; open.setAttribute('aria-label', `Читать «${item.title}»`); + const detail = document.createElement('div'); detail.className = 'detail'; detail.hidden = true; + const body = document.createElement('p'); body.className = 'body'; body.textContent = item.body; + const label = document.createElement('label'); label.textContent = 'Ваша заметка'; + const note = document.createElement('textarea'); note.rows = 3; note.placeholder = 'Запишите наблюдение'; note.setAttribute('aria-label', `Ваша заметка к «${item.title}»`); + const close = document.createElement('button'); close.type = 'button'; close.dataset.close = ''; close.textContent = 'К подборке ↙'; + label.append(note); detail.append(body, label, close); article.append(badge, category, title, summary, open, detail); + return article; +} +gallery.append(...materials.map(createCard)); + +function select(next: string | null): void { + if (selected === next) return; + const previous = selected; + if (next !== null) returnFocus = next; + projection.capture(cards()); + selected = next; + for (const element of cards()) { + const expanded = element.dataset.id === next; + element.classList.toggle('expanded', expanded); + element.querySelector('.detail')!.hidden = !expanded; + element.querySelector('[data-open]')!.hidden = expanded; + } + gallery.classList.toggle('has-selection', next !== null); + projection.play(); + if (next !== null) { + card(next)?.querySelector('[data-close]')?.focus({ preventScroll: true }); + status.textContent = `Открыта заметка «${materials.find(item => item.id === next)!.title}»`; + } else { + const focusId = returnFocus ?? previous; + card(focusId ?? '')?.querySelector('[data-open]')?.focus({ preventScroll: true }); + returnFocus = null; + status.textContent = 'Показана подборка'; + } +} + +gallery.addEventListener('click', event => { + const target = event.target as Element; + const item = target.closest('[data-id]'); + if (!item) return; + if (target.closest('[data-open]')) select(item.dataset.id!); + if (target.closest('[data-close]')) select(null); +}); +document.addEventListener('keydown', event => { + if (event.key === 'Escape' && selected !== null) { event.preventDefault(); select(null); } +}); +motionButton.addEventListener('click', () => { + noMotion = !noMotion; + motionButton.setAttribute('aria-pressed', String(noMotion)); + if (noMotion) projection.cancel(); + status.textContent = noMotion ? 'Движение выключено' : 'Движение включено'; +}); +direction.addEventListener('change', () => { + projection.capture(cards()); gallery.dir = direction.value; projection.play(); + status.textContent = direction.value === 'rtl' ? 'Направление справа налево' : 'Направление слева направо'; +}); +window.addEventListener('resize', rebaseGeometry); +new ResizeObserver(rebaseGeometry).observe(gallery); +reduced.addEventListener('change', () => { if (reduced.matches) projection.cancel(); }); +window.addEventListener('pagehide', () => { cancelAnimationFrame(geometryFrame); geometryFrame = 0; projection.cancel(); }); diff --git a/examples/card-detail/src/style.css b/examples/card-detail/src/style.css new file mode 100644 index 000000000..4526a3c3a --- /dev/null +++ b/examples/card-detail/src/style.css @@ -0,0 +1,227 @@ +:root{ + font-family:Inter,Arial,sans-serif; + color:#1c2925; + background:#f7f6f0; + font-synthesis:none +} +*{ + box-sizing:border-box +} +body{ + margin:0 +} +.app{ + max-width:1120px; + margin:auto; + padding:28px 28px 64px +} +header,.toolbar{ + display:flex; + align-items:center; + justify-content:space-between; + gap:16px +} +.brand,.eyebrow,.category{ + font-size:12px; + font-weight:700; + letter-spacing:.13em; + text-transform:uppercase +} +.brand{ + color:#317461 +} +button,select,textarea{ + font:inherit +} +button,select{ + border:1px solid #1c2925; + border-radius:6px; + background:transparent; + color:inherit; + padding:10px 14px; + cursor:pointer +} +button:hover{ + background:#1c2925; + color:white +} +button:focus-visible,select:focus-visible,textarea:focus-visible{ + outline:3px solid #d46542; + outline-offset:3px +} +.intro{ + padding:72px 0 54px; + max-width:730px +} +.eyebrow{ + color:#ac583e +} +h1{ + font-family:Georgia,serif; + font-size:clamp(42px,6vw,76px); + line-height:1.03; + letter-spacing:-.04em; + margin:14px 0 20px +} +h1 em{ + color:#317461; + font-weight:400 +} +.intro>p:last-child{ + max-width:600px; + line-height:1.65; + color:#53625c +} +.toolbar{ + border-top:1px solid #cad3cb; + padding:20px 0 24px; + justify-content:flex-start +} +.toolbar label{ + font-weight:600 +} +.toolbar #status{ + margin-left:auto; + font-size:14px; + color:#53625c +} +.gallery{ + display:grid; + grid-template-columns:repeat(2,minmax(0,1fr)); + gap:18px; + align-items:start +} +.card{ + position:relative; + border-radius:14px; + padding:32px; + min-height:265px; + display:flex; + flex-direction:column; + align-items:flex-start; + overflow:hidden; + box-shadow:0 1px 0 #1c29251a +} +.peach{ + background:#efcaba +} +.mint{ + background:#d2e7d7 +} +.lavender{ + background:#dcd9ed +} +.butter{ + background:#f0e3b6 +} +.badge{ + position:absolute; + right:30px; + top:27px; + font-family:Georgia,serif; + font-size:28px +} +.category{ + color:#4d6159 +} +.card h2{ + font-family:Georgia,serif; + font-size:clamp(27px,3vw,42px); + line-height:1.06; + letter-spacing:-.025em; + margin:46px 0 8px +} +.summary{ + margin:0 0 24px; + line-height:1.5 +} +.card button{ + margin-top:auto +} +.card.expanded{ + grid-column:1/-1; + min-height:440px; + padding:40px 48px +} +.card.expanded h2{ + font-size:clamp(38px,5vw,64px); + margin-top:38px +} +.card.expanded .summary{ + max-width:55ch +} +.detail{ + width:100%; + max-width:680px +} +.detail[hidden]{ + display:none +} +.body{ + font-size:18px; + line-height:1.6 +} +.detail label{ + display:block; + font-weight:600; + margin:24px 0 18px +} +.detail textarea{ + display:block; + width:100%; + max-width:580px; + resize:vertical; + background:#ffffffa0; + border:1px solid #75837c; + border-radius:6px; + margin-top:8px; + padding:12px; + line-height:1.5 +} +.has-selection .card:not(.expanded){ + min-height:190px +} +.has-selection .card:not(.expanded) h2{ + font-size:26px; + margin-top:20px +} +.has-selection .card:not(.expanded) .summary{ + display:none +} +footer{ + padding-top:46px; + color:#53625c; + font-size:13px +} +@media(max-width:680px){ + .app{ + padding:20px 18px 40px +} +.intro{ + padding:52px 0 36px +} +.gallery{ + grid-template-columns:1fr +} +.card,.card.expanded{ + grid-column:1; + padding:26px +} +.card.expanded{ + min-height:440px +} +.toolbar{ + flex-wrap:wrap +} +.toolbar #status{ + margin-left:0; + width:100% +} + +} +@media(prefers-reduced-motion:reduce){ + html{ + scroll-behavior:auto +} + +} diff --git a/examples/card-detail/test.mjs b/examples/card-detail/test.mjs new file mode 100644 index 000000000..ef6ff8194 --- /dev/null +++ b/examples/card-detail/test.mjs @@ -0,0 +1,105 @@ +import { createServer } from 'vite'; +import { chromium, firefox, webkit } from '@playwright/test'; +import { dirname } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { readFileSync } from 'node:fs'; +import { createHash } from 'node:crypto'; +import { execFileSync } from 'node:child_process'; + +const root = dirname(fileURLToPath(import.meta.url)); +const receipt = JSON.parse(readFileSync(new URL('./.artifacts/package.json', import.meta.url))); +const installedBytes = readFileSync(new URL('./node_modules/@labpics/motion/package.json', import.meta.url)); +const installed = JSON.parse(installedBytes); +const head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' }).trim(); +if (execFileSync('git', ['status', '--porcelain'], { cwd: root, encoding: 'utf8' }).trim()) { + throw new Error('Рабочее дерево изменено после подготовки архива'); +} +const digest = createHash('sha256').update(installedBytes).digest('hex'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +const archiveDigest = hash(readFileSync(new URL('./.artifacts/package.tgz', import.meta.url))); +const projectionDigest = hash(readFileSync(new URL('./node_modules/@labpics/motion/dist/projection/index.js', import.meta.url))); +if (receipt.source !== head || receipt.sourceDirty !== false || receipt.manifestSha256 !== digest || + receipt.package !== installed.name || receipt.version !== installed.version || + receipt.archiveSha256 !== archiveDigest || receipt.projectionSha256 !== projectionDigest) { + throw new Error('Пример не связан с установленным архивом'); +} +const server = await createServer({ root, server: { host: '127.0.0.1', port: 0 } }); +await server.listen(); +const address = server.httpServer.address(); +if (typeof address !== 'object' || address === null) throw new Error('Не найден адрес Vite'); +const url = `http://127.0.0.1:${address.port}`; +try { + for (const [name, browserType] of [['chromium', chromium], ['firefox', firefox], ['webkit', webkit]]) { + const browser = await browserType.launch(); + try { + const page = await browser.newPage({ viewport: { width: 1040, height: 800 } }); + await page.goto(url); + const light = page.locator('[data-id="light"]'); + const space = page.locator('[data-id="space"]'); + await light.locator('[data-open]').click(); + if (!(await light.locator('.detail').isVisible())) throw new Error(`${name}: подробности не открылись`); + await light.locator('textarea').fill('Мой текст'); + await space.locator('[data-open]').click(); + if (!(await space.locator('.detail').isVisible())) throw new Error(`${name}: другое содержание не открылось`); + await page.keyboard.press('Escape'); + if (await space.locator('.detail').isVisible()) throw new Error(`${name}: Escape не закрыл подробности`); + if (!(await space.locator('[data-open]').evaluate(el => el === document.activeElement))) throw new Error(`${name}: фокус не восстановлен`); + await light.locator('[data-open]').click(); + if (await light.locator('textarea').inputValue() !== 'Мой текст') throw new Error(`${name}: заметка потеряна`); + await page.evaluate(() => { + window.__cardMeasures = 0; + const measure = HTMLElement.prototype.getBoundingClientRect; + HTMLElement.prototype.getBoundingClientRect = function () { + if (this.matches('[data-id]')) window.__cardMeasures++; + return measure.call(this); + }; + }); + await page.waitForFunction(() => document.querySelector('[data-id="light"]').style.transform !== '', null, { timeout: 5_000 }); + await page.evaluate(() => { window.__cardMeasures = 0; }); + await page.setViewportSize({ width: 390, height: 760 }); + await page.waitForFunction(() => window.__cardMeasures > 0, null, { timeout: 5_000 }); + if (await page.evaluate(() => window.__cardMeasures) === 0) throw new Error(`${name}: размер изменился во время полёта без нового замера цели`); + await page.keyboard.press('Escape'); + await light.locator('[data-open]').click(); + await page.waitForFunction(() => document.querySelector('[data-id="light"]').style.transform !== '', null, { timeout: 5_000 }); + await page.evaluate(() => { window.__cardMeasures = 0; }); + await light.locator('textarea').evaluate(el => { el.style.height = '220px'; }); + await page.waitForFunction(() => window.__cardMeasures > 0, null, { timeout: 5_000 }); + if (await page.evaluate(() => window.__cardMeasures) === 0) throw new Error(`${name}: изменение контента во время полёта не обновило цель`); + await page.waitForFunction(() => document.querySelector('[data-id="light"]').style.transform === '', null, { timeout: 5_000 }); + if (await light.evaluate(el => el.style.transform !== '')) throw new Error(`${name}: изменённая геометрия не завершила полёт`); + if (await page.evaluate(() => document.documentElement.scrollWidth > innerWidth)) throw new Error(`${name}: горизонтальный переполненный экран`); + await page.keyboard.press('Escape'); + await light.locator('[data-open]').click(); + await page.evaluate(() => { + window.dispatchEvent(new Event('resize')); + window.dispatchEvent(new Event('pagehide')); + window.dispatchEvent(new Event('pageshow')); + window.__cardMeasures = 0; + }); + await page.keyboard.press('Escape'); + await page.evaluate(() => { window.__cardMeasures = 0; window.dispatchEvent(new Event('resize')); }); + await page.waitForFunction(() => window.__cardMeasures > 0, null, { timeout: 5_000 }); + if (await page.evaluate(() => window.__cardMeasures) === 0) throw new Error(`${name}: возврат после pagehide отключил изменение цели`); + await page.locator('#motion').click(); + if (await page.locator('#motion').getAttribute('aria-pressed') !== 'true') throw new Error(`${name}: контроль движения не включился`); + if (await light.evaluate(el => el.style.transform !== '')) throw new Error(`${name}: движение не остановлено`); + await light.locator('[data-open]').click(); + await page.setViewportSize({ width: 1040, height: 800 }); + await page.locator('#direction').selectOption('rtl'); + if (await page.locator('#gallery').getAttribute('dir') !== 'rtl') throw new Error(`${name}: направление не изменилось`); + const positions = await page.locator('[data-id="space"], [data-id="color"]').evaluateAll(elements => elements.map(el => el.getBoundingClientRect().x)); + if (!(positions[0] > positions[1])) throw new Error(`${name}: RTL не поменял геометрию карточек`); + await page.keyboard.press('Escape'); + if (!(await light.locator('[data-open]').evaluate(el => el === document.activeElement))) throw new Error(`${name}: RTL нарушил возврат фокуса`); + await light.locator('[data-open]').click(); + if (await light.evaluate(el => el.style.transform !== '')) throw new Error(`${name}: режим без движения создал полёт`); + const reducedPage = await browser.newPage({ reducedMotion: 'reduce' }); + await reducedPage.goto(url); + await reducedPage.locator('[data-id="light"] [data-open]').click(); + if (await reducedPage.locator('[data-id="light"]').evaluate(el => el.style.transform !== '')) throw new Error(`${name}: системное снижение движения проигнорировано`); + await reducedPage.close(); + console.log(`${name}: PASS`); + } finally { await browser.close(); } + } +} finally { await server.close(); } diff --git a/examples/card-detail/tsconfig.json b/examples/card-detail/tsconfig.json new file mode 100644 index 000000000..b5e4ec9df --- /dev/null +++ b/examples/card-detail/tsconfig.json @@ -0,0 +1 @@ +{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"Bundler","types":["vite/client"],"lib":["ES2022","DOM"],"strict":true,"noEmit":true,"skipLibCheck":true},"include":["src/**/*.ts"]} diff --git a/examples/card-detail/vite.config.mjs b/examples/card-detail/vite.config.mjs new file mode 100644 index 000000000..2860ca64d --- /dev/null +++ b/examples/card-detail/vite.config.mjs @@ -0,0 +1,6 @@ +import { defineConfig } from 'vite'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const root = dirname(fileURLToPath(import.meta.url)); +export default defineConfig({ root, build: { outDir: resolve(root, 'dist'), emptyOutDir: true } }); diff --git a/examples/itinerary-sheet/README.md b/examples/itinerary-sheet/README.md new file mode 100644 index 000000000..2f34a6b2b --- /dev/null +++ b/examples/itinerary-sheet/README.md @@ -0,0 +1,22 @@ +# Маршрут выходного дня + +Пример непосредственного управления панелью маршрута. Пользователь выбирает остановку, читает детали и сохраняет заметку; данные принадлежат приложению и живут до закрытия страницы. Панель принимает указатель, стрелки, Home/End и кнопки остановок. Пакетные `CompositorSpring` и `createDecay` ведут захват, отпускание и доводку. Отдельные режимы «Без движения» и системный `prefers-reduced-motion` сохраняют те же целевые положения. + +Из корня репозитория: + +```sh +pnpm install --frozen-lockfile +node examples/itinerary-sheet/prepare.mjs +pnpm exec tsc -p examples/itinerary-sheet/tsconfig.json +pnpm exec vite build --config examples/itinerary-sheet/vite.config.mjs +``` + +Подготовка заново собирает пакет, устанавливает архив в `examples/itinerary-sheet/node_modules` и записывает `.artifacts/package.json` с SHA-256 архива, версией и наблюдаемым source commit. Эти поля идентифицируют используемые байты, но сами по себе не доказывают воспроизводимость сборки. + +Для ручной проверки запустите сервер; команда занимает терминал до остановки: + +```sh +pnpm exec vite --config examples/itinerary-sheet/vite.config.mjs +``` + +После открытия панели можно сменить остановку кнопками «Предыдущая» и «Следующая», не закрывая её. Для браузерного smoke запустите сервер на `127.0.0.1:4178`, затем `node examples/itinerary-sheet/smoke.mjs`. Smoke проверяет синтетическую последовательность `pagehide`/`pageshow`; она не удостоверяет, что конкретный браузер поместил страницу в bfcache. diff --git a/examples/itinerary-sheet/index.html b/examples/itinerary-sheet/index.html new file mode 100644 index 000000000..3c74fb336 --- /dev/null +++ b/examples/itinerary-sheet/index.html @@ -0,0 +1,39 @@ + + + + + + Маршрут выходного дня — Lab Motion + + +
    +
    Маршрут
    Выходной в городе · данные до закрытия страницы
    +
    +

    Суббота · пешая прогулка

    +

    Город в своём
    темпе.

    +

    Выберите точку на карте. Потяните панель, чтобы посмотреть детали, или откройте её кнопкой. Заметка к месту сохранится до закрытия страницы.

    +
    +
    +
    + + + + +

    Три остановки · около 4 км

    +
    +
    +
    +
    +

    Точка маршрута 01 / 03

    Городской сад

    10:00
    +

    Начните прогулку среди старых деревьев и тихих аллей.

    +
    +
    Время на месте45 минут
    Следующая точкаМузей · 12 минут пешком
    +
    +

    +
    +
    + +
    + + + diff --git a/examples/itinerary-sheet/package.json b/examples/itinerary-sheet/package.json new file mode 100644 index 000000000..3e12f5a0e --- /dev/null +++ b/examples/itinerary-sheet/package.json @@ -0,0 +1,6 @@ +{ + "name": "@labpics/motion-itinerary-sheet-example", + "private": true, + "type": "module", + "dependencies": { "@labpics/motion": "0.3.0" } +} diff --git a/examples/itinerary-sheet/prepare.mjs b/examples/itinerary-sheet/prepare.mjs new file mode 100644 index 000000000..2fe293869 --- /dev/null +++ b/examples/itinerary-sheet/prepare.mjs @@ -0,0 +1,60 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const app = dirname(fileURLToPath(import.meta.url)); +const root = resolve(app, '../..'); +const temporary = mkdtempSync(join(tmpdir(), 'motion-itinerary-sheet-')); +const installed = join(app, 'node_modules', '@labpics', 'motion'); +const receiptPath = join(app, '.artifacts', 'package.json'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +try { + // Собранный dist игнорируется Git: повторная сборка связывает архив с текущим source. + if (process.platform === 'win32') execFileSync('cmd.exe', ['/d', '/s', '/c', 'pnpm build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + else execFileSync('pnpm', ['build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + const npmLocation = process.platform === 'win32' + ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }).split(/\r?\n/).find(Boolean) + : undefined; + const npmCli = npmLocation ? join(dirname(npmLocation), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined; + const command = process.platform === 'win32' ? process.execPath : 'npm'; + const args = process.platform === 'win32' ? [npmCli] : []; + if (process.platform === 'win32' && (!npmCli || !existsSync(npmCli))) throw new Error('Не найден npm CLI рядом с npm.cmd'); + const npmVersion = execFileSync(command, [...args, '--version'], { encoding: 'utf8' }).trim(); + process.stdout.write(`npm CLI: ${npmCli ?? command} (${npmVersion})\n`); + const [packed] = JSON.parse(execFileSync(command, + [...args, 'pack', '--ignore-scripts', '--json', '--pack-destination', temporary], + { cwd: root, encoding: 'utf8', timeout: 120_000 })); + if (!packed?.filename) throw new Error('npm pack не вернул имя архива'); + const archive = join(temporary, packed.filename); + const bytes = readFileSync(archive); + const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + if (manifest.version !== '0.3.0') throw new Error('Версия примера не совпадает с корневым пакетом'); + rmSync(installed, { recursive: true, force: true }); + mkdirSync(installed, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', archive, '-C', installed, '--strip-components=1'], { timeout: 120_000 }); + const installedManifest = readFileSync(join(installed, 'package.json')); + if (!installedManifest.equals(readFileSync(join(root, 'package.json')))) { + throw new Error('Установленный манифест не совпадает с архивом'); + } + const installedPackage = JSON.parse(installedManifest.toString('utf8')); + const exportPaths = value => typeof value === 'string' ? [value] : Object.values(value).flatMap(exportPaths); + const paths = exportPaths(installedPackage.exports); + for (const path of paths) { + if (typeof path !== 'string' || !path.startsWith('./') || !existsSync(join(installed, path))) { + throw new Error(`Не найден экспорт в архиве: ${path}`); + } + } + mkdirSync(dirname(receiptPath), { recursive: true }); + const sourceDirty = execFileSync('git', ['status', '--porcelain'], { cwd: root, encoding: 'utf8' }).trim().length > 0; + if (sourceDirty) throw new Error('Рабочее дерево изменено: архив нельзя связать с HEAD'); + writeFileSync(receiptPath, JSON.stringify({ source: execFileSync('git', ['rev-parse', 'HEAD'], + { cwd: root, encoding: 'utf8' }).trim(), sourceDirty, archiveSha256: hash(bytes), + manifestSha256: hash(installedManifest), npmVersion, package: manifest.name, version: manifest.version }, null, 2) + '\n'); + process.stdout.write(`Маршрут: установлен архив ${hash(bytes)}\n`); +} finally { + rmSync(temporary, { recursive: true, force: true }); +} diff --git a/examples/itinerary-sheet/smoke.mjs b/examples/itinerary-sheet/smoke.mjs new file mode 100644 index 000000000..2de7f708c --- /dev/null +++ b/examples/itinerary-sheet/smoke.mjs @@ -0,0 +1,116 @@ +import { chromium, firefox, webkit } from '@playwright/test'; + +const engineName = process.env.MOTION_BROWSER ?? 'chromium'; +const engine = { chromium, firefox, webkit }[engineName]; +if (!engine) throw new Error(`Неизвестный браузер: ${engineName}`); +const browser = await engine.launch({ headless: true }); +const page = await browser.newPage({ viewport: { width: 1100, height: 850 } }); +const errors = []; +page.on('pageerror', error => errors.push(error.message)); +try { + await page.addInitScript(() => window.addEventListener('pageshow', event => { + if (event.isTrusted && location.pathname === '/') sessionStorage.setItem('sheetReturnPersisted', String(event.persisted)); + })); + await page.goto('http://127.0.0.1:4178/', { waitUntil: 'networkidle' }); + const state = page.locator('#sheet-state'); + if (await state.textContent() !== 'Панель закрыта') throw new Error('Исходная панель не закрыта'); + await page.locator('#open-sheet').click(); + if (await state.textContent() !== 'Панель раскрыта') throw new Error('Панель не раскрылась'); + await page.locator('#note').fill('Увидеть старую оранжерею'); + await page.locator('#note-form button').click(); + await page.locator('[data-select-place="next"]').click(); + if (await page.locator('#place-title').textContent() !== 'Музей графики') throw new Error('Смена точки не обновила детали'); + await page.locator('[data-select-place="previous"]').click(); + if (await page.locator('#note').inputValue() !== 'Увидеть старую оранжерею') throw new Error('Заметка потеряна при возврате'); + await page.locator('#handle').focus(); + await page.keyboard.press('End'); + if (await state.textContent() !== 'Панель закрыта') throw new Error('Клавиатура не закрыла панель'); + await page.keyboard.press('ArrowUp'); + if (await state.textContent() !== 'Панель наполовину') throw new Error('Клавиатура не открыла среднее положение'); + await page.locator('#quiet-sheet').click(); + await page.locator('[data-snap="0"]').click(); + if (await page.locator('#quiet').getAttribute('aria-pressed') !== 'true') throw new Error('Режим без движения не включился'); + if (await state.textContent() !== 'Панель раскрыта') throw new Error('Snap не сработал в режиме без движения'); + await page.screenshot({ path: 'examples/itinerary-sheet/.artifacts/desktop.png' }); + await page.locator('#quiet-sheet').click(); + await page.setViewportSize({ width: 430, height: 650 }); + await page.locator('[data-snap="2"]').click(); + await page.waitForTimeout(500); + async function upwardDrag(dwellMs, amount = 220, shouldOpen = true) { + const box = await page.locator('#handle').boundingBox(); + if (!box) throw new Error('Ручка не видна'); + const dragX = box.x + box.width / 3, dragY = box.y + box.height / 2; + await page.mouse.move(dragX, dragY); await page.mouse.down(); + await page.mouse.move(dragX, dragY - amount, { steps: 8 }); + if (dwellMs) await page.waitForTimeout(dwellMs); + await page.mouse.up(); + const opened = await state.textContent() !== 'Панель закрыта'; + if (opened !== shouldOpen) throw new Error(`Жест ${amount}px с ожиданием ${dwellMs}ms выбрал неверное положение`); + } + await upwardDrag(0); + await page.locator('[data-snap="2"]').click(); await page.waitForTimeout(500); + await upwardDrag(100); + await page.locator('[data-snap="2"]').click(); await page.waitForTimeout(500); + await upwardDrag(0, 70); + await page.locator('[data-snap="2"]').click(); await page.waitForTimeout(500); + await upwardDrag(180, 70, false); + await page.locator('[data-snap="2"]').click(); await page.waitForTimeout(500); + const reverseBox = await page.locator('#handle').boundingBox(); + if (!reverseBox) throw new Error('Ручка не видна для разворота'); + const reverseX = reverseBox.x + reverseBox.width / 3, reverseY = reverseBox.y + reverseBox.height / 2; + await page.mouse.move(reverseX, reverseY); await page.mouse.down(); + await page.mouse.move(reverseX, reverseY - 130, { steps: 6 }); + await page.waitForTimeout(120); + await page.mouse.move(reverseX, reverseY - 30, { steps: 6 }); await page.mouse.up(); + if (await state.textContent() !== 'Панель закрыта') throw new Error('Разворот жеста не сохранил закрытое положение'); + const cancelBox = await page.locator('#handle').boundingBox(); + if (!cancelBox) throw new Error('Ручка не видна для отмены'); + const cancelX = cancelBox.x + cancelBox.width / 3, cancelY = cancelBox.y + cancelBox.height / 2; + await page.locator('#handle').evaluate(element => element.addEventListener('pointerdown', event => { window.__dragPointer = event.pointerId; }, { once: true })); + await page.mouse.move(cancelX, cancelY); await page.mouse.down(); + await page.mouse.move(cancelX, cancelY - 220, { steps: 8 }); + await page.locator('#handle').evaluate(element => element.dispatchEvent(new PointerEvent('pointercancel', { bubbles: true, pointerId: window.__dragPointer }))); + await page.mouse.up(); + if (await state.textContent() !== 'Панель закрыта') throw new Error('Отмена жеста изменила выбранное положение'); + const handle = await page.locator('#handle').boundingBox(); + if (!handle) throw new Error('Ручка не видна'); + const x = handle.x + handle.width / 3, y = handle.y + handle.height / 2; + await page.mouse.move(x, y); await page.mouse.down(); + await page.setViewportSize({ width: 460, height: 710 }); + await page.mouse.move(x, y - 220, { steps: 8 }); await page.mouse.up(); + if (await state.textContent() === 'Панель закрыта') throw new Error('Pointer-жест не выбрал открытое положение'); + await page.locator('[data-snap="2"]').click(); + await page.emulateMedia({ reducedMotion: 'reduce' }); + await page.locator('[data-snap="0"]').click(); + if (await state.textContent() !== 'Панель раскрыта') throw new Error('Reduced-motion не сохранил доступную цель'); + await page.locator('[data-snap="2"]').click(); + await page.emulateMedia({ reducedMotion: 'no-preference' }); + await page.locator('[data-snap="0"]').click(); + const returnToMotion = await page.locator('#sheet').evaluate(element => new DOMMatrixReadOnly(getComputedStyle(element).transform).m42); + if (returnToMotion <= 0) throw new Error('После отключения reduced-motion не возобновилась анимация'); + await page.waitForFunction(() => Math.abs(new DOMMatrixReadOnly(getComputedStyle(document.querySelector('#sheet')).transform).m42) < 1); + await page.locator('[data-snap="1"]').click(); + await page.evaluate(() => { dispatchEvent(new PageTransitionEvent('pagehide', { persisted: true })); dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true })); }); + if (await state.textContent() !== 'Панель наполовину') throw new Error('Положение панели потеряно при возврате'); + if (await page.locator('#note').inputValue() !== 'Увидеть старую оранжерею') throw new Error('Заметка потеряна при возврате страницы'); + await page.locator('#open-sheet').click(); + if (await state.textContent() !== 'Панель раскрыта') throw new Error('Контроллер не восстановился при возврате'); + await page.waitForTimeout(700); + await page.screenshot({ path: 'examples/itinerary-sheet/.artifacts/mobile.png' }); + await page.route('http://127.0.0.1:4178/away', route => route.fulfill({ status: 200, contentType: 'text/html', body: 'Другая страница' })); + await page.evaluate(() => sessionStorage.removeItem('sheetReturnPersisted')); + await page.goto('http://127.0.0.1:4178/away'); + await page.goBack(); + await page.waitForFunction(() => sessionStorage.getItem('sheetReturnPersisted') !== null); + const persisted = await page.evaluate(() => sessionStorage.getItem('sheetReturnPersisted')); + const restoration = await page.evaluate(() => { + const nav = performance.getEntriesByType('navigation')[0]; + return 'notRestoredReasons' in nav ? JSON.stringify(nav.notRestoredReasons) : 'unavailable'; + }); + if (persisted === 'true') { + if (await state.textContent() !== 'Панель раскрыта') throw new Error('Реальный bfcache-возврат потерял положение'); + if (await page.locator('#note').inputValue() !== 'Увидеть старую оранжерею') throw new Error('Реальный bfcache-возврат потерял заметку'); + } + if (errors.length) throw new Error(`Ошибки страницы: ${errors.join('; ')}`); + process.stdout.write(`Itinerary sheet smoke (${engineName}): PASS; bfcache persisted=${persisted}; reasons=${restoration}\n`); +} finally { await browser.close(); } diff --git a/examples/itinerary-sheet/src/main.ts b/examples/itinerary-sheet/src/main.ts new file mode 100644 index 000000000..01af48c34 --- /dev/null +++ b/examples/itinerary-sheet/src/main.ts @@ -0,0 +1,158 @@ +import { CompositorSpring } from '@labpics/motion/compositor'; +import { createDecay } from '@labpics/motion/decay'; +import { createVelocityTracker } from '@labpics/motion/gestures'; +import './style.css'; + +type Place = { id: string; number: string; title: string; time: string; description: string; duration: string; next: string; note: string }; +const places: Place[] = [ + { id: 'garden', number: '01', title: 'Городской сад', time: '10:00', description: 'Начните прогулку среди старых деревьев и тихих аллей.', duration: '45 минут', next: 'Музей · 12 минут пешком', note: '' }, + { id: 'museum', number: '02', title: 'Музей графики', time: '11:00', description: 'Небольшая коллекция плакатов и книжной графики. Загляните в зал временной выставки.', duration: '60 минут', next: 'Набережная · 18 минут пешком', note: '' }, + { id: 'quay', number: '03', title: 'Старая набережная', time: '12:30', description: 'Закончите маршрут у воды: здесь удобно остановиться и пересмотреть сделанные заметки.', duration: '40 минут', next: 'Конец маршрута', note: '' }, +]; +let current = places[0]!; +let noMotion = false; +let lastSnap = 2; +const sheet = document.querySelector('#sheet')!; +const sheetTop = document.querySelector('.sheet-top')!; +const handle = document.querySelector('#handle')!; +const content = document.querySelector('#sheet-content')!; +const open = document.querySelector('#open-sheet')!; +const quietButton = document.querySelector('#quiet')!; +const quietSheetButton = document.querySelector('#quiet-sheet')!; +const status = document.querySelector('#motion-status')!; +const noteStatus = document.querySelector('#note-status')!; +const note = document.querySelector('#note')!; +const reduced = matchMedia('(prefers-reduced-motion: reduce)'); + +function renderPlace() { + document.querySelector('#place-number')!.textContent = current.number; + document.querySelector('#place-title')!.textContent = current.title; + document.querySelector('#place-time')!.textContent = current.time; + document.querySelector('#place-description')!.textContent = current.description; + document.querySelector('#place-duration')!.textContent = current.duration; + document.querySelector('#place-next')!.textContent = current.next; + note.value = current.note; noteStatus.textContent = ''; + const position = places.indexOf(current); + document.querySelector('[data-select-place="previous"]')!.disabled = position === 0; + document.querySelector('[data-select-place="next"]')!.disabled = position === places.length - 1; + document.querySelectorAll('[data-place]').forEach(button => button.setAttribute('aria-current', String(button.dataset.place === current.id))); +} + +function mountSheet() { + const events = new AbortController(); + const snap = () => { + const height = sheet.getBoundingClientRect().height; + return [0, Math.round(height * 0.48), Math.max(1, Math.round(height - sheetTop.getBoundingClientRect().height))]; + }; + let points = snap(); + let selected = lastSnap; + let pointer: number | undefined; + let anchor = 0; + let coordinate = 0; + let live: ReturnType | undefined; + const velocity = createVelocityTracker(); + const quiet = () => noMotion || reduced.matches; + const format = (value: number) => `translateY(${value}px)`; + const motion = new CompositorSpring({ + spring: { mass: 1, stiffness: 240, damping: 28 }, property: 'transform', + from: points[selected]!, to: points[selected]!, target: sheet, format, + apply: value => { sheet.style.transform = String(value); }, + matchMedia: () => ({ matches: quiet() }), + }); + sheet.style.transform = format(points[selected]!); + const bounded = (value: number) => Math.max(points[0]!, Math.min(points[2]!, value)); + function release() { + const captured = pointer; pointer = undefined; + if (captured !== undefined && handle.hasPointerCapture(captured)) handle.releasePointerCapture(captured); + } + function select(index: number) { + if (events.signal.aborted) return; + release(); live = undefined; selected = Math.max(0, Math.min(2, index)); lastSnap = selected; + if (quiet()) motion.handoffToLive(points[selected]!).snapTo(points[selected]!); + else motion.handoffToCompositor(points[selected]!); + const labels = ['Панель раскрыта', 'Панель наполовину', 'Панель закрыта']; + document.querySelector('#sheet-state')!.textContent = labels[selected]!; + status.textContent = labels[selected]!; + open.setAttribute('aria-expanded', String(selected !== 2)); + content.inert = selected === 2; + content.setAttribute('aria-hidden', String(selected === 2)); + sheet.querySelectorAll('[data-snap]').forEach(button => button.setAttribute('aria-pressed', String(Number(button.dataset.snap) === selected))); + if (selected === 2 && content.contains(document.activeElement)) open.focus({ preventScroll: true }); + } + const follow = (event: PointerEvent) => { + if (event.pointerId !== pointer || !live) return; + coordinate = event.clientY; + velocity.push({ x: event.clientX, y: event.clientY, t: event.timeStamp / 1000 }); + const goal = bounded(anchor + coordinate); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + }; + const finish = (event: PointerEvent, cancelled: boolean) => { + if (event.pointerId !== pointer || !live) return; + if (!cancelled) follow(event); + // До следующего кадра spring.value и spring.velocity могут быть старыми. + // Положение и скорость отпускания берём из одного жеста указателя. + const releaseGoal = bounded(anchor + event.clientY); + const rest = createDecay({ from: releaseGoal, velocity: velocity.velocity().vy }).rest; + const next = cancelled ? selected : points.reduce((best, value, index) => + Math.abs(value - rest) < Math.abs(points[best]! - rest) ? index : best, 0); + select(next); + }; + handle.addEventListener('pointerdown', event => { + if (!event.isPrimary || event.button !== 0 || pointer !== undefined) return; + event.preventDefault(); handle.focus({ preventScroll: true }); + live = motion.handoffToLive(); coordinate = event.clientY; anchor = live.value - coordinate; + velocity.reset(); velocity.push({ x: event.clientX, y: event.clientY, t: event.timeStamp / 1000 }); + pointer = event.pointerId; handle.setPointerCapture(pointer); + }, { signal: events.signal }); + handle.addEventListener('pointermove', follow, { signal: events.signal }); + handle.addEventListener('pointerup', event => finish(event, false), { signal: events.signal }); + handle.addEventListener('pointercancel', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('lostpointercapture', event => finish(event, true), { signal: events.signal }); + handle.addEventListener('keydown', event => { + if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return; + const next = event.key === 'Home' ? 0 : event.key === 'End' ? 2 : event.key === 'ArrowUp' ? selected - 1 : event.key === 'ArrowDown' ? selected + 1 : undefined; + if (next !== undefined) { event.preventDefault(); select(next); } + }, { signal: events.signal }); + const observer = new ResizeObserver(() => { + const next = snap(); + if (next.every((point, index) => point === points[index])) return; + points = next; + if (pointer !== undefined && live) { + anchor = live.value - coordinate; + const goal = bounded(live.value); + if (quiet()) live.snapTo(goal); else live.setTarget(goal); + } else select(selected); + }); + observer.observe(sheet); + observer.observe(sheetTop); + select(selected); + return { select, get selected() { return selected; }, destroy() { events.abort(); observer.disconnect(); release(); live = undefined; motion.destroy(); sheet.style.removeProperty('transform'); } }; +} + +let controller = mountSheet(); +renderPlace(); +open.addEventListener('click', () => controller.select(0)); +const remount = () => { controller.destroy(); controller = mountSheet(); }; +const toggleMotion = () => { noMotion = !noMotion; for (const button of [quietButton, quietSheetButton]) button.setAttribute('aria-pressed', String(noMotion)); remount(); }; +quietButton.addEventListener('click', toggleMotion); +quietSheetButton.addEventListener('click', toggleMotion); +reduced.addEventListener('change', remount); +document.querySelectorAll('[data-place]').forEach(button => button.addEventListener('click', () => { + current = places.find(place => place.id === button.dataset.place)!; + renderPlace(); controller.select(0); +})); +sheet.addEventListener('click', event => { + const placeButton = (event.target as Element).closest('[data-select-place]'); + if (placeButton && sheet.contains(placeButton)) { + const offset = placeButton.dataset.selectPlace === 'next' ? 1 : -1; + current = places[places.indexOf(current) + offset] ?? current; + renderPlace(); placeButton.focus({ preventScroll: true }); return; + } + const button = (event.target as Element).closest('[data-snap]'); + if (button && sheet.contains(button)) controller.select(Number(button.dataset.snap)); +}); +document.querySelector('#note-form')!.addEventListener('submit', event => { + event.preventDefault(); current.note = note.value; noteStatus.textContent = `Заметка к точке «${current.title}» сохранена`; +}); +window.addEventListener('pagehide', () => controller.destroy()); +window.addEventListener('pageshow', event => { if (event.persisted) remount(); }); diff --git a/examples/itinerary-sheet/src/style.css b/examples/itinerary-sheet/src/style.css new file mode 100644 index 000000000..de1fb09ce --- /dev/null +++ b/examples/itinerary-sheet/src/style.css @@ -0,0 +1,53 @@ +:root { font-family: Inter, ui-sans-serif, system-ui, sans-serif; color: #24332f; background: #e9eee9; } +* { box-sizing: border-box; } +body { margin: 0; } +button, textarea { font: inherit; } +button { cursor: pointer; } +.app { min-height: 100vh; padding: 0 max(24px, calc((100vw - 1160px)/2)); overflow: hidden; } +.top { display: flex; justify-content: space-between; gap: 20px; align-items: center; min-height: 80px; border-bottom: 1px solid #cbd7cf; color: #67796d; font-size: 13px; } +.brand { font-size: 20px; font-weight: 750; color: #264338; } +.brand span { display: inline-grid; place-items: center; background: #264338; color: white; width: 35px; height: 35px; border-radius: 50%; margin-right: 8px; } +.overview { padding: 50px 0 20px; position: relative; z-index: 1; } +.eyebrow { text-transform: uppercase; letter-spacing: .16em; color: #9a6550; font-size: 11px; font-weight: 750; } +h1 { margin: 14px 0; font: 400 clamp(52px, 6vw, 82px)/1.04 Georgia, serif; letter-spacing: -.05em; } +h1 em { color: #a67054; } +.lead { max-width: 530px; color: #65776d; line-height: 1.6; font-size: 15px; } +.toolbar { display: flex; gap: 10px; flex-wrap: wrap; margin-top: 24px; } +.toolbar button { border-radius: 8px; padding: 12px 18px; border: 1px solid #315444; background: #315444; color: white; } +.toolbar #quiet { background: transparent; color: #315444; } +.toolbar #quiet[aria-pressed=true] { background: #d5e0d6; } +.map { position: relative; min-height: 420px; margin-top: -40px; border: 1px solid #d4ded5; border-radius: 26px; background: radial-gradient(circle at 18% 36%, #dce9d5 0 9%, transparent 10%), radial-gradient(circle at 83% 50%, #dce9d5 0 14%, transparent 15%), repeating-linear-gradient(28deg, transparent 0 75px, #dce6dc 76px 78px, transparent 79px 150px), #f6f8f2; overflow: hidden; } +.map-line { position: absolute; inset: 34% 18% 23% 16%; border: 3px dashed #a1b69e; border-radius: 52% 40% 30% 60%; transform: rotate(-6deg); } +.stop { position: absolute; display: flex; align-items: center; gap: 8px; padding: 9px 13px 9px 8px; border: 1px solid #c5d5c6; border-radius: 24px; background: white; box-shadow: 0 8px 25px #2c51351c; color: #294538; font-weight: 700; } +.stop span { display: grid; place-items: center; width: 28px; height: 28px; border-radius: 50%; background: #315444; color: white; font-size: 11px; } +.stop[aria-current=true] { border-color: #a66f4d; box-shadow: 0 0 0 3px #e8c6ae; } +.stop-a { left: 12%; top: 22%; } .stop-b { left: 49%; top: 43%; } .stop-c { right: 9%; bottom: 19%; } +.map-hint { position: absolute; bottom: 12px; left: 25px; color: #718278; font-size: 12px; } +.sheet { position: fixed; z-index: 5; bottom: 0; left: 50%; width: min(720px, 100%); height: min(76vh, 690px); border: 1px solid #d3dbd0; border-bottom: 0; border-radius: 24px 24px 0 0; background: #fffefa; box-shadow: 0 -16px 65px #20382b3d; display: flex; flex-direction: column; translate: -50% 0; will-change: transform; } +.sheet-top { min-height: 68px; display: flex; align-items: center; justify-content: space-between; gap: 10px; padding: 6px 20px; border-bottom: 1px solid #e6e8e0; } +#handle { flex: 1; display: flex; align-items: center; gap: 12px; height: 54px; border: 0; background: transparent; color: #315444; text-align: left; font-size: 13px; font-weight: 700; touch-action: none; } +.grab { display: block; width: 35px; height: 5px; border-radius: 9px; background: #a9bdb0; } +.sheet-actions { display: flex; flex-wrap: wrap; gap: 5px; } +.sheet-actions button { border: 1px solid #d9e1d9; background: #f3f6f1; border-radius: 7px; padding: 8px; font-size: 11px; color: #385245; } +.sheet-actions button[aria-pressed=true] { background: #315444; color: white; } +#quiet-sheet[aria-pressed=true] { background: #315444; color: white; } +.sheet-content { overflow-y: auto; padding: 28px 36px 42px; } +.sheet-heading { display: flex; justify-content: space-between; gap: 20px; align-items: center; } +h2 { margin: 10px 0; font: 400 clamp(32px, 4vw, 48px) Georgia, serif; } +.time { font: 30px Georgia, serif; color: #a67054; } +.description { color: #5c6c60; line-height: 1.6; } +.place-nav { display: flex; gap: 9px; margin: 16px 0 22px; } +.place-nav button { border: 1px solid #cbd8cd; background: #f5f8f2; border-radius: 8px; padding: 9px 12px; color: #315444; } +.place-nav button:disabled { opacity: .45; cursor: default; } +.detail-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 14px; padding: 20px 0; border-top: 1px solid #e5eae2; border-bottom: 1px solid #e5eae2; } +.detail-grid div { display: flex; flex-direction: column; gap: 6px; } +.detail-label { color: #7b8b7e; font-size: 12px; } +.detail-grid strong { font-size: 14px; } +#note-form { display: flex; flex-direction: column; gap: 10px; margin-top: 24px; } +#note-form label { font-size: 14px; font-weight: 720; } +#note { width: 100%; resize: vertical; border: 1px solid #cbd8cd; border-radius: 8px; padding: 12px; background: #fff; } +#note-form button { align-self: start; border: 0; border-radius: 8px; background: #315444; padding: 11px 16px; color: white; } +#note-status { min-height: 22px; color: #315444; font-size: 13px; } +:focus-visible { outline: 3px solid #b87953; outline-offset: 3px; } +.visually-hidden { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; } +@media (max-width: 720px) { .app { padding: 0 16px; } .top > span { display: none; } .overview { padding-top: 35px; } .map { min-height: 390px; margin-top: 12px; } .sheet-top { flex-wrap: wrap; padding: 5px 16px 10px; } #handle { flex-basis: 100%; height: 32px; } .sheet-actions { width: 100%; } .sheet-actions button { padding: 6px; } .sheet-content { padding: 23px 20px; } .detail-grid { grid-template-columns: 1fr; } } diff --git a/examples/itinerary-sheet/tsconfig.json b/examples/itinerary-sheet/tsconfig.json new file mode 100644 index 000000000..0a1a73131 --- /dev/null +++ b/examples/itinerary-sheet/tsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "target": "ES2022", "module": "ESNext", "moduleResolution": "Bundler", + "lib": ["ES2022", "DOM", "DOM.Iterable"], "types": ["vite/client"], + "strict": true, "noEmit": true, "skipLibCheck": true + }, + "include": ["src/**/*.ts"] +} diff --git a/examples/itinerary-sheet/vite.config.mjs b/examples/itinerary-sheet/vite.config.mjs new file mode 100644 index 000000000..2860ca64d --- /dev/null +++ b/examples/itinerary-sheet/vite.config.mjs @@ -0,0 +1,6 @@ +import { defineConfig } from 'vite'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const root = dirname(fileURLToPath(import.meta.url)); +export default defineConfig({ root, build: { outDir: resolve(root, 'dist'), emptyOutDir: true } }); diff --git a/examples/reading-shelf/README.md b/examples/reading-shelf/README.md new file mode 100644 index 000000000..735e8adcd --- /dev/null +++ b/examples/reading-shelf/README.md @@ -0,0 +1,24 @@ +# Полка для чтения + +Самостоятельный пример коллекции с добавлением, удалением, состояниями чтения, фильтром и перестановкой. Порядок и состав принадлежат приложению; `@labpics/motion/behaviors/reorder` предлагает перестановку по текущей геометрии, а `@labpics/motion/projection` сопровождает подтверждённое изменение. Данные хранятся только до закрытия страницы. + +Из корня репозитория: + +```sh +pnpm install --frozen-lockfile +node examples/reading-shelf/prepare.mjs +pnpm exec tsc -p examples/reading-shelf/tsconfig.json +pnpm exec vite build --config examples/reading-shelf/vite.config.mjs +``` + +При запущенном сервере на порту 4177 smoke-сценарий проверяется командой `node examples/reading-shelf/smoke.mjs`. Переменная `MOTION_BROWSER` выбирает `chromium`, `firefox` или `webkit`; без неё используется Chromium. + +## Запуск + +Команда ниже запускает сервер и занимает терминал до остановки: + +```sh +pnpm exec vite --config examples/reading-shelf/vite.config.mjs --host 127.0.0.1 --port 4177 --strictPort +``` + +`prepare.mjs` заново собирает корневой пакет, затем создаёт `node_modules` внутри примера и устанавливает туда архив `npm pack`. `.artifacts/package.json` содержит SHA-256 архива и манифеста, версию npm, наблюдаемый исходный commit и признак грязного рабочего дерева. Commit и признак чистоты сами по себе не удостоверяют воспроизводимость сборки; точная идентичность используемых байтов — SHA-256 архива. Для проверки жеста возьмите кнопку «Переместить» мышью или нажмите на ней Enter, затем стрелки и Enter. Escape возвращает порядок до начала клавиатурного жеста; кнопки «Раньше» и «Позже» доступны отдельно. Фильтр, смена направления и добавление обновляют снимок списка. diff --git a/examples/reading-shelf/index.html b/examples/reading-shelf/index.html new file mode 100644 index 000000000..c7235491d --- /dev/null +++ b/examples/reading-shelf/index.html @@ -0,0 +1,46 @@ + + + + + + + Полка для чтения — пример Lab Motion + + +
    +
    +
    Полка для чтения
    + Демонстрация Lab Motion · данные остаются в этом окне +
    +
    +
    +

    Личная коллекция

    +

    Управляйте порядком,
    не теряя контекст.

    +

    Меняйте порядок мышью или клавиатурой, фильтруйте записи и добавляйте новые. Порядок принадлежит приложению; движение следует за ним.

    +
    +

    0записей
    на полке

    +
    +
    +
    +

    Коллекция

    Мои записи

    +
    + + + +
    +
    +
    + + + +
    +

    На кнопке «Переместить» нажмите Enter или пробел, затем стрелки; Enter сохранит порядок, Escape вернёт исходный. Кнопки «Раньше» и «Позже» дают ту же операцию без перетаскивания.

    +
    + +

    +
    +
    Пример сценария коллекции · Lab Motion
    +
    + + + diff --git a/examples/reading-shelf/package.json b/examples/reading-shelf/package.json new file mode 100644 index 000000000..243029056 --- /dev/null +++ b/examples/reading-shelf/package.json @@ -0,0 +1,8 @@ +{ + "name": "@labpics/motion-reading-shelf-example", + "private": true, + "type": "module", + "dependencies": { + "@labpics/motion": "0.3.0" + } +} diff --git a/examples/reading-shelf/prepare.mjs b/examples/reading-shelf/prepare.mjs new file mode 100644 index 000000000..74ca07413 --- /dev/null +++ b/examples/reading-shelf/prepare.mjs @@ -0,0 +1,60 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const app = dirname(fileURLToPath(import.meta.url)); +const root = resolve(app, '../..'); +const temporary = mkdtempSync(join(tmpdir(), 'motion-reading-shelf-')); +const installed = join(app, 'node_modules', '@labpics', 'motion'); +const receiptPath = join(app, '.artifacts', 'package.json'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +try { + // Собранный dist игнорируется Git: повторная сборка связывает архив с текущим source. + if (process.platform === 'win32') execFileSync('cmd.exe', ['/d', '/s', '/c', 'pnpm build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + else execFileSync('pnpm', ['build'], { cwd: root, stdio: 'inherit', timeout: 180_000 }); + const npmLocation = process.platform === 'win32' + ? execFileSync('where.exe', ['npm.cmd'], { encoding: 'utf8' }).split(/\r?\n/).find(Boolean) + : undefined; + const npmCli = npmLocation ? join(dirname(npmLocation), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined; + const command = process.platform === 'win32' ? process.execPath : 'npm'; + const args = process.platform === 'win32' ? [npmCli] : []; + if (process.platform === 'win32' && (!npmCli || !existsSync(npmCli))) throw new Error('Не найден npm CLI рядом с npm.cmd'); + const npmVersion = execFileSync(command, [...args, '--version'], { encoding: 'utf8' }).trim(); + process.stdout.write(`npm CLI: ${npmCli ?? command} (${npmVersion})\n`); + const [packed] = JSON.parse(execFileSync(command, + [...args, 'pack', '--ignore-scripts', '--json', '--pack-destination', temporary], + { cwd: root, encoding: 'utf8', timeout: 120_000 })); + if (!packed?.filename) throw new Error('npm pack не вернул имя архива'); + const archive = join(temporary, packed.filename); + const bytes = readFileSync(archive); + const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); + const consumer = JSON.parse(readFileSync(join(app, 'package.json'), 'utf8')); + if (consumer.dependencies?.[manifest.name] !== manifest.version) throw new Error('Версия примера не совпадает с корневым пакетом'); + rmSync(installed, { recursive: true, force: true }); + mkdirSync(installed, { recursive: true }); + const tar = process.platform === 'win32' ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'tar'; + execFileSync(tar, ['-xzf', archive, '-C', installed, '--strip-components=1'], { timeout: 120_000 }); + const installedManifest = readFileSync(join(installed, 'package.json')); + if (!installedManifest.equals(readFileSync(join(root, 'package.json')))) { + throw new Error('Установленный манифест не совпадает с архивом'); + } + const installedPackage = JSON.parse(installedManifest.toString('utf8')); + const exportPaths = value => typeof value === 'string' ? [value] : Object.values(value).flatMap(exportPaths); + const paths = exportPaths(installedPackage.exports); + for (const path of paths) { + if (typeof path !== 'string' || !path.startsWith('./') || !existsSync(join(installed, path))) { + throw new Error(`Не найден экспорт в архиве: ${path}`); + } + } + mkdirSync(dirname(receiptPath), { recursive: true }); + writeFileSync(receiptPath, JSON.stringify({ source: execFileSync('git', ['rev-parse', 'HEAD'], + { cwd: root, encoding: 'utf8' }).trim(), sourceDirty: execFileSync('git', ['status', '--porcelain'], + { cwd: root, encoding: 'utf8' }).trim().length > 0, archiveSha256: hash(bytes), + manifestSha256: hash(installedManifest), npmVersion, package: manifest.name, version: manifest.version }, null, 2) + '\n'); + process.stdout.write(`Полка: установлен архив ${hash(bytes)}\n`); +} finally { + rmSync(temporary, { recursive: true, force: true }); +} diff --git a/examples/reading-shelf/smoke.mjs b/examples/reading-shelf/smoke.mjs new file mode 100644 index 000000000..6cd45d9de --- /dev/null +++ b/examples/reading-shelf/smoke.mjs @@ -0,0 +1,74 @@ +import { chromium, firefox, webkit } from '@playwright/test'; + +const browsers = { chromium, firefox, webkit }; +const browserName = process.env.MOTION_BROWSER ?? 'chromium'; +if (!Object.hasOwn(browsers, browserName)) throw new Error(`Неподдерживаемый браузер: ${browserName}`); +const browser = await browsers[browserName].launch({ headless: true }); +const page = await browser.newPage({ viewport: { width: 1280, height: 900 } }); +const errors = []; +page.on('pageerror', error => errors.push(error.message)); +try { + await page.goto('http://127.0.0.1:4177/', { waitUntil: 'networkidle' }); + const cards = page.locator('[data-id]'); + if (await cards.count() !== 4) throw new Error('Исходная коллекция не показана'); + await page.locator('[data-id="b"] [data-move="previous"]').click(); + if (await cards.first().getAttribute('data-id') !== 'b') throw new Error('Перестановка не сохранилась'); + await page.waitForFunction(() => [...document.querySelectorAll('[data-id]')].every(card => card.style.transform === '')); + const grip = page.locator('[data-id="b"] [data-grip]'); + const target = page.locator('[data-id="d"]'); + const from = await grip.boundingBox(); const to = await target.boundingBox(); + if (!from || !to) throw new Error('Карточки не измерены'); + await page.mouse.move(from.x + from.width / 2, from.y + from.height / 2); + await page.mouse.down(); + await page.mouse.move(to.x + to.width / 2, to.y + to.height / 2, { steps: 5 }); + await page.mouse.up(); + if (await cards.last().getAttribute('data-id') !== 'b') throw new Error('Pointer перестановка не сохранилась'); + await page.locator('#filter').selectOption('queue'); + if (await cards.count() !== 2) throw new Error('Фильтр не применён'); + await page.locator('[data-id="b"] [data-grip]').focus(); + await page.keyboard.press('Enter'); + await page.keyboard.press('Home'); + if (await cards.first().getAttribute('data-id') !== 'b') throw new Error('Клавиатурная перестановка не сохранилась'); + if (await page.evaluate(() => document.activeElement?.closest('[data-id]')?.getAttribute('data-id')) !== 'b') throw new Error('Фокус потерян'); + await page.keyboard.press('Escape'); + if (await cards.last().getAttribute('data-id') !== 'b') throw new Error('Escape не вернул порядок'); + if (await page.evaluate(() => document.activeElement?.closest('[data-id]')?.getAttribute('data-id')) !== 'b') throw new Error('Escape потерял фокус'); + await page.locator('[data-id="d"] [data-grip]').focus(); + await page.keyboard.press('Enter'); + await page.locator('#filter').focus(); + if (await page.locator('[data-id="d"] [data-grip]').getAttribute('aria-pressed') !== 'false') throw new Error('Сессия осталась активной после ухода фокуса'); + await page.locator('[data-id="b"] [data-grip]').focus(); + await page.keyboard.press('Enter'); + if (await page.locator('[data-id="b"] [data-grip]').getAttribute('aria-pressed') !== 'true') throw new Error('Новая кнопка не начала сессию'); + await page.keyboard.press('Enter'); + await page.locator('#direction').click(); + if (await page.locator('#shelf').getAttribute('dir') !== 'rtl') throw new Error('RTL не включился'); + await page.locator('#motion').click(); + if (await page.locator('#motion').getAttribute('aria-pressed') !== 'true') throw new Error('Режим без движения не включился'); + await page.locator('#filter').selectOption('done'); + await page.locator('[data-id="c"] [data-remove]').click(); + if (!await page.locator('#empty').isVisible()) throw new Error('Пустое состояние не показано'); + await page.locator('#filter').selectOption('all'); + await page.locator('#new-title').fill('Новая книга'); + await page.locator('#add-form button').click(); + if (!await page.getByRole('heading', { name: 'Новая книга' }).isVisible()) throw new Error('Добавление не показано'); + await page.evaluate(() => { + dispatchEvent(new PageTransitionEvent('pagehide', { persisted: true })); + dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true })); + }); + const beforeRestoreMove = await cards.allTextContents(); + await page.locator('[data-id="b"] [data-move="previous"]').click(); + if (JSON.stringify(await cards.allTextContents()) === JSON.stringify(beforeRestoreMove)) throw new Error('Контроллер не восстановлен после возврата страницы'); + await page.setViewportSize({ width: 320, height: 700 }); + const inputFits = await page.evaluate(() => { + document.body.style.zoom = '200%'; + const input = document.querySelector('#new-title').getBoundingClientRect(); + const form = document.querySelector('#add-form').getBoundingClientRect(); + return input.right <= form.right + 1; + }); + if (!inputFits) throw new Error('Поле добавления вышло за форму при увеличении'); + if (errors.length) throw new Error(`Ошибки страницы: ${errors.join('; ')}`); + process.stdout.write(`Reading shelf smoke (${browserName}): PASS\n`); +} finally { + await browser.close(); +} diff --git a/examples/reading-shelf/src/main.ts b/examples/reading-shelf/src/main.ts new file mode 100644 index 000000000..8d00a4446 --- /dev/null +++ b/examples/reading-shelf/src/main.ts @@ -0,0 +1,130 @@ +import { createReorder, type ReorderSession, type ReorderStep } from '@labpics/motion/behaviors/reorder'; +import { createDomProjection } from '@labpics/motion/projection'; +import './style.css'; + +type Stage = 'queue' | 'reading' | 'done'; +type Entry = { id: string; title: string; stage: Stage }; +const entries: Entry[] = [ + { id: 'a', title: 'Искусство видеть', stage: 'reading' }, + { id: 'b', title: 'Город и память', stage: 'queue' }, + { id: 'c', title: 'Записки о цвете', stage: 'done' }, + { id: 'd', title: 'Короткая история света', stage: 'queue' }, +]; +let order = entries.map(item => item.id); +let filter: Stage | 'all' = 'all'; +let rtl = false; +let noMotion = false; +let session: ReorderSession | undefined; +let keyboardStart: string[] | undefined; +let pointer: number | undefined; +let rendering = false; +let origin = { x: 0, y: 0 }; +const shelf = document.querySelector('#shelf')!; +const status = document.querySelector('#status')!; +const empty = document.querySelector('#empty')!; +const total = document.querySelector('#total-count')!; +const filterInput = document.querySelector('#filter')!; +const direction = document.querySelector('#direction')!; +const motion = document.querySelector('#motion')!; +const media = matchMedia('(prefers-reduced-motion: reduce)'); +const projection = createDomProjection({ radius: false, matchMedia: () => ({ matches: noMotion || media.matches }) }); +const byId = (id: string) => entries.find(item => item.id === id)!; +const visible = () => order.filter(id => filter === 'all' || byId(id).stage === filter); +const cards = () => Array.from(shelf.querySelectorAll('[data-id]')); +const measure = () => visible().map(id => ({ key: id, rect: shelf.querySelector(`[data-id="${id}"]`)?.getBoundingClientRect() })); +const announce = (id: string) => { status.textContent = `${byId(id).title}: ${visible().indexOf(id) + 1} из ${visible().length}`; }; +let controller = makeController(); +function makeController() { + return createReorder({ items: measure(), direction: rtl ? 'rtl' : 'ltr', onReorder(next, proposal) { + if (!controller.isCurrent(proposal)) return; + const focused = document.activeElement as HTMLElement | null; + if (!noMotion && !media.matches) projection.capture(cards()); + const shown = new Set(visible()); + const positions = order.map((id, index) => ({ id, index })).filter(item => shown.has(item.id)).map(item => item.index); + next.forEach((id, index) => { order[positions[index]!] = id; }); + render(); + if (!noMotion && !media.matches) projection.play(); + focused?.focus({ preventScroll: true }); + announce(proposal.key); + } }); +} +function finish() { + session?.end(); session = undefined; + keyboardStart = undefined; + const captured = pointer; pointer = undefined; + if (captured !== undefined && shelf.hasPointerCapture(captured)) shelf.releasePointerCapture(captured); + shelf.querySelectorAll('[data-grip]').forEach(node => node.setAttribute('aria-pressed', 'false')); +} +function render() { + const existing = new Map(cards().map(card => [card.dataset.id!, card])); + rendering = true; + shelf.replaceChildren(...visible().map(id => { + const item = byId(id); + const previous = existing.get(id); + if (previous) { + previous.querySelector('.stage')!.textContent = { queue: 'На очереди', reading: 'Читаю', done: 'Прочитано' }[item.stage]; + previous.querySelector('[data-stage]')!.value = item.stage; + return previous; + } + const card = document.createElement('article'); card.className = 'card'; card.dataset.id = id; + const heading = document.createElement('h3'); heading.textContent = item.title; + const label = document.createElement('span'); label.className = 'stage'; label.textContent = { queue: 'На очереди', reading: 'Читаю', done: 'Прочитано' }[item.stage]; + const grip = document.createElement('button'); grip.type = 'button'; grip.dataset.grip = ''; grip.textContent = 'Переместить'; grip.setAttribute('aria-label', `Переместить «${item.title}»`); grip.setAttribute('aria-pressed', 'false'); + const before = document.createElement('button'); before.type = 'button'; before.dataset.move = 'previous'; before.textContent = 'Раньше'; + const after = document.createElement('button'); after.type = 'button'; after.dataset.move = 'next'; after.textContent = 'Позже'; + const select = document.createElement('select'); select.setAttribute('aria-label', `Состояние «${item.title}»`); + for (const [value, text] of [['queue', 'На очереди'], ['reading', 'Читаю'], ['done', 'Прочитано']]) { const option = new Option(text, value); select.add(option); } + select.value = item.stage; select.dataset.stage = ''; + const remove = document.createElement('button'); remove.type = 'button'; remove.dataset.remove = ''; remove.textContent = 'Удалить'; remove.setAttribute('aria-label', `Удалить «${item.title}»`); + const actions = document.createElement('div'); actions.className = 'actions'; actions.append(grip, before, after, select, remove); + card.append(label, heading, actions); return card; + })); + rendering = false; + empty.hidden = visible().length !== 0; total.textContent = String(entries.length); + controller.update(measure()); +} +function resetView() { finish(); controller.destroy(); controller = makeController(); render(); } +const cardFor = (target: EventTarget | null) => (target instanceof Element ? target.closest('[data-id]') : null); +shelf.addEventListener('click', event => { + const target = event.target as Element; const card = cardFor(target); if (!card) return; + const id = card.dataset.id!; + if (target.closest('[data-remove]')) { finish(); entries.splice(entries.findIndex(item => item.id === id), 1); order = order.filter(key => key !== id); render(); document.querySelector('#new-title')!.focus(); status.textContent = 'Запись удалена'; return; } + const move = target.closest('[data-move]')?.dataset.move as ReorderStep | undefined; + if (move) { finish(); controller.update(measure()); session = controller.start(id); session?.step(move); finish(); } +}); +shelf.addEventListener('change', event => { + const target = event.target as HTMLSelectElement; if (!target.matches('[data-stage]')) return; + const card = cardFor(target); if (!card) return; + finish(); byId(card.dataset.id!).stage = target.value as Stage; render(); if (!card.isConnected) filterInput.focus(); status.textContent = 'Состояние обновлено'; +}); +shelf.addEventListener('keydown', event => { + const target = event.target as Element; if (!target.matches('[data-grip]')) return; + const id = cardFor(target)?.dataset.id; if (!id) return; + if (event.key === 'Escape') { event.preventDefault(); const original = keyboardStart; finish(); if (original) { projection.cancel(); order = original; render(); shelf.querySelector(`[data-id="${id}"] [data-grip]`)?.focus({ preventScroll: true }); status.textContent = 'Перемещение отменено'; } return; } + if (event.key === ' ' || event.key === 'Enter') { event.preventDefault(); if (session?.active && controller.activeKey === id) finish(); else { finish(); controller.update(measure()); session = controller.start(id); if (session) keyboardStart = [...order]; target.setAttribute('aria-pressed', String(!!session)); announce(id); } return; } + const steps: Record = { ArrowLeft: 'left', ArrowRight: 'right', ArrowUp: 'up', ArrowDown: 'down', Home: 'first', End: 'last' }; + if (session?.active && steps[event.key]) { event.preventDefault(); controller.update(measure()); session.step(steps[event.key]!); } +}); +shelf.addEventListener('focusout', event => { + if (!rendering && (event.target as Element).matches('[data-grip]') && session?.active && pointer === undefined) finish(); +}); +shelf.addEventListener('pointerdown', event => { + if (event.button !== 0 || pointer !== undefined || !(event.target as Element).closest('[data-grip]')) return; + const card = cardFor(event.target); if (!card) return; + finish(); controller.update(measure()); session = controller.start(card.dataset.id!); if (!session) return; + event.preventDefault(); const rect = card.getBoundingClientRect(); origin = { x: rect.x + rect.width / 2 - event.clientX, y: rect.y + rect.height / 2 - event.clientY }; + pointer = event.pointerId; shelf.setPointerCapture(pointer); card.querySelector('[data-grip]')!.setAttribute('aria-pressed', 'true'); +}); +shelf.addEventListener('pointermove', event => { if (event.pointerId === pointer) session?.move({ x: event.clientX + origin.x, y: event.clientY + origin.y }); }); +for (const type of ['pointerup', 'pointercancel', 'lostpointercapture']) shelf.addEventListener(type, event => { if ((event as PointerEvent).pointerId === pointer) finish(); }); +filterInput.addEventListener('change', () => { filter = filterInput.value as Stage | 'all'; resetView(); status.textContent = `Показано ${visible().length}`; }); +direction.addEventListener('click', () => { rtl = !rtl; shelf.dir = rtl ? 'rtl' : 'ltr'; direction.setAttribute('aria-pressed', String(rtl)); resetView(); }); +motion.addEventListener('click', () => { noMotion = !noMotion; motion.setAttribute('aria-pressed', String(noMotion)); projection.cancel(); }); +media.addEventListener('change', () => { if (media.matches) projection.cancel(); }); +document.querySelector('#add-form')!.addEventListener('submit', event => { + event.preventDefault(); const input = document.querySelector('#new-title')!; const title = input.value.trim(); if (!title) return; + const id = crypto.randomUUID(); entries.push({ id, title, stage: 'queue' }); order.push(id); input.value = ''; filter = 'all'; filterInput.value = 'all'; finish(); render(); shelf.querySelector(`[data-id="${id}"] [data-grip]`)!.focus(); status.textContent = `Добавлено: ${title}`; +}); +window.addEventListener('pagehide', () => { finish(); controller.destroy(); projection.cancel(); }); +window.addEventListener('pageshow', event => { if (event.persisted) resetView(); }); +render(); diff --git a/examples/reading-shelf/src/style.css b/examples/reading-shelf/src/style.css new file mode 100644 index 000000000..d66282c6a --- /dev/null +++ b/examples/reading-shelf/src/style.css @@ -0,0 +1,44 @@ +:root { font-family: Inter, ui-sans-serif, system-ui, sans-serif; color: #202522; background: #f2f2ea; } +* { box-sizing: border-box; } +body { margin: 0; } +button, input, select { font: inherit; } +button { cursor: pointer; } +.app { max-width: 1200px; margin: auto; padding: 0 32px; } +.masthead { display: flex; justify-content: space-between; align-items: center; padding: 27px 0; border-bottom: 1px solid #d1d6cd; font-size: 14px; } +.brand { display: flex; align-items: center; gap: 10px; font-weight: 760; font-size: 18px; } +.brand-mark { display: grid; place-items: center; width: 32px; height: 32px; background: #293d35; color: white; border-radius: 8px; } +.edition, .intro-copy, .usage, footer { color: #69756b; } +.intro { display: flex; justify-content: space-between; gap: 40px; align-items: end; padding: 74px 0 68px; } +.eyebrow { text-transform: uppercase; letter-spacing: .15em; font-size: 11px; font-weight: 750; color: #8a6144; } +h1 { margin: 10px 0 18px; max-width: 720px; font-family: Georgia, serif; font-weight: 400; font-size: clamp(44px, 6vw, 78px); line-height: 1.05; letter-spacing: -.05em; } +h1 em { color: #9a674b; font-weight: 400; } +.intro-copy { max-width: 620px; line-height: 1.6; } +.intro-count { display: flex; gap: 12px; align-items: center; flex-shrink: 0; font-size: 12px; color: #67766a; } +.intro-count strong { font: 64px Georgia, serif; color: #283d34; } +.workspace { background: #fff; border: 1px solid #e1e5dc; border-radius: 18px; padding: 32px; box-shadow: 0 20px 60px #4658470c; } +.workspace-head, .controls, .add-form, .actions { display: flex; align-items: center; gap: 12px; } +.workspace-head { justify-content: space-between; flex-wrap: wrap; } +h2 { margin: 0 0 20px; font: 36px Georgia, serif; } +.controls { flex-wrap: wrap; } +.filter-label { font-size: 13px; color: #536055; } +.controls button, select, .actions button { border: 1px solid #d6ddd3; background: #fff; color: #314338; border-radius: 8px; padding: 9px 11px; } +.controls button[aria-pressed=true] { background: #304d3d; color: white; } +.add-form { margin-top: 20px; padding: 18px; background: #eef2eb; border-radius: 12px; flex-wrap: wrap; } +.add-form label { font-weight: 700; } +.add-form input { flex: 1; min-width: min(100%, 200px); padding: 12px; border: 1px solid #cbd6cb; border-radius: 8px; background: #fff; } +.add-form button { padding: 12px 16px; border: 0; border-radius: 8px; background: #304d3d; color: white; } +.usage { font-size: 13px; margin: 20px 0; } +.shelf { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 275px), 1fr)); gap: 16px; min-height: 100px; } +.card { min-height: 210px; padding: 22px; border: 1px solid #e3e7df; border-radius: 12px; background: #fafbf8; display: flex; flex-direction: column; } +.stage { font-size: 12px; color: #8a6144; } +.card h3 { font: 29px Georgia, serif; margin: 18px 0 auto; } +.actions { flex-wrap: wrap; gap: 7px; margin-top: 22px; } +.actions button, .actions select { font-size: 12px; padding: 7px 9px; } +.actions [data-grip] { touch-action: none; background: #e4ebe1; } +.actions [data-grip][aria-pressed=true] { background: #304d3d; color: white; } +.actions [data-remove] { margin-left: auto; color: #9b5341; } +.empty, .status { min-height: 20px; color: #536055; } +footer { padding: 30px 0 50px; font-size: 12px; } +footer span { color: #304d3d; font-weight: 700; } +:focus-visible { outline: 3px solid #ad7655; outline-offset: 3px; } +@media(max-width: 650px) { .app { padding: 0 16px; } .intro { padding: 45px 0; align-items: start; } .intro-count { display: none; } .workspace { padding: 18px; } .edition { display: none; } } diff --git a/examples/reading-shelf/tsconfig.json b/examples/reading-shelf/tsconfig.json new file mode 100644 index 000000000..fcb4c8002 --- /dev/null +++ b/examples/reading-shelf/tsconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "Bundler", + "types": ["vite/client"], + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "strict": true, + "noEmit": true, + "skipLibCheck": true + }, + "include": ["src/**/*.ts"] +} diff --git a/examples/reading-shelf/vite.config.mjs b/examples/reading-shelf/vite.config.mjs new file mode 100644 index 000000000..2860ca64d --- /dev/null +++ b/examples/reading-shelf/vite.config.mjs @@ -0,0 +1,6 @@ +import { defineConfig } from 'vite'; +import { dirname, resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const root = dirname(fileURLToPath(import.meta.url)); +export default defineConfig({ root, build: { outDir: resolve(root, 'dist'), emptyOutDir: true } }); diff --git a/examples/shot-inspector/prepare.mjs b/examples/shot-inspector/prepare.mjs index 631a4af93..c0d13f1b8 100644 --- a/examples/shot-inspector/prepare.mjs +++ b/examples/shot-inspector/prepare.mjs @@ -62,4 +62,3 @@ try { } finally { rmSync(temporary, { recursive: true, force: true }); } - diff --git a/package.json b/package.json index 31e711ca3..fedbf70e9 100644 --- a/package.json +++ b/package.json @@ -386,6 +386,16 @@ "default": "./dist/compositor/index.cjs" } }, + "./compositor/follow": { + "import": { + "types": "./dist/compositor/follow/index.d.ts", + "default": "./dist/compositor/follow/index.js" + }, + "require": { + "types": "./dist/compositor/follow/index.d.cts", + "default": "./dist/compositor/follow/index.cjs" + } + }, "./compositor/stagger": { "import": { "types": "./dist/compositor/stagger/index.d.ts", @@ -511,7 +521,7 @@ "typecheck": "tsc --noEmit", "typecheck:browser": "tsc --noEmit -p tsconfig.browser.json", "typecheck:motion-program": "tsc -p tsconfig.motion-program.json", - "test": "node scripts/check-docs-drift.mjs && vitest run", + "test": "pnpm build && node scripts/check-docs-drift.mjs && vitest run", "test:journey:behaviors-pareto": "pnpm build && vitest run test/journey-behaviors-pareto-budget.test.ts", "test:watch": "vitest", "naming:inventory": "node scripts/naming-inventory.mjs", diff --git a/scripts/bench-support.mjs b/scripts/bench-support.mjs index 0f596aa6a..f6dcd6fb0 100644 --- a/scripts/bench-support.mjs +++ b/scripts/bench-support.mjs @@ -1,5 +1,41 @@ /** Общие детерминированные швы Node-бенчмарков. */ +/** Штатный drain-clock stock C: без timestamp, с прежними handle и cap. */ +export function makeSynchronousDrainClock() { + let queue = []; + const requestFrame = (cb) => { + queue.push(cb); + return queue.length; // ненулевой handle + }; + const drain = (cap = 100000) => { + let n = 0; + while (queue.length && n < cap) { + const cb = queue.shift(); + cb(); + n++; + } + return n; + }; + return { requestFrame, drain }; +} + +/** Тело stock C общее; factory и чтение frame count находятся вне тайминга. */ +export function createMotionValueDefaultBenchmark(MotionValue, SPRING) { + let frames = 0; + const makeClock = makeSynchronousDrainClock; + const run = () => { + const clock = makeClock(); + let last = 0; + const mv = new MotionValue({ initial: 0, spring: SPRING, requestFrame: clock.requestFrame }); + mv.onChange((v) => (last = v)); + mv.setTarget(100); + frames = clock.drain(); + mv.destroy(); + return last; + }; + return { run, getFrameCount: () => frames }; +} + export function createBenchClock() { let queue = []; let requests = 0; diff --git a/scripts/bench-transform-support.mjs b/scripts/bench-transform-support.mjs index da5fe8f24..48c381401 100644 --- a/scripts/bench-transform-support.mjs +++ b/scripts/bench-transform-support.mjs @@ -93,8 +93,16 @@ function readTransform(text) { return state; } -function checkValues(text, expected, label) { - const actual = readTransform(text); +function checkValues(text, expected, label, parsedTransforms) { + // CSS string неизменяема; повторный разбор в одном verification context + // не меняет чтение raw или сравнение каждого expected channel. Кеш ограничен + // 64 короткими строками и принадлежит вызову validator, не измеряемому пакету. + const cacheable = parsedTransforms && typeof text === 'string' && text.length <= 4096; + let actual = cacheable && parsedTransforms.get(text); + if (!actual) { + actual = readTransform(text); + if (cacheable && parsedTransforms.size < 64) parsedTransforms.set(text, Object.freeze(actual)); + } for (const key of KEYS) { if (Math.abs(actual[key] - expected[key]) > TRANSFORM_PAIR_PROFILE.oracleAbsoluteTolerance) { throw new Error(`transform: ${label} ${key}=${actual[key]}, ожидалось ${expected[key]}`); @@ -109,6 +117,153 @@ async function flushReactions() { /** @typedef {{ status: 'pending' } | { status: 'fulfilled' } | { status: 'rejected', reason: unknown }} FinishedState */ +function requireLineage(condition, message) { + if (!condition) throw new Error(`transform lineage: ${message}`); +} + +function sameArray(actual, expected) { + return Array.isArray(actual) && actual.length === expected.length && Array.from(actual).every((value, index) => value === expected[index]); +} + +function caseTimeline({ lifecycle }) { + const profile = TRANSFORM_PAIR_PROFILE; + const setupOffsetsMs = lifecycle === 'fresh' ? [] : lifecycle === 'settled' + ? [...profile.previousSettledOffsetsMs] : [...profile.previousLiveOffsetsMs]; + return { + clockOriginMs: profile.clockOriginMs, setupOffsetsMs, frameOffsetsMs: [...profile.frameOffsetsMs], + successorBaseMs: profile.clockOriginMs + (setupOffsetsMs.length ? setupOffsetsMs.at(-1) + profile.successorGapMs : 0), + }; +} + +/** Позиции целей задаёт from/count; одинаковые записи сохраняются целиком, без hash-only замены. */ +function captureTargetTraces(slots, lifecycle) { + const runs = []; + let previousText; + for (let target = 0; target < slots.length; target++) { + const slot = slots[target]; + const trace = { + value: slot.value, + setup: lifecycle === 'fresh' ? [] : Array.from(slot.setup, (value) => value ?? null), + setupWrites: lifecycle === 'fresh' ? [] : Array.from(slot.setupWrites), + values: Array.from(slot.values, (value) => value ?? null), writes: Array.from(slot.writes), + outsideWrites: slot.outsideWrites, events: slot.events.map((event) => ({ ...event })), + }; + const text = JSON.stringify(trace); + if (text === previousText) runs.at(-1).count++; + else runs.push({ from: target, count: 1, trace }); + previousText = text; + } + return { encoding: 'runs', count: slots.length, runs }; +} + +/** Пересчитывает успешный sample из первичных clock/CSS записей, без статистики или новых порогов. */ +export function validateTransformLifecycleSample(sample, expectedCase) { + return replayTransformLifecycleSample(sample, expectedCase); +} + +// Повторные raw samples в одной серии используют один независимый CSS parser. +// Его memo скрыт в closure; вызывающий не может подставить разобранные значения. +export function createTransformLifecycleValidator() { + const parsedTransforms = new Map(); + return (sample, expectedCase) => replayTransformLifecycleSample(sample, expectedCase, parsedTransforms); +} + +function replayTransformLifecycleSample(sample, expectedCase, parsedTransforms) { + const profile = TRANSFORM_PAIR_PROFILE; + const { count, lifecycle, channels } = expectedCase ?? {}; + requireLineage(profile.counts.includes(count) && profile.lifecycles.includes(lifecycle) && profile.channels.includes(channels), 'неизвестный ожидаемый case'); + const raw = sample?.raw; + requireLineage(raw?.schemaVersion === 1 && raw.case?.count === count && raw.case?.lifecycle === lifecycle && raw.case?.channels === channels, 'case не соответствует владельцу'); + requireLineage(sample.semantic?.valid === true, 'отказ не является успешным sample'); + const expectedReads = [ + { metric: 'operationNs', frame: null, edge: 'before' }, { metric: 'operationNs', frame: null, edge: 'after' }, + ...profile.frameOffsetsMs.flatMap((_, frame) => [{ metric: 'frameNs', frame, edge: 'before' }, { metric: 'frameNs', frame, edge: 'after' }]), + { metric: 'cancelDrainNs', frame: null, edge: 'before' }, { metric: 'cancelDrainNs', frame: null, edge: 'after' }, + ]; + requireLineage(Array.isArray(raw.clockReads) && raw.clockReads.length === expectedReads.length, 'потеряны clock reads'); + const readings = raw.clockReads.map((read, sequence) => { + const expected = expectedReads[sequence]; + requireLineage(read?.sequence === sequence && read.metric === expected.metric && read.frame === expected.frame && read.edge === expected.edge, 'нарушен порядок clock reads'); + requireLineage(typeof read.valueNs === 'string' && /^-?(?:0|[1-9]\d*)$/.test(read.valueNs), 'clock read не является целым ns'); + const value = BigInt(read.valueNs); + requireLineage(value.toString() === read.valueNs, 'clock read не является каноническим StringBigInt'); + return value; + }); + for (let index = 1; index < readings.length; index++) requireLineage(readings[index] >= readings[index - 1], 'clock reads идут назад'); + const intervals = []; + const frameNs = []; + let operationNs; + let cancelDrainNs; + for (let index = 0; index < readings.length; index += 2) { + const read = raw.clockReads[index]; + const duration = readings[index + 1] - readings[index]; + const value = Number(duration); + requireLineage(Number.isFinite(value) && value >= 0, 'некорректный пересчитанный интервал'); + intervals.push({ metric: read.metric, frame: read.frame, beforeNs: read.valueNs, afterNs: raw.clockReads[index + 1].valueNs, durationNs: duration.toString() }); + if (read.metric === 'operationNs') operationNs = value; + else if (read.metric === 'cancelDrainNs') cancelDrainNs = value; + else frameNs.push(value); + } + requireLineage(sample.operationNs === operationNs && sample.cancelDrainNs === cancelDrainNs && + sameArray(sample.frameNs, frameNs), 'metric не пересчитывается из endpoints'); + const timeline = caseTimeline(expectedCase); + requireLineage(raw.timeline?.clockOriginMs === timeline.clockOriginMs && raw.timeline?.successorBaseMs === timeline.successorBaseMs && + sameArray(raw.timeline?.setupOffsetsMs, timeline.setupOffsetsMs) && sameArray(raw.timeline?.frameOffsetsMs, timeline.frameOffsetsMs), 'timeline не соответствует профилю'); + const expectedSteps = [ + ...timeline.setupOffsetsMs.map((offset, index) => ({ stage: 'setup', index, phase: 'setup', timestampMs: timeline.clockOriginMs + offset })), + ...(lifecycle === 'settled' ? [{ stage: 'settled-drain', index: null, phase: 'outside', timestampMs: timeline.clockOriginMs + timeline.setupOffsetsMs.at(-1) + 1 }] : []), + ...timeline.frameOffsetsMs.map((offset, index) => ({ stage: 'frame', index, phase: 'frames', timestampMs: timeline.successorBaseMs + offset })), + { stage: 'cancel-drain', index: null, phase: 'outside', timestampMs: timeline.successorBaseMs + profile.durationMs }, + ...[2, 3].map((factor) => ({ stage: 'idle', index: null, phase: 'outside', timestampMs: timeline.successorBaseMs + profile.durationMs * factor })), + ]; + requireLineage(Array.isArray(raw.timeline.steps) && raw.timeline.steps.length === expectedSteps.length, 'потеряны или добавлены scheduler steps'); + for (let sequence = 0; sequence < raw.timeline.steps.length; sequence++) { + const step = raw.timeline.steps[sequence]; + const expected = expectedSteps[sequence]; + requireLineage(step?.sequence === sequence && Object.keys(expected).every((key) => step[key] === expected[key]), 'нарушен порядок scheduler steps'); + } + const packed = raw.targetTraces; + requireLineage(packed?.encoding === 'runs' && packed.count === count && Array.isArray(packed.runs) && packed.runs.length > 0 && packed.runs.length <= count, 'некорректный target RLE'); + const expectedEvents = expectedSteps.map((step, sequence) => ({ ...step, step: sequence })).filter((step) => step.stage === 'setup' || step.stage === 'frame'); + let nextTarget = 0; + for (const run of packed.runs) { + requireLineage(run?.from === nextTarget && Number.isSafeInteger(run.count) && run.count > 0 && run.count <= count - nextTarget, 'RLE потерял или повторил target identity'); + const trace = run.trace; + requireLineage(trace && Array.isArray(trace.setup) && trace.setup.length === timeline.setupOffsetsMs.length && + Array.isArray(trace.setupWrites) && trace.setupWrites.length === trace.setup.length && Array.from(trace.setupWrites).every((value) => value === 1) && + Array.isArray(trace.values) && trace.values.length === frameNs.length && Array.isArray(trace.writes) && trace.writes.length === frameNs.length && + Array.from(trace.writes).every((value) => value === 1) && trace.outsideWrites === 0 && trace.value === trace.values.at(-1), 'неполная запись target'); + for (let frame = 0; frame < trace.setup.length; frame++) { + checkValues(trace.setup[frame], interpolate(INITIAL, PREVIOUS, timeline.setupOffsetsMs[frame] / profile.durationMs), `raw setup target ${run.from} frame ${frame}`, parsedTransforms); + } + for (let frame = 0; frame < trace.values.length; frame++) { + checkValues(trace.values[frame], expectedTransformValues(lifecycle, channels, timeline.frameOffsetsMs[frame]), `raw target ${run.from} frame ${frame}`, parsedTransforms); + } + requireLineage(Array.isArray(trace.events) && trace.events.length === expectedEvents.length, 'потеряны target write events'); + for (let sequence = 0; sequence < trace.events.length; sequence++) { + const event = trace.events[sequence]; + const expected = expectedEvents[sequence]; + const value = expected.stage === 'setup' ? trace.setup[expected.index] : trace.values[expected.index]; + requireLineage(event?.sequence === sequence && event.phase === expected.phase && event.index === expected.index && event.step === expected.step && + event.timestampMs === expected.timestampMs && event.property === 'transform' && event.value === value, 'write event не соответствует приобретённому кадру'); + } + const hash = createHash('sha256').update(JSON.stringify(trace.values)).digest('hex'); + const hashes = sample.semantic.targetTraceHashes; + if (Array.isArray(hashes)) { + requireLineage(hashes.length === count, 'потеряны target hashes'); + for (let target = run.from; target < run.from + run.count; target++) requireLineage(hashes[target] === hash, 'hash не соответствует raw CSS'); + } else { + requireLineage(hashes?.encoding === 'repeat' && hashes.count === count && hashes.value === hash, 'hash RLE не соответствует raw CSS'); + } + nextTarget += run.count; + } + requireLineage(nextTarget === count && sample.semantic.targets === count && sample.semantic.frames === frameNs.length && sample.semantic.finished === true && + sample.semantic.previousFinished === (lifecycle === 'fresh' ? null : true) && sample.semantic.onCompleteCalls === 0 && + sample.semantic.previousCompleteCalls === (lifecycle === 'settled' ? 1 : 0) && Number.isSafeInteger(sample.semantic.requests) && + sample.semantic.requests > 0 && sample.semantic.executions === sample.semantic.requests && sample.semantic.pending === 0, 'raw/semantic итог не соответствует case'); + return { operationNs, frameNs, cancelDrainNs, intervals, traceRuns: packed.runs }; +} + export async function runTransformLifecycleSample({ animate, count, lifecycle, channels, nowNs = () => process.hrtime.bigint() }) { const profile = TRANSFORM_PAIR_PROFILE; if (typeof animate !== 'function' || !profile.counts.includes(count) || @@ -116,17 +271,22 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c throw new Error('transform lifecycle: вход вне фиксированного профиля'); } const clock = createBenchClock(); + const clockReads = []; + const steps = []; + let currentStep = null; const frames = profile.frameOffsetsMs.length; const setupOffsets = lifecycle === 'settled' ? profile.previousSettledOffsetsMs : profile.previousLiveOffsetsMs; const slots = Array.from({ length: count }, () => ({ value: '', setup: new Array(setupOffsets.length), setupWrites: new Uint32Array(setupOffsets.length), - values: new Array(frames), writes: new Uint32Array(frames), outsideWrites: 0, + values: new Array(frames), writes: new Uint32Array(frames), outsideWrites: 0, events: [], })); let phase = 'outside'; let index = -1; const targets = slots.map((slot) => ({ style: { getPropertyValue: (name) => name === 'transform' ? slot.value : '', setProperty(name, value) { + slot.events.push({ sequence: slot.events.length, phase, index: phase === 'outside' ? null : index, + step: currentStep?.sequence ?? null, timestampMs: currentStep?.timestampMs ?? null, property: name, value }); slot.value = name === 'transform' ? value : `invalid:${name}`; if (phase === 'setup') { slot.setup[index] = slot.value; slot.setupWrites[index]++; } else if (phase === 'frames') { slot.values[index] = slot.value; slot.writes[index]++; } @@ -148,6 +308,23 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c duration: profile.durationMs, ease: LINEAR, requestFrame: clock.requestFrame, matchMedia: () => ({ matches: false }), onComplete: () => { onCompleteCalls++; }, }; + const readNs = (metric, frame, edge) => { + const value = nowNs(); + clockReads.push({ sequence: clockReads.length, metric, frame, edge, value }); + return value; + }; + // Время записи — общий последний предложенный scheduler timestamp, не чтение физических часов. + const step = (stage, frame, timestampMs) => { + currentStep = { sequence: steps.length, stage, index: frame, phase, timestampMs }; + steps.push(currentStep); + clock.step(timestampMs); + }; + const captureRaw = () => ({ + schemaVersion: 1, case: { count, lifecycle, channels }, + clockReads: clockReads.map(({ value, ...read }) => ({ ...read, valueNs: String(value) })), + timeline: { ...caseTimeline({ lifecycle }), steps: steps.map((entry) => ({ ...entry })) }, + targetTraces: captureTargetTraces(slots, lifecycle), + }); const pending = () => clock.requests - clock.executions; const requirePending = (expected, label) => { if (pending() !== expected) throw new Error(`transform scheduler: ${label} pending=${pending()}, ожидалось ${expected}`); @@ -155,7 +332,14 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c const requireLive = (label) => { if (pending() <= 0) throw new Error(`transform scheduler: ${label} отсутствует следующий callback`); }; - const frameNs = new Array(frames); + let operationNs = null; + const frameNs = []; + let cancelDrainNs = null; + let failurePhase = 'setup'; + let activeMetric = null; + let activeFrame = null; + let intervalBefore = null; + let intervalAfter = null; const cleanupErrors = []; const recordedFailure = Symbol('recorded lifecycle failure'); const requireNoRecordedFailures = () => { @@ -174,17 +358,29 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c } }; let cleanupStarted = false; + let cleanupCompleted = false; const cleanup = async () => { cleanupStarted = true; phase = 'outside'; + currentStep = null; // Каждый владелец и drain получают попытку очистки; throw undefined тоже сохраняется. try { controls?.cancel(); } catch (error) { cleanupErrors.push(error); } try { previous?.cancel(); } catch (error) { cleanupErrors.push(error); } for (let drain = 0; drain < 4 && pending() > 0; drain++) { - try { clock.step(timestamp + profile.durationMs * (4 + drain)); } catch (error) { cleanupErrors.push(error); } + try { step('cleanup-drain', null, timestamp + profile.durationMs * (4 + drain)); } catch (error) { cleanupErrors.push(error); } } await flushReactions(); + cleanupCompleted = true; }; + const failureSemantic = () => ({ + valid: false, targets: count, frames, phase, index, timestampBaseMs: timestamp, + finished: finished.status, previousFinished: lifecycle === 'fresh' ? null : previousFinished.status, + onCompleteCalls, previousCompleteCalls, requests: clock.requests, executions: clock.executions, pending: pending(), + targetTraces: slots.map((slot) => ({ + value: slot.value, setup: Array.from(slot.setup, (value) => value ?? null), setupWrites: Array.from(slot.setupWrites), + values: Array.from(slot.values, (value) => value ?? null), writes: Array.from(slot.writes), outsideWrites: slot.outsideWrites, + })), + }); try { if (lifecycle !== 'fresh') { previous = animate(targets, previousProps, { ...options, onComplete: () => { previousCompleteCalls++; } }); @@ -193,10 +389,11 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c phase = 'setup'; for (index = 0; index < setupOffsets.length; index++) { timestamp = profile.clockOriginMs + setupOffsets[index]; - clock.step(timestamp); + step('setup', index, timestamp); await flushReactions(); } phase = 'outside'; + currentStep = null; await flushReactions(); requireNoRecordedFailures(); if ((previousFinished.status === 'fulfilled') !== (lifecycle === 'settled') || previousCompleteCalls !== (lifecycle === 'settled' ? 1 : 0)) { @@ -210,49 +407,70 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c } // После естественного завершения один drain очищает уже поставленные callbacks. if (lifecycle === 'settled') { - clock.step(timestamp + 1); + step('settled-drain', null, timestamp + 1); await flushReactions(); + currentStep = null; } if (lifecycle === 'live') requireLive('setup end'); else requirePending(0, 'setup end'); timestamp += profile.successorGapMs; } - const operationBefore = nowNs(); + failurePhase = 'operation'; + activeMetric = 'operationNs'; + intervalBefore = readNs('operationNs', null, 'before'); controls = animate(targets, props, options); // Observer регистрируется до реакции и второго чтения часов: отказ часов не теряет finished. observeFinished(controls, (state) => { finished = state; }); await flushReactions(); - const operationNs = Number(nowNs() - operationBefore); + intervalAfter = readNs('operationNs', null, 'after'); + operationNs = Number(intervalAfter - intervalBefore); + activeMetric = null; requireLive('operation'); requireNoRecordedFailures(); if (finished.status === 'fulfilled' || onCompleteCalls !== 0 || (lifecycle !== 'fresh' && previousFinished.status !== 'fulfilled')) { throw new Error('transform: handoff finished/onComplete нарушен'); } phase = 'frames'; + failurePhase = 'frame'; for (index = 0; index < frames; index++) { - const before = nowNs(); - clock.step(timestamp + profile.frameOffsetsMs[index]); + activeMetric = 'frameNs'; + activeFrame = index; + intervalBefore = null; + intervalAfter = null; + intervalBefore = readNs('frameNs', index, 'before'); + step('frame', index, timestamp + profile.frameOffsetsMs[index]); await flushReactions(); - frameNs[index] = Number(nowNs() - before); + intervalAfter = readNs('frameNs', index, 'after'); + frameNs[index] = Number(intervalAfter - intervalBefore); + activeMetric = null; requireLive(`frame ${index}`); } phase = 'outside'; + currentStep = null; requireNoRecordedFailures(); if (finished.status === 'fulfilled' || onCompleteCalls !== 0) throw new Error('transform: преждевременный finished/onComplete'); - const cancelBefore = nowNs(); + failurePhase = 'cancel'; + activeMetric = 'cancelDrainNs'; + activeFrame = null; + intervalBefore = null; + intervalAfter = null; + intervalBefore = readNs('cancelDrainNs', null, 'before'); controls.cancel(); - clock.step(timestamp + profile.durationMs); + step('cancel-drain', null, timestamp + profile.durationMs); await flushReactions(); - const cancelDrainNs = Number(nowNs() - cancelBefore); + intervalAfter = readNs('cancelDrainNs', null, 'after'); + cancelDrainNs = Number(intervalAfter - intervalBefore); + activeMetric = null; requireNoRecordedFailures(); if (finished.status !== 'fulfilled' || onCompleteCalls !== 0 || previousCompleteCalls !== (lifecycle === 'settled' ? 1 : 0)) { throw new Error('transform: cancel finished/onComplete нарушен'); } requirePending(0, 'cancel drain'); const idleExecutions = clock.executions; - clock.step(timestamp + profile.durationMs * 2); - clock.step(timestamp + profile.durationMs * 3); + step('idle', null, timestamp + profile.durationMs * 2); + step('idle', null, timestamp + profile.durationMs * 3); // PASS относится к состоянию после всех эффектов, включая повторную отмену обоих владельцев. + failurePhase = 'cleanup'; await cleanup(); requireNoRecordedFailures(); requirePending(0, 'cleanup'); @@ -260,6 +478,7 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c throw new Error('transform: cleanup finished/onComplete нарушен'); } if (clock.executions !== idleExecutions) throw new Error('transform scheduler: stale idle callback'); + failurePhase = 'oracle'; const targetTraceHashes = slots.map((slot, target) => { if (slot.outsideWrites !== 0) throw new Error(`transform: target ${target} запись вне кадра`); for (let frame = 0; frame < frames; frame++) { @@ -269,22 +488,40 @@ export async function runTransformLifecycleSample({ animate, count, lifecycle, c if (slot.value !== slot.values[frames - 1]) throw new Error('transform: cancel изменил последнее значение'); return createHash('sha256').update(JSON.stringify(slot.values)).digest('hex'); }); + failurePhase = 'timing'; if ([operationNs, ...frameNs, cancelDrainNs].some((value) => !Number.isFinite(value) || value < 0)) { throw new Error('transform: некорректный timing'); } - return { operationNs, frameNs, cancelDrainNs, semantic: { + return { operationNs, frameNs, cancelDrainNs, raw: captureRaw(), semantic: { valid: true, targets: count, frames, targetTraceHashes, finished: finished.status === 'fulfilled', onCompleteCalls, previousFinished: lifecycle === 'fresh' ? null : previousFinished.status === 'fulfilled', previousCompleteCalls, requests: clock.requests, executions: clock.executions, pending: pending(), } }; } catch (error) { - if (!cleanupStarted) await cleanup(); + // Незавершённый интервал не закрывается часами очистки и не становится успешным замером. + const unfinishedInterval = activeMetric === null ? null : { + metric: activeMetric, frame: activeFrame, + beforeNs: typeof intervalBefore === 'bigint' || typeof intervalBefore === 'number' ? String(intervalBefore) : null, + afterNs: typeof intervalAfter === 'bigint' || typeof intervalAfter === 'number' ? String(intervalAfter) : null, + }; + const beforeCleanupSemantic = failureSemantic(); + if (!cleanupStarted) { + try { await cleanup(); } catch (cleanupError) { cleanupErrors.push(cleanupError); } + } const errors = error === recordedFailure ? [] : [error]; errors.push(...cleanupErrors); for (const state of [previousFinished, finished]) { if (state.status === 'rejected') errors.push(state.reason); } - if (error !== recordedFailure && errors.length === 1) throw error; - throw new AggregateError(errors, 'transform: sample и cleanup завершились ошибкой'); + // Снимок raw принадлежит оболочке отказа: исходный отказ может быть undefined или замороженным Error. + const message = errors.length === 1 && errors[0] instanceof Error + ? errors[0].message : 'transform: sample и cleanup завершились ошибкой'; + const retainTiming = (value) => value === null || Number.isFinite(value) + ? value : { kind: 'nonfinite', value: String(value) }; + throw Object.assign(new AggregateError(errors, message), { raw: { + ...captureRaw(), operationNs: retainTiming(operationNs), frameNs: frameNs.map(retainTiming), + cancelDrainNs: retainTiming(cancelDrainNs), failurePhase, unfinishedInterval, + beforeCleanupSemantic, semantic: failureSemantic(), cleanupCompleted, + } }); } } diff --git a/scripts/bench.mjs b/scripts/bench.mjs index 302958e2b..677aa4f04 100644 --- a/scripts/bench.mjs +++ b/scripts/bench.mjs @@ -31,8 +31,10 @@ import { } from '../bench/compare/methodology.mjs'; import { checksumTransformOutputs, + createMotionValueDefaultBenchmark, createSeededTransformStates, createSeededUnitInputs, + makeSynchronousDrainClock as makeClock, materializeTransformOutputs, reconstructedPartsBuildTransform, summarizeDistribution, @@ -66,27 +68,6 @@ const tokenModule = await import(distUrl('dist/tokens/index.js')); const easingModule = await import(distUrl('dist/easing/index.js')); const valueModule = await import(distUrl('dist/value/index.js')); -/** Синхронные дренируемые часы: requestFrame копит cb, drain гоняет их без ts - * (→ solver двигается фикс-шагом FIXED_DT_S). Handle ненулевой — drive/MV не - * ставят setTimeout-фоллбек, прогон остаётся синхронным. */ -function makeClock() { - let queue = []; - const requestFrame = (cb) => { - queue.push(cb); - return queue.length; // ненулевой handle - }; - const drain = (cap = 100000) => { - let n = 0; - while (queue.length && n < cap) { - const cb = queue.shift(); - cb(); - n++; - } - return n; - }; - return { requestFrame, drain }; -} - /** * Замер: median ns/op по `samples` сэмплам, в каждом — `iters` итераций. * Возвращает { nsPerOp, opsPerSec, sink }. `fn(i)` обязана возвращать число @@ -297,21 +278,12 @@ row('пустой loop/sink baseline', 'итерация', measure((i) => i & 1, // ── C. MotionValue прогон (макро: второй горячий цикл, v0-путь) ── { - let frames = 0; + const macro = createMotionValueDefaultBenchmark(MotionValue, SPRING); const r = measure( - () => { - const clock = makeClock(); - let last = 0; - const mv = new MotionValue({ initial: 0, spring: SPRING, requestFrame: clock.requestFrame }); - mv.onChange((v) => (last = v)); - mv.setTarget(100); - frames = clock.drain(); - mv.destroy(); - return last; - }, + macro.run, { iters: 2000, samples: 7 }, ); - row(`MotionValue прогон (${frames} кадров)`, 'прогон', r); + row(`MotionValue прогон (${macro.getFrameCount()} кадров)`, 'прогон', r); } // ── D. createDriver clamp:false (горячий путь: солвер+сходимость+эмит) ── diff --git a/scripts/check-error-catalog.mjs b/scripts/check-error-catalog.mjs index 3c56b86e9..850da5bf2 100644 --- a/scripts/check-error-catalog.mjs +++ b/scripts/check-error-catalog.mjs @@ -4,7 +4,7 @@ */ import { existsSync, readFileSync, readdirSync } from 'node:fs'; -import { extname, resolve } from 'node:path'; +import { dirname, extname, resolve } from 'node:path'; import { pathToFileURL } from 'node:url'; import ts from 'typescript'; @@ -118,7 +118,64 @@ function verifyFactory(node, sourceFile, file) { }; } -function constructorBindings(sourceFile) { +function isErrorsModule(moduleName) { + return /(?:^|\/)errors(?:\.js)?$/.test(moduleName); +} + +function constructorExportOrigins(sources) { + const modules = new Map(sources.map(([file, source]) => [resolve(file), + ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true)])); + const constructorModules = new Set(); + const reexports = new Map(); + const targetModule = (file, moduleName) => { + if (!moduleName.startsWith('.')) return undefined; + const path = resolve(dirname(file), moduleName); + return [path, path.replace(/\.jsx?$/, '.ts'), path.replace(/\.jsx?$/, '.tsx'), + `${path}.ts`, `${path}.tsx`, resolve(path, 'index.ts'), resolve(path, 'index.tsx')] + .find(candidate => modules.has(candidate)); + }; + const exportsConstructor = (file, moduleName) => { + const target = targetModule(resolve(file), moduleName); + return target !== undefined ? constructorModules.has(target) : + moduleName.startsWith('.') && isErrorsModule(moduleName); + }; + + for (const [file, sourceFile] of modules) { + const dependencies = []; + reexports.set(file, dependencies); + for (const statement of sourceFile.statements) { + if (ts.isClassDeclaration(statement) && statement.name?.text === 'MotionParamError' && + statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)) { + constructorModules.add(file); + } + if (!ts.isExportDeclaration(statement) || statement.isTypeOnly) continue; + const exported = statement.exportClause; + if (exported !== undefined && ts.isNamedExports(exported)) { + if (exported.elements.some(element => !element.isTypeOnly && + (element.propertyName ?? element.name).text === 'MotionParamError')) { + constructorModules.add(file); + } + } else if (statement.moduleSpecifier !== undefined && ts.isStringLiteral(statement.moduleSpecifier)) { + dependencies.push(statement.moduleSpecifier.text); + } + } + } + // Замыкание по runtime-реэкспортам не зависит от порядка файлов и циклов. + // Namespace запрещается у первого владельца, который упаковывает конструктор. + let changed; + do { + changed = false; + for (const [file, dependencies] of reexports) { + if (!constructorModules.has(file) && dependencies.some(moduleName => exportsConstructor(file, moduleName))) { + constructorModules.add(file); + changed = true; + } + } + } while (changed); + return exportsConstructor; +} + +function constructorBindings(sourceFile, exportsConstructor) { const bindings = new Set(['MotionParamError']); const namespaces = new Set(); const escapes = []; @@ -148,7 +205,7 @@ function constructorBindings(sourceFile) { const moduleName = ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : ''; - if (/(?:^|\/)errors(?:\.js)?$/.test(moduleName)) escapes.push(exported.name); + if (exportsConstructor(sourceFile.fileName, moduleName)) escapes.push(exported.name); continue; } if (!ts.isNamedExports(exported)) continue; @@ -195,6 +252,7 @@ function isTypeReference(node) { let current = node; while (current.parent !== undefined) { current = current.parent; + if ((ts.isExportSpecifier(current) || ts.isExportDeclaration(current)) && current.isTypeOnly) return true; if (ts.isTypeNode(current) || ts.isInterfaceDeclaration(current)) return true; if (ts.isStatement(current) || ts.isSourceFile(current)) return false; } @@ -228,17 +286,17 @@ function isConstructorProperty(node) { argument.text === 'MotionParamError'; } -function isDynamicErrorsImport(node) { +function isDynamicErrorsImport(node, file, exportsConstructor) { if (!ts.isCallExpression(node) || node.expression.kind !== ts.SyntaxKind.ImportKeyword) { return false; } const specifier = node.arguments[0]; return specifier !== undefined && (ts.isStringLiteral(specifier) || ts.isNoSubstitutionTemplateLiteral(specifier)) && - /(?:^|\/)errors(?:\.js)?$/.test(specifier.text); + exportsConstructor(file, specifier.text); } -function inspectMotionParamErrorSource(source, file = 'source.ts') { +function inspectMotionParamErrorSource(source, file = 'source.ts', exportsConstructor = (_file, moduleName) => isErrorsModule(moduleName)) { const sourceFile = ts.createSourceFile( file, source, @@ -249,7 +307,7 @@ function inspectMotionParamErrorSource(source, file = 'source.ts') { const calls = []; const errors = []; const factories = new Map(); - const constructorScope = constructorBindings(sourceFile); + const constructorScope = constructorBindings(sourceFile, exportsConstructor); const findFactories = (node) => { if (hasFactoryTag(node)) { @@ -286,7 +344,7 @@ function inspectMotionParamErrorSource(source, file = 'source.ts') { for (const node of constructorScope.escapes) escape(node); const visit = (node) => { if (innerConstructions.has(node)) return; - if (isDynamicErrorsImport(node)) { + if (isDynamicErrorsImport(node, sourceFile.fileName, exportsConstructor)) { escape(node); return; } @@ -306,7 +364,11 @@ function inspectMotionParamErrorSource(source, file = 'source.ts') { return; } if (ts.isIdentifier(node) && constructorScope.namespaces.has(node.text)) { - if (!isImportExportReference(node) && !isTypeReference(node)) escape(node); + // Именованный член эквивалентен named import. Вынос всего namespace + // (включая export) и computed-доступ могут скрыть конструктор ошибки. + const namedMember = ts.isPropertyAccessExpression(node.parent) && + node.parent.expression === node && node.parent.name.text !== 'MotionParamError'; + if (!namedMember && !ts.isNamespaceImport(node.parent) && !isTypeReference(node)) escape(node); return; } if (ts.isIdentifier(node) && constructorScope.bindings.has(node.text)) { @@ -355,9 +417,10 @@ export function validateErrorCatalog({ catalogText, sources }) { const catalog = parseErrorCatalog(catalogText); const errors = [...catalog.errors]; const uses = new Set(); + const exportsConstructor = constructorExportOrigins(sources); for (const [file, source] of sources) { - const inspected = inspectMotionParamErrorSource(source, file); + const inspected = inspectMotionParamErrorSource(source, file, exportsConstructor); errors.push(...inspected.errors); for (const call of inspected.calls) { const at = `${call.file}:${call.line}`; diff --git a/scripts/emit-declarations.mjs b/scripts/emit-declarations.mjs index 053af0c90..1980220f9 100644 --- a/scripts/emit-declarations.mjs +++ b/scripts/emit-declarations.mjs @@ -25,6 +25,8 @@ const OPTIONS = { strict: true, verbatimModuleSyntax: false, isolatedDeclarations: true, + // Внутренние hooks не обещают потребителю имена, переименованные runtime-сборкой. + stripInternal: true, }; /** Относительные .js-спецификаторы → .cjs (для require-ветки деклараций). */ diff --git a/scripts/motion-program-wire.ts b/scripts/motion-program-wire.ts index e699e0637..29b232ee8 100644 --- a/scripts/motion-program-wire.ts +++ b/scripts/motion-program-wire.ts @@ -395,6 +395,7 @@ export function decodeMotionProgramV1(input: Uint8Array): MotionProgramV1 { const strings = new Array(stringCount); let utf8Bytes = 0; + let codeUnits = 0; for (let i = 0; i < stringCount; i++) { const count = reader.u32(); utf8Bytes = checkedSize(utf8Bytes, count); @@ -406,6 +407,8 @@ export function decodeMotionProgramV1(input: Uint8Array): MotionProgramV1 { } catch { wireFailure(); } + codeUnits += decoded.length; + if (codeUnits > MOTION_PROGRAM_LIMITS_V1.maxStringCodeUnits) limitFailure(); // Даже fatal UTF-8 допускает хостовую обработку BOM; точный re-encode // оставляет для одной последовательности скаляров единственное представление. if (!sameBytes(UTF8.encode(decoded), encoded)) wireFailure(); diff --git a/scripts/pack-compat.mjs b/scripts/pack-compat.mjs index dcec7aba0..41327368f 100644 --- a/scripts/pack-compat.mjs +++ b/scripts/pack-compat.mjs @@ -37,6 +37,22 @@ const TSC5_BIN = join(ROOT, 'node_modules', 'typescript5', 'bin', 'tsc'); const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')); const suppliedTarball = process.argv[2] === undefined ? undefined : resolve(process.argv[2]); +// Один consumer-контракт проверяется всеми поставляемыми ветками деклараций. +const compositorSubclassContract = ` +class PublicSpringSubclass extends CompositorSpring { + readValue(): number { return this.value; } + override stop(): void { super.stop(); } + private inspectInternals(): void { + // @ts-expect-error Внутреннее значение не является subclass API. + this._from; + // @ts-expect-error Lifetime capability принадлежит владельцу. + this._now; + } + // @ts-expect-error Внутренний commit hook нельзя переопределить потребителю. + protected override _commitOwner(): void {} +} +`; + /** Субпути с обязательным peer-фреймворком — вне consumer-контракта голого пакета. */ const PEER_BINDING_SUBPATHS = new Set([ './react', @@ -185,17 +201,25 @@ try { join(dir, 'consumer.ts'), `import { spring, type SpringResult } from '${pkg.name}';\n` + `import { readCompositorSpring } from '${pkg.name}/compositor';\n` + + `import { createCompositorFollow, type CompositorFollow } from '${pkg.name}/compositor/follow';\n` + `import { CompositorSpring, CompositorStaggerGroup, compileSpringPlan, compileStaggerPlan, type CompositorStaggerPlan } from '${pkg.name}/compositor/stagger';\n` + `import { animate, type AnimateControls } from '${pkg.name}/animate';\n` + `import { animate as nanoAnimate, type NanoControls } from '${pkg.name}/nano';\n` + `import { createDrag } from '${pkg.name}/gestures';\n` + `import { createMotionConfig } from '${pkg.name}/a11y';\n` + + compositorSubclassContract + `const r: SpringResult = spring({ mass: 1, stiffness: 200, damping: 20 }, 0.1);\n` + `const v: number = r.value + r.velocity;\n` + `const plan = compileSpringPlan({ spring: { mass: 1, stiffness: 200, damping: 20 }, property: 'opacity', from: 0, to: 1 });\n` + `const staggerPlan: CompositorStaggerPlan = compileStaggerPlan({ spring: { mass: 1, stiffness: 200, damping: 20 }, property: 'opacity', from: 0, to: 1, count: 0 });\n` + `const single = new CompositorSpring({ spring: { mass: 1, stiffness: 200, damping: 20 }, property: 'opacity', from: 0, to: 1 });\n` + `const group = new CompositorStaggerGroup({ spring: { mass: 1, stiffness: 200, damping: 20 }, property: 'opacity', from: 0, to: 1, targets: [] });\n` + + `const follow: CompositorFollow = createCompositorFollow({ spring: { mass: 1, stiffness: 200, damping: 20 }, property: 'opacity', from: 0, to: 1, apply: () => {} });\n` + + `follow.beginFollow(0); follow.follow(0.2, 0.01); follow.settle(1, 0.02); follow.destroy();\n` + + `// @ts-expect-error Timestamp отпускания обязателен.\n` + + `follow.settle(1);\n` + + `// @ts-expect-error Внутренние lifecycle hooks не входят в consumer contract.\n` + + `follow._commitOwner();\n` + `const read = readCompositorSpring({ mass: 1, stiffness: 200, damping: 20 }, { t: 0.1 });\n` + `const drag = createDrag({ inertia: false });\n` + `const cfg = createMotionConfig({ reducedMotion: 'system' });\n` + @@ -286,7 +310,8 @@ try { `import { spring } from '${pkg.name}';\n` + `import { clamp } from '${pkg.name}/utils';\n` + `import { animate as nanoAnimate } from '${pkg.name}/nano';\n` + - `import { compileStaggerPlan } from '${pkg.name}/compositor/stagger';\n` + + `import { CompositorSpring, compileStaggerPlan } from '${pkg.name}/compositor/stagger';\n` + + compositorSubclassContract + `export const value: number = clamp(0, 1, spring({ mass: 1, stiffness: 200, damping: 20 }, 0.1).value);\n` + `export const motion = [nanoAnimate, compileStaggerPlan] as const;\n`, ); @@ -349,6 +374,7 @@ try { `import { spring, type SpringResult } from '${pkg.name}';\n` + `import { CompositorSpring, CompositorStaggerGroup, compileSpringPlan, compileStaggerPlan } from '${pkg.name}/compositor/stagger';\n` + `import { animate as nanoAnimate, type NanoControls } from '${pkg.name}/nano';\n` + + compositorSubclassContract + `const r: SpringResult = spring({ mass: 1, stiffness: 200, damping: 20 }, 0.1);\n` + `const physics = { mass: 1, stiffness: 200, damping: 20 };\n` + `const single = new CompositorSpring({ spring: physics, property: 'opacity', from: 0, to: 1 });\n` + diff --git a/scripts/pack-smoke.mjs b/scripts/pack-smoke.mjs index 0108fa25b..3f9d16b28 100644 --- a/scripts/pack-smoke.mjs +++ b/scripts/pack-smoke.mjs @@ -146,6 +146,66 @@ try { writeFileSync(join(app, 'cjs.cjs'), cjsProbe); log(execSync('node cjs.cjs', { cwd: app, encoding: 'utf8' }).trim()); + // Самодостаточный follow-entry проверяется после pack/install в обоих форматах. + const followProbe = (kind) => ` + globalThis.CSS = { supports: () => true }; + Object.defineProperty(globalThis, 'navigator', { configurable: true, value: { vendor: '', userAgent: 'Chromium' } }); + const { createCompositorFollow } = ${kind === 'esm' + ? `await import('${pkg.name}/compositor/follow')` + : `require('${pkg.name}/compositor/follow')`}; + const animations = []; + let frames = 0; + let written; + const owner = createCompositorFollow({ + spring: { mass: 1, stiffness: 170, damping: 26 }, property: 'opacity', from: 0, to: 100, + target: { animate() { const a = { currentTime: 16, cancelled: false, cancel() { this.cancelled = true; } }; animations.push(a); return a; } }, + apply(value) { written = value; }, now: () => 0, requestFrame: () => ++frames, + matchMedia: () => ({ matches: false }), + }); + owner.start(); + for (let turn = 1; turn <= 2; turn++) { + const value = owner.beginFollow(turn); + if (!Number.isFinite(value) || written !== value || !animations.at(-1).cancelled) throw new Error('follow pickup failed'); + owner.follow(value + 20, turn + 0.02); + owner.settle(100 * (turn + 1), turn + 0.02); + } + if (animations.length !== 3 || frames !== 0) throw new Error('native repeat became live'); + owner.destroy(); + if (animations.some((a) => !a.cancelled)) throw new Error('follow owner leaked'); + console.log('follow ${kind}: native repeat + terminal cleanup OK'); + `; + for (const kind of ['esm', 'cjs']) { + const file = kind === 'esm' ? 'follow.mjs' : 'follow.cjs'; + writeFileSync(join(app, file), followProbe(kind)); + log(execSync(`node ${file}`, { cwd: app, encoding: 'utf8' }).trim()); + } + + // Публичное наследование должно работать с теми же именами, что обещают типы. + for (const kind of ['esm', 'cjs']) { + const probe = ` + for (const sub of ['compositor', 'compositor/stagger']) { + const { CompositorSpring } = ${kind === 'esm' ? `await import('${pkg.name}/' + sub)` : `require('${pkg.name}/' + sub)`}; + class PublicSpring extends CompositorSpring { + readValue() { return this.value; } + stop() { super.stop(); } + } + const owner = new PublicSpring({ + spring: { mass: 1, stiffness: 170, damping: 26 }, property: 'opacity', + from: 7, to: 9, apply() {}, matchMedia: () => ({ matches: true }), + }); + if (owner.readValue() !== 7) throw new Error('subclass value'); + owner.start(); + owner.retarget(11); + if (owner.readValue() !== 11) throw new Error('subclass retarget'); + owner.stop(); owner.destroy(); + } + console.log('public subclass ${kind} OK'); + `; + const file = kind === 'esm' ? 'subclass.mjs' : 'subclass.cjs'; + writeFileSync(join(app, file), probe); + log(execSync(`node ${file}`, { cwd: app, encoding: 'utf8' }).trim()); + } + // 3. Публичный frame, фасад ./animate и zero-dependency binding обязаны разделять один // scheduler ИМЕННО после pack/install. Source-тест не ловит дублирование, // которое создаёт сборщик при `splitting: false`: три entry могли пройти все diff --git a/scripts/size-gate.mjs b/scripts/size-gate.mjs index 4b0f18121..b0d1e2327 100644 --- a/scripts/size-gate.mjs +++ b/scripts/size-gate.mjs @@ -139,6 +139,10 @@ export const IN_VIEW_CONSUMER_GATE_BYTES = 1908; // общего consumer-графа, не смешивая его с file-level потолком. export const COMPOSITOR_CAPABILITY_GATE_BYTES = 6600; +// Новый opt-in follow: не более 1 KiB сверх native-capability бюджета 6450 B. +// Предел установлен до первой сборки этого entry; прежние клетки не меняются. +export const COMPOSITOR_FOLLOW_GATE_BYTES = 6450 + 1024; + // Совместный consumer-граф ./animate + базового spring-компилятора. Exact // clean-base 7968d161 (2026-07-16): 12 494 B gz; потолок равен факту без люфта, // чтобы локальная оптимизация одного entry не покупалась дублированием между @@ -195,6 +199,7 @@ export const BESPOKE_SUBPATH_GATES = { // Групповой фасад самодостаточен и включает только нужные ему базовые план и // контроллер. Порог равен прежнему полному compositor-контракту, не новому факту. './compositor/stagger': 6450, + './compositor/follow': COMPOSITOR_FOLLOW_GATE_BYTES, // ./tokens — motion-токены (SSOT labui): duration/easing/spring/staggerGap + // distanceScale + springFromDurationBounce (каноническая пара ДС (duration,bounce) // → SpringParams; тянет validateSpringParams ядра, чтобы выход ГАРАНТИРОВАННО @@ -369,6 +374,11 @@ export const IMPORT_COST_SCENARIOS = [ code: `import { CompositorSpring, CompositorStaggerGroup, compileSpringPlan, compileStaggerPlan } from '%DIST%/../compositor/stagger/index.js'; console.log(CompositorSpring, CompositorStaggerGroup, compileSpringPlan, compileStaggerPlan);`, gate: COMPOSITOR_CAPABILITY_GATE_BYTES, }, + { + name: 'compositor-follow capability', + code: `import { createCompositorFollow, compileSpringPlan } from '%DIST%/../compositor/follow/index.js'; console.log(createCompositorFollow, compileSpringPlan);`, + gate: COMPOSITOR_FOLLOW_GATE_BYTES, + }, { // Cross-entry страж: фасад и прямой spring-компилятор часто сосуществуют; // их суммарная цена не выводится из двух изолированных сценариев. diff --git a/src/animate/index.ts b/src/animate/index.ts index eaa3d84bc..cf2741821 100644 --- a/src/animate/index.ts +++ b/src/animate/index.ts @@ -424,17 +424,25 @@ export function animate( let natural = 0; let setupDone = false; let resolveFinished!: (value: void | PromiseLike) => void; + let ownedOptions: AnimateOptions | undefined = options; // Наружу виден один lifecycle, поэтому один aggregate Promise заменяет N // скрытых Unit-deferred и не превращает массовый start в GC-hot-path. const maybeComplete = (): void => { if (!setupDone || done !== total) return; setupDone = false; // та же защёлка гасит повторную terminal-отчётность + // После последнего terminal report controls больше не владеют исполнителями. + // Освобождение до callback не затрагивает successor из onComplete. + units.length = 0; mainBatch = undefined; + // Public controls остаются у caller, но terminal aggregate больше не + // владеет компонентными callbacks/scheduler из configuration. + const completedOptions = ownedOptions!; + ownedOptions = undefined; // Thenable-adoption даёт промежуточную Promise job: уже поставленная // caller-микрозадача остаётся перед finished reactions. resolveFinished(ASYNC_FINISH); if (natural === total) { - try { options.onComplete?.(); } catch (error) { + try { completedOptions.onComplete?.(); } catch (error) { // Отчёт об ошибке callback не владеет lifecycle: hostile reporter не // может спрятать controls или заменить natural completion. try { @@ -450,8 +458,20 @@ export function animate( }; // Чистый compositor/reduced не создаёт main-state. WAAPI handoff и обычные // main slots одного aggregate делят kernel и исходный plan capacity. - const getMainBatch = (): SurfaceBatch => - mainBatch ??= surfaceBatchFor(options.requestFrame); + const getMainBatch = (): SurfaceBatch => { + if (mainBatch !== undefined) return mainBatch; + // Внешний getter является эффектом. Reflect.get сохраняет эту границу + // и в minified artifact: pure_getters не вправе перенести её за reentry guard. + const frame: AnimateOptions['requestFrame'] = Reflect.get(ownedOptions!, 'requestFrame'); + // Accessor может выполнить вложенный handoff того же aggregate: уже + // опубликованный batch остаётся единственным владельцем его live slots. + if (mainBatch !== undefined) return mainBatch; + const batch = surfaceBatchFor(frame); + // Accessor requestFrame может терминализировать aggregate. Его уже + // отозванная configuration не получает новый scheduler root обратно. + if (ownedOptions !== undefined) mainBatch = batch; + return batch; + }; // 4. Фаза commit в исходном target-major порядке. Владелец берётся из // record ЗДЕСЬ, а не сохраняется в плане: повтор цели в списке обязан diff --git a/src/animate/waapi-unit.ts b/src/animate/waapi-unit.ts index edf9ff6ac..ee103973f 100644 --- a/src/animate/waapi-unit.ts +++ b/src/animate/waapi-unit.ts @@ -103,7 +103,7 @@ export interface WaapiUnitOptions { /** Compositor-прогон группы: Element.animate + piecewise-прерывания. */ export class WaapiUnit implements GroupOwner { - private readonly _o: WaapiUnitOptions; + private _o: WaapiUnitOptions | undefined; private _done = false; private _paused = false; /** Блокирует реентрантные controls, пока terminal pose/семантика фиксируются. */ @@ -135,7 +135,8 @@ export class WaapiUnit implements GroupOwner { } _capture(): void { - const rec = this._o._record; + if (this._done) return; + const rec = this._o!._record; if (this._delegate || rec._transition || this._locked) return; // currentTime — hostile host-boundary: nested animate не должен успеть // опубликовать owner, после чего внешний снимок перезапишет новое видимое @@ -149,12 +150,13 @@ export class WaapiUnit implements GroupOwner { } _captureNum(key: string): ChannelSnapshot | undefined { + if (this._done) return undefined; if (this._delegate) return this._delegate._captureNum(key); - const ch = this._o._numeric.find((c) => c._key === key); + const ch = this._o!._numeric.find((c) => c._key === key); if (ch) { return { _value: ch._value, _velocity: ch._velocity }; } - const frozen = this._o._residuals.get(key); + const frozen = this._o!._residuals.get(key); return frozen === undefined ? undefined : { _value: frozen, _velocity: 0 }; } @@ -163,8 +165,9 @@ export class WaapiUnit implements GroupOwner { } _numericKeys(): readonly string[] { + if (this._done) return []; if (this._delegate) return this._delegate._numericKeys(); - return [...this._o._numeric.map((c) => c._key), ...this._o._residuals.keys()]; + return [...this._o!._numeric.map((c) => c._key), ...this._o!._residuals.keys()]; } _supersede(replacement?: () => void): void { @@ -190,6 +193,7 @@ export class WaapiUnit implements GroupOwner { /** Откат ещё не опубликованного successor без inline-записи. */ _rollback(): void { + if (this._done) return; this._transaction(() => { this._clearTimer(); this._cancelAnim(); @@ -200,7 +204,7 @@ export class WaapiUnit implements GroupOwner { // ── Контролы ────────────────────────────────────────────────────────────── pause(): void { - if (this._done || this._o._record._transition || this._locked || this._paused) return; + if (this._done || this._o!._record._transition || this._locked || this._paused) return; if (this._delegate !== undefined) { this._transaction(() => { this._delegate!.pause(); @@ -218,7 +222,7 @@ export class WaapiUnit implements GroupOwner { } play(): void { - if (this._done || this._o._record._transition || this._locked || !this._paused) return; + if (this._done || this._o!._record._transition || this._locked || !this._paused) return; if (this._delegate) { // Wrapper меняет состояние только после успешной подписки delegate: // бросок оставляет оба уровня повторяемо paused. @@ -246,7 +250,7 @@ export class WaapiUnit implements GroupOwner { seek(tMs: number): void { if ( this._done || - this._o._record._transition || + this._o!._record._transition || this._locked || !Number.isFinite(tMs) ) return; @@ -275,7 +279,7 @@ export class WaapiUnit implements GroupOwner { /** Стоп в текущей позиции: инлайн-фиксация ДО cancel (без отката к базе). */ cancel(): void { - if (this._done || this._o._record._transition || this._locked) return; + if (this._done || this._o!._record._transition || this._locked) return; if (this._delegate !== undefined) { this._transaction(() => this._delegate!.cancel()); return; @@ -294,7 +298,7 @@ export class WaapiUnit implements GroupOwner { /** Коммит плана в Element.animate (канон _emitCompositor CompositorSpring). */ private _emit(delayMs: number, artifact: SpringExecutionArtifactTuple): void { - const o = this._o; + const o = this._o!; const explicit = requiresExplicitSpringKeyframes(); const samples = artifact[1]; const durationMs = artifact[2]; @@ -345,7 +349,7 @@ export class WaapiUnit implements GroupOwner { this._transaction(() => { this._clearTimer(); this._cancelAnim(); - if (this._o._record._owner !== this || !this._paused) this._finish(false); + if (o._record._owner !== this || !this._paused) this._finish(false); }); throw error; } @@ -353,7 +357,7 @@ export class WaapiUnit implements GroupOwner { /** Строка/число группы при прогрессе p (края — точные from/to каналов). */ private _valueAt(p: number): string | number { - const o = this._o; + const o = this._o!; if (o._group === 'transform') { const state = o._transform!; for (const ch of o._numeric) state[ch._key] = channelAt(ch, p); @@ -371,7 +375,7 @@ export class WaapiUnit implements GroupOwner { delayMs, SPRING_SAMPLE, ); - for (const ch of this._o._numeric) { + for (const ch of this._o!._numeric) { // Та же устойчивая интерполяция, что у кадров WebKit: снимок MAX ↔ // -MAX не должен телепортироваться в цель из-за переполнения. ch._value = channelAt(ch, r.value); @@ -390,7 +394,7 @@ export class WaapiUnit implements GroupOwner { let current = animationTimeOrFallback(this._anim, NaN); if (Number.isNaN(current) || (fallbackPending && current < 0)) { try { - current = this._o._now() - this._startTime; + current = this._o!._now() - this._startTime; } catch { // Отказ clock означает безопасный pre-start либо fail-closed wake. } @@ -405,7 +409,7 @@ export class WaapiUnit implements GroupOwner { * Разошедшиеся v0 не сжимаются в одну кривую — caller переведёт группу в live. */ private _tryReseedFromSnapshot(): SpringExecutionArtifactTuple | undefined { - const o = this._o; + const o = this._o!; const rebased = rebaseNumericChannels(o._numeric); const v0 = sharedV0(rebased); if (v0 === undefined) return undefined; @@ -426,8 +430,15 @@ export class WaapiUnit implements GroupOwner { * поэтому смена движка не раскрывает underlying style ни на один кадр. */ private _handoffToLive(paused: boolean): void { - const o = this._o; + const o = this._o!; + const previousPaused = this._paused; const batch = o._getBatch(); + // Чтение lazy host-шва может отменить control или уже перевести его в live. + // Вложенный delegate нельзя заменить ещё одним скрытым writer. + if (this._done || this._delegate !== undefined) return; + // Принятая pause из accessor новее входного seek/play. Если host не + // менял pause, сохраняем исходное намерение (play обязан возобновить). + if (this._paused !== previousPaused) paused = this._paused; const rebased = rebaseNumericChannels(o._numeric); this._transaction(() => { this._holdInline(); @@ -468,7 +479,7 @@ export class WaapiUnit implements GroupOwner { /** Инлайн-фиксация текущего значения (перед cancel — без миганья к базе). */ private _holdInline(): void { - const o = this._o; + const o = this._o!; if (o._group === 'transform') { const state = o._transform!; for (const ch of o._numeric) state[ch._key] = ch._value; @@ -525,7 +536,7 @@ export class WaapiUnit implements GroupOwner { }; this._timerCancel = cancel; try { - hostCancel = this._o._setTimer(() => { + hostCancel = this._o!._setTimer(() => { if (!active || this._timerCancel !== cancel) return; active = false; if (sync) { @@ -575,14 +586,15 @@ export class WaapiUnit implements GroupOwner { /** Публикует unit: выпускает sync timer только вне host-транзакции и ровно один раз. */ _commit(): void { if ( - this._o._record._owner !== this || + this._done || + this._o!._record._owner !== this || !this._pendingNatural || - this._o._record._transition || + this._o!._record._transition || this._locked ) return; this._transaction(() => { this._clearTimer(); - for (const ch of this._o._numeric) { + for (const ch of this._o!._numeric) { ch._value = ch._to; ch._velocity = 0; } @@ -601,8 +613,8 @@ export class WaapiUnit implements GroupOwner { } private _writeBack(): void { - const rec = this._o._record; - for (const ch of this._o._numeric) { + const rec = this._o!._record; + for (const ch of this._o!._numeric) { rec._numeric.set(ch._key, { _value: ch._value, _velocity: 0 }); } } @@ -610,7 +622,13 @@ export class WaapiUnit implements GroupOwner { private _finish(natural: boolean): void { if (this._done) return; this._done = true; - if (this._o._record._owner === this) this._o._record._owner = undefined; - this._o._onDone(natural); + const o = this._o!; + if (o._record._owner === this) o._record._owner = undefined; + // Завершённый слот может оставаться в ещё живом aggregate. Его trajectory + // и handoff executor больше не нужны ни одному terminal control. + this._samples = undefined; + this._delegate = undefined; + this._o = undefined; + o._onDone(natural); } } diff --git a/src/behaviors/index.ts b/src/behaviors/index.ts index d9adda053..82efa7d9d 100644 --- a/src/behaviors/index.ts +++ b/src/behaviors/index.ts @@ -27,8 +27,8 @@ * smooth-pickup MotionValue): доводка value→target с наследованием velocity * (v0n = velocity/range даёт C¹ на стыке follow|release). * ../spring validateSpringForFrameLoop — ранний fail-fast MotionParamError В ФАБРИКЕ. - * ../tokens spring — токены темпа (дефолтные пружины доводки); семантическую - * роль задаёт потребитель, labui НЕ импортируется. + * ../internal/motion-defaults — общие пружины доводки и публичных токенов; + * роль задаёт потребитель, labui и инициализация изингов не импортируются. * * Инварианты (нарушение = провал): * B1. ОДНА state machine владеет фазой и переходами; pointer/programmatic @@ -74,7 +74,7 @@ import { solveSpring } from '../internal/solver.js'; import { CONVERGENCE_THRESHOLD, FIXED_DT_S, MAX_FRAMES } from '../internal/constants.js'; import type { MatchMediaLike } from '../internal/media-query.js'; import { validateSpringForFrameLoop, type SpringParams } from '../spring.js'; -import { spring as springTokens } from '../tokens/index.js'; +import { DEFAULT_SPRING, SNAPPY_SPRING } from '../internal/motion-defaults.js'; import type { RequestFrameFn } from '../motion-value.js'; // ─── Общий контракт ────────────────────────────────────────────────────────── @@ -158,41 +158,63 @@ interface _SettleArgs { readonly onDone: () => void; } -/** Хендл единого runner'а поведения. */ +/** Внутренний контракт доводки общего владельца поведения. */ interface _Runner { /** Запустить доводку value→target (ровно один активный цикл). */ _settle(args: _SettleArgs): void; /** Погасить активный цикл (перехват/cancel) — stale-кадры инвалидируются. */ - _invalidate(): number; + _invalidate(reset?: boolean): number; } /** - * Создать единый runner поведения. Владеет generation-токеном: любой новый - * `_settle()` или `_invalidate()` инкрементит его, и запланированные кадры чужого - * поколения гаснут (B1 — ноль параллельных loops). reduced-motion → мгновенный - * снап в target без единого кадра (B4 character-switch). + * Общий владелец состояния, подписчиков, tracker и кадровой доводки. Четыре + * поведения задают переходы и цели, сохраняя один generation-токен: новый + * `_settle()` или `_invalidate()` гасит запланированные кадры старой доводки. + * reduced-motion мгновенно ставит target без кадров (B4). */ -function _createRunner( - requestFrame: RequestFrameFn | undefined, - reduced: boolean, -): _Runner { +function _createBase, O extends object | true>( + initial: S, + options: { + readonly requestFrame?: RequestFrameFn | undefined; + readonly matchMedia?: MatchMediaLike | undefined; + }, + owner: O, +) { + let requestFrame = options.requestFrame; + const reduced = _prefersReduced(options.matchMedia); let gen = 0; - let curVel: number | undefined; + let curVel = 0; const schedule = (cb: (ts?: number) => void): void => { const handle = requestFrame!(cb); if (handle === 0) setTimeout(() => cb(undefined), 0); // non-draining шов (конвенция repo) }; - return { + const tracker = createVelocityTracker(); + const subs = new Set<(s: S) => void>(); + let state = initial; + + const emit = (next: Partial): boolean => { + const emitted = state = { ...state, ...next }; + for (const fn of subs) { + try { + fn(emitted); + } catch { + // Подписчик не имеет права срывать соседей. + } + if (state !== emitted) break; + } + return !!base.owner && state === emitted; + }; + + const base = { _settle(args: _SettleArgs): void { - gen++; - const my = gen; + const my = ++gen; curVel = args.velocity; const range = args.target - args.from; const finishNow = (): void => { - curVel = undefined; + curVel = 0; args.onStep(_finite(args.target), 0); if (my === gen) args.onDone(); }; @@ -243,63 +265,32 @@ function _createRunner( schedule(tick); }, - _invalidate(): number { + /** Программная смена цели сохраняет samples; перехват/cancel/destroy сбрасывают. */ + _invalidate(reset?: boolean): number { gen++; - const velocity = curVel ?? 0; - curVel = undefined; + if (reset) tracker.reset(); + const velocity = curVel; + curVel = 0; return velocity; }, - }; -} - -/** - * База поведения: подписчики + текущее состояние + единый runner + трекер - * скорости + reduced-флаг + идемпотентные cancel/destroy. Каждое из четырёх - * поведений оборачивает её собственными обработчиками ввода/выбора цели. - */ -function _createBase>( - initial: S, - requestFrame: RequestFrameFn | undefined, - matchMedia: MatchMediaLike | undefined, -) { - const runner = _createRunner(requestFrame, _prefersReduced(matchMedia)); - const tracker = createVelocityTracker(); - const subs = new Set<(s: S) => void>(); - let state = initial; - let destroyed = false; - - const emit = (next: Partial): boolean => { - const emitted = state = { ...state, ...next }; - for (const fn of subs) { - try { - fn(emitted); - } catch { - // Подписчик не имеет права срывать соседей. - } - if (state !== emitted) break; - } - return !destroyed && state === emitted; - }; - - return { - runner, tracker, + // Только Dismiss/Pull нужны поздние getter и receiver исходных options. + // Sheet/Pager владеют lifecycle-token: после off не удерживают constructor + // onChange через ненужный options. Одна terminal-граница освобождает owner. + owner: owner as O | null, get state(): S { return state; }, - get destroyed(): boolean { - return destroyed; - }, emit, get _following(): boolean { - return !destroyed && state.phase === 'follow'; + return !!base.owner && state.phase === 'follow'; }, subscribe(fn: (s: S) => void): () => void { - if (destroyed) return () => {}; + if (!base.owner) return () => {}; subs.add(fn); - return () => { - subs.delete(fn); - }; + // Живой Set владеет fn; сохранённый off удерживает только слабую identity. + const reference = new WeakRef(fn); + return () => { subs.delete(reference.deref()!); }; }, /** * Погасить активную доводку и осесть в покой на ТЕКУЩЕМ значении (phase idle, @@ -307,34 +298,45 @@ function _createBase>( * no-op (не плодит эмитов). destroy() строится поверх неё. */ cancel(reset?: Partial): void { - if (destroyed || state.phase === 'idle') return; // уже в покое - runner._invalidate(); - tracker.reset(); + if (!base.owner || state.phase === 'idle') return; // уже в покое + base._invalidate(true); emit({ ...reset, velocity: 0, phase: 'idle' } as Partial); }, destroy(): void { - if (destroyed) return; - runner._invalidate(); - tracker.reset(); + if (!base.owner) return; + base.owner = null; + base._invalidate(true); + requestFrame = undefined; subs.clear(); - destroyed = true; }, }; + return base; +} + +/** Поздний getter может отозвать intent; повторная проверка предшествует эффекту. */ +function _invoke( + base: { owner: O | null; readonly state: unknown }, + key: keyof O, +): unknown { + const owner = base.owner; + const state = base.state; + const callback = owner?.[key] as (() => unknown) | undefined; + if (base.owner && base.state === state && callback != null) { + return Reflect.apply(callback, owner, []); + } } /** Перехватить активную доводку тем же tracker/runner и сохранить C¹-prior. */ function _beginPickup( - base: { runner: _Runner; tracker: ReturnType }, + base: _Runner & { tracker: ReturnType }, p: BehaviorPoint, axis: BehaviorAxis, velocityScale = 1, ): void { - const carry = base.runner._invalidate() * velocityScale; - base.tracker.reset(); + const carry = base._invalidate(true) * velocityScale; if (carry !== 0) { const back = { x: _finite(p.x), y: _finite(p.y), t: _finite(p.t) - PICKUP_SEED_DT_S }; - if (axis === 'x') back.x -= carry * PICKUP_SEED_DT_S; - else back.y -= carry * PICKUP_SEED_DT_S; + back[axis === 'x' ? 'x' : 'y'] -= carry * PICKUP_SEED_DT_S; base.tracker.push(back); } base.tracker.push(p); @@ -419,16 +421,15 @@ export function createBottomSheet(options: SheetOptions): SheetController { }; let snaps = readSnaps([...options.snapPoints].map(_finite)); const axis = options.axis ?? 'y'; - const springParams = options.spring ?? (springTokens.default as SpringParams); + const springParams = options.spring ?? DEFAULT_SPRING; validateSpringForFrameLoop(springParams); const rubber = _clampFactor(options.rubberBand, DEFAULT_RUBBER_BAND); const start = _finite(options.initial ?? snaps[0]!); const startIndex = _pickSnap(snaps, start, 0); - const base = _createBase( + const base = _createBase( { value: start, velocity: 0, phase: 'idle', snapIndex: startIndex }, - options.requestFrame, - options.matchMedia, + options, true, ); let grabValue = 0; @@ -450,7 +451,7 @@ export function createBottomSheet(options: SheetOptions): SheetController { }; const settleTo = (index: number, velocity: number): void => { - base.emit({ phase: 'release', snapIndex: index }) && base.runner._settle({ + base.emit({ phase: 'release', snapIndex: index }) && base._settle({ from: base.state.value, velocity, target: snaps[index]!, @@ -462,7 +463,7 @@ export function createBottomSheet(options: SheetOptions): SheetController { const ctrl: SheetController = { pointerDown(p: BehaviorPoint): void { - if (base.destroyed) return; + if (!base.owner) return; // Прерывание: гасим активную доводку, наследуем её скорость прайором (C¹). _beginPickup(base, p, axis); lastPointer = _coord(p, axis); @@ -488,7 +489,7 @@ export function createBottomSheet(options: SheetOptions): SheetController { settleTo(_pickSnap(snaps, base.state.value, 0), 0); }, update(next: readonly number[]): void { - if (base.destroyed) return; + if (!base.owner) return; const parsed = readSnaps([...next]); if (parsed.length === snaps.length && parsed.every((v, i) => v === snaps[i])) return; snaps = parsed; @@ -500,12 +501,12 @@ export function createBottomSheet(options: SheetOptions): SheetController { : value > max ? max + (value - max) / rubber : value < min ? min + (value - min) / rubber : value, lastPointer); base.emit({ snapIndex: Math.min(base.state.snapIndex, snaps.length - 1) }); - } else settleTo(Math.min(base.state.snapIndex, snaps.length - 1), base.runner._invalidate()); + } else settleTo(Math.min(base.state.snapIndex, snaps.length - 1), base._invalidate()); }, snapTo(index: number): void { - if (base.destroyed) return; + if (!base.owner) return; const i = Math.max(0, Math.min(snaps.length - 1, Math.trunc(_finite(index)))); - settleTo(i, base.runner._invalidate()); + settleTo(i, base._invalidate()); }, subscribe: base.subscribe, cancel: base.cancel, @@ -580,21 +581,19 @@ export function createDragDismiss(options: DismissOptions): DismissController { const velThresh = Number.isFinite(options.velocityThreshold) ? Math.abs(options.velocityThreshold as number) : DEFAULT_DISMISS_VELOCITY; - const springParams = options.spring ?? (springTokens.default as SpringParams); + const springParams = options.spring ?? DEFAULT_SPRING; validateSpringForFrameLoop(springParams); const dismissTarget = _finite(options.dismissTarget ?? dir * dist * 8); - - const base = _createBase( + const base = _createBase( { value: 0, velocity: 0, phase: 'idle', dismissed: false }, - options.requestFrame, - options.matchMedia, + options, options, ); let grabPointer = 0; let grabValue = 0; const returnHome = (velocity: number): void => { - base.emit({ phase: 'release' }) && base.runner._settle({ + base.emit({ phase: 'release' }) && base._settle({ from: base.state.value, velocity, target: 0, @@ -605,21 +604,21 @@ export function createDragDismiss(options: DismissOptions): DismissController { }; const dismiss = (velocity: number): void => { - base.emit({ phase: 'release' }) && base.runner._settle({ + base.emit({ phase: 'release' }) && base._settle({ from: base.state.value, velocity, target: dismissTarget, spring: springParams, onStep: (v, vel) => base.emit({ value: v, velocity: vel }), onDone: () => { - if (base.emit({ phase: 'settle', dismissed: true })) options.onDismiss?.(); + if (base.emit({ phase: 'settle', dismissed: true })) _invoke(base, 'onDismiss'); }, }); }; const ctrl: DismissController = { pointerDown(p: BehaviorPoint): void { - if (base.destroyed || base.state.dismissed) return; + if (!base.owner || base.state.dismissed) return; _beginPickup(base, p, axis); grabPointer = _coord(p, axis); grabValue = base.state.value; @@ -727,17 +726,16 @@ export function createCarousel(options: CarouselOptions): CarouselController { const velThresh = Number.isFinite(options.velocityThreshold) ? Math.abs(options.velocityThreshold as number) : DEFAULT_CAROUSEL_VELOCITY; - const springParams = options.spring ?? (springTokens.snappy as SpringParams); + const springParams = options.spring ?? SNAPPY_SPRING; validateSpringForFrameLoop(springParams); const clampIndex = (i: number): number => Math.max(0, Math.min(pageCount - 1, i)); let targetIndex = clampIndex(Math.round(_finite(options.index ?? 0))); const initialValue = _finite(targetIndex * pageSize); - const base = _createBase( + const base = _createBase( { value: initialValue, velocity: 0, phase: 'idle', index: clampIndex(Math.round(initialValue / pageSize)) }, - options.requestFrame, - options.matchMedia, + options, true, ); let grabPointer = 0; @@ -751,7 +749,7 @@ export function createCarousel(options: CarouselOptions): CarouselController { const settleTo = (index: number, velocity: number): void => { const i = clampIndex(index); targetIndex = i; - base.emit({ phase: 'release', index: clampIndex(base.state.index) }) && base.runner._settle({ + base.emit({ phase: 'release', index: clampIndex(base.state.index) }) && base._settle({ from: base.state.value, velocity, target: i * pageSize, @@ -764,7 +762,7 @@ export function createCarousel(options: CarouselOptions): CarouselController { const ctrl: CarouselController = { pointerDown(p: BehaviorPoint): void { - if (base.destroyed) return; + if (!base.owner) return; _beginPickup(base, p, axis, posDirSign); grabPointer = _coord(p, axis); grabValue = base.state.value; @@ -797,17 +795,17 @@ export function createCarousel(options: CarouselOptions): CarouselController { settleTo(Math.round(base.state.value / pageSize), 0); }, update(count: number, size: number): void { - if (base.destroyed) return; + if (!base.owner) return; _readCarouselGeometry(count, size); if (count === pageCount && size === pageSize) return; pageCount = count; pageSize = size; if (base._following) base.emit({ index: clampIndex(Math.round(base.state.value / pageSize)) }); - else settleTo(targetIndex, base.runner._invalidate()); + else settleTo(targetIndex, base._invalidate()); }, goTo(index: number): void { - if (base.destroyed) return; - settleTo(Math.round(_finite(index)), base.runner._invalidate()); + if (!base.owner) return; + settleTo(Math.round(_finite(index)), base._invalidate()); }, next(): void { ctrl.goTo(base.state.index + 1); @@ -891,14 +889,12 @@ export function createPullToRefresh(options: PullOptions): PullController { const axis = options.axis ?? 'y'; const dir: 1 | -1 = options.direction === -1 ? -1 : 1; const resistance = _clampFactor(options.resistance, DEFAULT_RUBBER_BAND); - const springParams = options.spring ?? (springTokens.default as SpringParams); + const springParams = options.spring ?? DEFAULT_SPRING; validateSpringForFrameLoop(springParams); const pendingPos = _finite(options.pendingPosition ?? threshold); - - const base = _createBase( + const base = _createBase( { value: 0, velocity: 0, phase: 'idle', pulling: false, armed: false, pending: false }, - options.requestFrame, - options.matchMedia, + options, options, ); let grabPointer = 0; @@ -908,7 +904,7 @@ export function createPullToRefresh(options: PullOptions): PullController { velocity: number, onDone: () => void, ): void => { - base.emit({ phase: 'release' }) && base.runner._settle({ + base.emit({ phase: 'release' }) && base._settle({ from: base.state.value, velocity, target, @@ -931,10 +927,10 @@ export function createPullToRefresh(options: PullOptions): PullController { if (!base.emit({ phase: 'settle', pending: true, armed: false })) return; const pendingState = base.state; const finish = (): void => { - if (!base.destroyed && base.state === pendingState) returnHome(0); + if (base.owner && base.state === pendingState) returnHome(0); }; try { - Promise.resolve(options.onRefresh?.()).then(finish, finish); + Promise.resolve(_invoke(base, 'onRefresh')).then(finish, finish); } catch { finish(); } @@ -943,7 +939,7 @@ export function createPullToRefresh(options: PullOptions): PullController { const ctrl: PullController = { pointerDown(p: BehaviorPoint): void { - if (base.destroyed || base.state.pending) return; // pending владеет позицией + if (!base.owner || base.state.pending) return; // pending владеет позицией _beginPickup(base, p, axis, 0); grabPointer = _coord(p, axis); base.emit({ phase: 'follow', pulling: true, velocity: 0 }); diff --git a/src/compositor/core.ts b/src/compositor/core.ts index cd338c317..0b43fd353 100644 --- a/src/compositor/core.ts +++ b/src/compositor/core.ts @@ -38,7 +38,9 @@ */ import { MotionParamError } from '../errors.js'; +import { DEFAULT_SPRING } from '../internal/motion-defaults.js'; import { readSpringUnchecked } from '../internal/read-spring.js'; +import { finiteOr } from '../internal/finite.js'; import { type SpringParams, validateSpringForFrameLoop, @@ -65,7 +67,7 @@ import { compileSpringRuntimeExecutionTupleUnchecked, } from './execution.js'; import { - animationTimeOrFallback, + animationLocalTimeOrFallback, sampleSerializedSpringIntoUnchecked, scaleSerializedVelocity, } from './sample.js'; @@ -436,50 +438,57 @@ type HostOwner = CompositorAnimation | (() => void) | null | undefined; * трогает DOM/часы; native time читается только при прерывании. */ export class CompositorSpring { - private readonly _spring: SpringParams; - private readonly _property: string; - private readonly _tolerance: number; - private readonly _fill: 'none' | 'forwards' | 'backwards' | 'both'; - private readonly _composite: 'replace' | 'add' | 'accumulate'; - private _format: ((v: number) => string | number) | undefined; - private _target: WaapiAnimatable | undefined; - private _apply: ((value: string | number) => void) | undefined; - /** Часы — lifetime-capability: destroy снимает её до любого host cleanup. */ - private _now: (() => number) | undefined; - private _requestFrame: RequestFrameFn | undefined; - private readonly _delay: number; - private _setTimer: SetTimerFn | undefined; - private readonly _tier: CompositorTierCode; - - private _from: number; - private _to: number; + declare private _spring: SpringParams; + declare private readonly _property: string; + declare private readonly _tolerance: number; + declare private readonly _fill: 'none' | 'forwards' | 'backwards' | 'both'; + declare private readonly _composite: 'replace' | 'add' | 'accumulate'; + declare private _format: ((v: number) => string | number) | undefined; + declare private _target: WaapiAnimatable | undefined; + /** @internal */ + declare protected _apply: ((value: string | number) => void) | undefined; + /** @internal Часы — lifetime-capability: destroy снимает её до любого host cleanup. */ + declare protected _now: (() => number) | undefined; + declare private _requestFrame: RequestFrameFn | undefined; + declare private readonly _delay: number; + declare private _setTimer: SetTimerFn | undefined; + /** @internal */ + declare protected readonly _tier: CompositorTierCode; + + /** @internal */ + declare protected _from: number; + /** @internal */ + declare protected _to: number; private _v0Norm = 0; - private _startTime!: number; + declare private _startTime: number; /** Задержка ТЕКУЩЕГО прогона (мс): _delay на первичном start, 0 на retarget/handoff. */ - private _startDelay!: number; - /** Единственный host-owner; null резервирует незавершённый setTimer. */ - private _host: HostOwner; + declare private _startDelay: number; + /** @internal Единственный host-owner; null резервирует незавершённый setTimer. */ + declare protected _host: HostOwner; /** Один artifact — SSOT samples и duration текущего compositor-owner. */ - private _artifact: SpringExecutionArtifactTuple | undefined; + declare private _artifact: SpringExecutionArtifactTuple | undefined; private readonly _sample = { value: 0, velocity: 0 }; - private _mv: MotionValue | undefined; - /** Монотонный identity-token текущего owner/continuation. */ - private _epoch = 0; - /** Host cleanup блокирует мутации, пока current-owner continuation не выдаст capability. */ - private _cleaning?: true; + /** @internal */ + declare protected _mv: MotionValue | undefined; + /** @internal Монотонный identity-token текущего owner/continuation. */ + protected _epoch = 0; + /** @internal Host cleanup блокирует мутации, пока current-owner continuation не выдаст capability. */ + declare protected _cleaning?: true; - /** + /** @internal * Единый мост «кадр живой пружины → внутреннее значение + apply». Один экземпляр * на контроллер, переиспользуется всеми живыми путями (_ensureFallback, * compositor→live хендофф, reduced-хендофф) — DRY: правило распространения * значения живёт в ОДНОМ месте (иначе тройной дубль тихо расходится). Читает * _apply/_format в момент ВЫЗОВА (после конструктора), поэтому bound-поле безопасно. */ - private readonly _onLiveFrame = (v: number): void => { + protected readonly _onLiveFrame = (v: number): boolean => { const epoch = this._epoch; this._from = v; const value = this._apply && this._format!(v); - if (this._epoch === epoch) this._apply?.(value!); + if (this._epoch !== epoch || !this._apply) return false; + this._apply(value!); + return true; }; constructor(opts: CompositorSpringOptions) { @@ -584,17 +593,32 @@ export class CompositorSpring { } // Живой rAF-путь (waapi-no-linear / raf / ssr). if (!this._ensureFallback(generation)) return; - if (this._delay > 0) { - // Fallback-каскад: callback атомарно потребляет timer-owner. - this._adoptTimer(generation, () => this._setTimer!(() => { + if (this._delay === 0) { + this._mv!.setTarget(this._to); + return; + } + // Резервируем слот до внешнего вызова; устаревший результат освобождаем отдельно. + this._host = null; + let host: () => void; + try { + host = this._setTimer!(() => { if (this._epoch === generation) { this._host = undefined; this._epoch++; this._mv!.setTarget(this._to); } - }, this._delay)); - } else if (this._epoch === generation) { - this._mv!.setTarget(this._to); + }, this._delay); + } catch (error) { + if (this._host === null) { + this._host = undefined; + this._epoch++; + } + throw error; + } + if (this._epoch === generation) { + this._host = host; + } else { + if (this._host !== host) this._cancelHost(host); } } @@ -606,6 +630,10 @@ export class CompositorSpring { * commit-кадр хендоффа); на fallback — MotionValue.setTarget. */ retarget(newTarget: number): void { + this._retarget(newTarget); + } + + private _retarget(newTarget: number, mv?: MotionValue): void { if (!this._now || this._cleaning) return; validateFinite(newTarget); const generation = ++this._epoch; @@ -613,11 +641,16 @@ export class CompositorSpring { if (this._tier === 3) { // reduce активен: снап к новой цели, без анимации. this._to = newTarget; - this._onLiveFrame(newTarget); + // Тот же live-owner теряет старую траекторию до публикации reduced-снапа. + const live = this._mv; + live?.snapTo(newTarget); + // Выданный loan мог быть самостоятельно уничтожен. Старый snapshot не + // разрешает потерять новую цель; callback нового intent имеет приоритет. + if (!live || (this._epoch === generation && this._from !== newTarget)) this._onLiveFrame(newTarget); return; } - if (!this._usesCompositor()) { + if (!this._usesCompositor(mv)) { // Живой rAF-путь: smooth-pickup MotionValue переносит скорость. this._releaseHost(); // retarget = «сейчас»: снимаем delay-owner if (this._epoch !== generation || !this._ensureFallback(generation)) return; @@ -627,7 +660,7 @@ export class CompositorSpring { } // Compositor-путь. - if (!this._host) { + if (!this._host && !mv) { // Ещё не в полёте — просто задаём цель и стартуем свежий прогон. this._to = newTarget; this.start(); @@ -635,22 +668,34 @@ export class CompositorSpring { } // В полёте: читаем фактическое effect-состояние в момент прерывания (без layout). - const read = this._snapshot(generation); + const read = mv ?? this._snapshot(generation); if (!read) return; - const range = newTarget - read.value; + this._retargetFrom(read.value, read.velocity, newTarget, generation, mv); + } + + /** @internal Продолжение из уже захваченного состояния того же owner. */ + protected _retargetFrom( + from: number, velocity: number, newTarget: number, generation: number, mv?: MotionValue, + ): void { + const revision = mv?._epoch; + const range = newTarget - from; const v0Norm = Math.abs(range) > RANGE_EPSILON - ? read.velocity / range - : read.velocity === 0 + ? velocity / range + : velocity === 0 ? 0 : Infinity; // normalized curve cannot represent absolute impulse at zero range validateSpringForFrameLoop(this._spring); - const artifact = tryCompileSpringExecutionArtifactTupleUnchecked( + const artifact = this._tier === 0 && tryCompileSpringExecutionArtifactTupleUnchecked( this._spring, v0Norm, this._tolerance, ); - if (this._epoch !== generation) return; + if (this._epoch !== generation || mv?._epoch !== revision) return; if (!artifact) { + if (mv) { + this.retarget(newTarget); + return; + } // Без writer live-путь не может сохранить видимый контракт. Ошибка должна // случиться ДО cancel: прежний compositor-прогон остаётся владельцем. if (!this._apply) { @@ -660,14 +705,14 @@ export class CompositorSpring { this._tolerance, ); } - const mv = this._liveCandidate(read.value, read.velocity, generation); + const candidate = this._liveCandidate(from, velocity, generation); // Новый owner уже активен: отказ hostile host-cancel не должен откатить // хендофф или оставить ссылку на прежний Animation. - this._adoptLive(mv, newTarget, generation); + this._adoptLive(candidate, newTarget, generation); return; } // Donor остаётся owner до успешного возврата successor из animate(). - this._emitCompositor(read.value, newTarget, v0Norm, artifact, generation); + this._emitCompositor(from, newTarget, v0Norm, artifact, generation); } /** @@ -739,6 +784,18 @@ export class CompositorSpring { return mv; } + /** + * Завершает live/follow-фазу автономным переходом к цели. Пара value/velocity + * читается у уже выданного MotionValue; consumer не переносит скорость вручную. + * Native successor принимает поверхность до terminal-уборки live donor. + * После commit старый MotionValue инертен, а destroy контроллера остаётся + * единственной границей lifetime. При неподдержанном native-пути продолжает + * тот же live-owner; mode показывает фактическое представление. + */ + handoffToCompositor(newTarget: number = this._to): void { + this._retarget(newTarget, this._mv); + } + /** * Останавливает прогон (без разрушения контроллера). Позиция прерывания * compositor-эффекта НЕ фиксируется: cancel снимает effect, повторный @@ -756,20 +813,20 @@ export class CompositorSpring { /** Полностью останавливает и освобождает ресурсы. */ destroy(): void { if (!this._now) return; - const mv = this._mv; - this._mv = undefined; + // Инертный handoff не читает пользовательские параметры и не удерживает их метаданные. + this._spring = DEFAULT_SPRING; // Permanent terminal и retention-разрыв публикуются до недоверенного cleanup. this._epoch++; this._artifact = this._format = this._setTimer = this._now = this._target = this._requestFrame = this._apply = undefined; + this._commitOwner(); this._releaseHost(); - mv?.destroy(); } // ─── Приватное ────────────────────────────────────────────────────────────── - private _usesCompositor(): boolean { - return this._tier === 0 && !this._mv; + private _usesCompositor(returningLive?: MotionValue): boolean { + return this._tier === 0 && this._mv === returningLive; } private _inertValue(): MotionValue { @@ -789,8 +846,8 @@ export class CompositorSpring { } } - /** Слот снимается до первого недоверенного host-вызова. */ - private _releaseHost(): void { + /** @internal Слот снимается до первого недоверенного host-вызова. */ + protected _releaseHost(): void { const host = this._host; this._host = undefined; this._cancelHost(host); @@ -809,31 +866,11 @@ export class CompositorSpring { this._cleaning = undefined; } - /** CAS-граница setTimer: stale-return оплачивается, новый owner не стирается. */ - private _adoptTimer(generation: number, create: () => () => void): void { - this._host = null; - let host: () => void; - try { - host = create(); - } catch (error) { - if (this._host === null) { - this._host = undefined; - this._epoch++; - } - throw error; - } - if (this._epoch === generation) { - this._host = host; - } else { - if (this._host !== host) this._cancelHost(host); - } - } - - /** Фактический piecewise-снимок без style/layout-read. */ - private _snapshot(generation: number): { value: number; velocity: number } | undefined { + /** @internal Фактический piecewise-снимок без style/layout-read. */ + protected _snapshot(generation: number): { value: number; velocity: number } | undefined { const now = this._now!(); if (this._epoch !== generation) return undefined; - const currentTime = animationTimeOrFallback( + const currentTime = animationLocalTimeOrFallback( this._host as CompositorAnimation, now - this._startTime, ); @@ -841,7 +878,7 @@ export class CompositorSpring { const sample = sampleSerializedSpringIntoUnchecked( this._artifact![1], this._artifact![2], - currentTime, + currentTime ?? -1, this._startDelay, this._sample, ); @@ -853,8 +890,10 @@ export class CompositorSpring { : (1 - progress) * this._from + progress * this._to; // Scratch не пересекает публичную границу: оба вызывающих синхронно // копируют поля до следующего snapshot. Это убирает allocation на прерывание. - sample.value = Number.isFinite(rawValue) ? rawValue : this._to; - sample.velocity = scaleSerializedVelocity(sample.velocity, this._from, this._to); + sample.value = finiteOr(rawValue, this._to); + // Pending local-time ещё не исполняет serialized slope: сохраняем prior + // handoff вместо потери скорости при немедленном новом вводе. + sample.velocity = scaleSerializedVelocity(currentTime === null ? this._v0Norm : sample.velocity, this._from, this._to); return sample; } @@ -866,6 +905,7 @@ export class CompositorSpring { generation: number, delayMs = 0, ): void { + const revision = this._mv?._epoch; const plan = compileSpringRuntimeExecutionTupleUnchecked( this._spring, this._property, @@ -878,9 +918,9 @@ export class CompositorSpring { this._format, artifact, ); - if (this._epoch !== generation) return; + if (this._epoch !== generation || this._mv?._epoch !== revision) return; const now = this._now!(); - if (this._epoch !== generation) return; + if (this._epoch !== generation || this._mv?._epoch !== revision) return; const donor = this._host; const host = this._target!.animate(plan[0], { duration: plan[2], @@ -892,7 +932,7 @@ export class CompositorSpring { // планирует старт off-main-thread — каскад stagger без работы main-потока. ...(delayMs > 0 ? { delay: delayMs } : {}), }) as CompositorAnimation; - if (this._epoch !== generation) { + if (this._epoch !== generation || this._mv?._epoch !== revision) { if (this._host !== host) this._cancelHost(host); return; } @@ -904,11 +944,14 @@ export class CompositorSpring { this._startDelay = delayMs; this._startTime = now; this._artifact = artifact; + // До cleanup прежнего host отзываются input и live capability, + // включая уже выданный кадр, доставленный из cleanup timer-owner. + this._commitOwner(); if (donor !== host) this._cancelHost(donor); } - /** Строит live-кандидата; ошибка не меняет metadata действующего donor. */ - private _liveCandidate( + /** @internal Строит live-кандидата; ошибка не меняет metadata действующего donor. */ + protected _liveCandidate( value: number, velocity: number, generation: number, @@ -936,8 +979,8 @@ export class CompositorSpring { } } - /** CAS-публикация live-owner; stale-кандидат оплачивается здесь же. */ - private _adoptLive( + /** @internal CAS-публикация live-owner; stale-кандидат оплачивается здесь же. */ + protected _adoptLive( mv: MotionValue, target: number, generation: number, @@ -945,6 +988,8 @@ export class CompositorSpring { if (this._epoch === generation) { this._releaseHost(); if (this._epoch === generation) { + // Новый loan не оставляет прежний live-owner за пределами lifetime. + this._commitOwner(); this._to = target; this._mv = mv; // Commit заканчивается до scheduler-IO: после cancel donor откат уже @@ -970,6 +1015,13 @@ export class CompositorSpring { mv.destroy(); return false; } + + /** @internal Отзывает прежнее исполнение до публикации нового live-owner или host cleanup. */ + protected _commitOwner(): void { + const mv = this._mv; + this._mv = undefined; + mv?.destroy(); + } } /** Часы по умолчанию: performance.now при наличии, иначе Date.now (SSR-safe). */ diff --git a/src/compositor/execution.ts b/src/compositor/execution.ts index 037f335f7..6152a5b12 100644 --- a/src/compositor/execution.ts +++ b/src/compositor/execution.ts @@ -8,6 +8,7 @@ */ import type { SpringParams } from '../spring.js'; +import { finiteOr } from '../internal/finite.js'; import { clearSpringExecutionArtifactCacheUnchecked, compileSpringExecutionArtifactTupleUnchecked, @@ -62,7 +63,7 @@ function explicitKeyframes( // Для p∈[0,1] взвешенная форма остаётся конечной даже когда `to-from` // переполняется. Нефинитность здесь возможна только у реального overshoot, // вышедшего за представимый диапазон; CSS-safe политика снапает его в цель. - const value = Number.isFinite(raw) ? raw : to; + const value = finiteOr(raw, to); frames[i] = { offset: i === 0 ? 0 : i === last ? 1 : samples[i * 2]! / 100, [property]: format == null ? value : format(value), diff --git a/src/compositor/follow.ts b/src/compositor/follow.ts new file mode 100644 index 000000000..6b57961b1 --- /dev/null +++ b/src/compositor/follow.ts @@ -0,0 +1,161 @@ +import { MotionParamError } from '../errors.js'; +import type { MotionValue } from '../motion-value.js'; +import { createInputVelocityTracker, DEFAULT_VELOCITY_WINDOW_S, type InputVelocityTracker } from '../internal/velocity-tracker.js'; +import { CompositorSpring, type CompositorSpringOptions } from './core.js'; + +/** Один spring-owner для прямого ввода и автономного продолжения. */ +export interface CompositorFollow extends Pick { + /** Захватить текущее значение и скорость; timestamp входного потока в секундах. */ + beginFollow(tSeconds: number): number; + /** Передать абсолютное значение и неубывающий timestamp того же потока. */ + follow(value: number, tSeconds: number): void; + /** Отпустить ввод в target; timestamp учитывает неподвижное удержание. */ + settle(target: number, tSeconds: number): void; +} + +/** Универсальный input-протокол; UI определяет координаты, ограничения и конечную цель. */ +export function createCompositorFollow(options: CompositorSpringOptions): CompositorFollow { + return new InputSpring(options); +} + +class InputSpring extends CompositorSpring implements CompositorFollow { + private _following: { + tracker: InputVelocityTracker; + t: number; + at: number; + origin: number; + velocity: number; + } | undefined; + + beginFollow(tSeconds: number): number { + if (!this._now || this._cleaning) return this._from; + this._validateInputTime(tSeconds); + if (!this._apply) throw new MotionParamError('LM182'); + const generation = ++this._epoch; + const previous = this._from; + const following = this._following; + const mv = this._mv; + let value = previous; + let velocity = following ? this._inputVelocity() : mv?.velocity ?? 0; + if (this._host && !mv && !following) { + const read = this._snapshot(generation); + if (!read) return this._from; + value = read.value; + velocity = read.velocity; + } + const tracker = createInputVelocityTracker(); + if (velocity !== 0) { + const dt = DEFAULT_VELOCITY_WINDOW_S / 2; + tracker.push(-velocity * dt, -dt); + } + tracker.push(0, 0); + // Live callback теряет право записи до вызова пользовательского writer. + // При ошибке writer сохранённый MotionValue остаётся остановленным и повторяемым. + mv?.stop(); + this._following = { tracker, t: tSeconds, at: tSeconds, origin: value, velocity }; + this._mv = undefined; + try { + // Reentry видит новый ввод; native donor снимается после underlying-записи. + this._writeInput(value); + } catch (error) { + if (this._epoch === generation) { + this._from = previous; + this._following = following; + this._mv = mv; + } else mv?.destroy(); + throw error; + } + mv?.destroy(); + return this._from; + } + + follow(value: number, tSeconds: number): void { + if (!this._now || this._cleaning) return; + this._validateValue(value); + this._trackInput(value, tSeconds); + this._epoch++; + this._writeInput(value); + } + + settle(target: number, tSeconds: number): void { + if (!this._now || this._cleaning) return; + this._validateValue(target); + this._trackInput(this._from, tSeconds); + this.retarget(target); + } + + override start(): void { + if (this._following) this.retarget(this._to); + else super.start(); + } + + override retarget(target: number): void { + if (!this._following) return super.retarget(target); + if (!this._now || this._cleaning) return; + this._validateValue(target); + if (this._tier === 3) { + this._following = undefined; + super.retarget(target); + } else { + this._retargetFrom(this._from, this._inputVelocity(), target, ++this._epoch); + } + } + + override handoffToLive(target?: number): MotionValue { + if (!this._following || !this._now || this._cleaning) return super.handoffToLive(target); + if (target !== undefined) this._validateValue(target); + const generation = ++this._epoch; + const to = target ?? this._to; + const mv = this._liveCandidate( + this._tier === 3 ? to : this._from, + this._tier === 3 ? 0 : this._inputVelocity(), + generation, + ); + this._adoptLive(mv, to, generation); + return mv; + } + + override stop(): void { + if (!this._cleaning) this._following = undefined; + super.stop(); + } + + protected override _commitOwner(): void { + this._following = undefined; + super._commitOwner(); + } + + private _writeInput(value: number): void { + const input = this._following; + const written = this._onLiveFrame(value); + // Reentrant follow сохраняет input-owner; settle/handoff заменяют его. + // Подавленный до apply кадр не выдаёт право снять native donor. + if (written && this._following === input) this._releaseHost(); + } + + private _validateValue(value: number): void { + if (!Number.isFinite(value)) throw new MotionParamError('LM009'); + } + + private _validateInputTime(t: number): void { + if (!Number.isFinite(t) || (this._following && t < this._following.t)) { + throw new MotionParamError('LM183'); + } + } + + private _trackInput(value: number, t: number): void { + this._validateInputTime(t); + if (!this._following) throw new MotionParamError('LM184'); + const input = this._following; + input.t = t; + input.tracker.push(value - input.origin, t - input.at); + } + + private _inputVelocity(): number { + const input = this._following!; + // При немедленном re-release prior не проходит через вычитание больших координат/часов. + return input.t === input.at && this._from === input.origin + ? input.velocity : input.tracker.velocity(); + } +} diff --git a/src/compositor/follow/index.ts b/src/compositor/follow/index.ts new file mode 100644 index 000000000..5b84fff02 --- /dev/null +++ b/src/compositor/follow/index.ts @@ -0,0 +1,8 @@ +/** Прямой ввод и native-продолжение у одного spring-owner. */ +export { createCompositorFollow, type CompositorFollow } from '../follow.js'; +export { + compileSpringPlan, + type CompositorPlan, + type CompositorPlanOptions, + type CompositorSpringOptions, +} from '../core.js'; diff --git a/src/compositor/sample.ts b/src/compositor/sample.ts index 7a19a5f6a..a754b1cdb 100644 --- a/src/compositor/sample.ts +++ b/src/compositor/sample.ts @@ -1,6 +1,6 @@ /** Точный sampler фактически исполняемых serialized stops. */ -import { finiteOrZero } from '../internal/finite.js'; +import { finiteOr, finiteOrZero } from '../internal/finite.js'; import type { SpringSerializedSamples } from './curve.js'; export interface SerializedSpringSample { @@ -18,16 +18,27 @@ export interface AnimationTimeSource { * Реальный `null` означает unresolved/pending local time: effect ещё не имеет * видимого времени и должен читаться как pre-start, а не догонять JS clock. * Duck-объект без свойства сохраняет детерминированный fallback старых seams. + * Числовые callers сохраняют -1 для pre-start; nullable reader нужен для + * отличия actual null от известного отрицательного numeric local time. */ +/** Числовая pre-start совместимость прежних sampler callers. */ export function animationTimeOrFallback( animation: AnimationTimeSource | undefined, fallbackMs: number, ): number { + return animationLocalTimeOrFallback(animation, fallbackMs) ?? -1; +} + +/** Настоящий null остаётся отличимым от любого конечного numeric local time. */ +export function animationLocalTimeOrFallback( + animation: AnimationTimeSource | undefined, + fallbackMs: number, +): number | null { try { if (animation !== undefined && 'currentTime' in animation) { const current = animation.currentTime; - if (current === null) return -1; - if (typeof current === 'number' && Number.isFinite(current)) return current; + // Number.isFinite не приводит strings/objects и уже проверяет type. + if (current === null || Number.isFinite(current)) return current as number | null; } } catch { // Отказ host-getter/in-trap не блокирует monotonic fallback clock. @@ -95,7 +106,7 @@ export function sampleSerializedSpringIntoUnchecked( const q = (percent - x0) / (x1 - x0); const value = (1 - q) * p0 + q * p1; const velocity = (p1 - p0) / ((x1 - x0) * durationMs / 100_000); - result.value = Number.isFinite(value) ? value : p1; + result.value = finiteOr(value, p1); result.velocity = finiteOrZero(velocity); return result; } diff --git a/src/compositor/stagger.ts b/src/compositor/stagger.ts index 3047c823f..9980356db 100644 --- a/src/compositor/stagger.ts +++ b/src/compositor/stagger.ts @@ -209,8 +209,8 @@ export interface CompositorStaggerGroupOptions extends StaggerPlanBase { * CompositorSpring (execution-snapshot + reseed скорости). */ export class CompositorStaggerGroup { - private readonly _plan: CompositorStaggerPlan; - private readonly _springs: CompositorSpring[]; + declare private readonly _plan: CompositorStaggerPlan; + declare private readonly _springs: CompositorSpring[]; constructor(opts: CompositorStaggerGroupOptions) { if (!Array.isArray(opts.targets)) { @@ -224,7 +224,7 @@ export class CompositorStaggerGroup { const delays = this._plan.delays; const apply = opts.apply; - const springs = new Array(count); + const springs = this._springs = new Array(count); // CompositorSpring синхронно захватывает значения опций и не удерживает // объект. Один переиспользуемый carrier убирает N краткоживущих option- // объектов перед первым кадром большого каскада. @@ -250,7 +250,6 @@ export class CompositorStaggerGroup { child.apply = apply && ((value: string | number): void => apply(i, value)); springs[i] = new CompositorSpring(child); } - this._springs = springs; } /** Путь исполнения группы (по первому элементу; пустая группа → 'fallback'). */ diff --git a/src/errors.ts b/src/errors.ts index 2ae17f181..b8b602276 100644 --- a/src/errors.ts +++ b/src/errors.ts @@ -14,7 +14,7 @@ export type MotionParamErrorCode = `LM${Digit}${Digit}${Digit}`; const MOTION_PARAM_ERROR_CODE = /^LM\d{3}$/; /** Последний непрерывный код каталога; contract-тест сверяет его с docs/errors.md. */ -export const LAST_MOTION_PARAM_ERROR_CODE: MotionParamErrorCode = 'LM181'; +export const LAST_MOTION_PARAM_ERROR_CODE: MotionParamErrorCode = 'LM184'; /** Thrown when caller-supplied physics parameters are invalid (invariant 2). */ export class MotionParamError extends Error { diff --git a/src/internal/motion-defaults.ts b/src/internal/motion-defaults.ts index 56cf7a0c8..20218f792 100644 --- a/src/internal/motion-defaults.ts +++ b/src/internal/motion-defaults.ts @@ -1,9 +1,10 @@ -/** SSOT дефолтов фасада и публичных motion-токенов. */ +/** SSOT дефолтов фасада, поведений и публичных motion-токенов. */ import type { SpringParams } from './types.js'; export const DEFAULT_DURATION_MS = 200; export const DEFAULT_SPRING: SpringParams = { mass: 1, stiffness: 170, damping: 26 }; +export const SNAPPY_SPRING = { mass: 1, stiffness: 260, damping: 28 } as const; export const STANDARD_EASING_COORDS = [0.2, 0, 0, 1] as const; /** diff --git a/src/internal/velocity-tracker.ts b/src/internal/velocity-tracker.ts new file mode 100644 index 000000000..fb3082df7 --- /dev/null +++ b/src/internal/velocity-tracker.ts @@ -0,0 +1,37 @@ +import { advanceSlidingWindow } from './sliding-window.js'; + +/** Последнее значение каждого timestamp в scalar input-протоколе. */ +export interface InputVelocityTracker { + push(x: number, t: number): void; + velocity(): number; +} + +export const DEFAULT_VELOCITY_WINDOW_S = 0.1; + +function finite(x: number): number { + if (Number.isFinite(x)) return x; + if (Number.isNaN(x)) return 0; + return x > 0 ? Number.MAX_VALUE : -Number.MAX_VALUE; +} + +/** Follow заменяет повторный timestamp; публичный gesture tracker хранит оба. */ +export function createInputVelocityTracker(): InputVelocityTracker { + const samples: { x: number; t: number }[] = []; + let start = 0; + return { + push(x, t): void { + const sample = { x: finite(x), t: finite(t) }; + if (samples.length && samples[samples.length - 1]!.t === sample.t) { + samples[samples.length - 1] = sample; + } else samples.push(sample); + start = advanceSlidingWindow(samples, start, DEFAULT_VELOCITY_WINDOW_S); + }, + velocity(): number { + if (samples.length - start < 2) return 0; + const a = samples[start]!; + const b = samples[samples.length - 1]!; + const dt = b.t - a.t; + return dt > 0 ? finite(finite(b.x - a.x) / dt) : 0; + }, + }; +} diff --git a/src/motion-value.ts b/src/motion-value.ts index ff48ba010..3cf5b51b7 100644 --- a/src/motion-value.ts +++ b/src/motion-value.ts @@ -30,6 +30,7 @@ import { type SpringParams, validateSpringForFrameLoop } from './spring.js'; import { MotionParamError } from './errors.js'; import { defaultRequestFrame } from './internal/request-frame.js'; +import { finiteOr } from './internal/finite.js'; import { solveSpring } from './internal/solver.js'; // ─── Public types ──────────────────────────────────────────────────────────── @@ -80,19 +81,18 @@ export interface MotionValueOptions { import { CONVERGENCE_THRESHOLD, MAX_FRAMES, FIXED_DT_S } from './internal/constants.js'; /** - * Порог численной стабильности: величины меньше него трактуются как ноль. - * Две роли (обе — защита от вырождения, значение общее): (1) «покой» — скорость - * ниже EPSILON считается нулевой (snap-if-at-rest в setTarget); (2) знаменатель — - * |range| ниже EPSILON вырожден, деление на него дало бы ±∞/NaN, поэтому диапазон - * либо снапается, либо floor'ится к EPSILON. Локален модулю: деления на range в - * drive/driver защищены early-exit `from === to` (absRange > 0 гарантирован - * статически), им epsilon-пол не нужен — потому в общий internal/constants не вынесен. + * Порог покоя и вырожденного диапазона. При живом импульсе setTarget расширяет + * узкий range до представимой величины; из покоя такой диапазон снапается. + * После деления finiteOr отдельно отсекает переполнение нормализованной скорости. */ const EPSILON = 1e-10; /** Синхронный output-сcratch солвера: _tick копирует оба числа до callback-границы. */ const solverSample = { value: 0, velocity: 0 }; +/** Терминальная отписка не удерживает экземпляр или callback новой подписки. */ +const noopUnsubscribe = () => {}; + /** * Единый fail-fast страж конечности публичных числовых входов MotionValue: * NaN/±Infinity → MotionParamError синхронно (до Promise и до единого кадра). @@ -129,17 +129,17 @@ export class MotionValue { */ declare private _velocity: number; - /** Active spring params. */ - declare private readonly _spring: SpringParams; + /** Пользовательские параметры; null означает необратимо завершённого владельца. */ + declare private _spring: SpringParams | null; /** Клэмп-режим: true = легаси CSS-safe; false — честная пружина (overshoot эмитится). */ declare private readonly _clamp: boolean; - /** Injected frame scheduler. */ - declare private readonly _requestFrame: RequestFrameFn; + /** Планировщик живого владельца; null после destroy(). */ + declare private _requestFrame: RequestFrameFn | null; - /** Registered onChange subscribers. */ - private readonly _listeners: Set<(value: number) => void> = new Set(); + /** Реестр callback и его единственной функции отзыва. */ + private readonly _listeners = new Map<(value: number) => void, () => void>(); // ── Animation run state (reset on each setTarget) ─────────────────────── @@ -156,30 +156,20 @@ export class MotionValue { /** Начало текущей траектории в timestamp-координате инжектированного клока. */ declare private _startTs: number | undefined; - /** Whether a frame loop is currently active. */ - private _running: boolean = false; - /** Whether destroy() has been called. */ - private _destroyed: boolean = false; - /** Single-flight re-entrancy guard for the tick body. */ - private _tickActive: boolean = false; + /** + * Объект принадлежит одному активному циклу; null означает покой. + * Только setTarget создаёт его после проверки живого владельца, поэтому + * активный цикл всегда имеет spring и scheduler. Отзыв перед очисткой + * отсекает уже выданные host callbacks, даже после следующего запуска. + */ + private _run: object | null = null; + /** @internal Версия состояния для передачи владения без потери нового live intent. */ + _epoch = 0; /** Whether to use setTimeout fallback (handle=0 path). */ - private _useTimeoutFallback: boolean = false; + declare private _useTimeoutFallback: boolean; /** Frame counter for the current run. */ declare private _frameCount: number; - /** - * Bumped by stop()/snapTo() to invalidate any frame already handed to the - * injected requestFrame seam. The seam contract (RequestFrameFn) has no - * cancel handle, so a frame scheduled before a stop()/snapTo() cannot be - * pulled back out of the queue — instead each scheduled tick closure - * captures the generation it was born into, and _tick() no-ops (does not - * emit, does not reschedule) if that generation is stale. Without this, - * stop() followed by a resuming setTarget() (or snapTo()) leaves the old - * frame alive alongside the new one: both re-schedule themselves forever, - * doubling the effective tick rate every frame (Lit hostDisconnected/ - * hostConnected churn, and reduced-motion mid-flight snaps, both do this). - */ - private _generation: number = 0; // ── Constructor ────────────────────────────────────────────────────────── @@ -227,20 +217,29 @@ export class MotionValue { * Returns an unsubscribe function. */ onChange(cb: (value: number) => void): () => void { - const added = !this._listeners.has(cb); - this._listeners.add(cb); - // Подписка становится видимой только вместе с успешной первичной доставкой: - // иначе бросивший callback навсегда отравляет каждый следующий кадр. + if (!this._spring) return noopUnsubscribe; + let listeners: typeof this._listeners | null = this._listeners; + const existing = listeners.get(cb); + if (existing) { + // Повторная доставка не владеет существующей подпиской. + cb(this._value); + return existing; + } + const off = () => { + // Отзыв освобождает оба захвата; старый handle не удаляет новую подписку. + listeners?.delete(cb); + listeners = null; + cb = noopUnsubscribe; + }; + listeners.set(cb, off); + // Подписка становится видимой только вместе с успешной первичной доставкой. try { cb(this._value); } catch (error) { - // Повторный onChange того же callback не владеет старой Set-записью. - if (added) this._listeners.delete(cb); + off(); throw error; } - return () => { - this._listeners.delete(cb); - }; + return off; } /** @@ -258,23 +257,26 @@ export class MotionValue { * @param target - Finite target value. */ setTarget(target: number): void { - if (this._destroyed) return; + if (!this._spring) return; assertFinite(target); // Повтор цели сохраняет подготовленную траекторию и её часы. Проверка - // running важна: stop() не запрещает снова двигаться к той же цели. - if (this._running && target === this._target) return; - - if (target === this._value && Math.abs(this._velocity) < EPSILON) { - this._target = target; + // активного цикла важна: stop() не запрещает снова двигаться к той же цели. + const currentVelocity = this._velocity; + const settled = target === this._value && Math.abs(currentVelocity) < EPSILON; + if (target === this._target && (this._run || settled)) return; + this._epoch++; + this._target = target; + if (settled) { + this._run = null; + this._velocity = 0; return; } // ── Smooth pickup: capture current velocity before resetting run state ── - const currentVelocity = this._velocity; // units/s const targetRange = target - this._value; const range = - !(Math.abs(targetRange) > EPSILON) && currentVelocity !== 0 + Math.abs(targetRange) <= EPSILON && currentVelocity !== 0 ? Math.sign(currentVelocity) * Math.max( EPSILON, Math.abs(this._value) * Number.EPSILON, @@ -283,28 +285,24 @@ export class MotionValue { // Даже конечные операнды могут переполнить частное: солверу нельзя // передавать бесконечный v0 из узкого, но невырожденного диапазона. - const normalized = currentVelocity / range; - const v0Normalized = Number.isFinite(normalized) ? normalized : 0; + const v0Normalized = finiteOr(currentVelocity / range, 0); // ── Reset run state ────────────────────────────────────────────────── this._from = this._value; - this._target = target; this._range = range; this._v0Normalized = v0Normalized; // Новый origin принадлежит последнему опубликованному snapshot, а не // будущему callback. Иначе поток setTarget перед каждым кадром навсегда // держит elapsed=0. Глобальные часы не читаются; до первого кадра epoch нет. - this._startTs = this._running && this._startTs !== undefined + this._startTs = this._run && this._startTs !== undefined ? this._startTs + this._elapsed * 1000 : undefined; - this._elapsed = 0; - this._frameCount = 0; + this._frameCount = this._elapsed = 0; // ── Start frame loop (idempotent: only one loop runs at a time) ────── - if (!this._running) { + if (!this._run) { this._useTimeoutFallback = false; - this._running = true; - this._schedule(this._generation); + this._schedule(this._run = {}); } // If already running, the active loop will pick up the new _target/_from/_v0Normalized // on its next tick (because it re-reads these fields). The loop is already scheduled. @@ -315,23 +313,25 @@ export class MotionValue { * After destroy(), setTarget() and onChange() are no-ops. */ destroy(): void { - this._destroyed = true; - this._running = false; - this._listeners.clear(); + if (!this._spring) return; + this._epoch++; + // Параметры могут содержать ссылки на компонент; terminal больше не исполняет физику. + this._spring = this._requestFrame = this._run = null; + this._listeners.forEach((off) => off()); } /** - * Halt the running frame loop without destroying the instance: no further - * ticks fire, but `_destroyed` stays false and listeners are kept — unlike - * destroy(), a later setTarget() resumes animating normally. For consumers - * whose host can disconnect and reconnect (e.g. Lit hostDisconnected/ - * hostConnected) without permanently killing the value. + * Останавливает текущий цикл, сохраняя параметры пружины и подписки. + * Следующий setTarget возобновляет движение. Подходит для временного + * отключения хоста (например, Lit hostDisconnected/hostConnected); + * необратимое завершение остаётся за destroy(). */ stop(): void { - this._running = false; + if (!this._run) return; + this._epoch++; + this._run = null; // Не сбрасываем неактивную траекторию: следующий setTarget — её единственный - // инициализатор. Поколение отсекает callback до любого чтения её полей. - this._generation++; // invalidate any frame already scheduled by this run + // инициализатор. Отозванный объект отсекает callback до чтения её полей. } /** @@ -348,17 +348,14 @@ export class MotionValue { * форсированный re-render — штатный путь для этого host.requestUpdate(). */ snapTo(target: number): void { - if (this._destroyed) return; + if (!this._spring) return; assertFinite(target); // Идемпотентность: уже покоимся ровно в target → нечего менять и незачем // эмитить (лишний requestUpdate у Lit-хоста). Живой ран в тот же target — // НЕ no-op: его надо прервать и снапнуть. - if (!this._running && this._value === target && this._target === target) return; - this._generation++; // invalidate any frame scheduled by the run being replaced - this._running = false; - this._value = target; + if (!this._run && this._value === target && this._target === target) return; + this._run = null; this._target = target; - this._velocity = 0; this._emit(target); } @@ -369,143 +366,133 @@ export class MotionValue { * бывшие две копии, ужим под гейт ядра): handle=0 = non-draining step-clock * (конвенция repo) → setTimeout(0)-fallback, дальше цикл живёт на нём. */ - private _schedule(gen: number): void { + private _schedule(run: object): void { + // Единственный вход в host IO принадлежит только текущему живому циклу. + if (run !== this._run) return; let sync = true; let called = false; let timestamp: number | undefined; try { - if (this._useTimeoutFallback) { - setTimeout(() => this._tick(undefined, gen), 0); - return; - } - const handle = this._requestFrame((ts) => { - if (sync) { - called = true; - timestamp = ts; - } else if (!this._useTimeoutFallback) { - this._tick(ts, gen); - } - }); - sync = false; - if (called || handle === 0) { + if (!this._useTimeoutFallback) { + const handle = this._requestFrame!((ts) => { + if (sync) { + called = true; + timestamp = ts; + } else if (!called && !this._useTimeoutFallback) { + // Заявка rAF одноразова: погашаем её до getter/listener-границ тика. + called = true; + this._tick(ts, run); + } + }); + sync = false; + // Host мог завершить владельца до возврата handle или синхронного callback. + if (run !== this._run) return; + if (!called && handle !== 0) return; // Синхронный host и handle=0 сходятся в один trampoline; callback host-а // после возврата уже не может создать второй живой тик. this._useTimeoutFallback = true; - setTimeout(() => this._tick(timestamp, gen), 0); } + // Первый fallback сохраняет timestamp host-а; последующие используют FIXED_DT. + setTimeout(() => this._tick(timestamp, run), 0); } catch (error) { - if (gen === this._generation) { - // Host мог поставить callback перед throw: новое поколение делает его - // инертным, а running=false позволяет следующему setTarget повторить выдачу. + if (run === this._run) { + // Host мог поставить callback перед throw: отзыв делает его инертным + // и позволяет следующему setTarget повторить выдачу. this.stop(); } throw error; } } - private _tick(ts: number | undefined, gen: number): void { - // A frame scheduled by a run that was since stop()/snapTo()-ed away is - // stale: it must not emit and must not reschedule (see _generation doc). - if (gen !== this._generation) return; - if (!this._running) return; - if (this._tickActive) return; - this._tickActive = true; - try { - // Advance elapsed time. - if (ts !== undefined) { - if (this._startTs === undefined) this._startTs = ts; - this._elapsed = (ts - this._startTs) / 1000; - } else { - this._elapsed += FIXED_DT_S; - } + private _tick(ts: number | undefined, run: object): void { + // Отозванный цикл не публикует кадры и не ставит новые, даже если + // setTarget уже начал другой цикл на том же экземпляре. + if (run !== this._run) return; + // Advance elapsed time. + if (ts !== undefined) { + if (this._startTs === undefined) this._startTs = ts; + this._elapsed = (ts - this._startTs) / 1000; + } else { + this._elapsed += FIXED_DT_S; + } - this._frameCount++; - - const range = this._range; - const absRange = Math.abs(range); - - // Общий солвер (internal/solver.ts) + стражи этого модуля инлайн - // (value→1, velocity→0 — политика отличается от clampFinite spring.ts). - const raw = solveSpring(this._spring, this._elapsed, this._v0Normalized, solverSample); - const normPos = Number.isFinite(raw.value) ? raw.value : 1; - const normVel = Number.isFinite(raw.velocity) ? raw.velocity : 0; - - // Denormalize: absolute value and velocity. - const rawValue = this._from + normPos * range; - const rawVelocity = normVel * range; // units/s - - // Check convergence or hard cap. - // Единый epsilon-пол знаменателя (двойной Math.max свёрнут в const — ужим). - const denom = Math.max(absRange, EPSILON); - const converged = - // Frame-cap страхует только застывший host-clock. При растущем времени - // большой переносимый v0 вправе оседать дольше rest-бюджета. - (this._frameCount >= MAX_FRAMES && this._elapsed <= 0) || - !Number.isFinite(range) || // unrepresentable span: |from|+|target| overflowed past MAX_VALUE - // Реально крошечный span из покоя снапается как раньше. При живом - // импульсе _range синтетически представим и эта ветка не съедает скорость. - (absRange < EPSILON && this._v0Normalized === 0) || - (Math.abs(rawValue - (this._from + range)) / denom < CONVERGENCE_THRESHOLD && - Math.abs(rawVelocity) / denom < CONVERGENCE_THRESHOLD); - - // Emit value. bounded=true (default): CSS-safe clamp to [from, target]. - // bounded=false: honest trajectory — underdamped overshoot is emitted. - const outputRange = this._target - this._from; - const lo = outputRange >= 0 ? this._from : this._target; - const hi = outputRange >= 0 ? this._target : this._from; - const clampedValue = this._clamp ? Math.max(lo, Math.min(hi, rawValue)) : rawValue; - - // Единый снап-в-target: сходимость ИЛИ финальный CSS-страж (инвариант 2) — - // даже конечный range может переполнить денормализацию в Inf/NaN на - // экстремальных величинах; non-finite не эмитится НИКОГДА, единственный - // контрактно-безопасный исход — снап в (валидированно-конечный) target. - // Одно тело вместо двух идентичных (converged / non-finite) — семантика - // бит-в-бит прежняя, ужим под размерный гейт ядра (срез #93). - if (converged || !Number.isFinite(clampedValue) || !Number.isFinite(rawVelocity)) { - this._value = this._target; - this._velocity = 0; - this._running = false; - // Сохраняет прежнюю reentrant-семантику финального emit: синхронный - // scheduler нового setTarget не должен увидеть guard старого рана. - this._tickActive = false; - this._emit(this._target); - return; - } + this._frameCount++; + + const range = this._range; + const absRange = Math.abs(range); + const epoch = this._epoch; + + // Общий солвер (internal/solver.ts) + стражи этого модуля инлайн + // (value→1, velocity→0 — политика отличается от clampFinite spring.ts). + const raw = solveSpring(this._spring!, this._elapsed, this._v0Normalized, solverSample); + // Getter мог сменить цель без нового run. Старый sample не публикуется, + // а единственный следующий кадр остаётся у живого владельца. + if (epoch !== this._epoch) return this._schedule(run); + // Denormalize: absolute value and velocity. + const rawValue = this._from + finiteOr(raw.value, 1) * range; + const rawVelocity = finiteOr(raw.velocity, 0) * range; // units/s + + // Check convergence or hard cap. + // Узкий span из покоя завершает выражение до деления; при импульсе + // setTarget уже расширил range до EPSILON. + const converged = + // Frame-cap страхует только застывший host-clock. При растущем времени + // большой переносимый v0 вправе оседать дольше rest-бюджета. + (this._frameCount >= MAX_FRAMES && this._elapsed <= 0) || + // Реально крошечный span из покоя снапается как раньше. При живом + // импульсе _range синтетически представим и эта ветка не съедает скорость. + (absRange < EPSILON && this._v0Normalized === 0) || + (Math.abs(rawValue - (this._from + range)) / absRange < CONVERGENCE_THRESHOLD && + Math.abs(rawVelocity) / absRange < CONVERGENCE_THRESHOLD); + + // Emit value. bounded=true (default): CSS-safe clamp to [from, target]. + // bounded=false: honest trajectory — underdamped overshoot is emitted. + const forward = this._target >= this._from; + const lo = forward ? this._from : this._target; + const hi = forward ? this._target : this._from; + const clampedValue = this._clamp ? Math.max(lo, Math.min(hi, rawValue)) : rawValue; + + // Единый снап-в-target: сходимость ИЛИ финальный CSS-страж (инвариант 2) — + // даже конечный range может переполнить денормализацию в Inf/NaN на + // экстремальных величинах; non-finite не эмитится НИКОГДА, единственный + // контрактно-безопасный исход — снап в (валидированно-конечный) target. + // Одно тело вместо двух идентичных (converged / non-finite) — семантика + // бит-в-бит прежняя, ужим под размерный гейт ядра (срез #93). + if (converged || !Number.isFinite(clampedValue) || !Number.isFinite(rawVelocity)) { + this._run = null; + return this._emit(this._target); + } - this._value = clampedValue; - this._velocity = rawVelocity; - try { - this._emit(clampedValue); - } catch (primaryError) { - // Сначала сохраняем живой ран; transactional _schedule сам сделает его - // retryable при host-ошибке. Вторичная ошибка не маскирует listener RCA. - if (gen === this._generation && this._running) { - try { this._schedule(gen); } catch { /* первична listener-ошибка */ } - } - throw primaryError; - } - if (gen === this._generation && this._running) this._schedule(gen); - } finally { - this._tickActive = false; + try { + this._emit(clampedValue, rawVelocity); + } catch (primaryError) { + // Сначала сохраняем живой ран; transactional _schedule сам сделает его + // retryable при host-ошибке. Вторичная ошибка не маскирует listener RCA. + try { this._schedule(run); } catch { /* первична listener-ошибка */ } + throw primaryError; } + this._schedule(run); } - private _emit(value: number): void { + /** Снимок и его версия публикуются вместе до любого listener. */ + private _emit(value: number, velocity = 0): void { + this._epoch++; + this._value = value; + this._velocity = velocity; let failed = false; let firstError: unknown; - for (const cb of this._listeners) { + this._listeners.forEach((off, cb) => { try { cb(value); } catch (error) { - // Set допускает удаление текущего элемента без snapshot-массива: соседям - // всё ещё доставляется этот кадр, а дефектный callback больше не вызывается. - this._listeners.delete(cb); + // Map передал исходную отписку до callback; преемник не отзывается. + off(); if (!failed) { failed = true; firstError = error; } } - } + }); if (failed) throw firstError; } } diff --git a/src/projection/geometry.ts b/src/projection/geometry.ts index 52f517a18..8caf58ff2 100644 --- a/src/projection/geometry.ts +++ b/src/projection/geometry.ts @@ -352,7 +352,7 @@ export interface DriverProjector extends Projector { at(p: number, positionBasisValue?: number): readonly ProjectionFrame[]; } -/** Реализация читает остаточный базис без изменения данных владельца. */ +/** @internal Реализация читает остаточный базис без изменения данных владельца. */ export function createProjector(nodes: readonly Readonly[]): DriverProjector { const count = nodes.length; diff --git a/src/stagger/scheduler.ts b/src/stagger/scheduler.ts index a871a7232..419debd15 100644 --- a/src/stagger/scheduler.ts +++ b/src/stagger/scheduler.ts @@ -56,11 +56,11 @@ export function scheduleStagger( const numericOrigin = Number.isFinite(fromInput) ? Math.max(0, Math.min(count - 1, Math.round(fromInput as number))) : 0; + const fromEdges = fromInput === 'edges'; let maxDistance = 0; if (gridColumns) { const rows = Math.ceil(count / gridColumns); - const fromEdges = fromInput === 'edges'; let originRow = 0; let originColumn = 0; if (!fromEdges) { @@ -96,15 +96,11 @@ export function scheduleStagger( return result; } - const fromEdges = fromInput === 'edges'; - let origin = 0; - if (!fromEdges) { - origin = fromInput === 'last' - ? count - 1 - : fromInput === 'center' - ? (count - 1) / 2 - : numericOrigin; - } + const origin = fromInput === 'last' + ? count - 1 + : fromInput === 'center' + ? (count - 1) / 2 + : numericOrigin; maxDistance = fromEdges ? Math.floor((count - 1) / 2) : Math.max(origin, count - 1 - origin); diff --git a/src/svelte/index.ts b/src/svelte/index.ts index 15bbd5179..3d55b291b 100644 --- a/src/svelte/index.ts +++ b/src/svelte/index.ts @@ -38,9 +38,9 @@ function prefersReducedMotion(): boolean { */ export interface SpringStore { /** - * Svelte store subscription. Receives every animated frame value. - * Calls `run` immediately with the current value on subscribe. - * Returns an unsubscribe function (Svelte auto-unsubscribes with `$` syntax). + * Подписка Svelte: каждый вызов сразу доставляет run текущее значение. + * Повторная подписка с тем же run использует текущую активную регистрацию. + * Любая её отписка отзывает регистрацию; повтор отписки не затрагивает преемника. */ subscribe(run: (value: number) => void): () => void; @@ -96,24 +96,35 @@ export function springStore( ): SpringStore { const mv = createBoundValue({ initial, spring, requestFrame }); - // Subscriber registry (mirrors Svelte store contract). - const subscribers = new Set<(value: number) => void>(); + // Callback владеет одной активной регистрацией и общей функцией её отзыва. + const subscribers = new Map<(value: number) => void, () => void>(); // Listen to MotionValue changes and broadcast to all Svelte subscribers. mv.onChange((v) => { - for (const run of subscribers) { + for (const run of subscribers.keys()) { run(v); } }); return { subscribe(run) { - subscribers.add(run); - // Emit current value immediately (Svelte store contract). - run(mv.value); - return () => { - subscribers.delete(run); + const existing = subscribers.get(run); + if (existing) { + run(mv.value); + return existing; + } + let registry: typeof subscribers | null = subscribers; + let callback: typeof run | null = run; + const off = () => { + if (callback === null) return; + registry?.delete(callback); + registry = null; + callback = null; }; + subscribers.set(run, off); + // Немедленная доставка и её прежняя ошибка остаются частью subscribe. + run(mv.value); + return off; }, set(target, modeOverride) { @@ -130,7 +141,7 @@ export function springStore( destroy() { mv.destroy(); - subscribers.clear(); + subscribers.forEach((off) => off()); }, }; } diff --git a/src/tokens/index.ts b/src/tokens/index.ts index 854358d3d..2dd0c4289 100644 --- a/src/tokens/index.ts +++ b/src/tokens/index.ts @@ -38,6 +38,7 @@ import { cubicBezierUnchecked } from '../internal/cubic-bezier.js'; import { DEFAULT_DURATION_MS, DEFAULT_SPRING, + SNAPPY_SPRING, STANDARD_EASING, STANDARD_EASING_COORDS, } from '../internal/motion-defaults.js'; @@ -216,7 +217,7 @@ export interface SpringTokens { export const spring: SpringTokens = { default: DEFAULT_SPRING, gentle: { mass: 1, stiffness: 120, damping: 30 }, - snappy: { mass: 1, stiffness: 260, damping: 28 }, + snappy: SNAPPY_SPRING, bounce: { mass: 1, stiffness: 180, damping: 12 }, // PURE-аннотации: вызовы с константами не бросают (запинено тестом), поэтому // честно помечены чистыми — иначе tsup-бандлы соседних субпутей (presets, diff --git a/src/vue/index.ts b/src/vue/index.ts index c57525a1a..19308976c 100644 --- a/src/vue/index.ts +++ b/src/vue/index.ts @@ -25,7 +25,8 @@ * SSR-safe: no window/document access on import. */ -import { ref, watch, onUnmounted, type Ref, type ObjectDirective } from 'vue'; +import { ref, watch, onUnmounted, getCurrentInstance, type Ref, type ObjectDirective } from 'vue'; +import * as Vue from 'vue'; import type { MotionValue, MotionValueOptions, RequestFrameFn } from '../motion-value.js'; import { createBoundValue } from '../internal/binding-value.js'; import { renderTemplateValue } from '../internal/template.js'; @@ -41,7 +42,8 @@ function prefersReducedMotion(): boolean { // ─── useMotionValue ─────────────────────────────────────────────────────── /** - * Creates a stable MotionValue instance, cleaned up on component unmount. + * Создаёт MotionValue с уборкой при остановке текущего Vue scope. + * Вне scope владелец вызывает destroy() явно. * * @param initial - Initial numeric value. Must be finite. * @param spring - Spring physics parameters. @@ -60,13 +62,12 @@ export function useMotionValue( ): MotionValue { const mv = createBoundValue({ initial, spring, requestFrame }); - try { - onUnmounted(() => { - mv.destroy(); - }); - } catch { - // Called outside component context (e.g. tests) — no lifecycle hook available. - } + // Effect scope может закончиться раньше компонента. Vue 3.0/3.1 ещё не + // экспортирует scope API: для этих поддерживаемых версий остаётся unmount. + const registerCleanup = Vue.getCurrentScope?.() + ? Vue.onScopeDispose + : getCurrentInstance() ? onUnmounted : undefined; + registerCleanup?.(() => mv.destroy()); return mv; } @@ -119,18 +120,10 @@ export function useSpring( const value = ref(initial); // Subscribe to MotionValue changes. - const unsub = mv.onChange((v) => { + mv.onChange((v) => { value.value = v; }); - try { - onUnmounted(() => { - unsub(); - }); - } catch { - // Outside component context — subscriber will be cleaned up by mv.destroy(). - } - // Watch target changes and drive animation. const targetGetter = typeof target === 'function' ? target : () => target.value; diff --git a/test/animate-scope-recipes.test.ts b/test/animate-scope-recipes.test.ts index 9d6a54069..81bad6d06 100644 --- a/test/animate-scope-recipes.test.ts +++ b/test/animate-scope-recipes.test.ts @@ -1,21 +1,35 @@ import { execFileSync } from 'node:child_process'; -import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'; -import { createRequire } from 'node:module'; -import { tmpdir } from 'node:os'; -import { dirname, join, resolve } from 'node:path'; +import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'; +import { dirname, join, resolve, sep } from 'node:path'; import { fileURLToPath } from 'node:url'; import { build } from 'esbuild'; import { expect, it } from 'vitest'; const root = resolve(dirname(fileURLToPath(import.meta.url)), '..'); -const require = createRequire(join(root, 'package.json')); it('runnable DOM setup снимает listener при броске; React recipe рендерится без DOM на сервере', async () => { - const dir = mkdtempSync(join(tmpdir(), 'scope-recipes-')); + mkdirSync(join(root, 'scratchpad'), { recursive: true }); + const dir = mkdtempSync(join(root, 'scratchpad', 'scope recipes ')); try { const sourceUrl = new URL('../browser/fixtures/scope-recipes.mjs', import.meta.url).href; - const { writeScopeRecipeSources } = await import(sourceUrl); - writeScopeRecipeSources(root, dir); + const { packScopeRecipePackage, writeScopeRecipeSources } = await import(sourceUrl); + const { packageRoot, receipt } = packScopeRecipePackage(root, dir); + writeScopeRecipeSources(packageRoot, dir); + expect(receipt.tarball.sha256).toMatch(/^[a-f0-9]{64}$/); + const config = join(dir, 'tsconfig.json'); + writeFileSync(config, JSON.stringify({ compilerOptions: { + noEmit: true, strict: true, skipLibCheck: true, lib: ['es2022', 'dom'], + module: 'nodenext', moduleResolution: 'nodenext', types: ['react'], + }, files: ['card-motion.ts', 'react-card.ts', 'solid-card.ts', 'compositor-sheet.ts', 'compositor-pager.ts', + 'presence-dialog.ts', 'reorder-component.ts'] })); + for (const compiler of ['typescript5', 'typescript']) { + try { + execFileSync(process.execPath, [join(root, 'node_modules', compiler, 'bin', 'tsc'), '--project', config], + { cwd: root, encoding: 'utf8', timeout: 60_000 }); + } catch (error: any) { + throw new Error(`${compiler} отверг packed literal recipes:\n${error.stdout ?? ''}\n${error.stderr ?? ''}`, { cause: error }); + } + } const file = join(dir, 'entry.ts'); const out = join(dir, 'run.cjs'); writeFileSync(file, ` import assert from 'node:assert/strict'; @@ -23,7 +37,11 @@ it('runnable DOM setup снимает listener при броске; React recipe import {renderToString} from 'react-dom/server'; import {ScopedCard} from './react-card.js'; import {mountCardMotion} from './card-motion.js'; + import {mountCompositorSheet} from './compositor-sheet.js'; + import {mountCompositorPager} from './compositor-pager.js'; assert.equal(typeof document, 'undefined'); + assert.equal(typeof mountCompositorSheet,'function'); + assert.equal(typeof mountCompositorPager,'function'); const html=renderToString(createElement(ScopedCard)); assert(html.includes('data-replay')); assert(html.includes('motion-target')); const listeners=new Set(); let calls=0; @@ -35,10 +53,13 @@ it('runnable DOM setup снимает listener при броске; React recipe assert.equal(calls,1); assert.equal(listeners.size,0,'setup без controls оставил listener'); console.log('scope-recipes: PASS'); `); - await build({ absWorkingDir: root, entryPoints: [file], outfile: out, platform: 'node', format: 'cjs', bundle: true, - alias: { '@labpics/motion/animate': join(root, 'dist/animate/index.cjs'), - react: require.resolve('react'), 'react-dom/server': require.resolve('react-dom/server') }, + const result = await build({ absWorkingDir: root, entryPoints: [file], outfile: out, platform: 'node', format: 'cjs', bundle: true, + metafile: true, }); + const inputs = Object.keys(result.metafile!.inputs).map(path => resolve(root, path)); + expect(inputs.some(path => path.startsWith(packageRoot + sep))).toBe(true); + expect(inputs.filter(path => path.startsWith(join(root, 'dist') + sep) + || path.startsWith(join(root, 'src') + sep))).toEqual([]); expect(execFileSync(process.execPath, [out], { cwd: root, encoding: 'utf8', timeout: 30_000 })).toContain('scope-recipes: PASS'); } finally { rmSync(dir, { recursive: true, force: true }); } -}); +}, 120_000); diff --git a/test/animate-terminal-retention.test.ts b/test/animate-terminal-retention.test.ts new file mode 100644 index 000000000..2fd43c76c --- /dev/null +++ b/test/animate-terminal-retention.test.ts @@ -0,0 +1,19 @@ +import { execFileSync } from 'node:child_process'; +import { mkdtempSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join, resolve } from 'node:path'; +import { buildSync } from 'esbuild'; +import { expect, it } from 'vitest'; + +it('terminal animate освобождает исполнители и trajectory buffers при сохранённых controls', () => { + const work = mkdtempSync(join(tmpdir(), 'labmotion-animate-terminal-')); + const outfile = join(work, 'probe.mjs'); + try { + buildSync({ entryPoints: [resolve('test/fixtures/animate-terminal-retention.probe.ts')], + outfile, bundle: true, format: 'esm', platform: 'node', target: 'node22' }); + const output = execFileSync(process.execPath, ['--expose-gc', outfile], { + encoding: 'utf8', timeout: 60_000, + }); + expect(output).toContain('animate-terminal-retention: PASS'); + } finally { rmSync(work, { recursive: true, force: true }); } +}); diff --git a/test/animate-waapi-lifecycle.test.ts b/test/animate-waapi-lifecycle.test.ts index 93716d298..3b6ceeef9 100644 --- a/test/animate-waapi-lifecycle.test.ts +++ b/test/animate-waapi-lifecycle.test.ts @@ -548,6 +548,98 @@ describe('animate: жизненный цикл WAAPI-юнита', () => { controls.cancel(); }); + it('отмена из getter requestFrame при lazy handoff остаётся terminal без новых jobs', async () => { + const target = fakeEl({}, true); + const physics = { mass: 1, stiffness: 100, damping: 10 }; + const clock = makeClock(); + let armed = false, requests = 0; + let controls: ReturnType; + const frame = (callback: (timestamp?: number) => void): number => { + requests++; return clock.requestFrame(callback); + }; + controls = animate(target.el, { opacity: [0, 1] }, { + spring: physics, now: () => 0, setTimer: () => () => {}, + get requestFrame() { + if (armed) { armed = false; controls.cancel(); } + return frame; + }, + }); + expect(target.animateCalls).toHaveLength(1); + armed = true; + expect(() => controls.seek(firstSerializedTargetCrossingMs(physics))).not.toThrow(); + await controls.finished; + expect(target.cancels).toBe(1); + expect(requests).toBe(0); + const before = target.writes.length; + controls.play(); controls.pause(); controls.seek(32); controls.stop(); + clock.drain(); + expect(target.writes).toHaveLength(before); + expect(requests).toBe(0); + }); + + it('вложенный crossing seek из getter requestFrame не оставляет writer после terminal cancel', async () => { + const target = fakeEl({}, true); + const physics = { mass: 1, stiffness: 100, damping: 10 }; + const crossingMs = firstSerializedTargetCrossingMs(physics); + const clock = makeClock(); + let armed = false, requests = 0, completes = 0; + let controls: ReturnType; + const frame = (callback: (timestamp?: number) => void): number => { + requests++; return clock.requestFrame(callback); + }; + controls = animate(target.el, { opacity: [0, 1] }, { + spring: physics, now: () => 0, setTimer: () => () => {}, + onComplete: () => { completes++; }, + get requestFrame() { + if (armed) { armed = false; controls.seek(crossingMs); } + return frame; + }, + }); + armed = true; + controls.seek(crossingMs); + expect(requests).toBe(1); + controls.cancel(); + await controls.finished; + expect(target.cancels).toBe(1); + const before = target.writes.length; + const requested = requests; + controls.play(); controls.pause(); controls.seek(32); controls.stop(); + clock.drain(); + expect(target.writes).toHaveLength(before); + expect(requests).toBe(requested); + expect(completes).toBe(0); + }); + + it('принятая pause из getter requestFrame сохраняется после crossing seek до явного play', async () => { + const target = fakeEl({}, true); + const physics = { mass: 1, stiffness: 100, damping: 10 }; + const clock = makeClock(); + let armed = false, requests = 0, completes = 0; + let controls: ReturnType; + const frame = (callback: (timestamp?: number) => void): number => { + requests++; return clock.requestFrame(callback); + }; + controls = animate(target.el, { opacity: [0, 1] }, { + spring: physics, now: () => 0, setTimer: () => () => {}, + onComplete: () => { completes++; }, + get requestFrame() { + if (armed) { armed = false; controls.pause(); } + return frame; + }, + }); + armed = true; + controls.seek(firstSerializedTargetCrossingMs(physics)); + expect(target.cancels).toBe(1); + const before = target.writes.length; + clock.drain(); + expect(requests).toBe(0); + expect(target.writes).toHaveLength(before); + controls.play(); + expect(requests).toBe(1); + controls.cancel(); await controls.finished; + expect(completes).toBe(0); + }); + it('pause → seek(target crossing) не тикает до play и продолжает C1 в live', async () => { const target = fakeEl({}, true); const physics = { mass: 1, stiffness: 100, damping: 10 }; diff --git a/test/behaviors-late-callback-owner.test.ts b/test/behaviors-late-callback-owner.test.ts new file mode 100644 index 000000000..0bac1471f --- /dev/null +++ b/test/behaviors-late-callback-owner.test.ts @@ -0,0 +1,66 @@ +import { describe, expect, it } from 'vitest'; +import { + createDragDismiss, createPullToRefresh, + type DismissController, type PullController, +} from '../src/behaviors/index.js'; +import { makeClock, pt, reduceMedia } from './behaviors-helpers.js'; + +describe('./behaviors — getter позднего callback не восстанавливает отозванное намерение', () => { + for (const kind of ['dismiss', 'refresh'] as const) { + for (const reduced of [false, true]) { + function scenario(action?: 'destroy' | 'cancel') { + const clock = makeClock(); + let control!: DismissController | PullController; + let reads = 0, calls = 0; + const receivers: unknown[] = []; + const callback = function (this: unknown) { calls++; receivers.push(this); }; + // Обычный method call не читает одноимённый public member функции. + Object.defineProperty(callback, 'call', { get() { throw new Error('не читать callback.call'); } }); + const options = { + distanceThreshold: 10, threshold: 10, resistance: 1, + requestFrame: clock.requestFrame, matchMedia: reduced ? reduceMedia() : undefined, + get onDismiss() { reads++; action && control[action](); return callback; }, + get onRefresh() { reads++; action && control[action](); return callback; }, + }; + control = kind === 'dismiss' ? createDragDismiss(options) : createPullToRefresh(options); + control.pointerDown(pt(0, 0, 0)); + control.pointerMove(pt(0, 20, 0.2)); + control.pointerUp(pt(0, 20, 0.4)); + // Проверка до drain различает синхронный reduced-путь и кадровую доводку. + expect(clock.rafCalls()).toBe(reduced ? 0 : 1); + expect(clock.pending()).toBe(reduced ? 0 : 1); + expect(reads).toBe(reduced ? 1 : 0); + expect(calls).toBe(reduced && !action ? 1 : 0); + clock.drain(16); + return { control, clock, options, receivers, reads, calls }; + } + + for (const action of ['destroy', 'cancel'] as const) { + it(`${kind}, reduced=${reduced}: getter ${action} отзывает callback`, async () => { + const result = scenario(action); + const state = result.control.state; + await Promise.resolve(); await Promise.resolve(); + result.clock.drain(16); + expect(result.clock.pending()).toBe(0); + if (reduced) expect(result.clock.rafCalls()).toBe(0); + expect(result.reads).toBe(1); + expect(result.calls).toBe(0); + expect(result.receivers).toEqual([]); + expect(result.control.state).toBe(state); + }); + } + + it(`${kind}, reduced=${reduced}: здоровый getter читается один раз и сохраняет receiver`, async () => { + const result = scenario(); + await Promise.resolve(); await Promise.resolve(); + result.clock.drain(16); + expect(result.clock.pending()).toBe(0); + if (reduced) expect(result.clock.rafCalls()).toBe(0); + expect(result.reads).toBe(1); + expect(result.calls).toBe(1); + expect(result.receivers).toEqual([result.options]); + if (kind === 'refresh') expect(result.control.state.phase).toBe('idle'); + }); + } + } +}); diff --git a/test/behaviors-reset-domain.test.ts b/test/behaviors-reset-domain.test.ts new file mode 100644 index 000000000..556a118fe --- /dev/null +++ b/test/behaviors-reset-domain.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from 'vitest'; +import { createBottomSheet } from '../src/behaviors/index.js'; + +const point = (y: number, t: number) => ({ x: 0, y, t }); + +describe('./behaviors — tracker reset при смене цели', () => { + it('обычный getter точки не мешает завершить разрешённый flick', () => { + const sheet = createBottomSheet({ snapPoints: [0, 100, 200] }); + sheet.pointerDown(point(0, 0)); + sheet.pointerMove(point(50, 0.1)); + let read = false; + + sheet.pointerUp({ get x() { read = true; return 0; }, y: 200, t: 0.2 }); + + expect(read).toBe(true); + expect(sheet.state).toMatchObject({ value: 200, snapIndex: 2, phase: 'settle' }); + sheet.destroy(); + }); + + it('snapTo внутри getter точки сохраняет samples ещё исполняемого pointerUp', () => { + const sheet = createBottomSheet({ snapPoints: [0, 100, 200] }); + sheet.pointerDown(point(0, 0)); + sheet.pointerMove(point(50, 0.1)); + let redirected = false; + + sheet.pointerUp({ + get x() { + if (!redirected) { redirected = true; sheet.snapTo(1); } + return 0; + }, + y: 200, + t: 0.2, + }); + + // Последние samples: y=50 при t=.1 и y=200 при t=.2. Скорость 1500 px/s + // из позиции 100 проецируется выше 200, поэтому прежний target — snap 2. + expect(redirected).toBe(true); + expect(sheet.state).toMatchObject({ value: 200, snapIndex: 2, phase: 'settle' }); + sheet.destroy(); + }); +}); diff --git a/test/behaviors-state-cascade-model.test.ts b/test/behaviors-state-cascade-model.test.ts index a5d6d9460..2d8c1cc0c 100644 --- a/test/behaviors-state-cascade-model.test.ts +++ b/test/behaviors-state-cascade-model.test.ts @@ -1,3 +1,4 @@ +import assert from 'node:assert/strict'; import { describe, expect, it } from 'vitest'; import { createStateCascade, type StateCascadeLayer } from '../src/behaviors/index.js'; import { MotionValue } from '../src/motion-value.js'; @@ -45,16 +46,16 @@ describe('каскад: независимая модель и настоящи // Иная модель: полный shallow merge всех слоёв; не повторяет affected-key scan. const expected = Object.assign(Object.create(null) as Values, ...slots.map(slot => slot.target)); const actual = state.snapshot(); - expect(Object.keys(actual).sort()).toEqual(Object.keys(expected).sort()); - expect(Object.keys(mirror).sort()).toEqual(Object.keys(expected).sort()); + assert.deepEqual(Object.keys(actual).sort(), Object.keys(expected).sort()); + assert.deepEqual(Object.keys(mirror).sort(), Object.keys(expected).sort()); for (const key of keys) { - expect(Object.is(actual[key], expected[key])).toBe(true); - expect(Object.is(mirror[key], expected[key])).toBe(true); - expect(Object.is(state.get(key), expected[key])).toBe(true); + assert.equal(Object.is(actual[key], expected[key]), true); + assert.equal(Object.is(mirror[key], expected[key]), true); + assert.equal(Object.is(state.get(key), expected[key]), true); } } state.destroy(); - expect(slots.every(slot => !slot.handle.active)).toBe(true); + assert.equal(slots.every(slot => !slot.handle.active), true); }); it('настоящий MotionValue получает последний target, скрытые updates не перезапускают его', () => { diff --git a/test/bench-transform-pair.test.ts b/test/bench-transform-pair.test.ts index 56ecff2c5..9320afca5 100644 --- a/test/bench-transform-pair.test.ts +++ b/test/bench-transform-pair.test.ts @@ -1,16 +1,75 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'; import { tmpdir } from 'node:os'; import path from 'node:path'; +import { createHash } from 'node:crypto'; import { describe, expect, it } from 'vitest'; import { animate, type AnimateOptions, type AnimateProps } from '../src/animate/index.js'; import { TRANSFORM_PAIR_PROFILE, + createTransformLifecycleValidator, expectedTransformValues, runTransformLifecycleSample, + validateTransformLifecycleSample, } from '../scripts/bench-transform-support.mjs'; import { makeTransformPairPlan, parseTransformPairArgs, runTransformPair } from '../scripts/bench-transform-pair.mjs'; import { summarizeDistribution } from '../scripts/bench-support.mjs'; +/** Независимый линейный контроль: конечные значения, время первого кадра и публичные запросы кадров. */ +function independentFreshLinear(fault: 'cancel' | 'cleanup' | 'oracle' | null = null, reason: unknown = undefined) { + return (targets: Parameters[0], props: AnimateProps, options: AnimateOptions) => { + if (typeof targets === 'string' || !('length' in targets) || typeof options?.duration !== 'number') { + throw new Error('Линейный контроль: нужны список целей и числовая длительность'); + } + const duration = options.duration; + const from = { x: 0, y: 0, scaleX: 1, scaleY: 1, rotate: 0, skewX: 0, skewY: 0 }; + const destination = props as Record; + let start: number | undefined; + let stopped = false; + let frame = 0; + let cancels = 0; + let resolveFinished!: () => void; + const finished = new Promise((resolve) => { resolveFinished = resolve; }); + const tick = (timestamp?: number) => { + if (stopped) return; + if (timestamp === undefined) throw new Error('Линейный контроль: время кадра отсутствует'); + start ??= timestamp; + const progress = (timestamp - start) / duration; + const value = Object.fromEntries(Object.entries(from).map(([key, initial]) => + [key, initial + ((destination[key] ?? initial) - initial) * progress])); + const text = `translate(${value.x}px, ${value.y}px) scaleX(${value.scaleX}) scaleY(${value.scaleY}) rotate(${value.rotate}deg) skew(${value.skewX}deg, ${value.skewY}deg)`; + for (let target = 0; target < targets.length; target++) { + targets[target]!.style.setProperty('transform', fault === 'oracle' && frame === 2 && target === targets.length - 1 + ? 'translateX(999px)' : text); + } + frame++; + options.requestFrame!(tick); + }; + options.requestFrame!(tick); + return { + finished, + cancel() { + stopped = true; + resolveFinished(); + cancels++; + if ((fault === 'cancel' && cancels === 1) || (fault === 'cleanup' && cancels === 2)) throw reason; + }, + }; + }; +} + +type RetainedTiming = number | null | { kind: 'nonfinite'; value: string }; +type FailedTransformSample = AggregateError & { + raw: { + operationNs: RetainedTiming; + frameNs: RetainedTiming[]; + cancelDrainNs: RetainedTiming; + failurePhase: string; + unfinishedInterval: { metric: string; frame: number | null; beforeNs: string | null; afterNs: string | null } | null; + semantic: { valid: false; targetTraces: { values: (string | null)[]; writes: number[] }[] }; + beforeCleanupSemantic: { targetTraces: { values: (string | null)[]; writes: number[] }[] }; + }; +}; + describe('paired public transform lifecycle screening', () => { it('fixes the workload and balances AB/BA within every paired block', () => { expect(TRANSFORM_PAIR_PROFILE.counts).toEqual([1, 100, 1000]); @@ -386,10 +445,304 @@ describe('paired public transform lifecycle screening', () => { } catch (error) { expect(error).toBeInstanceOf(AggregateError); expect((error as AggregateError).errors).toEqual([measurementError, cleanupError]); + expect((error as FailedTransformSample).raw).toMatchObject({ + operationNs: null, frameNs: [], cancelDrainNs: null, + unfinishedInterval: { metric: 'operationNs', beforeNs: '0', afterNs: null }, + semantic: { valid: false, finished: 'fulfilled', pending: 0 }, + }); } expect(cancels).toBe(1); }); + it('сохраняет семь завершённых интервалов при независимом позднем отказе cancel', async () => { + let healthyReads = 0; + const healthy = await runTransformLifecycleSample({ + animate: independentFreshLinear(), count: 1000, lifecycle: 'fresh', channels: 7, + nowNs: () => BigInt(++healthyReads) * 1000n, + }); + expect(healthy.semantic.valid).toBe(true); + expect(healthyReads).toBe(16); + expect(healthy.operationNs).toBe(1000); + expect(healthy.frameNs).toEqual([1000, 1000, 1000, 1000, 1000, 1000]); + expect(healthy.cancelDrainNs).toBe(1000); + + const reason = new Error('Независимый отказ поздней отмены'); + let failedReads = 0; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear('cancel', reason), count: 1000, lifecycle: 'fresh', channels: 7, + nowNs: () => BigInt(++failedReads) * 1000n, + }).then(() => { throw new Error('Неуспешный замер не должен вернуться'); }, (error: unknown) => error); + expect(failure).toBeInstanceOf(AggregateError); + const retained = failure as FailedTransformSample; + expect(retained.errors).toEqual([reason]); + expect(failedReads).toBe(15); + expect(retained.raw).toMatchObject({ + operationNs: healthy.operationNs, frameNs: healthy.frameNs, cancelDrainNs: null, + failurePhase: 'cancel', unfinishedInterval: { metric: 'cancelDrainNs', frame: null, beforeNs: '15000', afterNs: null }, + beforeCleanupSemantic: { valid: false, targets: 1000, finished: 'pending', pending: 1 }, + semantic: { valid: false, targets: 1000, finished: 'fulfilled', pending: 0 }, + }); + expect(retained.raw.semantic.targetTraces).toHaveLength(1000); + expect(retained.raw.semantic.targetTraces.every((trace) => trace.writes.join(',') === '1,1,1,1,1,1' && + trace.values.length === 6 && trace.values.every((value) => typeof value === 'string'))).toBe(true); + expect(JSON.parse(JSON.stringify(retained.raw))).toEqual(retained.raw); + }); + + it.each([7, 8])('сохраняет завершённые интервалы и CSS при throw undefined на чтении часов %i', async (failedRead) => { + let reads = 0; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear(), count: 1, lifecycle: 'fresh', channels: 7, + nowNs: () => { if (++reads === failedRead) throw undefined; return BigInt(reads) * 1000n; }, + }).then(() => { throw new Error('Отказ часов не должен стать замером'); }, (error: unknown) => error); + expect(failure).toBeInstanceOf(AggregateError); + const retained = failure as FailedTransformSample; + expect(retained.errors).toEqual([undefined]); + expect(reads).toBe(failedRead); + expect(retained.raw).toMatchObject({ + operationNs: 1000, frameNs: [1000, 1000], cancelDrainNs: null, + failurePhase: 'frame', unfinishedInterval: { metric: 'frameNs', frame: 2, beforeNs: failedRead === 8 ? '7000' : null, afterNs: null }, + beforeCleanupSemantic: { finished: 'pending', pending: 1 }, + semantic: { valid: false, finished: 'fulfilled', pending: 0 }, + }); + expect(retained.raw.beforeCleanupSemantic.targetTraces[0].writes).toEqual([1, 1, failedRead === 8 ? 1 : 0, 0, 0, 0]); + if (failedRead === 8) expect(retained.raw.beforeCleanupSemantic.targetTraces[0].values[2]).toContain('translate(64px, 40px)'); + else expect(retained.raw.beforeCleanupSemantic.targetTraces[0].values[2]).toBeNull(); + expect(retained.raw.beforeCleanupSemantic.targetTraces[0].values.slice(3)).toEqual([null, null, null]); + expect(JSON.parse(JSON.stringify(retained.raw))).toEqual(retained.raw); + }); + + it('сохраняет состояние отказа до изменения CSS очисткой и обе исходные ошибки', async () => { + const cleanupError = Object.freeze(new Error('Очистка изменила CSS и отказала')); + const linear = independentFreshLinear(); + let reads = 0; + const failure = await runTransformLifecycleSample({ + animate: (targets: Parameters[0], props: AnimateProps, options: AnimateOptions) => { + const controls = linear(targets, props, options); + return { ...controls, cancel() { + controls.cancel(); + if (typeof targets !== 'string' && 'length' in targets) targets[0]!.style.setProperty('transform', 'translateX(999px)'); + throw cleanupError; + } }; + }, + count: 1, lifecycle: 'fresh', channels: 7, + nowNs: () => { if (++reads === 8) throw undefined; return BigInt(reads) * 1000n; }, + }).then(() => { throw new Error('Отказ не должен стать замером'); }, (error: unknown) => error); + expect(failure).toBeInstanceOf(AggregateError); + const retained = failure as FailedTransformSample; + expect(retained.errors).toEqual([undefined, cleanupError]); + expect(retained.raw.beforeCleanupSemantic.targetTraces[0]).toMatchObject({ + value: expect.stringContaining('translate(64px, 40px)'), outsideWrites: 0, + }); + expect(retained.raw.semantic.targetTraces[0]).toMatchObject({ value: 'translateX(999px)', outsideWrites: 1 }); + expect(retained.raw).toMatchObject({ operationNs: 1000, frameNs: [1000, 1000], cancelDrainNs: null, semantic: { valid: false } }); + expect(JSON.parse(JSON.stringify(retained.raw))).toEqual(retained.raw); + }); + + it('сохраняет неконечный интервал явно при JSON-переносе неуспешного замера', async () => { + let reads = 0; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear(), count: 1, lifecycle: 'fresh', channels: 7, + nowNs: () => { reads++; return reads === 1 ? 0n : reads === 2 ? 1n << 1024n : BigInt(reads); }, + }).then(() => { throw new Error('Неконечные часы не должны дать замер'); }, (error: unknown) => error); + expect(failure).toBeInstanceOf(AggregateError); + const retained = failure as FailedTransformSample; + expect(retained.errors).toHaveLength(1); + expect(retained.errors[0].message).toMatch(/некорректный timing/); + expect(reads).toBe(16); + expect(retained.raw).toMatchObject({ + operationNs: { kind: 'nonfinite', value: 'Infinity' }, frameNs: [1, 1, 1, 1, 1, 1], cancelDrainNs: 1, + failurePhase: 'timing', unfinishedInterval: null, semantic: { valid: false, finished: 'fulfilled', pending: 0 }, + }); + expect(JSON.parse(JSON.stringify(retained.raw))).toEqual(retained.raw); + }); + + it('lineage сохраняет каждый внешний BigInt endpoint и фактический CSS всех целей', async () => { + const counterValues: string[] = []; + const writes: { target: number; timestampMs: number | undefined; value: string }[] = []; + let counter = 10n ** 26n; + let timestampMs: number | undefined; + const linear = independentFreshLinear(); + const sample = await runTransformLifecycleSample({ + count: 1000, lifecycle: 'fresh', channels: 7, + nowNs: () => { counter += 1000n; counterValues.push(counter.toString()); return counter; }, + animate: (targets: Parameters[0], props: AnimateProps, options: AnimateOptions) => { + if (typeof targets === 'string' || !('length' in targets)) throw new Error('Нужен список целей'); + for (let target = 0; target < targets.length; target++) { + const style = targets[target]!.style; + const write = style.setProperty.bind(style); + style.setProperty = (property, value) => { writes.push({ target, timestampMs, value }); write(property, value); }; + } + return linear(targets, props, { ...options, requestFrame: (callback) => options.requestFrame!((timestamp) => { + timestampMs = timestamp; + callback(timestamp); + }) }); + }, + }); + expect(counterValues).toHaveLength(16); + expect(sample.raw.clockReads.map((read: { valueNs: string }) => read.valueNs)).toEqual(counterValues); + expect(writes).toHaveLength(6000); + expect(sample.raw.targetTraces.encoding).toBe('runs'); + expect(sample.raw.targetTraces.count).toBe(1000); + expect(sample.raw.targetTraces.runs).toHaveLength(1); + const run = sample.raw.targetTraces.runs[0]; + expect(run.from).toBe(0); + expect(run.count).toBe(1000); + for (const write of writes) { + const frame = TRANSFORM_PAIR_PROFILE.frameOffsetsMs.indexOf(write.timestampMs! - TRANSFORM_PAIR_PROFILE.clockOriginMs); + expect(run.trace.values[frame]).toBe(write.value); + expect(run.trace.events[frame]).toMatchObject({ timestampMs: write.timestampMs, property: 'transform', value: write.value }); + } + const replay = validateTransformLifecycleSample(sample, { count: 1000, lifecycle: 'fresh', channels: 7 }); + expect(replay).toMatchObject({ operationNs: 1000, frameNs: [1000, 1000, 1000, 1000, 1000, 1000], cancelDrainNs: 1000 }); + expect(replay.intervals.map((interval: { durationNs: string }) => interval.durationNs)).toEqual(Array(8).fill('1000')); + expect(replay.traceRuns).toHaveLength(1); + expect(JSON.parse(JSON.stringify(sample.raw))).toEqual(sample.raw); + }); + + it.each(['fresh', 'live', 'settled'] as const)('lineage пересчитывает generic clock и setup/frame координаты: %s', async (lifecycle) => { + for (const channels of [1, 7]) { + let counter = 0n; + const sample = await runTransformLifecycleSample({ animate, count: 1, lifecycle, channels, nowNs: () => ++counter }); + const replay = validateTransformLifecycleSample(sample, { count: 1, lifecycle, channels }); + expect(replay.operationNs).toBe(1); + expect(replay.frameNs).toEqual([1, 1, 1, 1, 1, 1]); + expect(replay.cancelDrainNs).toBe(1); + const setupCount = lifecycle === 'fresh' ? 0 : lifecycle === 'live' ? 2 : 3; + expect(replay.traceRuns[0].trace.events).toHaveLength(setupCount + 6); + expect(replay.traceRuns[0].trace.setup).toHaveLength(setupCount); + } + }); + + it('lineage сохраняет весь приобретённый prefix при позднем cancel failure', async () => { + const values: string[] = []; + let counter = 0n; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear('cancel', new Error('Отказ отмены')), count: 1000, lifecycle: 'fresh', channels: 7, + nowNs: () => { counter += 1000n; values.push(counter.toString()); return counter; }, + }).then(() => { throw new Error('Отказ не должен стать замером'); }, (error: any) => error); + expect(failure.raw.clockReads.map((read: { valueNs: string }) => read.valueNs)).toEqual(values); + expect(values).toHaveLength(15); + expect(failure.raw.clockReads[14]).toMatchObject({ metric: 'cancelDrainNs', frame: null, edge: 'before', valueNs: '15000' }); + expect(failure.raw.targetTraces.runs[0]).toMatchObject({ from: 0, count: 1000 }); + expect(failure.raw.targetTraces.runs[0].trace.events).toHaveLength(6); + expect(() => validateTransformLifecycleSample({ ...failure.raw, raw: failure.raw }, { count: 1000, lifecycle: 'fresh', channels: 7 })).toThrow(/отказ/); + }); + + it.each([7, 8])('lineage не придумывает endpoint при отказе часов на попытке %i', async (failedRead) => { + const acquired: string[] = []; + let attempted = 0; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear(), count: 1, lifecycle: 'fresh', channels: 7, + nowNs: () => { if (++attempted === failedRead) throw undefined; const value = BigInt(attempted); acquired.push(value.toString()); return value; }, + }).then(() => { throw new Error('Отказ не должен стать замером'); }, (error: any) => error); + expect(failure.errors).toEqual([undefined]); + expect(failure.raw.clockReads.map((read: { valueNs: string }) => read.valueNs)).toEqual(acquired); + expect(failure.raw.clockReads).toHaveLength(failedRead - 1); + expect(failure.raw.targetTraces.runs[0].trace.events).toHaveLength(failedRead === 7 ? 2 : 3); + }); + + it('lineage сохраняет повторные и внешние записи CSS без потери overwritten значения', async () => { + const linear = independentFreshLinear(); + let counter = 0n; + const failure = await runTransformLifecycleSample({ + count: 1, lifecycle: 'fresh', channels: 7, nowNs: () => ++counter, + animate: (targets: Parameters[0], props: AnimateProps, options: AnimateOptions) => { + if (typeof targets === 'string' || !('length' in targets)) throw new Error('Нужен список целей'); + const style = targets[0]!.style; + const write = style.setProperty.bind(style); + let writes = 0; + style.setProperty = (property, value) => { if (++writes === 3) write(property, 'translateX(999px)'); write(property, value); }; + const controls = linear(targets, props, options); + let cancels = 0; + return { ...controls, cancel() { controls.cancel(); if (++cancels === 2) write('transform', 'translateX(888px)'); } }; + }, + }).then(() => { throw new Error('Отказ не должен стать замером'); }, (error: any) => error); + const trace = failure.raw.targetTraces.runs[0].trace; + expect(trace.writes).toEqual([1, 1, 2, 1, 1, 1]); + expect(trace.outsideWrites).toBe(1); + expect(trace.events).toHaveLength(8); + expect(trace.events[2]).toMatchObject({ phase: 'frames', index: 2, value: 'translateX(999px)', timestampMs: 1000032 }); + expect(trace.events[3]).toMatchObject({ phase: 'frames', index: 2, value: expect.stringContaining('translate(64px, 40px)') }); + expect(trace.events[7]).toMatchObject({ phase: 'outside', index: null, step: null, timestampMs: null, value: 'translateX(888px)' }); + }); + + it.each(['endpoint', 'clock-order', 'missing-clock', 'missing-target', 'RLE-count', 'RLE-from', 'RLE-hash-only', 'missing-event', 'event-order', 'event-time', 'coordinates-and-hash'] as const)( + 'lineage отвергает согласованное по labels повреждение: %s', async (fault) => { + let counter = 0n; + const original = await runTransformLifecycleSample({ animate: independentFreshLinear(), count: 100, lifecycle: 'fresh', channels: 7, nowNs: () => counter += 1000n }); + expect(() => validateTransformLifecycleSample(original, { count: 100, lifecycle: 'fresh', channels: 7 })).not.toThrow(); + const mutant = JSON.parse(JSON.stringify(original)); + const trace = mutant.raw.targetTraces.runs[0].trace; + if (fault === 'endpoint') mutant.raw.clockReads[1].valueNs = '2001'; + if (fault === 'clock-order') [mutant.raw.clockReads[2], mutant.raw.clockReads[3]] = [mutant.raw.clockReads[3], mutant.raw.clockReads[2]]; + if (fault === 'missing-clock') mutant.raw.clockReads.splice(4, 1); + if (fault === 'missing-target') mutant.raw.targetTraces.runs = []; + if (fault === 'RLE-count') mutant.raw.targetTraces.runs[0].count = 99; + if (fault === 'RLE-from') mutant.raw.targetTraces.runs[0].from = 1; + if (fault === 'RLE-hash-only') mutant.raw.targetTraces.runs[0].trace = { hash: original.semantic.targetTraceHashes[0] }; + if (fault === 'missing-event') delete trace.events[2]; + if (fault === 'event-order') [trace.events[2], trace.events[3]] = [trace.events[3], trace.events[2]]; + if (fault === 'event-time') trace.events[2].timestampMs++; + if (fault === 'coordinates-and-hash') { + trace.values[2] = 'translateX(999px)'; + trace.events[2].value = trace.values[2]; + const hash = createHash('sha256').update(JSON.stringify(trace.values)).digest('hex'); + mutant.semantic.targetTraceHashes.fill(hash); + } + expect(() => validateTransformLifecycleSample(mutant, { count: 100, lifecycle: 'fresh', channels: 7 })).toThrow(/transform/); + }, + ); + + it('lineage связывает external case и повторённые hash identities с полным CSS', async () => { + const sample = await runTransformLifecycleSample({ animate: independentFreshLinear(), count: 100, lifecycle: 'fresh', channels: 7, nowNs: () => 0n }); + sample.semantic.targetTraceHashes = { encoding: 'repeat', count: 100, value: sample.semantic.targetTraceHashes[0] }; + expect(() => validateTransformLifecycleSample(sample, { count: 100, lifecycle: 'fresh', channels: 7 })).not.toThrow(); + expect(() => validateTransformLifecycleSample(sample, { count: 1000, lifecycle: 'fresh', channels: 7 })).toThrow(/case/); + sample.semantic.targetTraceHashes.count = 99; + expect(() => validateTransformLifecycleSample(sample, { count: 100, lifecycle: 'fresh', channels: 7 })).toThrow(/hash RLE/); + }); + + it.each(['уже разобранный CSS другого кадра', 'новый неверный CSS'])('verification context повторно проверяет ожидаемые координаты: %s', async (fault) => { + const sample = await runTransformLifecycleSample({ animate: independentFreshLinear(), count: 100, lifecycle: 'fresh', channels: 7, nowNs: () => 0n }); + const expectedCase = { count: 100, lifecycle: 'fresh', channels: 7 }; + const validate = createTransformLifecycleValidator(); + expect(validate(sample, expectedCase)).toEqual(validateTransformLifecycleSample(sample, expectedCase)); + const mutant = JSON.parse(JSON.stringify(sample)); + const trace = mutant.raw.targetTraces.runs[0].trace; + trace.values[2] = fault === 'уже разобранный CSS другого кадра' ? trace.values[3] : 'translateX(999px)'; + trace.events[2].value = trace.values[2]; + mutant.semantic.targetTraceHashes.fill(createHash('sha256').update(JSON.stringify(trace.values)).digest('hex')); + expect(() => validate(mutant, expectedCase)).toThrow(/transform/); + // Посторонний третий аргумент прежнего callable не может подменить parser. + expect(() => (validateTransformLifecycleSample as (...args: unknown[]) => unknown)(mutant, expectedCase, new Map())).toThrow(/transform/); + expect(validate(sample, expectedCase)).toEqual(validateTransformLifecycleSample(sample, expectedCase)); + }); + + it.each(['oracle', 'cleanup'] as const)('сохраняет все восемь интервалов при позднем отказе %s', async (fault) => { + const reason = Object.freeze(new Error('Ошибка поздней очистки')); + let reads = 0; + const failure = await runTransformLifecycleSample({ + animate: independentFreshLinear(fault, reason), count: 100, lifecycle: 'fresh', channels: 7, + nowNs: () => BigInt(++reads) * 1000n, + }).then(() => { throw new Error('Отказ не должен стать замером'); }, (error: unknown) => error); + expect(failure).toBeInstanceOf(AggregateError); + const retained = failure as FailedTransformSample; + expect(reads).toBe(16); + expect(retained.raw).toMatchObject({ + operationNs: 1000, frameNs: [1000, 1000, 1000, 1000, 1000, 1000], cancelDrainNs: 1000, + failurePhase: fault, unfinishedInterval: null, + semantic: { valid: false, targets: 100, finished: 'fulfilled', pending: 0 }, + }); + if (fault === 'oracle') { + expect(retained.errors).toHaveLength(1); + expect(retained.errors[0].message).toMatch(/target 99 frame 2/); + expect(retained.raw.semantic.targetTraces[99].values[2]).toBe('translateX(999px)'); + } else { + expect(retained.errors).toEqual([reason]); + } + expect(JSON.parse(JSON.stringify(retained.raw))).toEqual(retained.raw); + }); + it('retains the primary and both live cancellation failures while draining and resolving finished', async () => { const primary = new Error('measurement clock'); const successorError = new Error('successor cancel'); @@ -427,6 +780,10 @@ describe('paired public transform lifecycle screening', () => { } catch (error) { expect(error).toBeInstanceOf(AggregateError); expect((error as AggregateError).errors).toEqual([primary, successorError, donorError]); + expect((error as FailedTransformSample).raw).toMatchObject({ + operationNs: null, frameNs: [], cancelDrainNs: null, + semantic: { valid: false, finished: 'fulfilled', previousFinished: 'fulfilled', pending: 0 }, + }); } expect(cancelled).toEqual(['successor', 'donor']); expect(cleanupDrains).toBeGreaterThan(0); @@ -451,6 +808,10 @@ describe('paired public transform lifecycle screening', () => { } catch (error) { expect(error).toBeInstanceOf(AggregateError); expect((error as AggregateError).errors).toEqual([reason]); + expect((error as FailedTransformSample).raw).toMatchObject({ + frameNs: [], cancelDrainNs: null, + semantic: role === 'donor' ? { valid: false, previousFinished: 'rejected' } : { valid: false, finished: 'rejected' }, + }); } }); @@ -482,6 +843,11 @@ describe('paired public transform lifecycle screening', () => { } catch (error) { expect(error).toBeInstanceOf(AggregateError); expect((error as AggregateError).errors).toEqual([undefined, successorError, donorError, undefined]); + expect((error as FailedTransformSample).raw).toMatchObject({ + operationNs: null, frameNs: [], cancelDrainNs: null, + unfinishedInterval: { metric: 'operationNs', beforeNs: '0', afterNs: null }, + semantic: { valid: false, finished: 'rejected', previousFinished: 'fulfilled', pending: 0 }, + }); } expect(cancelled).toEqual(['successor', 'donor']); }); diff --git a/test/benchmark-methodology.test.ts b/test/benchmark-methodology.test.ts index 0b9176d98..7361d681d 100644 --- a/test/benchmark-methodology.test.ts +++ b/test/benchmark-methodology.test.ts @@ -377,7 +377,7 @@ describe('benchmark methodology fail-closed contracts', () => { const callStartedAtMs = Array.from({ length: calls }, () => 0); const checkpointTimes = config.staggerGapMs > 0 ? [0.2, 0.5, 0.8].map((fraction) => config.staggerGapMs * (config.targetsPerCall - 1) * fraction) - : [config.durationMs * 0.25]; + : [config.durationMs * 0.25, config.durationMs * 0.5, config.durationMs * 0.625]; const checkpoints = checkpointTimes.map((elapsedMs) => ({ groups: Array.from({ length: calls }, () => ({ readStartedMs: elapsedMs, @@ -472,6 +472,38 @@ describe('benchmark methodology fail-closed contracts', () => { })).toThrow(/anime\.s3 run 1.*semantic/i); }); + it.each([ + { name: '128мс и завершённый последний кадр', times: [32, 64, 140], positions: [75, 150, 300], width: 0.1, duration: 128, expected: true }, + { name: '128мс и неразрешающие окна чтения', times: [32, 64, 80], positions: [75, 150, 187.5], width: 20, duration: 128, expected: false }, + { name: '256мс и неразрешающие 32мс окна', times: [88, 136, 184], positions: [103.125, 159.375, 215.625], width: 32, duration: 256, expected: false }, + { name: '256мс и разрешающие узкие окна', times: [88, 136, 184], positions: [103.125, 159.375, 215.625], width: 0.1, duration: 256, expected: true }, + { name: 'только завершённые позиции', times: [140, 156, 172], positions: [300, 300, 300], width: 0.1, duration: 128, expected: false }, + ])('temporal oracle: $name', ({ times, positions, width, duration, expected: accepted }) => { + const config = { ...START_SCENARIO_MANIFEST.s2, targetsPerCall: 3, durationMs: duration }; + // Векторы заданы независимо; ширина окна меняется при том же законе движения. + const evidence = { topology: { calls: 1, targetsPerCall: 3, staggerGapMs: 0, durationMs: duration, toPx: 300 }, + callStartedAtMs: [0], checkpoints: times.map((time, index) => ({ frameTimestampMs: time, + groups: [{ readStartedMs: time, readEndedMs: time + width, + positions: Array(3).fill(positions[index]) }] })), + terminal: [[300, 300, 300]] }; + expect(config.durationMs).toBe(duration); + expect(evidence.topology.durationMs).toBe(duration); + expect(positions).toEqual(times.map((time) => 300 * Math.min(1, time / duration))); + expect(evaluateStartSemanticEvidence(evidence, config, 1)).toBe(accepted); + expect(evaluateStartSemanticEvidence(evidence, { ...config, durationMs: duration === 128 ? 256 : 128 }, 1)).toBe(false); + }); + + it.each([0, 75])('fresh0→300 связывает фазу с API start, offset=%s', (offset) => { + const config = { ...START_SCENARIO_MANIFEST.s2, targetsPerCall: 3, durationMs: 128, fromPx: 0, requireFreshStart: true }; + const evidence = { topology: { calls: 1, targetsPerCall: 3, staggerGapMs: 0, durationMs: 128, toPx: 300 }, + callStartedAtMs: [0], onset: { before: [{ readStartedMs: 0, readEndedMs: 0, positions: [0, 0, 0] }], + after: [{ readStartedMs: 0.025, readEndedMs: 0.05, positions: [offset, offset, offset] }] }, + checkpoints: [32, 64, 80].map((time) => ({ frameTimestampMs: time, + groups: [{ readStartedMs: time, readEndedMs: time + 0.1, positions: Array(3).fill(Math.min(300, offset + 300 * time / 128)) }] })), + terminal: [[300, 300, 300]] }; + expect(evaluateStartSemanticEvidence(evidence, config, 1)).toBe(offset === 0); + }); + it('bootstraps paired independent run clusters reproducibly without flattening rounds', () => { const clusters = (base: number) => Array.from({ length: 12 }, (_, run) => ({ run, diff --git a/test/benchmark-report-contract.test.ts b/test/benchmark-report-contract.test.ts index a9af4c5e4..24a4bfddf 100644 --- a/test/benchmark-report-contract.test.ts +++ b/test/benchmark-report-contract.test.ts @@ -73,7 +73,7 @@ function semanticEvidence(scenario: keyof typeof START_SCENARIO_MANIFEST, calls: const config = START_SCENARIO_MANIFEST[scenario]; const checkpointTimes = config.staggerGapMs > 0 ? [0.2, 0.5, 0.8].map((fraction) => config.staggerGapMs * (config.targetsPerCall - 1) * fraction) - : [config.durationMs * 0.25]; + : [0.25, 0.5, 0.625].map((fraction) => config.durationMs * fraction); const evidence: any = { topology: { calls, @@ -84,6 +84,7 @@ function semanticEvidence(scenario: keyof typeof START_SCENARIO_MANIFEST, calls: }, callStartedAtMs: Array.from({ length: calls }, () => 0), checkpoints: checkpointTimes.map((elapsedMs) => ({ + frameTimestampMs: elapsedMs, groups: Array.from({ length: calls }, () => ({ readStartedMs: elapsedMs, readEndedMs: elapsedMs, @@ -485,20 +486,26 @@ function freeze25To65(): MotionPoint[] { } describe('schema 10 motion conformance admission', () => { - it('публикация требует качества и не позволяет ослабить требования вызывающему', () => { - const report = motionFixture(); - expect(() => validateBenchmarkReportForPublication(report)).not.toThrow(); + it('публикация принимает отчёт с обязательным качеством движения', () => { + expect(() => validateBenchmarkReportForPublication(motionFixture())).not.toThrow(); + }); + + it('публикация требует motion conformance', () => { expect(() => validateBenchmarkReportForPublication(fixture())).toThrow(/motion conformance/); - report.payload.results['motion-mini'].raw.freeze[0].evidence.blocked = freeze25To65(); - refreshMotionReport(report); - expect(() => validateBenchmarkReportPair(report)).not.toThrow(); - expect(() => validateBenchmarkReportForPublication({ ...report, motionRequirements: undefined })) - .toThrow(/motion-mini\.blocked = fail/); - expect(() => validateBenchmarkReportForPublication({ - ...report, motionRequirements: { baseline: ['lab'], blocked: [] }, - })).toThrow(/motion-mini\.blocked = fail/); }); + it.each([undefined, { baseline: ['lab'], blocked: [] }])( + 'публикация не позволяет ослабить требования вызывающему (%j)', + (motionRequirements) => { + const report = motionFixture(); + report.payload.results['motion-mini'].raw.freeze[0].evidence.blocked = freeze25To65(); + refreshMotionReport(report); + expect(() => validateBenchmarkReportPair(report)).not.toThrow(); + expect(() => validateBenchmarkReportForPublication({ ...report, motionRequirements })) + .toThrow(/motion-mini\.blocked = fail/); + }, + ); + it('CI и release reader используют обязательный допуск публикации', () => { const reader = readFileSync('scripts/check-docs-facts.mjs', 'utf8'); expect(reader).toContain('validateBenchmarkReportForPublication({ stem, markdown, payload, rootPackage, benchmarkPackage })'); @@ -815,9 +822,8 @@ describe('paired comparative benchmark report', () => { })).toThrow(/motion conformance/i); }); - it('accepts a clean paired report whose summaries and freeze evidence recompute', () => { - expect(() => validateBenchmarkReportPair(fixture())).not.toThrow(); - expect(() => validateBenchmarkReportPair(fixture(40))).not.toThrow(); + it.each([20, 40])('accepts a clean paired report whose summaries and freeze evidence recompute (%i runs)', (startRuns) => { + expect(() => validateBenchmarkReportPair(fixture(startRuns))).not.toThrow(); }); it('rejects a fully self-consistent report when any start topology is unproved', () => { diff --git a/test/ci-workflow-contract.test.ts b/test/ci-workflow-contract.test.ts index 8a3467ede..f2dfd2cb1 100644 --- a/test/ci-workflow-contract.test.ts +++ b/test/ci-workflow-contract.test.ts @@ -96,6 +96,7 @@ const testCommands = [ 'pnpm build', vitestCommand, 'pnpm vitest run --reporter=verbose test/*finiteness-fuzz.test.ts', + 'node test/fixtures/server-thread-cpu-clock-check.mjs', ]; const mutationCommands = [ activatePnpm, @@ -237,6 +238,14 @@ const requiredActions = { "if-no-files-found": "error", "retention-days": 7 } + }, + { + "index": 8, + "name": "Setup registered native-clock Node", + "uses": "actions/setup-node@820762786026740c76f36085b0efc47a31fe5020", + "with": { + "node-version": "24.19.0" + } } ], "mutation": [ @@ -283,9 +292,20 @@ function assertNativeGraph(files: Map) { expect(files.has('ci-gate.yml')).toBe(false); const ci = workflows.get('ci.yml')!; const browser = workflows.get('browser.yml')!; - expect(ci.on).toEqual({ push: { branches: ['main'] }, pull_request: null, merge_group: null, workflow_dispatch: null }); + expect(ci.on).toEqual({ + push: { branches: ['main'] }, pull_request: null, merge_group: null, + workflow_dispatch: { inputs: { profile_baseline: { + description: 'Снять зарегистрированный размерный baseline PROFILE-01', + type: 'boolean', default: false, + } } }, + }); expect(browser.on).toEqual({ workflow_call: null }); - expect(Object.keys(ci.jobs).sort()).toEqual(['CI', 'browser-static', 'mutation', 'node-floor', 'tests', 'verify']); + expect(Object.keys(ci.jobs).sort()).toEqual(['CI', 'browser-static', 'mutation', 'node-floor', 'profile-baseline', 'tests', 'verify']); + expect(ci.jobs['profile-baseline']).toEqual({ + if: "${{ github.event_name == 'workflow_dispatch' && inputs.profile_baseline }}", + uses: './.github/workflows/profile-01.yml', + }); + expect(workflows.get('profile-01.yml')!.on).toEqual({ workflow_call: null }); expect(Object.keys(browser.jobs)).toEqual(['conformance']); for (const document of [ci, browser]) { expect(document.permissions).toEqual({ contents: 'read' }); @@ -394,6 +414,11 @@ describe('нативный граф CI', () => { ['пустой успех', 'ci.yml', (w: Workflow) => { w.jobs.CI!.steps![0]!.run = 'true\n'; }], ['игнорирование итога', 'ci.yml', (w: Workflow) => { w.jobs.CI!['continue-on-error'] = true; }], ['добавлен trigger browser', 'browser.yml', (w: Workflow) => { w.on.pull_request = null; }], + ['добавлен PR trigger PROFILE', 'profile-01.yml', (w: Workflow) => { w.on.pull_request = null; }], + ['PROFILE запущен для обычного кандидата', 'ci.yml', (w: Workflow) => { delete w.jobs['profile-baseline']!.if; }], + ['PROFILE без явного запроса', 'ci.yml', (w: Workflow) => { + w.jobs['profile-baseline']!.if = "${{ github.event_name == 'workflow_dispatch' }}"; + }], ['нет workflow_call', 'browser.yml', (w: Workflow) => { w.on = { workflow_dispatch: null }; }], ...['chromium', 'firefox', 'webkit'].map((engine) => [`нет ${engine}`, 'browser.yml', (w: Workflow) => { const matrix = w.jobs.conformance!.strategy!.matrix; @@ -494,24 +519,22 @@ describe('нативный граф CI', () => { } }); - it('shell итога требует success каждого dependency', () => { + it.each(['VERIFY_RESULT', 'TESTS_RESULT', 'MUTATION_RESULT', 'NODE_FLOOR_RESULT', 'BROWSER_RESULT'] + .flatMap((key) => ['success', 'failure', 'cancelled', 'skipped', 'neutral', 'pending', '', undefined] + .map((result) => ({ key, result }))))('shell итога проверяет $key=$result', ({ key, result }) => { const ci = parse(sources().get('ci.yml')!) as Workflow; const program = ci.jobs.CI!.steps![0]!.run!; - for (const key of ['VERIFY_RESULT', 'TESTS_RESULT', 'MUTATION_RESULT', 'NODE_FLOOR_RESULT', 'BROWSER_RESULT']) { - for (const result of ['success', 'failure', 'cancelled', 'skipped', 'neutral', 'pending', '', undefined]) { - const env: NodeJS.ProcessEnv = { - ...process.env, VERIFY_RESULT: 'success', TESTS_RESULT: 'success', - MUTATION_RESULT: 'success', NODE_FLOOR_RESULT: 'success', BROWSER_RESULT: 'success', - }; - delete env[key]; - if (result !== undefined) env[key] = result; - const actual = spawnSync(bash, ['--noprofile', '--norc', '-e', '-o', 'pipefail', '-c', program], { - env, encoding: 'utf8', timeout: 5000, - }); - expect(actual.error).toBeUndefined(); - expect(actual.status === 0, `${key}=${result}: ${actual.stderr}`).toBe(result === 'success'); - } - } + const env: NodeJS.ProcessEnv = { + ...process.env, VERIFY_RESULT: 'success', TESTS_RESULT: 'success', + MUTATION_RESULT: 'success', NODE_FLOOR_RESULT: 'success', BROWSER_RESULT: 'success', + }; + delete env[key]; + if (result !== undefined) env[key] = result; + const actual = spawnSync(bash, ['--noprofile', '--norc', '-e', '-o', 'pipefail', '-c', program], { + env, encoding: 'utf8', timeout: 5000, + }); + expect(actual.error).toBeUndefined(); + expect(actual.status === 0, `${key}=${result}: ${actual.stderr}`).toBe(result === 'success'); }); it('shell Vitest сохраняет код отказа после tee для diagnostics', () => { @@ -532,4 +555,4 @@ describe('нативный граф CI', () => { rmSync(cwd, { recursive: true, force: true }); } }); -}); \ No newline at end of file +}); diff --git a/test/compositor-follow-package.test.ts b/test/compositor-follow-package.test.ts new file mode 100644 index 000000000..304ec5d5a --- /dev/null +++ b/test/compositor-follow-package.test.ts @@ -0,0 +1,37 @@ +import { readFileSync } from 'node:fs'; +import { describe, expect, it } from 'vitest'; +import * as follow from '../src/compositor/follow/index.js'; +import * as base from '../src/compositor/index.js'; +import * as stagger from '../src/compositor/stagger/index.js'; +import { BESPOKE_SUBPATH_GATES, COMPOSITOR_FOLLOW_GATE_BYTES, IMPORT_COST_SCENARIOS } from '../scripts/size-gate.mjs'; +import { entriesFromPackageExports } from '../tsup.config.js'; + +const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')); + +describe('compositor/follow: граница новой capability', () => { + it('не расширяет старые barrels и не публикует internal subclass', () => { + expect(Object.keys(follow).sort()).toEqual(['compileSpringPlan', 'createCompositorFollow']); + expect('createCompositorFollow' in base).toBe(false); + expect('createCompositorFollow' in stagger).toBe(false); + expect('beginFollow' in base.CompositorSpring.prototype).toBe(false); + }); + + it('поставляет ESM/CJS и отдельные declarations через официальный build entry', () => { + expect(pkg.exports['./compositor/follow']).toEqual({ + import: { types: './dist/compositor/follow/index.d.ts', default: './dist/compositor/follow/index.js' }, + require: { types: './dist/compositor/follow/index.d.cts', default: './dist/compositor/follow/index.cjs' }, + }); + expect(entriesFromPackageExports()['compositor/follow/index']).toBe('src/compositor/follow/index.ts'); + }); + + it('новый admission не ослабляет старые native ceilings', () => { + expect(BESPOKE_SUBPATH_GATES['./compositor']).toBe(6450); + expect(BESPOKE_SUBPATH_GATES['./compositor/stagger']).toBe(6450); + expect(COMPOSITOR_FOLLOW_GATE_BYTES).toBe(6450 + 1024); + expect(BESPOKE_SUBPATH_GATES['./compositor/follow']).toBe(COMPOSITOR_FOLLOW_GATE_BYTES); + const scenario = IMPORT_COST_SCENARIOS.find(({ name }) => name === 'compositor-follow capability'); + expect(scenario?.gate).toBe(COMPOSITOR_FOLLOW_GATE_BYTES); + expect(scenario?.code).toContain('createCompositorFollow'); + expect(scenario?.code).toContain('compileSpringPlan'); + }); +}); diff --git a/test/compositor-follow-recipes.test.ts b/test/compositor-follow-recipes.test.ts new file mode 100644 index 000000000..6c5bf9d38 --- /dev/null +++ b/test/compositor-follow-recipes.test.ts @@ -0,0 +1,56 @@ +import { describe, expect, it, onTestFinished } from 'vitest'; +import { createHash } from 'node:crypto'; +import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { buildCompositorFollowRecipes, compositorFollowRecipes } from '../browser/fixtures/compositor-follow-recipes.mjs'; + +function fixture() { + const consumer = mkdtempSync(join(tmpdir(), 'motion-recipe-test-')); + onTestFinished(() => rmSync(consumer, { recursive: true, force: true })); + const installed = join(consumer, 'node_modules/@labpics/motion'); + const out = join(consumer, 'out'); + mkdirSync(join(installed, 'docs'), { recursive: true }); + mkdirSync(out); + writeFileSync(join(installed, 'package.json'), JSON.stringify({ + name: '@labpics/motion', type: 'module', exports: { './compositor/follow': './follow.js' }, + })); + const recipe = "export { marker, load } from '@labpics/motion/compositor/follow';"; + const docs = '\n' + + '```typescript\n' + recipe + '\n```\n\n'; + writeFileSync(join(installed, 'docs/recipes.md'), docs.replaceAll('\n', '\r\n')); + writeFileSync(join(installed, 'follow.js'), + "export const marker = 'shipped-marker'; export const load = () => import('./lazy.js');"); + writeFileSync(join(installed, 'lazy.js'), "export const value = 'shipped-lazy';"); + mkdirSync(join(consumer, 'docs')); + writeFileSync(join(consumer, 'docs/recipes.md'), docs.replace(recipe, "export const marker = 'checkout-marker';")); + return { consumer, installed, out, recipe }; +} + +describe('shipped compositor recipes', () => { + it('reads installed CRLF docs and measures the emitted initial and lazy bytes', async () => { + const { consumer, installed, out, recipe } = fixture(); + expect(compositorFollowRecipes(installed)).toBe(recipe); + const receipt = await buildCompositorFollowRecipes(installed, out, consumer); + const initial = readFileSync(join(out, 'compositor-follow-recipes.js'), 'utf8'); + expect(initial).toContain('shipped-marker'); + expect(initial).not.toContain('checkout-marker'); + expect(receipt.packageInputs).toEqual(['follow.js', 'lazy.js']); + expect(receipt.measurement.initialFiles).toBe(1); + expect(receipt.measurement.lazyFiles).toBe(1); + expect(receipt.measurement.totalGzBytes).toBeGreaterThan(receipt.measurement.gzBytes); + for (const output of receipt.outputs) { + const bytes = readFileSync(join(out, output.file)); + expect(createHash('sha256').update(bytes).digest('hex')).toBe(output.sha256); + } + }); + + it('rejects a resolver that includes source outside the installed package', async () => { + const { consumer, installed, out } = fixture(); + writeFileSync(join(consumer, 'escaped.js'), "export const marker = 'checkout-marker';"); + writeFileSync(join(installed, 'follow.js'), + "export { marker } from '../../../escaped.js'; export const load = () => 0;"); + await expect(buildCompositorFollowRecipes(installed, out, consumer)) + .rejects.toThrow('recipe dependency escaped installed package'); + }); +}); diff --git a/test/compositor-follow.test.ts b/test/compositor-follow.test.ts new file mode 100644 index 000000000..6017cc839 --- /dev/null +++ b/test/compositor-follow.test.ts @@ -0,0 +1,384 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { createCompositorFollow, compileSpringPlan } from '../src/compositor/follow/index.js'; +import { __resetDetectionCache } from '../src/compositor/detect.js'; +import { MotionParamError } from '../src/errors.js'; + +const SPRING = { mass: 1, stiffness: 170, damping: 26 }; + +function fixture(withWriter = true, reduced = false) { + const hooks: { + format?: (value: number) => string | number; + write?: (value: string | number) => void; + cancel?: () => void; + animate?: () => void; + } = {}; + const frames: Array<(timestamp?: number) => void> = []; + const writes: Array = []; + const animations: Array<{ + currentTime: number; + cancel: ReturnType; + timing: { easing: string; duration: number }; + }> = []; + const target = { + animate(_keyframes: unknown, timing: object) { + const animation = { + currentTime: 16, + cancel: vi.fn(() => hooks.cancel?.()), + timing: timing as { easing: string; duration: number }, + }; + animations.push(animation); + hooks.animate?.(); + return animation; + }, + }; + const owner = createCompositorFollow({ + spring: SPRING, property: 'opacity', from: 0, to: 100, target, + apply: withWriter ? (value) => { writes.push(value); hooks.write?.(value); } : undefined, + format: (value) => hooks.format?.(value) ?? value, + now: () => 0, + requestFrame(callback) { frames.push(callback); return frames.length; }, + matchMedia: () => ({ matches: reduced }), + }); + return { owner, frames, writes, animations, hooks }; +} + +function plan(from: number, to: number, velocity: number) { + return compileSpringPlan({ + spring: SPRING, property: 'opacity', from, to, + v0: velocity / (to - from), + }); +} + +beforeEach(() => { + vi.stubGlobal('CSS', { supports: () => true }); + vi.stubGlobal('navigator', { vendor: '', userAgent: 'Chromium' }); + __resetDetectionCache(); +}); +afterEach(() => { vi.unstubAllGlobals(); __resetDetectionCache(); }); + +describe('универсальный follow → native settle → pickup', () => { + it('повторяет цикл у одного owner без live-кадра на pickup или release', () => { + const f = fixture(); + f.owner.start(); + const first = f.animations[0]!; + const value = f.owner.beginFollow(10); + expect(value).toBeGreaterThan(0); + expect(value).toBeLessThan(100); + expect(f.writes.at(-1)).toBe(value); + expect(first.cancel).toHaveBeenCalledTimes(1); + expect(f.frames).toHaveLength(0); + + f.owner.follow(value + 40, 10.02); + f.owner.settle(200, 10.02); + expect(f.animations).toHaveLength(2); + expect(f.frames).toHaveLength(0); + const next = f.owner.beginFollow(10.1); + expect(f.animations[1]!.cancel).toHaveBeenCalledTimes(1); + f.owner.follow(next + 15, 10.12); + f.owner.settle(300, 10.12); + expect(f.animations).toHaveLength(3); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + expect(f.animations[2]!.cancel).toHaveBeenCalledTimes(1); + }); + + it('обычное движение переносит скорость из input timestamps в native план', () => { + const f = fixture(); + expect(f.owner.beginFollow(1)).toBe(0); + f.owner.follow(20, 1.02); + f.owner.settle(100, 1.02); + const expected = plan(20, 100, 20 / (1.02 - 1)); + expect(f.animations[0]!.timing.easing).toBe(expected.easing); + expect(f.animations[0]!.timing.duration).toBe(expected.duration); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + }); + + it('различает немедленный re-release и неподвижное удержание с продвижением времени', () => { + const instant = fixture(); + instant.owner.start(); + const first = instant.owner.beginFollow(5); + instant.owner.settle(200, 5); + expect(instant.animations[1]!.timing.easing).not.toBe(plan(first, 200, 0).easing); + instant.owner.destroy(); + + const held = fixture(); + held.owner.start(); + const second = held.owner.beginFollow(5); + held.owner.settle(200, 7); + expect(held.animations[1]!.timing.easing).toBe(plan(second, 200, 0).easing); + expect(held.frames).toHaveLength(0); + held.owner.destroy(); + }); + + it('отвергает неверное время, значение и порядок до host effects', () => { + const f = fixture(); + expect(() => f.owner.follow(1, 0)).toThrow(); + f.owner.start(); + const native = f.animations[0]!; + expect(() => f.owner.beginFollow(Number.NaN)).toThrow(); + expect(native.cancel).not.toHaveBeenCalled(); + f.owner.beginFollow(5); + const writes = f.writes.length; + const animations = f.animations.length; + expect(() => f.owner.follow(Number.NaN, 5.1)).toThrow(); + expect(() => f.owner.follow(1, 4.9)).toThrow(); + expect(() => f.owner.settle(100, Number.POSITIVE_INFINITY)).toThrow(); + expect(() => f.owner.settle(100, 4.9)).toThrow(); + expect(f.writes).toHaveLength(writes); + expect(f.animations).toHaveLength(animations); + expect(f.frames).toHaveLength(0); + f.owner.follow(10, 5.1); + f.owner.settle(100, 5.1); + expect(f.animations).toHaveLength(animations + 1); + f.owner.destroy(); + }); + + it('проверяет writer до отмены действующего native owner', () => { + const f = fixture(false); + f.owner.start(); + expect(() => f.owner.beginFollow(1)).toThrow(MotionParamError); + expect(f.animations[0]!.cancel).not.toHaveBeenCalled(); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + }); + + it('сохраняет прямой ввод при reduced motion, а settle завершает без анимации', () => { + const f = fixture(true, true); + f.owner.beginFollow(0); + f.owner.follow(20, 0.05); + expect(f.writes.at(-1)).toBe(20); + f.owner.settle(100, 0.05); + expect(f.writes.at(-1)).toBe(100); + expect(f.animations).toHaveLength(0); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + }); + + it('same-time sample заменяет предыдущую точку, а последующее движение остаётся разрешено', () => { + const f = fixture(); + f.owner.beginFollow(1); + f.owner.follow(10, 1); + f.owner.follow(20, 1.02); + f.owner.settle(100, 1.02); + expect(f.animations[0]!.timing.easing).toBe(plan(20, 100, 10 / (1.02 - 1)).easing); + f.owner.destroy(); + }); + + it('немедленный pickup сохраняет скорость при большом конечном origin input clock', () => { + const control = fixture(); + control.owner.start(); + const live = control.owner.handoffToLive(); + const value = live.value; + const velocity = live.velocity; + expect(velocity).toBeGreaterThan(0); + control.owner.destroy(); + + const f = fixture(); + f.owner.start(); + expect(f.owner.beginFollow(1e16)).toBe(value); + f.owner.settle(200, 1e16); + expect(f.animations[1]!.timing.easing).toBe(plan(value, 200, velocity).easing); + f.owner.destroy(); + }); + + it('stop отзывает сессию, destroy остаётся terminal, последующий begin после stop разрешён', () => { + const f = fixture(); + f.owner.beginFollow(1); + f.owner.follow(20, 1.02); + f.owner.stop(); + expect(() => f.owner.settle(100, 1.03)).toThrow(MotionParamError); + expect(() => f.owner.follow(30, 1.03)).toThrow(MotionParamError); + expect(f.owner.beginFollow(2)).toBe(20); + f.owner.settle(100, 2); + expect(() => f.owner.settle(200, 2)).toThrow(MotionParamError); + f.owner.destroy(); + const writes = f.writes.length; + f.owner.beginFollow(3); + f.owner.follow(0, 4); + f.owner.settle(100, 4); + f.owner.start(); + expect(f.animations).toHaveLength(1); + expect(f.writes).toHaveLength(writes); + }); + + it.each(['format', 'write'] as const)('ошибка pickup в %s сохраняет native donor и первичную ошибку', (hook) => { + const f = fixture(); + f.owner.start(); + const failure = new Error('pickup failed'); + f.hooks[hook] = () => { throw failure; }; + expect(() => f.owner.beginFollow(1)).toThrow(failure); + expect(f.animations[0]!.cancel).not.toHaveBeenCalled(); + f.hooks[hook] = undefined; + f.owner.retarget(200); + expect(f.animations).toHaveLength(2); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + f.owner.destroy(); + }); + + it.each([['format', false], ['format', true], ['write', false], ['write', true]] as const)( + 'reentrant follow из %s снимает donor; ошибка outer callback: %s', (hook, throws) => { + const f = fixture(); + f.owner.start(); + const failure = new Error('outer callback failed'); + f.hooks[hook] = (value) => { + f.hooks[hook] = undefined; + f.owner.follow(20, 1.01); + if (throws) throw failure; + return value; + }; + if (throws) expect(() => f.owner.beginFollow(1)).toThrow(failure); + else expect(f.owner.beginFollow(1)).toBe(20); + expect(f.owner.value).toBe(20); + expect(f.writes.at(-1)).toBe(20); + expect(f.animations).toHaveLength(1); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + expect(f.frames).toHaveLength(0); + f.owner.follow(30, 1.02); + expect(f.writes.at(-1)).toBe(30); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + f.owner.destroy(); + }, + ); + + it.each(['format', 'write'] as const)('пойманная inner-ошибка в %s снимает donor только после состоявшейся записи', (hook) => { + const f = fixture(); + f.owner.start(); + const failure = new Error('nested format failed'); + let caught: unknown; + f.hooks[hook] = (value) => { + f.hooks[hook] = undefined; + f.hooks.format = () => { throw failure; }; + try { f.owner.follow(20, 1.01); } catch (error) { caught = error; } + f.hooks.format = undefined; + return value; + }; + f.owner.beginFollow(1); + expect(caught).toBe(failure); + const writes = hook === 'write' ? 1 : 0; + expect(f.writes).toHaveLength(writes); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(writes); + f.owner.follow(30, 1.02); + expect(f.writes.at(-1)).toBe(30); + expect(f.animations).toHaveLength(1); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + }); + + it('reentrant settle внутри pickup write оставляет новый native owner', () => { + const f = fixture(); + f.owner.start(); + f.hooks.write = () => { + f.hooks.write = undefined; + f.owner.settle(200, 1); + }; + f.owner.beginFollow(1); + expect(f.animations).toHaveLength(2); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + expect(f.animations[1]!.cancel).not.toHaveBeenCalled(); + expect(f.frames).toHaveLength(0); + f.owner.destroy(); + }); + + it.each(['settle', 'retarget', 'handoff', 'stop', 'destroy'] as const)('nested follow сохраняет successor %s', (action) => { + const f = fixture(); + f.owner.start(); + f.hooks.write = () => { + f.hooks.write = () => { + f.hooks.write = undefined; + if (action === 'settle') f.owner.settle(200, 1.01); + else if (action === 'retarget') f.owner.retarget(200); + else if (action === 'handoff') f.owner.handoffToLive(200); + else f.owner[action](); + }; + f.owner.follow(20, 1.01); + }; + f.owner.beginFollow(1); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + const native = action === 'settle' || action === 'retarget'; + expect(f.animations).toHaveLength(native ? 2 : 1); + if (native) expect(f.animations[1]!.cancel).not.toHaveBeenCalled(); + expect(f.frames).toHaveLength(action === 'handoff' ? 1 : 0); + if (action === 'stop') expect(() => f.owner.follow(30, 1.02)).toThrow(MotionParamError); + f.owner.destroy(); + const writes = f.writes.length; + f.owner.follow(30, 1.02); + expect(f.writes).toHaveLength(writes); + }); + + it('destroy во время write не даёт callback восстановить direct или native owner', () => { + const f = fixture(); + f.owner.start(); + f.hooks.write = () => f.owner.destroy(); + f.owner.beginFollow(1); + f.owner.follow(20, 1.02); + f.owner.settle(200, 1.02); + expect(f.animations).toHaveLength(1); + expect(f.animations[0]!.cancel).toHaveBeenCalledTimes(1); + expect(f.frames).toHaveLength(0); + }); + + it('native cleanup не выдаёт повторную mutation capability', () => { + const f = fixture(); + f.owner.start(); + f.hooks.cancel = () => { + f.owner.start(); + f.owner.follow(99, 1); + }; + const value = f.owner.beginFollow(1); + expect(value).not.toBe(99); + expect(f.animations).toHaveLength(1); + f.hooks.cancel = undefined; + f.owner.settle(200, 1); + expect(f.animations).toHaveLength(2); + f.owner.destroy(); + }); + + it('повторный pickup отзывает старые live callbacks и снова допускает native settle', () => { + const f = fixture(); + f.owner.start(); + f.owner.handoffToLive(200); + expect(f.frames).toHaveLength(1); + const value = f.owner.beginFollow(1); + const writes = f.writes.length; + f.frames[0]!(16); + expect(f.writes).toHaveLength(writes); + expect(f.frames).toHaveLength(1); + f.owner.settle(value + 200, 1); + expect(f.animations).toHaveLength(2); + expect(f.frames).toHaveLength(1); + f.owner.destroy(); + }); + + it('live callback уже отозван внутри writer нового direct owner', () => { + const f = fixture(); + f.owner.start(); + f.owner.handoffToLive(200); + const frames = f.frames.length; + const writes = f.writes.length; + f.hooks.write = () => { + f.hooks.write = undefined; + f.frames[0]!(16); + }; + f.owner.beginFollow(1); + expect(f.writes).toHaveLength(writes + 1); + expect(f.frames).toHaveLength(frames); + f.owner.destroy(); + }); + + it('нулевой диапазон с импульсом использует canonical live fallback', () => { + const f = fixture(); + f.owner.beginFollow(1); + f.owner.follow(20, 1.02); + f.owner.settle(20, 1.02); + expect(f.animations).toHaveLength(0); + expect(f.frames).toHaveLength(1); + expect(f.owner.mode).toBe('fallback'); + f.owner.beginFollow(1.02); + f.owner.settle(200, 1.02); + expect(f.animations).toHaveLength(1); + expect(f.owner.mode).toBe('compositor'); + f.owner.destroy(); + }); +}); diff --git a/test/compositor-host-owner.test.ts b/test/compositor-host-owner.test.ts index 0a47b4ded..e4639a768 100644 --- a/test/compositor-host-owner.test.ts +++ b/test/compositor-host-owner.test.ts @@ -743,6 +743,45 @@ describe('CompositorSpring host-owner protocol', () => { spring.handoffToLive().destroy(); }); + it('живой контроллер сохраняет наблюдение исходных spring-параметров', () => { + const params = { ...SPRING }; + const spring = controller({ animate: () => ({ cancel() {} }) }, { spring: params }); + params.mass = 0; + + expect(() => spring.start()).toThrow('LM088'); + spring.destroy(); + }); + + it('terminal cleanup и инертный handoff не читают spring getters', () => { + let closed = false; + let frames = 0; + const params = { + get mass() { + if (closed) throw new Error('terminal spring read'); + return 2; + }, + stiffness: 240, + damping: 30, + }; + const spring = controller({ animate: () => ({ cancel() {} }) }, { + spring: params, + from: 5, + requestFrame: () => ++frames, + }); + closed = true; + + expect(() => spring.destroy()).not.toThrow(); + const inert = spring.handoffToLive(); + expect(inert.value).toBe(5); + expect(inert.velocity).toBe(0); + inert.setTarget(12); + inert.snapTo(9); + expect(inert.value).toBe(5); + expect(inert.velocity).toBe(0); + expect(frames).toBe(0); + expect(() => spring.destroy()).not.toThrow(); + }); + it('restart throw после commit оставляет forward-only live-owner', () => { const queue: Array<(timestamp?: number) => void> = []; let frames = 0; diff --git a/test/compositor-return-to-native.test.ts b/test/compositor-return-to-native.test.ts new file mode 100644 index 000000000..aed267620 --- /dev/null +++ b/test/compositor-return-to-native.test.ts @@ -0,0 +1,366 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { CompositorSpring } from '../src/compositor/index.js'; +import { __resetDetectionCache } from '../src/compositor/detect.js'; +import { MotionParamError } from '../src/errors.js'; + +const SPRING = { mass: 1, stiffness: 170, damping: 26 }; + +function scene(extra: Record = {}) { + const queue: Array<(time?: number) => void> = []; + const effects: Array<{ currentTime: number | null; cancelled: boolean }> = []; + const calls: Array<{ frames: Record[]; timing: Record }> = []; + const seen: Array = []; + let time = 0; + let requests = 0; + const controller = new CompositorSpring({ + spring: SPRING, property: 'opacity', from: 0, to: 100, + target: { animate(frames, timing) { + calls.push({ frames: frames as Record[], timing: timing as Record }); + const effect = { currentTime: null as number | null, cancelled: false, cancel() { this.cancelled = true; } }; + effects.push(effect); + return effect; + } }, + now: () => time, + requestFrame(callback) { requests++; queue.push(callback); return requests; }, + apply(value) { seen.push(value); }, + ...extra, + }); + function step() { + time += 1000 / 60; + for (const callback of queue.splice(0)) callback(time); + } + return { controller, queue, effects, calls, seen, step, requests: () => requests }; +} + +beforeEach(() => { + vi.stubGlobal('CSS', { supports: () => true }); + __resetDetectionCache(); +}); +afterEach(() => { + vi.unstubAllGlobals(); + __resetDetectionCache(); +}); + +describe('CompositorSpring: обратная передача единственного владельца', () => { + it('старый retarget после live остаётся живым: один и тот же endpoint не доказывает native release', () => { + const s = scene(); + const live = s.controller.handoffToLive(80); + s.step(); + const requests = s.requests(); + s.controller.retarget(100); + s.step(); + expect(live.value).toBeGreaterThan(0); + expect(s.controller.mode).toBe('fallback'); + expect(s.calls).toHaveLength(0); + expect(s.requests()).toBeGreaterThan(requests); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it.each([ + ['sheet', 80, 300], + ['pager', -80, -200], + ] as const)('%s: live follow → native release → новый live ввод без второго clock', (_name, pointer, target) => { + const s = scene(); + const live = s.controller.handoffToLive(pointer); + for (let i = 0; i < 4; i++) s.step(); + const value = live.value; + const velocity = live.velocity; + expect(velocity).not.toBe(0); + + s.controller.handoffToCompositor(target); + + expect(s.controller.mode).toBe('compositor'); + expect(s.calls).toHaveLength(1); + expect(s.calls[0]!.frames[0]!.opacity).toBe(value); + expect(s.calls[0]!.frames.at(-1)!.opacity).toBe(target); + expect(s.effects.filter(effect => !effect.cancelled)).toHaveLength(1); + const nativeRequests = s.requests(); + const writes = s.seen.length; + live.setTarget(-1000); + s.step(); + expect(s.requests()).toBe(nativeRequests); + expect(s.seen).toHaveLength(writes); + expect(s.queue).toHaveLength(0); + + // Pending native-time ещё не имеет rendered slope: это исходная пара live. + const picked = s.controller.handoffToLive(pointer / 2); + expect(picked.value).toBe(value); + expect(picked.velocity).toBeCloseTo(velocity, 10); + expect(s.effects[0]!.cancelled).toBe(true); + s.step(); + s.controller.handoffToCompositor(target / 2); + expect(s.calls).toHaveLength(2); + expect(s.effects.filter(effect => !effect.cancelled)).toHaveLength(1); + s.controller.destroy(); + s.step(); + expect(s.effects.every(effect => effect.cancelled)).toBe(true); + expect(s.queue).toHaveLength(0); + }); + + it('host отказ до commit оставляет живого donor и не теряет новый контроль', () => { + let reject = true; + const s = scene({ target: { animate() { + if (reject) throw new Error('successor rejected'); + return { currentTime: null, cancel() {} }; + } } }); + const live = s.controller.handoffToLive(80); + s.step(); + expect(() => s.controller.handoffToCompositor(200)).toThrow('successor rejected'); + expect(s.controller.mode).toBe('fallback'); + const value = live.value; + s.step(); + expect(live.value).toBeGreaterThan(value); + reject = false; + s.controller.handoffToCompositor(200); + expect(s.controller.mode).toBe('compositor'); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it('непредставимый импульс при нулевом span сохраняет того же live-owner', () => { + const s = scene(); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + const from = live.value; + expect(live.velocity).not.toBe(0); + s.controller.handoffToCompositor(from); + expect(s.controller.mode).toBe('fallback'); + expect(s.calls).toHaveLength(0); + s.step(); + expect(live.value).not.toBe(from); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it('отказ cleanup timer-donor после native commit не оставляет живую петлю', () => { + let cancellations = 0; + const s = scene({ delay: 30, setTimer() { return () => { + cancellations++; + throw new Error('timer cleanup failed'); + }; } }); + const live = s.controller.handoffToLive(80); + s.step(); + s.controller.start(); + expect(() => s.controller.handoffToCompositor(200)).not.toThrow(); + expect(cancellations).toBe(1); + expect(s.controller.mode).toBe('compositor'); + expect(s.effects.filter(effect => !effect.cancelled)).toHaveLength(1); + const requests = s.requests(); + live.setTarget(300); + s.step(); + expect(s.requests()).toBe(requests); + expect(s.queue).toHaveLength(0); + s.controller.destroy(); + expect(s.effects.every(effect => effect.cancelled)).toBe(true); + }); + + it.each([false, true])('native commit отзывает live donor до callback его cleanup, throw=%s', throws => { + let s!: ReturnType; + s = scene({ delay: 30, setTimer() { return () => { + s.step(); + if (throws) throw new Error('cleanup after delivered frame'); + }; } }); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + s.controller.start(); + const value = live.value; + const velocity = live.velocity; + expect(velocity).not.toBe(0); + s.controller.handoffToCompositor(200); + expect(s.calls[0]!.frames[0]!.opacity).toBe(value); + const picked = s.controller.handoffToLive(); + expect(picked.value).toBe(value); + expect(picked.velocity).toBeCloseTo(velocity, 10); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it.each([-10, -1, null])('numeric pre-start и pending native time различаются: %s', currentTime => { + const s = scene(); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + const value = live.value; + const velocity = live.velocity; + expect(velocity).not.toBe(0); + s.controller.handoffToCompositor(200); + let reads = 0; + Object.defineProperty(s.effects[0], 'currentTime', { get() { reads++; return currentTime; } }); + const picked = s.controller.handoffToLive(); + expect(reads).toBe(1); + expect(picked.value).toBe(value); + expect(picked.velocity).toBeCloseTo(currentTime === null ? velocity : 0, 10); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it.each([ + 'retarget', 'setTarget', 'snapTo', 'setTarget(value)', 'snapTo(value)', 'setTarget ABA', + ])('%s: новый live intent отзывает возвращающийся native effect', action => { + const cancel = vi.fn(); + let reenter = () => {}; + const s = scene({ target: { animate() { + reenter(); + return { currentTime: null, cancel }; + } } }); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + const from = live.value; + expect(from).not.toBe(0); + expect(live.velocity).not.toBe(0); + const target = action.endsWith('(value)') ? from : action === 'setTarget ABA' ? 80 : 40; + reenter = () => { + if (action === 'retarget') s.controller.retarget(target); + else if (action === 'setTarget ABA') { + live.setTarget(40); + live.setTarget(80); + } else if (action.startsWith('setTarget')) live.setTarget(target); + else live.snapTo(target); + }; + + s.controller.handoffToCompositor(200); + expect(cancel).toHaveBeenCalledTimes(1); + expect(s.controller.mode).toBe('fallback'); + for (let i = 0; i < 200 && s.queue.length; i++) s.step(); + expect(live.value).toBe(target); + expect(s.controller.value).toBe(target); + expect(s.seen.at(-1)).toBe(target); + + live.setTarget(-20); + for (let i = 0; i < 200 && s.queue.length; i++) s.step(); + expect(s.controller.value).toBe(-20); + s.controller.destroy(); + s.step(); + expect(s.queue).toHaveLength(0); + }); + + it.each(['stop', 'destroy'] as const)('%s live donor отзывает ещё не принятый native effect', action => { + const cancel = vi.fn(); + let reenter = () => {}; + const s = scene({ target: { animate() { + reenter(); + return { currentTime: null, cancel }; + } } }); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + const value = live.value; + const writes = s.seen.length; + reenter = () => live[action](); + + s.controller.handoffToCompositor(200); + expect(cancel).toHaveBeenCalledTimes(1); + expect(s.controller.mode).toBe('fallback'); + s.step(); + expect(s.controller.value).toBe(value); + expect(s.seen).toHaveLength(writes); + expect(s.queue).toHaveLength(0); + s.controller.destroy(); + }); + + it.each([ + { method: 'setTarget', resting: false }, + { method: 'setTarget', resting: true }, + { method: 'snapTo', resting: true }, + ] as const)('$method: no-op повтор цели не отменяет native release, resting=$resting', ({ method, resting }) => { + const cancel = vi.fn(); + let reenter = () => {}; + const s = scene({ target: { animate() { + reenter(); + return { currentTime: null, cancel }; + } } }); + const live = s.controller.handoffToLive(80); + for (let i = 0; i < 4; i++) s.step(); + if (resting) live.snapTo(80); + const from = live.value; + reenter = () => live[method](80); + + s.controller.handoffToCompositor(200); + expect(cancel).not.toHaveBeenCalled(); + expect(s.controller.mode).toBe('compositor'); + expect(s.controller.value).toBe(from); + const writes = s.seen.length; + live.setTarget(-20); + s.step(); + expect(s.seen).toHaveLength(writes); + expect(s.queue).toHaveLength(0); + s.controller.destroy(); + expect(cancel).toHaveBeenCalledTimes(1); + }); + + it('reduced и RAF сохраняют endpoint без притворного native эффекта', () => { + for (const extra of [{ target: undefined }, { matchMedia: () => ({ matches: true }) }]) { + const s = scene(extra); + s.controller.handoffToLive(80); + s.step(); + s.controller.handoffToCompositor(200); + for (let i = 0; i < 200 && s.queue.length; i++) s.step(); + expect(s.controller.value).toBe(200); + expect(s.controller.mode).toBe('fallback'); + expect(s.calls).toHaveLength(0); + s.controller.destroy(); + } + }); + + it('reduced release завершает активный live follow устойчивым снапом', () => { + const s = scene({ matchMedia: () => ({ matches: true }) }); + const live = s.controller.handoffToLive(80); + live.setTarget(0); + s.step(); s.step(); + expect(live.velocity).not.toBe(0); + const requests = s.requests(); + s.controller.handoffToCompositor(200); + const writes = s.seen.length; + expect(live.value).toBe(200); + expect(live.velocity).toBe(0); + s.step(); + expect(s.controller.value).toBe(200); + expect(s.seen).toHaveLength(writes); + expect(s.requests()).toBe(requests); + expect(s.queue).toHaveLength(0); + expect(s.calls).toHaveLength(0); + s.controller.destroy(); + }); + + it('reduced release применяет новую цель после самостоятельного destroy live loan', () => { + const s = scene({ matchMedia: () => ({ matches: true }) }); + s.controller.handoffToLive(80).destroy(); + s.controller.handoffToCompositor(200); + expect(s.controller.value).toBe(200); + s.controller.handoffToCompositor(80); + expect(s.controller.value).toBe(80); + expect(s.requests()).toBe(0); + s.controller.destroy(); + }); + + it('новый reduced loan отзывает прежний live-owner и его поздние кадры', () => { + const s = scene({ matchMedia: () => ({ matches: true }) }); + const old = s.controller.handoffToLive(80); + old.setTarget(0); + s.step(); s.step(); + const next = s.controller.handoffToLive(200); + expect(next.value).toBe(200); + const requests = s.requests(); + old.setTarget(-500); + s.step(); + expect(s.controller.value).toBe(200); + expect(s.requests()).toBe(requests); + expect(s.queue).toHaveLength(0); + s.controller.destroy(); + }); + + it('проверяет target до effects, а terminal вызов остаётся инертным', () => { + const s = scene(); + s.controller.handoffToLive(80); + expect(() => s.controller.handoffToCompositor(Number.NaN)).toThrow(MotionParamError); + expect(s.calls).toHaveLength(0); + s.controller.destroy(); + expect(() => s.controller.handoffToCompositor(Number.NaN)).not.toThrow(); + s.step(); + expect(s.queue).toHaveLength(0); + }); +}); diff --git a/test/error-catalog-check.test.ts b/test/error-catalog-check.test.ts index 5ca4f5e0b..4cdde0557 100644 --- a/test/error-catalog-check.test.ts +++ b/test/error-catalog-check.test.ts @@ -180,6 +180,34 @@ ${row('LM001', 'unknown')} expect(errors.join('\n')).toMatch(/runtime-escape конструктора/); }); + it.each([ + 'Vue.getCurrentScope?.();', + 'const cleanup = Vue.onScopeDispose;', + 'Vue?.onScopeDispose(callback);', + ])('разрешает статически именованный член namespace: %s', (use) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [['src/adapter.ts', `import * as Vue from 'vue'; ${use}`]], + }); + expect(errors).toEqual([]); + }); + + it.each([ + 'const Constructor = errors.MotionParamError;', + "const Constructor = errors['MotionParamError'];", + 'const Constructor = errors[key];', + 'const alias = errors; const Constructor = alias[key];', + 'consume(errors);', + 'Object.values(errors);', + 'const { MotionParamError: Constructor } = errors;', + ])('сохраняет запрет выноса конструктора или всего namespace: %s', (use) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [['src/escape.ts', `import * as errors from './errors.js'; ${use}`]], + }); + expect(errors.join('\n')).toMatch(/runtime-escape конструктора/); + }); + it('не позволяет computed access к namespace ошибок', () => { const errors = validateErrorCatalog({ catalogText: catalog([]), @@ -208,6 +236,21 @@ ${row('LM001', 'unknown')} expect(errors.join('\n')).toMatch(/runtime-escape конструктора/); }); + it.each([ + ["export { MotionParamError as createError } from './errors.js';", 'createError'], + ["import { MotionParamError } from './errors.js'; export default MotionParamError;", 'default'], + ])('проверяет владельца alias до статического namespace-доступа: %s', (barrel, member) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/barrel.ts', barrel], + ['src/use.ts', `import * as api from './barrel.js'; new api.${member}(runtimeCode);`], + ], + }); + expect(errors.some(error => error.startsWith('src/barrel.ts:') && + error.includes('runtime-escape конструктора'))).toBe(true); + }); + it('не позволяет default re-export конструктора', () => { const errors = validateErrorCatalog({ catalogText: catalog([]), @@ -233,6 +276,97 @@ ${row('LM001', 'unknown')} expect(errors.join('\n')).toMatch(/runtime-escape конструктора/); }); + it.each(["'./nested/barrel.js'", '`./nested/barrel.js`'])( + 'проверяет origin динамического импорта транзитивного barrel: %s', (specifier) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/public.ts', "export { MotionParamError } from './errors.js';"], + ['src/nested/barrel.ts', "export * from '../public.js';"], + ['src/use.ts', `const errors = await import(${specifier}); new errors[key](runtimeCode);`], + ], + }); + expect(errors.some(error => error.startsWith('src/use.ts:') && + error.includes('runtime-escape конструктора'))).toBe(true); + }, + ); + + it('разрешает динамический импорт barrel без runtime-конструктора', () => { + expect(validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/public.ts', "export type { MotionParamError } from './errors.js'; export const value = 1;"], + ['src/use.ts', "const api = await import('./public.js'); void api.value;"], + ], + })).toEqual([]); + }); + + it.each([ + "export { MotionParamError } from './errors.js';", + "export * from './errors.js';", + "import { MotionParamError } from './errors.js'; export { MotionParamError };", + 'export class MotionParamError extends Error {}', + ])('запрещает namespace реэкспорта конструктора: %s', (publicExport) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/public.ts', publicExport], + ['src/barrel.ts', "export * as errors from './public.js';"], + ['src/use.ts', "import * as api from './barrel.js'; const key = 'MotionParamError' as const; new api.errors[key](runtimeCode);"], + ], + }); + expect(errors.some(error => error.startsWith('src/barrel.ts:') && + error.includes('runtime-escape конструктора'))).toBe(true); + }); + + it.each([false, true])('находит конструктор через транзитивный цикл независимо от порядка файлов: %s', (reverse) => { + const sources = [ + ['src/a.ts', "export * from './b.js'; export * from './public/index.js';"], + ['src/b.ts', "export * from './a.js';"], + ['src/public/index.ts', "export { MotionParamError } from '../errors.js';"], + ['src/barrel.ts', "export * as nested from './b.js';"], + ['src/use.ts', "import { nested } from './barrel.js'; new nested[key](runtimeCode);"], + ]; + const errors = validateErrorCatalog({ catalogText: catalog([]), sources: reverse ? sources.reverse() : sources }); + expect(errors.some(error => error.startsWith('src/barrel.ts:') && + error.includes('runtime-escape конструктора'))).toBe(true); + }); + + it.each(['export { errors };', 'export { errors as nested };', 'export { errors as default };', 'export default errors;'])( + 'не освобождает передачу импортированного namespace через export: %s', (exported) => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/public.ts', "export { MotionParamError } from './errors.js';"], + ['src/barrel.ts', `import * as errors from './public.js'; ${exported}`], + ['src/use.ts', "import * as api from './barrel.js'; new api.errors[key](runtimeCode);"], + ], + }); + expect(errors.some(error => error.startsWith('src/barrel.ts:') && + error.includes('runtime-escape конструктора'))).toBe(true); + }, + ); + + it('сохраняет type-only передачу namespace без runtime-эффекта', () => { + expect(validateErrorCatalog({ + catalogText: catalog([]), + sources: [['src/types.ts', "import * as errors from './errors.js'; export type { errors }; export { type errors as ErrorTypes }; type Namespace = typeof errors;"]], + })).toEqual([]); + }); + + it('разрешает namespace без runtime-конструктора и type-only реэкспорты', () => { + const errors = validateErrorCatalog({ + catalogText: catalog([]), + sources: [ + ['src/safe.ts', "export type { MotionParamError } from './errors.js'; export const value = 1;"], + ['src/safe-star.ts', "export type * from './errors.js'; export * from './safe.js';"], + ['src/barrel.ts', "export * as safe from './safe-star.js'; export * as Vue from 'vue'; export type * as errors from './errors.js';"], + ['src/use.ts', "import * as api from './barrel.js'; void api.safe.value; api.Vue.getCurrentScope?.();"], + ], + }); + expect(errors).toEqual([]); + }); + it('не позволяет Reflect, передачу или наследование конструктора', () => { const errors = validateErrorCatalog({ catalogText: catalog([]), diff --git a/test/fixtures/animate-terminal-retention.probe.ts b/test/fixtures/animate-terminal-retention.probe.ts new file mode 100644 index 000000000..f10cb6ef7 --- /dev/null +++ b/test/fixtures/animate-terminal-retention.probe.ts @@ -0,0 +1,156 @@ +import { strict as assert } from 'node:assert'; +import { setImmediate } from 'node:timers/promises'; +import { animate } from '../../src/animate/index.js'; +import { WaapiUnit } from '../../src/animate/waapi-unit.js'; +import { clearSpringExecutionArtifactCacheUnchecked, + compileSpringExecutionArtifactTupleUnchecked, DEFAULT_TOLERANCE } from '../../src/compositor/curve.js'; +import { SurfaceBatch } from '../../src/animate/surface-batch.js'; + +// Наблюдатель не меняет исполнение: вызывает исходный метод с тем же this, +// не держит units/buffers сильными ссылками и не зависит от приватных имён. +const observed: Array<{ unit: WeakRef; buffers: WeakRef[] }> = []; +const seen = new WeakSet(); +const mainUnits: WeakRef[] = []; +const originalAdd = SurfaceBatch.prototype._add; +SurfaceBatch.prototype._add = function (unit, paused): void { + mainUnits.push(new WeakRef(unit)); + originalAdd.call(this, unit, paused); +}; +const originalCommit = WaapiUnit.prototype._commit; +WaapiUnit.prototype._commit = function (): void { + if (!seen.has(this)) { + seen.add(this); + observed.push({ unit: new WeakRef(this), buffers: Object.values(this) + .filter(value => Array.isArray(value) || ArrayBuffer.isView(value)) + .map(value => new WeakRef(value)) }); + } + originalCommit.call(this); +}; +Object.defineProperty(globalThis, 'CSS', { configurable: true, value: { supports: () => true } }); +const physics = Object.freeze({ mass: 1, stiffness: 100, damping: 10 }); + +function fixture() { + const styles = new Map(); + let effects = 0; + const timers = new Map void>(); + const target = { style: { + getPropertyValue: (name: string) => styles.get(name) ?? '', + setProperty: (name: string, value: string) => { styles.set(name, value); }, + }, animate() { effects++; return { currentTime: 32, cancel() { effects--; } }; } }; + return { target, styles, timers, effects: () => effects, + options: { spring: physics, now: () => 0, + setTimer(callback: () => void) { + const key = {}; timers.set(key, callback); + return () => { timers.delete(key); }; + }, + }, + finishOne() { + const next = timers.entries().next().value; + assert.ok(next); timers.delete(next[0]); next[1](); + }, + }; +} +async function collect() { + assert.equal(typeof globalThis.gc, 'function', 'probe requires --expose-gc'); + for (let i = 0; i < 4; i++) { await setImmediate(); globalThis.gc!(); } +} +const alive = (refs: WeakRef[]) => refs.filter(ref => ref.deref() !== undefined).length; +const holds: unknown[] = []; +const records: Array<{ name: string; start: number; count: number }> = []; + +for (const terminal of ['cancel', 'stop', 'natural'] as const) { + const f = fixture(), start = observed.length; + const controls = animate(f.target, { opacity: [0, 1] }, f.options); + assert.equal(f.effects(), 1, 'positive native owner'); + assert.equal(observed.length - start, 1); + assert.ok(observed[start]!.buffers.length > 0, 'observer must see live trajectory storage'); + if (terminal === 'natural') f.finishOne(); else controls[terminal](); + await controls.finished; + assert.equal(f.effects(), 0); + assert.equal(f.timers.size, 0); + holds.push(controls, controls.finished); + records.push({ name: terminal, start, count: 1 }); +} + +// Один завершённый слот не вправе держать кривую, пока sibling ещё играет. +const partial = fixture(), partialStart = observed.length; +const partialControls = animate(partial.target, { opacity: [0, 1], x: [0, 100] }, partial.options); +assert.equal(observed.length - partialStart, 2); +partial.finishOne(); +assert.equal(partial.effects(), 1); +holds.push(partialControls); +await collect(); +const partialVectors = observed.slice(partialStart).map(item => alive(item.buffers)); +console.log(JSON.stringify({ phase: 'partial', retainedBuffers: partialVectors })); +// Общая кривая может законно жить в sibling/cache: проверяется lease слота, +// а не ложное требование собрать shared value при живом потребителе. +const ownsBuffers = (ref: WeakRef) => Object.values(ref.deref() ?? {}) + .some(value => Array.isArray(value) || ArrayBuffer.isView(value)); +assert.equal(ownsBuffers(observed[partialStart]!.unit), false, + 'completed slot retains a trajectory lease while sibling is live'); +assert.ok(partialVectors[1]! > 0, 'healthy live sibling lost its trajectory'); +partialControls.cancel(); await partialControls.finished; +assert.equal(partial.effects(), 0); +records.push({ name: 'partial-then-cancel', start: partialStart, count: 2 }); + +// Новый owner остаётся живым, когда predecessor полностью завершён и удерживается. +const next = fixture(), nextStart = observed.length; +const old = animate(next.target, { opacity: [0, 1] }, next.options); +const successor = animate(next.target, { opacity: 0.2 }, next.options); +await old.finished; +holds.push(old, successor); +await collect(); +assert.equal(observed[nextStart]!.unit.deref(), undefined, 'superseded aggregate keeps its executor'); +assert.ok(observed[nextStart + 1]!.unit.deref(), 'healthy successor disappeared'); +assert.equal(next.effects(), 1); +successor.cancel(); await successor.finished; +records.push({ name: 'superseded', start: nextStart, count: 2 }); + +// Live handoff не превращает terminal wrapper в владельца завершённого +// MainUnit, пока другой слот того же aggregate продолжает жить. +function crossingMs(): number { + const artifact = compileSpringExecutionArtifactTupleUnchecked(physics, 0, DEFAULT_TOLERANCE); + const samples = artifact[1]; + for (let i = 0; i + 3 < samples.length; i += 2) { + const p0 = samples[i + 1]!, p1 = samples[i + 3]!; + if (p0 < 1 && p1 >= 1) return (samples[i]! + (1 - p0) / (p1 - p0) + * (samples[i + 2]! - samples[i]!)) / 100 * artifact[2]; + } + throw new Error('positive target crossing is required'); +} +const handoff = fixture(), mainStart = mainUnits.length, nativeStart = observed.length; +let jobs: Array<(timestamp?: number) => void> = []; +const handoffOptions = { ...handoff.options, + requestFrame(callback: (timestamp?: number) => void) { jobs.push(callback); return jobs.length; }, +}; +const crossing = crossingMs(); +const handoffControls = animate(handoff.target, { opacity: [0, 1], x: [0, 100] }, handoffOptions); +handoffControls.seek(crossing); +assert.equal(mainUnits.length - mainStart, 2, 'both native slots must reach live handoff'); +const replacement = animate(handoff.target, { opacity: [0, 0.2] }, handoff.options); +await collect(); +assert.equal(mainUnits[mainStart]!.deref(), undefined, + 'terminal native wrapper retains its superseded main delegate'); +assert.ok(mainUnits[mainStart + 1]!.deref(), 'healthy live sibling lost its main delegate'); +handoffControls.cancel(); replacement.cancel(); +await Promise.all([handoffControls.finished, replacement.finished]); +const pending = jobs; jobs = []; +for (const callback of pending) callback(16); +assert.equal(jobs.length, 0); +holds.push(handoffControls, replacement); +records.push({ name: 'handoff', start: nativeStart, count: observed.length - nativeStart }); + +// Кэш имеет собственное законное владение; его очистка отделяет его от controls. +clearSpringExecutionArtifactCacheUnchecked(); +await collect(); +for (const record of records) { + const items = observed.slice(record.start, record.start + record.count); + assert.equal(alive(items.map(item => item.unit)), 0, `${record.name}: terminal controls retain executors`); + assert.equal(alive(items.flatMap(item => item.buffers)), 0, `${record.name}: terminal controls retain trajectory buffers`); +} +// Все controls по-прежнему удерживаются вызывающей стороной, а не выброшены тестом. +assert.equal(holds.length, 11); +assert.equal(alive(mainUnits), 0, 'terminal controls retain main delegates'); +SurfaceBatch.prototype._add = originalAdd; +WaapiUnit.prototype._commit = originalCommit; +console.log('animate-terminal-retention: PASS'); diff --git a/test/fixtures/resource-package-probe.mjs b/test/fixtures/resource-package-probe.mjs new file mode 100644 index 000000000..e1708e3ed --- /dev/null +++ b/test/fixtures/resource-package-probe.mjs @@ -0,0 +1,955 @@ +import assert from 'node:assert/strict'; +import { createRequire } from 'node:module'; +import { setImmediate } from 'node:timers/promises'; + +// Этот файл копируется в приложение, установившее полный tarball. Импорты +// резолвятся только через его package.json, а не через исходный checkout. +const require = createRequire(import.meta.url); +const specifiers = ['@labpics/motion', '@labpics/motion/frame', '@labpics/motion/compositor', + '@labpics/motion/bindings', '@labpics/motion/behaviors', '@labpics/motion/behaviors/reorder', + '@labpics/motion/compositor/follow', '@labpics/motion/presence', '@labpics/motion/animate']; +const modules = []; +for (const format of ['esm', 'cjs']) { + const loaded = []; + for (const name of specifiers) loaded.push(format === 'esm' ? await import(name) : require(name)); + const [root, frame, compositor, bindings, behaviors, reorder, follow, presence, animate] = loaded; + modules.push({ format, root, frame, compositor, bindings, behaviors, reorder, follow, presence, animate }); +} +const mode = process.argv[2]; +assert.ok(['witness', 'lifecycle', 'retention', 'bytes', 'reentry'].includes(mode), 'неизвестный режим RESOURCE proof'); +const CYCLES = 10_000; +const SPRING = Object.freeze({ mass: 1, stiffness: 170, damping: 26 }); +const EXISTING_KINDS = ['frame', 'motion-value', 'compositor-native', 'compositor-live', + 'compositor-delay', 'compositor-handoff', 'compositor-roundtrip', 'compositor-reduced-loans', 'binding', 'sheet', 'pager', + 'dismiss', 'pull', 'pull-pending', 'pull-settled', 'reorder', + 'follow-native', 'follow-pickup', 'follow-live']; +const ADDED_KINDS = ['presence-transition', 'animate-scope-main', 'animate-scope-native']; +const corpus = process.argv[3] ?? 'combined'; +assert.ok(['existing', 'presence-scope', 'combined'].includes(corpus), 'неизвестный RESOURCE corpus'); +const ALL_CASES = modules.flatMap(mod => [...EXISTING_KINDS, ...ADDED_KINDS] + .map(kind => ({ mod, kind, name: `${mod.format}/${kind}` }))); +const CASES = ALL_CASES.filter(({ kind }) => corpus === 'combined' + || (corpus === 'existing' ? EXISTING_KINDS : ADDED_KINDS).includes(kind)); +const terminalPromises = []; +const settledPromises = []; +const componentPromises = []; + +// Array хранится в JS heap: external ArrayBuffer/RSS не подменяют heapUsed. +function component(id, words = 256) { return { id, publications: 0, refreshes: 0, dismissals: 0, payload: new Array(words).fill(id) }; } +function listener(value) { return () => { value.publications++; }; } +function formatter(value) { return number => { void value.id; return number; }; } +function scheduler(value, host) { return callback => { void value.id; return host.requestFrame(callback); }; } +function clock(value, host) { return () => { void value.id; return host.now; }; } +function completion(value) { return () => { value.dismissals++; }; } +function refresh(value, deferred) { return () => { value.refreshes++; return deferred.promise; }; } +const LINEAR = t => t; +function scopeTarget(value, host, native) { + const notify = listener(value); + return { marker: value, style: { + getPropertyValue: () => '', setProperty: notify, removeProperty: notify, + }, ...(native ? { animate: host.animate } : {}) }; +} +function scopeRoot(value, elements) { return { marker: value, querySelectorAll: () => elements }; } +function deferred() { + let resolve; + // Executor/resolver нейтрален к компоненту. Внешний promise сам по себе + // не получает права держать component callbacks уничтоженного controller. + const promise = new Promise(done => { resolve = done; }); + return { promise, resolve }; +} + +// Host-seams измеряют владение package. Реальные raster/GPU bytes этим double +// не измеряются. Stale frame физически дрейнится один раз по RequestFrameFn: +// у этого публичного шва нет cancel handle, но stale callback инертен. +// Все terminal host-объекты остаются roots. Общий prototype и отсутствие +// пустых очередей отделяют стоимость observer от удержания package owners. +class ResourceHost { + #frames; + #timers; + #effects; + #next = 0; + #now = 0; + #createdEffects = 0; + #cancelledEffects = 0; + #scheduledFrames = 0; + + get now() { return this.#now; } + get pendingFrames() { return this.#frames?.length ?? 0; } + get pendingTimers() { return this.#timers?.size ?? 0; } + get activeEffects() { return this.#effects?.size ?? 0; } + get createdEffects() { return this.#createdEffects; } + get cancelledEffects() { return this.#cancelledEffects; } + get scheduledFrames() { return this.#scheduledFrames; } + requestFrame = callback => { (this.#frames ??= []).push(callback); this.#scheduledFrames++; return ++this.#next; }; + setTimer = callback => { + const token = ++this.#next; (this.#timers ??= new Map()).set(token, callback); + return () => { + this.#timers?.delete(token); + if (this.#timers?.size === 0) this.#timers = undefined; + }; + }; + animate = () => { + const effect = { currentTime: 32, cancel: () => { + this.#cancelledEffects++; + this.#effects?.delete(effect); + if (this.#effects?.size === 0) this.#effects = undefined; + } }; + (this.#effects ??= new Set()).add(effect); this.#createdEffects++; return effect; + }; + step() { + this.#now += 16; + const batch = this.#frames ?? []; + this.#frames = undefined; + for (const callback of batch) callback(this.#now); + } + finishTimers() { + const callbacks = [...(this.#timers?.values() ?? [])]; + this.#timers = undefined; + for (const callback of callbacks) callback(); + } + drain() { + let count = 0; + while (this.pendingFrames) { + assert.ok(++count <= 1000, 'здоровый runner не достиг terminal snapshot'); + this.step(); + } + } + terminalDrain() { + assert.equal(this.pendingTimers, 0, 'terminal owner оставил timer'); + assert.equal(this.activeEffects, 0, 'terminal owner оставил native effect'); + assert.equal(this.cancelledEffects, this.createdEffects, 'native effects должны отменяться ровно один раз'); + this.step(); + assert.equal(this.pendingFrames, 0, 'terminal drain создал следующий frame'); + assert.equal(this.pendingTimers, 0, 'terminal drain воскресил timer'); + assert.equal(this.activeEffects, 0, 'terminal drain воскресил native effect'); + assert.equal(this.cancelledEffects, this.createdEffects, 'stale callback повторно отменил native effect'); + } +} +function makeHost() { return new ResourceHost(); } + +function runCase({ mod, kind, name }, value, terminal) { + const host = makeHost(); + const notify = listener(value); + const frame = scheduler(value, host); + let owners; + let destroy; + let terminalCheck; + switch (kind) { + case 'frame': { + // cancelAll не делает переиспользуемый FrameLoop permanently dead; + // component принадлежит callbacks/teardown, не общему scheduler. + const owner = mod.frame.createFrameLoop({ requestFrame: host.requestFrame }); + const offs = [owner.read(notify), owner.update(notify), owner.render(notify, { onTeardown: notify })]; + host.step(); + assert.equal(value.publications, 3, name + ': здоровый кадр не доставлен'); + destroy = () => { for (const off of offs) off(); owner.cancelAll(); }; + owners = [owner, ...offs]; + break; + } + case 'motion-value': { + const owner = new mod.root.MotionValue({ initial: 0, spring: SPRING, requestFrame: frame }); + const off = owner.onChange(notify); + owner.setTarget(1); host.step(); owner.setTarget(0.5); + assert.ok(value.publications > 1, name + ': живое значение не публикуется'); + off(); off(); + const before = value.publications; + host.step(); + assert.equal(value.publications, before, name + ': unsubscribe действует на живом owner'); + const again = owner.onChange(notify); + assert.equal(value.publications, before + 1, name + ': повторная подписка доставляет current snapshot'); + owner.stop(); owner.setTarget(0.75); + // Unsubscribe-handle остаётся у потребителя: destroy обязан разорвать + // ссылки даже без дополнительного вызова already terminal off. + destroy = () => { owner.destroy(); owner.setTarget(1); }; + owners = [owner, off, again]; + break; + } + case 'compositor-native': + case 'compositor-live': + case 'compositor-delay': + case 'compositor-handoff': + case 'compositor-roundtrip': { + const native = kind === 'compositor-native' || kind === 'compositor-handoff' || kind === 'compositor-roundtrip'; + const target = native ? { marker: value, animate: host.animate } : undefined; + const owner = new mod.compositor.CompositorSpring({ + spring: SPRING, property: 'opacity', from: 0, to: 1, target, + apply: notify, format: formatter(value), now: clock(value, host), requestFrame: frame, + delay: kind === 'compositor-delay' ? 100 : 0, setTimer: host.setTimer, + }); + owner.start(); + if (native) { + assert.equal(host.createdEffects, 1, name + ': native здоровый контроль не активен'); + assert.equal(host.activeEffects, 1); + } else if (kind === 'compositor-delay') assert.equal(host.pendingTimers, 1); + else assert.ok(host.pendingFrames > 0, name + ': live здоровый контроль не активен'); + owner.retarget(0.8); + if (native) assert.equal(host.activeEffects, 1, name + ': retarget оставил donor effect'); + else assert.equal(host.pendingTimers, 0, name + ': retarget не снял delay'); + let live, off; + if (kind === 'compositor-handoff' || kind === 'compositor-roundtrip') { + live = owner.handoffToLive(0.6); off = live.onChange(notify); + assert.equal(host.activeEffects, 0, name + ': handoff не снял native donor'); + assert.ok(host.pendingFrames > 0, name + ': handoff не запустил live owner'); + } + host.step(); + if (kind === 'compositor-roundtrip') { + owner.handoffToCompositor(0.7); + assert.equal(owner.mode, 'compositor', name + ': reciprocal native successor не принят'); + assert.equal(host.activeEffects, 1, name + ': reciprocal successor не владеет effect'); + const before = value.publications; + live.setTarget(0.4); host.step(); + assert.equal(value.publications, before, name + ': переданный live donor продолжает публиковаться'); + assert.equal(host.pendingFrames, 0, name + ': переданный live donor создал job'); + } + destroy = () => { owner.destroy(); owner.start(); owner.retarget(1); }; + owners = [owner, ...(live ? [live, off] : [])]; + break; + } + case 'follow-native': + case 'follow-pickup': + case 'follow-live': { + const target = { marker: value, animate() { + const effect = host.animate(); effect.target = this; return effect; + } }; + const owner = mod.follow.createCompositorFollow({ + spring: { ...SPRING, owner: value }, property: 'opacity', from: 0, to: 1, target, + apply: notify, format: formatter(value), now: clock(value, host), requestFrame: frame, + }); + owner.beginFollow(0); owner.follow(0.2, 0.02); owner.settle(1, 0.02); + assert.equal(host.activeEffects, 1, name + ': native settle не создал владельца'); + assert.equal(host.pendingFrames, 0, name + ': native settle создал frame'); + const loans = []; + if (kind === 'follow-live') { + const donor = owner.handoffToLive(0.6), off = donor.onChange(notify); + loans.push(donor, off); + host.step(); host.step(); + assert.ok(host.pendingFrames > 0, name + ': live donor не работает'); + owner.beginFollow(0.03); + const before = value.publications; + donor.setTarget(0.1); host.step(); + assert.equal(value.publications, before, name + ': pickup не отозвал live donor'); + assert.equal(host.pendingFrames, 0, name + ': старый donor создал следующий frame'); + owner.follow(0.4, 0.04); + const live = owner.handoffToLive(0.7), liveOff = live.onChange(notify); + loans.push(live, liveOff); + host.step(); + assert.ok(host.pendingFrames > 0, name + ': новый live owner не работает'); + } else if (kind === 'follow-pickup') { + owner.beginFollow(0.03); owner.follow(0.4, 0.04); + } + assert.equal(host.activeEffects, kind === 'follow-native' ? 1 : 0, + name + ': pickup оставил native donor'); + assert.ok(value.publications > 0, name + ': здоровый follow не доставил ввод'); + destroy = () => { + owner.destroy(); owner.beginFollow(2); owner.follow(0.5, 2); owner.settle(1, 2); + owner.start(); owner.retarget(1); + for (const loan of loans) if (typeof loan !== 'function') loan.setTarget(0.2); + }; + owners = [owner, ...loans]; + break; + } + case 'compositor-reduced-loans': { + const owner = new mod.compositor.CompositorSpring({ + spring: SPRING, property: 'opacity', from: 0, to: 1, + apply: notify, format: formatter(value), now: clock(value, host), requestFrame: frame, + matchMedia: () => ({ matches: true }), + }); + const old = owner.handoffToLive(0.8); + const oldOff = old.onChange(notify); + old.setTarget(0.2); host.step(); host.step(); + assert.ok(host.pendingFrames > 0, name + ': здоровый старый loan не активен'); + const next = owner.handoffToLive(0.6); + const nextOff = next.onChange(notify); + const before = value.publications; + old.setTarget(0.4); host.step(); + assert.equal(value.publications, before, name + ': прежний loan продолжает писать'); + assert.equal(host.pendingFrames, 0, name + ': прежний loan продолжает планировать'); + next.setTarget(0.9); host.step(); + assert.ok(host.pendingFrames > 0, name + ': текущий loan потерял ownership'); + destroy = () => { owner.destroy(); old.setTarget(0.1); next.setTarget(0.2); }; + owners = [owner, old, oldOff, next, nextOff]; + break; + } + case 'binding': { + const project = model => { void value.id; return { surface: { opacity: model } }; }; + const owner = mod.bindings.createMotionBinding(project, { surface() { notify(); return host.animate(); } }); + owner.update(0); owner.update(0); + assert.equal(host.createdEffects, 1, name + ': одна цель перезапускает роль'); + owner.update(1); + assert.equal(host.createdEffects, 2, name + ': изменённая цель не принята'); + assert.equal(host.activeEffects, 1, name + ': successor не освободил donor'); + destroy = () => { owner.destroy(); owner.update(0.5); assert.equal(owner.state, 'destroyed'); }; + owners = [owner]; + break; + } + case 'presence-transition': { + const action = deferred(); + const phase = () => { + notify(); + return { ...host.animate(), finished: action.promise }; + }; + const owner = mod.presence.createPresenceTransition({ enter: phase, exit: phase, + onPresent: completion(value), onGone: completion(value) }); + const enter = owner.setPresent(true); + assert.equal(owner.setPresent(true), enter, name + ': повтор цели создал другую фазу'); + const exit = owner.setPresent(false); + const pending = owner.setPresent(true); + assert.equal(host.createdEffects, 3, name + ': interruption не создало successor'); + assert.equal(host.cancelledEffects, 2, name + ': supersede не снял прежние effects'); + assert.equal(host.activeEffects, 1, name + ': current phase не владеет effect'); + assert.equal(value.publications, 3, name + ': здоровые factory не выполнены'); + destroy = () => { + owner.destroy(); + assert.equal(owner.state, 'destroyed'); + assert.equal(owner.setPresent(false), pending, name + ': terminal input создал Promise'); + }; + if (terminal) { + terminalCheck = { name, kind, host, owner, pending, + earlier: [enter, exit], ref: new WeakRef(value) }; + componentPromises.push(terminalCheck); + } + // Нейтральный незавершённый Promise не является consumer callback-root. + owners = [owner, enter, exit, pending, action]; + break; + } + case 'animate-scope-main': + case 'animate-scope-native': { + const native = kind === 'animate-scope-native'; + const elements = [scopeTarget(value, host, native), scopeTarget(value, host, native), scopeTarget(value, host, native)]; + const root = scopeRoot(value, elements); + const owner = mod.animate.createAnimateScope(root); + const options = { ...(native ? { spring: SPRING } : { duration: 1000, ease: LINEAR }), + requestFrame: frame, now: clock(value, host), setTimer: host.setTimer, + onComplete: completion(value) }; + const initial = owner.animate('.surface', { opacity: [0, 1] }, options); + host.step(); + if (native) { + assert.equal(host.activeEffects, 3, name + ': native scope не владеет effects'); + host.finishTimers(); + assert.equal(host.activeEffects, 0, name + ': natural completion не освободило effects'); + assert.equal(value.dismissals, 1, name + ': natural completion callback'); + } + else assert.ok(value.publications > 0, name + ': живой scope не пишет'); + const active = owner.animate(elements[0], { opacity: [0, 0.8] }, options); + const paused = owner.animate(elements[1], { opacity: [0, 0.6] }, options); + paused.pause(); + const delayed = owner.animate(elements[2], { opacity: [0, 0.4] }, { ...options, delay: 1000 }); + host.step(); + if (native) assert.equal(host.activeEffects, 2, name + ': current/paused/delayed native ownership'); + else assert.ok(host.pendingFrames > 0, name + ': active/delayed scope потерял scheduler'); + destroy = () => { + owner.destroy(); + const before = value.publications; + for (const controls of [initial, active, paused, delayed]) { + controls.play(); controls.pause(); controls.seek(32); controls.cancel(); controls.stop(); + } + assert.equal(value.publications, before, name + ': terminal control воскресил writer'); + }; + if (terminal) { + terminalCheck = { name, kind, host, owner, + pending: Promise.all([initial.finished, active.finished, paused.finished, delayed.finished]), + ref: new WeakRef(value) }; + componentPromises.push(terminalCheck); + } + // Scope destroy терминализирует принадлежащие ему runs. Сохранённые + // public controls/finished не дают motion право удерживать component. + owners = [owner, initial, active, paused, delayed]; + break; + } + case 'sheet': + case 'pager': { + const sheet = kind === 'sheet'; + const owner = sheet + ? mod.behaviors.createBottomSheet({ snapPoints: [0, 100, 200], requestFrame: frame, onChange: notify }) + : mod.behaviors.createCarousel({ pageCount: 3, pageSize: 100, requestFrame: frame, onChange: notify }); + const off = owner.subscribe(notify); + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: -60, y: 60, t: 0.05 }); + owner.pointerUp({ x: -60, y: 60, t: 0.1 }); + host.step(); + off(); off(); + const before = value.publications; + host.step(); + assert.equal(value.publications, before, name + ': unsubscribe не снял listener живого owner'); + const again = owner.subscribe(notify); + if (sheet) owner.update([0, 80, 160]); else owner.update(3, 80); + // Новый ввод должен отозвать старую release-очередь того же владельца. + owner.pointerDown({ x: 0, y: 0, t: 1 }); + owner.pointerMove({ x: -20, y: 20, t: 1.05 }); + owner.pointerCancel(); + assert.ok(host.pendingFrames > 0, name + ': release не создал job'); + assert.ok(value.publications > 0, name + ': подписка не работает'); + destroy = () => { owner.destroy(); owner.pointerDown({ x: 0, y: 0, t: 2 }); }; + owners = [owner, off, again]; + break; + } + case 'dismiss': { + const owner = mod.behaviors.createDragDismiss({ + distanceThreshold: 40, spring: SPRING, requestFrame: frame, + onChange: notify, onDismiss: completion(value), + }); + const off = owner.subscribe(notify); + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: 0, y: 60, t: 0.2 }); + owner.pointerUp({ x: 0, y: 60, t: 0.4 }); + host.step(); + assert.ok(host.pendingFrames > 0, name + ': release не запустил runner'); + // Новый ввод отменяет уход прежде onDismiss и возвращает ту же машину. + owner.pointerDown({ x: 0, y: 0, t: 1 }); + owner.pointerMove({ x: 0, y: 20, t: 1.2 }); + owner.pointerCancel(); + assert.equal(value.dismissals, 0, name + ': отменённый dismiss вызвал completion'); + destroy = () => { owner.destroy(); owner.pointerDown({ x: 0, y: 0, t: 2 }); }; + owners = [owner, off]; + break; + } + case 'pull': + case 'pull-pending': + case 'pull-settled': { + const action = deferred(); + const owner = mod.behaviors.createPullToRefresh({ + threshold: 40, resistance: 1, pendingPosition: 60, spring: SPRING, + requestFrame: frame, onChange: notify, onRefresh: refresh(value, action), + }); + const off = owner.subscribe(notify); + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: 0, y: 20, t: 0.1 }); + owner.pointerUp({ x: 0, y: 20, t: 0.2 }); + host.step(); + assert.ok(host.pendingFrames > 0, name + ': возврат не запустил runner'); + owner.pointerDown({ x: 0, y: 0, t: 1 }); + owner.pointerMove({ x: 0, y: 60, t: 1.2 }); + if (kind !== 'pull') { + // value === pendingPosition позволяет достигнуть Promise-владения + // синхронно; старый выданный возврат остаётся stale и дрейнится ниже. + owner.pointerUp({ x: 0, y: 60, t: 1.4 }); + assert.equal(owner.state.pending, true, name + ': pending не достигнут'); + assert.equal(value.refreshes, 1, name + ': onRefresh не вызван ровно один раз'); + const pending = owner.state; + owner.pointerDown({ x: 0, y: 0, t: 2 }); + assert.equal(owner.state, pending, name + ': pending потерял единственного владельца'); + } else { + owner.pointerCancel(); + assert.equal(value.refreshes, 0, name + ': pointerCancel запустил refresh'); + } + let released = false; + destroy = () => { + if (kind === 'pull-settled') { + if (!released) { + released = true; + settledPromises.push({ host, owner, ref: new WeakRef(value), terminal: true }); + action.resolve(); + } + return; + } + owner.destroy(); owner.pointerDown({ x: 0, y: 0, t: 3 }); + if (!released && kind === 'pull-pending') { + released = true; + terminalPromises.push({ host, owner, state: owner.state, + ref: new WeakRef(value), publications: value.publications }); + action.resolve(); + } + }; + if (!terminal && kind === 'pull-settled') { + settledPromises.push({ host, owner, ref: new WeakRef(value), terminal: false }); + action.resolve(); + } + owners = [owner, off, action]; + break; + } + case 'reorder': { + const items = [{ key: 'a', rect: { x: 0, y: 0, width: 20, height: 20 } }, + { key: 'b', rect: { x: 40, y: 0, width: 20, height: 20 } }]; + const owner = mod.reorder.createReorder({ items, onReorder: notify }); + const before = owner.start('a'); before.step('next'); + assert.equal(value.publications, 1, name + ': proposal не доставлен'); + owner.update(items); before.cancel(); + const after = owner.start('b'); after.step('previous'); + assert.equal(value.publications, 2, name + ': successor session не доставлен'); + destroy = () => { owner.destroy(); before.step('next'); after.step('previous'); }; + owners = [owner, before, after]; + break; + } + default: throw new Error(kind); + } + if (terminal) { + destroy(); destroy(); + const publications = value.publications; + if (terminalCheck) terminalCheck.publications = publications; + host.terminalDrain(); + assert.equal(value.publications, publications, name + ': terminal listener был вызван'); + } + // У живого контроля host остаётся вместе с owner: очередь сама является + // допустимой сильной ссылкой. У terminal host физически пуст. + return [host, ...owners]; +} + +async function flushTerminalPromises() { + await Promise.resolve(); await Promise.resolve(); + for (const check of componentPromises.splice(0)) { + const result = await check.pending; + if (check.kind === 'presence-transition') { + assert.deepEqual(result, { status: 'destroyed', present: true }, check.name + ': terminal result'); + for (const promise of check.earlier) assert.equal((await promise).status, 'superseded'); + } + check.host.terminalDrain(); + const value = check.ref.deref(); + if (value) assert.equal(value.publications, check.publications, check.name + ': deferred cleanup вызвал writer'); + } + for (const check of settledPromises.splice(0)) { + check.host.drain(); + assert.equal(check.owner.state.phase, 'idle', 'refresh не завершил возврат прежде destroy'); + assert.equal(check.owner.state.pending, false); + assert.equal(check.owner.state.value, 0); + const value = check.ref.deref(); + assert.ok(value, 'живой controller потерял component callback до завершения refresh'); + assert.equal(value.refreshes, 1); + if (check.terminal) { + const publications = value.publications, state = check.owner.state; + check.owner.destroy(); check.owner.destroy(); + check.owner.pointerDown({ x: 0, y: 0, t: 3 }); + check.host.terminalDrain(); + assert.equal(value.publications, publications, 'settled destroy вызвал terminal listener'); + assert.equal(check.owner.state, state, 'settled destroy был отменён поздним вводом'); + } + } + for (const check of terminalPromises.splice(0)) { + assert.equal(check.owner.state, check.state, 'поздний refresh изменил terminal state'); + check.host.terminalDrain(); + assert.equal(check.owner.state, check.state, 'поздний refresh-frame изменил terminal state'); + const value = check.ref.deref(); + if (value) assert.equal(value.publications, check.publications, 'поздний refresh вызвал terminal listener'); + } +} + +function setup(testCase, id, terminal, weak, words = 256) { + const value = component(id, words); + const ref = weak ? new WeakRef(value) : undefined; + const owners = runCase(testCase, value, terminal); + testCase.completed = (testCase.completed ?? 0) + 1; + return { ref, owners }; +} + +function resetExecutions() { for (const testCase of CASES) testCase.completed = 0; } +function executions() { return CASES.map(testCase => ({ name: testCase.name, cycles: testCase.completed })); } + +function activeUnsubscribe(mod, kind) { + const value = component(4); + const ref = new WeakRef(value); + const host = makeHost(); + const progress = { publications: 0 }; + const notify = listener(value); + const constructorListener = kind.endsWith('-constructor'); + const behaviorKind = kind.replace('-constructor', ''); + let owner, off; + if (kind === 'motion-value') { + owner = new mod.root.MotionValue({ initial: 0, spring: SPRING, requestFrame: host.requestFrame }); + off = owner.onChange(notify); + owner.onChange(listener(progress)); + off(); off(); + owner.setTarget(1); host.step(); + assert.ok(progress.publications > 1, 'unsubscribe остановил соседний listener живого MotionValue'); + } else { + owner = behaviorKind === 'sheet' + ? mod.behaviors.createBottomSheet({ snapPoints: [0, 100], requestFrame: host.requestFrame, + onChange: constructorListener ? notify : undefined }) + : behaviorKind === 'pager' + ? mod.behaviors.createCarousel({ pageCount: 2, pageSize: 100, requestFrame: host.requestFrame, + onChange: constructorListener ? notify : undefined }) + : kind === 'dismiss' + ? mod.behaviors.createDragDismiss({ distanceThreshold: 40, requestFrame: host.requestFrame }) + : mod.behaviors.createPullToRefresh({ threshold: 40, resistance: 1, requestFrame: host.requestFrame }); + // Даже callback из constructor-options использует ту же Set identity: + // off повторной subscribe снимает запись и не удерживает receiver options. + off = owner.subscribe(notify); + owner.subscribe(listener(progress)); + off(); off(); + if (behaviorKind === 'sheet') owner.snapTo(1); + else if (behaviorKind === 'pager') owner.goTo(1); + else { + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: 0, y: 20, t: 0.1 }); + owner.pointerUp({ x: 0, y: 20, t: 0.2 }); + } + host.step(); + assert.ok(progress.publications > 0, 'unsubscribe остановил соседний listener живого behavior'); + } + return { ref, owners: [owner, off, host, progress] }; +} + +function promiseRoot(mod, kind) { + const value = component(5), ref = new WeakRef(value), action = deferred(); + if (kind === 'user-owned') { + action.promise.then(listener(value)); + return { ref, owners: [action] }; + } + const host = makeHost(); + const owner = mod.behaviors.createPullToRefresh({ + threshold: 40, resistance: 1, pendingPosition: 60, + requestFrame: host.requestFrame, onRefresh: refresh(value, action), + }); + const off = owner.subscribe(listener(value)); + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: 0, y: 60, t: 0.1 }); + owner.pointerUp({ x: 0, y: 60, t: 0.2 }); + assert.equal(owner.state.pending, true); + assert.equal(value.refreshes, 1); + if (kind !== 'live') { owner.destroy(); host.terminalDrain(); } + return { ref, owners: kind === 'promise-only' ? [action] : [owner, off, action, host] }; +} + +// Узкие witnesses прежнего follow proof: scheduler/listeners уже входят в +// общий корпус, а spring-only и отменённый native donor требуют отдельных roots. +function springRoot(mod, kind, terminal, metadata) { + const value = component(7), ref = new WeakRef(value); + const spring = metadata ? { ...SPRING, owner: value } : SPRING; + const options = { spring, property: 'opacity', from: 0, to: 1 }; + const owner = kind === 'motion-value' + ? new mod.root.MotionValue({ initial: 0, spring, requestFrame: () => 1 }) + : kind === 'follow' ? mod.follow.createCompositorFollow(options) + : new mod.compositor.CompositorSpring(options); + if (terminal) owner.destroy(); + return { ref, owners: [owner] }; +} + +function lateCallbackRoot(mod) { + const value = component(8), ref = new WeakRef(value); + const owner = new mod.root.MotionValue({ initial: 0, spring: SPRING, requestFrame: () => 1 }); + owner.destroy(); + return { ref, owners: [owner, owner.onChange(listener(value))] }; +} + +function followEffectRoot(mod, pickup, terminal) { + const value = component(9), ref = new WeakRef(value), host = makeHost(); + let effectRef; + const target = { marker: value, animate() { + const effect = host.animate(); effect.target = this; effectRef = new WeakRef(effect); return effect; + } }; + const owner = mod.follow.createCompositorFollow({ + spring: SPRING, property: 'opacity', from: 0, to: 1, target, + apply: listener(value), format: formatter(value), now: () => host.now, requestFrame: host.requestFrame, + }); + owner.beginFollow(0); owner.follow(0.2, 0.02); owner.settle(1, 0.02); + assert.equal(host.createdEffects, 1, 'follow settle должен создать ровно один native effect'); + assert.equal(host.activeEffects, 1, 'follow reference control не создал native effect'); + assert.equal(host.cancelledEffects, 0, 'follow settle преждевременно отменил native effect'); + if (pickup) owner.beginFollow(0.03); + assert.equal(host.cancelledEffects, pickup ? 1 : 0, 'follow pickup должен отменить donor ровно один раз'); + if (terminal) owner.destroy(); + assert.equal(host.activeEffects, pickup || terminal ? 0 : 1); + assert.equal(host.cancelledEffects, pickup || terminal ? 1 : 0, 'follow native effect отменён больше одного раза'); + return { ref, effectRef, owners: [owner, host] }; +} + +async function promiseHealthy(mod) { + const value = component(6), action = deferred(), host = makeHost(); + const owner = mod.behaviors.createPullToRefresh({ + threshold: 40, resistance: 1, pendingPosition: 60, requestFrame: host.requestFrame, + onRefresh: refresh(value, action), onChange: listener(value), + }); + owner.pointerDown({ x: 0, y: 0, t: 0 }); + owner.pointerMove({ x: 0, y: 60, t: 0.1 }); + owner.pointerUp({ x: 0, y: 60, t: 0.2 }); + assert.equal(owner.state.pending, true); + assert.equal(value.refreshes, 1); + assert.equal(host.pendingFrames, 0); + action.resolve(); await Promise.resolve(); await Promise.resolve(); + assert.ok(host.pendingFrames > 0, 'healthy Promise не продолжил возврат'); + host.drain(); + assert.equal(owner.state.phase, 'idle'); assert.equal(owner.state.pending, false); + assert.equal(owner.state.value, 0); + owner.destroy(); host.terminalDrain(); + const dismiss = mod.behaviors.createDragDismiss({ + distanceThreshold: 40, dismissTarget: 80, matchMedia: () => ({ matches: true }), + requestFrame: host.requestFrame, onDismiss: completion(value), + }); + dismiss.pointerDown({ x: 0, y: 0, t: 0 }); + dismiss.pointerMove({ x: 0, y: 60, t: 0.1 }); + dismiss.pointerUp({ x: 0, y: 60, t: 0.2 }); + assert.equal(value.dismissals, 1, 'healthy onDismiss не выполнен'); + assert.equal(dismiss.state.dismissed, true); + dismiss.destroy(); host.terminalDrain(); +} +async function collect(rounds = 4) { + assert.equal(typeof globalThis.gc, 'function', '--expose-gc отсутствует'); + for (let round = 0; round < rounds; round++) { await setImmediate(); globalThis.gc(); } +} +const countAlive = refs => refs.reduce((count, ref) => count + (ref.deref() === undefined ? 0 : 1), 0); + +// Host getter может принять вложенный handoff и вернуть управление после +// частичного отказа sibling. Проверяется реальный packed API, не source alias. +async function packedReentry(animate, scenario) { + const rejectedWrite = new Error('reentry witness: rejected host write'); + const makeTarget = () => { + const values = new Map(); + const state = { writes: 0, cancels: 0, rejectNextWrite: false, calls: [] }; + state.target = { style: { + getPropertyValue: name => values.get(name) ?? '', + setProperty(name, value) { + if (state.rejectNextWrite) { state.rejectNextWrite = false; throw rejectedWrite; } + state.writes++; values.set(name, value); + }, + }, animate(keyframes, timing) { + state.calls.push({ keyframes, timing }); + return { cancel() { state.cancels++; } }; + } }; + return state; + }; + const targets = [makeTarget(), makeTarget(), makeTarget()]; + let queue = [], requests = 0, armed = false, caught = 0, completions = 0, crossing; + let controls; + const requestFrame = callback => { queue.push(callback); return ++requests; }; + controls = animate(targets.map(item => item.target), { opacity: [0, 1] }, { + spring: { mass: 1, stiffness: 100, damping: 10 }, + now: () => 0, setTimer: () => () => {}, onComplete: () => { completions++; }, + get requestFrame() { + if (armed) { + armed = false; + if (scenario === 'nested-failure') { + targets[1].rejectNextWrite = true; + try { controls.seek(crossing); } + catch (error) { assert.equal(error, rejectedWrite); caught++; } + } else if (scenario === 'cancel') controls.cancel(); + else if (scenario === 'pause') controls.pause(); + } + return requestFrame; + }, + }); + assert.ok(targets.every(item => item.calls.length === 1), 'healthy native start must be reached'); + const timing = targets[0].calls[0].timing; + // Время crossing выводится из фактически отданной host кривой, а не из + // независимого solver с иной сериализацией/допуском. + assert.ok(timing.easing.startsWith('linear(')); + const stops = timing.easing.slice(7, -1).split(',').map(stop => + stop.trim().split(/\s+/).map(parseFloat)); + for (let i = 0; i + 1 < stops.length; i++) { + const [p0, t0] = stops[i], [p1, t1] = stops[i + 1]; + if (p0 < 1 && p1 >= 1) { + crossing = (t0 + (1 - p0) / (p1 - p0) * (t1 - t0)) / 100 * timing.duration; + break; + } + } + assert.ok(Number.isFinite(crossing), 'positive target crossing is required'); + armed = scenario !== 'control'; + controls.seek(crossing); + const initialRequests = requests; + if (scenario === 'cancel' || scenario === 'pause') assert.equal(requests, 0); + else assert.equal(requests, 1, 'one aggregate created multiple frame clocks after getter reentry'); + assert.equal(caught, scenario === 'nested-failure' ? 1 : 0); + if (scenario === 'pause') { + controls.play(); assert.equal(requests, 1, 'accepted pause must remain resumable'); + } + controls.cancel(); await controls.finished; + assert.ok(targets.every(item => item.cancels === 1), 'every original native effect must be released once'); + const writes = targets.map(item => item.writes), requested = requests; + controls.play(); controls.pause(); controls.seek(32); controls.stop(); + const pending = queue; queue = []; + for (const callback of pending) callback(16); + assert.deepEqual(targets.map(item => item.writes), writes, 'terminal controls published stale writes'); + assert.equal(requests, requested, 'terminal aggregate rearmed a frame'); + assert.equal(queue.length, 0); + assert.equal(completions, 0); + return { scenario, caught, initialRequests, requests, nativeCancels: targets.map(item => item.cancels) }; +} + +if (mode === 'reentry') { + const checks = []; + for (const mod of modules) { + for (const scenario of ['control', 'nested-failure', 'cancel', 'pause']) { + checks.push({ format: mod.format, ...await packedReentry(mod.animate.animate, scenario) }); + } + } + console.log(JSON.stringify({ status: 'pass', mode, corpus, checks })); +} else if (mode === 'lifecycle') { + resetExecutions(); + for (const testCase of CASES) for (let cycle = 0; cycle < CYCLES; cycle++) setup(testCase, cycle, true, false, 0); + await flushTerminalPromises(); + const caches = modules.map(mod => { + const cache = mod.compositor.createSpringLinearCache(2); + for (let i = 0; i < 20; i++) cache.compile({ mass: 1, stiffness: 120 + i, damping: 26 }); + assert.equal(cache.capacity, 2); assert.equal(cache.size, 2); + cache.clear(); assert.equal(cache.size, 0); + const defaults = mod.compositor.createSpringLinearCache(); + assert.equal(defaults.capacity, 256, 'зарегистрированная ёмкость default-cache изменилась'); + for (let i = 0; i < 260; i++) defaults.compile({ mass: 1, stiffness: 120 + i, damping: 26 }); + assert.equal(defaults.size, 256, 'default-cache не вытесняет сверх frozen capacity'); + defaults.clear(); assert.equal(defaults.size, 0); + return { format: mod.format, isolatedCapacity: cache.capacity, defaultCapacity: defaults.capacity, finalSize: 0 }; + }); + console.log(JSON.stringify({ status: 'pass', mode, corpus, cyclesPerOwner: CYCLES, + executions: executions(), terminal: { effects: 0, jobs: 0, publications: 0 }, caches })); +} else if (mode === 'retention' || mode === 'witness') { + const count = mode === 'witness' ? 1 : CYCLES; + const terminalOwners = [], terminalRefs = CASES.map(() => []), droppedRefs = [], liveOwners = [], liveRefs = []; + const unsubscribedOwners = [], unsubscribedRefs = []; + const promiseOwners = [], promiseRefs = { live: [], terminal: [], 'promise-only': [], 'user-owned': [] }; + const inheritedOwners = [], inheritedChecks = []; + for (const mod of modules) { + for (const kind of ['motion-value', 'compositor', 'follow']) { + for (const [terminal, metadata] of [[true, true], [true, false], [false, true]]) { + const result = springRoot(mod, kind, terminal, metadata); + inheritedOwners.push(result.owners); + inheritedChecks.push({ ref: result.ref, alive: !terminal, label: `${mod.format}/${kind}/spring/${terminal}/${metadata}` }); + } + } + const late = lateCallbackRoot(mod); + inheritedOwners.push(late.owners); + inheritedChecks.push({ ref: late.ref, alive: false, label: `${mod.format}/late-subscription` }); + for (const pickup of [false, true]) for (const terminal of [false, true]) { + const result = followEffectRoot(mod, pickup, terminal); + inheritedOwners.push(result.owners); + inheritedChecks.push({ ref: result.ref, alive: !terminal, label: `${mod.format}/follow/target/${pickup}/${terminal}` }); + inheritedChecks.push({ ref: result.effectRef, alive: !pickup && !terminal, label: `${mod.format}/follow/effect/${pickup}/${terminal}` }); + } + } + for (const mod of modules) { + await promiseHealthy(mod); + for (const kind of Object.keys(promiseRefs)) { + const result = promiseRoot(mod, kind); + promiseOwners.push(result.owners); promiseRefs[kind].push(result.ref); + } + } + for (const mod of modules) for (const kind of ['motion-value', 'sheet', 'sheet-constructor', + 'pager', 'pager-constructor', 'dismiss', 'pull']) { + const result = activeUnsubscribe(mod, kind); + unsubscribedOwners.push(result.owners); unsubscribedRefs.push(result.ref); + } + for (const testCase of CASES) { + const control = setup(testCase, 1, false, true); + liveOwners.push(control.owners); liveRefs.push(control.ref); + droppedRefs.push(setup(testCase, 2, true, true).ref); + } + const deliberateOwners = [component(3)], deliberateRefs = [new WeakRef(deliberateOwners[0])]; + resetExecutions(); + for (let cycle = 0; cycle < count; cycle++) { + for (let index = 0; index < CASES.length; index++) { + const result = setup(CASES[index], cycle, true, true); + terminalOwners.push(result.owners); terminalRefs[index].push(result.ref); + } + if ((cycle + 1) % 500 === 0) { await flushTerminalPromises(); await collect(2); } + } + // Глобальная достижимость не позволяет оптимизатору выбросить контролируемые roots. + globalThis.__resourceControls = { terminalOwners, liveOwners, deliberateOwners, unsubscribedOwners, promiseOwners, inheritedOwners }; + await flushTerminalPromises(); + await collect(16); + const owners = CASES.map((testCase, index) => ({ name: testCase.name, retained: countAlive(terminalRefs[index]) })); + const retainedComponentReferences = owners.reduce((total, owner) => total + owner.retained, 0); + const inheritedFailures = inheritedChecks.filter(({ ref, alive }) => (ref.deref() !== undefined) !== alive) + .map(({ label }) => label); + const controls = { inheritedChecks: inheritedChecks.length, inheritedFailures, + live: countAlive(liveRefs), expectedLive: CASES.length, + dropped: countAlive(droppedRefs), deliberate: countAlive(deliberateRefs), + unsubscribedActive: countAlive(unsubscribedRefs), activeOwnersWithHealthySibling: unsubscribedOwners.length, + promiseRoots: Object.fromEntries(Object.entries(promiseRefs).map(([name, refs]) => [name, countAlive(refs)])), + healthyPromiseCompletions: modules.length, healthyDismissCompletions: modules.length }; + // Тот же live scope/presence controller остаётся сильным root после destroy; + // прежние 38 controls не меняют свой текущий lifetime premise. + const addedLiveRefs = []; + for (let index = 0; index < CASES.length; index++) if (ADDED_KINDS.includes(CASES[index].kind)) { + const [host, owner] = liveOwners[index]; + owner.destroy(); host.terminalDrain(); + addedLiveRefs.push(liveRefs[index]); + } + await flushTerminalPromises(); await collect(16); + controls.addedLiveReleased = countAlive(addedLiveRefs); + controls.addedLiveReleaseControls = addedLiveRefs.length; + const passed = inheritedFailures.length === 0 && retainedComponentReferences === 0 && controls.live === CASES.length + && controls.dropped === 0 && controls.deliberate === 1 && controls.unsubscribedActive === 0 + && controls.promiseRoots.live === 2 && controls.promiseRoots.terminal === 0 + && controls.promiseRoots['promise-only'] === 0 && controls.promiseRoots['user-owned'] === 2 + && controls.addedLiveReleased === 0; + const report = { status: passed ? 'pass' : 'fail', mode, corpus, cyclesPerOwner: count, executions: executions(), + retainedComponentReferences, retainedComponentPayloadBytes: retainedComponentReferences === 0 ? 0 : null, owners, controls }; + console.log(JSON.stringify(report)); + assert.deepEqual(inheritedFailures, [], 'spring/callback/follow reference contract нарушен'); + assert.equal(controls.live, CASES.length, 'live-owner control собран преждевременно'); + assert.equal(controls.dropped, 0, 'dropped-owner control остался достижим'); + assert.equal(controls.deliberate, 1, 'deliberate-retention control не обнаружен'); + assert.equal(controls.unsubscribedActive, 0, 'retained off удерживает компонент при живом owner'); + assert.equal(controls.promiseRoots.live, 2, 'live Promise control потерял компонент'); + assert.equal(controls.promiseRoots.terminal, 0, 'terminal controller удерживает onRefresh при нейтральном внешнем Promise'); + assert.equal(controls.promiseRoots['promise-only'], 0, 'motion continuation удерживает компонент через нейтральный внешний Promise'); + assert.equal(controls.promiseRoots['user-owned'], 2, 'внешний пользовательский Promise callback не различается'); + assert.equal(retainedComponentReferences, 0, 'terminal controls удерживают уничтоженные компоненты'); + assert.equal(controls.addedLiveReleased, 0, 'тот же уничтоженный live scope/presence удерживает компонент'); +} else { + // До candidate фиксированы измеримость и правило отказа. Полоса — разрешение + // стенда, не новый budget продукта: шире 256 KiB калибровка не принимается. + // Контрольный Array содержит 131 072 элемента; измеренный сигнал должен + // различаться минимум в 4× band независимо от представления элементов V8. + const MAX_RESOLVABLE_BAND = 256 * 1024; + const READOUT_ALLOWANCE = 8 * 1024; + const CONTROL_WORDS = 128 * 1024; + const batch = cycles => { for (let i = 0; i < cycles; i++) for (const testCase of CASES) setup(testCase, i, true, false); }; + const memory = async () => { await flushTerminalPromises(); await collect(); return process.memoryUsage(); }; + const heap = async () => (await memory()).heapUsed; + batch(256); + await heap(); + const calibration = []; + for (let i = 0; i < 8; i++) { batch(128); calibration.push(await heap()); } + const low = Math.min(...calibration), high = Math.max(...calibration); + const band = high - low + READOUT_ALLOWANCE; + const baseline = { low, high, band, maximumResolvableBand: MAX_RESOLVABLE_BAND, samples: calibration }; + console.log(JSON.stringify({ phase: 'baseline', mode, corpus, baseline })); + assert.ok(band <= MAX_RESOLVABLE_BAND, 'named gap: A/A heap baseline не разрешает 256 KiB; candidate admission не запущен'); + + let deliberate = [component(1, CONTROL_WORDS)]; + globalThis.__resourceBytesControls = deliberate; + const deliberateHeap = await heap(); + const deliberateSignal = deliberateHeap - high; + assert.ok(deliberateSignal >= 4 * band, 'named gap: deliberate-retention bytes не различаются от A/A baseline'); + deliberate = undefined; globalThis.__resourceBytesControls = undefined; + const releasedControl = await heap(); + assert.ok(releasedControl <= high + band, 'deliberate control не вернулся в baseline после release'); + + const liveCase = CASES.find(testCase => testCase.name === + (corpus === 'presence-scope' ? 'esm/presence-transition' : 'esm/compositor-native')); + let live = [setup(liveCase, 2, false, false, CONTROL_WORDS).owners]; + globalThis.__resourceBytesControls = live; + const liveHeap = await heap(); + const liveSignal = liveHeap - high; + assert.ok(liveSignal >= 4 * band, 'named gap: live-owner bytes не различаются от A/A baseline'); + live = undefined; globalThis.__resourceBytesControls = undefined; + const droppedControl = await heap(); + assert.ok(droppedControl <= high + band, 'dropped owner не вернулся в baseline'); + + const samples = []; + resetExecutions(); + for (let prefix = 2000; prefix <= CYCLES; prefix += 2000) { + batch(2000); + const measured = await memory(); + samples.push({ cyclesPerOwner: prefix, ...measured }); + } + // Префиксы сохраняют форму churn, но не являются terminal retention: + // V8 может держать уже недостижимые allocation/WeakMap backing stores между + // major GC и затем вернуть их без нового product work. Поэтому старый + // every-prefix критерий отвергал здоровый corpus на 4k/6k, хотя 10k и + // последующий quiescent tail стабильно возвращались ниже той же A/A полосы. + // M-07 требует возврат retained bytes после terminal boundary и отсутствие + // растущего retained хвоста. Число tail-read фиксировано, каждый использует + // тот же memory()/forced-GC oracle; устойчивый retained owner остаётся выше. + const upper = high + band; + const excess = samples.map(sample => Math.max(0, sample.heapUsed - upper)); + const terminalTail = []; + for (let i = 0; i < 4; i++) terminalTail.push(await memory()); + const tailExcess = terminalTail.map(sample => Math.max(0, sample.heapUsed - upper)); + // Historical existing-38 guard не ослабляется: его префиксы уже являются + // устойчивым доказанным contract. Новый presence/scope corpus использует + // свой независимый terminal-tail admission после обнаруженного V8 false RED. + const prefixRequired = corpus !== 'presence-scope'; + const retained = tailExcess.every(bytes => bytes === 0) + && (!prefixRequired || excess.every(bytes => bytes === 0)); + const report = { status: retained ? 'pass' : 'fail', mode, corpus, cyclesPerOwner: CYCLES, + executions: executions(), baseline, + controls: { deliberateHeap, deliberateSignal, releasedControl, liveHeap, liveSignal, droppedControl }, + samples, excess, terminalTail, tailExcess, + accounting: { componentPayload: 'JS Array', boundedCaches: 'warmed before A/A', + terminalShells: 'отдельный retention proof; в bytes owners dropped', + prefixSamples: prefixRequired + ? 'historical guard: каждый prefix + terminal tail обязаны быть в полосе' + : 'new-6 diagnostic churn; admission принадлежит фиксированному terminal tail после 10k', + process: 'heapUsed, heapTotal, external, arrayBuffers и rss показаны отдельно', + nativeGpuBytes: 'не измерены этим Node host' } }; + console.log(JSON.stringify(report)); + assert.ok(retained, 'retained heap не вернулся в baseline-полосу на terminal tail'); +} diff --git a/test/fixtures/server-thread-cpu-clock-check.mjs b/test/fixtures/server-thread-cpu-clock-check.mjs new file mode 100644 index 000000000..60626c7a9 --- /dev/null +++ b/test/fixtures/server-thread-cpu-clock-check.mjs @@ -0,0 +1,195 @@ +// Обязательная Linux/Node24.19 проверка private getter; не performance sample. +import assert from 'node:assert/strict'; +import { execFileSync, fork, spawnSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, appendFileSync } from 'node:fs'; +import { createRequire } from 'node:module'; +import os from 'node:os'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { Worker } from 'node:worker_threads'; + +const root = fileURLToPath(new URL('../..', import.meta.url)); +const self = fileURLToPath(import.meta.url); +const owner = new URL('../../bench/profile/server-thread-cpu-clock.mjs', import.meta.url); +const source = path.join(root, 'bench/profile/server-thread-cpu-clock.c'); +const host = path.join(root, 'test/fixtures/server-thread-cpu-clock-host.c'); +const include = path.join(root, 'bench/profile/native-clock/include'); +const hash = bytes => createHash('sha256').update(bytes).digest('hex'); +const flags = ['-std=c11', '-O2', '-Wall', '-Wextra', '-Werror', '-shared', '-fPIC', '-fvisibility=hidden', '-DNAPI_VERSION=8']; +const codes = [['read-errno', 'read', 'CLOCK_READ'], ['negative-seconds', 'read', 'CLOCK_VALUE'], + ['negative-nanoseconds', 'read', 'CLOCK_VALUE'], ['overflow-nanoseconds', 'read', 'CLOCK_VALUE'], + ['negative-pid', 'read', 'CLOCK_IDENTITY'], ['negative-tid', 'read', 'CLOCK_IDENTITY'], + ['resolution-errno', 'info', 'CLOCK_RESOLUTION'], ['zero-resolution', 'info', 'CLOCK_RESOLUTION']]; + +async function child(mode, directory) { + if (mode === 'operator-signal') { + const { parseServerProfileArgs, runServerProfile, withServerProfileSignals } = await import(new URL('../../bench/profile/server-profile-runner.mjs', import.meta.url)); + const before = { interrupt: process.listenerCount('SIGINT'), terminate: process.listenerCount('SIGTERM') }; + let aborts = 0, received; + const artifact = await withServerProfileSignals(async (signal) => { + const stopped = new Promise(resolve => signal.addEventListener('abort', () => { aborts++; resolve(); }, { once: true })); + process.channel.ref(); + process.send({ ready: true, pid: process.pid }); + await stopped; + process.channel.unref(); + received = signal.reason.raw.signal; + return runServerProfile(parseServerProfileArgs(['--baseline', root, '--candidate', directory, '--browser', 'chromium', '--out', path.join(directory, 'out')]), { signal }); + }); + assert.equal(aborts, 1); assert.equal(received, process.argv[5]); + assert.equal(process.listenerCount('SIGINT'), before.interrupt); + assert.equal(process.listenerCount('SIGTERM'), before.terminate); + assert.equal(artifact.verdict, 'UNPROVEN'); assert.equal(artifact.registration, null); + assert.equal(artifact.failures.length, 1); assert.equal(artifact.failures[0].error.code, 'OPERATOR_INTERRUPTION'); + assert.equal(artifact.failures[0].error.raw.signal, received); assert.deepEqual(artifact.stages, []); + const raw = readFileSync(path.join(directory, 'out/server-profile.json')); + assert.deepEqual(JSON.parse(raw), artifact); + assert.equal(readFileSync(path.join(directory, 'out/server-profile.sha256'), 'utf8').split(' ')[0], hash(raw)); + const journal = readFileSync(path.join(directory, 'out/journal.ndjson'), 'utf8').trim().split('\n').map(line => JSON.parse(line)); + assert.deepEqual(journal.map(row => row.type), ['failure', 'finished']); + assert.deepEqual(journal.at(-1).value, { verdict: 'UNPROVEN', digest: hash(raw) }); + return { mode, signal: received, aborts, artifact, journal, scope: 'настоящий сигнал Node через общий CLI wrapper и реальный отказ/finally до подготовки; без SUT серии' }; + } + if (mode === 'native-abi') { + const native = createRequire(import.meta.url)(directory); + process.env.MOTION_CLOCK_CHECK_MODE = 'large-exact'; + let acquired, info; + assert.doesNotThrow(() => { acquired = native.read(); }); + assert.doesNotThrow(() => { info = native.info(); }); + assert.deepEqual(acquired, { seconds: '9007199254740993', nanoseconds: 17, pid: process.pid, tid: process.pid }); + assert.deepEqual(info, { pid: process.pid, tid: process.pid, nominalResolutionNs: '1' }); + for (const [fault, method, code] of codes) { + process.env.MOTION_CLOCK_CHECK_MODE = fault; + assert.throws(() => native[method](), error => error.code === code, fault); + } + return { mode, controls: codes.length + 2, exactLargeSeconds: true }; + } + const api = await import(owner); + assert.throws(() => api.readServerThreadCpuEndpoint(), /не подготовлен/); + if (mode === 'worker') { + const worker = new Worker(`(async () => { + const { parentPort } = require('node:worker_threads'); + const { prepareServerThreadCpuClock } = await import(${JSON.stringify(owner.href)}); + try { prepareServerThreadCpuClock({directory:${JSON.stringify(directory)}}); parentPort.postMessage({accepted:true}); } + catch(error) { parentPort.postMessage({message:error.message,raw:error.raw}); } + })();`, { eval: true }); + const result = await new Promise((resolve, reject) => { + worker.once('message', resolve); worker.once('error', reject); + worker.once('exit', code => { if (code) reject(new Error('worker exit ' + code)); }); + }); + await worker.terminate(); + assert.equal(result.raw?.isMainThread, false); assert.match(result.message, /main-thread/); + return { mode, refusal: result }; + } + if (mode === 'stale') { + mkdirSync(path.join(directory, 'native-clock'), { recursive: true }); + const binary = path.join(directory, 'native-clock/thread-cpu-clock.node'); + writeFileSync(binary, 'retained-stale-binary'); + assert.throws(() => api.prepareServerThreadCpuClock({ directory }), /stale\/replay/); + assert.equal(readFileSync(binary, 'utf8'), 'retained-stale-binary'); + return { mode, retainedOriginal: true }; + } + if (mode === 'missing-compiler') { + process.env.PATH = directory; + assert.throws(() => api.prepareServerThreadCpuClock({ directory }), /нет C compiler/); + return { mode, refusal: true }; + } + assert.equal(mode, 'actual-api'); + const prepared = api.prepareServerThreadCpuClock({ directory }); + const { metadata } = prepared; + assert.equal(metadata.node.version, 'v24.19.0'); + assert.equal(metadata.pid, process.pid); assert.equal(metadata.tid, process.pid); + assert.equal(metadata.clock, 'CLOCK_THREAD_CPUTIME_ID'); + assert.equal(metadata.nominalResolutionIsNotErrorCertificate, true); + for (const [file, digest] of Object.entries(metadata.nativeSources)) assert.equal(hash(readFileSync(path.join(root, file))), digest); + assert.equal(hash(readFileSync(metadata.nativeBinary.path)), metadata.nativeBinary.sha256); + const first = api.readServerThreadCpuEndpoint(); + let sum = 0; for (let i = 0; i < 8192; i++) sum = (sum + i) | 0; + assert.equal(sum, 33550336); + const second = api.readServerThreadCpuEndpoint(); + for (const read of [first, second]) { + assert.equal(read.pid, process.pid); assert.equal(read.tid, process.pid); + assert.equal(read.valueNs, String(BigInt(read.seconds) * 1000000000n + BigInt(read.nanoseconds))); + } + assert(BigInt(second.valueNs) > BigInt(first.valueNs)); + prepared.assertUnchanged(); + assert.throws(() => api.prepareServerThreadCpuClock({ directory }), /уже подготовлен/); + appendFileSync(metadata.nativeBinary.path, Buffer.from([0])); + assert.throws(() => prepared.assertUnchanged(), /identity изменились/); + return { mode, metadata, acquired: [first, second], scope: 'actual API/ABI, не физическая точность clock model' }; +} + +function run(mode, directory) { + return spawnSync(process.execPath, [self, '--case', mode, directory], { encoding: 'utf8', timeout: 30000 }); +} + +async function runSignal(directory, signal) { + mkdirSync(directory); + const child = fork(self, ['--case', 'operator-signal', directory, signal], { stdio: ['ignore', 'pipe', 'pipe', 'ipc'] }); + let stdout = '', stderr = '', sent = false; + child.stdout.on('data', data => { stdout += data; }); child.stderr.on('data', data => { stderr += data; }); + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { child.kill('SIGKILL'); reject(new Error(`operator-signal ${signal}: timeout`)); }, 30000); + child.once('error', error => { clearTimeout(timeout); reject(error); }); + child.on('message', message => { + if (message?.ready !== true || sent) return; + sent = true; assert.equal(message.pid, child.pid); + assert(child.kill(signal)); assert(child.kill(signal)); + }); + child.once('close', (code, nativeSignal) => { + clearTimeout(timeout); + try { + assert(sent); assert.equal(nativeSignal, null); assert.equal(code, 0, stderr || stdout); + resolve(JSON.parse(stdout)); + } catch (error) { reject(error); } + }); + }); +} + +async function main() { + assert.equal(process.platform, 'linux'); assert.equal(process.arch, 'x64'); assert.equal(process.version, 'v24.19.0'); + const directory = mkdtempSync(path.join(os.tmpdir(), 'motion-native-clock-check-')); + const records = []; + try { + for (const mode of ['actual-api', 'worker', 'stale', 'missing-compiler']) { + const result = run(mode, path.join(directory, mode)); + assert.equal(result.status, 0, `${mode}: ${result.stderr || result.stdout}`); + records.push(JSON.parse(result.stdout)); + } + const original = readFileSync(source, 'utf8'); + const replacements = [ + ['wrong-clock', 'CLOCK_THREAD_CPUTIME_ID', 'CLOCK_PROCESS_CPUTIME_ID', true], + ['read-errno', 'if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &value) != 0) return fail(env, "CLOCK_READ", strerror(errno));', + '(void)clock_gettime(CLOCK_THREAD_CPUTIME_ID, &value);'], + ['invalid-timespec', 'if (value.tv_sec < 0 || value.tv_nsec < 0 || value.tv_nsec >= 1000000000L)', 'if (0)'], + ['invalid-identity', 'if (pid <= 0 || tid <= 0)', 'if (0)'], + ['seconds-number-loss', '!string_field(env, result, "seconds", seconds)', '!integer_field(env, result, "seconds", (int64_t)value.tv_sec)'], + ['resolution-errno', 'if (clock_getres(CLOCK_THREAD_CPUTIME_ID, &resolution) != 0) return fail(env, "CLOCK_RESOLUTION", strerror(errno));', + '(void)clock_getres(CLOCK_THREAD_CPUTIME_ID, &resolution);'], + ]; + for (const [name, before, after, all] of [['healthy-native', '', '', false], ...replacements]) { + if (before) assert(original.includes(before), name); + const body = before ? all ? original.replaceAll(before, after) : original.replace(before, after) : original; + const file = path.join(directory, name + '.c'), binary = path.join(directory, name + '.node'); + writeFileSync(file, body); + const argv = [...flags, '-I', include, '-o', binary, file, host, + '-Wl,--wrap=clock_gettime', '-Wl,--wrap=clock_getres', '-Wl,--wrap=getpid', '-Wl,--wrap=syscall']; + execFileSync('cc', argv, { encoding: 'utf8', timeout: 30000 }); + const result = run('native-abi', binary); + if (before) { + assert.equal(result.status, 1, `${name}: mutant must reach the independent ABI oracle`); + assert.match(result.stderr, /AssertionError/); + } else assert.equal(result.status, 0, result.stderr); + records.push({ name, sourceSha256: hash(Buffer.from(body)), binarySha256: hash(readFileSync(binary)), + argv, exitCode: result.status, killed: Boolean(before), stdout: result.stdout, stderr: result.stderr }); + } + for (const signal of ['SIGINT', 'SIGTERM']) records.push(await runSignal(path.join(directory, signal), signal)); + process.stdout.write(JSON.stringify({ node: process.version, kernel: os.release(), sourceSha256: hash(readFileSync(source)), + hostSha256: hash(readFileSync(host)), records, registeredTimingSamples: 0 }) + '\n'); + } finally { rmSync(directory, { recursive: true, force: true }); } +} + +if (process.argv[2] === '--case') { + try { process.stdout.write(JSON.stringify(await child(process.argv[3], process.argv[4])) + '\n'); } + catch (error) { process.stderr.write(String(error.stack ?? error) + '\n'); process.exitCode = 1; } +} else await main(); diff --git a/test/fixtures/server-thread-cpu-clock-host.c b/test/fixtures/server-thread-cpu-clock-host.c new file mode 100644 index 000000000..08629b8b6 --- /dev/null +++ b/test/fixtures/server-thread-cpu-clock-host.c @@ -0,0 +1,43 @@ +/* Управляемый native host для проверок настоящего C getter, без JS mock ABI. */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +extern pid_t __real_getpid(void); +extern long __real_syscall(long number, ...); + +static int mode(const char *name) { + const char *value = getenv("MOTION_CLOCK_CHECK_MODE"); + return value != NULL && strcmp(value, name) == 0; +} + +int __wrap_clock_gettime(clockid_t clock, struct timespec *value) { + value->tv_sec = 9007199254740993LL; + value->tv_nsec = 17; + if (clock != CLOCK_THREAD_CPUTIME_ID) { errno = EINVAL; return -1; } + if (mode("read-errno")) { errno = EIO; return -1; } + if (mode("negative-seconds")) value->tv_sec = -1; + if (mode("negative-nanoseconds")) value->tv_nsec = -1; + if (mode("overflow-nanoseconds")) value->tv_nsec = 1000000000L; + return 0; +} + +int __wrap_clock_getres(clockid_t clock, struct timespec *value) { + value->tv_sec = 0; + value->tv_nsec = 1; + if (clock != CLOCK_THREAD_CPUTIME_ID) { errno = EINVAL; return -1; } + if (mode("resolution-errno")) { errno = EIO; return -1; } + if (mode("zero-resolution")) value->tv_nsec = 0; + return 0; +} + +pid_t __wrap_getpid(void) { return mode("negative-pid") ? -1 : __real_getpid(); } +long __wrap_syscall(long number, ...) { + if (number != SYS_gettid) { errno = EINVAL; return -1; } + return mode("negative-tid") ? -1 : __real_syscall(number); +} diff --git a/test/journey-package-consumers.test.ts b/test/journey-package-consumers.test.ts index 7f5e60109..48b90c7da 100644 --- a/test/journey-package-consumers.test.ts +++ b/test/journey-package-consumers.test.ts @@ -10,10 +10,11 @@ type Packed = { readonly root: string; readonly tarball: string; readonly sha256 function packOnce( runPack: (root: string) => string = (root) => execFileSync('npm', [ - 'pack', '--ignore-scripts', '--json', '--pack-destination', root, - ], { cwd: resolve('.'), encoding: 'utf8', timeout: 30_000 }), + 'pack', '--ignore-scripts', '--json', '--pack-destination', process.platform === 'win32' ? `"${root}"` : root, + ], { cwd: resolve('.'), encoding: 'utf8', timeout: 30_000, shell: process.platform === 'win32' }), ): Packed { - const root = mkdtempSync(join(tmpdir(), 'journey-direct-package-')); + // Пробел выявляет потерю границы аргумента в Windows shell. + const root = mkdtempSync(join(tmpdir(), 'journey direct package-')); try { const packed = JSON.parse(runPack(root)) as Array<{ filename: string }>; expect(packed).toHaveLength(1); diff --git a/test/journey-package-tuple.test.ts b/test/journey-package-tuple.test.ts new file mode 100644 index 000000000..c74dc0807 --- /dev/null +++ b/test/journey-package-tuple.test.ts @@ -0,0 +1,30 @@ +import { createHash } from 'node:crypto'; +import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { join, resolve } from 'node:path'; +import { expect, it } from 'vitest'; + +const root = resolve('.'); +const digest = (bytes: Buffer) => createHash('sha256').update(bytes).digest('hex'); + +it('scope journeys устанавливают заданные байты tgz, включая отличие от checkout той же версии', async () => { + mkdirSync(join(root, 'work'), { recursive: true }); + const work = mkdtempSync(join(root, 'work', 'journey tuple ')); + try { + const { packScopeRecipePackage } = await import('../browser/fixtures/scope-recipes.mjs'); + const initial = packScopeRecipePackage(root, join(work, 'initial consumer')); + const entry = join(initial.packageRoot, 'dist/smart/index.js'); + const marker = '\nexport const suppliedJourneyMarker = "actual-supplied-tarball";\n'; + writeFileSync(entry, readFileSync(entry, 'utf8') + marker); + const destination = join(work, 'supplied archive'); + mkdirSync(destination); + const packed = packScopeRecipePackage(initial.packageRoot, destination); + const supplied = packed.tarball; + const expected = digest(readFileSync(supplied)); + expect(expected).not.toBe(initial.receipt.tarball.sha256); + const consumer = packScopeRecipePackage(root, join(work, 'supplied consumer'), supplied); + expect(consumer.receipt.tarball.sha256).toBe(expected); + expect(readFileSync(join(consumer.packageRoot, 'dist/smart/index.js'), 'utf8')).toContain(marker); + expect(digest(readFileSync(join(consumer.packageRoot, 'package.json')))) + .toBe(consumer.receipt.manifest.sha256); + } finally { rmSync(work, { recursive: true, force: true }); } +}, 120_000); diff --git a/test/journey-tuple-fence.test.ts b/test/journey-tuple-fence.test.ts new file mode 100644 index 000000000..f06885982 --- /dev/null +++ b/test/journey-tuple-fence.test.ts @@ -0,0 +1,71 @@ +import { createHash } from 'node:crypto'; +import { createServer } from 'node:http'; +import { once } from 'node:events'; +import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { join, resolve } from 'node:path'; +import { request } from '@playwright/test'; +import type { Page, TestInfo } from '@playwright/test'; +import { afterEach, expect, it, onTestFinished, vi } from 'vitest'; +import { verifyJourneyTuple } from '../browser/fixtures/journey-tuple'; + +const globalSetup = vi.hoisted(() => ({ archive: Buffer.alloc(0), reads: 0 })); +// Только readback Node-owner: ни один общий browser artifact тест не перезаписывает. +vi.mock('node:fs', async importOriginal => { + const actual = await importOriginal(); + return { ...actual, readFileSync(path: Parameters[0], ...args: any[]) { + if (path instanceof URL && path.pathname.endsWith('/browser/.artifacts/compositor-follow-package.tgz')) { + globalSetup.reads++; return globalSetup.archive; + } + return (actual.readFileSync as any)(path, ...args); + } }; +}); + +afterEach(() => vi.unstubAllEnvs()); +const digest = (bytes: Buffer) => createHash('sha256').update(bytes).digest('hex'); + +it('default fence отклоняет coherent foreign HTTP tuple той же версии, сохраняя local healthy control', async () => { + vi.stubEnv('LAB_MOTION_TARBALL', ''); + const root = resolve('.'); + mkdirSync(join(root, 'work'), { recursive: true }); + const work = mkdtempSync(join(root, 'work', 'journey fence ')); + try { + const { packScopeRecipePackage } = await import('../browser/fixtures/scope-recipes.mjs'); + const local = packScopeRecipePackage(root, join(work, 'local')); + globalSetup.archive = readFileSync(local.tarball); globalSetup.reads = 0; + const entry = join(local.packageRoot, 'dist/smart/index.js'); + writeFileSync(entry, readFileSync(entry, 'utf8') + '\nexport const foreignTuple = true;\n'); + const foreign = packScopeRecipePackage(local.packageRoot, join(work, 'foreign')); + const foreignBytes = readFileSync(foreign.tarball); + expect(digest(foreignBytes)).not.toBe(digest(globalSetup.archive)); + let bytes = globalSetup.archive; + const bundle = Buffer.from('export const checkerFixture = true;'); + const hash = digest(bundle); + const server = createServer((req, res) => { + if (req.url?.endsWith('.tgz')) { res.end(bytes); return; } + if (req.url?.endsWith('.js')) { res.end(bundle); return; } + const archive = { sha256: digest(bytes), integrity: `sha512-${createHash('sha512').update(bytes).digest('base64')}` }; + const scope = { schema: 'scope-recipes-package-v1', package: local.receipt.package, tarball: archive, + bundleSha256: hash, recipesSha256: hash, motionInputs: ['dist/smart/index.js'], motionInputSha256: { 'dist/smart/index.js': hash } }; + const follow = { package: `${scope.package.name}@${scope.package.version}`, tarball: archive, + documentSha256: hash, outputs: [{ file: 'compositor-follow-recipes.js', sha256: hash }] }; + res.setHeader('Content-Type', 'application/json'); + res.end(JSON.stringify(req.url?.endsWith('scope-recipes.package.json') ? scope : follow)); + }); + onTestFinished(async () => { + if (server.listening) { server.close(); await once(server, 'close'); } + }); + server.listen(0, '127.0.0.1'); await once(server, 'listening'); + const address = server.address(); + if (!address || typeof address === 'string') throw new Error('HTTP fixture did not bind a port'); + const client = await request.newContext({ baseURL: `http://127.0.0.1:${address.port}` }); + try { + // Проверяется Node checker seam; этот тест не объявляет browser journey выполненным. + const page = { request: client, context: () => ({ browser: () => undefined }) } as unknown as Page; + const info = { annotations: [], project: { name: 'checker-seam' }, attach: async () => {} } as unknown as TestInfo; + await verifyJourneyTuple(page, info); + bytes = foreignBytes; + await expect(verifyJourneyTuple(page, info)).rejects.toThrow(); + expect(globalSetup.reads).toBe(2); + } finally { await client.dispose(); server.close(); await once(server, 'close'); } + } finally { rmSync(work, { recursive: true, force: true }); } +}, 120_000); diff --git a/test/motion-program-wire-v1.test.ts b/test/motion-program-wire-v1.test.ts index e20cf1efa..db60b442b 100644 --- a/test/motion-program-wire-v1.test.ts +++ b/test/motion-program-wire-v1.test.ts @@ -206,6 +206,60 @@ describe('MotionProgram V1 canonical wire', () => { expect(decodeMotionProgramV1(wire)[2]).toEqual([value]); }); + it.each([ + ['одиночная строка', [MOTION_PROGRAM_LIMITS_V1.maxStringCodeUnits + 1]], + ['сумма строк', [MOTION_PROGRAM_LIMITS_V1.maxStringCodeUnits, 1]], + ] as const)('отклоняет превышение code-unit бюджета до re-encode и следующих таблиц: %s', (_name, lengths) => { + const input = minimalProgramInput(); + const base = encodeMotionProgramV1(parseMotionProgramV1(input)); + const table = new Uint8Array(lengths.reduce((sum, length) => sum + 4 + length, 0)); + const tableView = new DataView(table.buffer); + let offset = 0; + for (let index = 0; index < lengths.length; index++) { + const length = lengths[index]!; + tableView.setUint32(offset, length, true); + table.fill(97 + index, offset + 4, offset + 4 + length); + offset += 4 + length; + } + const wire = replaceWireBytes(base, 18, 0, table); + new DataView(wire.buffer).setUint16(10, lengths.length, true); + + const encode = TextEncoder.prototype.encode; + const getFloat64 = DataView.prototype.getFloat64; + let reencodes = 0; + let floatReads = 0; + let error: unknown; + TextEncoder.prototype.encode = function (value) { + reencodes++; + return encode.call(this, value); + }; + DataView.prototype.getFloat64 = function (byteOffset, littleEndian) { + floatReads++; + return getFloat64.call(this, byteOffset, littleEndian); + }; + try { + decodeMotionProgramV1(wire); + } catch (caught) { + error = caught; + } finally { + TextEncoder.prototype.encode = encode; + DataView.prototype.getFloat64 = getFloat64; + } + expectIssue(() => { throw error; }, 'LMP_LIMIT'); + expect(reencodes).toBe(lengths.length - 1); + expect(floatReads).toBe(0); + }); + + it.each(['ascii', 'surrogate-pair'] as const)('сохраняет точную UTF-16 границу для %s', (kind) => { + const limit = MOTION_PROGRAM_LIMITS_V1.maxStringCodeUnits; + const value = kind === 'ascii' ? 'a'.repeat(limit) : '𠮷'.repeat(Math.floor(limit / 2)) + 'a'; + expect(value.length).toBe(limit); + const input = minimalProgramInput(); + input[2] = [value]; + const wire = encodeMotionProgramV1(parseMotionProgramV1(input)); + expect(decodeMotionProgramV1(wire)[2]).toEqual([value]); + }); + it('сохраняет пустую UTF-8 строку через raw(0)', () => { const input = validProgramInput(); (input[2] as unknown[])[0] = ''; diff --git a/test/motion-value-bounded-zero.test.ts b/test/motion-value-bounded-zero.test.ts new file mode 100644 index 000000000..5f5ff4766 --- /dev/null +++ b/test/motion-value-bounded-zero.test.ts @@ -0,0 +1,23 @@ +import { describe, expect, it } from 'vitest'; +import { MotionValue } from '../src/motion-value.js'; + +describe('MotionValue: сохранённая ориентация вырожденного bounded span', () => { + it.each([0, -0])('начальный signed zero %s сохраняется при отрицательном импульсе', initial => { + const queue: Array<(time?: number) => void> = []; + const value = new MotionValue({ + initial, initialVelocity: -1, + spring: { mass: 1, stiffness: 170, damping: 26 }, + requestFrame(callback) { queue.push(callback); return 1; }, + }); + value.setTarget(Object.is(initial, -0) ? 0 : -0); + queue.shift()!(0); + queue.shift()!(1); + // При равном span legacy from→target orientation остаётся неубывающей. + // Положительный lower bound сохраняет +0; отрицательный допускает -0. + expect(Object.is(value.value, initial)).toBe(true); + expect(value.velocity).toBeLessThan(0); + value.destroy(); + for (const callback of queue.splice(0)) callback(2); + expect(queue).toHaveLength(0); + }); +}); diff --git a/test/motion-value-frame-delivery.test.ts b/test/motion-value-frame-delivery.test.ts new file mode 100644 index 000000000..fac2a49eb --- /dev/null +++ b/test/motion-value-frame-delivery.test.ts @@ -0,0 +1,30 @@ +import { expect, it } from 'vitest'; +import { MotionValue } from '../src/index.js'; + +it('одна заявка кадра не размножает цикл при повторной доставке', () => { + const queue: Array<(timestamp?: number) => void> = []; + const value = new MotionValue({ + initial: 0, + spring: { mass: 1, stiffness: 200, damping: 20 }, + requestFrame(callback) { queue.push(callback); return 1; }, + }); + let emissions = 0; + value.onChange(() => emissions++); + value.setTarget(1); + const delivered = queue.shift()!; + delivered(); + const snapshot = [value.value, value.velocity, emissions]; + try { + // Повтор старой заявки не заменяет отдельную заявку следующего кадра. + delivered(); + expect([value.value, value.velocity, emissions]).toEqual(snapshot); + expect(queue).toHaveLength(1); + queue.shift()!(); + expect(value.value).toBeGreaterThan(snapshot[0]!); + expect(emissions).toBe(snapshot[2]! + 1); + expect(queue).toHaveLength(1); + } finally { + value.destroy(); + for (const callback of queue) callback(); + } +}); diff --git a/test/motion-value-listener-isolation.test.ts b/test/motion-value-listener-isolation.test.ts index 0c52ea1f2..5cee6a558 100644 --- a/test/motion-value-listener-isolation.test.ts +++ b/test/motion-value-listener-isolation.test.ts @@ -104,9 +104,8 @@ describe('MotionValue: изоляция ошибок слушателей', () = expect(second).toHaveBeenCalledTimes(2); }); - it('сохраняет listener-ошибку первичной, если перепланирование тоже бросило', () => { + it.each([undefined, null, false, 0, '', { source: 'listener' }])('сохраняет listener-ошибку %s первичной, если перепланирование тоже бросило', (listenerFailure) => { const queue: Array<(ts?: number) => void> = []; - const listenerFailure = { source: 'listener' }; const schedulerFailure = { source: 'scheduler' }; let requests = 0; let time = 0; @@ -126,8 +125,10 @@ describe('MotionValue: изоляция ошибок слушателей', () = armed = true; value.setTarget(100); + let didThrow = false; let thrown: unknown; - try { drain(); } catch (error) { thrown = error; } + try { drain(); } catch (error) { didThrow = true; thrown = error; } + expect(didThrow).toBe(true); expect(thrown).toBe(listenerFailure); expect(queue).toHaveLength(0); @@ -139,9 +140,8 @@ describe('MotionValue: изоляция ошибок слушателей', () = expect(value.value).toBeCloseTo(25, 5); }); - it('выбрасывает scheduler-ошибку, если более ранней listener-ошибки нет', () => { + it.each([undefined, null, false, 0, '', { source: 'scheduler' }])('выбрасывает scheduler-ошибку %s, если более ранней listener-ошибки нет', (schedulerFailure) => { const queue: Array<(ts?: number) => void> = []; - const schedulerFailure = { source: 'scheduler' }; let requests = 0; let time = 0; const requestFrame = (callback: (ts?: number) => void): number => { @@ -157,8 +157,10 @@ describe('MotionValue: изоляция ошибок слушателей', () = const value = new MotionValue({ initial: 0, spring: SPRING, requestFrame }); value.setTarget(100); + let didThrow = false; let thrown: unknown; - try { drain(); } catch (error) { thrown = error; } + try { drain(); } catch (error) { didThrow = true; thrown = error; } + expect(didThrow).toBe(true); expect(thrown).toBe(schedulerFailure); value.setTarget(25); diff --git a/test/motion-value-reentrant-start.test.ts b/test/motion-value-reentrant-start.test.ts new file mode 100644 index 000000000..4d9506e1a --- /dev/null +++ b/test/motion-value-reentrant-start.test.ts @@ -0,0 +1,254 @@ +import { describe, expect, it, vi } from 'vitest'; +import { MotionValue } from '../src/index.js'; + +const SPRING = { mass: 1, stiffness: 200, damping: 20 }; + +function makeClock(syncSuccessor = false) { + const queue: Array<(timestamp?: number) => void> = []; + const delivered = new Set(); + let requests = 0; + return { + requestFrame(callback: (timestamp?: number) => void): number { + const handle = ++requests; + const once = (timestamp?: number): void => { + expect(delivered.has(handle)).toBe(false); + delivered.add(handle); + callback(timestamp); + }; + if (syncSuccessor && handle === 2) once(); + else queue.push(once); + return handle; + }, + next(): void { + expect(queue.length).toBeGreaterThan(0); + queue.shift()!(); + }, + drain(): void { + let frames = 0; + while (queue.length > 0) { + expect(++frames).toBeLessThan(1000); + this.next(); + } + }, + pending: () => queue.length, + requests: () => requests, + }; +} + +describe('MotionValue: guard принадлежит текущему запуску', () => { + it.each([[false, 0], [true, 0], [false, 5e-11], [true, 5e-11]] as const)( + 'возврат к достигнутой цели отзывает ожидающий кадр (clamp=%s, v0=%s)', (clamp, initialVelocity) => { + const clock = makeClock(); + const value = new MotionValue({ + initial: 0, initialVelocity, spring: SPRING, + clamp, requestFrame: clock.requestFrame, + }); + const emissions: number[] = []; + value.onChange(current => emissions.push(current)); + value.setTarget(100); + value.setTarget(0); + + expect([value.value, value.velocity]).toEqual([0, 0]); + expect(emissions).toEqual([0]); + clock.next(); + expect([value.value, value.velocity]).toEqual([0, 0]); + expect(emissions).toEqual([0]); + expect(clock.pending()).toBe(0); + + value.setTarget(100); + clock.next(); + expect(value.value).toBeGreaterThan(0); + clock.drain(); + expect([value.value, value.velocity]).toEqual([100, 0]); + value.destroy(); + }); + + it.each([100, -50])('цель %s из getter сохраняет только согласованный кадр и живой цикл', (target) => { + const clock = makeClock(); + let armed = false; + const value: MotionValue = new MotionValue({ + initial: 0, clamp: false, requestFrame: clock.requestFrame, + spring: { + get mass() { + if (armed) { armed = false; value.setTarget(target); } + return 1; + }, + stiffness: 200, damping: 20, + }, + }); + const emissions: number[] = []; + value.onChange(current => emissions.push(current)); + value.setTarget(100); + clock.next(); + const before = [value.value, value.velocity]; + const emitted = emissions.length; + armed = true; + clock.next(); + + if (target === 100) { + // Повтор цели не меняет траекторию и не должен съедать здоровый кадр. + expect(value.value).toBeGreaterThan(before[0]!); + expect(emissions).toHaveLength(emitted + 1); + } else { + expect([value.value, value.velocity]).toEqual(before); + expect(emissions).toHaveLength(emitted); + } + expect(clock.pending()).toBe(1); + clock.drain(); + expect([value.value, value.velocity]).toEqual([target, 0]); + expect(clock.pending()).toBe(0); + value.destroy(); + }); + + it.each(['getter', 'listener'] as const)( + 'сохраняет one-shot кадр преемника из %s после возврата requestFrame', + (site) => { + vi.useFakeTimers(); + const clock = makeClock(); + let value: MotionValue | undefined; + let control: MotionValue | undefined; + let armed = false; + let origin: [number, number] | undefined; + const handoff = (): void => { + if (!armed) return; + armed = false; + origin = [value!.value, value!.velocity]; + value!.stop(); + value!.setTarget(2); + // requestFrame уже вернулся; callback всё ещё вызывается на стеке старого tick. + clock.next(); + }; + const params = { + get mass() { if (site === 'getter') handoff(); return 1; }, + stiffness: 200, + damping: 20, + }; + try { + value = new MotionValue({ initial: 0, spring: params, requestFrame: clock.requestFrame }); + value.onChange(() => { if (site === 'listener') handoff(); }); + value.setTarget(1); + armed = true; + clock.next(); + + expect(origin).toBeDefined(); + expect(clock.pending()).toBe(1); + expect(vi.getTimerCount()).toBe(0); + const requests = clock.requests(); + value.setTarget(2); + expect(clock.requests()).toBe(requests); + + // Отдельный запуск из того же snapshot проверяет sample после shared-scratch reentry. + const referenceClock = makeClock(); + control = new MotionValue({ + initial: origin![0], initialVelocity: origin![1], spring: SPRING, + requestFrame: referenceClock.requestFrame, + }); + control.setTarget(2); + referenceClock.next(); + expect([value.value, value.velocity]).toEqual([control.value, control.velocity]); + control.destroy(); + referenceClock.drain(); + + clock.drain(); + expect(value.value).toBe(2); + expect(value.velocity).toBe(0); + expect(clock.pending()).toBe(0); + } finally { + control?.destroy(); + value?.destroy(); + vi.clearAllTimers(); + vi.useRealTimers(); + } + }, + ); + + it.each(['getter', 'listener'] as const)( + 'сохраняет trampoline, если преемник из %s вызван внутри requestFrame', + (site) => { + vi.useFakeTimers(); + const clock = makeClock(true); + let value: MotionValue | undefined; + let armed = false; + const handoff = (): void => { + if (!armed) return; + armed = false; + value!.stop(); + value!.setTarget(2); + }; + try { + value = new MotionValue({ + initial: 0, + spring: { + get mass() { if (site === 'getter') handoff(); return 1; }, + stiffness: 200, damping: 20, + }, + requestFrame: clock.requestFrame, + }); + value.onChange(() => { if (site === 'listener') handoff(); }); + value.setTarget(1); + armed = true; + clock.next(); + expect(clock.pending()).toBe(0); + expect(vi.getTimerCount()).toBe(1); + vi.runAllTimers(); + expect(value.value).toBe(2); + expect(clock.requests()).toBe(2); + expect(vi.getTimerCount()).toBe(0); + } finally { + value?.destroy(); + vi.clearAllTimers(); + vi.useRealTimers(); + } + }, + ); + + it('final emit начинает преемника через тот же fresh-start owner', () => { + const clock = makeClock(); + const value = new MotionValue({ initial: 0, spring: SPRING, requestFrame: clock.requestFrame }); + let restarted = false; + let firstSuccessorValue = 0; + value.onChange(current => { + if (restarted || current !== 1 || value.velocity !== 0) return; + restarted = true; + value.setTarget(2); + clock.next(); + firstSuccessorValue = value.value; + expect(clock.pending()).toBe(1); + }); + value.setTarget(1); + clock.drain(); + expect(restarted).toBe(true); + expect(firstSuccessorValue).toBeGreaterThan(1); + expect(value.value).toBe(2); + value.destroy(); + }); + + it('тот же активный run сохраняет защиту от вложенной доставки callback', () => { + const queue: Array<() => void> = []; + let executing: (() => void) | undefined; + let armed = false; + const value = new MotionValue({ + initial: 0, + spring: { + get mass() { + if (armed) { armed = false; executing!(); } + return 1; + }, + stiffness: 200, damping: 20, + }, + requestFrame(callback) { queue.push(callback); return 1; }, + }); + let emissions = 0; + value.onChange(() => emissions++); + value.setTarget(1); + executing = queue.shift()!; + armed = true; + // Защитный сосед: этот host намеренно повторяет тот же callback внутри getter. + executing(); + expect(emissions).toBe(2); + expect(queue).toHaveLength(1); + value.destroy(); + queue.shift()!(); + expect(queue).toHaveLength(0); + }); +}); diff --git a/test/motion-value-terminal-sentinel.test.ts b/test/motion-value-terminal-sentinel.test.ts new file mode 100644 index 000000000..48b38479f --- /dev/null +++ b/test/motion-value-terminal-sentinel.test.ts @@ -0,0 +1,54 @@ +import { describe, expect, it, vi } from 'vitest'; +import { MotionValue, type RequestFrameFn } from '../src/motion-value.js'; +import { MotionParamError } from '../src/errors.js'; + +const spring = { mass: 1, stiffness: 170, damping: 26 }; + +describe('MotionValue: terminal scheduler-owner', () => { + it.each([0, false])('malformed scheduler %s не подменяет terminal и не обходит numeric validator', requestFrame => { + // JS consumer может передать неверный seam. Его поздний host failure не + // разрешает молча принять NaN как вызов уничтоженного контроллера. + const value = new MotionValue({ initial: 0, spring, requestFrame: requestFrame as unknown as RequestFrameFn }); + const listener = vi.fn(); + const off = value.onChange(listener); + expect(listener).toHaveBeenCalledWith(0); + expect(() => value.setTarget(Number.NaN)).toThrow(MotionParamError); + expect(() => value.snapTo(Number.POSITIVE_INFINITY)).toThrow(MotionParamError); + expect(() => value.setTarget(1)).toThrow(TypeError); + value.destroy(); + expect(() => value.setTarget(Number.NaN)).not.toThrow(); + const late = vi.fn(); + const lateOff = value.onChange(late); + off(); off(); lateOff(); lateOff(); + expect(late).not.toHaveBeenCalled(); + }); + + it('destroy из первичной доставки не оставляет подписку и поздний вызов ничего не доставляет', () => { + const value = new MotionValue({ initial: 0, spring }); + const off = value.onChange(() => value.destroy()); + const late = vi.fn(); + value.onChange(late); + off(); off(); + expect(late).not.toHaveBeenCalled(); + expect(value.value).toBe(0); + }); + + it.each([undefined, 0, false, Number.NaN])('сохраняет первый thrown value %s и доставляет соседям', first => { + const value = new MotionValue({ initial: 0, spring }); + let armed = false; + value.onChange(() => { if (armed) throw first; }); + value.onChange(() => { if (armed) throw new Error('later failure'); }); + const healthy = vi.fn(); + value.onChange(healthy); + armed = true; + let caught: unknown; + let failed = false; + try { value.snapTo(1); } catch (error) { failed = true; caught = error; } + expect(failed).toBe(true); + expect(Object.is(caught, first)).toBe(true); + expect(healthy).toHaveBeenLastCalledWith(1); + expect(() => value.snapTo(2)).not.toThrow(); + expect(healthy).toHaveBeenLastCalledWith(2); + value.destroy(); + }); +}); diff --git a/test/motion-value.test.ts b/test/motion-value.test.ts index 09ea6f61e..974c73be1 100644 --- a/test/motion-value.test.ts +++ b/test/motion-value.test.ts @@ -186,6 +186,51 @@ describe('MotionValue setTarget validation', () => { // ─── Suite A: destroy ──────────────────────────────────────────────────────── describe('MotionValue destroy', () => { + it('живой владелец наблюдает изменение исходных spring-параметров', () => { + const params = { mass: 1, stiffness: 200, damping: 20 }; + const actualClock = makeVirtualClock(); + const actual = new MotionValue({ initial: 0, spring: params, requestFrame: actualClock.requestFrame }); + params.stiffness = 300; + const expectedClock = makeVirtualClock(); + const expected = new MotionValue({ initial: 0, spring: { ...params }, requestFrame: expectedClock.requestFrame }); + actual.setTarget(100); + expected.setTarget(100); + actualClock.drain(5); + expectedClock.drain(5); + + expect(actual.value).toBe(expected.value); + expect(actual.velocity).toBe(expected.velocity); + actual.destroy(); + expected.destroy(); + }); + + it('destroy не читает spring getters и сохраняет последний value/velocity', () => { + let closed = false; + const params = { + get mass() { + if (closed) throw new Error('terminal spring read'); + return 2; + }, + stiffness: 240, + damping: 30, + }; + const clock = makeVirtualClock(); + const value = new MotionValue({ initial: 5, spring: params, requestFrame: clock.requestFrame }); + value.setTarget(100); + clock.drain(5); + const terminalValue = value.value; + const terminalVelocity = value.velocity; + closed = true; + + expect(() => value.destroy()).not.toThrow(); + expect(() => clock.drainAll()).not.toThrow(); + value.setTarget(12); + value.snapTo(9); + expect(value.value).toBe(terminalValue); + expect(value.velocity).toBe(terminalVelocity); + expect(clock.queueLength()).toBe(0); + }); + it('stops the animation loop after destroy()', () => { const clock = makeVirtualClock(); const mv = new MotionValue({ initial: 0, spring: STD_SPRING, requestFrame: clock.requestFrame }); @@ -206,10 +251,209 @@ describe('MotionValue destroy', () => { expect(() => mv.setTarget(100)).not.toThrow(); }); - it('onChange after destroy does not throw', () => { - const mv = new MotionValue({ initial: 0, spring: STD_SPRING }); + it('onChange после destroy не доставляет значение и возвращает инертную отписку', () => { + const mv = new MotionValue({ initial: 5, spring: STD_SPRING }); mv.destroy(); - expect(() => mv.onChange(() => {})).not.toThrow(); + const callback = vi.fn(() => { throw new Error('terminal callback'); }); + let off: (() => void) | undefined; + + expect(() => { off = mv.onChange(callback); }).not.toThrow(); + expect(callback).not.toHaveBeenCalled(); + expect(typeof off).toBe('function'); + expect(() => { off?.(); off?.(); }).not.toThrow(); + mv.setTarget(10); + mv.snapTo(9); + expect(callback).not.toHaveBeenCalled(); + expect(mv.value).toBe(5); + }); + + it.each(['mass', 'stiffness', 'damping'] as const)( + 'destroy из spring getter %s сохраняет последний value/velocity', + (field) => { + const clock = makeVirtualClock(); + const params = { ...STD_SPRING }; + const parameter = params[field]; + let armed = false; + let destroyed = 0; + let mv: MotionValue; + Object.defineProperty(params, field, { + get() { + if (armed) { + armed = false; + destroyed++; + mv.destroy(); + } + return parameter; + }, + }); + mv = new MotionValue({ initial: 5, spring: params, requestFrame: clock.requestFrame }); + const received: number[] = []; + mv.onChange((value) => received.push(value)); + mv.setTarget(100); + clock.drain(5); + const terminalValue = mv.value; + const terminalVelocity = mv.velocity; + const delivered = received.length; + armed = true; + + clock.drainAll(); + + expect(destroyed).toBe(1); + expect(mv.value).toBe(terminalValue); + expect(mv.velocity).toBe(terminalVelocity); + expect(received).toHaveLength(delivered); + expect(clock.queueLength()).toBe(0); + }, + ); + + it.each([ + ['handle=0', false, 0], + ['sync callback', true, 1], + ['sync callback и handle=0', true, 0], + ] as const)('destroy из requestFrame: %s не создаёт motion-owned timeout', (_, sync, handle) => { + vi.useFakeTimers(); + try { + let requests = 0; + let lateFrame: ((timestamp?: number) => void) | undefined; + const mv = new MotionValue({ + initial: 5, + initialVelocity: 2, + spring: STD_SPRING, + requestFrame: (callback) => { + requests++; + lateFrame = callback; + mv.destroy(); + if (sync) callback(1); + return handle; + }, + }); + const received: number[] = []; + mv.onChange((value) => received.push(value)); + + mv.setTarget(100); + + expect(requests).toBe(1); + expect(vi.getTimerCount()).toBe(0); + lateFrame?.(2); + expect(mv.value).toBe(5); + expect(mv.velocity).toBe(2); + expect(received).toEqual([5]); + expect(vi.getTimerCount()).toBe(0); + } finally { + vi.clearAllTimers(); + vi.useRealTimers(); + } + }); +}); + +describe('MotionValue: отозванные отписки', () => { + it.each([undefined, null, false, 0, '', new Error('first')])( + 'сохраняет первый throw %s и доставляет значение соседям', + (failure) => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + const received: number[] = []; + value.onChange((v) => { if (v !== 0) throw failure; }); + value.onChange((v) => { if (v !== 0) throw new Error('second'); }); + value.onChange((v) => received.push(v)); + let threw = false; + let actual: unknown; + try { + value.snapTo(10); + } catch (error) { + threw = true; + actual = error; + } + expect(threw).toBe(true); + expect(actual).toBe(failure); + expect(received).toEqual([0, 10]); + expect(() => value.snapTo(20)).not.toThrow(); + expect(received).toEqual([0, 10, 20]); + value.destroy(); + }, + ); + + it.each([undefined, null])('не сохраняет ошибочную регистрацию callback=%s после TypeError', (callback) => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + expect(() => value.onChange(callback as unknown as (v: number) => void)).toThrow(TypeError); + expect(() => value.snapTo(10)).not.toThrow(); + value.destroy(); + }); + + it('ошибка прежнего callback не отзывает его реентрантного преемника', () => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + const failure = new Error('retired listener failure'); + const received: number[] = []; + let armed = true; + let off = () => {}; + const callback = (v: number) => { + received.push(v); + if (v === 10 && armed) { + armed = false; + off(); + off = value.onChange(callback); + throw failure; + } + }; + off = value.onChange(callback); + expect(() => value.snapTo(10)).toThrow(failure); + value.snapTo(20); + expect(received).toContain(20); + off(); + value.destroy(); + }); + + it('повторная старая отписка не удаляет новую регистрацию того же callback', () => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + const received: number[] = []; + const callback = (v: number) => received.push(v); + const oldOff = value.onChange(callback); + oldOff(); + oldOff(); + const currentOff = value.onChange(callback); + oldOff(); + value.snapTo(10); + expect(received).toEqual([0, 0, 10]); + currentOff(); + value.snapTo(20); + expect(received).toEqual([0, 0, 10]); + value.destroy(); + }); + + it('дублирующая подписка доставляется один раз и снимается любым своим handle', () => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + const received: number[] = []; + const callback = (v: number) => received.push(v); + const first = value.onChange(callback); + const second = value.onChange(callback); + value.snapTo(10); + expect(received).toEqual([0, 0, 10]); + second(); + first(); + value.snapTo(20); + expect(received).toEqual([0, 0, 10]); + value.destroy(); + }); + + it('реентрантная отписка не пропускает соседа; destroy отзывает оставшийся handle', () => { + const value = new MotionValue({ initial: 0, spring: STD_SPRING }); + const firstValues: number[] = []; + const secondValues: number[] = []; + let firstOff = () => {}; + firstOff = value.onChange((v) => { + firstValues.push(v); + if (v === 10) firstOff(); + }); + const secondOff = value.onChange((v) => { + secondValues.push(v); + if (v === 20) value.destroy(); + }); + value.snapTo(10); + value.snapTo(20); + secondOff(); + secondOff(); + value.snapTo(30); + expect(firstValues).toEqual([0, 10]); + expect(secondValues).toEqual([0, 10, 20]); }); }); diff --git a/test/profile-measurement.test.ts b/test/profile-measurement.test.ts new file mode 100644 index 000000000..bc8c8ea8e --- /dev/null +++ b/test/profile-measurement.test.ts @@ -0,0 +1,304 @@ +import { describe, expect, it } from 'vitest'; +import { execFileSync, spawnSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { dirname, join } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { validateReplayedVector } from '../bench/profile/profile-measurement.mjs'; +import { PROFILE_01, unmeasuredCells, verifyPreregistration } from '../bench/profile/profile-01-preregistration.mjs'; +import { PREREG_OWN_PATHS, makeGit } from '../bench/profile/profile-git-proof.mjs'; + +function cleanPreregistrationFixture(directory: string) { + const root = fileURLToPath(new URL('../', import.meta.url)); + const frozenHead = execFileSync('git', ['--no-replace-objects', 'rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' }).trim(); + // Контекст берётся из точного коммита; новые байты двух CLI принадлежат этой + // проверке. Фиксируем их до создания клона и не копируем грязное дерево. + const candidateCli = new Set(['bench/profile/probe-profile-01.mjs', 'bench/profile/validate-profile-01.mjs']); + const readset = PREREG_OWN_PATHS.map((path) => ({ path, bytes: candidateCli.has(path) ? readFileSync(join(root, path)) + : execFileSync('git', ['--no-replace-objects', 'show', `${frozenHead}:${path}`], { cwd: root }) })); + const clone = join(directory, 'checkout'); + execFileSync('git', ['clone', '--quiet', '--no-hardlinks', '--no-checkout', root, clone], + { encoding: 'utf8', timeout: 30_000 }); + execFileSync('git', ['checkout', '--quiet', '--detach', PROFILE_01.productBase.sourceSha], { cwd: clone, timeout: 30_000 }); + for (const { path, bytes } of readset) { + mkdirSync(dirname(join(clone, path)), { recursive: true }); + writeFileSync(join(clone, path), bytes); + expect(createHash('sha256').update(readFileSync(join(clone, path))).digest('hex')) + .toBe(createHash('sha256').update(bytes).digest('hex')); + } + execFileSync('git', ['add', '--', ...PREREG_OWN_PATHS], { cwd: clone, timeout: 30_000 }); + execFileSync('git', ['-c', 'core.hooksPath=' + join(directory, 'no-hooks'), '-c', 'commit.gpgsign=false', + '-c', 'user.name=PROFILE test', '-c', 'user.email=profile@example.invalid', + 'commit', '--quiet', '-m', 'frozen prereg-only fixture'], { cwd: clone, timeout: 30_000 }); + const head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: clone, encoding: 'utf8' }).trim(); + const changed = execFileSync('git', ['diff', '--name-only', PROFILE_01.productBase.sourceSha, head], + { cwd: clone, encoding: 'utf8' }).trim().split('\n').filter(Boolean); + expect(changed.every((path) => PREREG_OWN_PATHS.includes(path))).toBe(true); + expect(execFileSync('git', ['status', '--porcelain'], { cwd: clone, encoding: 'utf8' })).toBe(''); + return { clone, head }; +} + +describe('PROFILE: происхождение подтверждает настоящий Git', () => { + it('различает clean, tracked/untracked drift, ancestry и недоступное доказательство', () => { + const directory = mkdtempSync(join(tmpdir(), 'motion-profile-git-')); + const git = (...args: string[]) => execFileSync('git', args, { + cwd: directory, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10_000, + }).trim(); + const proof = makeGit((message: string) => { throw new Error(message); }); + try { + git('init', '--quiet'); + git('config', 'core.autocrlf', 'false'); + git('config', 'core.hooksPath', join(directory, 'no-hooks')); + const commit = () => { + git('add', '.'); + git('-c', 'user.name=PROFILE test', '-c', 'user.email=profile@example.invalid', '-c', 'commit.gpgsign=false', + 'commit', '--quiet', '-m', 'fixture'); + return git('rev-parse', 'HEAD'); + }; + writeFileSync(join(directory, 'source.txt'), 'first\n'); + const base = commit(); + expect(proof.head(directory)).toBe(base); + const originalBlob = createHash('sha1').update('blob 6\0first\n').digest('hex'); + expect(proof.blob(directory, base, 'source.txt')).toBe(originalBlob); + expect(proof.workingBlob(directory, 'source.txt')).toBe(originalBlob); + writeFileSync(join(directory, 'source.txt'), 'second\n'); + expect(() => proof.head(directory)).toThrow(); + expect(proof.workingBlob(directory, 'source.txt')).not.toBe(originalBlob); + const head = commit(); + expect(proof.head(directory)).toBe(head); + expect(proof.diffNames(directory, base, head)).toEqual(['source.txt']); + expect(proof.ancestor(directory, base)).toBe(true); + git('checkout', '--quiet', '--detach', base); + expect(proof.ancestor(directory, head)).toBe(false); + writeFileSync(join(directory, 'untracked.txt'), 'drift\n'); + expect(() => proof.head(directory)).toThrow(); + expect(() => proof.blob(directory, base, 'missing.txt')).toThrow(); + expect(() => proof.workingBlob(directory, 'missing.txt')).toThrow(); + expect(() => proof.diffNames(directory, 'missing-revision', head)).toThrow(); + expect(() => proof.head(join(directory, 'missing-directory'))).toThrow(); + } finally { + rmSync(directory, { recursive: true, force: true }); + } + }, 30_000); + + it('old-vector сохраняет отказ измерения, когда в clean clone нет инструментов', () => { + const directory = mkdtempSync(join(tmpdir(), 'motion-profile-missing-tools-')); + try { + // Отсутствие инструментов проверяется после происхождения. Текущая ветка + // меняет runtime и правильно отвергается раньше: не расширяем список + // исключений, а создаём разрешённую фикстуру регистрации над PRODUCT_BASE. + const { clone, head: sourceHead } = cleanPreregistrationFixture(directory); + const run = spawnSync(process.execPath, [ + 'bench/profile/probe-profile-01.mjs', '--mode', 'old-vector', '--cells', 'all', + '--out', join(directory, 'raw'), + ], { cwd: clone, encoding: 'utf8', timeout: 30_000 }); + expect(run.status, run.stderr).toBe(1); + const receipt = JSON.parse(run.stdout.trim()); + const raw = readFileSync(receipt.rawPath); + const artifact = JSON.parse(raw.toString('utf8')); + expect(artifact.head).toBe(sourceHead); + expect(artifact.admission).toBe('NOT-GRANTED'); + expect(artifact.rejection).toContain('незавершённое измерение'); + expect(artifact.rejection).toMatch(/не установлен|не создала обязательный|сборка/); + expect(artifact.costVector).toBeNull(); + expect(artifact.cellsMeasured).toEqual([]); + expect(artifact.cellsUnproven).toEqual(unmeasuredCells('all')); + expect(receipt.rawDigest).toBe(createHash('sha256').update(raw).digest('hex')); + const refusal = spawnSync(process.execPath, ['bench/profile/validate-profile-01.mjs', '--raw', receipt.rawPath], + { cwd: clone, encoding: 'utf8', timeout: 30_000 }); + expect(refusal.status, refusal.stderr).toBe(0); + expect(JSON.parse(refusal.stdout.trim()).verification).toBe('recorded-refusal-only'); + } finally { + rmSync(directory, { recursive: true, force: true }); + } + }, 90_000); +}); + +describe('PROFILE: замороженный протокол проверяется целиком', () => { + it('исполняемый size-gate сохраняет все потолки зарегистрированного baseline', async () => { + const gate = await import('../scripts/size-gate.mjs'); + const registered = PROFILE_01.oldCostVectorGzipBytes; + // Новые opt-in клетки не дописываются в исторический baseline. Каждый его + // ключ и точный потолок остаются обязательными в текущем измерителе. + expect(gate.BESPOKE_SUBPATH_GATES).toMatchObject(registered.bespoke); + expect(Object.fromEntries( + gate.IMPORT_COST_SCENARIOS.map(({ name, gate: ceiling }) => [name, ceiling]), + )).toMatchObject(registered.scenarios); + expect(registered.core).toBe(gate.CORE_GATE_BYTES); + expect(registered.subpath).toBe(gate.SUBPATH_GATE_BYTES); + expect(registered.fullCoreConsumer).toBe(gate.FULL_CORE_CONSUMER_GATE_BYTES); + expect(registered.nano).toBe(gate.NANO_GATE_BYTES); + expect(registered.compiledRuntime).toBe(gate.BESPOKE_SUBPATH_GATES['./compiler/runtime']); + expect(registered.compilerSurface).toBe(gate.BESPOKE_SUBPATH_GATES['./compiler/surface']); + expect(registered.inView).toBe(gate.IN_VIEW_GATE_BYTES); + expect(registered.inViewConsumer).toBe(gate.IN_VIEW_CONSUMER_GATE_BYTES); + expect(registered.compositorCapability).toBe(gate.COMPOSITOR_CAPABILITY_GATE_BYTES); + expect(registered.fullAnimate).toBe(gate.FULL_ANIMATE_GATE_BYTES); + expect(registered.animateCompositorMixed).toBe(gate.ANIMATE_COMPOSITOR_MIXED_GATE_BYTES); + }); + + it('принимает независимую JSON-копию полного протокола', () => { + expect(verifyPreregistration()).toBe(true); + expect(verifyPreregistration(JSON.parse(JSON.stringify(PROFILE_01)))).toBe(true); + }); + + it.each([ + ['productBase', 'reason'], ['scenes', 'm05a', 'acceptance'], + ['rawControls', 'aa'], ['statsMde', 'sampleSize'], ['calibration', 'failClosed'], + ])('отвергает подмену условия %s.%s', (...path) => { + const changed = JSON.parse(JSON.stringify(PROFILE_01)); + const parent = path.slice(0, -1).reduce((object, key) => object[key], changed); + parent[path.at(-1)!] = 'условие удалено'; + expect(() => verifyPreregistration(changed)).toThrow(); + }); + + it('отвергает потерю, подмену и лишние поля на каждой глубине', () => { + function visit(value: unknown, path: string[] = []) { + if (value === null || typeof value !== 'object') return; + for (const [key, child] of Object.entries(value)) { + const childPath = [...path, key]; + for (const operation of ['delete', 'replace']) { + const changed = JSON.parse(JSON.stringify(PROFILE_01)); + const parent = path.reduce((object, segment) => object[segment], changed); + if (operation === 'delete') delete parent[key]; + else parent[key] = typeof child === 'string' ? `${child}!` : 'другой тип'; + expect(() => verifyPreregistration(changed), `${operation} ${childPath.join('.')}`).toThrow(); + } + visit(child, childPath); + } + const extra = JSON.parse(JSON.stringify(PROFILE_01)); + const parent = path.reduce((object, key) => object[key], extra); + parent.unregistered = true; + expect(() => verifyPreregistration(extra), `extra ${path.join('.')}`).toThrow(); + } + visit(PROFILE_01); + for (const invalid of [null, [], '', 1, true]) { + expect(() => verifyPreregistration(invalid)).toThrow(); + } + }); + + it('не позволяет мутировать вложенные массивы исходного протокола', () => { + expect(() => PROFILE_01.roster.classes[0].browsers.push('подмена')).toThrow(); + expect(PROFILE_01.roster.classes[0].browsers).toEqual(['chromium-webview-stable']); + }); +}); + +function measured() { + return { + exitCode: 0, + entries: { rows: [{ label: '.', gzBytes: 42, gate: 100 }], hasWarnings: false }, + scenarios: [{ name: 'only-spring', gzBytes: 7, totalGzBytes: 7, gate: 10 }], + provenance: { + revision: 'a'.repeat(40), trackedRevisionSha256: 'b'.repeat(64), + inputs: { 'root/pnpm-lock.yaml': 'c'.repeat(64) }, + distRuntime: { sha256: 'd'.repeat(64), files: 2 }, + environment: { node: 'v24.15.0', pnpm: '11.11.0' }, + builtAt: '2026-09-30T00:00:00Z', + }, + }; +} + +describe('PROFILE: записанный успех не заменяет независимый результат', () => { + it('принимает воспроизведённые данные с новым временем сборки', () => { + const replayed = measured(); + replayed.provenance.builtAt = '2026-09-30T00:01:00Z'; + expect(() => validateReplayedVector(measured(), replayed)).not.toThrow(); + }); + + it('отвергает старую подделку из имён сценариев и exit 0', () => { + const forged = { exitCode: 0, transcript: 'only-spring size-gate: PASS' }; + expect(() => validateReplayedVector(forged, measured())).toThrow('структурированные измерения'); + }); + + it('отвергает отказ повторного измерения при записанном успехе', () => { + expect(() => validateReplayedVector(measured(), { ...measured(), exitCode: 1 })).toThrow('независимое измерение'); + }); + + it('не повышает сохранённый отказ до успеха', () => { + expect(() => validateReplayedVector({ ...measured(), exitCode: 1 }, measured())).toThrow('независимое измерение'); + }); + + it('ловит подмену числа при сохранённом PASS и неизменных названиях', () => { + const forged = measured(); + forged.scenarios[0].gzBytes = 1; + expect(() => validateReplayedVector(forged, measured())).toThrow('scenarios'); + }); + + it('ловит удалённый consumer и лишний неподтверждённый entry', () => { + const missing = measured(); + missing.scenarios = []; + expect(() => validateReplayedVector(missing, measured())).toThrow(); + const extra = measured(); + extra.entries.rows.push({ label: './extra', gzBytes: 1, gate: 100 }); + expect(() => validateReplayedVector(extra, measured())).toThrow('entries'); + }); + + it.each(['revision', 'trackedRevisionSha256', 'inputs', 'distRuntime', 'environment'])('отвергает другой %s', (field) => { + const forged = measured(); + Reflect.set(forged.provenance, field, 'forged'); + expect(() => validateReplayedVector(forged, measured())).toThrow(`provenance.${field}`); + }); + + it('размерный прогон оставляет все device/timing клетки непроверенными', () => { + expect(unmeasuredCells('desktop').map((row: { cell: string }) => row.cell)).toEqual([ + 'desktop-chromium', 'desktop-firefox', 'desktop-webkit', 'whole-page energy/GPU', + ]); + expect(unmeasuredCells('all').map((row: { cell: string }) => row.cell)).toEqual([ + 'android-mid-60', 'android-mid-120', 'ios-60', 'ios-120', + 'desktop-chromium', 'desktop-firefox', 'desktop-webkit', 'whole-page energy/GPU', + ]); + expect(() => unmeasuredCells('unknown')).toThrow(); + }); + + it('хеш реального failure-артефакта покрывает отступы, Unicode и конечный LF', () => { + const directory = mkdtempSync(join(tmpdir(), 'motion-profile-digest-')); + try { + const { clone, head } = cleanPreregistrationFixture(directory); + const run = spawnSync(process.execPath, [ + 'bench/profile/probe-profile-01.mjs', '--mode', 'aa', '--out', join(directory, 'raw'), + ], { cwd: clone, encoding: 'utf8', timeout: 15_000 }); + expect(run.status, run.stderr).toBe(1); + const receipt = JSON.parse(run.stdout.trim()); + const raw = readFileSync(receipt.rawPath); + const artifact = JSON.parse(raw.toString('utf8')); + expect(artifact.head).toBe(head); + expect(artifact.admission).toBe('NOT-GRANTED'); + expect(artifact.rejection).toContain('browser-калибровки'); + expect(raw.toString('utf8')).toContain('\n "node"'); + expect(raw.at(-1)).toBe(10); + expect(receipt.rawDigest).toBe(createHash('sha256').update(raw).digest('hex')); + } finally { + rmSync(directory, { recursive: true, force: true }); + } + }, 20_000); +}); + +describe('PROFILE: ошибка операнда CLI не создаёт артефакт', () => { + it.each([ + { script: 'probe-profile-01.mjs', args: ['--mode'] }, + { script: 'probe-profile-01.mjs', args: ['--mode', '--out', 'raw'] }, + { script: 'probe-profile-01.mjs', args: ['--mode', 'aa', '--cells'] }, + { script: 'probe-profile-01.mjs', args: ['--mode', 'aa', '--cells', '--out', 'raw'] }, + { script: 'probe-profile-01.mjs', args: ['--mode', 'aa', '--out'] }, + { script: 'probe-profile-01.mjs', args: ['--out', '--mode', 'aa'] }, + { script: 'probe-profile-01.mjs', args: ['--mode', 'aa', '--out', ''] }, + { script: 'probe-profile-01.mjs', args: ['--mode', 'aa', '--out', 'raw', '--out'] }, + { script: 'validate-profile-01.mjs', args: ['--raw'] }, + { script: 'validate-profile-01.mjs', args: ['--raw', '--mode'] }, + { script: 'validate-profile-01.mjs', args: ['--raw', ''] }, + { script: 'validate-profile-01.mjs', args: ['--raw', 'raw.json', '--raw'] }, + ])('$script $args', ({ script, args }) => { + const directory = mkdtempSync(join(tmpdir(), 'motion-profile-cli-')); + try { + const root = fileURLToPath(new URL('../', import.meta.url)); + const run = spawnSync(process.execPath, [join(root, 'bench/profile', script), ...args], + { cwd: directory, encoding: 'utf8', timeout: 15_000, env: { ...process.env, TMPDIR: directory } }); + expect(run.status, run.stderr).toBe(1); + expect(run.stdout).toBe(''); + expect(run.stderr).toMatch(/флаг --(?:mode|cells|out|raw) требует значение/); + expect(readdirSync(directory)).toEqual([]); + expect(existsSync(join(directory, 'profile-01-raw'))).toBe(false); + } finally { rmSync(directory, { recursive: true, force: true }); } + }); +}); diff --git a/test/resource-actual-package-retention.test.ts b/test/resource-actual-package-retention.test.ts index 5adac082d..efd72f28e 100644 --- a/test/resource-actual-package-retention.test.ts +++ b/test/resource-actual-package-retention.test.ts @@ -1,230 +1,148 @@ import { execFileSync } from 'node:child_process'; -import { - copyFileSync, - mkdirSync, - mkdtempSync, - readFileSync, - readdirSync, - rmSync, - symlinkSync, - writeFileSync, -} from 'node:fs'; +import { createHash } from 'node:crypto'; +import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; import { tmpdir } from 'node:os'; import { dirname, join, resolve } from 'node:path'; import { fileURLToPath } from 'node:url'; -import { expect, it } from 'vitest'; +import { afterAll, beforeAll, describe, expect, it } from 'vitest'; const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..'); -const PACKAGE = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')) as { name: string }; -const PACKAGE_COMMAND_TIMEOUT_MS = 30_000; -const PROBE_TIMEOUT_MS = 20_000; +// Архив пакета, сведения о сборке, точный скрипт и журналы сохраняют воспроизводимость, +// включая неудачные прогоны. r11 G-PERF §4/§6 защищает ошибки и единственную копию доказательств. +const EVIDENCE = join(ROOT, 'scratchpad', 'resource-evidence'); const WINDOWS_SHELL = process.platform === 'win32'; -const TSUP_CLI = join(ROOT, 'node_modules', 'tsup', 'dist', 'cli-default.js'); -const RESOURCE_RUNTIME_EXPORTS = ['./frame', './compositor'] as const; - -function copyTrackedSource(target: string): void { - const tracked = execFileSync('git', ['ls-files', '-z'], { - cwd: ROOT, - encoding: 'utf8', - timeout: PACKAGE_COMMAND_TIMEOUT_MS, - }).split('\0').filter(Boolean); - for (const relative of tracked) { - const destination = join(target, relative); - mkdirSync(dirname(destination), { recursive: true }); - copyFileSync(join(ROOT, relative), destination); - } - symlinkSync( - join(ROOT, 'node_modules'), - join(target, 'node_modules'), - process.platform === 'win32' ? 'junction' : 'dir', - ); -} +const NPM = WINDOWS_SHELL ? 'npm.cmd' : 'npm'; +const shellPath = (value: string): string => WINDOWS_SHELL ? `"${value}"` : value; +const RUNTIME_FILES = [ + 'index', 'frame/index', 'compositor/index', 'bindings/index', + 'behaviors/index', 'behaviors/reorder/index', 'compositor/follow/index', + 'presence/index', 'animate/index', +].flatMap(entry => [`dist/${entry}.js`, `dist/${entry}.cjs`]); +const digest = (bytes: Buffer): string => createHash('sha256').update(bytes).digest('hex'); +const EXISTING_KINDS = [ + 'frame', 'motion-value', 'compositor-native', 'compositor-live', 'compositor-delay', + 'compositor-handoff', 'compositor-roundtrip', 'compositor-reduced-loans', 'binding', 'sheet', 'pager', + 'dismiss', 'pull', 'pull-pending', 'pull-settled', 'reorder', + 'follow-native', 'follow-pickup', 'follow-live', +]; +const ADDED_KINDS = ['presence-transition', 'animate-scope-main', 'animate-scope-native']; +const ownerNames = (kinds: string[]) => ['esm', 'cjs'].flatMap(format => kinds.map(owner => `${format}/${owner}`)); +const EXPECTED_OWNERS = ownerNames([...EXISTING_KINDS, ...ADDED_KINDS]); -function runInstalledPackageProbe(): string { - const work = mkdtempSync(join(tmpdir(), 'resource-actual-package-')); - try { - const source = join(work, 'source'); - mkdirSync(source); - copyTrackedSource(source); - // Собираем только два owner-entry и ниже сверяем их байты с полной production-сборкой. - const packagePath = join(source, 'package.json'); - const manifest = JSON.parse(readFileSync(packagePath, 'utf8')) as { - exports: Record; - }; - manifest.exports = Object.fromEntries(RESOURCE_RUNTIME_EXPORTS.map((key) => { - const value = manifest.exports[key]; - if (value === undefined) throw new Error(`resource proof: missing public export ${key}`); - return [key, value]; - })); - writeFileSync(packagePath, JSON.stringify(manifest, null, 2) + '\n'); - execFileSync(process.execPath, [TSUP_CLI], { - cwd: source, - stdio: 'pipe', - timeout: PACKAGE_COMMAND_TIMEOUT_MS, - }); - for (const relative of [ - 'frame/index.js', - 'frame/index.cjs', - 'compositor/index.js', - 'compositor/index.cjs', - ]) { - expect(readFileSync(join(source, 'dist', relative))).toEqual( - readFileSync(join(ROOT, 'dist', relative)), - ); - } - execFileSync('pnpm', ['pack', '--pack-destination', work], { - cwd: source, - stdio: 'pipe', - shell: WINDOWS_SHELL, - timeout: PACKAGE_COMMAND_TIMEOUT_MS, - }); - const tarball = readdirSync(work).find((file) => file.endsWith('.tgz')); - if (tarball === undefined) throw new Error('pnpm pack не создал tarball'); +describe('RESOURCE-01: реальные байты установленного production tarball', () => { + let work: string | undefined; + let app: string; + let entry: string; + let evidenceRun: string; - const app = join(work, 'consumer'); + beforeAll(() => { + mkdirSync(EVIDENCE, { recursive: true }); + evidenceRun = mkdtempSync(join(EVIDENCE, 'run-')); + work = mkdtempSync(join(tmpdir(), 'resource-actual-package-')); + const dirty = execFileSync('git', ['status', '--porcelain'], { cwd: ROOT, encoding: 'utf8' }).trim(); + const packed = JSON.parse(execFileSync(NPM, [ + 'pack', '--ignore-scripts', '--json', '--pack-destination', shellPath(work), + ], { cwd: ROOT, encoding: 'utf8', shell: WINDOWS_SHELL, timeout: 30_000 })) as Array<{ filename: string }>; + expect(packed).toHaveLength(1); + const tarball = join(work, packed[0]!.filename); + copyFileSync(tarball, join(evidenceRun, 'package.tgz')); + app = join(work, 'consumer'); mkdirSync(app); - writeFileSync(join(app, 'package.json'), JSON.stringify({ - name: 'resource-retention-consumer', - private: true, - type: 'module', + writeFileSync(join(app, 'package.json'), '{"name":"resource-retention-consumer","private":true,"type":"module"}\n'); + execFileSync(NPM, ['install', '--ignore-scripts', '--no-audit', '--no-fund', shellPath(tarball)], { + cwd: app, stdio: 'pipe', shell: WINDOWS_SHELL, timeout: 30_000, + }); + const installed = join(app, 'node_modules', '@labpics', 'motion'); + // Полный manifest и runtime readback связывают proof с доставляемым tuple; + // исходники, source aliases и урезанная export-map здесь не участвуют. + expect(readFileSync(join(installed, 'package.json'))).toEqual(readFileSync(join(ROOT, 'package.json'))); + const files = Object.fromEntries(RUNTIME_FILES.map(relative => { + const actual = readFileSync(join(installed, relative)); + expect(actual).toEqual(readFileSync(join(ROOT, relative))); + return [relative, digest(actual)]; })); - execFileSync( - 'npm', - ['install', '--ignore-scripts', '--no-audit', '--no-fund', join(work, tarball)], - { - cwd: app, - stdio: 'pipe', - shell: WINDOWS_SHELL, - timeout: PACKAGE_COMMAND_TIMEOUT_MS, - }, - ); - - const frameSpecifier = `${PACKAGE.name}/frame`; - const compositorSpecifier = `${PACKAGE.name}/compositor`; - const probe = ` -import assert from 'node:assert/strict'; -import { createRequire } from 'node:module'; -import { setImmediate } from 'node:timers/promises'; + writeFileSync(join(evidenceRun, 'package-tuple.json'), JSON.stringify({ + node: process.version, platform: process.platform, + head: execFileSync('git', ['rev-parse', 'HEAD'], { cwd: ROOT, encoding: 'utf8' }).trim(), + dirty, + tarballSha256: digest(readFileSync(tarball)), installedRuntimeSha256: files, + fixtureSha256: digest(readFileSync(join(ROOT, 'test/fixtures/resource-package-probe.mjs'))), + }, null, 2) + '\n'); + entry = join(app, 'resource-package-probe.mjs'); + copyFileSync(join(ROOT, 'test/fixtures/resource-package-probe.mjs'), entry); + copyFileSync(entry, join(evidenceRun, 'resource-package-probe.mjs')); + }, 60_000); -const require = createRequire(import.meta.url); -const frameEsm = await import(${JSON.stringify(frameSpecifier)}); -const frameCjs = require(${JSON.stringify(frameSpecifier)}); -const compositorEsm = await import(${JSON.stringify(compositorSpecifier)}); -const compositorCjs = require(${JSON.stringify(compositorSpecifier)}); -const gc = globalThis.gc; -assert.equal(typeof gc, 'function', '--expose-gc missing'); + // Удаляется только временный установленный пакет; evidenceRun сохраняет доказательства. + afterAll(() => { if (work !== undefined) rmSync(work, { recursive: true, force: true }); }); -const retainedOwners = []; - -const boundedCacheCase = (mod, label) => { - const cache = mod.createSpringLinearCache(2); - assert.equal(cache.capacity, 2, label + ': installed cache capacity drifted'); - cache.compile({ mass: 1, stiffness: 170, damping: 26 }); - cache.compile({ mass: 1, stiffness: 180, damping: 8 }); - cache.compile({ mass: 1, stiffness: 120, damping: 30 }); - assert.equal(cache.size, 2, label + ': installed cache exceeded frozen capacity'); - cache.clear(); - assert.equal(cache.size, 0, label + ': installed cache clear retained entries'); -}; + function probe(mode: string, forcedGc = false, corpus = 'combined'): Record { + const args = [...(forcedGc ? ['--expose-gc'] : []), entry, mode, corpus]; + const receiptName = corpus === 'combined' ? mode : `${mode}-${corpus}`; + let output: string; + try { + output = execFileSync(process.execPath, args, { + cwd: app, encoding: 'utf8', timeout: 90_000, maxBuffer: 4 * 1024 * 1024, + }); + } catch (error) { + const result = error as Error & { stdout?: string; stderr?: string }; + writeFileSync(join(evidenceRun, `${receiptName}.stdout.log`), result.stdout ?? ''); + writeFileSync(join(evidenceRun, `${receiptName}.stderr.log`), result.stderr ?? result.message); + throw error; + } + writeFileSync(join(evidenceRun, `${receiptName}.stdout.log`), output); + const result = JSON.parse(output.trim().split('\n').at(-1)!) as Record; + expect(result.corpus).toBe(corpus); + return result; + } -boundedCacheCase(compositorEsm, 'compositor-esm'); -boundedCacheCase(compositorCjs, 'compositor-cjs'); + function completeCycles(result: Record, owners = EXPECTED_OWNERS): void { + expect(result.cyclesPerOwner).toBe(10_000); + const measured = result.executions as Array<{ name: string; cycles: number }>; + expect(measured.map(owner => owner.name)).toEqual(owners); + expect(measured.every(owner => owner.cycles === 10_000)).toBe(true); + } -const frameCase = (mod, label, terminal) => { - let payload = { id: label }; - const ref = new WeakRef(payload); - const hold = (value) => () => { void value.id; }; - let callback = hold(payload); - const loop = mod.createFrameLoop({ requestFrame: () => 1 }); - const off = loop.update(callback); - if (terminal) off(); - payload = undefined; - callback = undefined; - retainedOwners.push(loop, off); - return ref; -}; + it('packed ESM/CJS сохраняют один frame clock после getter reentry и частичного host failure', () => { + const result = probe('reentry'); + expect(result.status).toBe('pass'); + const checks = result.checks as Array<{ format: string; scenario: string }>; + expect(checks.map(check => `${check.format}/${check.scenario}`)).toEqual( + ['esm', 'cjs'].flatMap(format => ['control', 'nested-failure', 'cancel', 'pause'] + .map(scenario => `${format}/${scenario}`)), + ); + }, 120_000); -const compositorCase = (mod, label, terminal) => { - let animateCalls = 0; - let cancelCalls = 0; - let target = { - marker: label, - animate: () => { - animateCalls++; - return { cancel() { cancelCalls++; } }; - }, - }; - const ref = new WeakRef(target); - const captured = target; - const controller = new mod.CompositorSpring({ - spring: { mass: 1, stiffness: 170, damping: 26 }, - property: 'opacity', - from: 0, - to: 1, - target, - format: (value) => captured.marker + ':' + value, - apply: () => { void captured.marker; }, - now: () => 1, - requestFrame: () => 1, - setTimer: () => () => {}, - }); - controller.start(); - assert.equal(animateCalls, 1, label + ': one controller start must own exactly one native effect'); - if (terminal) { - controller.destroy(); - assert.equal(cancelCalls, 1, label + ': terminal owner must release exactly one native effect'); - } else { - assert.equal(cancelCalls, 0, label + ': live owner released native effect too early'); - } - retainedOwners.push(controller); - target = undefined; - return ref; -}; + it('terminal owner не удерживает компонент: дешёвый различающий witness', () => { + expect(probe('witness', true).status).toBe('pass'); + }, 120_000); -const dropped = [ - frameCase(frameEsm, 'frame-esm-dropped', true), - frameCase(frameCjs, 'frame-cjs-dropped', true), - compositorCase(compositorEsm, 'compositor-esm-dropped', true), - compositorCase(compositorCjs, 'compositor-cjs-dropped', true), -]; -const live = [ - frameCase(frameEsm, 'frame-esm-live', false), - frameCase(frameCjs, 'frame-cjs-live', false), - compositorCase(compositorEsm, 'compositor-esm-live', false), - compositorCase(compositorCjs, 'compositor-cjs-live', false), -]; -let deliberate = { id: 'deliberate-retention' }; -const deliberateRef = new WeakRef(deliberate); -retainedOwners.push(deliberate); -deliberate = undefined; + it('10 000 mount/update/interrupt/dispose циклов на каждый ESM/CJS owner не оставляют effects/listeners/jobs', () => { + const result = probe('lifecycle'); + expect(result.status).toBe('pass'); + completeCycles(result); + }, 120_000); -globalThis.__resourceOwners = retainedOwners; -for (let i = 0; i < 60; i++) { - await setImmediate(); - gc(); -} -for (const ref of dropped) { - assert.equal(ref.deref(), undefined, 'terminal owner удерживает объект установленного package'); -} -for (const ref of live) { - assert.notEqual(ref.deref(), undefined, 'live-owner control собран слишком рано'); -} -assert.notEqual(deliberateRef.deref(), undefined, 'deliberate-retention control не различает strong owner'); -console.log('resource-installed-package-retention: PASS'); -`; + it('отдельный forced-GC proof различает terminal/live/dropped/deliberate owners после 10 000 циклов', () => { + const result = probe('retention', true); + expect(result.status).toBe('pass'); + completeCycles(result); + expect(result.retainedComponentReferences).toBe(0); + expect(result.retainedComponentPayloadBytes).toBe(0); + }, 120_000); - const probePath = join(app, 'resource-retention.mjs'); - writeFileSync(probePath, probe); - return execFileSync(process.execPath, ['--expose-gc', probePath], { - cwd: app, - encoding: 'utf8', - timeout: PROBE_TIMEOUT_MS, - }); - } finally { - rmSync(work, { recursive: true, force: true }); - } -} + it('dropped owners возвращают heap в заранее разрешённую A/A baseline-полосу без роста по циклам', () => { + const result = probe('bytes', true, 'existing'); + expect(result.status).toBe('pass'); + completeCycles(result, ownerNames(EXISTING_KINDS)); + }, 120_000); -it('установленный tarball освобождает ресурсы завершённых владельцев в ESM и CJS', () => { - expect(runInstalledPackageProbe()).toContain('resource-installed-package-retention: PASS'); -}, 120_000); + it('presence/scope после 10 000 циклов имеет стабильный terminal tail в своей A/A baseline-полосе', () => { + const result = probe('bytes', true, 'presence-scope'); + expect(result.status).toBe('pass'); + completeCycles(result, ownerNames(ADDED_KINDS)); + const tailExcess = result.tailExcess as number[]; + expect(tailExcess).toHaveLength(4); + expect(tailExcess.every(bytes => bytes === 0)).toBe(true); + }, 120_000); +}); diff --git a/test/server-profile-artifact.test.ts b/test/server-profile-artifact.test.ts new file mode 100644 index 000000000..0209504c9 --- /dev/null +++ b/test/server-profile-artifact.test.ts @@ -0,0 +1,46 @@ +import { describe, expect, it } from 'vitest'; +import { spawnSync } from 'node:child_process'; +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { SERVER_PROFILE, serverProfileDigest } from '../bench/profile/server-profile-registration.mjs'; +import { writeServerArtifact } from '../bench/profile/server-profile-artifact.mjs'; + +const cli = fileURLToPath(new URL('../bench/profile/server-profile-artifact.mjs', import.meta.url)); + +describe('файловый адаптер серверного профиля', () => { + it.each(['intact', 'raw', 'digest', 'journal'] as const)('CLI проверяет связанные файлы: %s', (change) => { + const directory = mkdtempSync(path.join(os.tmpdir(), 'motion profile cli-')); + try { + const artifact = { schema: 1, protocol: SERVER_PROFILE, registration: null, registrationDigest: null, + verdict: 'UNPROVEN', failures: [{ stage: 'preparation', error: { message: 'нет среды' } }] }; + const rawFile = path.join(directory, 'server-profile.json'); + const journalFile = path.join(directory, 'journal.ndjson'); + const { sha256 } = writeServerArtifact(rawFile, artifact); + let previous = '0'.repeat(64); + const records = [{ type: 'failure', value: artifact.failures[0] }, + { type: 'finished', value: { verdict: artifact.verdict, digest: sha256 } }].map((event) => { + const payload = { sequenceDigest: previous, ...event }; + previous = serverProfileDigest(payload); + return { ...payload, digest: previous }; + }); + if (change === 'journal') records[0].digest = 'b'.repeat(64); + writeFileSync(journalFile, records.map((record) => JSON.stringify(record)).join('\n') + '\n'); + if (change === 'raw') writeFileSync(rawFile, Buffer.concat([readFileSync(rawFile), Buffer.from('\n')])); + const result = spawnSync(process.execPath, [cli, '--raw', rawFile, '--digest', + change === 'digest' ? '0'.repeat(64) : sha256, '--journal', journalFile], { encoding: 'utf8', timeout: 10_000 }); + expect(result.error).toBeUndefined(); + if (change === 'intact') { + expect(result.status).toBe(0); + expect(JSON.parse(result.stdout)).toMatchObject({ verification: 'preparation-refused', verdict: 'UNPROVEN', + journalFinalDigest: previous }); + expect(result.stderr).toBe(''); + } else { + expect(result.status).toBe(1); + expect(result.stdout).toBe(''); + expect(result.stderr).toMatch(change === 'journal' ? /цепь журнала/ : /digest raw/); + } + } finally { rmSync(directory, { recursive: true, force: true }); } + }); +}); diff --git a/test/server-profile-contract.test.ts b/test/server-profile-contract.test.ts new file mode 100644 index 000000000..ee358ccde --- /dev/null +++ b/test/server-profile-contract.test.ts @@ -0,0 +1,1398 @@ +import { describe, expect, it, vi, type TestContext } from 'vitest'; +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import { createContext, runInContext } from 'node:vm'; +import { createHash } from 'node:crypto'; +import { isDeepStrictEqual } from 'node:util'; +import { SERVER_PROFILE, planServerSampleSize, serverProfileDigest, serverTailPolicy, verifyServerProfile } from '../bench/profile/server-profile-registration.mjs'; +import { serverCalibrationVerdict, serverCellPairs, serverFamilyIntervals, serverMetricCells, serverOrders, + compactServerCpuEvidence, expandServerCpuEvidence, compactServerSemanticEvidence, serverArtifactChunks, serverArtifactDigest, serverBrowserClockBounds, serverBrowserSemanticClockErrorMs, serverOrderStatisticBounds, serverResourceReasons, + parseServerJsonBytes, parseServerJournalBytes, validateServerArtifact, validateServerBrowserSample, validateServerEngineSample, validateServerJournal, + verifyServerClockRegistration } from '../bench/profile/server-profile-contract.mjs'; +import { writeServerArtifact } from '../bench/profile/server-profile-artifact.mjs'; +import { compactStockMotionValueOutcomes, deriveRealmTimerStep, evaluateStartSemanticEvidence, validateStockMotionValueBatch } from '../bench/compare/methodology.mjs'; +import { measureServerBrowser, measureServerEngine, runServerProfile, runServerProfileCalibration } from '../bench/profile/server-profile-runner.mjs'; +import * as threadCpuClock from '../bench/profile/server-thread-cpu-clock.mjs'; + +const hash = 'a'.repeat(64); +const clone = (value: T): T => structuredClone(value); +const syntheticCpuIdentity = { clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 12345, tid: 12345 }; +function syntheticNativeEndpoint(ns: bigint, identity = syntheticCpuIdentity) { + return { ...identity, seconds: String(ns / 1_000_000_000n), nanoseconds: Number(ns % 1_000_000_000n), valueNs: String(ns) }; +} +function nativeCpuEndpoint(read: any, identity = syntheticCpuIdentity) { + return { sequence: read.sequence, ...syntheticNativeEndpoint(BigInt(read.valueNs), identity) }; +} +function pairs(runs = SERVER_PROFILE.minRuns, ratio = 1) { + return serverMetricCells().map(({ id }) => ({ id, left: Array(runs).fill(100), right: Array(runs).fill(100 * ratio), + leftBounds: Array.from({ length: runs }, () => ({ low: 100, high: 100 })), + rightBounds: Array.from({ length: runs }, () => ({ low: 100 * ratio, high: 100 * ratio })) })); +} + +function normalMotion(scene: any) { + const times = (scene.staggerGapMs > 0 ? [0.2, 0.5, 0.8] : [0.25, 0.5, 0.625]).map((fraction) => SERVER_PROFILE.durationMs * fraction); + const positions = (time: number) => Array.from({ length: scene.targetsPerCall }, (_, index) => + SERVER_PROFILE.toPx * Math.max(0, Math.min(1, (time - scene.staggerGapMs * index) / SERVER_PROFILE.durationMs))); + return compactServerSemanticEvidence({ valid: true, topology: { calls: 1, targetsPerCall: scene.targetsPerCall, staggerGapMs: scene.staggerGapMs, + durationMs: SERVER_PROFILE.durationMs, toPx: SERVER_PROFILE.toPx }, callStartedAtMs: [0], + onset: { before: [{ readStartedMs: 0, readEndedMs: 0, documentFrame: { beforeMs: 0, afterMs: 0 }, positions: Array(scene.targetsPerCall).fill(0) }], + after: [{ readStartedMs: 0.025, readEndedMs: 0.05, documentFrame: { beforeMs: 0, afterMs: 0 }, positions: Array(scene.targetsPerCall).fill(0) }], + firstFrame: { frameTimestampMs: 0, groups: [{ readStartedMs: 0.06, readEndedMs: 0.07, + documentFrame: { beforeMs: 0, afterMs: 0 }, positions: Array(scene.targetsPerCall).fill(0) }] } }, + checkpoints: times.map((time) => ({ frameTimestampMs: time, groups: [{ readStartedMs: time, readEndedMs: time + 0.1, + documentFrame: { beforeMs: time, afterMs: time }, positions: positions(time) }] })), + terminal: [Array(scene.targetsPerCall).fill(SERVER_PROFILE.toPx)] }); +} + +// Независимые explicit linear vectors, не solver/formatter/expectedValues SUT. +function engineRaw(scene: any, repetition = 0) { + const render = ([x, y, scaleX, scaleY, rotate, skewX, skewY]: number[]) => + `translate(${x}px, ${y}px) scaleX(${scaleX}) scaleY(${scaleY}) rotate(${rotate}deg) skew(${skewX}deg, ${skewY}deg)`; + const live = scene.lifecycle === 'live'; + const offsets = [0, 16, 32, 48, 64, 80], setupOffsets = live ? [0, 32] : []; + const setup = live ? [[0, 0, 1, 1, 0, 0, 0], [16, 8, 1.25, 1.5, 8, 2, 4]].map(render) : []; + const values = live ? [16, 46, 76, 106, 136, 166].map((x) => render([x, 8, 1.25, 1.5, 8, 2, 4])) + : [[0, 0, 1, 1, 0, 0, 0], [32, 20, 1.375, 1.5, 12, 3, 5], [64, 40, 1.75, 2, 24, 6, 10], + [96, 60, 2.125, 2.5, 36, 9, 15], [128, 80, 2.5, 3, 48, 12, 20], [160, 100, 2.875, 3.5, 60, 15, 25]].map(render); + const base = 1_000_000 + (live ? 48 : 0); + const steps = [ + ...setupOffsets.map((offset, index) => ({ stage: 'setup', index, phase: 'setup', timestampMs: 1_000_000 + offset })), + ...offsets.map((offset, index) => ({ stage: 'frame', index, phase: 'frames', timestampMs: base + offset })), + { stage: 'cancel-drain', index: null, phase: 'outside', timestampMs: base + 128 }, + ...[256, 384].map((offset) => ({ stage: 'idle', index: null, phase: 'outside', timestampMs: base + offset })), + ].map((step, sequence) => ({ sequence, ...step })); + const events = steps.filter((step) => ['setup', 'frame'].includes(step.stage)).map((step, sequence) => ({ sequence, + phase: step.phase, index: step.index, step: step.sequence, timestampMs: step.timestampMs, property: 'transform', + value: step.stage === 'setup' ? setup[step.index!] : values[step.index!] })); + const clockReads = [{ metric: 'operationNs', frame: null }, ...offsets.map((_, frame) => ({ metric: 'frameNs', frame })), + { metric: 'cancelDrainNs', frame: null }].flatMap(({ metric, frame }, interval) => ['before', 'after'].map((edge, half) => ({ + sequence: interval * 2 + half, metric, frame, edge, + valueNs: String(10_000_000 + repetition * 100_000_000 + interval * 2_000_000 + (half ? metric === 'cancelDrainNs' ? 500_000 : 1_000_000 : 0)) }))); + return { operationNs: 1_000_000, frameNs: Array(6).fill(1_000_000), cancelDrainNs: 500_000, + raw: { schemaVersion: 1, case: { count: scene.count, lifecycle: scene.lifecycle, channels: scene.channels }, clockReads, + cpuReads: clockReads.map((read) => nativeCpuEndpoint(read)), + timeline: { clockOriginMs: 1_000_000, setupOffsetsMs: setupOffsets, frameOffsetsMs: offsets, successorBaseMs: base, steps }, + targetTraces: { encoding: 'runs', count: scene.count, runs: [{ from: 0, count: scene.count, + trace: { value: values.at(-1), setup, setupWrites: setup.map(() => 1), values, writes: values.map(() => 1), outsideWrites: 0, events } }] } }, + semantic: { valid: true, targets: scene.count, frames: 6, finished: true, pending: 0, onCompleteCalls: 0, + previousFinished: live ? true : null, previousCompleteCalls: 0, requests: live ? 9 : 7, executions: live ? 9 : 7, + targetTraceHashes: { encoding: 'repeat', count: scene.count, value: createHash('sha256').update(JSON.stringify(values)).digest('hex') } } }; +} + +function stockRaw(scene: any, multiplier = 1, timed = true, repetition = 0) { + const calls = scene.callsPerRepetition * multiplier; + const clockReads = timed ? ['before', 'after'].map((edge, sequence) => ({ sequence, metric: 'operationNs', frame: null, edge, + valueNs: String(10_000_000 + repetition * (10_000_000 + scene.callsPerRepetition * multiplier * 1_000_000) + + sequence * scene.callsPerRepetition * multiplier * 1_000_000) })) : []; + return { operationNs: timed ? 1_000_000 * multiplier : null, raw: { schemaVersion: 1, scene: scene.id, + phase: timed ? 'timed' : 'warmup', calls, completed: calls, denominator: scene.callsPerRepetition, + clockReads, cpuReads: clockReads.map((read) => nativeCpuEndpoint(read)), + outcomes: { encoding: 'runs', count: calls, runs: [{ from: 0, count: calls, value: 100, frames: 47 }] } } }; +} + +function stage(name = 'aa', runs = 2) { + const rows: any[] = []; + for (let run = 0; run < runs; run++) for (const [kind, scenes] of [['engine', SERVER_PROFILE.engineScenes], ['browser', SERVER_PROFILE.browserScenes]] as const) { + for (const scene of scenes) { + const samples: any = {}; + for (const id of ['left', 'right']) { + const multiplier = name === 'positive' && id === 'right' ? 2 : 1; + let raw: any[]; + let extra: any = {}; + if (kind === 'engine') { + if ((scene as any).workload === 'stock-c') { + raw = Array.from({ length: SERVER_PROFILE.repetitions }, (_, repetition) => stockRaw(scene, multiplier, true, repetition)); + extra = { operationNs: 1_000_000 * multiplier, cpuScope: SERVER_PROFILE.stockCpuScope, + warmup: Array.from({ length: (scene as any).warmupBatches }, () => stockRaw(scene, 1, false)) }; + } else { + raw = Array.from({ length: SERVER_PROFILE.repetitions * multiplier }, (_, repetition) => engineRaw(scene, repetition)); + extra = { operationNs: 1_000_000 * multiplier, meanFrameNs: 1_000_000 * multiplier, cancelDrainNs: 500_000 * multiplier }; + } + } else { + const timerEvidence = { crossOriginIsolated: true, probes: ['before', 'after'].map((phase) => ({ phase, + timeOriginMs: 1000, performanceNowDeltasMs: Array(64).fill(0.005) })) }; + const count = (scene as any).targetsPerCall; + const calls = SERVER_PROFILE.browserBatchCalls * multiplier; + const cancellation = (targets: number) => ({ connectedTargets: targets, activeWaapiBefore: 0, transformsBefore: { encoding: 'repeat', count: targets, value: 0 }, + frames: Array.from({ length: SERVER_PROFILE.browserCancellationWitness.frames }, () => ({ connectedTargets: targets, activeWaapi: 0, transforms: { encoding: 'repeat', count: targets, value: 0 } })), + cancelDrainMs: 64 }); + raw = Array.from({ length: SERVER_PROFILE.repetitions }, (_, index) => { + const beginMs = 100 + index * 1000, endMs = beginMs + SERVER_PROFILE.browserBatchCalls * multiplier; + return { startMs: multiplier, cancelMs: 0.5 * multiplier, + batchStartMs: SERVER_PROFILE.browserBatchCalls * multiplier, batchCancelMs: SERVER_PROFILE.browserBatchCalls * 0.5 * multiplier, + calls, ownersStarted: calls, ownersCancelled: calls, startClock: { beginMs, endMs }, + cancelClock: { beginMs: endMs + 3, endMs: endMs + 3 + SERVER_PROFILE.browserBatchCalls * 0.5 * multiplier }, + startWitness: { connectedTargets: calls * count, activeWaapi: 0, leadingPositions: { encoding: 'repeat', count: calls, value: 0 }, + readClock: { beginMs: endMs + 1, endMs: endMs + 2 } }, cancelWitness: cancellation(calls * count) }; + }); + extra = { startMs: 1 * multiplier, cancelMs: 0.5 * multiplier, timerEvidence, + timerStepMs: deriveRealmTimerStep('fixture', timerEvidence), measurementTimeOriginMs: 1000, + endpoints: Array(count).fill(SERVER_PROFILE.toPx), controlCancelMs: 0.5, controlCancelWitness: cancellation(count), warmup: [raw[0]], + semanticEvidence: normalMotion(scene), monotonicHostUpperNs: '1000000000000', clockModelDigest: serverProfileDigest(SERVER_PROFILE.clockError) }; + } + samples[id] = { raw, ...extra, semantic: true, workMultiplier: multiplier, repetitions: SERVER_PROFILE.repetitions, denominator: SERVER_PROFILE.denominator, + ...(kind === 'engine' ? { cpuClock: { ...syntheticCpuIdentity } } : {}) }; + } + rows.push({ kind, scene: scene.id, run, order: serverOrders(runs)[run], samples }); + } + } + const blocks = Array.from({ length: runs / 2 }, (_, block) => { + const cpuStat = { usage_usec: 10 + block * 10, user_usec: 10 + block * 10, system_usec: 0, nr_periods: 0, nr_throttled: 0, throttled_usec: 0 }; + return { block, before: { cpuStat, affinity: '0', cpuMax: '400000 100000' }, after: { cpuStat: { ...cpuStat, usage_usec: cpuStat.usage_usec + 10, user_usec: cpuStat.user_usec + 10 }, affinity: '0', cpuMax: '400000 100000' }, + delta: { usage_usec: 10, user_usec: 10, system_usec: 0, nr_periods: 0, nr_throttled: 0, throttled_usec: 0 } }; + }); + return { name, rows, blocks }; +} + +function registeredRefusal() { + const packageInfo = { version: '1.0.0', sha256: hash, files: 1 }; + const provenance = { revision: SERVER_PROFILE.baselineRevision, dirty: false, trackedRevisionSha256: hash, worktreeSha256: hash, + distRuntime: { sha256: hash, files: 1 }, inputs: Object.fromEntries(['root/package.json', 'root/pnpm-lock.yaml', 'bench/package.json', 'bench/pnpm-lock.yaml'].map((name) => [name, hash])), + environment: { node: SERVER_PROFILE.clockError.nodeVersion, nodeExecutableSha256: SERVER_PROFILE.clockError.nodeExecutableSha256, pnpm: '11.11.0', + packages: Object.fromEntries(['esbuild', 'playwright', 'motion', 'gsap', 'animejs'].map((name) => [name, packageInfo])), + rootPackages: Object.fromEntries(['tsup', 'typescript', 'esbuild'].map((name) => [name, packageInfo])) } }; + const machineIdentity = { affinity: '0', cgroupCpuMax: '400000 100000', platform: 'linux', release: SERVER_PROFILE.clockError.kernelRelease, node: SERVER_PROFILE.clockError.nodeVersion, + nodeExecutableSha256: SERVER_PROFILE.clockError.nodeExecutableSha256 }; + const consumer = { tarballSha256: hash, treeSha256: hash }; + const registration = { protocolDigest: serverProfileDigest(SERVER_PROFILE), candidateSamplesObserved: false, + candidateSamplesObservedScope: SERVER_PROFILE.candidateSamplesObservedScope, + browser: 'chromium', browserVersion: SERVER_PROFILE.clockError.browserVersion, browserExecutableSha256: SERVER_PROFILE.clockError.browserExecutableSha256, + clockModelDigest: serverProfileDigest(SERVER_PROFILE.clockError), browserTree: { sha256: hash, files: 1 }, + provenance: { baseline: provenance, candidate: { ...provenance, revision: 'b'.repeat(40) } }, + machine: { identity: machineIdentity, sha256: serverProfileDigest(machineIdentity) }, + engineClock: { schema: 1, ...syntheticCpuIdentity, napiVersion: 8, + node: { version: SERVER_PROFILE.clockError.nodeVersion, executableSha256: SERVER_PROFILE.clockError.nodeExecutableSha256 }, + nativeBinary: { path: '/synthetic/thread-cpu.node', bytes: 1, sha256: hash }, nativeSources: clone(SERVER_PROFILE.clockError.nativeSourceFiles), + nativeSourceDigest: serverProfileDigest(Object.fromEntries(Object.entries(SERVER_PROFILE.clockError.nativeSourceFiles).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))), + compiler: { path: '/synthetic/cc', version: 'synthetic compiler', binarySha256: hash, flags: ['-shared', '-fPIC', '-DNAPI_VERSION=8'] }, + libc: { path: '/synthetic/libc.so', sha256: hash }, nominalResolutionNs: '1', nominalResolutionIsNotErrorCertificate: true }, + harness: Object.fromEntries(Array.from({ length: 6 }, (_, i) => [String(i), { sha256: hash }])), + packages: Object.fromEntries(['baseline', 'candidate', ...SERVER_PROFILE.comparators.filter((x) => x !== 'waapi-ctl')].map((name) => [name, clone(consumer)])), + transitivePackages: { one: consumer, two: consumer, three: consumer } }; + return { schema: 1, protocol: SERVER_PROFILE, registration, registrationDigest: serverProfileDigest(registration), verdict: 'UNPROVEN', + failures: [{ stage: 'warmup', error: { message: 'незавершённая контрольная серия' } }] }; +} + +function healthyAdmission() { + const artifact: any = registeredRefusal(); artifact.failures = []; artifact.verdict = 'PASS'; + artifact.warmup = stage('warmup', SERVER_PROFILE.warmupRuns); + artifact.pilot = stage('pilot', SERVER_PROFILE.pilotRuns); + artifact.samplePlan = planServerSampleSize(serverCellPairs(artifact.pilot, SERVER_PROFILE.pilotRuns, 'pilot')); + const runs = artifact.samplePlan.runs; + artifact.aa = stage('aa', runs); artifact.positive = stage('positive', runs); artifact.ab = stage('ab', runs); + artifact.frozenPlanDigest = serverProfileDigest({ registrationDigest: artifact.registrationDigest, samplePlan: artifact.samplePlan }); + const aa = serverFamilyIntervals(serverCellPairs(artifact.aa, runs, 'aa')); + const positive = serverFamilyIntervals(serverCellPairs(artifact.positive, runs, 'positive')); + artifact.calibration = { ...serverCalibrationVerdict(aa, positive, artifact.samplePlan), aa, positive }; + artifact.comparison = serverFamilyIntervals(serverCellPairs(artifact.ab, runs, 'ab')); + const control = { noMotion: { equal: true, beforeSha256: hash, afterSha256: hash }, + reduced: { prefersReducedMotion: true, x: SERVER_PROFILE.toPx, rafRequests: 0, activeWaapi: 0 } }; + artifact.rawControls = { baseline: clone(control), candidate: clone(control) }; + artifact.comparators = SERVER_PROFILE.browserScenes.flatMap((scene) => SERVER_PROFILE.comparators.map((id) => { + if (scene.staggerGapMs > 0 && ['motion-mini', 'anime-waapi'].includes(id)) return { scene: scene.id, id, + status: 'UNPROVEN', reason: 'общего stagger API нет' }; + const sample = artifact.ab.rows.find((row: any) => row.scene === scene.id).samples.left; + return { scene: scene.id, id, rows: Array.from({ length: runs }, () => sample) }; + })); + const retention = { verdict: 'COMPLETE', failure: null, rows: SERVER_PROFILE.engineScenes.map((scene) => ({ + scene: scene.id, before: { heapUsed: 1000 }, after: { heapUsed: 900 }, retainedHeapDeltaBytes: -100 })) }; + artifact.retention = { baseline: clone(retention), candidate: clone(retention) }; + return artifact; +} + +function admissionEvents(artifact: any) { + const events: any[] = [{ type: 'registration-before-any-sample', value: { registration: artifact.registration, digest: artifact.registrationDigest } }, + { type: 'raw-controls-baseline', value: artifact.rawControls.baseline }]; + for (const name of ['warmup', 'pilot', 'aa', 'positive', 'ab']) { + if (name === 'aa') events.push({ type: 'N-frozen-before-calibration-and-AB', value: { samplePlan: artifact.samplePlan, digest: artifact.frozenPlanDigest } }); + if (name === 'ab') events.push({ type: 'calibration', value: artifact.calibration }, { type: 'raw-controls-candidate-after-calibration', value: artifact.rawControls.candidate }); + const current = artifact[name]; + current.rows.forEach((row: any, index: number) => { + for (const participant of row.order) events.push({ type: 'sample', value: { stage: name, kind: row.kind, scene: row.scene, run: row.run, participant, + build: name === 'ab' && participant === 'right' ? 'candidate' : 'baseline', value: row.samples[participant] } }); + const blockRows = (SERVER_PROFILE.engineScenes.length + SERVER_PROFILE.browserScenes.length) * 2; + if ((index + 1) % blockRows === 0) events.push({ type: 'resources-block', value: { stage: name, ...current.blocks[Math.floor(index / blockRows)] } }); + }); + } + for (const comparator of artifact.comparators) for (let run = 0; run < (comparator.rows ?? []).length; run++) { + events.push({ type: 'comparator-sample', value: { scene: comparator.scene, id: comparator.id, run, sample: comparator.rows[run] } }); + } + for (const id of ['baseline', 'candidate']) events.push({ type: 'retention-sample', value: { id, value: artifact.retention[id] } }); + events.push({ type: 'retention-separate-forced-GC', value: artifact.retention }); + events.push({ type: 'finished', value: { verdict: artifact.verdict, digest: serverArtifactDigest(artifact) } }); + return events; +} + +function chain(events: any[], shared?: { events: any[]; records: any[] }) { + // Только подготовка fixture переиспользует неизменённый префикс по identity. + // Валидатор заново проверяет каждый hash и весь зарегистрированный raw каждой истории. + let prefix = 0; + while (shared && prefix < events.length && events[prefix] === shared.events[prefix]) prefix++; + let previous = prefix ? shared!.records[prefix - 1].digest : '0'.repeat(64); + return [...(shared?.records.slice(0, prefix) ?? []), ...events.slice(prefix).map((event) => { + const payload = { sequenceDigest: previous, ...event }; previous = serverProfileDigest(payload); + return { ...payload, digest: previous }; + })]; +} + +// Два набора fault cases используют одну healthy зарегистрированную историю. Изменяются +// только принадлежащие fault ветви; исходные events/raw остаются неизменными. +let sharedAdmission: { artifact: any; events: any[]; records: any[] } | undefined; +function admissionHistory() { + if (!sharedAdmission) { + const artifact = healthyAdmission(); + // Полные независимые vectors переходят в зарегистрированный carrier до events/hash. + // N, поля наблюдений и четыре контрпримера остаются прежними; legacy fault fixtures не меняются. + for (const name of ['warmup', 'pilot', 'aa', 'positive', 'ab']) for (const row of artifact[name].rows) { + if (row.kind === 'engine') for (const sample of Object.values(row.samples) as any[]) { + for (const measured of sample.raw) measured.raw.cpuReads = compactServerCpuEvidence(measured.raw.cpuReads); + } + } + const events = admissionEvents(artifact); + sharedAdmission = { artifact, events, records: chain(events) }; + } + return sharedAdmission; +} + +describe('серверный PROFILE: потеря полей при CPU RLE запрещена', () => { + const original = [ + { sequence: 0, clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 12345, tid: 12345, seconds: '9007199254740993', nanoseconds: 17, valueNs: '9007199254740993000000017' }, + { sequence: 1, clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 12345, tid: 12345, seconds: '9007199254740993', nanoseconds: 18, valueNs: '9007199254740993000000018' }, + { sequence: 2, clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 23456, tid: 23456, seconds: '9007199254740993', nanoseconds: 19, valueNs: '9007199254740993000000019' }, + ]; + const encoded = { encoding: 'native-cpu-rle-v1', count: 3, runs: [ + { from: 0, count: 2, clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 12345, tid: 12345, values: [['9007199254740993', 17], ['9007199254740993', 18]] }, + { from: 2, count: 1, clock: 'CLOCK_THREAD_CPUTIME_ID', pid: 23456, tid: 23456, values: [['9007199254740993', 19]] }, + ] }; + it('восстанавливает каждый exact timespec/ordinal/PID и исходный порядок JSON', () => { + expect(compactServerCpuEvidence(original)).toEqual(encoded); + const restored = expandServerCpuEvidence(JSON.parse(JSON.stringify(encoded)), 3); + expect(restored).toEqual(original); + expect(JSON.stringify(restored)).toBe(JSON.stringify(original)); + expect(expandServerCpuEvidence(original, 3)).toBe(original); + }); + it.each(['valueNs', 'sequence'])('encoder не исправляет forged %s', (field) => { + const changed = clone(original); changed[1][field] = field === 'valueNs' ? '9007199254740993000000019' : 0; + const before = JSON.stringify(changed); + expect(() => compactServerCpuEvidence(changed)).toThrow(/native CPU/); + expect(JSON.stringify(changed)).toBe(before); + }); + it.each(['count', 'gap'])('decoder не скрывает %s в приобретённом suffix', (field) => { + const changed = clone(encoded); + if (field === 'count') changed.count++; else changed.runs[1].from++; + expect(() => expandServerCpuEvidence(changed, 3)).toThrow(/native CPU/); + }); +}); + +// Исполняем настоящий browser owner в VM с независимым линейным DOM и +// намеренно грубыми часами. Это synthetic fault test, не performance sample. +function syntheticBrowser(options: { startCostMs?: number; snap?: boolean; snapAt?: number; cancelAt?: number; rejectTiming?: boolean; + durationMultiplier?: number; shape?: 'quadratic'; rafStepMs?: number; readCostMs?: number; timerLagMs?: number; + initialProgress?: number; initialProgressAt?: number; onsetReadAt?: number; documentClock?: 'missing' | 'unstable' | 'unrelated'; + documentOriginLagMs?: number; quarterAtFirstFrame?: boolean; quarterAtFrame?: number } = {}) { + const directory = mkdtempSync(path.join(os.tmpdir(), 'motion-server-synthetic-')); + const source = path.join(directory, 'adapter.js'); writeFileSync(source, '// Синтетический adapter задан VM.\n'); + let timeMs = 100, frameTimeMs = timeMs - (options.documentOriginLagMs ?? 0), frameReads = 0, frames = 0, starts = 0, cancels = 0; + const children: any[] = []; + const position = (element: any) => { + if (!element.motion) return element.x; + if (element.motion.pendingFrame) return SERVER_PROFILE.toPx * element.motion.initialProgress; + const progress = Math.max(0, Math.min(1, (timeMs - element.motion.startedMs - element.motion.delayMs) / element.motion.durationMs + element.motion.initialProgress)); + return SERVER_PROFILE.toPx * (options.shape === 'quadratic' ? progress * progress : progress); + }; + const start = (elements: any[], to: number, duration: number, gap = 0) => { + starts++; + const startedMs = timeMs; + for (const [index, element] of elements.entries()) { + if (options.snap || starts === options.snapAt) { element.x = to; element.motion = null; } + else element.motion = { startedMs, durationMs: duration * (options.durationMultiplier ?? 1), delayMs: index * gap, + pendingFrame: true, + initialProgress: starts >= (options.initialProgressAt ?? 1) ? options.initialProgress ?? 0 : 0 }; + } + timeMs += options.startCostMs ?? 0.025; + return { cancel() { + cancels++; + if (cancels === options.cancelAt) throw undefined; + timeMs += 0.05; + for (const element of elements) { element.x = position(element); element.motion = null; } + } }; + }; + const sandbox: any = { crossOriginIsolated: true, performance: { timeOrigin: 1000, now() { + timeMs += 0.001; return Math.floor(timeMs / 0.005) * 0.005; + } }, document: { timeline: { get currentTime() { + if (options.documentClock === 'missing') return null; + return frameTimeMs + (options.documentClock === 'unstable' ? ++frameReads * 0.01 : options.documentClock === 'unrelated' ? 1 : 0); + } }, createElement() { return { x: 0, motion: null, isConnected: false, + getAnimations: () => [], remove() { this.isConnected = false; } }; }, body: { appendChild(element: any) { element.isConnected = true; children.push(element); } } }, + getComputedStyle: (element: any) => { + if (starts === 0 && children.indexOf(element) === options.onsetReadAt) throw new Error('синтетический отказ acquired onset prefix'); + const transform = String(position(element)); timeMs += options.readCostMs ?? 0; + return { transform }; + }, DOMMatrixReadOnly: class { e: number; constructor(value: string) { this.e = Number(value); } }, + setTimeout(callback: () => void, delay: number) { + // VM автоматически публикует pending animation frame во время timer wait; + // explicit first-frame oracle получает тот же ноль своим rAF. + for (const element of children) if (element.motion?.pendingFrame) { + element.motion.startedMs += options.rafStepMs ?? 16; element.motion.pendingFrame = false; + } + timeMs += delay + (options.timerLagMs ?? 0); queueMicrotask(callback); + }, + requestAnimationFrame(callback: (time: number) => void) { + timeMs += options.rafStepMs ?? 16; frameTimeMs = timeMs; frames++; + for (const element of children) if (element.motion) { + if (element.motion.pendingFrame) { element.motion.startedMs = frameTimeMs; element.motion.pendingFrame = false; } + if (frames === (options.quarterAtFirstFrame ? 1 : options.quarterAtFrame)) element.motion.initialProgress = 0.25; + } + queueMicrotask(() => callback(timeMs)); + }, + __adapterModule: { start, startStagger: start } }; + sandbox.window = sandbox; + const realm = createContext(sandbox); + const page = { goto: async () => {}, exposeFunction: async (name: string, fn: Function) => { sandbox[name] = fn; }, + async evaluate(fn: Function, argument?: any) { + if (options.rejectTiming && fn.toString().includes('const raw = [], warmup')) throw undefined; + return runInContext(`(${fn.toString()})`, realm)(argument); + } }; + const context = { newPage: async () => page, close: async () => {} }; + return { browser: { newContext: async () => context }, page, adapter: { path: source }, + dispose: () => rmSync(directory, { recursive: true, force: true }), read: () => ({ starts, cancels, connected: children.filter((element) => element.isConnected).length }) }; +} + +// Исполняем замороженную границу page.evaluate общего владельца. VM задаёт +// часы и движение самостоятельно; производственный oracle получает его raw. +async function syntheticSemanticControl(fake: ReturnType, scene: any) { + const bench = readFileSync(new URL('../bench/compare/bench.mjs', import.meta.url), 'utf8'); + const source = bench.slice(bench.indexOf('export async function runSemanticStartCheck('), bench.indexOf('// ─── сценарий S5:')).trim().replace(/^export /, ''); + const runCheck = Function('evaluateStartSemanticEvidence', `return (${source})`)(evaluateStartSemanticEvidence); + const semanticClockErrorMs = serverBrowserSemanticClockErrorMs('1000000000000'); + return runCheck(fake.page, { ...scene, ...SERVER_PROFILE.browserSemantics, semanticClockErrorMs, + durationMs: SERVER_PROFILE.durationMs, toPx: SERVER_PROFILE.toPx }, SERVER_PROFILE.browserSemanticCalls); +} + +describe('серверный PROFILE: clock/progress falsifiers', () => { + it('stock C добавляет ровно одну whole-macro family и сохраняет per-operation47/100', () => { + const scene = SERVER_PROFILE.engineScenes.find((scene) => scene.workload === 'stock-c')!; + expect(serverMetricCells()).toHaveLength(11); + expect(serverMetricCells().filter((cell) => cell.scene === scene.id).map((cell) => cell.metric)).toEqual(['operationNs']); + const plain = compactStockMotionValueOutcomes([100, 100, 0, 200], [47, 47, 0, 94]); + expect(plain).toEqual({ encoding: 'runs', count: 4, runs: [ + { from: 0, count: 2, value: 100, frames: 47 }, { from: 2, count: 1, value: 0, frames: 0 }, { from: 3, count: 1, value: 200, frames: 94 }] }); + const sample = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + validateServerEngineSample(sample, scene); + const cell = serverCellPairs(stage(), 2, 'aa').find((cell) => cell.scene === scene.id)!; + expect(cell.leftBounds[0].low).toBeLessThanOrEqual(1_000_000 - 1); + expect(cell.leftBounds[0].high).toBeGreaterThanOrEqual(1_000_000 + 1); + }); + it('stock C failure outcomes сохраняют приобретённые primitive identities после JSON/RLE', () => { + const acquired = [undefined, undefined, -0, 0, NaN, Infinity, -Infinity]; + const saved = JSON.parse(JSON.stringify(compactStockMotionValueOutcomes(acquired, [47, 47, 47, 47, 47, 47, undefined]))); + const expanded = saved.runs.flatMap((run: any) => Array.from({ length: run.count }, () => [run.value, run.frames])); + expect(expanded).toEqual([[{ type: 'undefined' }, 47], [{ type: 'undefined' }, 47], [{ number: '-0' }, 47], [0, 47], + [{ nonfinite: 'NaN' }, 47], [{ nonfinite: 'Infinity' }, 47], [{ nonfinite: '-Infinity' }, { type: 'undefined' }]]); + expect(saved.count).toBe(acquired.length); + expect(saved.runs.map((run: any) => run.from)).toEqual([0, 2, 3, 4, 5, 6]); + }); + it.each(['mixed-frames', 'mixed-endpoints', 'missing-operation', 'wrong-divisor', 'missing-warmup', 'missing-cpu-read', + 'coherent-timespec-mismatch', 'aggregate-only-drift'])('stock C raw отвергает %s с правильными aggregates', (fault) => { + const scene = SERVER_PROFILE.engineScenes.find((scene) => scene.workload === 'stock-c')!; + const sample = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + validateServerEngineSample(sample, scene); + const raw = sample.raw[0]; + if (fault === 'mixed-frames') raw.raw.outcomes.runs = [{ from: 0, count: 1000, value: 100, frames: 0 }, { from: 1000, count: 1000, value: 100, frames: 94 }]; + if (fault === 'mixed-endpoints') raw.raw.outcomes.runs = [{ from: 0, count: 1000, value: 0, frames: 47 }, { from: 1000, count: 1000, value: 200, frames: 47 }]; + if (fault === 'missing-operation') raw.raw.outcomes.runs[0].count--; + if (fault === 'wrong-divisor') raw.raw.denominator = 4000; + if (fault === 'missing-warmup') sample.warmup.pop(); + if (fault === 'missing-cpu-read') raw.raw.cpuReads.pop(); + if (fault === 'coherent-timespec-mismatch') { + raw.raw.clockReads[1].valueNs = String(BigInt(raw.raw.clockReads[1].valueNs) + 1n); + raw.raw.cpuReads[1].valueNs = raw.raw.clockReads[1].valueNs; + raw.operationNs += 1 / 2000; + sample.operationNs = sample.raw.reduce((sum: number, item: any) => sum + item.operationNs, 0) / sample.repetitions; + } + if (fault === 'aggregate-only-drift') sample.operationNs++; + expect(() => validateServerEngineSample(sample, scene)).toThrow(/stock C|CPU|timing/); + }); + it('stock C producer делает2warmups, actual2×work и сохраняет поздний prefix без выдуманного CPU endpoint', async () => { + const scene = SERVER_PROFILE.engineScenes.find((scene) => scene.workload === 'stock-c')!; + // Каждый вызов проверяется; Vitest оформляет только несовпадение значений. + const same = (actual: unknown, expected: unknown): void => { + if (!Object.is(actual, expected)) expect(actual).toBe(expected); + }; + const expectedSpring = { mass: 1, stiffness: 170, damping: 26 }; + let constructors = 0, destroys = 0, failAt = Infinity, cpuNs = 0n; + const cpu = vi.spyOn(threadCpuClock, 'readServerThreadCpuEndpoint').mockImplementation(() => + syntheticNativeEndpoint(cpuNs += 2_000_000_000n, { clock: 'CLOCK_THREAD_CPUTIME_ID', pid: process.pid, tid: process.pid })); + class ObservedMotionValue { + private readonly options: any; + private changed: (value: number) => unknown = () => {}; + private index: number; + constructor(options: any) { + this.index = constructors++; this.options = options; + same(options.initial, 0); + const spring = options.spring; + if (!isDeepStrictEqual(spring, expectedSpring)) expect(spring).toEqual(expectedSpring); + same(Object.hasOwn(options, 'clamp'), false); + } + onChange(changed: (value: number) => unknown) { this.changed = changed; changed(0); } + setTarget(target: number) { + same(target, 100); + let count = 0; + const frame = () => { this.changed(++count === 47 ? 100 : count); if (count < 47) this.options.requestFrame(frame); }; + this.options.requestFrame(frame); + } + destroy() { destroys++; if (this.index === failAt) throw undefined; } + } + try { + const success = await measureServerEngine(ObservedMotionValue, scene, 2); + expect(constructors).toBe(2 * 2000 + 8 * 4000); expect(destroys).toBe(constructors); + expect(cpu).toHaveBeenCalledTimes(16); expect(success.raw).toHaveLength(8); expect(success.warmup).toHaveLength(2); + success.warmup.forEach((batch: any) => validateStockMotionValueBatch(batch, scene, 1, false)); + success.raw.forEach((batch: any) => { + expect(batch.raw.outcomes).toEqual({ encoding: 'runs', count: 4000, runs: [{ from: 0, count: 4000, value: 100, frames: 47 }] }); + expect(batch.operationNs).toBe(1_000_000); + }); + validateServerEngineSample(success, scene, 2); + constructors = destroys = 0; failAt = 4002; cpu.mockClear(); + const failed: any = await measureServerEngine(ObservedMotionValue, scene).catch((error) => error); + expect(failed).toBeInstanceOf(AggregateError); expect(failed.raw.warmup).toHaveLength(2); expect(failed.raw.completed).toEqual([]); + expect(failed.raw.failedRepetition.raw).toMatchObject({ completed: 2, values: [100, 100], frames: [47, 47], + unfinishedOperation: { index: 2, valueAcquired: false, frameAcquired: false } }); + expect(failed.raw.failedRepetition.raw.clockReads).toHaveLength(1); expect(failed.raw.failedRepetition.raw.cpuReads).toHaveLength(1); + expect(cpu).toHaveBeenCalledTimes(1); + if (process.env.MOTION_SERVER_STOCK_UNIT_EVIDENCE) writeFileSync(process.env.MOTION_SERVER_STOCK_UNIT_EVIDENCE, + JSON.stringify({ synthetic: true, actualRegisteredPerformanceSamples: 0, scene, success, failure: { name: failed.name, message: failed.message, raw: failed.raw } }) + '\n', { flag: 'wx' }); + } finally { cpu.mockRestore(); } + }); + it('chunked JSON сохраняет native values, порядок, escape/UTF8 и duplicate/prototype keys', () => { + const text = '{"rows":[{"text":"кириллица\\n\\\"[,]{}\\\\🙂","raw":[null,true,false,-0,1e200,9007199254740993]},[{},[]]],"__proto__":{"safe":1},"a":1,"a":2,"tail":"\\u0000"}'; + const expected = JSON.parse(text); + for (const chunkBytes of [1, 7, 17, 64, 1024]) { + const actual = parseServerJsonBytes(Buffer.from(text), chunkBytes); + expect(actual).toEqual(expected); expect(Object.keys(actual)).toEqual(Object.keys(expected)); + expect(Object.getPrototypeOf(actual)).toBe(Object.prototype); + expect(Object.hasOwn(actual, '__proto__')).toBe(true); expect(Object.is(actual.rows[0].raw[3], -0)).toBe(true); + } + for (const malformed of ['', '[1,]', '{"a":1,}', '{"a" 1}', '{"a":1}{}', '[1,,2]', '[{"a":1]]', '{"a":[1}}', + '{"a":"escape\\"}', '[NaN]', '[1 2]', '{"a":01}', '["unclosed]', '{bare:1}']) { + expect(() => JSON.parse(malformed)).toThrow(); + expect(() => parseServerJsonBytes(Buffer.from(malformed), 1)).toThrow(); + } + }); + it('journal декодируется по полным records, сохраняя literal escapes и отказ на потерянной строке', () => { + const records = [{ type: 'sample', value: { text: 'строка\n[,]{}\\"', large: 'x'.repeat(1000) } }, + { type: 'failure', value: { raw: [{ metric: -0 }, null] } }]; + const bytes = Buffer.from(` \n${records.map((record) => JSON.stringify(record)).join('\n')}\r\n `); + expect(parseServerJournalBytes(bytes)).toEqual(records.map((record) => JSON.parse(JSON.stringify(record)))); + expect(() => parseServerJournalBytes(Buffer.from(`${JSON.stringify(records[0])}\n\n${JSON.stringify(records[1])}`))).toThrow(); + expect(() => parseServerJournalBytes(Buffer.from(' \r\n'))).toThrow(); + }); + it('настоящий engine owner сохраняет controlled CPU endpoints на успехе и позднем отказе', async () => { + const { animate } = await import('../src/animate/index.js'); + let cpuNs = 0n; + const cpu = vi.spyOn(threadCpuClock, 'readServerThreadCpuEndpoint').mockImplementation(() => + syntheticNativeEndpoint(cpuNs += 1_000_000n, { clock: 'CLOCK_THREAD_CPUTIME_ID', pid: process.pid, tid: process.pid })); + const scene = SERVER_PROFILE.engineScenes[1]; + try { + const success = await measureServerEngine(animate, scene); + expect(success.raw).toHaveLength(8); expect(cpu).toHaveBeenCalledTimes(128); + for (const measured of success.raw) { + expect(measured.raw.clockReads).toHaveLength(16); expect(measured.raw.cpuReads).toHaveLength(16); + measured.raw.clockReads.forEach((read: any, sequence: number) => { + expect(measured.raw.cpuReads[sequence].valueNs).toBe(read.valueNs); + expect(String(BigInt(measured.raw.cpuReads[sequence].seconds) * 1_000_000_000n + BigInt(measured.raw.cpuReads[sequence].nanoseconds))).toBe(read.valueNs); + }); + } + validateServerEngineSample(success, scene); + cpu.mockClear(); + const broken = ((...args: Parameters) => { + const owner = animate(...args); + return { ...owner, cancel() { owner.cancel(); throw undefined; } }; + }) as typeof animate; + const failure: any = await measureServerEngine(broken, scene).catch((error) => error); + // Опциональная долговечная квитанция только этого synthetic unit probe. + // CPU поля вымышлены mock clock; это не performance sample продукта. + if (process.env.MOTION_SERVER_PROFILE_UNIT_EVIDENCE) writeFileSync(process.env.MOTION_SERVER_PROFILE_UNIT_EVIDENCE, + `${JSON.stringify({ synthetic: true, actualTimingSamplesObserved: 0, scene, success, + failure: { name: failure?.name, message: failure?.message, raw: failure?.raw } }, null, 2)}\n`, { flag: 'wx' }); + expect(failure).toBeInstanceOf(AggregateError); expect(failure.raw.completed).toEqual([]); + const failed = failure.raw.failedRepetition; + expect(failed.clockReads).toHaveLength(15); expect(failed.cpuReads).toHaveLength(15); + expect(failed.operationNs).toBe(1_000_000); expect(failed.frameNs).toEqual(Array(6).fill(1_000_000)); + expect(failed.cancelDrainNs).toBe(null); expect(failed.unfinishedInterval.metric).toBe('cancelDrainNs'); + expect(cpu).toHaveBeenCalledTimes(15); + } finally { cpu.mockRestore(); } + }); + it.each(['missing-read', 'read-order', 'impossible-ns', 'coherent-impossible-ns', 'missing-cpu-field', 'backward-native-counter', + 'last-target-coordinate', 'missing-target-identity', 'hash-only-drift'])('engine raw lineage отвергает %s при semantic:true', (fault) => { + const scene = SERVER_PROFILE.engineScenes[1]; + const sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + validateServerEngineSample(sample, scene); + const measured = sample.raw[0], lineage = measured.raw; + if (fault === 'missing-read') lineage.clockReads.pop(); + if (fault === 'read-order') [lineage.clockReads[0], lineage.clockReads[1]] = [lineage.clockReads[1], lineage.clockReads[0]]; + if (fault === 'impossible-ns' || fault === 'coherent-impossible-ns') { + measured.operationNs++; + if (fault === 'coherent-impossible-ns') { + lineage.clockReads[1].valueNs = String(BigInt(lineage.clockReads[1].valueNs) + 1n); + lineage.cpuReads[1].valueNs = lineage.clockReads[1].valueNs; + } + sample.operationNs = sample.raw.reduce((sum: number, raw: any) => sum + raw.operationNs, 0) / sample.repetitions; + } + if (fault === 'missing-cpu-field') delete lineage.cpuReads[1].seconds; + if (fault === 'backward-native-counter') { + lineage.clockReads[2].valueNs = String(BigInt(lineage.clockReads[1].valueNs) - 1n); + lineage.cpuReads[2] = nativeCpuEndpoint(lineage.clockReads[2]); + measured.frameNs[0] = Number(BigInt(lineage.clockReads[3].valueNs) - BigInt(lineage.clockReads[2].valueNs)); + sample.meanFrameNs = sample.raw.reduce((sum: number, raw: any) => sum + raw.frameNs.reduce((a: number, b: number) => a + b, 0) / raw.frameNs.length, 0) / sample.repetitions; + } + if (fault === 'last-target-coordinate') { + const first = lineage.targetTraces.runs[0], last = clone(first.trace); + first.count--; + last.values[5] = last.values[5].replace('160px', '161px'); last.value = last.values[5]; last.events.at(-1).value = last.value; + lineage.targetTraces.runs.push({ from: scene.count - 1, count: 1, trace: last }); + const firstHash = measured.semantic.targetTraceHashes.value; + measured.semantic.targetTraceHashes = Array(scene.count).fill(firstHash); + measured.semantic.targetTraceHashes[scene.count - 1] = createHash('sha256').update(JSON.stringify(last.values)).digest('hex'); + } + if (fault === 'missing-target-identity') lineage.targetTraces.runs[0].count--; + if (fault === 'hash-only-drift') measured.semantic.targetTraceHashes.value = hash; + // Вызов новый: local projection cache не переносит trusted snapshot между проверками. + expect(() => validateServerEngineSample(sample, scene)).toThrow(/lineage|CPU|raw target/); + }); + it.each(['duration64', 'duration256', 'quadratic-last-target', 'missing-frame-time'])('raw normal-motion oracle пересчитывает %s при valid:true', (fault) => { + const scene = SERVER_PROFILE.browserScenes[0]; + const sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + for (const checkpoint of sample.semanticEvidence.checkpoints) { + const group = checkpoint.groups[0], time = checkpoint.frameTimestampMs; + if (fault === 'missing-frame-time') { delete checkpoint.frameTimestampMs; continue; } + const positions = Array(scene.targetsPerCall).fill(SERVER_PROFILE.toPx * time / SERVER_PROFILE.durationMs); + if (fault === 'quadratic-last-target') positions[scene.targetsPerCall - 1] = SERVER_PROFILE.toPx * (time / SERVER_PROFILE.durationMs) ** 2; + else positions.fill(SERVER_PROFILE.toPx * Math.min(1, time / (fault === 'duration64' ? 64 : 256))); + group.positions = compactServerSemanticEvidence({ ...sample.semanticEvidence, checkpoints: [{ ...checkpoint, groups: [{ ...group, positions }] }] }).checkpoints[0].groups[0].positions; + } + sample.semanticEvidence.valid = true; + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + }); + it.each([{ durationMultiplier: 0.5 }, { durationMultiplier: 2 }, { shape: 'quadratic' as const }, { rafStepMs: 300 }])( + 'отвергает чужую duration/shape и неразрешимое rAF окно %j', async (options) => { + const fake = syntheticBrowser(options); + try { + const error: any = await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0]).catch((error) => error); + expect(error).toBeInstanceOf(AggregateError); + expect(error.raw.partial.find((row: any) => row.phase === 'normal-motion').evidence.valid).toBe(false); + expect(fake.read().starts).toBe(1); + } finally { fake.dispose(); } + }); + it.each([ + { name: '128мс: узкое окно при позднем таймере', options: { timerLagMs: 40 }, expected: true }, + { name: '128мс: широкое неразрешающее окно', options: { timerLagMs: 40, readCostMs: 0.32 }, expected: false }, + { name: '256мс: честное широкое окно', options: { durationMultiplier: 2, timerLagMs: 40, readCostMs: 0.32 }, expected: false }, + ])('producer/consumer нормального движения: $name', async ({ options, expected }) => { + const scene = SERVER_PROFILE.browserScenes[0], fake = syntheticBrowser(options); + try { + const evidence = await syntheticSemanticControl(fake, scene); + expect(evidence.valid).toBe(expected); + const sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + // Пересчитываем acquired окна и CSS даже при поддельном upstream valid. + sample.semanticEvidence = compactServerSemanticEvidence({ ...evidence, valid: true }); + if (expected) expect(() => validateServerBrowserSample(sample, scene)).not.toThrow(); + else expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + expect(fake.read()).toEqual({ starts: 1, cancels: 1, connected: 0 }); + } finally { fake.dispose(); } + }); + it.each(SERVER_PROFILE.browserScenes)('отвергает начальный скачок0→75px в $id при valid:true', async (scene) => { + const fake = syntheticBrowser({ initialProgress: 0.25 }); + try { + const evidence = await syntheticSemanticControl(fake, scene); + expect(evidence.onset.before[0].positions).toEqual(Array(scene.targetsPerCall).fill(0)); + expect(evidence.onset.after[0].positions[0]).toBeGreaterThanOrEqual(75); + expect(evidence.valid).toBe(false); + const sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + sample.semanticEvidence = compactServerSemanticEvidence({ ...evidence, valid: true }); + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + expect(fake.read()).toEqual({ starts: 1, cancels: 1, connected: 0 }); + } finally { fake.dispose(); } + }); + it.each(['missing-before', 'missing-after', 'missing-last-coordinate', 'wrong-before', 'post-before-start', 'wide-before', 'before-phase-drift'])( + 'fresh onset decoder/oracle отвергает %s', (fault) => { + const scene = SERVER_PROFILE.browserScenes[0], sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + if (fault === 'missing-before') delete sample.semanticEvidence.onset.before; + if (fault === 'missing-after') delete sample.semanticEvidence.onset.after; + if (fault === 'missing-last-coordinate') sample.semanticEvidence.onset.before[0].positions.count--; + if (fault === 'wrong-before') sample.semanticEvidence.onset.before[0].positions.runs = [[99, 0], [1, 75]]; + if (fault === 'post-before-start') sample.semanticEvidence.callStartedAtMs[0] = 1; + if (fault === 'wide-before') sample.semanticEvidence.onset.before[0].readEndedMs = 20; + if (fault === 'before-phase-drift') sample.semanticEvidence.onset.before[0].readStartedMs = -1; + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + }); + it('сохраняет неполный acquired onset до отказа и все extra raw fields', async () => { + const scene = SERVER_PROFILE.browserScenes[0], fake = syntheticBrowser({ onsetReadAt: 17 }); + try { + const evidence = await syntheticSemanticControl(fake, scene); + expect(evidence.valid).toBe(false); expect(evidence.onset.before[0].positions).toHaveLength(17); + expect(evidence.onset.before[0].readEndedMs).toBeUndefined(); expect(evidence.onset.after).toHaveLength(0); + const raw = { ...evidence, onset: { ...evidence.onset, acquiredNote: 'не синтезировать остальные координаты' } }; + const compacted = compactServerSemanticEvidence(raw); + expect(compacted.onset.before[0].positions).toEqual({ encoding: 'rle', count: 17, runs: [[17, 0]] }); + expect(compacted.onset.before[0].readEndedMs).toBeUndefined(); expect(compacted.onset.after).toEqual([]); + expect(compacted.onset.acquiredNote).toBe(raw.onset.acquiredNote); + expect(fake.read()).toEqual({ starts: 0, cancels: 0, connected: 0 }); + } finally { fake.dispose(); } + }); + it.each(SERVER_PROFILE.browserScenes)('наблюдает intermediate $id и все32/64 useful owner outcomes', async (scene) => { + for (const multiplier of [1, 2]) { + const fake = syntheticBrowser(); + try { + const sample = await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, scene, multiplier); + expect(sample.semanticEvidence.valid).toBe(true); + expect(sample.raw).toHaveLength(SERVER_PROFILE.repetitions); + expect(sample.raw.every((row: any) => row.calls === SERVER_PROFILE.browserBatchCalls * multiplier && row.ownersCancelled === row.calls)).toBe(true); + expect(fake.read().connected).toBe(0); + } finally { fake.dispose(); } + } + }); + + it.each(['missing', 'unstable', 'unrelated'] as const)('producer отказывает при %s document frame и сохраняет приобретённый trace', async (documentClock) => { + const fake = syntheticBrowser({ documentClock }); + try { + let failure: any; + try { await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0]); } + catch (error) { failure = error; } + expect(failure).toMatchObject({ name: 'AggregateError' }); + expect(failure.raw.semanticEvidence.valid).toBe(false); + expect(failure.raw.semanticEvidence.checkpoints).toHaveLength(3); + expect(failure.raw.semanticEvidence.checkpoints[0].groups[0]).toHaveProperty('documentFrame'); + expect(fake.read()).toEqual({ starts: 1, cancels: 1, connected: 0 }); + } finally { fake.dispose(); } + }); + + it.each(['missing-frame', 'missing-end', 'unstable', 'RAF-disagreement', 'future-clock'])('consumer отвергает %s при valid:true', (fault) => { + const scene = SERVER_PROFILE.browserScenes[0], sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + const group = sample.semanticEvidence.checkpoints[0].groups[0]; + if (fault === 'missing-frame') delete group.documentFrame; + if (fault === 'missing-end') delete group.documentFrame.afterMs; + if (fault === 'unstable') group.documentFrame.afterMs += 0.001; + if (fault === 'RAF-disagreement') { group.documentFrame.beforeMs++; group.documentFrame.afterMs++; } + if (fault === 'future-clock') for (const checkpoint of sample.semanticEvidence.checkpoints) { + checkpoint.frameTimestampMs += 1e9; + for (const current of checkpoint.groups) { + current.readStartedMs += 1e9; current.readEndedMs += 1e9; + current.documentFrame.beforeMs += 1e9; current.documentFrame.afterMs += 1e9; + } + } + expect(sample.semanticEvidence.valid).toBe(true); + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion|clock/); + }); + + it('fresh API и CSS публикация предыдущего кадра сохраняют здоровый128ms raw', () => { + const scene = SERVER_PROFILE.browserScenes[0], sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + const evidence = sample.semanticEvidence; + // Приобретённые координаты/времена primary b214: прежний wall-after + // ошибочно требовал phase≥2.85ms, хотя CSS опубликован до API frame. + evidence.callStartedAtMs = [0.845]; + evidence.onset.before[0] = { readStartedMs: 0.01, readEndedMs: 0.84, + documentFrame: { beforeMs: -15.735, afterMs: -15.735 }, positions: { encoding: 'rle', count: scene.targetsPerCall, runs: [[scene.targetsPerCall, 0]] } }; + evidence.onset.after[0] = { readStartedMs: 3.065, readEndedMs: 3.73, + documentFrame: { beforeMs: -15.735, afterMs: -15.735 }, positions: { encoding: 'rle', count: scene.targetsPerCall, runs: [[scene.targetsPerCall, 0]] } }; + evidence.onset.firstFrame = { frameTimestampMs: 0.935, groups: [{ readStartedMs: 4, readEndedMs: 4.1, + documentFrame: { beforeMs: 0.935, afterMs: 0.935 }, positions: { encoding: 'rle', count: scene.targetsPerCall, runs: [[scene.targetsPerCall, 0]] } }] }; + evidence.checkpoints = [[34.265, 35.15, 35.94, 78.1172], [67.595, 68.55, 69.145, 156.234], [84.265, 85.22, 85.9, 195.305]] + .map(([frame, started, ended, value]) => ({ frameTimestampMs: frame, groups: [{ readStartedMs: started, readEndedMs: ended, + documentFrame: { beforeMs: frame, afterMs: frame }, positions: { encoding: 'rle', count: scene.targetsPerCall, runs: [[scene.targetsPerCall, value]] } }] })); + expect(() => validateServerBrowserSample(sample, scene)).not.toThrow(); + evidence.onset.after[0].positions.runs[0][1] = 75; + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + }); + + it.each(['before-missing', 'after-missing', 'after-unstable', 'after-future', 'after-backwards'])('consumer отвергает onset frame %s при valid:true', (fault) => { + const scene = SERVER_PROFILE.browserScenes[0], sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + const onset = sample.semanticEvidence.onset; + if (fault === 'before-missing') delete onset.before[0].documentFrame; + if (fault === 'after-missing') delete onset.after[0].documentFrame; + if (fault === 'after-unstable') onset.after[0].documentFrame.afterMs += 0.001; + if (fault === 'after-future') onset.after[0].documentFrame = { beforeMs: 1, afterMs: 1 }; + if (fault === 'after-backwards') onset.after[0].documentFrame = { beforeMs: -1, afterMs: -1 }; + expect(sample.semanticEvidence.valid).toBe(true); + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion|clock/); + }); + + it('mixed document/perf envelope покрывает независимые ошибки frame/now/origin, сохраняя API-cost envelope', () => { + const host = '1000000000000', cost = serverBrowserClockBounds({ beginMs: 0, endMs: 0 }, host).errorMs; + const semantic = serverBrowserSemanticClockErrorMs(host); + // Независимые ошибки трёх приобретённых timestamps, с обоими направлениями + // clamp/truncation. Origin сокращается только между perf endpoints. + for (const frameError of [-0.006, 0, 0.006]) for (const nowError of [-0.006, 0, 0.006]) for (const originError of [-0.006, 0, 0.006]) { + const mixedObserved = 64 + frameError - nowError + originError; + expect(Math.abs(mixedObserved - 64)).toBeLessThanOrEqual(semantic); + } + expect(cost).toBeLessThan(0.0120001); expect(semantic).toBeGreaterThanOrEqual(0.018); + }); + + it.each(SERVER_PROFILE.browserScenes.flatMap((scene) => [1, 2].map((frame) => ({ scene, frame }))))('старый doc clock не подменяет полезную публикацию $scene.id frame$frame', async ({ scene, frame }) => { + const healthy = syntheticBrowser({ documentOriginLagMs: 50 }); + const faulty = syntheticBrowser({ documentOriginLagMs: 50, quarterAtFrame: frame }); + try { + const good: any = await syntheticSemanticControl(healthy, scene), bad: any = await syntheticSemanticControl(faulty, scene); + expect(good.valid).toBe(true); expect(bad.valid).toBe(false); + expect(bad.onset.before[0].positions.every((value: number) => value === 0)).toBe(true); + expect(bad.onset.after[0].positions.every((value: number) => value === 0)).toBe(true); + if (frame === 1) expect(bad.onset.firstFrame.groups[0].positions[0]).toBeGreaterThanOrEqual(75); + else expect(bad.onset.firstFrame.groups[0].positions.every((value: number) => Math.abs(value) <= 0.5)).toBe(true); + const sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + sample.semanticEvidence = compactServerSemanticEvidence({ ...bad, valid: true }); + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + expect(healthy.read().connected).toBe(0); expect(faulty.read().connected).toBe(0); + } finally { healthy.dispose(); faulty.dispose(); } + }); + + it.each(['missing', 'nonzero', 'unstable', 'no-RAF', 'before-API-read'])('consumer отвергает first publication %s при valid:true', (fault) => { + const scene = SERVER_PROFILE.browserScenes[0], sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + const first = sample.semanticEvidence.onset.firstFrame; + if (fault === 'missing') delete sample.semanticEvidence.onset.firstFrame; + if (fault === 'nonzero') first.groups[0].positions.runs[0][1] = 75; + if (fault === 'unstable') first.groups[0].documentFrame.afterMs += 0.001; + if (fault === 'no-RAF') delete first.frameTimestampMs; + if (fault === 'before-API-read') first.groups[0].readStartedMs = 0; + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/normal-motion/); + }); + + it('endpoint snap и stateful nth-call snap отказывают до semantic:true', async () => { + for (const options of [{ snap: true }, { snapAt: 9 }]) { + const fake = syntheticBrowser(options); + try { await expect(measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0])).rejects.toMatchObject({ name: 'AggregateError' }); } + finally { fake.dispose(); } + } + }); + + it.each([3, 9])('сохраняет всю acquired работу при скачке0→75px только с timed вызова%s', async (initialProgressAt) => { + const fake = syntheticBrowser({ initialProgress: 0.25, initialProgressAt }); + try { + let failure: any; + try { await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0]); } + catch (error) { failure = error; } + expect(failure).toMatchObject({ name: 'AggregateError' }); + expect(failure.raw.semanticEvidence.valid).toBe(true); + expect(failure.raw.raw).toHaveLength(SERVER_PROFILE.repetitions); + expect(failure.raw.warmup).toHaveLength(1); + expect(failure.raw.raw.every((row: any) => row.ownersStarted === SERVER_PROFILE.browserBatchCalls && row.ownersCancelled === row.ownersStarted)).toBe(true); + expect(fake.read().connected).toBe(0); + expect(() => validateServerBrowserSample(failure.raw, SERVER_PROFILE.browserScenes[0])).toThrow(/начала|onset/); + } finally { fake.dispose(); } + }); + + it('consumer повторно выводит timed onset из actual start/read clocks при valid:true', () => { + const scene = SERVER_PROFILE.browserScenes[0], sample = stage().rows.find((row: any) => row.scene === scene.id).samples.left; + const raw = sample.raw[0]; raw.startClock.endMs = raw.startClock.beginMs + 0.8; + raw.batchStartMs = raw.startClock.endMs - raw.startClock.beginMs; raw.startMs = raw.batchStartMs / SERVER_PROFILE.browserBatchCalls; + raw.startWitness.readClock = { beginMs: raw.startClock.endMs + 0.001, endMs: raw.startClock.endMs + 0.002 }; + raw.startWitness.leadingPositions = { encoding: 'repeat', count: raw.calls, value: 75 }; + sample.startMs = sample.raw.reduce((sum: number, row: any) => sum + row.startMs, 0) / sample.repetitions; + expect(sample.semanticEvidence.valid).toBe(true); + expect(() => validateServerBrowserSample(sample, scene)).toThrow(/начала|onset/); + }); + + it('один batch отличает25us от27us; квант5us не скрывает8% в CI', async () => { + const measured: any[] = []; + for (const startCostMs of [0.025, 0.027]) { + const fake = syntheticBrowser({ startCostMs }); + try { measured.push(await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0])); } + finally { fake.dispose(); } + } + const values = pairs(); + const target = values.find((cell) => cell.id === 's2:startMs')!; + const smallStage = stage(); + for (const row of smallStage.rows.filter((row) => row.scene === 's2')) row.samples = { left: measured[0], right: measured[1] }; + const actual = serverCellPairs(smallStage, 2, 'aa').find((cell) => cell.id === target.id)!; + target.left.fill(actual.left[0]); target.right.fill(actual.right[0]); + target.leftBounds.fill(actual.leftBounds[0]); target.rightBounds.fill(actual.rightBounds[0]); + const contrast = serverFamilyIntervals(values).find((cell) => cell.id === target.id)!; + expect(contrast.p95.high).toBeGreaterThan(SERVER_PROFILE.nonInferiorityUpper); + expect(contrast.p95.baseline.low).toBeLessThanOrEqual(0.025); + expect(contrast.p95.candidate.high!).toBeGreaterThanOrEqual(0.027); + }); + + it('обе стороны dither/floor и binary64 error остаются в pointwise envelope', () => { + const q = 0.005; + for (let index = 0; index < 100; index++) { + const begin = index * 0.00017, duration = index % 2 ? 0.8 : 0.864; + const clamp = (time: number) => Math.floor(time / q) * q + ((time / q - Math.floor(time / q)) >= 0.23 ? q : 0); + const bound = serverBrowserClockBounds({ beginMs: clamp(begin), endMs: clamp(begin + duration) }, '1000000000000'); + expect(bound.low).toBeLessThanOrEqual(duration); expect(bound.high).toBeGreaterThanOrEqual(duration); + } + const bootMs = 2 ** 41, originMs = bootMs - 100; + const physicalBeginUs = BigInt(bootMs) * 1000n + 500n, physicalEndUs = physicalBeginUs + 864n; + const interval = { beginMs: Number(physicalBeginUs) / 1000 - originMs, endMs: Number(physicalEndUs) / 1000 - originMs }; + const bound = serverBrowserClockBounds(interval, ((physicalEndUs + 1000n) * 1000n).toString()); + expect(bound.low).toBeLessThanOrEqual(0.864); expect(bound.high).toBeGreaterThanOrEqual(0.864); + expect(() => serverBrowserClockBounds(interval, '-1')).toThrow(); + expect(() => serverBrowserClockBounds(interval, (BigInt(SERVER_PROFILE.clockError.monotonicCounterLimitMs) * 1_000_000n).toString())).toThrow(); + }); + + it('не усредняет clock error как noise и не допускает неразрешимую A/A', () => { + const value = pairs(); + for (const cell of value) { + cell.leftBounds.fill({ low: 96, high: 104 }); cell.rightBounds.fill({ low: 96, high: 104 }); + } + const intervals = serverFamilyIntervals(value); + expect(intervals.every((cell) => cell.p95.high! >= 104 / 96)).toBe(true); + expect(serverCalibrationVerdict(intervals, serverFamilyIntervals(pairs(SERVER_PROFILE.minRuns, 2)), planServerSampleSize(pairs(SERVER_PROFILE.pilotRuns))).verdict).toBe('UNPROVEN'); + delete (value[0] as any).leftBounds; + expect(() => serverFamilyIntervals(value)).toThrow(/pointwise/); + }); + + it('normal-motion RLE сохраняет все targets и отвергает snap с valid:true', () => { + const value = stage(); + const sample = value.rows.find((row) => row.scene === 's3')!.samples.left; + sample.semanticEvidence = compactServerSemanticEvidence(sample.semanticEvidence); + expect(() => validateServerBrowserSample(sample, SERVER_PROFILE.browserScenes[1])).not.toThrow(); + sample.semanticEvidence.checkpoints[0].groups[0].positions.runs = [[SERVER_PROFILE.browserScenes[1].targetsPerCall, 300]]; + expect(() => validateServerBrowserSample(sample, SERVER_PROFILE.browserScenes[1])).toThrow(/normal-motion/); + }); + + it('failed browser batch сохраняет acquired operation, open cancel и undefined cause', async () => { + const fake = syntheticBrowser({ cancelAt: 3 }); + try { + const error: any = await measureServerBrowser(fake.browser, { url: 'synthetic://profile' }, fake.adapter, SERVER_PROFILE.browserScenes[0]).catch((error) => error); + expect(error.errors).toEqual([undefined]); + const row = error.raw.partial.find((row: any) => row.phase === 'batch-cancel-failed'); + expect(row.batchStartMs).toBeGreaterThan(0); expect(row.ownersStarted).toBe(32); expect(row.ownersCancelled).toBe(0); + expect(row.unfinishedCancelClock.endMs).toBeGreaterThanOrEqual(row.unfinishedCancelClock.beginMs); + expect(row.error).toEqual({ name: 'undefined', message: 'undefined' }); + } finally { fake.dispose(); } + const rejection = syntheticBrowser({ rejectTiming: true }); + try { + const error: any = await measureServerBrowser(rejection.browser, { url: 'synthetic://profile' }, rejection.adapter, SERVER_PROFILE.browserScenes[0]).catch((error) => error); + expect(error.errors).toEqual([undefined]); expect(error.raw.partial.some((row: any) => row.phase === 'normal-motion')).toBe(true); + } finally { rejection.dispose(); } + }); + + it('итоговая сериализация сохраняет JSON identity и не требует общей строки V8', () => { + const value = { a: [{ raw: [1, undefined, 3] }], missing: undefined, nested: { b: 'данные', c: null } }; + expect([...serverArtifactChunks(value)].join('')).toBe(`${JSON.stringify(value)}\n`); + const large = { rows: Array(5400).fill({ data: 'a'.repeat(100_000) }) }; + let bytes = 0, maxChunkBytes = 0; + for (const chunk of serverArtifactChunks(large)) { const count = Buffer.byteLength(chunk); bytes += count; maxChunkBytes = Math.max(maxChunkBytes, count); } + expect(bytes).toBeGreaterThan(2 ** 29); expect(maxChunkBytes).toBeLessThan(101_000); + const directory = mkdtempSync(path.join(os.tmpdir(), 'motion-server-json-')); + try { + const file = path.join(directory, 'artifact.json'); const result = writeServerArtifact(file, value); + expect(readFileSync(file, 'utf8')).toBe(`${JSON.stringify(value)}\n`); + expect(result.sha256).toBe(serverArtifactDigest(value)); expect(result.bytes).toBe(Buffer.byteLength(readFileSync(file))); + expect(() => writeServerArtifact(file, value)).toThrow(/EEXIST/); + } finally { rmSync(directory, { recursive: true, force: true }); } + }); +}); + +describe('серверный PROFILE: заранее зарегистрированные границы', () => { + it('сохраняет невозможную мощность до отказа и не запускает A/A, 2×work или кандидат', async () => { + const artifact: any = registeredRefusal(); + artifact.failures = []; + const calls: any[] = [], events: any[] = []; + const runStage = async (name: string, runs: number) => { + calls.push({ name, runs }); + if (!['warmup', 'pilot'].includes(name)) throw new Error('после невозможного N запущена новая стадия'); + const value = stage(name, runs); + if (name === 'pilot') for (const row of value.rows.filter((row) => row.scene === 'motion-value-default-stock-c')) { + const factor = [1, 1, 100, 100, 2, 2, 3, 3][row.run]; + const sample = row.samples.right; + sample.operationNs *= factor; + for (const raw of sample.raw) { + raw.operationNs *= factor; + for (const read of raw.raw.clockReads) read.valueNs = String(BigInt(read.valueNs) * BigInt(factor)); + raw.raw.cpuReads = raw.raw.clockReads.map((read: any) => nativeCpuEndpoint(read)); + } + } + return value; + }; + await expect(runServerProfileCalibration(artifact, runStage, (type: string, value: any) => events.push({ type, value }))) + .rejects.toMatchObject({ code: 'UNPROVEN_POWER' }); + expect(calls).toEqual([{ name: 'warmup', runs: SERVER_PROFILE.warmupRuns }, { name: 'pilot', runs: SERVER_PROFILE.pilotRuns }]); + expect(artifact.samplePlan).toMatchObject({ feasible: false, runs: SERVER_PROFILE.maxRuns }); + expect(artifact.samplePlan.requiredRuns).toBeGreaterThan(SERVER_PROFILE.maxRuns); + expect(events).toEqual([{ type: 'N-frozen-before-calibration-and-AB', value: { + samplePlan: artifact.samplePlan, digest: serverProfileDigest({ registrationDigest: artifact.registrationDigest, samplePlan: artifact.samplePlan }), + } }]); + expect(artifact.aa).toBeUndefined(); expect(artifact.positive).toBeUndefined(); expect(artifact.ab).toBeUndefined(); + }); + + it('отмена перед запуском сохраняет отказ, digest и завершённый журнал', async () => { + const directory = mkdtempSync(path.join(os.tmpdir(), 'motion-profile-stop-')); + const out = path.join(directory, 'out'), controller = new AbortController(); + const reason = Object.assign(new Error('остановлено оператором'), { code: 'OPERATOR_INTERRUPTION', raw: { signal: 'SIGTERM' } }); + controller.abort(reason); + try { + const artifact = await runServerProfile({ baseline: directory, candidate: directory, browser: 'chromium', out }, { signal: controller.signal }); + expect(artifact.verdict).toBe('UNPROVEN'); + expect(artifact.failures).toHaveLength(1); + expect(artifact.failures[0].error).toMatchObject({ code: 'OPERATOR_INTERRUPTION', raw: { signal: 'SIGTERM' } }); + expect(artifact.registration).toBeNull(); expect(artifact.stages).toEqual([]); + expect(readFileSync(path.join(out, 'server-profile.json'), 'utf8')).toBe(`${JSON.stringify(artifact)}\n`); + const records = parseServerJournalBytes(readFileSync(path.join(out, 'journal.ndjson'))); + expect(records.map((record: any) => record.type)).toEqual(['failure', 'finished']); + expect(records.at(-1).value).toEqual({ verdict: 'UNPROVEN', digest: serverArtifactDigest(artifact) }); + } finally { rmSync(directory, { recursive: true, force: true }); } + }); + + it('отмена внутри получения sample сохраняет его до остановки следующего владельца', async () => { + const source = readFileSync(new URL('../bench/profile/server-profile-runner.mjs', import.meta.url), 'utf8'); + const begin = source.indexOf(' const runStage = async (name, runs) => {'); + const end = source.indexOf(' if (!await runServerProfileCalibration(', begin); + expect(begin).toBeGreaterThan(0); expect(end).toBeGreaterThan(begin); + const controller = new AbortController(), reason = new Error('остановлено после приобретения sample'); + const artifact: any = { stages: [] }, records: any[] = []; + const sample: any = stage('warmup', 2).rows[0].samples.left; + const measure = vi.fn(async () => { controller.abort(reason); return sample; }); + const context = createContext({ artifact, SERVER_PROFILE: { ...SERVER_PROFILE, engineScenes: [SERVER_PROFILE.engineScenes[0]], browserScenes: [] }, + checkpoint: () => controller.signal.throwIfAborted(), captureServerLoad: () => ({ cpuStat: {} }), + serverOrders, engineMeasure: measure, browserMeasure: vi.fn(), implementations: { baseline: {} }, + compactSampleCpuEvidence: (value: any) => { for (const row of value.raw) row.raw.cpuReads = compactServerCpuEvidence(row.raw.cpuReads); }, + journal: (type: string, value: any) => records.push({ type, value }), verify: vi.fn(), process: { stderr: { write: vi.fn() } } }); + const runStage = runInContext(`(() => { ${source.slice(begin, end)} return runStage; })()`, context); + await expect(runStage('warmup', 2)).rejects.toBe(reason); + expect(measure).toHaveBeenCalledTimes(1); + expect(artifact.warmup.rows).toHaveLength(1); + expect(artifact.warmup.rows[0].samples).toEqual({ left: sample }); + expect(records).toEqual([{ type: 'sample', value: { stage: 'warmup', kind: 'engine', scene: SERVER_PROFILE.engineScenes[0].id, + run: 0, participant: 'left', build: 'baseline', value: sample } }]); + }); + + it('не выдаёт server CPU за mobile/GPU/экран или продуктовые семейства', () => { + expect(SERVER_PROFILE.unproven).toContain('mobile Android/iOS'); + expect(SERVER_PROFILE.unproven).toContain('whole-page energy'); + expect(SERVER_PROFILE.unproven).toContain('M-05 product scene families'); + expect(SERVER_PROFILE.nonInferiorityUpper).toBe(1.05); + expect(verifyServerProfile(clone(SERVER_PROFILE))).toBeUndefined(); + const changed: any = clone(SERVER_PROFILE); changed.nonInferiorityUpper = 1.06; + expect(() => verifyServerProfile(changed)).toThrow(); + }); + + it('выводит N из независимых baseline blocks и сохраняет невозможную мощность', () => { + expect(planServerSampleSize(pairs(SERVER_PROFILE.pilotRuns))).toMatchObject({ runs: 292, feasible: true }); + const noisy = pairs(SERVER_PROFILE.pilotRuns); + noisy[0].right = [100, 100, 1000, 1000, 10, 10, 100, 100]; + expect(planServerSampleSize(noisy)).toMatchObject({ runs: SERVER_PROFILE.maxRuns, feasible: false }); + expect(() => planServerSampleSize(noisy.slice(1))).toThrow(); + noisy[0].left.pop(); expect(() => planServerSampleSize(noisy)).toThrow(); + }); + + it('family-wise CI различает тождественный build, реальную регрессию и 2×work', () => { + const aa = serverFamilyIntervals(pairs()); + const positive = serverFamilyIntervals(pairs(SERVER_PROFILE.minRuns, 2)); + expect(aa.every((x) => x.p95.high >= 1 && x.p95.high! < 1 + 1e-12 && x.p95.low <= 1 && x.p95.low > 1 - 1e-12)).toBe(true); + expect(positive.every((x) => x.p50.low <= 2 && x.p50.low > 2 - 1e-12)).toBe(true); + const plan = planServerSampleSize(pairs(SERVER_PROFILE.pilotRuns)); + expect(serverCalibrationVerdict(aa, positive, plan).verdict).toBe('PASS'); + const regression = serverFamilyIntervals(pairs(SERVER_PROFILE.minRuns, 1.08)); + expect(serverCalibrationVerdict(regression, positive, plan).verdict).toBe('UNPROVEN'); + expect(serverCalibrationVerdict(aa, aa, plan).verdict).toBe('UNPROVEN'); + expect(serverCalibrationVerdict(aa, positive, { ...plan, feasible: false }).verdict).toBe('UNPROVEN'); + expect(() => serverFamilyIntervals(pairs().slice(1))).toThrow(); + const zero = pairs(); zero[0].left[0] = 0; + expect(() => serverFamilyIntervals(zero)).toThrow(); + }); + + it('не даёт finite p95 upper короткой серии, пропускающей редкий 2×stall', () => { + const short = serverFamilyIntervals(pairs(20)); + expect(0.94 ** 10).toBeGreaterThan(SERVER_PROFILE.familyAlpha); + expect(short.every((cell) => !cell.p95.bounded && cell.p95.high === null)).toBe(true); + const policy = serverTailPolicy(); + expect(policy.alphaPerTail).toBe(1 / 1760); + expect(policy.minimumBlocks).toBe(146); + expect(serverOrderStatisticBounds(Array(145).fill(1), 0.95, policy.alphaPerTail).high).toBeNull(); + expect(serverOrderStatisticBounds(Array(146).fill(1), 0.95, policy.alphaPerTail).high).toBe(1); + expect(19n ** 146n * 1760n <= 20n ** 146n).toBe(true); + expect(19n ** 145n * 1760n <= 20n ** 145n).toBe(false); + }); +}); + +describe('серверный PROFILE: независимые sabotage controls', () => { + it('восстанавливает метрику из raw и не делит deliberate 2×work на два', () => { + const result = serverCellPairs(stage('positive'), 2, 'positive'); + expect(result.every((x) => x.right[0] === x.left[0] * 2)).toBe(true); + const changed = stage('positive'); + changed.rows[0].samples.right.meanFrameNs /= 2; + expect(() => serverCellPairs(changed, 2, 'positive')).toThrow(/знаменателя/); + }); + + it.each(['missing', 'duplicate', 'order', 'nonfinite', 'denominator', 'semantic', 'clock', 'endpoint'])('отвергает %s evidence', (mutation) => { + const value = stage(); + const engine = value.rows.find((row) => row.kind === 'engine')!; + const browser = value.rows.find((row) => row.kind === 'browser')!; + if (mutation === 'missing') delete engine.samples.left; + if (mutation === 'duplicate') value.rows[1] = value.rows[0]; + if (mutation === 'order') engine.order.reverse(); + if (mutation === 'nonfinite') engine.samples.left.raw[0].operationNs = NaN; + if (mutation === 'denominator') engine.samples.left.repetitions *= 2; + if (mutation === 'semantic') engine.samples.left.raw[0].semantic.pending = 1; + if (mutation === 'clock') browser.samples.left.measurementTimeOriginMs += 1; + if (mutation === 'endpoint') browser.samples.left.endpoints[0] = 0; + expect(() => serverCellPairs(value, 2, 'aa')).toThrow(); + }); + + it('регистрация и frozen N действительно предшествуют samples', () => { + const artifact: any = { registration: null, registrationDigest: null, verdict: 'UNPROVEN', failures: [{ stage: 'preparation', error: { message: 'нет среды' } }] }; + function journal(events: any[]) { + let previous = '0'.repeat(64); + return events.map((event) => { + const payload = { sequenceDigest: previous, ...event }; + previous = serverProfileDigest(payload); return { ...payload, digest: previous }; + }); + } + const failure = { type: 'failure', value: artifact.failures[0] }; + const finished = { type: 'finished', value: { verdict: artifact.verdict, digest: serverArtifactDigest(artifact) } }; + expect(validateServerJournal(artifact, journal([failure, finished]))).toHaveProperty('journalFinalDigest'); + const sample = { type: 'sample', value: { stage: 'ab', scene: 's2', run: 0, participant: 'right', build: 'candidate', value: {} } }; + expect(() => validateServerJournal(artifact, journal([sample, failure, finished]))).toThrow(/до preregistration/); + expect(() => validateServerJournal(artifact, journal([finished]))).toThrow(/failures/); + const broken = journal([failure, finished]); broken[0].digest = 'b'.repeat(64); + expect(() => validateServerJournal(artifact, broken)).toThrow(/цепь/); + }); + + it('допущенный UNPROVEN всё равно проверяет поздние body hashes после failure/chronology', () => { + const artifact: any = { registration: null, registrationDigest: null, verdict: 'UNPROVEN', failures: [{ stage: 'preparation', error: { message: 'сохранённый отказ' } }] }; + const events = [{ type: 'failure', value: artifact.failures[0] }, { type: 'finished', value: { verdict: artifact.verdict, digest: serverArtifactDigest(artifact) } }]; + const healthy = chain(events); + expect(validateServerJournal(artifact, healthy)).toHaveProperty('journalFinalDigest'); + const malformed = clone(healthy); malformed[1].digest = 'b'.repeat(64); + expect(() => validateServerJournal(artifact, malformed)).toThrow(/цепь/); + const changedBody = clone(healthy); changedBody[1].unclaimed = 'body должен хешироваться целиком'; + expect(() => validateServerJournal(artifact, changedBody)).toThrow(/цепь/); + }); + + it('имя positive не позволяет спрятать одиночную работу; RLE не доверяет чужой длине', () => { + const positive = stage('positive'); positive.name = 'aa'; + expect(() => serverCellPairs(positive, 2, 'positive')).toThrow(/имя стадии/); + const wrongCount = stage(); wrongCount.rows[0].samples.left.raw[0].semantic.targetTraceHashes.count -= 1; + expect(() => serverCellPairs(wrongCount, 2, 'aa')).toThrow(/hash RLE|lifecycle witness/); + }); + + it.each(['waapi', 'transform', 'disconnected', 'missing-frame', 'RLE-length', 'generic-RLE-length'])('cancel witness отвергает %s sabotage', (mutation) => { + const value = stage(); + const witness = value.rows.find((row) => row.kind === 'browser')!.samples.left.raw[0].cancelWitness; + if (mutation === 'waapi') witness.frames[0].activeWaapi = 1; + if (mutation === 'transform') witness.frames[1].transforms.value = 1; + if (mutation === 'disconnected') witness.frames[0].connectedTargets -= 1; + if (mutation === 'missing-frame') witness.frames.pop(); + if (mutation === 'RLE-length') witness.transformsBefore.count -= 1; + if (mutation === 'generic-RLE-length') witness.transformsBefore = { encoding: 'rle', count: witness.connectedTargets, runs: [[witness.connectedTargets - 1, 0]] }; + expect(() => serverCellPairs(value, 2, 'aa')).toThrow(/cancel/); + }); + + let healthyAdmissionTask: TestContext['task'] | undefined; + const acceptedAdmission = () => { + // Полный setup и успешный admission принадлежат предыдущему timed test. + // Result учитывает также framework timeout; отдельный fault без healthy + // prerequisite даёт отказ, не skip и не самостоятельный setup. + expect(healthyAdmissionTask?.result?.state).toBe('pass'); + return admissionHistory(); + }; + + it('полный healthy admission создаёт и проверяет весь зарегистрированный N', ({ task }) => { + healthyAdmissionTask = task; + const history = admissionHistory(), { artifact } = history; + expect(validateServerArtifact(artifact).verdict).toBe('PASS'); + expect(validateServerJournal(artifact, history.records)).toHaveProperty('journalFinalDigest'); + }, 30_000); + + it('полная история отвергает calibration до завершения A/A и 2×work', () => { + const history = acceptedAdmission(), { artifact, events } = history; + const earlyCalibration = events.filter((event) => event.type !== 'calibration'); + earlyCalibration.splice(earlyCalibration.findIndex((event) => event.type === 'N-frozen-before-calibration-and-AB') + 1, 0, + { type: 'calibration', value: artifact.calibration }); + expect(() => validateServerJournal(artifact, chain(earlyCalibration, history))).toThrow(/до завершения/); + }, 30_000); + + it('полная история отвергает замену противоположного порядка пар', () => { + const history = acceptedAdmission(), { artifact, events } = history; + const alwaysLeft = [...events]; + const firstOpposite = alwaysLeft.findIndex((event) => event.type === 'sample' && event.value.participant === 'right'); + [alwaysLeft[firstOpposite], alwaysLeft[firstOpposite + 1]] = [alwaysLeft[firstOpposite + 1], alwaysLeft[firstOpposite]]; + expect(() => validateServerJournal(artifact, chain(alwaysLeft, history))).toThrow(/порядок/); + }, 30_000); + + it('полная история отвергает потерянный failure union', () => { + const history = acceptedAdmission(), { artifact, events } = history; + const ignoredFailure = [...events.slice(0, -1), { type: 'failure', value: { stage: 'ab', error: { message: 'retained reviewer failure' } } }, events.at(-1)]; + expect(() => validateServerJournal(artifact, chain(ignoredFailure, history))).toThrow(/failures/); + }, 30_000); + + it('полная история отвергает подмену имени positive', () => { + const { artifact } = acceptedAdmission(); + const wrongPositive = { ...artifact, positive: { ...artifact.positive, name: 'aa' } }; + expect(() => validateServerArtifact(wrongPositive)).toThrow(/имя стадии/); + }, 30_000); + + it('полная история отвергает подмену финального raw digest', () => { + const history = acceptedAdmission(), { artifact, events } = history; + const wrongFinish = [...events.slice(0, -1), { type: 'finished', value: { verdict: 'PASS', digest: 'b'.repeat(64) } }]; + expect(() => validateServerJournal(artifact, chain(wrongFinish, history))).toThrow(/финальная/); + }, 30_000); + + it('сохраняет partial A/B и поздний отказ, а пропавшие comparator/retention не допускает', () => { + const history = admissionHistory(), complete = history.artifact; + // Меняются только принадлежащие отказу ветви. Полная unchanged история + // Полный зарегистрированный N остаётся входом, без трёх лишних копий raw. + const partial: any = { ...complete, verdict: 'UNPROVEN', ab: { ...complete.ab } }; + const completeEvents = history.events; + const firstAb = completeEvents.findIndex((event) => event.type === 'sample' && event.value.stage === 'ab'); + const failed = completeEvents[firstAb + 1].value; + const error = { name: 'Error', message: 'timeout второго участника; первый raw сохранён', raw: { completed: [] } }; + partial.failures = [{ stage: 'ab', error }]; + partial.ab.rows = [{ ...partial.ab.rows[0], samples: { [completeEvents[firstAb].value.participant]: completeEvents[firstAb].value.value } }]; + partial.ab.blocks = []; delete partial.comparison; delete partial.comparators; delete partial.retention; + const partialEvents = [...completeEvents.slice(0, firstAb + 1), { type: 'failed-sample', value: { ...failed, value: undefined, error } }, + { type: 'failure', value: partial.failures[0] }, { type: 'finished', value: { verdict: 'UNPROVEN', digest: serverArtifactDigest(partial) } }]; + expect(validateServerArtifact(partial).verification).toBe('partial-samples-refused'); + expect(validateServerJournal(partial, chain(partialEvents, history))).toHaveProperty('journalFinalDigest'); + const missingFailure = partialEvents.filter((event) => event.type !== 'failure'); + expect(() => validateServerJournal(partial, chain(missingFailure, history))).toThrow(/failures/); + + const late: any = { ...complete, verdict: 'UNPROVEN' }; + const firstComparator = completeEvents.findIndex((event) => event.type === 'comparator-sample'); + const comparatorFailure = completeEvents[firstComparator + 1].value; + late.failures = [{ stage: 'ab', error }]; late.comparators = [{ ...late.comparators[0], rows: [late.comparators[0].rows[0]] }]; + delete late.retention; + const lateEvents = [...completeEvents.slice(0, firstComparator + 1), { type: 'failed-comparator-sample', value: { ...comparatorFailure, stage: 'ab', error } }, + { type: 'failure', value: late.failures[0] }, { type: 'finished', value: { verdict: 'UNPROVEN', digest: serverArtifactDigest(late) } }]; + expect(validateServerArtifact(late).verification).toBe('completed-samples-refused'); + expect(validateServerJournal(late, chain(lateEvents, history))).toHaveProperty('journalFinalDigest'); + + const dropped: any = { ...complete, retention: { ...complete.retention } }; delete dropped.retention.candidate; + expect(() => validateServerArtifact(dropped)).toThrow(/retention/); + const omitted = completeEvents.filter((event) => event.type !== 'comparator-sample'); + expect(() => validateServerJournal(complete, chain(omitted, history))).toThrow(/retention/); + }, 30_000); + + it('сохраняет историческое throttle отдельно от DELTA и закрывает нарушение условий', () => { + const value = stage(); + for (const block of value.blocks) { + block.before.cpuStat.nr_throttled = 7755; block.after.cpuStat.nr_throttled = 7755; + } + const identity = { affinity: '0', cgroupCpuMax: '400000 100000' }; + expect(serverResourceReasons([value], identity)).toEqual([]); + value.blocks[0].after.cpuStat.nr_throttled += 1; value.blocks[0].delta.nr_throttled = 1; + expect(serverResourceReasons([value], identity)[0]).toMatch(/throttling/); + value.blocks[0].delta.nr_throttled = 0; + expect(() => serverResourceReasons([value], identity)).toThrow(/delta/); + }); + + it('stable drift между блоками/стадиями не заменяет зарегистрированные CPU/quota', () => { + const value = stage('aa', 4), identity = { affinity: '0', cgroupCpuMax: '400000 100000' }; + value.blocks[1].before.affinity = '1'; value.blocks[1].after.affinity = '1'; + expect(serverResourceReasons([value], identity)).toContain('aa: block 1 отличается от зарегистрированных affinity/quota'); + value.blocks[1].before.affinity = '0'; value.blocks[1].after.affinity = '0'; + value.blocks[1].before.cpuMax = '200000 100000'; value.blocks[1].after.cpuMax = '200000 100000'; + expect(serverResourceReasons([value], identity)).toContain('aa: block 1 отличается от зарегистрированных affinity/quota'); + const later = stage('positive'); later.blocks[0].before.cpuMax = 'max 100000'; later.blocks[0].after.cpuMax = 'max 100000'; + expect(serverResourceReasons([stage(), later], identity)).toContain('positive: block 0 отличается от зарегистрированных affinity/quota'); + }); + + it('потерянные provenance и неопределённая calibration не становятся PASS', () => { + const refusal: any = { schema: 1, protocol: SERVER_PROFILE, registration: null, registrationDigest: null, + verdict: 'UNPROVEN', failures: [{ stage: 'preparation', error: { message: 'нет browser' } }] }; + expect(validateServerArtifact(refusal)).toMatchObject({ verification: 'preparation-refused' }); + for (const mutation of [ + (x: any) => { x.verdict = 'PASS'; }, (x: any) => { x.ab = {}; }, + (x: any) => { x.failures = []; }, (x: any) => { x.registration = {}; }, + ]) { + const changed = clone(refusal); mutation(changed); + expect(() => validateServerArtifact(changed)).toThrow(); + } + }); + + it.each(['baseline', 'dirty', 'pnpm', 'dist', 'lock', 'binary', 'vendor', 'affinity', 'browser', 'transitive'])('не принимает подменённый %s provenance даже с новым digest', (mutation) => { + const value: any = clone(registeredRefusal()); + expect(validateServerArtifact(value).verification).toBe('recorded-refusal-only'); + if (mutation === 'baseline') value.registration.provenance.baseline.revision = 'c'.repeat(40); + if (mutation === 'dirty') value.registration.provenance.candidate.dirty = true; + if (mutation === 'pnpm') value.registration.provenance.baseline.environment.pnpm = '11.19.0'; + if (mutation === 'dist') delete value.registration.provenance.candidate.distRuntime; + if (mutation === 'lock') delete value.registration.provenance.baseline.inputs['root/pnpm-lock.yaml']; + if (mutation === 'binary') delete value.registration.provenance.baseline.environment.nodeExecutableSha256; + if (mutation === 'vendor') delete value.registration.packages.motion.tarballSha256; + if (mutation === 'affinity') { + value.registration.machine.identity.affinity = '0-4'; value.registration.machine.sha256 = serverProfileDigest(value.registration.machine.identity); + } + if (mutation === 'browser') delete value.registration.browserTree.sha256; + if (mutation === 'transitive') delete value.registration.transitivePackages; + value.registrationDigest = serverProfileDigest(value.registration); + expect(() => validateServerArtifact(value)).toThrow(); + }); + + it('timing не включает forced GC, retention остаётся в отдельном child process', () => { + const runner = readFileSync(new URL('../bench/profile/server-profile-runner.mjs', import.meta.url), 'utf8'); + const retention = readFileSync(new URL('../bench/profile/server-profile-retention.mjs', import.meta.url), 'utf8'); + expect(runner).not.toMatch(/globalThis\.gc\s*\(/); + expect(retention).toMatch(/globalThis\.gc\(\)/); + expect(runner).toContain("['--expose-gc'"); + }); +}); + +describe('PROFILE: ресурсный контракт проверяется до регистрации и samples', () => { + const keys = ['usage_usec', 'user_usec', 'system_usec', 'nr_periods', 'nr_throttled', 'throttled_usec']; + const healthy = { usage_usec: 100, user_usec: 70, system_usec: 30, nr_periods: 20, nr_throttled: 2, throttled_usec: 50 }; + function machine(quota: string | null = '400000 100000', counters: Record = healthy) { + const source = readFileSync(new URL('../bench/profile/server-profile-runner.mjs', import.meta.url), 'utf8'); + const common = source.slice(source.indexOf('function readOptional('), source.indexOf('async function withBrowserTimeout(')); + const capture = source.slice(source.indexOf('export function captureServerMachine('), source.indexOf('export function createServerJournal(')).replace(/^export /, ''); + const files: Record = { + '/proc/self/status': 'Cpus_allowed_list:\t0\nvoluntary_ctxt_switches:\t2\nnonvoluntary_ctxt_switches:\t3\n', + '/sys/fs/cgroup/cpu.stat': Object.entries(counters).map(([key, value]) => `${key} ${value}`).join('\n') + '\n', + }; + if (quota !== null) files['/sys/fs/cgroup/cpu.max'] = quota; + const hashBinary = vi.fn(() => hash); + // Исполняем точные функции владельца. Независимый FS задаёт отсутствующие + // controller/counters; VM не запускает пакеты, браузер или измерение CPU. + const realm = createContext({ + readFileSync(file: string) { if (!Object.hasOwn(files, file)) throw new Error('нет файла фикстуры ' + file); return files[file]; }, + existsSync: (file: string) => Object.hasOwn(files, file), loadavg: () => [0, 0, 0], + platform: () => 'linux', release: () => '6.18.44', arch: () => 'x64', hostname: () => 'fixture', + cpus: () => [{ model: 'fixture' }], totalmem: () => 1024, sha256File: hashBinary, serverProfileDigest, + process: { version: 'v24.19.0', execPath: '/fixture/node', execArgv: [], memoryUsage: () => ({ heapUsed: 1 }) }, + }); + return { capture: runInContext(`${common}\n${capture}\ncaptureServerMachine;`, realm), hashBinary }; + } + + it('принимает шесть полных счётчиков, включая честное историческое throttling', () => { + const fixture = machine(), captured = fixture.capture(); + expect(captured.identity.affinity).toBe('0'); + expect(captured.identity.cgroupCpuMax).toBe('400000 100000'); + expect(captured.sha256).toBe(serverProfileDigest(captured.identity)); + expect(fixture.hashBinary).toHaveBeenCalledTimes(1); + }); + + it.each([null, '', ' \n'])('отвергает cpu.max=%j до hashing/setup', (quota) => { + const fixture = machine(quota); + let failure: any; + try { fixture.capture(); } catch (error) { failure = error; } + expect(failure?.message).toMatch(/cpu\.max.*до samples/); + expect(failure.raw.cgroupCpuMax).toBe(quota === null ? null : ''); + expect(fixture.hashBinary).not.toHaveBeenCalled(); + }); + + it.each(keys.flatMap((key) => ['missing', 'negative', 'fractional', 'overflow', 'nonfinite'].map((fault) => ({ key, fault }))))( + 'отвергает cpu.stat $key/$fault до hashing/setup', ({ key, fault }) => { + const counters: Record = { ...healthy }; + if (fault === 'missing') delete counters[key]; + else { + const invalid: Record = { negative: -1, fractional: 0.5, overflow: Number.MAX_SAFE_INTEGER + 1, nonfinite: Infinity }; + counters[key] = invalid[fault]!; + } + const fixture = machine('400000 100000', counters); + let failure: any; + try { fixture.capture(); } catch (error) { failure = error; } + expect(failure?.message).toMatch(/cpu\.stat.*до samples/); + expect(failure.raw.resource.cpuMax).toBe('400000 100000'); + expect(Number.isSafeInteger(failure.raw.resource.cpuStat[key]) && failure.raw.resource.cpuStat[key] >= 0).toBe(false); + expect(fixture.hashBinary).not.toHaveBeenCalled(); + }); +}); + +describe('серверный PROFILE: native scheduled CPU endpoints', () => { + const scene = SERVER_PROFILE.engineScenes[1]; + const nativeSample = () => { + const sample: any = stage().rows.find((row) => row.scene === scene.id)!.samples.left; + sample.cpuClock = { ...syntheticCpuIdentity }; + for (const measured of sample.raw) measured.raw.cpuReads = measured.raw.clockReads.map((read: any) => nativeCpuEndpoint(read)); + return sample; + }; + it('принимает полные native timespec и main-thread IDs без user/system fields', () => { + const sample = nativeSample(); + expect(() => validateServerEngineSample(sample, scene)).not.toThrow(); + }); + it('старые Node user/system counters не становятся native clock после переименования', () => { + const sample = nativeSample(); + for (const measured of sample.raw) measured.raw.cpuReads = measured.raw.clockReads.map((read: any) => ({ + sequence: read.sequence, ...syntheticCpuIdentity, userUs: Number(read.valueNs) / 1000, systemUs: 0, valueNs: read.valueNs })); + expect(() => validateServerEngineSample(sample, scene)).toThrow(/CPU|native|timespec/); + }); + it.each(['missing-sample-identity', 'wrong-clock', 'wrong-endpoint-clock', 'missing-seconds', 'negative-seconds', 'noncanonical-seconds', 'overflow-seconds', + 'fractional-nanoseconds', 'negative-nanoseconds', 'negative-zero-nanoseconds', 'overflow-nanoseconds', 'missing-native-read', 'value-mismatch', + 'clock-read-mismatch', 'wrong-sequence', 'wrong-pid', 'wrong-tid', 'worker-thread', 'later-repetition-identity', 'later-repetition-backwards']) + ('отвергает %s при coherent semantic:true', (fault) => { + const sample = nativeSample(), lineage = sample.raw[0].raw, read = lineage.cpuReads[1]; + expect(() => validateServerEngineSample(sample, scene)).not.toThrow(); + if (fault === 'missing-sample-identity') delete sample.cpuClock; + if (fault === 'wrong-clock') sample.cpuClock.clock = 'process.threadCpuUsage'; + if (fault === 'wrong-endpoint-clock') read.clock = 'CLOCK_PROCESS_CPUTIME_ID'; + if (fault === 'missing-seconds') delete read.seconds; + if (fault === 'negative-seconds') read.seconds = '-1'; + if (fault === 'noncanonical-seconds') read.seconds = '00'; + if (fault === 'overflow-seconds') read.seconds = '9223372036854775808'; + if (fault === 'fractional-nanoseconds') read.nanoseconds += 0.5; + if (fault === 'negative-nanoseconds') read.nanoseconds = -1; + if (fault === 'negative-zero-nanoseconds') read.nanoseconds = -0; + if (fault === 'overflow-nanoseconds') read.nanoseconds = 1_000_000_000; + if (fault === 'missing-native-read') lineage.cpuReads.pop(); + if (fault === 'value-mismatch') read.valueNs = String(BigInt(read.valueNs) + 1n); + if (fault === 'clock-read-mismatch') lineage.clockReads[1].valueNs = String(BigInt(read.valueNs) + 1n); + if (fault === 'wrong-sequence') read.sequence = 0; + if (fault === 'wrong-pid') read.pid++; + if (fault === 'wrong-tid') read.tid++; + if (fault === 'worker-thread') { + sample.cpuClock.tid++; + for (const measured of sample.raw) for (const value of measured.raw.cpuReads) value.tid = sample.cpuClock.tid; + } + if (fault === 'later-repetition-identity') for (const value of sample.raw[1].raw.cpuReads) { value.pid++; value.tid++; } + if (fault === 'later-repetition-backwards') { + const later = sample.raw[1].raw; + for (const value of later.clockReads) value.valueNs = String(BigInt(value.valueNs) - 100_000_000n); + later.cpuReads = later.clockReads.map((value: any) => nativeCpuEndpoint(value)); + } + expect(() => validateServerEngineSample(sample, scene)).toThrow(/CPU|native|timespec|lineage/); + }); + it('exact seconds выше2^53 не проходят через Number', () => { + const sample = nativeSample(), shift = 9_007_199_254_740_993n * 1_000_000_000n; + for (const measured of sample.raw) { + for (const value of measured.raw.clockReads) value.valueNs = String(BigInt(value.valueNs) + shift); + measured.raw.cpuReads = measured.raw.clockReads.map((value: any) => nativeCpuEndpoint(value)); + } + expect(sample.raw[0].raw.cpuReads[0].seconds).toBe('9007199254740993'); + expect(() => validateServerEngineSample(sample, scene)).not.toThrow(); + }); + it('native1ns timespec изменение сохраняется и не требует старой user/system grid', () => { + const sample = nativeSample(), measured = sample.raw[0]; + measured.raw.clockReads[1].valueNs = '11000001'; + measured.raw.cpuReads[1] = nativeCpuEndpoint(measured.raw.clockReads[1]); + measured.operationNs = 1_000_001; + sample.operationNs = 1_000_000.125; + expect(() => validateServerEngineSample(sample, scene)).not.toThrow(); + expect(SERVER_PROFILE.clockError.engineCounterOutwardPaddingNs).toBe(2000); + }); + it('same-object mutation main-thread metadata проверяется заново', () => { + const current = stage(); + const cell = serverCellPairs(current, 2, 'aa', syntheticCpuIdentity).find((cell) => cell.scene === scene.id)!; + expect(cell.left[0]).toBe(1_000_000); + const sample = current.rows.find((row) => row.scene === scene.id)!.samples.left; + sample.cpuClock.pid++; sample.cpuClock.tid++; + for (const measured of sample.raw) for (const value of measured.raw.cpuReads) { value.pid++; value.tid++; } + expect(() => serverCellPairs(current, 2, 'aa', syntheticCpuIdentity)).toThrow(/зарегистрированным main-thread/); + }); + it.each(['missing-clock', 'wrong-clock', 'worker-thread', 'node', 'napi', 'source', 'header', 'source-digest', + 'native-binary', 'compiler', 'compiler-flags', 'libc', 'missing-nominal', 'physical-certificate']) + ('native registration отвергает %s до samples', (fault) => { + const registration: any = registeredRefusal().registration; + expect(() => verifyServerClockRegistration(registration)).not.toThrow(); + const clock = registration.engineClock; + if (fault === 'missing-clock') delete registration.engineClock; + if (fault === 'wrong-clock') clock.clock = 'process.threadCpuUsage'; + if (fault === 'worker-thread') clock.tid++; + if (fault === 'node') clock.node.executableSha256 = hash; + if (fault === 'napi') clock.napiVersion = 9; + if (fault === 'source' || fault === 'header') { + const key = fault === 'source' ? 'bench/profile/server-thread-cpu-clock.c' : 'bench/profile/native-clock/include/node_api.h'; + clock.nativeSources[key] = hash; + clock.nativeSourceDigest = serverProfileDigest(Object.fromEntries(Object.entries(clock.nativeSources).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))); + } + if (fault === 'source-digest') clock.nativeSourceDigest = hash; + if (fault === 'native-binary') delete clock.nativeBinary.sha256; + if (fault === 'compiler') delete clock.compiler.binarySha256; + if (fault === 'compiler-flags') clock.compiler.flags = []; + if (fault === 'libc') delete clock.libc.sha256; + if (fault === 'missing-nominal') delete clock.nominalResolutionNs; + if (fault === 'physical-certificate') clock.nominalResolutionIsNotErrorCertificate = false; + expect(() => verifyServerClockRegistration(registration)).toThrow(/CPU|native/); + }); +}); diff --git a/test/svelte-unsubscribe-lifecycle.test.ts b/test/svelte-unsubscribe-lifecycle.test.ts new file mode 100644 index 000000000..948967f58 --- /dev/null +++ b/test/svelte-unsubscribe-lifecycle.test.ts @@ -0,0 +1,69 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import { springStore, type SpringStore } from '../src/svelte/index.js'; + +const stores: SpringStore[] = []; +function createStore(): SpringStore { + vi.stubGlobal('window', { matchMedia: () => ({ matches: true }) }); + const store = springStore(0, { mass: 1, stiffness: 200, damping: 20 }, 'instant', () => { + throw new Error('Reduced-motion witness не должен запрашивать кадр'); + }); + stores.push(store); + return store; +} + +afterEach(() => { + for (const store of stores) store.destroy(); + stores.length = 0; + vi.unstubAllGlobals(); +}); + +it('повтор отменённой отписки не удаляет новую регистрацию того же callback', () => { + const store = createStore(); + const received: number[] = []; + const neighbor: number[] = []; + const callback = (value: number): void => { received.push(value); }; + store.subscribe((value) => { neighbor.push(value); }); + const oldOff = store.subscribe(callback); + oldOff(); + const successorOff = store.subscribe(callback); + oldOff(); + store.set(1); + expect(neighbor).toEqual([0, 1]); + expect(received).toEqual([0, 0, 1]); + successorOff(); + store.set(2); + expect(received).toEqual([0, 0, 1]); + expect(neighbor).toEqual([0, 1, 2]); +}); + +it.each([0, 1])('отписка duplicate %s отзывает старую регистрацию и не затрагивает преемника', (cancelIndex) => { + const store = createStore(); + const received: number[] = []; + const callback = (value: number): void => { received.push(value); }; + const handles = [store.subscribe(callback), store.subscribe(callback)] as const; + expect(received).toEqual([0, 0]); + store.set(1); + expect(received).toEqual([0, 0, 1]); + handles[cancelIndex]!(); + store.set(2); + expect(received).toEqual([0, 0, 1]); + const successorOff = store.subscribe(callback); + handles[1 - cancelIndex]!(); + store.set(3); + expect(received).toEqual([0, 0, 1, 2, 3]); + successorOff(); +}); + +it('сохраняет прежний fail-fast broadcast при ошибке подписчика', () => { + const store = createStore(); + const failure = { source: 'subscriber' }; + const neighbor: number[] = []; + store.subscribe((value) => { if (value !== 0) throw failure; }); + store.subscribe((value) => { neighbor.push(value); }); + let thrown: unknown; + try { store.set(1); } catch (error) { thrown = error; } + expect(thrown).toBe(failure); + expect(neighbor).toEqual([0]); + expect(() => store.set(2)).not.toThrow(); + expect(neighbor).toEqual([0]); +}); diff --git a/test/vue-scope-lifecycle.test.ts b/test/vue-scope-lifecycle.test.ts new file mode 100644 index 000000000..34964f4df --- /dev/null +++ b/test/vue-scope-lifecycle.test.ts @@ -0,0 +1,112 @@ +import { describe, expect, it, vi } from 'vitest'; +import { effectScope, nextTick, ref } from 'vue'; +import { useMotionValue, useSpring } from '../src/vue/index.js'; + +const SPRING = { mass: 1, stiffness: 300, damping: 30 } as const; + +function makeClock() { + const frames: Array<(time?: number) => void> = []; + let now = 0; + return { + requestFrame(callback: (time?: number) => void): number { + frames.push(callback); + return 1; + }, + step(): void { + now += 16; + for (const callback of frames.splice(0)) callback(now); + }, + pending: () => frames.length, + }; +} + +describe('Vue: владение анимацией в effectScope', () => { + it('stop освобождает активное значение и делает уже поставленный кадр инертным', () => { + const scope = effectScope(); + const clock = makeClock(); + const mv = scope.run(() => useMotionValue(0, SPRING, clock.requestFrame))!; + const changes: number[] = []; + mv.onChange(value => changes.push(value)); + try { + mv.setTarget(100); + clock.step(); + clock.step(); + expect(mv.value).toBeGreaterThan(0); + expect(changes.length).toBeGreaterThan(1); + expect(clock.pending()).toBe(1); + const before = [...changes]; + + scope.stop(); + clock.step(); + mv.setTarget(200); + const lateListener = vi.fn(); + const off = mv.onChange(lateListener); + + expect(changes).toEqual(before); + expect(lateListener).not.toHaveBeenCalled(); + expect(clock.pending()).toBe(0); + off(); + } finally { + scope.stop(); + mv.destroy(); + } + }); + + it('useSpring прекращает движение и наблюдение цели вместе со scope', async () => { + const scope = effectScope(); + const sibling = effectScope(); + const clock = makeClock(); + const target = ref(0); + const value = scope.run(() => useSpring(target, SPRING, 'instant', clock.requestFrame))!; + const neighbor = sibling.run(() => useMotionValue(0, SPRING, clock.requestFrame))!; + try { + target.value = 100; + await nextTick(); + neighbor.setTarget(100); + clock.step(); + clock.step(); + expect(value.value).toBeGreaterThan(0); + expect(neighbor.value).toBeGreaterThan(0); + const stoppedValue = value.value; + const liveValue = neighbor.value; + + scope.stop(); + target.value = 200; + await nextTick(); + clock.step(); + + expect(value.value).toBe(stoppedValue); + expect(neighbor.value).toBeGreaterThan(liveValue); + expect(clock.pending()).toBe(1); + sibling.stop(); + clock.step(); + expect(clock.pending()).toBe(0); + } finally { + scope.stop(); + sibling.stop(); + neighbor.destroy(); + } + }); + + it('вне scope MotionValue сохраняет явный destroy без lifecycle-предупреждений', () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}); + const clock = makeClock(); + const mv = useMotionValue(0, SPRING, clock.requestFrame); + try { + mv.setTarget(100); + clock.step(); + clock.step(); + expect(mv.value).toBeGreaterThan(0); + const before = mv.value; + mv.destroy(); + clock.step(); + mv.setTarget(200); + expect(mv.value).toBe(before); + expect(clock.pending()).toBe(0); + expect(warn).not.toHaveBeenCalled(); + } finally { + mv.destroy(); + warn.mockRestore(); + } + }); +}); diff --git a/test/vue.test.ts b/test/vue.test.ts index 8cafac24d..0e751552f 100644 --- a/test/vue.test.ts +++ b/test/vue.test.ts @@ -8,7 +8,7 @@ * C (Property): reduced-motion CHARACTER switching in useSpring AND vMotion directive * D (Mutation proof): documented per test * - * Vue's reactivity is mocked at the ref/watch/onUnmounted level. + * Реактивность Vue заменена на уровне ref/watch и завершения scope. * The virtual clock ensures deterministic animation. * * Reduced-motion CHARACTER: useSpring и vMotion идут через @@ -76,6 +76,11 @@ vi.mock('vue', () => { onUnmounted: (cb: () => void) => { _unmountedCallbacks.push(cb); }, + getCurrentInstance: () => ({}), + getCurrentScope: () => ({}), + onScopeDispose: (cb: () => void) => { + _unmountedCallbacks.push(cb); + }, }; }); @@ -148,7 +153,7 @@ describe('useMotionValue', () => { it('destroy is called on unmount', () => { // A: Integration — cleanup registered - // Mutation proof: remove onUnmounted registration → destroySpy never called + // Удаление регистрации уборки оставит destroySpy невызванным. const clock = makeVirtualClock(); const mv = useMotionValue(0, { mass: 1, stiffness: 200, damping: 20 }, clock.requestFrame); const destroySpy = vi.spyOn(mv, 'destroy'); @@ -198,7 +203,7 @@ describe('useSpring', () => { it('destroys MotionValue on unmount (no memory leak)', () => { // A: Integration — mv.destroy() called on component teardown - // Mutation proof: remove onUnmounted from useSpring → no cleanup, potential leak + // Удаление регистрации уборки оставит значение живым после scope. const clock = makeVirtualClock(); let targetValue = 0; @@ -209,7 +214,7 @@ describe('useSpring', () => { clock.requestFrame, ); - // onUnmounted callbacks should have been registered + // Scope получил уборку владельца MotionValue. expect(_unmountedCallbacks.length).toBeGreaterThan(0); }); }); diff --git a/tsconfig.browser.json b/tsconfig.browser.json index 3b5e81cc3..bfbb66684 100644 --- a/tsconfig.browser.json +++ b/tsconfig.browser.json @@ -15,7 +15,8 @@ // работать в 7.0. Ключи paths резолвятся относительно самого tsconfig, // поэтому маппинг ниже от его удаления не зависит. "paths": { - "/dist/*": ["./src/*"] + "/dist/*": ["./src/*"], + "/browser/.artifacts/scope-recipes.js": ["./browser/fixtures/packed-recipes.d.ts"] } }, "include": ["browser", "playwright.config.ts"]