Replace the ci:test:misc filter-glob branch with explicit package#script
branches — ci:test:runtime, ci:test:testing, ci:test:integration,
ci:test:pty — matching the package#script form already used for the
runtime-tests suites. Clearer and consistent: each branch names exactly one
suite, no filter syntax. (vp run takes a single package#script per task, so
each normal package gets its own branch.)
Verified `CI=true vp run ci` on a fresh checkout: runtime (309) + testing (7)
+ integration (756) + pty (110), PTY once, exit 0.
The previous fix (b77f42e, reverted in f0cc614) added a test:integration
script to runtime and testing just so `vp run -r test:integration` would match
them — polluting every package's contract to satisfy the CI graph.
Restore the clean contract: normal packages (runtime, testing, cli) have only
a plain `test`; only runtime-tests splits into test:integration + test:pty.
The ci graph adapts instead of the packages:
ci:test:misc -> vp run --filter "@vue-tui/*" --filter "!@vue-tui/runtime-tests" test
ci:test:integration -> vp run @vue-tui/runtime-tests#test:integration
ci:test:pty -> vp run @vue-tui/runtime-tests#test:pty
misc runs every normal package's own `test` (the glob auto-covers future
packages); runtime-tests' two suites are separate parallel branches, keeping
the slow PTY suite off the critical path. Verified `CI=true vp run ci` on a
fresh checkout: runtime (309) + testing (7) + integration (756) + pty (110),
PTY runs exactly once, exit 0.
The ci graph's test:integration task runs `vp run -r test:integration`, but
that script only existed in runtime-tests, so `vp run -r` silently skipped
packages/runtime (11 files, 309 tests) and packages/testing (2 files, 7 tests)
— their unit tests never ran in CI.
Give both packages a test:integration script (= vp test) and make their `test`
compose it, mirroring runtime-tests. `vp run -r test:integration` now covers
all three packages. PTY stays its own branch (no double-run).
Verified: `CI=true vp run ci` on a fresh checkout runs runtime (309) + testing
(7) + runtime-tests (756), exit 0.
Reported-by: @reviewer on PR #25
Fifth CI run failed on ~15 resize/throttle/flush tests that pass locally. Root
cause: the GitHub runner sets CI=true, and vue-tui computes
`interactive = !isInCi && isTTY`. With CI=true, interactive is false, so the
resize listener, cursor control, and ANSI erases are never wired up — exactly
the behavior those tests assert. Locally CI is unset, so they passed (the
local-vs-CI trap, reproducible with `CI=true vp test run`).
Set env CI:"false" in both vitest configs. The PTY child helpers already force
CI=false per-spawn for this reason; the in-process suite (and the testing
harness's render()) needs the same. Verified: `CI=true vp run ci` on a fresh
checkout (no dist) now exits 0 with all 756 + 110 tests passing.
The fourth CI run failed broadly: ~15 timing-sensitive tests (throttle, flush,
resize clear-counts, rapid-input ordering) failed under sequence.concurrent on
the 4-core ubuntu runner. These assert render/commit counts driven by the
~32ms commit throttle; in-file concurrency starves them of wall-clock when many
share few cores. It passed locally only because dev machines have more cores —
the classic "works on my 12-core mac" trap.
Remove sequence.concurrent from both the main and PTY configs; keep
fileParallelism (pool: forks), which is the proven, stable win (PTY suite still
~3x faster than serial). The it.sequential/describe.sequential markers and
context-local expect become harmless no-ops under serial in-file execution.
Verified cold (no dist): vp run ci exits 0, 0 lint warnings, all tests pass.
Third CI run failed: `vp lint --deny-warnings` reported 4 no-implied-eval
warnings on PTY fixtures (setTimeout(exit, ...)). The type-aware rule needs
@vue-tui/runtime's built types to prove the callback is a function; on a fresh
checkout dist doesn't exist yet, so it misfires. Locally it was hidden because
dist was always present.
Add dependsOn: ["ci:build"] to ci:lint. build is already on the critical path
(build -> test:pty), so overall wall-clock is unchanged. Verified by removing
all dist and running vp run ci: exit 0, 0 lint warnings, all tests pass.
Second CI run got past install but failed loading vite.config.ts: native TS
type-stripping (used by vite/oxlint to read .ts config) requires Node
^20.19.0 || >=22.18.0, and 22.13.0 is below that. 22.18.0 is the true floor —
it satisfies both pnpm (>=22.13) and TS config loading (>=22.18). Match
engines.node.
The first CI run failed at `vp install`: pnpm@11.1.2 requires Node >=22.13, but
the workflow pinned 22.12.0 (the old engines floor). Pin 22.13.0 — the real
lowest Node the toolchain supports — and correct engines.node to >=22.13.0 so
the declared engine matches what pnpm actually needs.
check:lint previously exited 0 even with warnings, so warnings accumulated
unnoticed (7 had piled up before being cleared). Add --deny-warnings so any
warning fails check:lint — locally, in `vp run ready`, and in CI alike.
Verified: clean tree still exits 0; a deliberately reintroduced warning makes
check:lint exit 1.
Record the rule: when code has to be written in a surprising or non-idiomatic
way because the situation requires it (control-char regexes, deliberate
code-point spread, justified lint suppressions), add a comment explaining why,
so the next reader doesn't have to guess whether it's intentional.
vp run check:lint reported 7 warnings, all false positives for a terminal UI
library:
- no-control-regex (×6): parsing keyboard escape sequences and stripping ANSI
inherently requires regexes matching control chars (ESC, BEL). Disable the
rule library-wide in vite.config.ts — it flags every such pattern and we
already use \x1b/\u escapes (its own suggested form). Also drop the now-
redundant (and misplaced — it sat one line above the regex) inline disable in
sanitize-ansi.test.ts.
- no-misused-spread (×1) at parse-keypress.ts:500: `[...s]` on a terminal
escape sequence (ASCII control chars + digits, never user text), so the
emoji-splitting concern doesn't apply. Suppressed in place with a comment
explaining why, keeping the rule active elsewhere.
check:lint now reports 0 warnings, 0 errors.
The main suite is now concurrent too, so correct the earlier "not concurrent"
note. Record the convention: snapshot tests stay concurrent via context-local
expect; process-global-state tests (fake timers, listener/node counts) move to
*.sequential.test.* files marked it.sequential / describe.sequential.
Enable sequence.concurrent: true in vite.config.ts so the non-PTY suite runs
concurrently like the PTY suite. Stress-verified stable (8/8 at maxForks=4);
the suite drops from ~13s to ~4-5s.
Three test patterns were incompatible with concurrency; handled per cause:
- Inline snapshots (background-color, borders): the module-level `expect`
loses snapshot test context under concurrency. Fixed in place by using the
context-local `expect` (async ({ expect }) => ...), so they stay concurrent.
- Process-global state (throttle/animation-scheduler use fake timers; leak
asserts on process exit/SIGINT listener counts and live yoga nodes): a
concurrent sibling clobbers the shared global mid-test. These genuinely
require serial execution, so they move to *.sequential.test.* files with
it.sequential / describe.sequential and a header explaining why.
`vp run ready` passes.
Document that the PTY suite runs concurrently (and the wall-clock-assertion
pitfall there), plus the two patterns that force the main suite to stay
sequential, with the root cause and fix for each:
- Inline snapshots lose test context under concurrency — fixable via the
context-local `expect` (test.concurrent("...", ({ expect }) => ...)).
- Fake timers mutate process-global timer functions, so concurrent tests
clobber each other's mocked timer state — not fixable with context; must
stay sequential.
Investigated empirically: enabling sequence.concurrent on the main suite fails
deterministically (not flaky) in exactly the snapshot files (background-color,
borders) and fake-timer files (throttle, animation-scheduler).
With resize rendering now synchronous, no PTY test depends on wall-clock
timing, so concurrent execution is safe. Enable sequence.concurrent: true.
Each test already spawns its own isolated PTY subprocess (or in-process app)
with no shared state.
Verified stable: 12/12 runs green under sequence.concurrent with forks capped
to 4 (mimicking a 4-core CI runner) — the configuration that reliably flaked
before the resize fix. No it.sequential opt-outs are needed.
The resize handler routed through scheduler.schedule(), deferring the repaint
through the ~32ms commit throttle. Ink's resized() calls onRender() directly,
and a resize is a discrete viewport change that should repaint immediately —
deferring it can leave stale/overlapping content on screen for a frame.
It also made the clearTerminal-on-overflow behavior depend on wall-clock
timing: the #450 "shrink into overflow" test passed only because the throttled
resize emitted ZERO clears (its trailing timer never fired within the test's
nextTicks) and the single clear came entirely from unmount. The test asserted
the right number for the wrong reason, and the dependency on real elapsed time
made it flaky under CPU contention.
Change the resize handler to commit() directly. Now the resize itself emits the
overflow clear deterministically. Update the test to assert the clear happens
ON the resize (clearsAfterResize - clearsBeforeResize === 1) after a single
nextTick — no longer dependent on throttle timing.
The PTY suite now runs file-parallel (see vitest.pty.config.ts), so the comment
claiming "no parallelism" was wrong. The real constraint is node-pty's forks
pool, not serial execution.
The PTY suite was the CI wall-clock bottleneck, run serially via
fileParallelism:false. The original reason for serializing was a node-pty
constraint — it needs child_process.fork(), not worker_threads — but that only
dictates the pool TYPE, not single-file execution. Each test already spawns its
own isolated PTY subprocess (helpers/term.ts, run.ts: no shared ports, temp
files, or mutable globals; cwd is the read-only fixtures dir), so files
parallelize safely.
Set pool:"forks" explicitly (the real node-pty requirement) and
fileParallelism:true. Measured: the PTY suite drops ~37s -> ~13s (~3x), and the
full `vp run ci` graph drops ~41s -> ~20s cold (no task cache, no prebuilt
dist). Verified stable across 9 isolated PTY runs (incl. maxForks capped to 4
to mimic a 4-core CI runner) and 3 cold full-graph runs — 110 PTY tests pass
every time, zero flakes. testTimeout stays 15s (slowest test ~2s) to absorb CPU
contention on smaller runners.
Replace ci.yml's five serial steps with a single `vp run ci` whose graph lives
in vite.config.ts (run.tasks). The vp task runner fans out independent branches
concurrently: fmt and lint start immediately while check:type and the test
suites wait on build (their consumers resolve @vue-tui/runtime from the built
dist/*.d.mts). The wall-clock critical path becomes build -> test:pty instead
of the sum of every check.
Measured cold (no task cache, no prebuilt dist — the real CI condition): the
graph completes in ~41s vs ~60s serial, ~32% faster, with build correctly
fanned out before the type and test branches. `vp run --last-details` (and the
run summary) still pinpoints which sub-task failed.
Also set run.cache=false so neither local nor CI verification depends on any
task-cache replay. The serial `ready` script in package.json is kept for simple
local use.
Single job on ubuntu-latest that runs the same checks as `vp run ready`, as
individual labeled steps so the run shows exactly which concern failed: format,
lint, build, type-check, test. Build precedes type-check and test because
@vue-tui/runtime has no "types" export — testing/runtime-tests resolve its
types and runtime from the built dist/*.d.mts, and same-job steps share the
filesystem so the dist persists.
Uses voidzero-dev/setup-vp@v1 (per the Vite+ CI docs), which installs Node, the
vp CLI, and runs vp install automatically (run-install defaults true), so no
separate install step. node-version pins the exact engines.node floor 22.12.0
so CI fails if code relies on a newer Node API; cache enables the pnpm store
cache (off by default). Triggers on pull_request, push to main, and manual
dispatch; concurrency cancels superseded PR runs but never a push-to-main run;
permissions are read-only.
Verified: actionlint reports no issues; both action refs confirmed via
git ls-remote.
A single top-level `vp run check:type` should fan out (-r) and fully type-check
every package, fixtures included — no separate top-level check:fixtures step.
runtime-tests' check:type now runs its main tsc then its fixtures tsc
(check:fixtures stays as a runnable sub-script). Drop the root check:fixtures
entry and its standalone step in ready.
Set lint.options.typeCheck=false so vp lint/check no longer runs the
tsgolint full type-check (typeAware stays on, keeping type-aware lint rules).
Type-checking is now owned by check:type, which runs the real tsc and honors
each tsconfig's project semantics — unlike tsgolint, which ignored tsconfig
exclude/nested configs.
Wire check:type into ready after build (it needs the built dist for
cross-package type resolution): fmt, lint, build, check:type, check:fixtures,
test.
Verified: with typeCheck off, vp lint no longer reports a TS2322 type error
(but keeps its type-aware warnings); check:type catches it via tsc.
Each package gets check:type = `tsc --noEmit` (under its own tsconfig); root
check:type = `vp run -r check:type` fans out across the workspace. Unlike vp's
tsgolint-based type-aware path, this is the standard TypeScript compiler, so it
honors each tsconfig's real project semantics.
Additive only here — vp lint still carries typeCheck; the switch-over and ready
rewiring land in the next commit. Note: testing and runtime-tests resolve
@vue-tui/runtime types from its built dist, so check:type requires a prior
build.
The cli package had no tsconfig, so it was never type-checked under its own
config. Add a tsconfig (matching the other packages, minus JSX which cli does
not use) and the typescript dev dep so `tsc --noEmit` can run here — a
prerequisite for the upcoming check:type script.
The committed file had unformatted line wrapping that vp fmt --check flags,
which would fail CI the moment check:fmt runs. Reflow to the formatter's
output; no behavior change.
Replace the opaque `vp check` bundling and the ad-hoc `ready` chain (which
shelled out via `cd ... && pnpm ...`) with explicit, composable named scripts.
Root delegates; category splits live in the package that owns them:
root: check:fmt / check:lint / check:fixtures / test / build / ready
runtime-tests: test = test:integration + test:pty; check:fixtures
`ready` now composes the named scripts in dependency order (fmt, lint, build,
fixtures, test) — build runs before check:fixtures and test:pty, which need
the built dist. Drop the broken root `dev` (referenced a non-existent website
package) and the redundant per-package `check` scripts (fmt/lint already run
workspace-wide from root). Renames: pty-test -> test:pty, typecheck:fixtures
-> check:fixtures.
`vp check` bundles format, lint, and typecheck, which hides which concern
failed and offers no way to run a single slice. Add explicit per-concern
entry points at the workspace root:
check -> vp check (umbrella, unchanged behavior)
check:fmt -> vp fmt --check (format only)
check:lint -> vp lint (lint + typecheck)
No separate check:type: with typeAware/typeCheck enabled in the root config,
vp lint already runs the tsc typecheck, so check:lint covers it.
The root vite.config.ts lint/fmt settings cascade into every workspace
package, and a package-level lint block merges with — rather than replaces —
the root options. So the `lint.options { typeAware, typeCheck }` and the empty
`fmt: {}` repeated in runtime, testing, and runtime-tests only restated what
each package already inherits.
Remove them. runtime-tests keeps just its `ignorePatterns` (the one genuine
per-package override); typeAware/typeCheck now come from root via the merge.
Verified with `vp check`: no lint or typecheck regression, and the PTY
fixtures stay excluded from lint.
The WithChildren shim is only exercised under jsx:"react-jsx", which lives
solely in integration/pty/fixtures/tsconfig.json. Nothing in `ready` ran tsc
against that config (vp check uses jsx:"preserve" and excludes the fixtures;
pty-test only transpiles them), so a regression in the shim — children
silently rejected, or declared props silently widened away — would pass
verification unnoticed.
Add a type-only regression fixture (not a runnable PTY program; not a
*.test.tsx, so vitest never collects it) that pins both directions of the
contract: children are accepted on Box/Text/Static/Transform, and declared
props stay validated via @ts-expect-error (invalid value, wrong type, unknown
prop, and missing required props on Transform/Static).
Wire `tsc -p integration/pty/fixtures/tsconfig.json --noEmit` into `ready` via
a typecheck:fixtures script, run after build (so @vue-tui/runtime resolves
against fresh dist types) and before pty-test, so the react-jsx path is
actually enforced rather than only manually checkable.
`lint.exclude` is not a property of OxlintConfig (the correct key is
`ignorePatterns`). The invalid property failed defineConfig overload
resolution, which surfaced as a TS2769 plus a TS2321 excessive-stack-depth
error against the recursive vitest-augmented UserConfig. Using
`ignorePatterns` excludes the PTY fixtures from lint as intended and clears
both config type errors.
Text/Box/Static/Transform read children via slots but never surfaced
`children` on their JSX `$props`. Under the automatic JSX runtime
(jsx: react-jsx + jsxImportSource: vue), children are passed as a
`children` prop, so `<Text>x</Text>` failed to type-check. Add a
type-only WithChildren cast that declares optional `children` on $props;
Vue routes that prop to the default slot at runtime, so there is no
runtime change.
Addresses PR #23 review: move the mid-file text-measure import to the
top-level import block, and declare engines.node>=22 to match the
upgraded text stack (cli-truncate@6, slice-ansi@9 require node>=22).
Bump slice-ansi@9, string-width@8, wrap-ansi@10 and add cli-truncate@6
(both the runtime dep and the pnpm catalog entry for string-width). Rewrite
wrapText truncate variants to delegate to cli-truncate, matching Ink's
wrap-text.ts: grapheme clusters (ZWJ emoji, combining marks) stay whole and
newlines are preserved. Adjust the horizontal-clip left-edge compensation in
paint.ts because slice-ansi@9 drops a straddling wide grapheme whole rather
than splitting it, so lineX must advance by the actually-dropped width.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Adds an early-return guard in paintNode so nodes with DISPLAY_NONE
(already set on their Yoga node) are entirely skipped during paint,
matching Ink's renderNodeToOutput behavior. Without the guard, hidden
text/borders leaked onto visible siblings at x=0.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Codex review found waitUntilRenderFlush gated the scheduler flush on
hasPending() alone, missing the window after schedule() queues a commit
but before the post-flush callback sets hasPendingFlag — letting the
promise resolve before the pending render flushed. Now delegates to
flush() unconditionally; flush() already short-circuits when nothing is
scheduled or pending, so this only adds the missing wait.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Correctness fixes found by max-effort review of the branch diff:
- frame-writer.sync() now updates lastFrame alongside log-update's
previousOutput. Previously the two dedup layers desynced after a sync()
(the clearTerminal path), silently dropping a legitimately-changed frame
and emitting an empty BSU/ESU pair. Adds a regression test.
- scheduler: the queuePostFlushCb callback now bails if scheduled was reset
by cancel(), so a stale callback can't commit on a torn-down tree or
re-arm an uncancellable trailing timer.
- scheduler.flush() now collects multiple concurrent waiters instead of
overwriting a single resolver — fixes a hang when two waitUntilRenderFlush()
calls await the same pending commit.
- render teardown nulls mountedClear so a post-unmount app.clear() can't
write to a torn-down stream.
- test-streams getContentWrites imports bsu/esu instead of hardcoding the
escape literals.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
- scheduler.cancel() now resolves a pending flush() waiter, preventing
waitUntilRenderFlush() from hanging when the app unmounts mid-flush
- BSU/ESU now wrap the actual stream writes instead of being embedded in
the frame string, so synchronization survives log-update's incremental
line diffing (matches Ink ink.tsx:1059-1097). Normal branch guarded by
willRender() to avoid empty synchronized-update pairs on unchanged frames
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Yunfei He