diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..6313b56c --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +* text=auto eol=lf diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8add9b09..ea26089f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,6 +6,7 @@ on: permissions: contents: read + packages: read jobs: toolchain: @@ -22,6 +23,11 @@ jobs: node-version: "24.x" cache: npm - run: npm ci + env: + NODE_AUTH_TOKEN: ${{ github.token }} + # `npm test` includes Chromium-backed lifecycle and runtime probes. The + # separate browser matrix expands that coverage to all three engines. + - run: npx playwright install --with-deps chromium - run: npm run check - run: npm test - run: npm run test:packages @@ -37,5 +43,7 @@ jobs: node-version: "24.x" cache: npm - run: npm ci + env: + NODE_AUTH_TOKEN: ${{ github.token }} - run: npx playwright install --with-deps chromium firefox webkit - run: npm run test:browser diff --git a/.github/workflows/external-preview-verification.yml b/.github/workflows/external-preview-verification.yml index a0ecc210..d14faa0b 100644 --- a/.github/workflows/external-preview-verification.yml +++ b/.github/workflows/external-preview-verification.yml @@ -10,6 +10,7 @@ on: permissions: contents: read + packages: read id-token: write attestations: write artifact-metadata: write @@ -25,6 +26,8 @@ jobs: node-version: "24.x" cache: npm - run: npm ci + env: + NODE_AUTH_TOKEN: ${{ github.token }} - run: npm run check - name: Prepare the exact root Netlify preview run: node scripts/prepare-external-preview.mjs --output-dir release/external-preview/site diff --git a/.github/workflows/release-rehearsal.yml b/.github/workflows/release-rehearsal.yml index 712c0244..b44d3bd4 100644 --- a/.github/workflows/release-rehearsal.yml +++ b/.github/workflows/release-rehearsal.yml @@ -8,6 +8,7 @@ on: permissions: contents: read + packages: read id-token: write attestations: write artifact-metadata: write @@ -26,6 +27,8 @@ jobs: registry-url: https://registry.npmjs.org package-manager-cache: false - run: npm ci + env: + NODE_AUTH_TOKEN: ${{ github.token }} - run: npm run check - run: npm test - name: Create non-publishing rehearsal diff --git a/.npmrc b/.npmrc new file mode 100644 index 00000000..ff0c2e66 --- /dev/null +++ b/.npmrc @@ -0,0 +1,2 @@ +@velaros-ai:registry=https://npm.pkg.github.com +//npm.pkg.github.com/:_authToken=${NODE_AUTH_TOKEN} diff --git a/CHANGELOG.md b/CHANGELOG.md index db250502..16c9f488 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,226 @@ language for people who already think in JavaScript and Python, shipped as one version-locked set of eight packages: compiler, Node runtime, Web and Desktop frameworks, project creator, CLI, text buffer, and script analysis. +### The reactive grid: `computed` is a declaration, and the function is `cached` + +`computed name = expression` now stands beside `state name = value`, and the +`computed(...)` **function is renamed `cached(...)`**. The function is not +retired — it remains a way to cache a value rather than declare one — but a +derived binding is declared, never assigned from a call. + +The reason is a defect the owner reported twice, from two directions, without +knowing they were the same defect: + +- `const doubled = count * 2` in component setup compiled clean and then never + updated. `const` freezes, which is precisely what `const` means. +- `const total = computed(() => …)` followed by `watch total:` compiled clean, + exited 0, emitted no diagnostic — and the watch body could never run. The + correct spelling was `watch total():`, and the language's own tests had the + parentheses while nothing said so. + +Both trace to one asymmetry: `state` was a declaration and `computed` was a +function, so every derived value had to be parked in a `const` — and `const` +is the thing that freezes reactive reads. The grid now has four cells that +each mean one thing: `let`/`const` are not reactive, `state`/`computed` are, +and within each pair one is written and one is derived. Fixing the spelling +removed the diagnostics that would otherwise have been needed to teach around +it, which is the order this project prefers: a design fix beats a diagnostic +fix, because the diagnostic only teaches after the mistake. + +Migration is mechanical and `velar fix` carries it, including across module +boundaries: `const x = computed(() => E)` becomes `computed x = E`, and reads +lose their parentheses only when every read in the module is a plain `x()`. + +- **VEL5063** answers the three shapes that survive a half-migrated project: + `x()` on a computed value (*"it is read bare like state"*), assignment to a + computed value (which names the `state` spelling that is written instead), + and assignment to a computed value **imported** from another module, which + cannot name a local fix and so names the export that would work. +- **VEL5064** refuses a `watch` subject that can never change, naming the + reactive sources that can: *"This watch subject never changes, so its body + can never run … watch a 'state', a 'computed', a prop, or a resource field, + or move these statements to where they should run."* A bare `5` was already + a compile error (VEL4030); `watch 5:` with a whole block behind it was the + same rule failing to reach one position. The subject is refused only where + the compile can *prove* nothing behind it moves, so a call whose reactivity + lives in another module is left alone. +- The frozen snapshot itself is reported at development time by the runtime, + and it fires **when the source diverges from the snapshot, never when the + snapshot is taken** — taking a snapshot on purpose is legitimate, and a + warning that fires on correct code is one people learn to ignore. The whole + mechanism installs only when the development host publishes its hooks, so a + production build pays nothing: no map, no stack capture. + +### Component props are mutable by default + +A prop is a handle to reactive state, and refusing to write through it forced +callers into ceremony that fought the way the rest of the language reads. +Props now accept assignment; a component that needs the old guarantee writes +`readonly` on the field, and only those props receive readonly-specific +guidance. This aligns a prop with every other reactive value rather than +making it the one exception, and the choice of which contract to offer now +belongs to the component's author. + +### Generic types + +`type Box`, `type Pair`, `type Sorted`, and recursive +forms like `type Tree` are available on records and aliases. A readonly +field is covariant and a mutable one is invariant, so variance follows from +what the field already says rather than from a separate annotation. + +**Generic classes are deliberately not in this release.** The evaluation found +that `Stack()` has no spelling in today's grammar — five candidate +paths were measured and all five are closed — and shipping a type that can be +declared but not constructed is worse than shipping nothing. The decision that +unblocks them is recorded, and it is larger than generic classes: annotations +will flow into generic call-site inference, which also fixes +`const names: List = empty()`. + +### Inline foreign source + +JavaScript and CSS can be written inline against a checked contract: +`extern js(captures)` with a backtick block declares a typed boundary, and +`unsafe js` admits an unchecked one. `unsafe css` does the same for styling +and is owned by the Web extension rather than Core — Core does not know what +CSS is, and putting a `css` keyword in it to save a file would have spent that +boundary for convenience. + +An inline block is **more checked** than the `import js unsafe` it replaces, +not less: the contract sits three lines below the source, where an entire +module going implicitly `any` is invisible. The data-URL spelling that used to +be the only way to write a module inline now gets a mechanical rewrite to the +block form, which is source-mapped. + +A block with captures does not support top-level `await`. That is a decision, +not a gap, and the conditions under which it would be revisited are recorded. + +### Classes can say what iterating them means + +`@iterate:` gives a class a definition for iteration, so a user type takes part +in the same loops the built-in collections do instead of exposing an internal +list to be iterated on its behalf. + +### Web surface + +- Element geometry and computed styles are readable through a controlled + surface — `measure(panel)` and its siblings — rather than through an escape + hatch. The framing that settled it: this is a library surface, not the + language, so it does not carry the language's strictness burden. +- `aria-*` booleans render as literal `true`/`false`, which is what ARIA + actually specifies; the previous rendering was silently wrong for assistive + technology. +- **Every Look property that accepts keywords now carries its own closed set.** + A diagnostic used to say *"use one of the closed fontWeight keywords"* when + `fontWeight` had no closed set to point at — publishing an unreachable table + is the same defect as publishing an unreachable name. A refused Look value + now names the values that property really takes, leading with the property's + own vocabulary and keeping the five CSS-wide keywords separate. The + invariant is enforced for every value kind that closes over strings, not + only the one kind where it was first found, and `transitionProperty`'s + vocabulary is now derived from the Look property table rather than listed by + hand — it previously accepted only the generic defaults, so no property name + was writable. +- **VEL5065**: a Web module publishes its own type names, and declaring one + used to be accepted at the declaration and then lose at every use — `type + Event:` compiled, and the first use was told it could not assign to `Event`, + naming a type the author had just written. The refusal now lands on the + declaration, which is the only place a rename is cheap. +- A module no longer emits type checks against bindings it does not have. + +### Spelling + +- The `Look.` prefix is retired; `Math` joins the permanent namespaces, which + are vocabulary rather than values and are legal only as the head of a member + access. +- Single quotes are retired in JSX attributes. +- Imports return to the named form. +- `-> null` is written only where it cannot be inferred; a body-backed + declaration that returns nothing omits it. +- A type position that receives `=>` is taught `->` instead of being told the + syntax is wrong. +- `velar fix` withholds a mechanical rewrite when the body returns a value, + because the rewrite would not be provably equivalent there. + +### Tests + +`toBe` and `toContain` use the language's own equality rather than +JavaScript's, so a test agrees with the `==` the author would have written. + +### What an adversarial audit found + +A ten-track audit was run against the language before this release, briefed to +attack rather than assess and to record for each finding *which gate should +have caught it*. It produced 26 entries, five of them the highest-value kind: +compiled clean, no diagnostic, wrong answer. + +- **A dynamic import inside `try`, `using`, a test body, a class getter, + `@dispose`, or `@iterate` was left out of the module graph.** + `try await import("./dep.vel")` answered `false` for a module that exists, + with a clean check and exit 0; the other positions surfaced as a runtime + module-not-found. Dependency discovery had a hand-written second walk over + node kinds, which had already drifted past `@iterate` on the day it shipped. + It is now a structural descent that never asks what a node is, the same + duplicated walk is gone from the extension protocol, and the regression is a + matrix of every expression position in the corpus rather than one example. +- **A CSS filename containing a legal `)` walked past the relative-address + gate** and shipped a stylesheet whose address resolves one directory from the + asset — measured as a live 404. The same regex refused `content: + "url(./x.svg)"`, which is text. Both came from a regex standing in for CSS + grammar; the scanner now tokenizes, which surfaced twenty more wrong shapes + in both directions, and the `@import` check — a second scanner in the same + file with lower coverage — reads the same token stream. +- **Three gates claimed more coverage than they had.** The documentation gate's + fence extractor was a regex rather than CommonMark, so legal fences were + silently skipped under a report that every block had compiled; the tour + coverage gate counted a named import as usage, so deleting the only call to a + name still reported full coverage; and the package gate derived its pack list + while leaving the content check and clean-install hand-written. A gate that + overstates its own reach is worse than a missing gate, because it is trusted. + +### Corpus, gates, and documentation + +- **`examples/` is retired.** Seven legacy directories and four loose files + are replaced by a 38-chapter usage tour (20 Core, 14 Web, 4 Desktop) and one + real application. The tour is not illustration: it is **gate corpus**, and + writing the Web and Desktop chapters alone produced ten findings — two of + them a class above the rest, because they are the tools breaking what the + tools promise. `velar format` turned compiling source into source that no + longer compiled, on the one-line reflow path the charter documents by name; + the regression now pins the invariant rather than the shape, so source that + compiles must still compile after formatting. And an exported + `type X = Component` passed `velar check` on two modules and then + failed `velar build`, because the emitter wrote Vel type syntax into + JavaScript — a clean check is a contract, and passing check then failing + build is worse than failing check, because by then the author has believed + it. +- A gate now requires the tour to cover the language surface, reading the + compiler's own tables at run time rather than a list maintained beside them. +- A gate audits what each standard module's runtime actually exports against + what it declares. It audits **one extension at a time**, because merging + them let Desktop's `velar/fs` mask Node's — the merged form reported 30 + surfaces where there were 36. +- The publishable package set is derived from `packages/*`, reading each + manifest's own private flag, so a new package joins the toolchain the day it + exists. The two literal copies it replaces were both correct — the failure + happened outside the repository, where a brief transcribed a truncated view + of one of them and shipped six names instead of eight. A list somebody has + to read and retype is a list somebody eventually gets wrong. Wiring it up + also revealed that `test:packages` had been red since `velar/collections` + stopped exporting `range`, because that gate is in CI but was not in the + three-command sequence being run by hand. +- `check:docs` now compiles every root README rather than only the English + one, and **prints what it could not fully check** instead of reporting a + clean pass over a partial scan. +- Ten instances of one defect family — a name list maintained by hand beside + the authority it was copied from — were replaced by derivation. Core's + contextual keywords had four copies; they now have one original. +- The user-facing documentation is rewritten for someone arriving rather than + for the marathon: a shorter README, a new getting-started guide, a new + language reference in reading order, a rewritten best-practices guide with + one complete program per rule, and a CLI reference grouped by task. +- `docs/handoff/` becomes `docs/decisions/`, with process artifacts moved to + an archive and an index that says what each ruling settled. + ### Final hardening and language surface - `IndexError` was unreachable from every CLI path — the class existed but diff --git a/README.md b/README.md index ef7f8363..929bb5f6 100644 --- a/README.md +++ b/README.md @@ -8,15 +8,36 @@ [![VelarScript CI](https://github.com/VelarOS-AI/VelarScript/actions/workflows/ci.yml/badge.svg)](https://github.com/VelarOS-AI/VelarScript/actions/workflows/ci.yml) -**A language AI writes and maintains, and humans read and own.** - -You supply the intent and read the result. The model writes the VelarScript -and every later change to it. The compiler guards each change. +**An extensible programming language for the AI era, where the framework is the +language.** + +A model can now write code faster than anyone can check it, so the bottleneck +has moved from writing to trusting. Every existing stack was built for the era +when a person wrote each line and held the whole context, where a silent +mistake was affordable because the author knew what they had meant. That +assumption is gone and the stacks have not moved. Vel answers with two things +that are one thing: it shrinks what has to be verified down to a single +language, and it makes the compiler the thing that verifies it. A wrong CSS +value, a misspelled `aria-*`, a missed reactive dependency, a coercion, an +unowned failure — silent everywhere else, compile errors here. + +`component`, `state`, `computed`, `watch`, `look`, and `keyframes` are +keywords, not imports — there is no framework layered on top of the language, +because the framework *is* the language. And Core itself knows none of those +words: it does not know what a DOM, a stylesheet, a filesystem, or a window +is. Every capability arrives as an extension that adds real syntax through a +compiler protocol — `@velarscript/web` brings the words above and JSX, +`@velarscript/desktop` runs that same source model on a system WebView with +permission-scoped capabilities, and `@velarscript/node` adds the server side. +Extensions add syntax, not only libraries, which is what makes the language +extensible rather than merely configurable. Vel is built from the bones of JavaScript and Python — the two languages every -model already knows best — so a model writes it on prior knowledge alone. And -the language keeps **one obvious spelling per idea**, so model output stays -uniform and any Vel codebase reads like any other. +model already knows best — so a model writes it on prior knowledge alone, and +the language keeps **one obvious spelling per idea** so that output stays +uniform and any Vel codebase reads like any other. You supply the intent and +read the result; the model writes the VelarScript and every later change to +it; the compiler guards each change. ## Start diff --git a/README.zh-CN.md b/README.zh-CN.md index cff83be7..f4cd8512 100644 --- a/README.zh-CN.md +++ b/README.zh-CN.md @@ -8,11 +8,13 @@ [![VelarScript CI](https://github.com/VelarOS-AI/VelarScript/actions/workflows/ci.yml/badge.svg)](https://github.com/VelarOS-AI/VelarScript/actions/workflows/ci.yml) -**一门由 AI 编写和维护、由人类阅读和掌控的语言。** +**面向 AI 时代的一门可扩展的编程语言，语言与框架一体化。** -你提供意图并阅读结果，模型负责编写 VelarScript 代码以及之后的每一次修改，编译器则守护每一次变更。 +模型写代码的速度，已经超过了任何人验证它的速度——瓶颈从「写」移到了「信」。今天在用的每一套技术栈，都是为另一个时代造的：每一行由人写，人脑里装着全部上下文。那个时代承受得起静默的错误，因为写的人知道自己是什么意思。这个前提没有了，而技术栈没有动。Vel 的回答是同一件事的两面：把需要验证的面收成一门语言，再让编译器来做验证。写错的 CSS 取值、拼错的 `aria-*`、漏掉的响应式依赖、一次强转、一个无主的失败——在别处全是静默的，在这里是编译错误。 -Vel 以 JavaScript 和 Python 为根基——这是所有模型最熟悉的两门语言，因此模型仅凭已有知识就能编写它。同时，这门语言坚持**每个概念只有一种明确写法**，让模型的输出始终统一，也让任何 Vel 代码库都拥有一致的阅读体验。 +`component`、`state`、`computed`、`watch`、`look`、`keyframes` 是**关键字，不是导入**——语言之上没有另铺一层框架，因为框架**就是**语言。而 Core 本身不认识上面任何一个词：它不知道什么是 DOM、样式表、文件系统或窗口。每一项能力都由扩展经编译器协议加入真正的语法：`@velarscript/web` 带来上面这些词和 JSX，`@velarscript/desktop` 让同一套源码模型跑在系统 WebView 上、能力受权限范围约束，`@velarscript/node` 补上服务端。**扩展加的是语法，不只是库**——这才叫可扩展，而不只是可配置。 + +Vel 以 JavaScript 和 Python 为根基——这是所有模型最熟悉的两门语言，因此模型仅凭已有知识就能编写它。同时，这门语言坚持**每个概念只有一种明确写法**，让输出始终统一，也让任何 Vel 代码库都拥有一致的阅读体验。你提供意图并阅读结果，模型负责编写 VelarScript 代码以及之后的每一次修改，编译器则守护每一次变更。 ## 开始使用 diff --git a/docs/ai-skill.md b/docs/ai-skill.md index bed0821f..9814980d 100644 --- a/docs/ai-skill.md +++ b/docs/ai-skill.md @@ -8,12 +8,12 @@ from the language. ## What VelarScript is -VelarScript (Vel) is a language AI writes and maintains, and humans read and -own. The owner supplies intent and reads the result; you write the Vel and -every later change to it; the compiler guards each change. Vel's parents are -JavaScript and Python. JavaScript is the mother: the program runs inside her, -so behavior defers to JS. Python is the father: the visible spelling follows -him. When unsure about behavior ask the mother, about spelling the father. +VelarScript (Vel) is an extensible programming language for the AI era where the +framework is the language: `component`, `state`, and `look` are keywords rather +than imports, so one checked language covers markup, styling, state, and tests. +You write the Vel and every later change; the owner reads the result; the +compiler guards each change. Vel's parents are JavaScript and Python: ask the +mother about behavior — the program runs inside her — and the father about spelling. **Write on your priors, and the compiler will teach you the rest**: where JS offers five spellings Vel keeps one, and every removed or mistaken spelling gets a diagnostic naming the one current spelling. Expect to self-correct in diff --git a/docs/contributing/continuous-integration.md b/docs/contributing/continuous-integration.md index 79eed756..f0e3bf1c 100644 --- a/docs/contributing/continuous-integration.md +++ b/docs/contributing/continuous-integration.md @@ -12,9 +12,20 @@ The repository defines three GitHub Actions workflows: through the eight packed installed tarballs (compiler, Node, Web, Desktop, creator, CLI, text-buffer, and script-analysis). Browser-project execution first verifies the exact production asset inventory and uses the public - preview server. + preview server. That set is derived from `packages/*` rather than listed: + every publishable workspace package is built, packed, checked against what + its own manifest promises a consumer — LICENSE, README, and every path named + by `main`, `types`, `exports`, `bin` or `velar.entry` — installed into the + clean consumer, and imported through every specifier it publishes. A package + added to the workspace therefore enters all four steps on the day it exists. - The check gate extracts every `velar` fence from README, package guides, and - language/API documentation. Every block — complete or `fragment` — is compiled as a whole module under + language/API documentation. Fences are read by CommonMark's rules rather than + by a regular expression: up to three columns of indentation, backticks or + tildes, a closing fence at least as long as its opening, and the opening + indentation removed from the content. A fence the extractor cannot reach — + inside a block quote, or indented four or more columns by a nested list — is + named and fails the gate rather than being skipped, so the example count is + never larger than the set actually compiled. Every block — complete or `fragment` — is compiled as a whole module under full project analysis with the real Web extension and standard modules. A `fragment` is excused only from the surrounding context it deliberately omits; a type error or a Web-semantic rejection fails the gate in a fragment diff --git a/docs/decisions/D78-POSITIONING.md b/docs/decisions/D78-POSITIONING.md new file mode 100644 index 00000000..01fa8d14 --- /dev/null +++ b/docs/decisions/D78-POSITIONING.md @@ -0,0 +1,107 @@ +# D78 — 这门语言的定位（用户裁决 2026-08-16） + +**推翻本场早些时候由我写下的定位。** 原文是 +「一门由 AI 编写和维护、由人类阅读和拥有的语言」， +所有者读后的判断是：**「没有体现这门语言真正的意义」**。 + +--- + +## 第 195 条 —— 定位 + +> **面向 AI 时代的一门可扩展的编程语言，语言与框架一体化。** +> +> *An extensible programming language for the AI era, where the framework is +> the language.* + +**这是所有者的原话，不是我拟的。** 他的说法是「我一直都是这个定位」—— +也就是说这不是新决定，是**仓库一直在执行、而文案从来没说出来**的那一条。 + +### 为什么旧定位不对（记下来，免得将来又漂回去） + +「AI 写、人读人拥有」回答的是**分工**——谁干什么。 +定位要回答的是**这门语言本身是什么**。分工是真的，但它是下游： + +```text +可扩展 + 语言框架一体化 ← 这门语言是什么 + ↓ +一门语言覆盖结构/样式/状态/测试/服务端，编译器检查全部 + ↓ +所以只留一种写法才有意义，所以敢不承诺兼容 + ↓ +而这两件事付得起代价，是因为 AI 写、AI 改 ← 分工在这里 +``` + +### 我在这条上犯的两个错，都记下来 + +1. **第一次纠偏时，我把所有者的「初衷」当成了定位** + （「不希望用它的人有一天因为受不了 Vel 而重新设计一门语言」）。 + 他的原话回复：**「这是我的初衷不是这门语言的定位」**。 + 两者的区别是：初衷解释**它为什么会出现**，定位说明**它是什么**。 + 两条都要有，但不能互相顶替 —— 见下面的文档结构。 +2. **我拟的第一版英文写成 "language framework"**， + 所有者更正为**编程语言 + 语言与框架一体化**。 + 差别不是措辞：「framework」会读成「语言之上还有一层」， + 而事实恰恰相反 —— `component`、`state`、`look` 是**关键字，不是导入**， + 框架**就是**语言。 + +--- + +## 第 196 条 —— 定位必须由「可扩展」和「一体化」两条一起成立 + +**这两条不是两个卖点，是同一件事的两面**，拆开任何一条都会塌： + +| | 作用 | 拆掉会怎样 | +|---|---|---| +| **一体化** | 把需要验证的面收成一门语言 | 模型又要同时正确拼接六个生态，接缝回来了 | +| **可扩展** | 让上面那条不以 Core 变成垃圾堆为代价 | Core 认识 DOM、CSS、文件系统，攒成它当初要逃离的那一堆 | + +**所以「Core 什么都不认识」是定位的一部分，不是内部纪律。** +本场我拦下的每一次边界违规（D53 的 `unsafe css` 归 web 而非 Core、 +D62 的 Core 名册、`check-runtime-boundary` 的逐扩展审计）**都是在守这条定位**， +只是当时没人把它写成定位。 + +--- + +## 第 197 条 —— 定位文档的八问结构（所有者给的提纲） + +所有者连续问出的八个问题，就是 `docs/why-velarscript.md` 的结构， +**按这个顺序**，不要合并、不要重排： + +1. 它存在的意义是什么 +2. 它能解决什么问题 +3. 它为什么会出现 +4. 它的设计宗旨是什么 +5. 你为什么要选择它 +6. 它的优点是什么 +7. 它承诺什么 +8. **不承诺什么** + +### 三条内容硬约束 + +- **第 3 问是「初衷」的位置。** React 那一堆条框、Vue 的 template、 + 「没有哪一条约束会逼人重写，是那一堆」——**全部放这里，不许上标题**。 + 第 195 条已经裁定它不是定位。 +- **第 3 问必须回答「为什么是现在」。** 删除一直在原理上可行、 + 在实践上付不起（迁移是人力）。**变的是这一点**：作者是模型之后， + 破坏性改动的代价变成一次模型重写加一轮诊断。 + **Vel 在这一刻之前造不出来 —— 不是语法需要模型，是它的核心机制需要。** +- **第 8 问不许软化。** 永不承诺兼容、没有长周期稳定通道、 + 生态广度要自己写边界、不换运行时、**迁移不免费**。 + 一份只说承诺不说不承诺的定位文档是广告，不是定位。 + +--- + +## 落点（本条已执行） + +| 文件 | 状态 | +|---|---| +| `README.md` / `README.zh-CN.md` | 新标题 + 「它解决什么问题」段 | +| `docs/why-velarscript.md` | 按八问重写 | +| `docs/ai-skill.md` + `packages/cli/skill/ai-skill.md` | 开头改写（两份有门禁强制一致） | +| 官网 | **未完成** —— 与响应式栅格的修正合并成一波 | + +**记一处结构缺陷（不是本条的活）**：`docs/ai-skill.md` 与 +`packages/cli/skill/ai-skill.md` 是**手工维护的副本**，靠 +`tests/hardening-blind2.test.ts` 与 `tests/package.acceptance.ts` 两道门禁 +兜住。有门禁所以漂移不会静默，但它仍然是 D57 第 134 条那一族的形状 —— +**该由构建步骤派生，而不是靠人记得 `cp`**。 diff --git a/docs/decisions/D79-CONSTRUCT-GRANULARITY.md b/docs/decisions/D79-CONSTRUCT-GRANULARITY.md new file mode 100644 index 00000000..72d49a37 --- /dev/null +++ b/docs/decisions/D79-CONSTRUCT-GRANULARITY.md @@ -0,0 +1,90 @@ +# D79 — 构造覆盖的粒度，与表达式侧的一个洞（波 U1 上报 2026-08-16） + +D56 第 129 条建的 tour 覆盖门禁，**十八个类别全部是「名字」**。 +波 U1 补上了第十九个类别 `statement-construct`（37 项，三张表派生）， +并在补的过程中撞出两件它无权自己决定的事。 + +**两条都不阻塞发版**，都已经在门禁里以「洞」的形式**印出来**， +而不是被豁免表悄悄吞掉 —— 这是 D57 第 140 条那条纪律的直接应用。 + +--- + +## 第 198 条（待裁决）—— 共享一个 AST 节点种类的拼写，门禁要不要分得开 + +### 现状（实测，门禁每次运行都会打印） + +| 一个节点种类 | 两种拼写 | +|---|---| +| `EmbeddedJavaScriptDeclaration` | `extern js(…)` / `unsafe js` | +| `VariableDeclaration` | `const` / `let` | +| `FunctionDeclaration` | `def` / `async def` | +| `ClassDeclaration` | `class` / `abstract class` | +| `ForStatement` | `for` / `async for` | + +**没有任何编译器自有的表枚举这些分叉**，所以新类别只能要求到*种类*： +tour 两种内联块都写了，但**删掉其中一种不会让门禁变红**。 + +### 反例已经在树里，而且是它自己长出来的 + +Web 扩展的 `unsafe css` **是例外**：它的 `source` 是真正的标签联合 +（`external` | `inline`），所以**两种拼写各自被单独要求** —— +波 U1 的第二次红色验证正是删掉内联块、**留着两行 `import css unsafe`**， +门禁照样红并点名。 + +**这说明代价已知且很小：一个联合。** + +### 我的建议：做 + +`unsafe css` 已经把模式跑通了。**但这是 `packages/**` 里的 AST 形状改动， +不是门禁改动**，所以要你点头。 + +**代价我如实说，不止一个联合**：五个节点里有四个 +（`const`/`let`、`def`/`async def`、`class`/`abstract class`、`for`/`async for`） +是**语言最核心的节点**，给它们加判别式会波及解析、类型、发射、格式化器 +的大量 `switch`。`EmbeddedJavaScriptDeclaration` 是最便宜的一个， +且是本轮唯一有实证需求的一个。 + +**所以可以拆两步，第一步单独就值**： +1. **只给 `EmbeddedJavaScriptDeclaration` 加判别式** —— 一个联合， + 立刻让两种内联块各自被门禁要求。 +2. 其余四对**另议**，它们的收益是纯粹的门禁粒度，代价是核心节点手术。 + +--- + +## 第 199 条（待裁决）—— `duration` 是个没有声明的节点，它挡住了表达式侧 + +### 实测 + +`packages/compiler/src/parser.ts:3486` 产出 +`ExtensionExpression:core:duration`，写法是**一个没有接口、 +不属于任何联合的裸 `as Expression` 强转**。 + +**后果**：一个照着 `CoreExpression` 映射出来的名册**会静默漏掉它** —— +也就是说，把 `statement-construct` 那套照搬到表达式侧， +**得到的会是一个假绿门禁**。这正是波 U1 把新类别**限定在语句**的原因， +而它把这个原因写进了报告而不是让它消失。 + +### 探针的负面结果，如实记（这是好消息） + +除 `duration` 外，**表达式、模式、类型语法、类体的每一个种类， +tour 今天都已经覆盖**，唯一的例外是 `AssignmentExpression` —— +它是解析恢复节点（`ast.ts:800-805` 自己写着「它永远到不了代码生成」）， +**按构造就是反向语料**，不该被要求。 + +### 我的建议：先给 `duration` 一个真正声明的节点，然后表达式侧才便宜 + +顺序是硬的，反过来做不成：**先有声明，才能派生名册**。 +而一旦 `duration` 有了接口并进入 `CoreExpression`， +表达式类别就是把已经跑通的那套照搬一遍。 + +**注意这条本身就是一个缺陷，与门禁无关**： +一个 Core 自己的解析器产出的、却没有类型声明的节点， +是 D57 第 134 条那一族在 AST 上的形态 —— 权威表没有把它算进去。 +**即使不做表达式覆盖，这个强转也该被消掉。** + +--- + +## 排期 + +**两条都不阻塞 0.10.0。** 门禁已经如实打印它覆盖不到的地方， +所以不存在「以为覆盖了其实没有」的假绿 —— 那才是必须在发版前解决的东西。 diff --git a/docs/decisions/D80-WEBSITE-GATE-BLINDNESS.md b/docs/decisions/D80-WEBSITE-GATE-BLINDNESS.md new file mode 100644 index 00000000..cddad20a --- /dev/null +++ b/docs/decisions/D80-WEBSITE-GATE-BLINDNESS.md @@ -0,0 +1,89 @@ +# D80 — 官网门禁的两处失明（波 W1 实测 2026-08-16） + +官网的 `samples:check` **绿了很久，而它验的是一门已经不存在的语言。** +换上当前编译器之后**立刻红，退出码 1，16 个样例失败**。 + +这是缺陷族 #2（门禁覆盖面低于自称）最严重的一种形态 —— +不是"漏了一个情形"，是**整门语言落后了一整轮**。 + +--- + +## 第 200 条 —— 工具链钉的是一个不存在的版本，没有任何东西盯着它 + +### 事实 + +- `package.json` 钉 `@velarscript/cli 0.10.0`、`@velarscript/web 0.10.0`。 +- **npm 上没有这两个包**（registry publication deferred，见语言仓 + `docs/contributing/release-process.md`）。 +- 实际装的是 `npm run bootstrap:local -- /path/to/VelarScript` 从本地源码构建的产物， + **而这一步是手动的**。 +- 所以 `node_modules` 里那份编译器**停在谁最后一次手动 bootstrap 的那一刻**， + 之后语言改多少次都不会有人知道。 + +### 它掩盖了什么（W1 换完编译器后的完整红名单） + +| 类别 | 数量 | 性质 | +|---|---|---| +| 退役的 `computed(` 调用 | 11 | 样例过时 | +| **反转的反例** | 1 | 页面把**正确写法当错误发布** | +| **D74 可变 prop** | 3 | **正文也错** —— 见下 | +| D72 Web 类型名冲突 | 1 | `VEL5065 'Event' is a Web type name` | +| Desktop 枚举长出两个成员 | 1 | `VEL4015 missing: fix, package` | + +**最重的是那三条 D74**，因为错的不只是样例，是**承诺**： +官网当时在发布一条语言已经**主动撤销**的无条件保证 +（对照表写着「顶层：编译错误。嵌套：编译错误。」， +章节标题写着「子组件不能改它收到的东西」， +另一处写着 record prop 以传递只读视图到达）。 + +**过时的样例是 bug；过时的保证是一条语言不再遵守的承诺。** + +### 裁决方向（我的建议，待你定） + +**让"工具链与语言仓一致"成为门禁，而不是一道人工步骤。** +三个候选，我倾向第一个： + +1. **`samples:check` 开跑前先断言装着的编译器与语言仓 HEAD 同源** + （比对构建指纹或 commit），不一致就红并提示 `bootstrap:local`。 + 代价：官网从此需要能看到语言仓的路径。 +2. 发布到 npm 之后改回真钉版本 —— **但这只把问题推迟到下一次语言改动**， + 钉住的版本一样会落后，只是落后得更体面。 +3. CI 手动钉 ref（现状）—— **已被本条证伪**，它正是漂移发生的地方。 + +--- + +## 第 201 条 —— 反例门禁只要求"引用的诊断码出现过"，不要求"只出现这些" + +### 实测 + +`src/pages/language-records.vel` 的 `commonFieldErrorCode` +**通过了门禁，同时静默发射着 VEL5065**，而它想教的是 VEL4001。 +门禁只检查被引用的码**出现过**，所以**一个想教一条错误、实际教了两条的反例， +可以一直绿着**。 + +还有一条**门禁按现状根本抓不到**：`web-overview.vel` 的 +`reservedErrorOutput` 发布 `VEL3007: 'computed' is a reserved extension binding`， +**当前编译器不再发这条**（`computed` 是上下文关键字，保留位归了 `cached`）， +而它绿着的原因是 —— **旁边那行 `tick` 仍然产出 VEL3007**。 + +### 裁决方向（我的建议） + +**反例的断言应当是集合相等，不是包含。** 引用了哪些码， +就必须**恰好**发射哪些码；多出来的一条要么写进去，要么就是这个反例写错了。 +这同时把上面那条「靠邻居顶包」的情形一并关掉。 + +**注意这两条是同一个形状**：断言写成了"存在"，而正确的断言是"恰好"。 +本仓 D57 第 140 条的标准模块表面审计当初也是这么错的 +（子串断言假装在验链接），**是同一族的第三次出现**。 + +--- + +## 一条观察，不是缺陷，不在本条范围 + +`` 在切换语言时**不会重新应用** —— +文档标题停在页面首次加载时的那门语言。W1 确认这是**既有行为且全站一致** +（`/evidence` 表现相同），**且没有触发冻结读取告警**， +所以它是 `Head` 自己的 apply-once 行为，不是 D70 的冻结 `const`。 + +**记它是因为它和状态章开篇讲的侧边栏 bug 是同一类**， +而语言恰好为那一类提供了工具 —— 值得单独查一次 `Head` 该不该跟随。 diff --git a/docs/decisions/D81-RELATIVE-ASSET-ADDRESS.md b/docs/decisions/D81-RELATIVE-ASSET-ADDRESS.md new file mode 100644 index 00000000..be84b51e --- /dev/null +++ b/docs/decisions/D81-RELATIVE-ASSET-ADDRESS.md @@ -0,0 +1,57 @@ +# D81 — 规则的射程是「相对资产地址」，不是 `url()`（2026-08-16） + +波 X2 把 CSS 资产扫描从正则换成 token 语法之后，**看清了一件原来看不见的事**： +同样会 404 的相对地址，还有两种写法，现行措辞一种都不拦。 + +--- + +## 第 202 条 —— VEL5037 覆盖相对资产地址的全部写法 + +### 现状 + +| 写法 | 现在 | 提取到 `assets/` 之后 | +|---|---|---| +| `url("./a.svg")` | **拦** | —— | +| `@font-face { src: url("./a.woff2") }` | **拦**（是 url token） | —— | +| `@font-face { src: src("./a.woff2") }` | **不拦** | **404** | +| `image-set("./a.png" 1x)` 的裸字符串 | **不拦** | **404** | +| `-webkit-image-set(...)` 同上 | **不拦** | **404** | + +### 裁决：按理由划射程，不按函数名 + +**这条规则的理由写在它自己的诊断文案里** —— +「so extracted asset ownership stays explicit」。 +资产归属这件事**分不出** `url()` 和 `src()`：两者提取之后都相对 +`dist/assets/` 解析，都 404，都让归属变成隐式的。 + +**所以规则在论证上早就覆盖了它们，只是措辞停在了一个函数名上。** +这与 D50 第 92 条同源：**发布一条够不到某个位置的规则， +和发布一个够不到的名字，是同一种失败** —— 作者写下一个 +真的会坏掉的东西，而工具说没事。 + +**措辞改述为「相对资产地址」**，实现覆盖 `url()`、`src()`、 +`image-set()` / `-webkit-image-set()` 的裸字符串实参。 + +### 实施必须先验，不许照单全收 + +**上表是波 X2 token 化之后观察到的，我没有逐条复核浏览器行为。** +实施波要**先对每一种形态确认它是真实可写的 CSS** +（浏览器确实会据此发起请求），**再**把它纳入规则。 + +**一个都验不出来的形态不许加进去** —— 那会变成 +「规则拦住了一个没人能写的写法」，正是 D50 第 92 条反对的另一面： +不可达的规则和不可达的名字一样没有价值。 +**验不出来的，在报告里如实说，然后不加。** + +### 不在射程内（写下来，免得将来重议） + +- **`url()` 之外的相对路径本身**（例如 `@import "./theme.css"`）—— + 已由 `containsCssImport()` 单独拦，不归本条。 +- **报告全部还是只报第一条** —— 既有行为，本条不动它。 + +--- + +## 归属 + +`@velarscript/web`。**Core 不认识 CSS**（D53 归属裁决）， +这条不给 Core 增加任何认知。 diff --git a/docs/decisions/D82-STRUCTURAL-TRAVERSAL.md b/docs/decisions/D82-STRUCTURAL-TRAVERSAL.md new file mode 100644 index 00000000..a45e2061 --- /dev/null +++ b/docs/decisions/D82-STRUCTURAL-TRAVERSAL.md @@ -0,0 +1,85 @@ +# D82 — 结构化遍历落地后的一条待裁决与三条记录（波 X1，2026-08-16） + +审计 A-010（S1）已修：依赖发现不再按 kind 走，改为对 AST 的结构化下降。 +**顺带删掉了同一缺陷的第二份副本** —— 扩展协议里的 +`CompilerDependencyContext` 与两个 `visitDependency*` 钩子， +它们让每个扩展各自维护一份 AST 的手抄镜像，各自独立漂移。 + +--- + +## 第 203 条（待裁决）—— `CORE_EXPRESSION_CONSTRUCTS` 要不要发布 + +### 现状不对称 + +| | 完备性由什么保证 | +|---|---| +| `CORE_STATEMENT_CONSTRUCTS` | **`satisfies` 映射类型 —— 抄漏一个 `tsc` 就不过**（U1 实测过） | +| Core 表达式种类 | **没有对应名册**。X1 的测试里手打了 19 个 | + +**后果**：往 `CoreExpression` 加一个新种类，**什么都不会红** —— +它会被静默归类成「不是表达式」，从探针名册里掉出去。 + +### 我的建议：加（与 X1 一致） + +**修复本身两种选择都安全** —— 结构化遍历不认 kind，所以运行时行为不受影响。 +**但门禁的完备性现在压在一份手抄件上，而这正是本波存在的目的所要铲除的那一族。** +D56 第 129 条的论证逐字适用；加了之后，tour 覆盖门禁将来还能顺势要求表达式构造。 + +**X1 没有做，理由正当**：它会改一份已发布的 Core 名册并触及 +tour 覆盖门禁，而当时另一波（X3）正在编辑那个门禁。 + +--- + +## 第 204 条 —— `statementContainsDirectAwait` 是同族剩下的最后一处 + +`packages/compiler/src/ast.ts` 里的这个 switch **是手工维护的， +带一个静默的 `default: return false`，并且没有任何 +`ExtensionStatement:` 的 case**。D43 第 69 条用它决定 +释放一个 `@dispose` 值是否需要异步作用域。 + +**X1 如实报告它构造不出活的失败**（组件体不能 await； +`mounted:`/`cleanup:`/`watch` 体各自是独立帧）， +**所以不记为缺陷，只记为同族的同一形状换了个问题**。 + +**下一轮审计从这里开始。** 一个带静默 `default: return false` +的手抄 switch，在这一场已经被证明是什么了。 + +--- + +## 第 205 条 —— 语料派生名册的真实边界：只以简写出现的容器不可见 + +`ExtensionStatement:web:expose.value` **在 tour 里够不到** —— +tour 只写简写形式 `expose {focus, label}`，它的 value span 就是 key span， +所以任何改写都落不进那个槽。该容器现由测试内自带源码覆盖。 + +**这是语料派生的固有限制，不是这次的疏漏**： +**任何只以简写出现的容器，对语料派生的名册都是隐形的。** +已写进测试正文，不要在将来把它当成新发现。 + +--- + +## 第 206 条 —— 静态 import 仍走顶层扫描，这是对的，别去「修」它 + +**记下来，免得将来有人把它当成 A-010 的漏网。** + +静态 import 与 web 的 `resources()` 都只扫 `program.body` 顶层。 +**X1 验证过这由语言规则兜底，不是运气**： + +| 形态 | 语言的回答 | +|---|---| +| 嵌套的 `import` | `VEL3011 Imports can only be declared at module scope` | +| 嵌套的 `import css unsafe … before look` | `VEL5037 Unsafe CSS is module-level; move the declaration to the top of the module so its order against Look stays visible` | + +**嵌套的 import 永远不可能需要进模块图**，因为它根本不合法。 +顶层扫描在这里是完备的。 + +--- + +## 记一处公开协议变更 + +`@velarscript/compiler/extension` 移除了 `CompilerDependencyContext` +与 `CompilerInspectionExtension` 的 `visitDependencyExpression` / +`visitDependencyStatement`。**仓内消费者只有 `packages/web/src/inspection.ts`，已更新**； +`docs/`、`tests/`、`scripts/`、`packages/*/skill/` 全无引用。 + +**没有任何东西发布过，所以不存在需要迁移的第三方扩展。** diff --git a/docs/escape-hatches.md b/docs/escape-hatches.md index 4d7717b2..bbc283e3 100644 --- a/docs/escape-hatches.md +++ b/docs/escape-hatches.md @@ -101,6 +101,45 @@ on("message", handleMessage) (`onMessage(listener)`, `onClose(listener)`), each declared precisely with `extern module`. +## 1b. JavaScript with no package to import from → an inline block + +Both hatches above name a package. A global, a shim, or a handful of lines that +exist only for one module has no package, and therefore no import spelling. +Write the JavaScript inline instead, with its contract directly underneath: + +```velar +const tokenBytes = 16 + +extern js(tokenBytes: number)` + export function sessionToken() { + const buffer = new Uint8Array(tokenBytes) + globalThis.crypto.getRandomValues(buffer) + return Array.from(buffer, (byte) => byte.toString(16).padStart(2, "0")).join("") + } +`: + export def sessionToken() -> string + +print(sessionToken()) +``` + +The parenthesized list captures Vel bindings of the same name and passes them +to the emitted module as checked arguments — not text substitution. Drop the +contract and it becomes `unsafe js`, whose exports are `any` and carry every +caveat of section 2. + +**This is the tighter hatch, not the looser one.** `import js unsafe` makes a +whole module `any` from another file; a block puts the contract three lines +under the source it governs, and the block compiles to a sibling `.js` with a +source map back to these lines. If you were reaching for a +`data:text/javascript,` import to inline a module, that spelling is now +rejected with a mechanical rewrite into this one. + +**The honest limit:** captures are handed to a synchronous factory, so a block +that takes them cannot use top-level `await`. Await on the Vel side and capture +the result. + +The CSS counterpart is `unsafe css`, in section 3. + ## 2. Quick raw access → `import js unsafe` When a checked declaration is not worth the ceremony yet, `import js unsafe` @@ -135,6 +174,27 @@ import css unsafe "./overrides.css" after look `before look` and `after look` set source order only; specificity and `!important` remain the stylesheet author's responsibility. +When the CSS is a few rules that belong to this module rather than a file worth +keeping, write it inline. The placement is mandatory here too — there is no +default order: + +```velar fragment +unsafe css` + @media print { + article { break-inside: avoid; orphans: 3; widows: 3 } + } +` after look +``` + +Paged media is the honest example: `print` is not a Look media subject and +`break-inside`, `orphans`, and `widows` are excluded properties, because paged +and fragmented media are outside the Web application target. So there is no +Look spelling being avoided — this reaches something Look does not cover at +all, which is what an escape hatch is for. + +`unsafe css` belongs to the Web extension rather than Core, for the same reason +Core has no `look`: Core does not know what a stylesheet is. + ### A stylesheet that ships inside an npm package `import css unsafe` takes a relative project path — `"./legacy.css"` — and diff --git a/docs/language-charter.md b/docs/language-charter.md index ff05505b..9673cfb2 100644 --- a/docs/language-charter.md +++ b/docs/language-charter.md @@ -6,11 +6,16 @@ not part of the language. ## 1. Design contract -VelarScript exists so that AI can write and maintain code that the product's -human owner can read and safely change: the human supplies intent, the model -writes the VelarScript, and the compiler guards each change. Every rule in -this contract serves that mission — uniform model output, diagnostics that -teach, and a readable JavaScript exit — as recorded in +VelarScript is an extensible programming language for the AI era, in which the +framework is the language: one language covers markup, styling, state, tests, +and the server side, and the compiler checks all of it. A model can write code +faster than anyone can check it, so the bottleneck is trust rather than +authorship — the human supplies intent, the model writes the VelarScript, and +the compiler guards each change. Every rule below serves that: uniform output, +diagnostics that teach, mistakes that stay silent elsewhere made loud here, and +a readable JavaScript exit. Rule 5 is the other half of the positioning and not +merely hygiene — unification is only affordable because capability lives in +extensions rather than in Core. The full statement is in [Why VelarScript exists](why-velarscript.md). VelarScript is designed for people and AI systems that already understand @@ -198,8 +203,10 @@ attempts += 1 `case`, `constructor`, `from`, `get`, `match`, `readonly`, `test`, `type`, and `using`; the compiler owns that roster as `CORE_CONTEXTUAL_KEYWORDS`, and this sentence quotes it rather than keeping a second copy of it. Every word - the Web extension adds — `component`, `state`, `resource`, `action`, `watch`, - `look`, `keyframes`, `css`, `expose`, `exposes` — belongs to the same family. + the Web extension adds — `component`, `state`, `computed`, `resource`, + `action`, `watch`, `look`, `keyframes`, `css`, `expose`, `exposes` — belongs + to the same family, and the compiler owns that roster as + `WEB_CONTEXTUAL_KEYWORDS`. All of them are ordinary names anywhere a name can stand: a binding, a parameter, a loop binding, a named argument, a record field, a member name, and a record shorthand. Each becomes a declaration only in the shape that @@ -2390,8 +2397,9 @@ export def encode(value: unknown) -> string: ``` The whole module-boundary family — `import`, every `export` form, re-exports, -`import js`, and `extern module` — is module-top-level only, like `type`, -`class`, and `enum` declarations; writing one inside a block or function body +`import js`, `extern module`, and the inline foreign-source blocks below — is +module-top-level only, like `type`, `class`, and `enum` declarations; writing +one inside a block or function body is a compile error, never partially-working shadow state. A module cannot import from or re-export from itself: the self edge has no valid evaluation order, so the answer is to use (or declare) the binding directly. Each module @@ -2587,6 +2595,54 @@ class field. Values that are not already guaranteed by their package should enter as `unknown` and be validated explicitly with the application's runtime `Type`. +### Inline foreign source + +`extern module` declares what a *package* exports and `import js` names it, so +JavaScript that has **no package to come from** — a global, a shim, a few lines +that exist only for this module — has no import spelling. It gets a block: + +```velar +const tokenBytes = 16 + +extern js(tokenBytes: number)` + export function sessionToken() { + const buffer = new Uint8Array(tokenBytes) + globalThis.crypto.getRandomValues(buffer) + return Array.from(buffer, (byte) => byte.toString(16).padStart(2, "0")).join("") + } +`: + export def sessionToken() -> string +``` + +The backtick body is the module source; the indented block after the colon is +its contract, in exactly the `extern module` grammar. The parenthesized list is +a **capture**: each name binds the Vel binding of that name and is passed to +the emitted factory as a checked argument of the declared type, not substituted +as text. Captures are handed to a synchronous factory, so a block that takes +them cannot use top-level `await` — await on the Vel side and capture the +result. + +`unsafe js` is the same block without a contract, for source whose shape cannot +honestly be declared. Its exports are `any` and the rules under *What `any` +means* apply unchanged: + +```velar +unsafe js` +export const engine = () => ({arch: globalThis.process.arch}); +` +``` + +An inline block is **more checked than the `import js unsafe` it replaces**, +not less: an unsafe import makes a whole module `any` from a distance, while a +block puts the contract three lines under the source it governs. The +`data:text/javascript,` import that used to be the only way to write a module +inline is now rejected with a mechanical rewrite to the block form, which is +source-mapped where the data URL was not. + +Both forms belong to Core, because JavaScript is the runtime Core already emits +into. The CSS counterpart, `unsafe css`, belongs to the Web extension and is +specified in section 13 — Core does not know what a stylesheet is. + ### What `any` means A value imported with `import js unsafe` has the type `any`, and `any` is the @@ -2657,11 +2713,13 @@ right, then JSX children, then the component function. Native JSX remains an owned DOM construction rather than a hidden Core-language operation. The source package then exposes the following language extension. This list is -the complete addition — ten contextual keywords, two lifecycle hooks, three +the complete addition — eleven contextual keywords, two lifecycle hooks, three reserved global functions, and the unit literals; nothing else in a Web module is new syntax. Every *contextual keyword* here declares only in its own shape -and remains available as an ordinary name (section 3). The three reserved -globals are the exception: `computed`, `mount`, and `tick` are real runtime +and remains available as an ordinary name (section 3), `computed` included: it +declares a derived value in `computed name = expression` and is an ordinary +name everywhere else. The three reserved +globals are the exception: `cached`, `mount`, and `tick` are real runtime entry points, so a Web module refuses them as binding names, as it does the media subjects `viewport`, `scheme`, and `motion` (section 17). Those six words are the whole difference between what a Core module and a Web module accept: diff --git a/docs/why-velarscript.md b/docs/why-velarscript.md index 5c4e5c28..e433a89f 100644 --- a/docs/why-velarscript.md +++ b/docs/why-velarscript.md @@ -1,122 +1,166 @@ # Why VelarScript exists -VelarScript is a language AI writes and maintains, and humans read and own. +**An extensible programming language for the AI era, where the framework is +the language.** -## The problem +## What it is for -In the AI era, writing code is no longer the bottleneck — models write it. -The bottleneck is what happens next: the person who owns the product cannot -maintain what the model wrote. JavaScript makes this worse in three specific -ways. It permits a thousand spellings for every idea, so model output varies -wildly between prompts, sessions, and models. It hides traps — coercion, -floating promises, `undefined`, prototype surprises — that only experienced -engineers recognize. And it therefore produces codebases that a product -person, a designer, or a founder can neither read nor safely change, even -though the product is theirs. +A model can now write code faster than anyone can check it. The bottleneck +moved from writing to trusting. -VelarScript exists to solve that problem, not to be a nicer syntax. +Every stack in use today was built for the other era — the one where a person +wrote each line and held the whole context in their head. That era could +afford silent mistakes, because the author knew what they had meant. The +assumption is gone. The stacks have not moved. -## Why it refuses to promise compatibility +VelarScript exists so that code a person did not write can still be owned by +that person: verified by a compiler rather than by reading every line. -This language was designed by someone who could not live inside React's pile -of constraints or Vue's template syntax. So the goal it holds itself to is -that nobody using Vel should one day have to design a replacement for the same -reason. +## What problem it solves + +Two things break when a model writes the code, and neither is "the model +cannot program". + +**The seams.** One feature in a conventional web stack has to be +simultaneously correct against JavaScript semantics, JSX, some CSS approach, +a state library, a router, a build configuration, and a test runner. Most +failures land in the joints between those ecosystems rather than inside any +one of them. Vel removes the joints: styling is syntax, state is syntax, tests +are syntax. The task shrinks from *compose six ecosystems correctly* to *write +one language correctly*. + +**The silence.** In JavaScript most mistakes compile and pass — a misspelled +CSS property, a wrong `aria-*` value, a missing reactive dependency, a +coercion, a floating promise. The person who owns the product, who often +cannot read the code, has no way to know whether the model got it right. +Vel makes those loud: every Look property that takes keywords carries its own +closed set, ARIA is checked, reactive dependencies are discovered rather than +declared, and there is no coercion, no truthiness, no silently dropped +statement, and no unowned failure. The compiler is the reviewer. + +There is a third, quieter one. Model output varies between prompts, sessions, +and models, so a codebase written across many sessions reads like several +codebases. **One obvious spelling per idea** is what makes any Vel codebase +read like any other — which is what makes it maintainable by whoever, or +whatever, picks it up next. + +## Why it appeared now + +Its author could not live inside React's pile of constraints or Vue's template +syntax. That is where it started, but it is not why it could be built. No single constraint makes anyone rewrite a language. React's are each -defensible, each documented, each justified when it was added — it is the -accumulation nobody can stand. Which means the dangerous constraints are -exactly the ones that look worth it individually. - -A language that promises backward compatibility can only add. Friction -accumulates by addition, so a compatibility-promising language drifts toward -being the thing this one was built to escape. **Refusing the promise is the -mechanism that lets a friction be removed once it is found**, rather than -carried forever because something depends on it. It is not a disclaimer about -immaturity; it is the property that keeps the pile from forming. - -What that costs, and how the cost is paid, is under Honest boundaries below. - -## The bet - -Vel is built from the bones of JavaScript and Python — the two languages -every model already knows best. JavaScript is the mother: the program lives -and runs inside her, so behavior defers to her — the runtime is the womb. -Python is the father: the visible surface carries his name — spelling and -readability follow him. A semantic question asks the mother; a spelling -question follows the father — and where an inherited behavior is a trap, -Vel removes it rather than documents it. A model can write Vel on prior -knowledge alone, and the compiler owns the rest: - -- **One obvious spelling.** Where JS offers five ways, Vel keeps one. Model - output becomes uniform: any Vel codebase reads like any other, which is - what makes it maintainable by someone who didn't write it. -- **Diagnostics teach.** Every removed or mistaken spelling gets an error - that names the one current spelling. A model self-corrects in one round - without documentation; a person learns the language from the compiler. - This is measured, not claimed: the release gate includes blind tests where - an AI that has never seen Vel must produce working programs with no - documentation, guided only by diagnostics. -- **Traps are removed, not documented.** No coercion, no truthiness, no - silently dropped statements, no unowned promise failures. The owner of the - product should never need to debug a category of bug they cannot see. -- **The compiler is the safety net.** Checks, bounded runtimes, validated - boundaries, and gates stand between model output and production. Trust is - placed in the gate, not in human review of every line. - -The intended division of labor: **the human supplies intent and reads the -result; the model writes the Vel and every later change to it; the compiler -guards each change.** Maintenance is AI work too — which is why uniformity -matters twice: the next session, or the next model, must be able to pick up -any Vel codebase and modify it safely. For a non-programmer owner, reading -matters more than writing: -Vel's surface is close enough to plain structured English (indentation -blocks, `and`/`or`/`not`, `is not`, `await`/`async`, one spelling per idea) -that the owner can verify the code says what they meant. - -## No dead ends - -A language for real products must never strand a project mid-development. -Vel maintains three exits, in order: - -1. **The diagnostic teaches the fix.** Most walls end here, in one round. -2. **Checked escape hatches to JavaScript.** When Vel or its standard - surface lacks something, `extern module` declares a typed boundary to any - npm package, `import js unsafe` admits a value as unchecked `any` to - validate at the edge, `import css unsafe` and `unsafe:html` cover the - styling and markup boundaries. The escape playbook is part of the - documentation, not folklore. -3. **The final exit: readable JavaScript.** Vel compiles to legible, - source-mapped JS. If Vel itself becomes the obstacle, take the emitted - JavaScript and keep shipping without us. This anti-lock-in property is - gate-tested, not promised. - -## Honest boundaries - -- **Breaking cleanly has a price, and you pay it.** The reason Vel refuses - the compatibility promise is above; here is what it costs. Removed spellings - get teaching diagnostics, never silent aliases and never permanent - compatibility debt, and `velar fix` applies the mechanical part — but you - pin your toolchain version, and you migrate when you move it. -- **Vel is currently for products that move fast**: prototypes, internal - tools, short-lifecycle applications — anything where validation speed - matters more than a ten-year support horizon. A stable channel for - long-lived products is a future milestone, earned by evidence, not - declared by a version number. -- Vel keeps the JavaScript runtime it stands on: objects, references, - Promises, the event loop, the browser. It replaces the source surface, not - the world. - -## How this document binds the project - -Every language decision is tested against this mission, in order: - -1. Normal-language usage — would a person or model fluent in JS/Python write - it that way without reading docs? -2. One obvious spelling — does the change keep model output uniform? -3. Teaching diagnostics — does every rejection name the current spelling? -4. Evidence over taste — blind tests and the real-application wall ledger +defensible, each documented, each justified when it was added. It is the +accumulation nobody can stand — which means the dangerous constraints are +exactly the ones that look worth it individually. A language that promises +backward compatibility can only add, so the friction it discovers is friction +it carries forever, and it drifts toward being the thing you wanted to escape. + +The only way out is to be able to *remove*. Removal has always been possible +in principle and unaffordable in practice, because migration was human labour +and someone always depended on the old spelling. + +**That is what changed.** When the model is the author, a breaking change +costs a rewrite the model performs and a diagnostic that teaches it in one +round. Vel could not have been built before this moment — not because the +syntax needed models, but because its central mechanism did. + +## Design tenets + +Two parents. **JavaScript is the mother**: the program lives and runs inside +her, so behaviour defers to her. **Python is the father**: the visible surface +carries his name, so spelling and readability follow him. A semantic question +asks the mother; a spelling question follows the father. Where an inherited +behaviour is a trap, Vel removes it instead of documenting it. + +Every proposal is tested against these, in order: + +1. **Normal-language usage.** Would someone fluent in JS and Python write it + that way without reading documentation? +2. **One obvious spelling.** Does the change keep output uniform? +3. **Teaching diagnostics.** Does every rejection name the current spelling? +4. **Evidence over taste.** Blind tests and the real-application wall ledger decide, not preference. -If a proposal serves engineers but costs the owner's ability to read the -code, it loses. +Three more that decide the hard cases: + +- **A design fix beats a diagnostic fix.** A diagnostic teaches after the + mistake; the right spelling prevents it. When a defect can be repaired by + changing what the language looks like, that is the repair. +- **Core knows nothing.** Core does not know what a DOM, a stylesheet, a + filesystem, or a window is. Every capability arrives as an extension that + adds real syntax through a compiler protocol. This is what keeps + unification from becoming a kitchen sink: the surface being verified stays + one language, and Core stays small. +- **A published name must be reachable.** Publishing a name, or a table of + values, that no author can reach is worse than publishing nothing. + +If a proposal serves engineers but costs the owner's ability to read the code, +it loses. + +## Why you would choose it + +- You want a model to build and maintain a real product, and you want to read + and own the result without reading every line. +- You want the compiler to be the reviewer. +- You are building something that is still moving — a prototype, an internal + tool, a product still finding its shape. +- You do not want to be trapped: the emitted JavaScript is legible and + source-mapped, and the exit is enforced by a permanent gate rather than + promised in prose. + +**Why you would not.** If you need a ten-year support horizon, Vel does not +have one yet. If you have a large JavaScript codebase you cannot rewrite, Vel +replaces the source surface rather than adopting it incrementally. If your +project's value is in ecosystem breadth, npm is reachable here through +declared boundaries rather than by default, and that boundary is work. + +## What it is good at + +- **One language for the whole application** — markup, styling, state, tests, + and the server side. +- **Surfaces others leave as strings are checked**: Look property values, ARIA, + DOM attributes. +- **No dependency arrays.** A reactive computation subscribes to the reads it + performs while it runs, so dependencies are discovered rather than declared, + and cannot be forgotten. +- **Diagnostics name the one correct spelling**, so a model self-corrects in a + single round and a person learns the language from the compiler. This is + measured by blind tests in which a model that has never seen Vel must + produce working programs with no documentation. +- **Readable, source-mapped output**, with no framework runtime in the browser + beyond the explicit package. +- **No coercion, no truthiness, no silently dropped statements, no unowned + failures.** +- **Extensions add syntax**, which is what makes the language extensible + rather than merely configurable. + +## What it promises + +- Every removed or mistaken spelling gets a diagnostic that names the one + current spelling — never a silent alias, never permanent compatibility debt. + `velar fix` applies the mechanical part, and only where the rewrite is + provably equivalent. +- **No dead ends**, in three exits, in order: the diagnostic teaches the fix; + checked escape hatches reach JavaScript (`extern module`, inline + `extern js` and `unsafe js` blocks, `import js unsafe`, `unsafe css`, + `unsafe:html`); and the final exit is the emitted JavaScript itself — if Vel + becomes the obstacle, take the output and keep shipping without us. +- Traps are removed rather than documented. +- The claims above are gates, not prose: the anti-lock-in exit, the blind + tests, and the language's own usage tour are all things CI can fail on. + +## What it does not promise + +- **Backward compatibility. Ever.** This is the mechanism, not a caveat about + immaturity: refusing the promise is what lets a friction be removed once it + is found. You pin your toolchain version, and you migrate when you move it. +- **A stable channel for long-lived products.** That is a future milestone, to + be earned by evidence rather than declared by a version number. +- **Ecosystem breadth by default.** The npm ecosystem is reachable, through + declared boundaries that cost you something to write. +- **A new runtime.** Vel keeps the JavaScript it stands on — objects, + references, Promises, the event loop, the browser. It replaces the source + surface, not the world. +- **That migration is free.** It is not. The cost is real, and it is the price + of being able to remove. diff --git a/examples/tour/core/13-javascript-boundary.vel b/examples/tour/core/13-javascript-boundary.vel index 379bbde6..47164e45 100644 --- a/examples/tour/core/13-javascript-boundary.vel +++ b/examples/tour/core/13-javascript-boundary.vel @@ -1,5 +1,5 @@ /// Chapter 13 — the JavaScript boundary: `extern module`, `import js`, -/// `import js unsafe`, and what `any` means. +/// `import js unsafe`, the two inline `js` blocks, and what `any` means. /// /// Charter section 12's tail and section 18. The specifier is `node:crypto` /// so the four keywords `extern`, `module`, `js`, and `unsafe` need no @@ -52,6 +52,55 @@ import js unsafe {createHash as rawCreateHash} from "node:crypto" import js unsafe {webcrypto as rawWebcrypto} from "node:crypto" import js unsafe rawDefault from "node:crypto" +// --------------------------------------------------------------------------- +// Inline blocks — the JavaScript that has no module to come from +// --------------------------------------------------------------------------- + +// Everything above names a package: `extern module` declares what one +// exports and `import js` brings a name across. A JavaScript global has no +// package, so there is nothing to declare and nothing to import — and +// `globalThis.crypto.getRandomValues` is a global. That is what an inline +// block is for. The JavaScript rides in a backtick string, so this file's +// parser never has to know JavaScript; the compiler emits the block as a +// sibling `.js` module whose source map points back at these lines. +const tokenBytes = 16 + +extern js(tokenBytes: number)` + export function randomToken() { + const buffer = new Uint8Array(tokenBytes) + globalThis.crypto.getRandomValues(buffer) + return Array.from(buffer, (byte) => byte.toString(16).padStart(2, "0")).join("") + } +`: + export def randomToken() -> string + +// The block is the *more* checked way to reach raw JavaScript, not the looser +// one. `import js unsafe` turns a whole module into `any`; here the contract is +// the one line under the backticks, and `randomToken` is an ordinary checked +// function from this line on — no import, because there is no other module to +// name it from. + +// The parenthesised list is the injection channel, and it binds rather than +// substitutes: `tokenBytes` becomes a real parameter of the emitted module and +// is checked against `number` on this side. Nothing is interpolated — the +// payload is raw bytes, so `${...}` and `{...}` inside a block are literal +// JavaScript text. Values cross through the contract; they are never spliced +// into source. +// +// Because captures are handed to a synchronous factory, a block that takes +// them cannot use top-level `await`. Await on this side and capture the result. + +// A block with no contract is the other form, and it must say `unsafe` — the +// same word as `import js unsafe` and `unsafe:html`, never a second one. +// Everything it exports is `any`. It is still the more honest of the two: +// undeclared JavaScript is readable right here, instead of behind a module +// name that quietly means "no promises about anything inside". +unsafe js` + export function engineReport() { + return { arch: globalThis.process.arch, node: globalThis.process.versions.node } + } +` + // --------------------------------------------------------------------------- // Using the checked side // --------------------------------------------------------------------------- @@ -69,6 +118,12 @@ export def throughNamespace(text: string) -> string: // A namespace import of an extern module reads the same declared contract. return crypto.createHash("sha512").update(text).digest("hex") +// A contracted block's export is checked like any other function: the result is +// `string` because the contract says so, not because the JavaScript looked like +// it returned one. +export def sessionToken() -> string: + return digest(randomToken()) + // A declared `const` export has no VelarScript initializer, and an `unknown` // must be validated before use. type CryptoSubtle: @@ -116,6 +171,17 @@ export def validatedAtTheEdge(candidate: unknown) -> number: const config = Config.parse(candidate) return config.retries +// 4. A block without a contract lands in exactly the same place: `engineReport` +// was never declared, so its result is `any` and every field read below it +// is raw JavaScript. The edge is still the boundary, so validate here too. +type EngineReport: + arch: string + node: string + +export def engineDescription() -> string: + const report = EngineReport.parse(engineReport()) + return f"{report.arch} on Node {report.node}" + // An `unknown` is the ordinary spelling for unvalidated dynamic input; `any` // is reserved for explicit unsafe JavaScript declarations. export def validatesUnknown(value: unknown) -> string: diff --git a/examples/tour/desktop/02-project-tasks.vel b/examples/tour/desktop/02-project-tasks.vel index e5ac222d..9f9b5bf7 100644 --- a/examples/tour/desktop/02-project-tasks.vel +++ b/examples/tour/desktop/02-project-tasks.vel @@ -1,9 +1,10 @@ -// Chapter 02 — the three long-lived Desktop handles. +// Chapter 02 — the four long-lived Desktop handles. // // Authority: the `velar/desktop` module interface in // packages/desktop/src/compiler.ts — `ProjectTask` (4 members), -// `TerminalSession` (6), and `LanguageServer` (3), plus the two enums -// `ProjectTaskCommand` (check, test, build, fix, package, run) and `ProjectTaskOutputChannel` +// `TerminalSession` (6), `LanguageServer` (3), and `ProjectChanges` (6), plus +// the task, output, project-change lifecycle, and project-change risk enums +// `ProjectTaskCommand` (check, test, browserTest, build, fix, package, run) and `ProjectTaskOutputChannel` // (stdout, stderr), and the three functions that open them. // // Every handle here publishes a release operation, so `using` supplies its @@ -12,15 +13,16 @@ // language server are all real actions, so every call below lives in a function // nothing calls. -import {LanguageServer, ProjectTask, ProjectTaskCommand, ProjectTaskOutputChannel, TerminalSession, languageServer, openTerminal, startProjectTask} from "velar/desktop" +import {LanguageServer, ProjectChangeLifecycle, ProjectChangeRisk, ProjectChanges, ProjectTask, ProjectTaskCommand, ProjectTaskOutputChannel, TerminalSession, languageServer, openTerminal, projectChanges, startProjectTask} from "velar/desktop" // `ProjectTaskCommand` is the closed set of toolchain commands a Desktop // application may start. Mechanical fixes and native packaging are first-class -// finite capabilities rather than caller-controlled CLI flags. Browser tests -// need a separately owned browser host and are intentionally absent here. +// finite capabilities rather than caller-controlled CLI flags. `browserTest` +// is the separately owned browser host and always covers all three engines. export const taskCommands: List = [ ProjectTaskCommand.check, ProjectTaskCommand.test, + ProjectTaskCommand.browserTest, ProjectTaskCommand.build, ProjectTaskCommand.fix, ProjectTaskCommand.package, @@ -33,6 +35,8 @@ export def commandLabel(command: ProjectTaskCommand) -> string: return "velar check" case ProjectTaskCommand.test: return "velar test" + case ProjectTaskCommand.browserTest: + return "velar test --browser=all" case ProjectTaskCommand.build: return "velar build" case ProjectTaskCommand.fix: @@ -72,6 +76,12 @@ export async def runTestsAndReport() -> string: const result = await task.wait() return f"{result.code ?? -1}|{result.signal ?? "none"}|{result.stdout.size}|{result.stderr.size}|{task.pid}" +export async def runBrowserTestsAndReport() -> number: + using task = await startProjectTask(ProjectTaskCommand.browserTest, [], {timeout: 600000, maxOutputBytes: 4194304}) + async for output in task: + print(output.text) + return (await task.wait()).code ?? -1 + export async def stopBuild(): using task = await startProjectTask(ProjectTaskCommand.build) await task.stop() @@ -79,6 +89,64 @@ export async def stopBuild(): def startProjectTaskHandle(command: ProjectTaskCommand) -> Promise: return startProjectTask(command) +// `projectChanges()` opens the finite, project-scoped semantic transaction +// owner. Lists are bounded projections; the renderer never receives the +// owner's state path, provider, project root, or arbitrary file operations. +export async def readProjectChanges() -> string: + using owner = await projectChanges() + return await describeProjectChanges(owner) + +async def describeProjectChanges(owner: ProjectChanges) -> string: + const page = await owner.list(10) + if page.changes.size == 0: + return "no governed project changes" + const change = await owner.get(page.changes[0].transactionId) + if change == null: + return "the projected transaction retired" + return f"{change.transactionId}|{lifecycleLabel(change.lifecycle)}|{riskLabel(change.risk)}|{change.changedLines}" + +export def lifecycleLabel(value: ProjectChangeLifecycle) -> string: + match value: + case ProjectChangeLifecycle.prepared: + return "prepared" + case ProjectChangeLifecycle.amended: + return "amended" + case ProjectChangeLifecycle.validated: + return "validated" + case ProjectChangeLifecycle.validationFailed: + return "validation failed" + case ProjectChangeLifecycle.applied: + return "applied" + case ProjectChangeLifecycle.rolledBack: + return "rolled back" + case ProjectChangeLifecycle.discarded: + return "discarded" + +export def riskLabel(value: ProjectChangeRisk) -> string: + match value: + case ProjectChangeRisk.low: + return "low" + case ProjectChangeRisk.medium: + return "medium" + case ProjectChangeRisk.high: + return "high" + +// Accept and rollback remain explicit user actions on the same durable owner. +export async def acceptProjectChange(transactionId: string) -> ProjectChangeLifecycle: + using owner = await projectChanges() + return (await owner.apply(transactionId)).lifecycle + +export async def rollbackProjectChange(transactionId: string) -> ProjectChangeLifecycle: + using owner = await projectChanges() + return (await owner.rollback(transactionId)).lifecycle + +// `subscribe()` is pull-based: one pending read returns a bounded coalesced +// update, or null when this handle is retired. +export async def nextProjectChange() -> number: + using owner = await projectChanges() + const update = await owner.subscribe() + return update?.changes?.size ?? 0 + // `openTerminal(options?)` answers a `TerminalSession`: a real PTY with `pid`, // `write`, `resize`, `next`, `wait`, and `close`. It requires the manifest's // `desktop.permissions.terminal` to be enabled. @@ -121,14 +189,17 @@ export async def streamDiagnostics() -> number: return messages -// The three named types are ordinary type names, so a handle may be annotated, +// The four named types are ordinary type names, so a handle may be annotated, // passed to a helper, and returned like any other value. -export def describeHandles(task: ProjectTask, session: TerminalSession, server: LanguageServer) -> string: - return f"task {task.pid}, terminal {session.pid}, server {describeServer(server)}" +export def describeHandles(task: ProjectTask, session: TerminalSession, server: LanguageServer, changes: ProjectChanges) -> string: + return f"task {task.pid}, terminal {session.pid}, server {describeServer(server)}, changes {describeChanges(changes)}" def describeServer(server: LanguageServer) -> string: return "ready" +def describeChanges(changes: ProjectChanges) -> string: + return "ready" + export component TaskPanel: state report = "no task has run" diff --git a/examples/tour/desktop/03-desktop-test.test.vel b/examples/tour/desktop/03-desktop-test.test.vel index ac857fba..1b2b1452 100644 --- a/examples/tour/desktop/03-desktop-test.test.vel +++ b/examples/tour/desktop/03-desktop-test.test.vel @@ -1,9 +1,9 @@ // Chapter 03 — `velar/desktop-test`. // // Authority: the `velar/desktop-test` module interface in -// packages/desktop/src/compiler.ts — six exports, all asynchronous: +// packages/desktop/src/compiler.ts — seven exports, all asynchronous: // `appDataDirectory`, `projectDirectory`, `makeDirectory`, `readText`, -// `writeText`, and `removeFile`. +// `writeText`, `removeFile`, and `seedProjectChange`. // // The module is the test-process door into the Desktop host, the way // `velar/web-test` is the door into the running page. Its runtime only exists @@ -16,7 +16,7 @@ // (VEL3019), which is why this chapter carries that suffix instead of being // imported by name from `main.vel` the way chapters 01 and 02 are. -import {appDataDirectory, makeDirectory, projectDirectory, readText, removeFile, writeText} from "velar/desktop-test" +import {appDataDirectory, makeDirectory, projectDirectory, readText, removeFile, seedProjectChange, writeText} from "velar/desktop-test" import {expect} from "velar/test" import {projectName} from "./01-desktop-host.vel" @@ -40,20 +40,25 @@ export async def fixtureRound() -> string: return f"{project}|{written}" -// The six export names in the order `fixtureRound` uses them. A Desktop +// Browser tests may seed one bounded semantic transaction through the actual +// capability bridge before they exercise their application's Change face. +export async def seedChangeFixture(): + await seedProjectChange("tour-change", "prepared", "+const toured = true\n") + +// The seven export names in the order the fixture helpers use them. A Desktop // project's `velar test` runs in Node, where no host bridge exists, so a test // module here asserts what it can compute rather than what it would have to // call — the calls themselves belong to `velar test --browser`, where the // framework host answers them. export def fixtureSteps() -> List: - return ["appDataDirectory", "projectDirectory", "makeDirectory", "writeText", "readText", "removeFile"] + return ["appDataDirectory", "projectDirectory", "makeDirectory", "writeText", "readText", "removeFile", "seedProjectChange"] test "a fixture path is built from the host directory and the file name": expect(fixturePath("/tmp/app-data", "round")).toBe("/tmp/app-data/tour-fixtures/round") expect(fixturePath("/tmp/app-data", "note.txt")).toBe("/tmp/app-data/tour-fixtures/note.txt") test "a fixture round is described before it is run": - expect(fixtureSteps()).toHaveLength(6) + expect(fixtureSteps()).toHaveLength(7) expect(fixtureSteps()).toContain("writeText") expect(fixtureSteps().join(" → ")).toMatch("appDataDirectory") diff --git a/examples/tour/desktop/04-desktop-app.browser.test.vel b/examples/tour/desktop/04-desktop-app.browser.test.vel index f7d57c2b..ab024ce1 100644 --- a/examples/tour/desktop/04-desktop-app.browser.test.vel +++ b/examples/tour/desktop/04-desktop-app.browser.test.vel @@ -1,4 +1,4 @@ -// Chapter 04 — the Desktop browser test, where the six `velar/desktop-test` +// Chapter 04 — the Desktop browser test, where the seven `velar/desktop-test` // exports actually run. // // Authority: the same module interface chapter 03 lists, plus D57 rule 138 for @@ -6,7 +6,7 @@ // `velar test --browser` the framework host answers the Desktop bridge, so this // is the one place a fixture round is a call and not a description. -import {appDataDirectory, makeDirectory, projectDirectory, readText, removeFile, writeText} from "velar/desktop-test" +import {appDataDirectory, makeDirectory, projectDirectory, readText, removeFile, seedProjectChange, writeText} from "velar/desktop-test" import {browser} from "velar/web-test" import {expect} from "velar/test" import {fixturePath} from "./03-desktop-test.test.vel" @@ -30,11 +30,15 @@ test "a fixture round writes, reads back, and removes": expect(await readText(file, 4096)).toBe("rewritten by the tour") await removeFile(file) +test "a semantic transaction fixture crosses the real Desktop test bridge": + await browser.open() + await seedProjectChange("tour-browser-change", "prepared", "+const toured = true\n") + test "the renderer is an ordinary Web page": await browser.open() expect(await browser.text("[data-chapter='01'] h2")).toBe("01 — the Desktop host") expect(await browser.text("[data-chapter='02'] h2")).toBe("02 — project tasks, terminals, and the language server") - expect(await browser.text("[data-commands]")).toBe("velar check, velar test, velar build, velar fix, velar package, velar run") + expect(await browser.text("[data-commands]")).toBe("velar check, velar test, velar test --browser=all, velar build, velar fix, velar package, velar run") expect(await browser.text("[data-channels]")).toBe("out/err") await browser.click("[data-read-summary]") await browser.waitForText("[data-summary]", "|") diff --git a/examples/tour/web/08-look-escape.vel b/examples/tour/web/08-look-escape.vel index bd668fc1..b3710e21 100644 --- a/examples/tour/web/08-look-escape.vel +++ b/examples/tour/web/08-look-escape.vel @@ -14,6 +14,28 @@ import css unsafe "./before.css" before look import css unsafe "./after.css" after look import {rgb} from "velar/look" +// The same escape hatch has an inline spelling, and it is the right one when +// the CSS belongs to this module and is short: a sibling file would split one +// idea across two places and add a file nothing in the module graph owns. +// Everything else is unchanged — the payload is raw with no interpolation, and +// `before look` / `after look` stays mandatory, because placement is source +// order and the compiler will not guess it. +// +// Paged media is the case in point. `print` is not one of Look's media +// subjects, and `break-inside`, `orphans`, and `widows` are three of the +// properties checked Look leaves out on purpose — paged and fragmented media +// are outside the Web application target. There is no Look spelling to prefer +// here, so it is native CSS or nothing. +unsafe css` + @media print { + .tour-cascade-counter { + break-inside: avoid; + orphans: 3; + widows: 3; + } + } +` after look + const ink = rgb(24, 31, 46) const accent = rgb(45, 79, 190) diff --git a/package-lock.json b/package-lock.json index 9da265a5..f433b539 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13,6 +13,7 @@ ], "devDependencies": { "@types/node": "^26.1.2", + "@velaros-ai/project": "2.0.1", "playwright": "^1.58.2", "typescript": "^7.0.2" }, @@ -20,6 +21,56 @@ "node": ">=24" } }, + "node_modules/@ai-sdk/gateway": { + "version": "3.0.174", + "resolved": "https://registry.npmjs.org/@ai-sdk/gateway/-/gateway-3.0.174.tgz", + "integrity": "sha512-RXDYc+FGEuy1Y/HlM4MThtQAzG99AIs8ki4tIoVnVweOlW5HDSfaNGNLw556ZR4TifTRuPfBc6QljX4UkuGG6A==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@ai-sdk/provider": "3.0.15", + "@ai-sdk/provider-utils": "4.0.46", + "@vercel/oidc": "3.2.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "zod": "^3.25.76 || ^4.1.8" + } + }, + "node_modules/@ai-sdk/provider": { + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-3.0.15.tgz", + "integrity": "sha512-XeZW1CcDF2GMbH4wejW6xBRI2QCOgnkVYUnxoeDadB1mf85riL2bMUeDoh+6gJ/r4mjNfzUPW8OjLjvwTP0u1Q==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "json-schema": "^0.4.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@ai-sdk/provider-utils": { + "version": "4.0.46", + "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-4.0.46.tgz", + "integrity": "sha512-tEtld97plCFiYevsJuOkGkeuhQndeMWFBVrJS4AjnbD5AqrNSXRCe0p+BZ3Cju/sxDeeZ9ym3q9YUV8fASA7aQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@ai-sdk/provider": "3.0.15", + "@standard-schema/spec": "^1.1.0", + "eventsource-parser": "^3.0.8", + "undici": "^6.28.0" + }, + "engines": { + "node": ">=18.17" + }, + "peerDependencies": { + "zod": "^3.25.76 || ^4.1.8" + } + }, "node_modules/@esbuild/aix-ppc64": { "version": "0.28.1", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz", @@ -436,6 +487,97 @@ "node": ">=18" } }, + "node_modules/@hono/node-server": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-2.1.1.tgz", + "integrity": "sha512-ELuehkj5VCBdgEw9zs+ivkKwyzzUCSQuE96YmiPvn1ECBoZCczbFXJLeEGMTYjphP6gydh4pHMqEYPVMYUVgQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "peerDependencies": { + "hono": "^4" + } + }, + "node_modules/@modelcontextprotocol/sdk": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.0.tgz", + "integrity": "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@hono/node-server": "^1.19.9 || ^2.0.5", + "ajv": "^8.17.1", + "ajv-formats": "^3.0.1", + "content-type": "^1.0.5", + "cors": "^2.8.5", + "cross-spawn": "^7.0.5", + "eventsource": "^3.0.2", + "eventsource-parser": "^3.0.0", + "express": "^5.2.1", + "express-rate-limit": "^8.2.1", + "hono": "^4.11.4", + "jose": "^6.1.3", + "json-schema-typed": "^8.0.2", + "pkce-challenge": "^5.0.0", + "raw-body": "^3.0.0", + "zod": "^3.25 || ^4.0", + "zod-to-json-schema": "^3.25.1" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@cfworker/json-schema": "^4.1.1", + "zod": "^3.25 || ^4.0" + }, + "peerDependenciesMeta": { + "@cfworker/json-schema": { + "optional": true + }, + "zod": { + "optional": false + } + } + }, + "node_modules/@opentelemetry/api": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.1.tgz", + "integrity": "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@sec-ant/readable-stream": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz", + "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@sindresorhus/merge-streams": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz", + "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/node": { "version": "26.1.2", "resolved": "https://registry.npmjs.org/@types/node/-/node-26.1.2.tgz", @@ -786,6 +928,102 @@ "node": ">=16.20.0" } }, + "node_modules/@velaros-ai/agent": { + "version": "0.5.1", + "resolved": "https://npm.pkg.github.com/download/@velaros-ai/agent/0.5.1/be0aa6441636e6093bf9b4b9fbab7318770436f1", + "integrity": "sha512-GT0A/Y60xAPU6JM8o4XAaL0Bmna3dl0O+Fo/l+O/xBRkAnvVlHRCxIfqAicuxrwmfuzGMsW4lj+ku6DHBdiF2w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.29.0", + "@velaros-ai/core": "0.4.0", + "@velaros-ai/kernel": "0.1.1", + "ai": "^6.0.168", + "execa": "^9.6.1", + "gpt-tokenizer": "^3.0.1", + "typescript": "^5.7.0", + "zod": "^4.3.6" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@velaros-ai/agent/node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/@velaros-ai/core": { + "version": "0.4.0", + "resolved": "https://npm.pkg.github.com/download/@velaros-ai/core/0.4.0/cd2528479b34ace04dad491f32ef419c5be441a2", + "integrity": "sha512-DpDMnQshiyNCW8EffbryTyGyQVDmz5Tv5qlhqOePf6VT/lNGZP//mQyLuvbTsH+uNbvqkOUrdIV88K0PISrTyA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@velaros-ai/kernel": { + "version": "0.1.1", + "resolved": "https://npm.pkg.github.com/download/@velaros-ai/kernel/0.1.1/62e08e5d7233a5d83f395ab17c2bca214c27f3f4", + "integrity": "sha512-x0VDoJs+HeufdhCp1lrgsd3Er/XY8VTXS88Of2yaFL/C+AdC4qjFFdEmhhfflbTALpxeYwQi/992X8+0NYtDBA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@velaros-ai/core": "0.4.0", + "zod": "^4.3.6" + }, + "bin": { + "velaros-kernel-daemon": "dist/serve/main.js" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@velaros-ai/project": { + "version": "2.0.1", + "resolved": "https://npm.pkg.github.com/download/@velaros-ai/project/2.0.1/b93b3da820c6e79c523936863b210c91e8476203", + "integrity": "sha512-SAJeZ8LQ63/RTya6ooYYi0T9BKjdl1iGZBWBVZLAvdlvdtspyt2IdRiwoQgcmxIphZOQXCIoBpqoeWttDVOvyw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@velaros-ai/agent": "0.5.1", + "@velaros-ai/core": "0.4.0", + "@velaros-ai/kernel": "0.1.1", + "diff": "^8.0.4", + "execa": "^9.6.1", + "iconv-lite": "^0.7.2", + "picomatch": "^4.0.3", + "typescript": "^5.0.0", + "zod": "^4.3.6" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@velaros-ai/project/node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, "node_modules/@velarscript/cli": { "resolved": "packages/cli", "link": true @@ -814,6 +1052,30 @@ "resolved": "packages/web", "link": true }, + "node_modules/@vercel/oidc": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.2.0.tgz", + "integrity": "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">= 20" + } + }, + "node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, "node_modules/acorn": { "version": "8.18.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.18.0.tgz", @@ -826,136 +1088,1610 @@ "node": ">=0.4.0" } }, - "node_modules/create-velar": { - "resolved": "packages/create", - "link": true - }, - "node_modules/esbuild": { - "version": "0.28.1", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", - "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" + "node_modules/ai": { + "version": "6.0.256", + "resolved": "https://registry.npmjs.org/ai/-/ai-6.0.256.tgz", + "integrity": "sha512-xYvQfvwFG1AsiLv8wSS1o1077q/494HxzI6SIw0G/5zIoirNyJUzFlh/BTZBqbHMa03Pt5EouIGAbGimldiDGg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@ai-sdk/gateway": "3.0.174", + "@ai-sdk/provider": "3.0.15", + "@ai-sdk/provider-utils": "4.0.46", + "@opentelemetry/api": "^1.9.0" }, "engines": { "node": ">=18" }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.28.1", - "@esbuild/android-arm": "0.28.1", - "@esbuild/android-arm64": "0.28.1", - "@esbuild/android-x64": "0.28.1", - "@esbuild/darwin-arm64": "0.28.1", - "@esbuild/darwin-x64": "0.28.1", - "@esbuild/freebsd-arm64": "0.28.1", - "@esbuild/freebsd-x64": "0.28.1", - "@esbuild/linux-arm": "0.28.1", - "@esbuild/linux-arm64": "0.28.1", - "@esbuild/linux-ia32": "0.28.1", - "@esbuild/linux-loong64": "0.28.1", - "@esbuild/linux-mips64el": "0.28.1", - "@esbuild/linux-ppc64": "0.28.1", - "@esbuild/linux-riscv64": "0.28.1", - "@esbuild/linux-s390x": "0.28.1", - "@esbuild/linux-x64": "0.28.1", - "@esbuild/netbsd-arm64": "0.28.1", - "@esbuild/netbsd-x64": "0.28.1", - "@esbuild/openbsd-arm64": "0.28.1", - "@esbuild/openbsd-x64": "0.28.1", - "@esbuild/openharmony-arm64": "0.28.1", - "@esbuild/sunos-x64": "0.28.1", - "@esbuild/win32-arm64": "0.28.1", - "@esbuild/win32-ia32": "0.28.1", - "@esbuild/win32-x64": "0.28.1" + "peerDependencies": { + "zod": "^3.25.76 || ^4.1.8" } }, - "node_modules/fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "hasInstallScript": true, + "node_modules/ajv": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz", + "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==", + "dev": true, "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" } }, - "node_modules/playwright": { - "version": "1.62.1", - "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.62.1.tgz", - "integrity": "sha512-0M+L3LAD8/nm554LOla9Ayx0j0tmFZ0FBcoQ7F1VuVHpM/XpiC8RcDzBQB8W5+hA8L22THxELzeF+2WcUzvcLg==", - "license": "Apache-2.0", + "node_modules/ajv-formats": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", + "dev": true, + "license": "MIT", "dependencies": { - "playwright-core": "1.62.1" + "ajv": "^8.0.0" }, - "bin": { - "playwright": "cli.js" + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/body-parser": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz", + "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^2.0.0", + "debug": "^4.4.3", + "http-errors": "^2.0.1", + "iconv-lite": "^0.7.2", + "on-finished": "^2.4.1", + "qs": "^6.15.2", + "raw-body": "^3.0.2", + "type-is": "^2.1.0" }, "engines": { - "node": ">=20" + "node": ">=18" }, - "optionalDependencies": { - "fsevents": "2.3.2" + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, - "node_modules/playwright-core": { - "version": "1.62.1", - "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.62.1.tgz", - "integrity": "sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw==", - "license": "Apache-2.0", - "bin": { - "playwright-core": "cli.js" + "node_modules/body-parser/node_modules/content-type": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.1.0.tgz", + "integrity": "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=20" + "node": ">= 0.8" } }, - "node_modules/typescript": { - "version": "7.0.2", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz", - "integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==", + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", "dev": true, - "license": "Apache-2.0", - "bin": { - "tsc": "bin/tsc" + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" }, "engines": { - "node": ">=16.20.0" + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" }, - "optionalDependencies": { - "@typescript/typescript-aix-ppc64": "7.0.2", - "@typescript/typescript-darwin-arm64": "7.0.2", - "@typescript/typescript-darwin-x64": "7.0.2", - "@typescript/typescript-freebsd-arm64": "7.0.2", - "@typescript/typescript-freebsd-x64": "7.0.2", - "@typescript/typescript-linux-arm": "7.0.2", - "@typescript/typescript-linux-arm64": "7.0.2", - "@typescript/typescript-linux-loong64": "7.0.2", - "@typescript/typescript-linux-mips64el": "7.0.2", - "@typescript/typescript-linux-ppc64": "7.0.2", - "@typescript/typescript-linux-riscv64": "7.0.2", - "@typescript/typescript-linux-s390x": "7.0.2", - "@typescript/typescript-linux-x64": "7.0.2", - "@typescript/typescript-netbsd-arm64": "7.0.2", - "@typescript/typescript-netbsd-x64": "7.0.2", - "@typescript/typescript-openbsd-arm64": "7.0.2", - "@typescript/typescript-openbsd-x64": "7.0.2", - "@typescript/typescript-sunos-x64": "7.0.2", - "@typescript/typescript-win32-arm64": "7.0.2", - "@typescript/typescript-win32-x64": "7.0.2" + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/undici-types": { - "version": "8.3.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz", - "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==", + "node_modules/content-disposition": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz", + "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==", "dev": true, - "license": "MIT" + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/cors": { + "version": "2.8.6", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz", + "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/create-velar": { + "resolved": "packages/create", + "link": true + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/diff": { + "version": "8.0.4", + "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.4.tgz", + "integrity": "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "dev": true, + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz", + "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "dev": true, + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventsource": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz", + "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==", + "dev": true, + "license": "MIT", + "dependencies": { + "eventsource-parser": "^3.0.1" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/eventsource-parser": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.1.tgz", + "integrity": "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/execa": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-9.6.1.tgz", + "integrity": "sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sindresorhus/merge-streams": "^4.0.0", + "cross-spawn": "^7.0.6", + "figures": "^6.1.0", + "get-stream": "^9.0.0", + "human-signals": "^8.0.1", + "is-plain-obj": "^4.1.0", + "is-stream": "^4.0.1", + "npm-run-path": "^6.0.0", + "pretty-ms": "^9.2.0", + "signal-exit": "^4.1.0", + "strip-final-newline": "^4.0.0", + "yoctocolors": "^2.1.1" + }, + "engines": { + "node": "^18.19.0 || >=20.5.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/express": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", + "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.1", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "depd": "^2.0.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "8.6.2", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.6.2.tgz", + "integrity": "sha512-YH4ru+eOJxQABscKFfRCy9R7x9QFGdezclVMwwgFFndzS2Xnm0uo6B0ABZsLhcpeptGv2qvuJVWlQr9gQZoC3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "ip-address": "^10.2.0" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": ">= 4.11" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz", + "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/figures": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz", + "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-unicode-supported": "^2.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/finalhandler": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", + "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-stream": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz", + "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sec-ant/readable-stream": "^0.4.1", + "is-stream": "^4.0.1" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gpt-tokenizer": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/gpt-tokenizer/-/gpt-tokenizer-3.4.0.tgz", + "integrity": "sha512-wxFLnhIXTDjYebd9A9pGl3e31ZpSypbpIJSOswbgop5jLte/AsZVDvjlbEuVFlsqZixVKqbcoNmRlFDf6pz/UQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", + "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hono": { + "version": "4.13.2", + "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.2.tgz", + "integrity": "sha512-JydRilDRkYBQMt9qR9U92mXxmbGqsqSn/IKOrh4e7/gEbn+0zSr8igTu0obwJoNGN4sez28DIql7FBHWydoJpA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.9.0" + } + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/human-signals": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz", + "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz", + "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/ip-address": { + "version": "10.5.0", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.5.0.tgz", + "integrity": "sha512-R5SnVLJmgYYvf2F2ZgwSBnelz5G4q5AxIC277GDfUaNbrZKNANcBC7RHqYYePlszf4kBolVkJauG0ZjHHFh55g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", + "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-stream": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz", + "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-unicode-supported": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz", + "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/jose": { + "version": "6.2.9", + "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.9.tgz", + "integrity": "sha512-XrchZOFZUl/T3vTwRe8XK+cJrGtMF4th1ARnDfwbBXFKThGhlsxEE4Zu03AD/bjJSt/9jT/mxrOCkJWOg77aPA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/panva" + } + }, + "node_modules/json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", + "dev": true, + "license": "(AFL-2.1 OR BSD-3-Clause)" + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-typed": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz", + "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==", + "dev": true, + "license": "BSD-2-Clause" + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.1.tgz", + "integrity": "sha512-yz3xRaG20c6/BOzvYoDaGtPmGscs7YivItZEEqe6GbwNfHuxu9YNmvnEkMzKldAGY4/80pRcQRZSEnhquk9XuQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-db": "^1.54.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/npm-run-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz", + "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^4.0.0", + "unicorn-magic": "^0.3.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path/node_modules/path-key": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz", + "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/parse-ms": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz", + "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-to-regexp": { + "version": "8.4.2", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz", + "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/picomatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", + "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pkce-challenge": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz", + "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/playwright": { + "version": "1.62.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.62.1.tgz", + "integrity": "sha512-0M+L3LAD8/nm554LOla9Ayx0j0tmFZ0FBcoQ7F1VuVHpM/XpiC8RcDzBQB8W5+hA8L22THxELzeF+2WcUzvcLg==", + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.62.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=20" + }, + "optionalDependencies": { + "fsevents": "2.3.2" + } + }, + "node_modules/playwright-core": { + "version": "1.62.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.62.1.tgz", + "integrity": "sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw==", + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/pretty-ms": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.3.0.tgz", + "integrity": "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parse-ms": "^4.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.15.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz", + "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "es-define-property": "^1.0.1", + "side-channel": "^1.1.1" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.3.0.tgz", + "integrity": "sha512-hek2mFQpPuI4E1BBKrSto+BU3e3x4xuarsbiwr3+lf7p44juvFMV0XFWQAP3xUyqXA4RrXLIoaSUGbSt056ZMw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/raw-body": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", + "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.7.0", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/router": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", + "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "depd": "^2.0.0", + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true, + "license": "MIT" + }, + "node_modules/send": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz", + "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^2.0.0", + "http-errors": "^2.0.1", + "mime-types": "^3.0.2", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/serve-static": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz", + "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==", + "dev": true, + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.2.0" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "dev": true, + "license": "ISC" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz", + "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4", + "side-channel-list": "^1.0.1", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz", + "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/strip-final-newline": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz", + "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/type-is": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz", + "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==", + "dev": true, + "license": "MIT", + "dependencies": { + "content-type": "^2.0.0", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/type-is/node_modules/content-type": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.1.0.tgz", + "integrity": "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/typescript": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz", + "integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc" + }, + "engines": { + "node": ">=16.20.0" + }, + "optionalDependencies": { + "@typescript/typescript-aix-ppc64": "7.0.2", + "@typescript/typescript-darwin-arm64": "7.0.2", + "@typescript/typescript-darwin-x64": "7.0.2", + "@typescript/typescript-freebsd-arm64": "7.0.2", + "@typescript/typescript-freebsd-x64": "7.0.2", + "@typescript/typescript-linux-arm": "7.0.2", + "@typescript/typescript-linux-arm64": "7.0.2", + "@typescript/typescript-linux-loong64": "7.0.2", + "@typescript/typescript-linux-mips64el": "7.0.2", + "@typescript/typescript-linux-ppc64": "7.0.2", + "@typescript/typescript-linux-riscv64": "7.0.2", + "@typescript/typescript-linux-s390x": "7.0.2", + "@typescript/typescript-linux-x64": "7.0.2", + "@typescript/typescript-netbsd-arm64": "7.0.2", + "@typescript/typescript-netbsd-x64": "7.0.2", + "@typescript/typescript-openbsd-arm64": "7.0.2", + "@typescript/typescript-openbsd-x64": "7.0.2", + "@typescript/typescript-sunos-x64": "7.0.2", + "@typescript/typescript-win32-arm64": "7.0.2", + "@typescript/typescript-win32-x64": "7.0.2" + } + }, + "node_modules/undici": { + "version": "6.28.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-6.28.0.tgz", + "integrity": "sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.17" + } + }, + "node_modules/undici-types": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz", + "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unicorn-magic": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz", + "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/yoctocolors": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.2.0.tgz", + "integrity": "sha512-xYqdZFUK/VYazNl/oCDYN+3WloWQwMfZxBoiNt6qNyk+xfOdi598muWE42rNZFp1kNOiqW936q5RhUdnpqElSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zod": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz", + "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-to-json-schema": { + "version": "3.25.2", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz", + "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==", + "dev": true, + "license": "ISC", + "peerDependencies": { + "zod": "^3.25.28 || ^4" + } }, "packages/cli": { "name": "@velarscript/cli", diff --git a/package.json b/package.json index 2daf277d..2effd88b 100644 --- a/package.json +++ b/package.json @@ -22,7 +22,7 @@ "release:verify": "node scripts/release-toolchain.mjs verify", "preview:prepare": "node scripts/prepare-external-preview.mjs", "velar": "node scripts/gate-lock.mjs npm run --silent gate:velar --", - "gate:build:packages": "npm run build --workspace @velarscript/compiler && npm run build --workspace @velarscript/node && npm run build --workspace @velarscript/web && npm run build --workspace create-velar && npm run build --workspace @velarscript/desktop && npm run build --workspace @velarscript/cli", + "gate:build:packages": "node scripts/build-packages.mjs", "gate:check": "npm run build:packages && npm run check:format && npm run check:docs && npm run check:boundaries && npm run check:projects && npm run check:tour-coverage && tsc -p tsconfig.json", "gate:test": "npm run build:packages && node --test --test-concurrency=1 --test-timeout=120000 tests/*.test.ts tests/ci.acceptance.ts tests/release.acceptance.ts && node scripts/run-project-gate.mjs unit", "gate:test:browser": "npm run build:packages && node tests/browser.acceptance.ts && node scripts/run-project-gate.mjs browser && node tests/installed-browser.acceptance.ts", @@ -37,6 +37,7 @@ "url": "git+https://github.com/VelarOS-AI/VelarScript.git" }, "devDependencies": { + "@velaros-ai/project": "2.0.1", "@types/node": "^26.1.2", "playwright": "^1.58.2", "typescript": "^7.0.2" diff --git a/packages/cli/skill/ai-skill.md b/packages/cli/skill/ai-skill.md index bed0821f..9814980d 100644 --- a/packages/cli/skill/ai-skill.md +++ b/packages/cli/skill/ai-skill.md @@ -8,12 +8,12 @@ from the language. ## What VelarScript is -VelarScript (Vel) is a language AI writes and maintains, and humans read and -own. The owner supplies intent and reads the result; you write the Vel and -every later change to it; the compiler guards each change. Vel's parents are -JavaScript and Python. JavaScript is the mother: the program runs inside her, -so behavior defers to JS. Python is the father: the visible spelling follows -him. When unsure about behavior ask the mother, about spelling the father. +VelarScript (Vel) is an extensible programming language for the AI era where the +framework is the language: `component`, `state`, and `look` are keywords rather +than imports, so one checked language covers markup, styling, state, and tests. +You write the Vel and every later change; the owner reads the result; the +compiler guards each change. Vel's parents are JavaScript and Python: ask the +mother about behavior — the program runs inside her — and the father about spelling. **Write on your priors, and the compiler will teach you the rest**: where JS offers five spellings Vel keeps one, and every removed or mistaken spelling gets a diagnostic naming the one current spelling. Expect to self-correct in diff --git a/packages/cli/src/browser-test-runner.ts b/packages/cli/src/browser-test-runner.ts index fefd809b..34c9a110 100644 --- a/packages/cli/src/browser-test-runner.ts +++ b/packages/cli/src/browser-test-runner.ts @@ -17,7 +17,7 @@ import { import type { VelarProjectConfig } from "./config.ts"; import { compileProject } from "./project.ts"; import { standardModuleSource, standardModuleSources } from "./standard-modules.ts"; -import { compiledTestModulePath, quoteReportedText, writeCompiledTestProject } from "./test-output.ts"; +import { compiledTestModulePath, portablePath, quoteReportedText, writeCompiledTestProject } from "./test-output.ts"; import { verifyProductionBuild } from "./production-verifier.ts"; import { startProductionPreview, type ProductionPreviewHandle } from "./preview-server.ts"; import { hostErrorStack } from "./host-error.ts"; @@ -475,7 +475,7 @@ async function runBrowserTestsInWorker( } catch (error) { if (lifecycleFailure !== null) throw lifecycleFailure; failed += entry.tests.length; - process.stderr.write(`✗ ${engine} :: ${relative(config.root, entry.file)} failed to load\n${stackOf(error)}\n${browserTestHostGuidance}\n`); + process.stderr.write(`✗ ${engine} :: ${portablePath(relative(config.root, entry.file))} failed to load\n${stackOf(error)}\n${browserTestHostGuidance}\n`); await channel.drain(); continue; } @@ -486,7 +486,7 @@ async function runBrowserTestsInWorker( const loadTimeErrors = await channel.drain(); if (loadTimeErrors.length > 0) { failed += entry.tests.length; - process.stderr.write(`✗ ${engine} :: ${relative(config.root, entry.file)} reported an unowned error while loading\n${loadTimeErrors.join("\n")}\n${browserTestHostGuidance}\n`); + process.stderr.write(`✗ ${engine} :: ${portablePath(relative(config.root, entry.file))} reported an unowned error while loading\n${loadTimeErrors.join("\n")}\n${browserTestHostGuidance}\n`); continue; } for (const declared of entry.tests) { @@ -517,7 +517,7 @@ async function runBrowserTestsInWorker( await boundedBrowserOperation( Promise.resolve().then(() => test()), limits.testTimeoutMs, - `Browser test ${quoteReportedText(relative(config.root, entry.file))} :: ${name}`, + `Browser test ${quoteReportedText(portablePath(relative(config.root, entry.file)))} :: ${name}`, lifecycle, ); if (runtimeFailures.length > 0) throw new Error(`Browser runtime failures:\n${runtimeFailures.join("\n")}`); @@ -549,10 +549,10 @@ async function runBrowserTestsInWorker( if (testFailure instanceof BrowserTestInterrupted || testFailure instanceof BrowserTestRunTimedOut) throw testFailure; if (testFailure === null) { passed += 1; - process.stdout.write(`✓ ${engine} :: ${quoteReportedText(relative(config.root, entry.file))} :: ${name}\n`); + process.stdout.write(`✓ ${engine} :: ${quoteReportedText(portablePath(relative(config.root, entry.file)))} :: ${name}\n`); } else { failed += 1; - process.stderr.write(`✗ ${engine} :: ${quoteReportedText(relative(config.root, entry.file))} :: ${name}\n${stackOf(testFailure)}\n`); + process.stderr.write(`✗ ${engine} :: ${quoteReportedText(portablePath(relative(config.root, entry.file)))} :: ${name}\n${stackOf(testFailure)}\n`); } if (!engineUsable) { process.stderr.write(`✗ ${engine} was retired after context cleanup failed\n`); @@ -680,14 +680,14 @@ async function compileBrowserTest( ...project.modules.flatMap((module) => module.result.diagnostics.map((diagnostic) => formatDiagnostic(module.result.source, diagnostic))), ]; if (errors.length > 0) { - process.stderr.write(`✗ ${relative(config.root, file)}\n${errors.join("\n\n")}\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))}\n${errors.join("\n\n")}\n`); return null; } await writeCompiledTestProject(project, outputRoot); const entry = project.modules.find((module) => module.inputPath === file); const tests = entry?.result.moduleInterface.tests ?? []; if (tests.length === 0) { - process.stderr.write(`✗ ${relative(config.root, file)} declares no tests\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))} declares no tests\n`); return null; } return { file, output: entry ? compiledTestModulePath(project, entry, outputRoot) : join(outputRoot, relative(config.root, file).replace(/\.vel$/u, ".js")), tests }; @@ -706,10 +706,13 @@ function installBrowserRuntime(page: Page, origin: string, base: string, runtime const value = String(path); if (!value.startsWith("/")) throw new Error("browser.open requires an application-relative path starting with '/'"); const target = base === "/" ? value : `${base.slice(0, -1)}${value}`; - await page.goto(new URL(target, origin).href, { waitUntil: "networkidle" }); + // Navigation owns document loading, not application network quiescence. + // A product may poll or stream forever; tests establish readiness with + // the web-first waitFor/waitForText assertions exposed beside open(). + await page.goto(new URL(target, origin).href, { waitUntil: "load" }); return null; }, - async reload() { await page.reload({ waitUntil: "networkidle" }); return null; }, + async reload() { await page.reload({ waitUntil: "load" }); return null; }, async click(selector: unknown) { await locator(selector).click(); return null; }, async fill(selector: unknown, value: unknown) { await locator(selector).fill(String(value)); return null; }, async select(selector: unknown, value: unknown) { await locator(selector).selectOption(String(value)); return null; }, diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts index 93c933c5..1b47a4cf 100755 --- a/packages/cli/src/cli.ts +++ b/packages/cli/src/cli.ts @@ -1028,7 +1028,7 @@ function displayInput(input: string | null, config: VelarProjectConfig): string function displayPath(path: string): string { const value = relative(process.cwd(), path); - return value && !value.startsWith("..") ? value : path; + return (value && !value.startsWith("..") ? value : path).replaceAll("\\", "/"); } function printHelp(output: NodeJS.WritableStream = process.stdout): void { diff --git a/packages/cli/src/dev-server.ts b/packages/cli/src/dev-server.ts index cf6cb4c8..4f05c49c 100644 --- a/packages/cli/src/dev-server.ts +++ b/packages/cli/src/dev-server.ts @@ -2,6 +2,7 @@ import { createReadStream, readdirSync, statSync, watch } from "node:fs"; import { createServer, type ServerResponse } from "node:http"; import { posix, resolve } from "node:path"; import { pipeline } from "node:stream/promises"; +import { fileURLToPath } from "node:url"; import { formatDiagnostic } from "@velarscript/compiler"; import type { FrameworkHostArtifacts } from "@velarscript/compiler/framework-host"; import { compileProject, type ProjectResult } from "./project.ts"; @@ -432,7 +433,8 @@ function mapSourcePosition( } } if (lineIndex === generatedLine - 1 && selected) { - const source = map.sources[selected.source] ?? module.inputPath; + const mappedSource = map.sources[selected.source] ?? module.inputPath; + const source = mappedSource.startsWith("file:") ? fileURLToPath(mappedSource) : mappedSource; const path = relativePath(project.projectRoot, source); return { path, line: selected.line, column: selected.column }; } diff --git a/packages/cli/src/production-build.ts b/packages/cli/src/production-build.ts index b3c7ac92..635ddf00 100644 --- a/packages/cli/src/production-build.ts +++ b/packages/cli/src/production-build.ts @@ -1,7 +1,7 @@ import { createHash } from "node:crypto"; import { realpathSync } from "node:fs"; import { mkdir, readdir, writeFile } from "node:fs/promises"; -import { dirname, join, relative, resolve } from "node:path"; +import { dirname, isAbsolute, join, relative, resolve, win32 } from "node:path"; import { build, type Plugin } from "esbuild"; import { projectStyles } from "./framework-host.ts"; import { projectImportKey, type ProjectResult } from "./project.ts"; @@ -48,6 +48,14 @@ export interface ProductionModuleSummary { export const PRODUCTION_MANIFEST_NAME = "velar-build.json"; +export function isAbsoluteBrowserImportPath(specifier: string): boolean { + // esbuild reports entry points in the host path syntax. `path.isAbsolute` + // covers the running host; the explicit Windows check keeps the classifier + // testable on Unix and prevents a drive or UNC path ever becoming a package + // request when a build graph crosses a host boundary. + return isAbsolute(specifier) || win32.isAbsolute(specifier); +} + export interface ProductionBuildManifest { readonly formatVersion: 3; readonly kind: "velar-framework-build"; @@ -286,6 +294,7 @@ function velarModules(project: ProjectResult): Plugin { return targetModule ? { path: targetModule.inputPath } : null; }); context.onResolve({ filter: /^[^./]/ }, async (arguments_) => { + if (isAbsoluteBrowserImportPath(arguments_.path)) return null; if (arguments_.path.startsWith("velar/")) return null; // Package-internal `imports` aliases belong to the importing package's // manifest. esbuild already resolves them with browser/import diff --git a/packages/cli/src/program-runner.ts b/packages/cli/src/program-runner.ts index d658ef97..ffc8b731 100644 --- a/packages/cli/src/program-runner.ts +++ b/packages/cli/src/program-runner.ts @@ -58,7 +58,7 @@ export async function runProgram( const launcher = join(temporary, ".velar-run-entry.mjs"); await writeFile(launcher, uncaughtProgramEntrySource({ entryUrl: pathToFileURL(compiledTestModulePath(project, entry, temporary)).href, - sourcePath: entry.inputPath, + sourcePath: entry.inputPath.replaceAll("\\", "/"), fullStack: options.fullStack === true, }), "utf8"); return await executeNodeProgram(launcher, programArguments); diff --git a/packages/cli/src/project-task-bundle-entry.ts b/packages/cli/src/project-task-bundle-entry.ts index 8d192b9d..78aa7052 100644 --- a/packages/cli/src/project-task-bundle-entry.ts +++ b/packages/cli/src/project-task-bundle-entry.ts @@ -1,11 +1,20 @@ import { velarApplicationPackageHost as desktopApplicationPackageHost } from "@velarscript/desktop/package-host"; import { registerBundledApplicationPackageHost } from "./bundled-application-package-host-registry.ts"; import { installOfficialLanguageServerExtensions } from "./official-language-server-extensions.ts"; -import { projectTaskCliArguments } from "./project-task-invocation.ts"; +import { + projectTaskBrowserWorkerCliArguments, + projectTaskBrowserWorkerEnvironment, + projectTaskCliArguments, +} from "./project-task-invocation.ts"; registerBundledApplicationPackageHost(desktopApplicationPackageHost); -const cliArguments = projectTaskCliArguments(process.argv.slice(2)); +const cliArguments = process.env[projectTaskBrowserWorkerEnvironment] === undefined + ? projectTaskCliArguments(process.argv.slice(2)) + : projectTaskBrowserWorkerCliArguments( + process.argv.slice(2), + process.env[projectTaskBrowserWorkerEnvironment], + ); if (typeof cliArguments === "string") { process.stderr.write(`velar project task: ${cliArguments}\n`); process.exitCode = 2; diff --git a/packages/cli/src/project-task-invocation.ts b/packages/cli/src/project-task-invocation.ts index 6a89e2b8..4872d60b 100644 --- a/packages/cli/src/project-task-invocation.ts +++ b/packages/cli/src/project-task-invocation.ts @@ -1,8 +1,10 @@ -import { isAbsolute } from "node:path"; +import { tmpdir } from "node:os"; +import { basename, dirname, isAbsolute, relative } from "node:path"; export const projectTaskCommands = [ "check", "test", + "browserTest", "build", "fix", "package", @@ -11,6 +13,8 @@ export const projectTaskCommands = [ export type ProjectTaskCommand = typeof projectTaskCommands[number]; +export const projectTaskBrowserWorkerEnvironment = "VELAR_BROWSER_TEST_WORKER_V1"; + const supportedProjectTaskCommands = new Set(projectTaskCommands); const isProjectTaskCommand = (value: string | undefined): value is ProjectTaskCommand => typeof value === "string" && supportedProjectTaskCommands.has(value); @@ -31,5 +35,44 @@ export function projectTaskCliArguments(arguments_: readonly string[]): readonly return separator === undefined ? ["run", projectRoot] : ["run", projectRoot, "--", ...programArguments]; } if (separator !== undefined || programArguments.length > 0) return "invalid package-owned task invocation"; + if (command === "browserTest") return ["test", projectRoot, "--browser=all"]; return [command, projectRoot]; } + +/** + * The browser owner supervises its test body in a second invocation of the + * same immutable tool. Desktop strips this private marker from the initial + * task environment, so only the official supervisor can enter this path. + */ +export function projectTaskBrowserWorkerCliArguments( + arguments_: readonly string[], + serializedLimits: string | undefined, +): readonly string[] | string { + if (typeof serializedLimits !== "string" || serializedLimits.length < 2 || serializedLimits.length > 4096) { + return "invalid supervised browser-test limits"; + } + try { + const limits: unknown = JSON.parse(serializedLimits); + if (limits === null || typeof limits !== "object" || Array.isArray(limits)) { + return "invalid supervised browser-test limits"; + } + } catch { + return "invalid supervised browser-test limits"; + } + const [command, input, browser, ...rest] = arguments_; + if (command === "test" && typeof input === "string" && isAbsolute(input) + && /^--browser=(?:chromium|firefox|webkit|all)$/u.test(browser ?? "") && rest.length === 0) { + return arguments_; + } + const [buildCommand, projectRoot, outFlag, outputDirectory, ...buildRest] = arguments_; + const temporaryRoot = typeof outputDirectory === "string" ? dirname(outputDirectory) : ""; + const fromSystemTemporary = temporaryRoot === "" ? ".." : relative(tmpdir(), temporaryRoot); + if (buildCommand === "build" && typeof projectRoot === "string" && isAbsolute(projectRoot) + && outFlag === "--out-dir" && typeof outputDirectory === "string" && isAbsolute(outputDirectory) + && basename(outputDirectory) === "site" && basename(temporaryRoot).startsWith("velar-browser-tests-") + && fromSystemTemporary !== "" && fromSystemTemporary !== ".." && !fromSystemTemporary.startsWith("../") + && !isAbsolute(fromSystemTemporary) && buildRest.length === 0) { + return arguments_; + } + return "invalid supervised browser-test arguments"; +} diff --git a/packages/cli/src/project-task-tool.ts b/packages/cli/src/project-task-tool.ts index 8266938c..9a755fb4 100644 --- a/packages/cli/src/project-task-tool.ts +++ b/packages/cli/src/project-task-tool.ts @@ -1,5 +1,6 @@ -import { chmod, mkdir } from "node:fs/promises"; -import { dirname, resolve } from "node:path"; +import { chmod, copyFile, mkdir } from "node:fs/promises"; +import { createRequire } from "node:module"; +import { dirname, join, resolve } from "node:path"; import { fileURLToPath } from "node:url"; import { build } from "esbuild"; import { officialToolModulesPlugin } from "./official-tool-assets.ts"; @@ -7,9 +8,26 @@ import { copyPackagedOfficialTool } from "./packaged-official-tool.ts"; export const VELAR_PROJECT_TASK_TOOL_ID = "velar-project-task"; +async function copyPlaywrightMetadata(outputFile: string): Promise { + const require = createRequire(import.meta.url); + const playwrightCoreRoot = dirname(require.resolve("playwright-core/package.json")); + const destination = join(dirname(outputFile), "playwright-core"); + await mkdir(destination, { recursive: true }); + await Promise.all([ + copyFile(join(playwrightCoreRoot, "package.json"), join(destination, "package.json")), + copyFile(join(playwrightCoreRoot, "browsers.json"), join(destination, "browsers.json")), + ]); +} + export async function buildProjectTaskTool(outputFile: string): Promise { outputFile = resolve(outputFile); - if (await copyPackagedOfficialTool(outputFile, "host/project-task.js", 0o644)) return; + if (await copyPackagedOfficialTool(outputFile, "host/project-task.js", 0o644)) { + await Promise.all([ + copyPackagedOfficialTool(join(dirname(outputFile), "playwright-core", "package.json"), "host/playwright-core/package.json", 0o644), + copyPackagedOfficialTool(join(dirname(outputFile), "playwright-core", "browsers.json"), "host/playwright-core/browsers.json", 0o644), + ]); + return; + } const sourceExtension = import.meta.url.endsWith(".ts") ? "ts" : "js"; await mkdir(dirname(outputFile), { recursive: true }); await build({ @@ -24,16 +42,22 @@ export async function buildProjectTaskTool(outputFile: string): Promise { sourcemap: false, legalComments: "none", logLevel: "silent", - banner: { js: "import {createRequire as __velarCreateRequire} from 'node:module';const require=__velarCreateRequire(import.meta.url);" }, + banner: { js: "import {createRequire as __velarCreateRequire} from 'node:module';import {fileURLToPath as __velarFileURLToPath} from 'node:url';import {dirname as __velarDirname,join as __velarJoin} from 'node:path';const require=__velarCreateRequire(import.meta.url);const __filename=__velarFileURLToPath(import.meta.url);const __dirname=__velarJoin(__velarDirname(__filename),'playwright-core','lib');" }, plugins: [ { - name: "velar-project-task-boundary", + name: "velar-project-task-browser-boundary", setup(buildContext) { - buildContext.onResolve({ filter: /^\.\/browser-test-runner\.(?:ts|js)$/ }, (args) => ({ path: args.path, external: true })); + // Browser-test tasks use Playwright's public launchServer/connect + // surface. Its package also carries optional filesystem watching and + // Chromium BiDi branches that this finite task never invokes. Keep + // those native/dynamic edges outside the self-contained task bundle; + // an accidental call still fails closed at module resolution. + buildContext.onResolve({ filter: /^(?:fsevents|chromium-bidi\/)/ }, (args) => ({ path: args.path, external: true })); }, }, await officialToolModulesPlugin(), ], }); + await copyPlaywrightMetadata(outputFile); await chmod(outputFile, 0o644); } diff --git a/packages/cli/src/project.ts b/packages/cli/src/project.ts index 51aa35ee..5940ed39 100644 --- a/packages/cli/src/project.ts +++ b/packages/cli/src/project.ts @@ -1,5 +1,5 @@ import { findPackageJSON, isBuiltin } from "node:module"; -import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path"; +import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path"; import { readdir } from "node:fs/promises"; import { pathToFileURL } from "node:url"; import { @@ -635,7 +635,7 @@ async function nearestModuleName(targetPath: string): Promise { try { const entries = await readdir(dirname(targetPath), { withFileTypes: true }); const names = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".vel")).map((entry) => entry.name); - const wanted = targetPath.slice(targetPath.lastIndexOf("/") + 1); + const wanted = basename(targetPath); return nearestName(wanted, names); } catch { return null; diff --git a/packages/cli/src/test-output.ts b/packages/cli/src/test-output.ts index b9dd32b4..fee2e67b 100644 --- a/packages/cli/src/test-output.ts +++ b/packages/cli/src/test-output.ts @@ -1,5 +1,5 @@ import { mkdir, mkdtemp, rm, rmdir, writeFile } from "node:fs/promises"; -import { dirname, join, relative } from "node:path"; +import { basename, dirname, join, relative } from "node:path"; import type { ProjectModule, ProjectResult, VelarSourcePackage } from "./project.ts"; import { assertUniqueEmbeddedModuleOutputs, embeddedModuleFileContents, embeddedModuleOutputPath } from "./embedded-modules.ts"; @@ -25,6 +25,11 @@ export function quoteReportedText(value: string): string { ); } +/** Paths printed by VelarScript are a portable author-facing protocol. */ +export function portablePath(value: string): string { + return value.replaceAll("\\", "/"); +} + /** * Creates the sandbox directory that receives a compiled test or run tree. * @@ -64,7 +69,7 @@ export async function writeCompiledTestProject(project: ProjectResult, outputRoo for (const module of project.modules) { const output = compiledTestModulePath(project, module, outputRoot); await mkdir(dirname(output), { recursive: true }); - await writeFile(output, `${module.result.code ?? ""}//# sourceMappingURL=${output.split("/").at(-1)}.map\n`, "utf8"); + await writeFile(output, `${module.result.code ?? ""}//# sourceMappingURL=${basename(output)}.map\n`, "utf8"); await writeFile(`${output}.map`, module.result.sourceMap ?? "", "utf8"); for (const embedded of module.result.embeddedModules) { const embeddedPath = embeddedModuleOutputPath(output, embedded.specifier); diff --git a/packages/cli/src/test-runner.ts b/packages/cli/src/test-runner.ts index 95e7ba94..0eaa4a95 100644 --- a/packages/cli/src/test-runner.ts +++ b/packages/cli/src/test-runner.ts @@ -5,7 +5,7 @@ import { formatDiagnostic } from "@velarscript/compiler"; import type { VelarProjectConfig } from "./config.ts"; import { compileProject } from "./project.ts"; import { standardModuleSource, standardModuleSources } from "./standard-modules.ts"; -import { compiledTestModulePath, createCompiledSandbox, quoteReportedText, removeCompiledSandbox, writeCompiledTestProject } from "./test-output.ts"; +import { compiledTestModulePath, createCompiledSandbox, portablePath, quoteReportedText, removeCompiledSandbox, writeCompiledTestProject } from "./test-output.ts"; import { hostErrorStack } from "./host-error.ts"; import { captureUnownedErrors, flushOutput, mapCompiledStacksToSources } from "./unowned-errors.ts"; @@ -97,7 +97,7 @@ export async function runTests( ]; if (errors.length > 0) { failed += 1; - process.stderr.write(`✗ ${relative(config.root, file)}\n${errors.join("\n\n")}\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))}\n${errors.join("\n\n")}\n`); continue; } @@ -107,7 +107,7 @@ export async function runTests( const tests = entry?.result.moduleInterface.tests ?? []; if (tests.length === 0) { failed += 1; - process.stderr.write(`✗ ${relative(config.root, file)} declares no tests\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))} declares no tests\n`); continue; } const outputEntry = entry ? compiledTestModulePath(project, entry, temporary) : join(temporary, relative(config.root, file).replace(/\.vel$/u, ".js")); @@ -116,7 +116,7 @@ export async function runTests( namespace = await import(`${pathToFileURL(outputEntry).href}?run=${Date.now()}`) as Record; } catch (error) { failed += tests.length; - process.stderr.write(`✗ ${relative(config.root, file)} failed to load\n${stackOf(error)}\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))} failed to load\n${stackOf(error)}\n`); await drainUnowned(); continue; } @@ -126,7 +126,7 @@ export async function runTests( const loadTimeErrors = await drainUnowned(); if (loadTimeErrors.length > 0) { failed += tests.length; - process.stderr.write(`✗ ${relative(config.root, file)} reported an unowned error while loading\n${loadTimeErrors.join("\n")}\n`); + process.stderr.write(`✗ ${portablePath(relative(config.root, file))} reported an unowned error while loading\n${loadTimeErrors.join("\n")}\n`); continue; } for (const declared of tests) { @@ -146,11 +146,11 @@ export async function runTests( } if (leftover !== null) throw new Error(leftover); passed += 1; - process.stdout.write(`✓ ${quoteReportedText(relative(config.root, file))} :: ${name}\n`); + process.stdout.write(`✓ ${quoteReportedText(portablePath(relative(config.root, file)))} :: ${name}\n`); } catch (error) { failed += 1; await drainUnowned(); - process.stderr.write(`✗ ${quoteReportedText(relative(config.root, file))} :: ${name}\n${stackOf(error)}\n`); + process.stderr.write(`✗ ${quoteReportedText(portablePath(relative(config.root, file)))} :: ${name}\n${stackOf(error)}\n`); } } } diff --git a/packages/cli/src/uncaught-program-error.ts b/packages/cli/src/uncaught-program-error.ts index 3b5a1779..dcad3da3 100644 --- a/packages/cli/src/uncaught-program-error.ts +++ b/packages/cli/src/uncaught-program-error.ts @@ -34,6 +34,7 @@ const framePosition = /\\(?([^()]+):(\\d+):(\\d+)\\)?$/u; const launcherUrl = import.meta.url; const bounded = (value) => (value.length <= maximumTextLength ? value : \`\${value.slice(0, maximumTextLength)}…\`); +const portableFrame = (frame) => frame.replaceAll("\\\\", "/"); const describe = (error) => { if (error instanceof Error) { @@ -79,7 +80,7 @@ const present = (error) => { if (depth > 0) output.push("caused by:"); output.push(...trace.header); if (depth === 0 && trace.owned.length > 0) output.push(...codeFrame(trace.owned[0])); - output.push(...trace.owned); + output.push(...trace.owned.map(portableFrame)); if (trace.hidden > 0) { output.push(\` (\${trace.hidden} Node.js internal frame\${trace.hidden === 1 ? "" : "s"} hidden; rerun with 'velar run --stack' for the full trace)\`); } diff --git a/packages/compiler/src/ast.ts b/packages/compiler/src/ast.ts index 037c40f5..edbad9ca 100644 --- a/packages/compiler/src/ast.ts +++ b/packages/compiler/src/ast.ts @@ -36,6 +36,60 @@ export type CoreStatement = export type Statement = CoreStatement | ExtensionStatement; +/** + * D56 rule 129 — every statement form Core's grammar produces, keyed by the + * node kind the parser returns for it. The string is prose for a failure + * message; the *keys* are the data. + * + * The mapped type is both the derivation and the enforcement: a member added + * to `CoreStatement` above makes this object stop typechecking until its + * spelling is written here, so the roster cannot fall behind the union the + * parser returns. That is the whole reason it lives beside the union instead + * of in a gate script — D57 rule 134's failure family is the hand-kept copy, + * and a copy that `tsc` refuses to accept as incomplete is not one. + * + * The tour-coverage gate requires every key to be parsed out of + * `examples/tour/`, and this is the one category of that gate that names a + * *construct* rather than a *name*. It exists because names were not enough: + * `extern`, `js`, and `unsafe` were already covered as keywords by chapter 13's + * `extern module` and `import js unsafe`, so D53 rule 117's two inline blocks — + * spelled entirely out of keywords the tour already exercised — landed with no + * tour example at all and the gate stayed green. + * + * One key can still cover more than one spelling: `extern js(…)` and + * `unsafe js` are one node kind distinguished by a boolean, and no + * compiler-owned table enumerates *that* split. The gate prints that limit on + * every run rather than implying a completeness it does not have. + */ +export const CORE_STATEMENT_CONSTRUCTS = Object.freeze({ + ImportDeclaration: 'import {name} from "./module.vel"', + ReExportDeclaration: 'export {name} from "./module.vel"', + ExternModuleDeclaration: 'extern module "node:crypto":', + EmbeddedJavaScriptDeclaration: "extern js(capture: T)`…`: — or unsafe js`…`", + TypeDeclaration: "type Name:", + TypeAliasDeclaration: "type Name = string", + EnumDeclaration: "enum Name:", + ClassDeclaration: "class Name:", + VariableDeclaration: "const name = value", + UsingDeclaration: "using name = open(path)", + TestDeclaration: 'test "a name":', + FunctionDeclaration: "def name() -> T:", + ReturnStatement: "return value", + ThrowStatement: "throw error", + AssertStatement: "assert condition", + IfStatement: "if condition:", + MatchStatement: "match value:", + ForStatement: "for item in values:", + WhileStatement: "while condition:", + BreakStatement: "break", + ContinueStatement: "continue", + TryStatement: "try:", + PassStatement: "pass", + AssignmentStatement: "name = value", + ExpressionStatement: "call()", + AsyncStatement: "async call()", +} satisfies { readonly [Kind in CoreStatement["kind"]]: string }); + /** * Target and framework syntax travels through one opaque Core AST slot. The * template-literal discriminator keeps extension nodes disjoint from Core @@ -868,6 +922,53 @@ export interface IndexExpression { readonly span: Span; } +/** Anything the AST puts a `kind` on: a node, a pattern, an f-string part. */ +export interface AstNode { + readonly kind: string; +} + +/** + * Every node under `root`, in source order, whatever shape it has. + * + * The walk is structural: it descends through arrays and objects without + * asking what they are, so it reaches a container the day the parser produces + * one — a new class member, a new statement form, an extension node this + * package has never heard of — with nothing here to update. Only nodes are + * reported, but the descent is unconditional, so an expression parked on a + * shape that carries no `kind` of its own (a `Parameter`, a `MatchCase`) is + * still reached through it. + * + * A pass that must not *miss* something walks with this instead of writing a + * second switch over the node kinds it happens to remember. A-010: dependency + * discovery kept such a switch, and `try`, `using`, `test "…":`, class + * getters, `@dispose:` and `@iterate:` were all outside the module graph — + * `@iterate:` from the day D68 added it, because a hand-kept copy of the AST + * starts drifting the moment the AST grows. That copy compiled, exited 0, and + * turned a module that exists and loads into `null`. + */ +export function* astNodes(root: unknown): Generator { + const pending: unknown[] = [root]; + const seen = new Set(); + while (pending.length > 0) { + const value = pending.pop(); + if (typeof value !== "object" || value === null) continue; + if (seen.has(value)) continue; + seen.add(value); + if (Array.isArray(value)) { + for (let index = value.length - 1; index >= 0; index -= 1) pending.push(value[index]); + continue; + } + if (typeof (value as { kind?: unknown }).kind === "string") yield value as AstNode; + const children = Object.values(value); + for (let index = children.length - 1; index >= 0; index -= 1) pending.push(children[index]); + } +} + +/** `astNodes` narrowed to one node kind, so a caller keeps the node's type. */ +export function* astNodesOfKind(root: unknown, kind: Node["kind"]): Generator { + for (const node of astNodes(root)) if (node.kind === kind) yield node as Node; +} + /** * Whether a block awaits in its own frame. A nested function or arrow owns its * awaits, so the walk stops at every declaration boundary. D43 item 69 uses diff --git a/packages/compiler/src/diagnostic.ts b/packages/compiler/src/diagnostic.ts index c8c168e4..ff45ca8e 100644 --- a/packages/compiler/src/diagnostic.ts +++ b/packages/compiler/src/diagnostic.ts @@ -71,7 +71,7 @@ export function formatDiagnostic(source: SourceText, item: Diagnostic): string { const marker = `${" ".repeat(displayColumn - 1)}${"^".repeat(markerLength)}`; return [ - `${source.path}:${location.line}:${location.column} error ${item.code}: ${item.message}`, + `${source.path.replaceAll("\\", "/")}:${location.line}:${location.column} error ${item.code}: ${item.message}`, line, marker, ].join("\n"); diff --git a/packages/compiler/src/emitter.ts b/packages/compiler/src/emitter.ts index 826e2e7f..fdb0afb9 100644 --- a/packages/compiler/src/emitter.ts +++ b/packages/compiler/src/emitter.ts @@ -2960,7 +2960,13 @@ function sourceMapFor(code: string, generatedMappings: readonly GeneratedMapping }).join(";"); return JSON.stringify({ version: 3, - sources: [source.path], + // Source-map sources are URLs, not host path strings. A Windows drive path + // starts with what URL parsers treat as a scheme (`C:`), so Node cannot + // map the generated frame back to VelarScript unless the drive path is a + // real file URL. POSIX and project-relative paths keep their existing form. + sources: [/^[A-Za-z]:[\\/]/u.test(source.path) + ? `file:///${source.path.replaceAll("\\", "/")}` + : source.path.replaceAll("\\", "/")], sourcesContent: [source.text], names: [], mappings, diff --git a/packages/compiler/src/extension.ts b/packages/compiler/src/extension.ts index 41078cf5..0fefdee4 100644 --- a/packages/compiler/src/extension.ts +++ b/packages/compiler/src/extension.ts @@ -302,12 +302,6 @@ export interface CompilerFormattingOpaqueSourceScan { readonly attachedToPrevious: boolean; } -export interface CompilerDependencyContext { - readonly visitExpression: (expression: Expression) => void; - readonly visitStatement: (statement: Statement) => void; - readonly visitBlock: (body: readonly Statement[]) => void; -} - export interface CompilerInterfaceContext { readonly exports: Map; readonly reactiveExports: Map; @@ -319,8 +313,11 @@ export interface CompilerInterfaceContext { } export interface CompilerInspectionExtension { - readonly visitDependencyExpression?: (expression: Expression, context: CompilerDependencyContext) => boolean; - readonly visitDependencyStatement?: (statement: Statement, context: CompilerDependencyContext) => boolean; + // An extension does not describe how to walk into its own nodes for + // dependency discovery: that walk is structural (`astNodes`), so an + // extension node holds a dynamic import the day it parses. A-010 is what + // the hooks that used to live here cost — a per-package hand-kept copy of + // the AST, one per extension, each free to drift on its own. readonly contributeInterface?: (statement: Statement, context: CompilerInterfaceContext) => boolean; /** * Whole-program annotations for exported names, merged into the module @@ -397,11 +394,35 @@ export interface ModuleInterface { readonly extensionData: ReadonlyMap; } +/** + * D56 rule 129 — the statement forms this extension's parser can produce. + * + * Core publishes its own roster as `CORE_STATEMENT_CONSTRUCTS`, derived from + * the `CoreStatement` union by a mapped type; an extension's statements never + * enter that union, so an extension that owns syntax has to hand its roster + * across. Without this slot the tour-coverage gate could only require *names* — + * keywords, exports, properties — and a construct spelled out of keywords the + * tour already covers is invisible to a name-by-name check. Registering a + * `parser` without a `syntax` is therefore a gate failure, not a default. + */ +export interface CompilerSyntaxExtension { + /** Construct key → the source spelling a reader would write, for failures. */ + readonly statementConstructs: Readonly>; + /** + * The construct key of one parsed node, or null when this extension does not + * own it. A key may refine the node kind — the Web extension's `unsafe css` + * splits on the tagged union its `source` field already carries — so the + * roster above is keyed by what this returns, not by node kind. + */ + statementConstructKey(node: { readonly kind: string }): string | null; +} + export interface CompilerExtension { readonly id: string; readonly contract?: VelarExtensionContract; readonly capabilities?: readonly string[]; readonly lexical?: CompilerLexicalExtension; + readonly syntax?: CompilerSyntaxExtension; readonly analysis?: CompilerAnalysisExtension; readonly modules?: CompilerModuleExtension; readonly editor?: CompilerEditorExtension; diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index 599d91f5..19f6abb9 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -1,6 +1,6 @@ import { Analyzer, inferredResultPlaceholderType, isCorePrimitiveName, type AnalysisContext, type ClassField, type ClassInfo, type InitializationImportRead } from "./analyzer.ts"; -import { blockContainsDirectAwait, testFunctionName } from "./ast.ts"; -import type { BindingPattern, Expression, FunctionDeclaration, MatchPattern, Program, Statement, TypeReference } from "./ast.ts"; +import { astNodesOfKind, blockContainsDirectAwait, testFunctionName } from "./ast.ts"; +import type { BindingPattern, DynamicImportExpression, Expression, FunctionDeclaration, Program, Statement, TypeReference } from "./ast.ts"; import { diagnostic, type Diagnostic } from "./diagnostic.ts"; import { JavaScriptEmitter } from "./emitter.ts"; import { programWithEmbeddedJavaScriptImports } from "./embedded-module.ts"; @@ -43,7 +43,7 @@ export { VELAR_EXTENSION_PROTOCOL_VERSION } from "./extension.ts"; // D62 rule 157: the editor's keyword list is the lexer's table plus Core's // contextual roster, so it is published rather than retyped downstream. export { keywordKinds } from "./token.ts"; -export type { CompilerAnalysisExtension, CompilerAnalyzerFactory, CompilerDependencyContext, CompilerEditorCompletion, CompilerEditorExtension, CompilerEmbeddedJavaScriptModule, CompilerEmitter, CompilerEmitterOptions, CompilerExtension, CompilerFormattingExtension, CompilerInspectionExtension, CompilerInterfaceContext, CompilerIntrinsicAnalysisContext, CompilerLexicalExtension, CompilerLexicalScanContext, CompilerLexicalScanResult, CompilerModuleExtension, CompilerParserFactory, CompilerProjectEditorCompletion, CompilerProjectEditorCompletionContext, CompilerProjectEditorCompletionResult, CompilerProjectEditorExtension, CompilerProjectEditorRenameContext, CompilerResourceDependency, CompilerStyleSegments, ModuleInterface, ModuleTest, VelarExtensionContract, VelarExtensionKind } from "./extension.ts"; +export type { CompilerAnalysisExtension, CompilerAnalyzerFactory, CompilerEditorCompletion, CompilerEditorExtension, CompilerEmbeddedJavaScriptModule, CompilerEmitter, CompilerEmitterOptions, CompilerExtension, CompilerFormattingExtension, CompilerInspectionExtension, CompilerInterfaceContext, CompilerIntrinsicAnalysisContext, CompilerLexicalExtension, CompilerLexicalScanContext, CompilerLexicalScanResult, CompilerModuleExtension, CompilerParserFactory, CompilerProjectEditorCompletion, CompilerProjectEditorCompletionContext, CompilerProjectEditorCompletionResult, CompilerProjectEditorExtension, CompilerProjectEditorRenameContext, CompilerResourceDependency, CompilerStyleSegments, ModuleInterface, ModuleTest, VelarExtensionContract, VelarExtensionKind } from "./extension.ts"; export { semanticImportAt, semanticModuleReferenceAt, semanticSymbolAt, semanticVisibleSymbolsAt, type CompilerSemanticExtension, type SemanticDeclareOptions, type SemanticExpression, type SemanticExtensionContext, type SemanticFunctionLike, type SemanticImport, type SemanticIndex, type SemanticMember, type SemanticMemberReference, type SemanticModuleReference, type SemanticReference, type SemanticScope, type SemanticSymbol, type SemanticSymbolKind } from "./semantic.ts"; export { analysisTypeIdentity, describeType, genericApplicationType, isReadonlyView, optionalOf, readonlyViewOf, semanticTypeIdentity, unionOf, type EnumInfo, type GenericApplication, type GenericTypeInfo, type ValueType } from "./types.ts"; export { permanentNamespaceCoveringModule } from "./analyzer.ts"; @@ -129,7 +129,7 @@ export function inspectModule(text: string, options: Pick extension.semantic ? [extension.semantic] : [])), @@ -246,7 +246,7 @@ function compileUnchecked(text: string, options: CompileOptions): CompileResult extensions: extensions.map((extension) => extension.id), diagnostics, source: parsed.source, - dependencies: dependenciesOf(parsed.program, extensions), + dependencies: dependenciesOf(parsed.program), resources: resourcesOf(parsed.program, extensions), moduleInterface: interfaceOf( semanticProgram, @@ -413,7 +413,8 @@ function normalizedExtensions(extensions: readonly CompilerExtension[]): readonl return extensions; } -function dependenciesOf(program: Program, extensions: readonly CompilerExtension[]): readonly ModuleDependency[] { +// No extension list: dependency discovery asks the AST and nothing else. +function dependenciesOf(program: Program): readonly ModuleDependency[] { const externSources = new Set(program.body .filter((statement) => statement.kind === "ExternModuleDeclaration") .map((statement) => statement.source)); @@ -447,119 +448,27 @@ function dependenciesOf(program: Program, extensions: readonly CompilerExtension }); } + // Dynamic imports are found by walking the AST structurally rather than by + // a second switch over the statement and expression kinds this function + // remembers. A-010: that switch existed, and it had no case for `try`, + // `using`, or `test "…":`, and descended into a class only through its + // fields, `constructor:` and methods — so a `import("./dep.vel")` in a + // getter, a `@dispose:`, or a `@iterate:` left the module out of the graph + // while `check` reported success. `@iterate:` was missing from the day D68 + // added it: a hand-kept copy of the AST drifts the moment the AST grows, + // and every future container would have drifted the same way. const dynamicSources = new Set(); - const dependencyExtensions = extensions.flatMap((extension) => extension.inspection ? [extension.inspection] : []); - const dependencyContext = { - visitExpression: (expression: Expression) => visitExpression(expression), - visitStatement: (statement: Statement) => visitStatement(statement), - visitBlock: (body: readonly Statement[]) => visitBlock(body), - }; - const visitExpression = (expression: Expression): void => { - for (const extension of dependencyExtensions) if (extension.visitDependencyExpression?.(expression, dependencyContext)) return; - switch (expression.kind) { - case "DynamicImportExpression": - if (!dynamicSources.has(expression.source)) { - dynamicSources.add(expression.source); - dependencies.push({ - source: expression.source, - javascript: false, - unsafe: false, - dynamic: true, - specifiers: [], - }); - } - break; - case "FStringExpression": - for (const part of expression.parts) if (part.kind === "expression") visitExpression(part.value); - break; - case "ListExpression": - for (const element of expression.elements) visitExpression(element); - break; - case "ObjectExpression": - for (const property of expression.properties) visitExpression(property.value); - break; - case "SpreadExpression": visitExpression(expression.value); break; - case "UnaryExpression": visitExpression(expression.operand); break; - case "BinaryExpression": visitExpression(expression.left); visitExpression(expression.right); break; - case "AssignmentExpression": visitExpression(expression.target); visitExpression(expression.value); break; - case "ComparisonChainExpression": for (const operand of expression.operands) visitExpression(operand); break; - case "ConditionalExpression": visitExpression(expression.condition); visitExpression(expression.thenValue); visitExpression(expression.elseValue); break; - case "IsExpression": visitExpression(expression.value); break; - case "ArrowFunctionExpression": - for (const parameter of expression.parameters) if (parameter.defaultValue) visitExpression(parameter.defaultValue); - visitExpression(expression.body); - break; - case "CallExpression": visitExpression(expression.callee); for (const argument of expression.arguments) visitExpression(argument); break; - case "MemberExpression": visitExpression(expression.object); break; - case "IndexExpression": visitExpression(expression.object); visitExpression(expression.index); break; - case "LiteralExpression": - case "IdentifierExpression": - case "SuperExpression": - break; - } - }; - const visitBlock = (body: readonly Statement[]): void => { for (const statement of body) visitStatement(statement); }; - const visitMatchPattern = (pattern: MatchPattern): void => { - switch (pattern.kind) { - case "MatchValuePattern": for (const value of pattern.values) visitExpression(value); break; - case "MatchAsPattern": visitMatchPattern(pattern.pattern); break; - case "MatchObjectPattern": for (const entry of pattern.entries) visitMatchPattern(entry.pattern); break; - case "MatchListPattern": for (const element of pattern.elements) visitMatchPattern(element); break; - case "MatchTypePattern": - case "MatchWildcardPattern": - case "MatchCapturePattern": - break; - } - }; - const visitStatement = (statement: Statement): void => { - for (const extension of dependencyExtensions) if (extension.visitDependencyStatement?.(statement, dependencyContext)) return; - switch (statement.kind) { - case "ClassDeclaration": - if (statement.base) for (const argument of statement.base.arguments) visitExpression(argument); - for (const parameter of statement.parameters) if (parameter.defaultValue) visitExpression(parameter.defaultValue); - for (const field of statement.fields) if (field.initializer) visitExpression(field.initializer); - if (statement.initialization) visitBlock(statement.initialization.body); - for (const method of statement.methods) { - for (const parameter of method.parameters) if (parameter.defaultValue) visitExpression(parameter.defaultValue); - visitBlock(method.body); - } - break; - case "VariableDeclaration": visitExpression(statement.initializer); break; - case "FunctionDeclaration": - for (const parameter of statement.parameters) if (parameter.defaultValue) visitExpression(parameter.defaultValue); - visitBlock(statement.body); - break; - case "ReturnStatement": if (statement.value) visitExpression(statement.value); break; - case "ThrowStatement": visitExpression(statement.value); break; - case "AssertStatement": visitExpression(statement.condition); if (statement.message) visitExpression(statement.message); break; - case "IfStatement": visitExpression(statement.condition); visitBlock(statement.thenBody); if (statement.elseBody) visitBlock(statement.elseBody); break; - case "MatchStatement": - visitExpression(statement.value); - for (const branch of statement.cases) { - visitMatchPattern(branch.pattern); - if (branch.guard) visitExpression(branch.guard); - visitBlock(branch.body); - } - break; - case "ForStatement": visitExpression(statement.iterable); visitBlock(statement.body); break; - case "WhileStatement": visitExpression(statement.condition); visitBlock(statement.body); break; - case "TryStatement": visitBlock(statement.tryBody); if (statement.catchBody) visitBlock(statement.catchBody); if (statement.finallyBody) visitBlock(statement.finallyBody); break; - case "AssignmentStatement": visitExpression(statement.target); visitExpression(statement.value); break; - case "ExpressionStatement": visitExpression(statement.expression); break; - case "AsyncStatement": visitExpression(statement.expression); break; - case "ImportDeclaration": - case "ReExportDeclaration": - case "ExternModuleDeclaration": - case "TypeDeclaration": - case "TypeAliasDeclaration": - case "EnumDeclaration": - case "BreakStatement": - case "ContinueStatement": - case "PassStatement": - break; - } - }; - visitBlock(program.body); + for (const expression of astNodesOfKind(program, "DynamicImportExpression")) { + if (dynamicSources.has(expression.source)) continue; + dynamicSources.add(expression.source); + dependencies.push({ + source: expression.source, + javascript: false, + unsafe: false, + dynamic: true, + specifiers: [], + }); + } return dependencies; } diff --git a/packages/desktop/README.md b/packages/desktop/README.md index 9d7c2a38..ecb0ca29 100644 --- a/packages/desktop/README.md +++ b/packages/desktop/README.md @@ -60,11 +60,15 @@ of hiding them from the application size budget. server, the bounded project-task launcher, the platform build engine, and the native PTY helper. They are stored under `Contents/Resources/host` and counted separately as language, -task, build-engine, and terminal-host bytes. The generated tools contain the official +task, build-engine, terminal-host, and capability-Worker bytes. The generated tools contain the official Core/Web/Desktop compiler extensions and source-backed standard assets, so the installed application neither searches `PATH` for `velar`, resolves project npm packages, nor depends on the build workspace. The default Desktop size budget -is 20 MiB; every tool remains inside that budget and the application tree hash. +is currently 32 MiB. It is an accounting threshold rather than an architecture +ceiling: a project may set `desktop.build.sizeBudgetBytes` to a larger measured +value when the bundle composition explains the growth. The package command +still reports every component and the application tree hash; size pressure must +not split a privileged owner across the renderer boundary. Desktop owns `velar/desktop` and permission-scoped target implementations of `velar/fs`, `velar/path`, `velar/process`, `velar/http`, and `velar/env`. @@ -77,11 +81,36 @@ document-generation retirement, project-grant replacement, Worker failure, or host shutdown reaps the corresponding process group. This exact official tool does not require a general process permission and cannot launch an arbitrary command. +Applications with the `project` file grant may also call +`projectChanges() -> Promise`. Desktop binds the returned owner +to the same durable `@velaros-ai/project` kernel that prepares and validates +transactions. The public surface is intentionally finite: `list(limit)`, +`get(transactionId)`, pull-based `subscribe()`, `apply(transactionId)`, +`rollback(transactionId)`, and idempotent `close()`. It exposes reviewable +intent, patch, diff, risk, revision, lifecycle, and timestamp projections, but +never the project root, persistence paths, policies, providers, old/new full +file contents, arbitrary metadata, or a caller-selected file operation. +Transactions and their latest projections are committed under the app-data +root before project mutation; a restarted Worker restores an interrupted +apply/rollback to its prior durable state and fails closed if an external edit +conflicts with that recovery. The JSONL change feed is fsynced before +subscribers observe a row. Subscriptions coalesce the latest record per +transaction and request a full `list()` rescan on bounded queue overflow. +Changing the project grant retires existing handles; an already-running +apply/rollback finishes against the original durable owner before that owner is +closed. The complete owner is bundled into the existing Node capability Worker +and adds about 4.39 MiB; there is still no Electron-style user main process, +second source graph, local server, port, or renderer-accessible IPC design. + Applications with the `project` file grant may also call `startProjectTask(ProjectTaskCommand, arguments, options)`. The finite command -set is `check`, `test`, `build`, `fix`, `package`, and `run`; only `run` -accepts program arguments. Browser testing is not a project-task flag: it -requires a separately owned browser host and is intentionally absent here. +set is `check`, `test`, `browserTest`, `build`, `fix`, `package`, and `run`; +only `run` accepts program arguments. `browserTest` always runs all three +engines through the packaged official browser-test supervisor and cannot +accept a browser, output-directory, or CLI-flag override. The Playwright driver +is counted in the application bundle; matching Chromium, Firefox, and WebKit +binaries remain an explicit external Playwright cache and a missing engine +fails the task instead of silently reducing coverage. The returned `ProjectTask` exposes its package-owned PID plus pull-based `next()`, terminal `wait()`, and bounded `stop()` operations. Desktop fixes the working directory to the current canonical project grant, injects only its @@ -206,12 +235,13 @@ velar test . --browser=all ``` `velar test --browser` runs `.browser.test.vel` files without opening a window. -It installs a deterministic, permission-aware in-memory Desktop filesystem and -deterministic handles for manifest-granted processes; the native worker keeps -a separate integration suite for real filesystem, process, and network -enforcement. Test modules may import the restricted `velar/desktop-test` -helpers to inspect app-data/project text, seed or remove an external edit or -recovery journal, and create a bounded test directory through the page's actual +It installs a deterministic, permission-aware in-memory Desktop filesystem, +finite ProjectChanges owner, and deterministic handles for manifest-granted +processes; the native worker keeps a separate integration suite for real +filesystem, process, network, and durable transaction enforcement. Test +modules may import the restricted `velar/desktop-test` helpers to inspect +app-data/project text, create a bounded test directory, and call +`seedProjectChange(transactionId, lifecycle, diff)` through the page's actual capability bridge; ordinary `velar/fs` remains application-side and is not faked in the test controller process. diff --git a/packages/desktop/native/node/project-transactions.js b/packages/desktop/native/node/project-transactions.js new file mode 100644 index 00000000..bc3a3115 --- /dev/null +++ b/packages/desktop/native/node/project-transactions.js @@ -0,0 +1,157 @@ +import { createHash } from "node:crypto"; +import { mkdir } from "node:fs/promises"; +import { resolve } from "node:path"; + +import { FileProjectChangeFeed } from "@velaros-ai/project/changes"; +import { createProjectKernel } from "@velaros-ai/project/runtime"; +import { createProjectTransactionController } from "@velaros-ai/project/transaction-controller"; + +const MAX_PROJECT_CHANGE_RECORD_BYTES = 16 * 1024 * 1024; +const MAX_PROJECT_CHANGE_PAGE_BYTES = 32 * 1024 * 1024; +const MAX_PROJECT_CHANGE_ITEMS = 1_000; +const projectChangeLifecycles = new Set([ + "prepared", + "amended", + "validated", + "validation_failed", + "applied", + "rolled_back", + "discarded", +]); +const riskLevels = new Set(["low", "medium", "high"]); + +function record(value, label) { + if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`); + return value; +} + +function text(value, label, maximumBytes, allowEmpty = false) { + if (typeof value !== "string" || (!allowEmpty && value.length === 0) || value.includes("\0") || Buffer.byteLength(value, "utf8") > maximumBytes) { + throw new TypeError(`${label} must be bounded text`); + } + return value; +} + +function optionalText(value, label, maximumBytes) { + return value === undefined ? null : text(value, label, maximumBytes); +} + +function safeInteger(value, label, minimum = 0) { + if (!Number.isSafeInteger(value) || value < minimum) throw new TypeError(`${label} must be a safe integer`); + return value; +} + +function list(value, label) { + if (!Array.isArray(value) || value.length > MAX_PROJECT_CHANGE_ITEMS) throw new TypeError(`${label} must be a bounded list`); + return value; +} + +function intentView(value) { + value = record(value, "Project change intent"); + const operation = record(value.operation, "Project change operation"); + return Object.freeze({ + type: text(operation.type, "Project change operation type", 128), + path: optionalText(operation.path, "Project change operation path", 4096), + from: optionalText(operation.from, "Project change operation source path", 4096), + to: optionalText(operation.to, "Project change operation target path", 4096), + targetId: optionalText(value.targetId, "Project change target id", 512), + reason: optionalText(value.reason, "Project change intent reason", 64 * 1024), + }); +} + +function patchView(value) { + value = record(value, "Project change patch"); + if (!riskLevels.has(value.risk)) throw new TypeError("Project change patch risk is invalid"); + return Object.freeze({ + patchId: text(value.patchId, "Project change patch id", 512), + strategyId: text(value.strategyId, "Project change strategy id", 512), + path: text(value.path, "Project change patch path", 4096), + baseRevision: optionalText(value.baseRevision, "Project change patch base revision", 512), + diff: text(value.diff, "Project change patch diff", MAX_PROJECT_CHANGE_RECORD_BYTES, true), + changedLines: safeInteger(value.changedLines, "Project change patch changed lines"), + risk: value.risk, + operation: optionalText(value.operation, "Project change patch operation", 128), + }); +} + +function revisionView(value) { + value = record(value, "Project change revision"); + return Object.freeze({ + path: text(value.path, "Project change revision path", 4096), + before: optionalText(value.before, "Project change prior revision", 512), + after: optionalText(value.after, "Project change next revision", 512), + }); +} + +export function desktopProjectChangeView(value) { + value = record(value, "Project change"); + if (!projectChangeLifecycles.has(value.lifecycle)) throw new TypeError("Project change lifecycle is invalid"); + if (!riskLevels.has(value.risk)) throw new TypeError("Project change risk is invalid"); + const output = Object.freeze({ + transactionId: text(value.transactionId, "Project change transaction id", 512), + sequence: safeInteger(value.sequence, "Project change sequence", 1), + lifecycle: value.lifecycle, + reason: optionalText(value.reason, "Project change reason", 64 * 1024), + intents: Object.freeze(list(value.intents, "Project change intents").map(intentView)), + patches: Object.freeze(list(value.patches, "Project change patches").map(patchView)), + changedFiles: Object.freeze(list(value.changedFiles, "Project change files") + .map((path) => text(path, "Project change file path", 4096))), + diff: text(value.diff, "Project change diff", MAX_PROJECT_CHANGE_RECORD_BYTES, true), + changedLines: safeInteger(value.changedLines, "Project change changed lines"), + risk: value.risk, + revisions: Object.freeze(list(value.revisions, "Project change revisions").map(revisionView)), + createdAt: safeInteger(value.createdAt, "Project change creation time"), + updatedAt: safeInteger(value.updatedAt, "Project change update time"), + appliedAt: value.appliedAt === undefined ? null : safeInteger(value.appliedAt, "Project change apply time"), + }); + if (Buffer.byteLength(JSON.stringify(output), "utf8") > MAX_PROJECT_CHANGE_RECORD_BYTES) { + throw new RangeError("Project change record exceeds 16 MiB"); + } + return output; +} + +export function desktopProjectChangePage(values, requestedLimit) { + const limit = safeInteger(requestedLimit, "Project change page limit", 1); + if (limit > 100) throw new RangeError("Project change page limit cannot exceed 100"); + const changes = []; + let bytes = 0; + let truncated = false; + for (const value of values) { + if (changes.length >= limit) { truncated = true; break; } + const change = desktopProjectChangeView(value); + const changeBytes = Buffer.byteLength(JSON.stringify(change), "utf8"); + if (bytes + changeBytes > MAX_PROJECT_CHANGE_PAGE_BYTES) { truncated = true; break; } + changes.push(change); + bytes += changeBytes; + } + return Object.freeze({ changes: Object.freeze(changes), truncated }); +} + +/** + * One host-private owner per canonical project root. The renderer never sees + * the root-derived key, state path, feed path, policy or underlying kernel. + */ +export async function createDesktopProjectTransactionOwner(projectRoot, appDataRoot) { + const key = createHash("sha256").update(projectRoot).digest("hex"); + const directory = resolve(appDataRoot, "project-transactions", key); + await mkdir(directory, { recursive: true, mode: 0o700 }); + const feed = new FileProjectChangeFeed({ path: resolve(directory, "changes.jsonl") }); + try { + const project = await createProjectKernel({ + root: projectRoot, + changeFeed: feed, + transactionStatePath: resolve(directory, "transactions.json"), + // Desktop's project grant is the outer write authority. The finite + // apply/rollback call is already explicit and cannot choose an operation. + corePolicy: { approval: { requireForHighRiskPatch: false } }, + }); + return { + root: projectRoot, + controller: createProjectTransactionController(project), + close() { feed.close(); }, + }; + } catch (error) { + feed.close(); + throw error; + } +} diff --git a/packages/desktop/native/node/worker.js b/packages/desktop/native/node/worker.js index b7399bd6..9b9b7584 100644 --- a/packages/desktop/native/node/worker.js +++ b/packages/desktop/native/node/worker.js @@ -4,6 +4,11 @@ import { createInterface } from "node:readline"; import { basename, dirname, isAbsolute, relative, resolve } from "node:path"; import { spawn } from "node:child_process"; import { StringDecoder } from "node:string_decoder"; +import { + createDesktopProjectTransactionOwner, + desktopProjectChangePage, + desktopProjectChangeView, +} from "./project-transactions.js"; const MAX_MESSAGE_BYTES = 128 * 1024 * 1024; const MAX_FILE_BYTES = 16 * 1024 * 1024; @@ -19,6 +24,9 @@ const MAX_LANGUAGE_SERVER_MESSAGE_BYTES = 16 * 1024 * 1024; const MAX_LANGUAGE_SERVER_QUEUED_BYTES = 64 * 1024 * 1024; const MAX_LANGUAGE_SERVERS = 4; const MAX_PROJECT_TASKS = 4; +const MAX_PROJECT_CHANGE_HANDLES = 16; +const MAX_PROJECT_CHANGE_QUEUE_ITEMS = 100; +const MAX_PROJECT_CHANGE_QUEUE_BYTES = 16 * 1024 * 1024; const MAX_TERMINALS = 4; const MAX_TERMINAL_CHUNK_BYTES = 1024 * 1024; const MAX_TERMINAL_QUEUED_BYTES = 4 * 1024 * 1024; @@ -52,6 +60,8 @@ const fileWatchers = new Map(); let nextFileWatcherHandle = 1; const languageServers = new Map(); let nextLanguageServerHandle = 1_000_000_000; +const projectChangeHandles = new Map(); +let nextProjectChangeHandle = 3_000_000_000; const terminals = new Map(); let nextTerminalHandle = 2_000_000_000; let nextTextReplacementIdentity = 1; @@ -64,6 +74,9 @@ let appDataLexicalRoot = null; let projectRoot = null; let projectLexicalRoot = null; let projectRootUpdate = Promise.resolve(); +let projectTransactionOwner = null; +let projectTransactionOwnerPending = null; +let projectTransactionGeneration = 0; let languageServerPath = null; let projectTaskPath = null; let buildEnginePath = null; @@ -145,6 +158,7 @@ rebuildFileRoots(); const reader = createInterface({ input: process.stdin, crlfDelay: Infinity, terminal: false }); reader.once("close", () => { if (activeOwner !== null) retireOwner(activeOwner); + retireProjectTransactionOwner(new Error("Desktop capability host closed")); for (const task of fileWatchers.values()) releaseFileWatcher(task, new Error("Desktop capability host closed")); for (const task of languageServers.values()) releaseLanguageServer(task, new Error("Desktop capability host closed")); for (const task of terminals.values()) releaseTerminal(task, new Error("Desktop capability host closed")); @@ -228,6 +242,11 @@ function cancelActivity(activity) { try { activity.cancel?.(); } catch {} } +function setActivityCancellation(activity, cancel) { + activity.cancel = cancel; + if (activity.cancelled) cancel(); +} + function validOwner(value) { return typeof value === "string" && /^[0-9a-f]{32}$/u.test(value); } @@ -244,6 +263,7 @@ async function dispatch(capability, operation, args, owner, activity) { } if (capability === "language-server") return languageServerOperation(operation, args, owner, activity); if (capability === "project-task") return projectTaskOperation(operation, args, owner, activity); + if (capability === "project-changes") return projectChangeOperation(operation, args, owner, activity); if (capability === "terminal") return terminalOperation(operation, args, owner, activity); if (capability === "http") { if (operation === "request") return httpRequest(args, owner, activity); @@ -273,6 +293,7 @@ async function replaceProjectRoot(path) { for (const task of fileWatchers.values()) releaseFileWatcher(task, new Error("Desktop project grant changed")); for (const task of languageServers.values()) releaseLanguageServer(task, new Error("Desktop project grant changed")); for (const task of terminals.values()) releaseTerminal(task, new Error("Desktop project grant changed")); + retireProjectTransactionOwner(new Error("Desktop project grant changed")); for (const activity of activeRequests.values()) cancelActivity(activity); for (const [handle, task] of processHandles) retainRetiredProcess(handle, task); for (const [handle, request] of httpHandles) { @@ -285,6 +306,214 @@ async function replaceProjectRoot(path) { rebuildFileRoots(); } +function closeRetiredProjectTransactionOwner(owner) { + if (!owner.retired || owner.activeOperations > 0) return; + owner.close(); +} + +function retireProjectTransactionOwner(error) { + projectTransactionGeneration += 1; + const current = projectTransactionOwner; + projectTransactionOwner = null; + if (current !== null) { + current.retired = true; + closeRetiredProjectTransactionOwner(current); + } + for (const task of projectChangeHandles.values()) releaseProjectChangeHandle(task, error); +} + +async function currentProjectTransactionOwner() { + if (projectRoot === null || !fileScopes.has("project")) { + throw new Error("Desktop project changes require the project file grant"); + } + if (projectTransactionOwner?.root === projectRoot && !projectTransactionOwner.retired) return projectTransactionOwner; + const generation = projectTransactionGeneration; + if (projectTransactionOwnerPending?.root !== projectRoot || projectTransactionOwnerPending.generation !== generation) { + const root = projectRoot; + const pending = createDesktopProjectTransactionOwner(root, appDataRoot).then((created) => ({ + ...created, + activeOperations: 0, + retired: false, + })); + projectTransactionOwnerPending = { root, generation, pending }; + } + const pendingOwner = projectTransactionOwnerPending; + try { + const created = await pendingOwner.pending; + if (generation !== projectTransactionGeneration || projectRoot !== pendingOwner.root) { + created.retired = true; + closeRetiredProjectTransactionOwner(created); + throw new Error("Desktop project grant changed while project transactions were opening"); + } + projectTransactionOwner = created; + return created; + } finally { + if (projectTransactionOwnerPending === pendingOwner) projectTransactionOwnerPending = null; + } +} + +async function withProjectTransactionOperation(owner, action) { + owner.activeOperations += 1; + try { + return await action(owner.controller); + } finally { + owner.activeOperations -= 1; + closeRetiredProjectTransactionOwner(owner); + } +} + +function allocateProjectChangeHandle() { + let candidate = nextProjectChangeHandle; + for (let attempts = 0; attempts <= MAX_PROJECT_CHANGE_HANDLES; attempts += 1) { + if (!projectChangeHandles.has(candidate)) { + nextProjectChangeHandle = candidate >= 3_000_000_015 ? 3_000_000_000 : candidate + 1; + return candidate; + } + candidate = candidate >= 3_000_000_015 ? 3_000_000_000 : candidate + 1; + } + throw new RangeError("Desktop project change handle space is unavailable"); +} + +function projectChangeUpdate(task) { + const changes = [...task.queue.values()]; + const update = { changes, rescan: task.rescan }; + task.queue.clear(); + task.queuedBytes = 0; + task.rescan = false; + return update; +} + +function settleProjectChangeSubscription(task) { + if (task.pending === null || !task.rescan && task.queue.size === 0) return; + const pending = task.pending; + task.pending = null; + pending.activity.cancel = null; + pending.resolve(projectChangeUpdate(task)); +} + +function enqueueProjectChange(task, value) { + if (task.closed || task.rescan) return; + try { + const change = desktopProjectChangeView(value); + const bytes = Buffer.byteLength(JSON.stringify(change), "utf8"); + const previous = task.queue.get(change.transactionId); + if (previous !== undefined) task.queuedBytes -= Buffer.byteLength(JSON.stringify(previous), "utf8"); + if (!task.queue.has(change.transactionId) && task.queue.size >= MAX_PROJECT_CHANGE_QUEUE_ITEMS + || task.queuedBytes + bytes > MAX_PROJECT_CHANGE_QUEUE_BYTES) { + task.queue.clear(); + task.queuedBytes = 0; + task.rescan = true; + } else { + task.queue.set(change.transactionId, change); + task.queuedBytes += bytes; + } + } catch { + task.queue.clear(); + task.queuedBytes = 0; + task.rescan = true; + } + settleProjectChangeSubscription(task); +} + +function releaseProjectChangeHandle(task, error = null) { + if (task.closed) return false; + task.closed = true; + projectChangeHandles.delete(task.handle); + task.unsubscribe(); + if (task.pending !== null) { + const pending = task.pending; + task.pending = null; + pending.activity.cancel = null; + if (error === null) pending.resolve(null); + else pending.reject(error); + } + return true; +} + +function ownedProjectChangeHandle(value, owner) { + const handle = integer(value, 3_000_000_000, 3_000_000_015, "ProjectChanges handle"); + const task = projectChangeHandles.get(handle); + if (!task || task.closed) throw new Error("Desktop ProjectChanges handle is unknown or already released"); + if (task.owner !== owner) throw new Error("Desktop ProjectChanges handle belongs to another document generation"); + return task; +} + +async function startProjectChanges(args, owner) { + if (args.length !== 0) throw new TypeError("projectChanges start arguments are invalid"); + if (projectChangeHandles.size >= MAX_PROJECT_CHANGE_HANDLES) throw new RangeError("Desktop cannot own more than 16 project change handles"); + const transactionOwner = await currentProjectTransactionOwner(); + const handle = allocateProjectChangeHandle(); + const task = { + handle, + owner, + transactionOwner, + queue: new Map(), + queuedBytes: 0, + rescan: false, + pending: null, + closed: false, + unsubscribe: null, + }; + task.unsubscribe = transactionOwner.controller.subscribe((change) => enqueueProjectChange(task, change)); + projectChangeHandles.set(handle, task); + return handle; +} + +function listProjectChanges(args, owner) { + if (args.length !== 2) throw new TypeError("ProjectChanges.list arguments are invalid"); + const task = ownedProjectChangeHandle(args[0], owner); + const limit = integer(args[1], 1, 100, "ProjectChanges.list limit"); + return desktopProjectChangePage(task.transactionOwner.controller.list({ limit: limit + 1 }), limit); +} + +function getProjectChange(args, owner) { + if (args.length !== 2) throw new TypeError("ProjectChanges.get arguments are invalid"); + const task = ownedProjectChangeHandle(args[0], owner); + const change = task.transactionOwner.controller.get(args[1]); + return change === undefined ? null : desktopProjectChangeView(change); +} + +function subscribeProjectChanges(args, owner, activity) { + if (args.length !== 1) throw new TypeError("ProjectChanges.subscribe arguments are invalid"); + const task = ownedProjectChangeHandle(args[0], owner); + if (task.pending !== null) throw new Error("ProjectChanges.subscribe already has an active pull"); + if (task.rescan || task.queue.size > 0) return projectChangeUpdate(task); + return new Promise((resolveNext, rejectNext) => { + const pending = { resolve: resolveNext, reject: rejectNext, activity }; + task.pending = pending; + setActivityCancellation(activity, () => { + if (task.pending !== pending) return; + task.pending = null; + pending.reject(new Error("Desktop project change subscription was cancelled")); + }); + }); +} + +async function mutateProjectChange(args, owner, operation) { + if (args.length !== 2) throw new TypeError(`ProjectChanges.${operation} arguments are invalid`); + const task = ownedProjectChangeHandle(args[0], owner); + const input = { transactionId: args[1] }; + await withProjectTransactionOperation(task.transactionOwner, (controller) => controller[operation](input)); + const change = task.transactionOwner.controller.get(args[1]); + if (change === undefined) throw new Error(`Project transaction disappeared after ${operation}`); + return desktopProjectChangeView(change); +} + +function projectChangeOperation(operation, args, owner, activity) { + if (operation === "start") return startProjectChanges(args, owner); + if (operation === "list") return listProjectChanges(args, owner); + if (operation === "get") return getProjectChange(args, owner); + if (operation === "subscribe") return subscribeProjectChanges(args, owner, activity); + if (operation === "apply") return mutateProjectChange(args, owner, "apply"); + if (operation === "rollback") return mutateProjectChange(args, owner, "rollback"); + if (operation === "close") { + if (args.length !== 1) throw new TypeError("ProjectChanges.close arguments are invalid"); + releaseProjectChangeHandle(ownedProjectChangeHandle(args[0], owner)); + return null; + } + throw new Error(`Unknown project-changes operation '${operation}'`); +} + function allocateFileWatcherHandle() { let candidate = nextFileWatcherHandle; for (let attempts = 0; attempts <= MAX_FILE_WATCHERS; attempts += 1) { @@ -416,9 +645,9 @@ function nextFileWatch(args, owner, activity) { return new Promise((resolveNext, rejectNext) => { const pending = { resolve: resolveNext, reject: rejectNext, activity }; task.pending = pending; - activity.cancel = () => { + setActivityCancellation(activity, () => { if (task.pending === pending) releaseFileWatcher(task, new Error("Desktop file watcher pull was cancelled")); - }; + }); }); } @@ -547,7 +776,7 @@ async function startLanguageServer(args, owner, activity) { const closed = new Promise(resolve => { resolveClosed = resolve; }); const task = { handle, owner, child, buffer: Buffer.alloc(0), queue: [], queuedBytes: 0, waiter: null, stderr: "", settled: false, failure: null, ownershipPublished: false, closed, resolveClosed }; languageServers.set(handle, task); - activity.cancel = () => releaseLanguageServer(task, new Error("Desktop language-server start was cancelled")); + setActivityCancellation(activity, () => releaseLanguageServer(task, new Error("Desktop language-server start was cancelled"))); child.stdout.on("data", chunk => parseLanguageServerOutput(task, chunk)); child.stderr.on("data", chunk => { if (task.stderr.length < 64 * 1024) task.stderr += chunk.toString("utf8").slice(0, 64 * 1024 - task.stderr.length); @@ -618,11 +847,11 @@ function nextLanguageServer(args, owner, activity) { return new Promise((resolveNext, rejectNext) => { const waiter = { resolve: resolveNext, reject: rejectNext, activity }; task.waiter = waiter; - activity.cancel = () => { + setActivityCancellation(activity, () => { if (task.waiter !== waiter) return; task.waiter = null; waiter.reject(new Error("Desktop language-server pull was cancelled")); - }; + }); }); } @@ -1093,7 +1322,7 @@ async function terminalOpen(args, owner, activity) { result, resolveResult, rejectResult, stderr: "", }; terminals.set(handle, task); - activity.cancel = () => releaseTerminal(task, new Error("Desktop terminal start was cancelled")); + setActivityCancellation(activity, () => releaseTerminal(task, new Error("Desktop terminal start was cancelled"))); child.stdout.on("data", chunk => enqueueTerminalText(task, task.decoder.write(chunk))); child.stderr.on("data", chunk => { if (task.stderr.length < 64 * 1024) task.stderr += chunk.toString("utf8").slice(0, 64 * 1024 - task.stderr.length); @@ -1163,11 +1392,11 @@ function terminalNext(args, owner, activity) { return new Promise((resolveNext, rejectNext) => { const waiter = {resolve: resolveNext, reject: rejectNext, activity}; task.waiter = waiter; - activity.cancel = () => { + setActivityCancellation(activity, () => { if (task.waiter !== waiter) return; task.waiter = null; waiter.reject(new Error("Desktop terminal pull was cancelled")); - }; + }); }); } @@ -1222,7 +1451,7 @@ async function projectTaskStart(args, owner, activity) { if (projectRoot === null || !fileScopes.has("project")) throw new Error("Desktop project tasks require the project file grant"); if (args.length !== 3) throw new TypeError("Project task start arguments are invalid"); const [command, commandArgs, options] = args; - if (!["check", "test", "build", "fix", "package", "run"].includes(command)) throw new TypeError("Project task command is invalid"); + if (!["check", "test", "browserTest", "build", "fix", "package", "run"].includes(command)) throw new TypeError("Project task command is invalid"); if (!Array.isArray(commandArgs) || commandArgs.length > 1000 || command !== "run" && commandArgs.length > 0) { throw new TypeError("Only a run project task accepts a bounded List of program arguments"); } @@ -1249,7 +1478,7 @@ async function projectTaskStart(args, owner, activity) { const toolArguments = [projectTaskPath, command, projectLexicalRoot ?? projectRoot]; if (command === "run" && commandArgs.length > 0) toolArguments.push("--", ...commandArgs); let task = null; - activity.cancel = () => { if (task !== null) retainRetiredProcess(handle, task); }; + setActivityCancellation(activity, () => { if (task !== null) retainRetiredProcess(handle, task); }); task = await launchChild(process.execPath, toolArguments, { cwd: projectRoot, environment, @@ -1300,7 +1529,7 @@ async function processStart(args, owner, activity) { if (activity.cancelled) throw new Error("Desktop host request was cancelled"); const handle = nextProcessHandle++; let task = null; - activity.cancel = () => { if (task !== null) retainRetiredProcess(handle, task); }; + setActivityCancellation(activity, () => { if (task !== null) retainRetiredProcess(handle, task); }); task = await launchProcess(args, () => respond({ protocolVersion: 1, hostEvent: "process-settled", owner, handle })); task.owner = owner; task.kind = "process"; @@ -1380,6 +1609,9 @@ function retireOwner(owner) { for (const task of languageServers.values()) { if (task.owner === owner) releaseLanguageServer(task, new Error("Desktop document generation retired")); } + for (const task of projectChangeHandles.values()) { + if (task.owner === owner) releaseProjectChangeHandle(task, new Error("Desktop document generation retired")); + } for (const task of terminals.values()) { if (task.owner === owner) releaseTerminal(task, new Error("Desktop document generation retired")); } @@ -1401,6 +1633,7 @@ async function fatalDrain() { reader.close(); for (const task of fileWatchers.values()) releaseFileWatcher(task, new Error("Desktop capability host failed")); for (const task of languageServers.values()) releaseLanguageServer(task, new Error("Desktop capability host failed")); + retireProjectTransactionOwner(new Error("Desktop capability host failed")); for (const task of terminals.values()) releaseTerminal(task, new Error("Desktop capability host failed")); const tasks = Array.from(processHandles.values()); for (const task of tasks) task.stop(); @@ -1734,7 +1967,7 @@ async function httpRequest(args, owner, activity) { if (body !== null && Buffer.byteLength(body, "utf8") > MAX_FILE_BYTES) throw new RangeError("HTTP body cannot exceed 16 MiB"); if ((method === "GET" || method === "HEAD") && body !== null) throw new TypeError(`${method} requests cannot have a body`); const controller = new AbortController(); - activity.cancel = () => controller.abort(new Error("Desktop host request was cancelled")); + setActivityCancellation(activity, () => controller.abort(new Error("Desktop host request was cancelled"))); const request = { owner, controller, diff --git a/packages/desktop/package.json b/packages/desktop/package.json index bb930ee2..ed77bdf5 100644 --- a/packages/desktop/package.json +++ b/packages/desktop/package.json @@ -11,7 +11,7 @@ ], "scripts": { "clean": "node ../../scripts/clean-package-dist.mjs", - "build": "npm run clean && tsc -p tsconfig.build.json", + "build": "npm run clean && tsc -p tsconfig.build.json && node scripts/build-worker.mjs", "prepack": "npm run build" }, "engines": { diff --git a/packages/desktop/scripts/build-worker.mjs b/packages/desktop/scripts/build-worker.mjs new file mode 100644 index 00000000..0c53ebd1 --- /dev/null +++ b/packages/desktop/scripts/build-worker.mjs @@ -0,0 +1,27 @@ +import { chmod, mkdir } from "node:fs/promises"; +import { dirname, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; + +import { build } from "esbuild"; + +const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), ".."); +const outputFile = resolve(packageRoot, "dist/worker.js"); + +await mkdir(dirname(outputFile), { recursive: true }); +await build({ + entryPoints: [resolve(packageRoot, "native/node/worker.js")], + outfile: outputFile, + bundle: true, + format: "esm", + platform: "node", + target: "node24", + minify: true, + treeShaking: true, + sourcemap: false, + legalComments: "none", + banner: { + js: 'import {createRequire as __velarCreateRequire} from "node:module"; import {fileURLToPath as __velarFileURLToPath} from "node:url"; import {dirname as __velarDirname} from "node:path"; const require = __velarCreateRequire(import.meta.url); const __filename = __velarFileURLToPath(import.meta.url); const __dirname = __velarDirname(__filename);', + }, + logLevel: "silent", +}); +await chmod(outputFile, 0o644); diff --git a/packages/desktop/src/build.ts b/packages/desktop/src/build.ts index 0849c781..2a9eed03 100644 --- a/packages/desktop/src/build.ts +++ b/packages/desktop/src/build.ts @@ -93,6 +93,10 @@ async function desktopNativeTemplate(): Promise { return template; } +function bundledCapabilityWorker(): string { + return fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../dist/worker.js" : "./worker.js", import.meta.url)); +} + function desktopSizeComponents(sizes: DesktopBuildSizes): readonly DesktopSizeComponent[] { return [ { label: "build engine (velar-build-engine)", bytes: sizes.buildEngineBytes, mandatory: true }, @@ -169,7 +173,7 @@ export async function buildDesktopApplication( const hostResources = join(resources, "host"); await mkdir(hostResources); const workerPath = join(hostResources, "worker.js"); - await cp(nativeTemplate?.worker ?? fileURLToPath(new URL("../native/node/worker.js", import.meta.url)), workerPath); + await cp(nativeTemplate?.worker ?? bundledCapabilityWorker(), workerPath); const languageServerPath = join(hostResources, "language-server.js"); const projectTaskPath = join(hostResources, "project-task.js"); const buildEnginePath = join(hostResources, "build-engine"); @@ -211,7 +215,9 @@ export async function buildDesktopApplication( const rendererBytes = await treeSize(renderer); const capabilityHostBytes = (await stat(workerPath)).size; const languageServerBytes = (await stat(languageServerPath)).size; - const projectTaskBytes = (await stat(projectTaskPath)).size; + const projectTaskBytes = (await stat(projectTaskPath)).size + + (await stat(join(hostResources, "playwright-core", "package.json"))).size + + (await stat(join(hostResources, "playwright-core", "browsers.json"))).size; const buildEngineBytes = (await stat(buildEnginePath)).size; const terminalHostBytes = (await stat(terminalHostPath)).size; const toolchainBytes = languageServerBytes + projectTaskBytes + buildEngineBytes + terminalHostBytes; diff --git a/packages/desktop/src/compiler.ts b/packages/desktop/src/compiler.ts index ad8f433b..0cd28f09 100644 --- a/packages/desktop/src/compiler.ts +++ b/packages/desktop/src/compiler.ts @@ -83,7 +83,7 @@ const languageServerType: ValueType = { kind: "named", name: "LanguageServer", i const projectTaskIdentity = "velar/desktop#type:ProjectTask"; const projectTaskType: ValueType = { kind: "named", name: "ProjectTask", identity: projectTaskIdentity }; const projectTaskCommandIdentity = "velar/desktop#enum:ProjectTaskCommand"; -const projectTaskCommands = new Set(["check", "test", "build", "fix", "package", "run"]); +const projectTaskCommands = new Set(["check", "test", "browserTest", "build", "fix", "package", "run"]); const projectTaskCommandType: ValueType = { kind: "enum", name: "ProjectTaskCommand", identity: projectTaskCommandIdentity }; const projectTaskOutputChannelIdentity = "velar/desktop#enum:ProjectTaskOutputChannel"; const projectTaskOutputChannels = new Set(["stdout", "stderr"]); @@ -103,6 +103,61 @@ const projectTaskOptionsType: ValueType = { fields: new Map([["timeout", numberType], ["maxOutputBytes", numberType]]), optionalFields: new Set(["timeout", "maxOutputBytes"]), }; +const projectChangesIdentity = "velar/desktop#type:ProjectChanges"; +const projectChangesType: ValueType = { kind: "named", name: "ProjectChanges", identity: projectChangesIdentity }; +const projectChangeLifecycleIdentity = "velar/desktop#enum:ProjectChangeLifecycle"; +const projectChangeLifecycles = new Set(["prepared", "amended", "validated", "validationFailed", "applied", "rolledBack", "discarded"]); +const projectChangeLifecycleType: ValueType = { kind: "enum", name: "ProjectChangeLifecycle", identity: projectChangeLifecycleIdentity }; +const projectChangeRiskIdentity = "velar/desktop#enum:ProjectChangeRisk"; +const projectChangeRisks = new Set(["low", "medium", "high"]); +const projectChangeRiskType: ValueType = { kind: "enum", name: "ProjectChangeRisk", identity: projectChangeRiskIdentity }; +const projectChangeIntentType: ValueType = { kind: "object", fields: new Map([ + ["type", stringType], + ["path", optionalStringType], + ["from", optionalStringType], + ["to", optionalStringType], + ["targetId", optionalStringType], + ["reason", optionalStringType], +]) }; +const projectChangePatchType: ValueType = { kind: "object", fields: new Map([ + ["patchId", stringType], + ["strategyId", stringType], + ["path", stringType], + ["baseRevision", optionalStringType], + ["diff", stringType], + ["changedLines", numberType], + ["risk", projectChangeRiskType], + ["operation", optionalStringType], +]) }; +const projectChangeRevisionType: ValueType = { kind: "object", fields: new Map([ + ["path", stringType], + ["before", optionalStringType], + ["after", optionalStringType], +]) }; +const projectChangeType: ValueType = { kind: "object", fields: new Map([ + ["transactionId", stringType], + ["sequence", numberType], + ["lifecycle", projectChangeLifecycleType], + ["reason", optionalStringType], + ["intents", { kind: "list", element: projectChangeIntentType }], + ["patches", { kind: "list", element: projectChangePatchType }], + ["changedFiles", listStringType], + ["diff", stringType], + ["changedLines", numberType], + ["risk", projectChangeRiskType], + ["revisions", { kind: "list", element: projectChangeRevisionType }], + ["createdAt", numberType], + ["updatedAt", numberType], + ["appliedAt", optionalNumberType], +]) }; +const projectChangePageType: ValueType = { kind: "object", fields: new Map([ + ["changes", { kind: "list", element: projectChangeType }], + ["truncated", boolType], +]) }; +const projectChangeUpdateType: ValueType = { kind: "object", fields: new Map([ + ["changes", { kind: "list", element: projectChangeType }], + ["rescan", boolType], +]) }; const terminalSessionIdentity = "velar/desktop#type:TerminalSession"; const terminalSessionType: ValueType = { kind: "named", name: "TerminalSession", identity: terminalSessionIdentity }; const terminalResultType: ValueType = { kind: "object", fields: new Map([["code", numberType]]) }; @@ -116,6 +171,9 @@ const desktopModuleInterface = moduleInterface(new Map([ ["ProjectTask", { kind: "typeObject", name: "ProjectTask" }], ["ProjectTaskCommand", { kind: "enumObject", name: "ProjectTaskCommand", identity: projectTaskCommandIdentity, members: projectTaskCommands }], ["ProjectTaskOutputChannel", { kind: "enumObject", name: "ProjectTaskOutputChannel", identity: projectTaskOutputChannelIdentity, members: projectTaskOutputChannels }], + ["ProjectChanges", { kind: "typeObject", name: "ProjectChanges" }], + ["ProjectChangeLifecycle", { kind: "enumObject", name: "ProjectChangeLifecycle", identity: projectChangeLifecycleIdentity, members: projectChangeLifecycles }], + ["ProjectChangeRisk", { kind: "enumObject", name: "ProjectChangeRisk", identity: projectChangeRiskIdentity, members: projectChangeRisks }], ["TerminalSession", { kind: "typeObject", name: "TerminalSession" }], ["platform", functionType([], stringType)], ["packaged", functionType([], boolType)], @@ -125,6 +183,7 @@ const desktopModuleInterface = moduleInterface(new Map([ ["selectedProjectDirectory", functionType([], { kind: "promise", value: optionalStringType })], ["selectProjectDirectory", functionType([], { kind: "promise", value: optionalStringType })], ["languageServer", functionType([], { kind: "promise", value: languageServerType })], + ["projectChanges", functionType([], { kind: "promise", value: projectChangesType })], ["startProjectTask", functionType([projectTaskCommandType, listStringType, projectTaskOptionsType], { kind: "promise", value: projectTaskType }, 1)], ["openTerminal", functionType([terminalOptionsType], { kind: "promise", value: terminalSessionType }, 0)], ]), new Map([ @@ -139,6 +198,14 @@ const desktopModuleInterface = moduleInterface(new Map([ ["wait", functionType([], { kind: "promise", value: projectTaskResultType })], ["stop", functionType([], { kind: "promise", value: nullType })], ])], + ["ProjectChanges", new Map([ + ["list", functionType([numberType], { kind: "promise", value: projectChangePageType }, 0)], + ["get", functionType([stringType], { kind: "promise", value: optionalOf(projectChangeType) })], + ["subscribe", functionType([], { kind: "promise", value: optionalOf(projectChangeUpdateType) })], + ["apply", functionType([stringType], { kind: "promise", value: projectChangeType })], + ["rollback", functionType([stringType], { kind: "promise", value: projectChangeType })], + ["close", functionType([], { kind: "promise", value: nullType })], + ])], ["TerminalSession", new Map([ ["pid", numberType], ["write", functionType([stringType], { kind: "promise", value: nullType })], @@ -150,15 +217,19 @@ const desktopModuleInterface = moduleInterface(new Map([ ]), new Map([ ["LanguageServer", languageServerIdentity], ["ProjectTask", projectTaskIdentity], + ["ProjectChanges", projectChangesIdentity], ["TerminalSession", terminalSessionIdentity], ]), new Map([ ["ProjectTaskCommand", { identity: projectTaskCommandIdentity, members: projectTaskCommands }], ["ProjectTaskOutputChannel", { identity: projectTaskOutputChannelIdentity, members: projectTaskOutputChannels }], + ["ProjectChangeLifecycle", { identity: projectChangeLifecycleIdentity, members: projectChangeLifecycles }], + ["ProjectChangeRisk", { identity: projectChangeRiskIdentity, members: projectChangeRisks }], ])); const desktopTestModuleInterface = moduleInterface(new Map([ ["appDataDirectory", functionType([], { kind: "promise", value: stringType })], ["projectDirectory", functionType([], { kind: "promise", value: stringType })], + ["seedProjectChange", functionType([stringType, stringType, stringType], { kind: "promise", value: nullType })], ["makeDirectory", functionType([stringType], { kind: "promise", value: nullType })], ["readText", functionType([stringType, { kind: "number" }], { kind: "promise", value: stringType })], ["writeText", functionType([stringType, stringType], { kind: "promise", value: nullType })], @@ -175,6 +246,7 @@ ${VELAR_UTF8_RUNTIME} ${VELAR_PROCESS_HOST_RUNTIME} const languageServerToken = Symbol("velar.desktop.language-server"); const projectTaskToken = Symbol("velar.desktop.project-task"); +const projectChangesToken = Symbol("velar.desktop.project-changes"); const terminalSessionToken = Symbol("velar.desktop.terminal-session"); export function platform() { const value = __velarDesktopHostField("platform"); @@ -245,6 +317,223 @@ export async function languageServer() { const handle = await __velarDesktopHostCall("language-server", "start", []); return new LanguageServerHandle(languageServerToken, handle); } +const projectChangeIntentFields = new __velarProcessNativeSet(["type", "path", "from", "to", "targetId", "reason"]); +const projectChangePatchFields = new __velarProcessNativeSet(["patchId", "strategyId", "path", "baseRevision", "diff", "changedLines", "risk", "operation"]); +const projectChangeRevisionFields = new __velarProcessNativeSet(["path", "before", "after"]); +const projectChangeFields = new __velarProcessNativeSet([ + "transactionId", "sequence", "lifecycle", "reason", "intents", "patches", "changedFiles", "diff", "changedLines", "risk", + "revisions", "createdAt", "updatedAt", "appliedAt", +]); +const projectChangePageFields = new __velarProcessNativeSet(["changes", "truncated"]); +const projectChangeUpdateFields = new __velarProcessNativeSet(["changes", "rescan"]); +export const ProjectChangeLifecycle = __velarRegisterRuntimeType(__velarProcessFreeze({ + prepared: "prepared", amended: "amended", validated: "validated", validationFailed: "validationFailed", applied: "applied", rolledBack: "rolledBack", discarded: "discarded", + is(value) { + return value === "prepared" || value === "amended" || value === "validated" || value === "validationFailed" + || value === "applied" || value === "rolledBack" || value === "discarded"; + }, + parse(value) { + if (!ProjectChangeLifecycle.is(value)) throw new __velarProcessNativeTypeError("Value does not match ProjectChangeLifecycle"); + return value; + }, + values() { return ["prepared", "amended", "validated", "validationFailed", "applied", "rolledBack", "discarded"]; }, +})); +export const ProjectChangeRisk = __velarRegisterRuntimeType(__velarProcessFreeze({ + low: "low", medium: "medium", high: "high", + is(value) { return value === "low" || value === "medium" || value === "high"; }, + parse(value) { + if (!ProjectChangeRisk.is(value)) throw new __velarProcessNativeTypeError("Value does not match ProjectChangeRisk"); + return value; + }, + values() { return ["low", "medium", "high"]; }, +})); +function projectChangeText(value, name, maximumBytes, allowEmpty = false) { + if (typeof value !== "string" || !allowEmpty && value.length === 0 || __velarProcessIncludes(value, "\0")) { + throw new __velarProcessNativeTypeError(name + " must be bounded text"); + } + const bytes = __velarUtf8ByteLength(value); + if (bytes > maximumBytes) throw new __velarProcessNativeRangeError(name + " exceeds its supported bound"); + return {value, bytes}; +} +function projectChangeOptionalText(value, name, maximumBytes) { + return value == null ? {value: null, bytes: 0} : projectChangeText(value, name, maximumBytes); +} +function projectChangeInteger(value, name, minimum = 0) { + if (!__velarProcessIsSafeInteger(value) || value < minimum) throw new __velarProcessNativeTypeError(name + " must be a non-negative safe integer"); + return value; +} +function projectChangeList(value, name, maximumItems, read) { + if (!__velarProcessIsArray(value) || value.length > maximumItems) throw new __velarProcessNativeTypeError(name + " must be a bounded List"); + const output = new __velarProcessNativeArray(value.length); + let bytes = 0; + for (let index = 0; index < value.length; index += 1) { + const descriptor = __velarProcessOwnDescriptor(value, __velarProcessNativeString(index)); + if (!descriptor?.enumerable || !("value" in descriptor)) throw new __velarProcessNativeTypeError(name + " must contain enumerable data values"); + const item = read(descriptor.value, index); + output[index] = item.value; + bytes += item.bytes; + } + // The hostile host value has already been descriptor-checked and copied. + // Keep the caller-owned copy as a normal VelarScript List: freezing this + // fresh array makes the language runtime correctly reject iteration even + // though no host alias remains to protect. + return {value: output, bytes}; +} +function projectChangeIntent(value) { + value = __velarProcessRecord(value, "Project change intent", projectChangeIntentFields); + const type = projectChangeText(value.type, "Project change intent type", 128); + const path = projectChangeOptionalText(value.path, "Project change intent path", 4096); + const from = projectChangeOptionalText(value.from, "Project change intent source path", 4096); + const to = projectChangeOptionalText(value.to, "Project change intent target path", 4096); + const targetId = projectChangeOptionalText(value.targetId, "Project change target id", 512); + const reason = projectChangeOptionalText(value.reason, "Project change intent reason", 64 * 1024); + return { + value: __velarProcessFreeze({type: type.value, path: path.value, from: from.value, to: to.value, targetId: targetId.value, reason: reason.value}), + bytes: type.bytes + path.bytes + from.bytes + to.bytes + targetId.bytes + reason.bytes, + }; +} +function projectChangePatch(value) { + value = __velarProcessRecord(value, "Project change patch", projectChangePatchFields); + const patchId = projectChangeText(value.patchId, "Project change patch id", 512); + const strategyId = projectChangeText(value.strategyId, "Project change strategy id", 512); + const path = projectChangeText(value.path, "Project change patch path", 4096); + const baseRevision = projectChangeOptionalText(value.baseRevision, "Project change patch base revision", 512); + const diff = projectChangeText(value.diff, "Project change patch diff", 16 * 1024 * 1024, true); + const operation = projectChangeOptionalText(value.operation, "Project change patch operation", 128); + const risk = ProjectChangeRisk.parse(value.risk); + const changedLines = projectChangeInteger(value.changedLines, "Project change patch changed lines"); + return { + value: __velarProcessFreeze({patchId: patchId.value, strategyId: strategyId.value, path: path.value, baseRevision: baseRevision.value, diff: diff.value, changedLines, risk, operation: operation.value}), + bytes: patchId.bytes + strategyId.bytes + path.bytes + baseRevision.bytes + diff.bytes + operation.bytes, + }; +} +function projectChangeRevision(value) { + value = __velarProcessRecord(value, "Project change revision", projectChangeRevisionFields); + const path = projectChangeText(value.path, "Project change revision path", 4096); + const before = projectChangeOptionalText(value.before, "Project change prior revision", 512); + const after = projectChangeOptionalText(value.after, "Project change next revision", 512); + return { + value: __velarProcessFreeze({path: path.value, before: before.value, after: after.value}), + bytes: path.bytes + before.bytes + after.bytes, + }; +} +function projectChangeLifecycle(value) { + if (value === "prepared" || value === "amended" || value === "validated" || value === "applied" || value === "discarded") return value; + if (value === "validation_failed") return "validationFailed"; + if (value === "rolled_back") return "rolledBack"; + throw new __velarProcessNativeTypeError("Desktop host returned an invalid project change lifecycle"); +} +function projectChangeValue(value) { + value = __velarProcessRecord(value, "Project change", projectChangeFields); + const transactionId = projectChangeText(value.transactionId, "Project change transaction id", 512); + const reason = projectChangeOptionalText(value.reason, "Project change reason", 64 * 1024); + const intents = projectChangeList(value.intents, "Project change intents", 1000, projectChangeIntent); + const patches = projectChangeList(value.patches, "Project change patches", 1000, projectChangePatch); + const changedFiles = projectChangeList(value.changedFiles, "Project change files", 1000, item => projectChangeText(item, "Project change file path", 4096)); + const diff = projectChangeText(value.diff, "Project change diff", 16 * 1024 * 1024, true); + const revisions = projectChangeList(value.revisions, "Project change revisions", 1000, projectChangeRevision); + const bytes = transactionId.bytes + reason.bytes + intents.bytes + patches.bytes + changedFiles.bytes + diff.bytes + revisions.bytes; + if (bytes > 16 * 1024 * 1024) throw new __velarProcessNativeRangeError("Project change record exceeds 16 MiB"); + const appliedAt = value.appliedAt == null ? null : projectChangeInteger(value.appliedAt, "Project change apply time"); + return { + value: __velarProcessFreeze({ + transactionId: transactionId.value, + sequence: projectChangeInteger(value.sequence, "Project change sequence", 1), + lifecycle: projectChangeLifecycle(value.lifecycle), + reason: reason.value, + intents: intents.value, + patches: patches.value, + changedFiles: changedFiles.value, + diff: diff.value, + changedLines: projectChangeInteger(value.changedLines, "Project change changed lines"), + risk: ProjectChangeRisk.parse(value.risk), + revisions: revisions.value, + createdAt: projectChangeInteger(value.createdAt, "Project change creation time"), + updatedAt: projectChangeInteger(value.updatedAt, "Project change update time"), + appliedAt, + }), + bytes, + }; +} +function projectChangeValues(value, name, maximumItems) { + return projectChangeList(value, name, maximumItems, projectChangeValue); +} +function projectChangePage(value) { + value = __velarProcessRecord(value, "Project change page", projectChangePageFields); + const changes = projectChangeValues(value.changes, "Project change page", 100); + if (changes.bytes > 32 * 1024 * 1024 || typeof value.truncated !== "boolean") { + throw new __velarProcessNativeTypeError("Desktop host returned an invalid project change page"); + } + return __velarProcessFreeze({changes: changes.value, truncated: value.truncated}); +} +function projectChangeUpdate(value) { + value = __velarProcessRecord(value, "Project change update", projectChangeUpdateFields); + const changes = projectChangeValues(value.changes, "Project change update", 100); + if (changes.bytes > 16 * 1024 * 1024 || typeof value.rescan !== "boolean") { + throw new __velarProcessNativeTypeError("Desktop host returned an invalid project change update"); + } + return __velarProcessFreeze({changes: changes.value, rescan: value.rescan}); +} +function projectChangeId(value) { + return projectChangeText(value, "Project change transaction id", 512).value; +} +class ProjectChangesHandle { + constructor(token, handle) { + if (token !== projectChangesToken || !__velarProcessIsSafeInteger(handle) || handle < 1) { + throw new __velarProcessNativeTypeError("ProjectChanges values are created only by velar/desktop.projectChanges"); + } + this.handle = handle; + this.closed = false; + this.reading = false; + __velarProcessSeal(this); + } + async list(limit = 50) { + if (this.closed) throw new __velarProcessNativeError("ProjectChanges is closed"); + if (!__velarProcessIsSafeInteger(limit) || limit < 1 || limit > 100) throw new __velarProcessNativeRangeError("ProjectChanges.list limit must be an integer from 1 through 100"); + return projectChangePage(await __velarDesktopHostCall("project-changes", "list", [this.handle, limit])); + } + async get(transactionId) { + if (this.closed) throw new __velarProcessNativeError("ProjectChanges is closed"); + const value = await __velarDesktopHostCall("project-changes", "get", [this.handle, projectChangeId(transactionId)]); + return value === null ? null : projectChangeValue(value).value; + } + async subscribe() { + if (this.closed) return null; + if (this.reading) throw new __velarProcessNativeError("ProjectChanges.subscribe() allows only one active pull"); + this.reading = true; + try { + const value = await __velarDesktopHostCall("project-changes", "subscribe", [this.handle], 0); + if (value === null) { this.closed = true; return null; } + return projectChangeUpdate(value); + } finally { this.reading = false; } + } + async apply(transactionId) { + if (this.closed) throw new __velarProcessNativeError("ProjectChanges is closed"); + return projectChangeValue(await __velarDesktopHostCall("project-changes", "apply", [this.handle, projectChangeId(transactionId)], 0)).value; + } + async rollback(transactionId) { + if (this.closed) throw new __velarProcessNativeError("ProjectChanges is closed"); + return projectChangeValue(await __velarDesktopHostCall("project-changes", "rollback", [this.handle, projectChangeId(transactionId)], 0)).value; + } + async close() { + if (this.closed) return null; + const value = await __velarDesktopHostCall("project-changes", "close", [this.handle], 10000); + if (value !== null) throw new __velarProcessNativeTypeError("Desktop host returned an invalid ProjectChanges close result"); + this.closed = true; + return null; + } +} +export const ProjectChanges = __velarProcessFreeze({ + is(value) { return value instanceof ProjectChangesHandle; }, + parse(value) { + if (!(value instanceof ProjectChangesHandle)) throw new __velarProcessNativeTypeError("Value does not match ProjectChanges"); + return value; + }, +}); +export async function projectChanges() { + const handle = await __velarDesktopHostCall("project-changes", "start", []); + return new ProjectChangesHandle(projectChangesToken, handle); +} const projectTaskOptionFields = new __velarProcessNativeSet(["timeout", "maxOutputBytes"]); const projectTaskStartFields = new __velarProcessNativeSet(["handle", "pid"]); const projectTaskOutputFields = new __velarProcessNativeSet(["channel", "text"]); @@ -253,15 +542,15 @@ const projectTaskErrorFields = new __velarProcessNativeSet(["name", "message"]); const projectTaskWaitFields = new __velarProcessNativeSet(["result", "error", "retained"]); const projectTaskStopFields = new __velarProcessNativeSet(["result", "error"]); export const ProjectTaskCommand = __velarRegisterRuntimeType(__velarProcessFreeze({ - check: "check", test: "test", build: "build", fix: "fix", package: "package", run: "run", - is(value) { return value === "check" || value === "test" || value === "build" || value === "fix" || value === "package" || value === "run"; }, + check: "check", test: "test", browserTest: "browserTest", build: "build", fix: "fix", package: "package", run: "run", + is(value) { return value === "check" || value === "test" || value === "browserTest" || value === "build" || value === "fix" || value === "package" || value === "run"; }, parse(value) { if (!ProjectTaskCommand.is(value)) throw new __velarProcessNativeTypeError("Value does not match ProjectTaskCommand"); return value; }, // D60 rule 149: values() is the third name charter section 6 reserves on // every enum, and it returns a fresh mutable List in declaration order. - values() { return ["check", "test", "build", "fix", "package", "run"]; }, + values() { return ["check", "test", "browserTest", "build", "fix", "package", "run"]; }, })); export const ProjectTaskOutputChannel = __velarRegisterRuntimeType(__velarProcessFreeze({ stdout: "stdout", stderr: "stderr", @@ -555,6 +844,20 @@ export async function projectDirectory() { if (typeof value !== "string" || !value.startsWith("/") || value.length > 4096 || value.includes("\0")) throw new TypeError("Desktop test host returned an invalid absolute project path"); return value; } +export async function seedProjectChange(transactionId, lifecycle, diff) { + if (typeof transactionId !== "string" || transactionId.length === 0 || transactionId.length > 512 || transactionId.includes("\0")) { + throw new TypeError("Desktop test seedProjectChange requires a bounded transaction id"); + } + if (typeof lifecycle !== "string" || lifecycle.length === 0 || lifecycle.length > 64) { + throw new TypeError("Desktop test seedProjectChange requires a lifecycle name"); + } + if (typeof diff !== "string" || new TextEncoder().encode(diff).byteLength > 16 * 1024 * 1024) { + throw new RangeError("Desktop test seedProjectChange diff cannot exceed 16 MiB"); + } + const value = await invoke("project-change-test", "seed", [transactionId, lifecycle, diff], 30000); + if (value !== null) throw new TypeError("Desktop test host returned an invalid project change seed result"); + return null; +} export async function makeDirectory(path) { if (typeof path !== "string" || path.length === 0 || path.length > 4096 || path.includes("\0")) throw new TypeError("Desktop test makeDirectory requires a bounded path"); const value = await invoke("fs", "makeDirectory", [path], 30000); @@ -1631,6 +1934,7 @@ export const velarCompilerExtension: CompilerExtension = Object.freeze({ // future application target cannot inherit hidden Web behavior via spread. lexical: webCompilerExtension.lexical!, parser: webCompilerExtension.parser!, + syntax: webCompilerExtension.syntax!, analyzer: webCompilerExtension.analyzer!, semantic: webCompilerExtension.semantic!, inspection: webCompilerExtension.inspection!, diff --git a/packages/desktop/src/config.ts b/packages/desktop/src/config.ts index 12ccc7c6..1f1474cd 100644 --- a/packages/desktop/src/config.ts +++ b/packages/desktop/src/config.ts @@ -1,5 +1,9 @@ export const VELAR_DESKTOP_API_VERSION = "0.10"; -export const DEFAULT_DESKTOP_SIZE_BUDGET_BYTES = 20 * 1024 * 1024; +// The complete Project transaction owner adds about 4.39 MiB to the mandatory +// capability Worker. 32 MiB is the current default accounting threshold, not +// an architectural ceiling: projects may raise it explicitly when their +// measured application payload justifies the increase. +export const DEFAULT_DESKTOP_SIZE_BUDGET_BYTES = 32 * 1024 * 1024; export interface DesktopWindowConfig { readonly title: string; diff --git a/packages/desktop/src/test-runtime.ts b/packages/desktop/src/test-runtime.ts index f30bd3be..47bb4ec6 100644 --- a/packages/desktop/src/test-runtime.ts +++ b/packages/desktop/src/test-runtime.ts @@ -23,8 +23,12 @@ export function desktopBrowserTestInitScript(config: VelarDesktopConfig): string const nodes = new Map(); const processHandles = new Map(); const fileWatchers = new Map(); + const projectChanges = new Map(); + const projectChangeHandles = new Map(); let nextProcessHandle = 1; let nextFileWatcherHandle = 1; + let nextProjectChangeHandle = 1; + let nextProjectChangeSequence = 1; const now = 0; const maxFileBytes = 16 * 1024 * 1024; const maxListItems = 100000; @@ -32,6 +36,130 @@ export function desktopBrowserTestInitScript(config: VelarDesktopConfig): string const maxWatchPaths = 4096; const maxWatchTextUnits = 2 * 1024 * 1024; + function projectChangeLifecycle(value) { + if (value === "prepared" || value === "amended" || value === "validated" || value === "applied" || value === "discarded") return value; + if (value === "validationFailed" || value === "validation_failed") return "validation_failed"; + if (value === "rolledBack" || value === "rolled_back") return "rolled_back"; + throw new TypeError("Desktop test project change lifecycle is invalid"); + } + function projectChangeId(value) { + if (typeof value !== "string" || value.length === 0 || value.length > 512 || value.includes("\0")) { + throw new TypeError("Desktop test project change id must be bounded text"); + } + return value; + } + function projectChangeDiff(value) { + if (typeof value !== "string" || new TextEncoder().encode(value).byteLength > 16 * 1024 * 1024) { + throw new RangeError("Desktop test project change diff cannot exceed 16 MiB"); + } + return value; + } + function changeLines(diff) { + if (diff.length === 0) return 0; + return diff.split("\n").filter(line => line.startsWith("+") || line.startsWith("-")).length; + } + function notifyProjectChanges(change) { + for (const handle of projectChangeHandles.values()) { + if (handle.closed) continue; + if (!handle.queue.has(change.transactionId) && handle.queue.size >= 100) { + handle.queue.clear(); + handle.rescan = true; + } else if (!handle.rescan) handle.queue.set(change.transactionId, change); + if (handle.pending) { + const resolveNext = handle.pending; + handle.pending = null; + const changes = [...handle.queue.values()]; + handle.queue.clear(); + const rescan = handle.rescan; + handle.rescan = false; + resolveNext({changes, rescan}); + } + } + } + function recordProjectChange(transactionId, lifecycle, diff, previous = null) { + const sequence = nextProjectChangeSequence++; + const changedLines = changeLines(diff); + const change = Object.freeze({ + transactionId, + sequence, + lifecycle, + reason: null, + intents: Object.freeze([Object.freeze({type: "replace_text", path: "src/main.vel", from: null, to: null, targetId: null, reason: "desktop browser test"})]), + patches: Object.freeze([Object.freeze({ + patchId: "desktop-test:" + transactionId, + strategyId: "desktop-test", + path: "src/main.vel", + baseRevision: null, + diff, + changedLines, + risk: "low", + operation: "replace_text", + })]), + changedFiles: Object.freeze(["src/main.vel"]), + diff, + changedLines, + risk: "low", + revisions: Object.freeze([Object.freeze({path: "src/main.vel", before: previous ? previous.revisions[0].before : "desktop-test:before", after: "desktop-test:" + sequence})]), + createdAt: previous ? previous.createdAt : sequence, + updatedAt: sequence, + appliedAt: lifecycle === "applied" ? sequence : previous?.appliedAt ?? null, + }); + projectChanges.set(transactionId, change); + notifyProjectChanges(change); + return change; + } + async function projectChangeCapability(operation, args) { + if (!grants.has("project")) throw new Error("Desktop test project changes require the project file grant"); + if (operation === "start") { + if (args.length !== 0) throw new TypeError("Desktop test projectChanges start arguments are invalid"); + const handle = nextProjectChangeHandle++; + projectChangeHandles.set(handle, {queue: new Map(), rescan: false, pending: null, closed: false}); + return handle; + } + const handle = projectChangeHandles.get(args[0]); + if (!handle || handle.closed) throw new Error("Desktop test ProjectChanges handle is unknown or already released"); + if (operation === "list") { + const limit = args[1]; + if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new RangeError("Desktop test ProjectChanges list limit is invalid"); + const values = [...projectChanges.values()].sort((left, right) => right.sequence - left.sequence); + return {changes: values.slice(0, limit), truncated: values.length > limit}; + } + if (operation === "get") return projectChanges.get(projectChangeId(args[1])) ?? null; + if (operation === "subscribe") { + if (handle.pending) throw new Error("Desktop test ProjectChanges subscribe already has an active pull"); + if (handle.rescan || handle.queue.size > 0) { + const changes = [...handle.queue.values()]; + handle.queue.clear(); + const rescan = handle.rescan; + handle.rescan = false; + return {changes, rescan}; + } + return new Promise(resolveNext => { handle.pending = resolveNext; }); + } + if (operation === "apply" || operation === "rollback") { + const transactionId = projectChangeId(args[1]); + const current = projectChanges.get(transactionId); + if (!current) throw new Error("Desktop test project transaction is unknown"); + if (operation === "apply" && current.lifecycle === "applied") throw new Error("Desktop test project transaction is already applied"); + if (operation === "rollback" && current.lifecycle !== "applied") throw new Error("Desktop test project transaction is not applied"); + return recordProjectChange(transactionId, operation === "apply" ? "applied" : "rolled_back", current.diff, current); + } + if (operation === "close") { + handle.closed = true; + projectChangeHandles.delete(args[0]); + if (handle.pending) { const resolveNext = handle.pending; handle.pending = null; resolveNext(null); } + return null; + } + throw new Error("Unsupported Desktop test project change operation '" + operation + "'"); + } + async function projectChangeTest(operation, args) { + if (operation !== "seed" || args.length !== 3) throw new TypeError("Desktop test project change seed arguments are invalid"); + if (!grants.has("project")) throw new Error("Desktop test project change seed requires the project file grant"); + const transactionId = projectChangeId(args[0]); + recordProjectChange(transactionId, projectChangeLifecycle(args[1]), projectChangeDiff(args[2]), projectChanges.get(transactionId) ?? null); + return null; + } + function watchBatch(watcher) { if (watcher.rescan) { watcher.rescan = false; @@ -311,6 +439,8 @@ export function desktopBrowserTestInitScript(config: VelarDesktopConfig): string } if (capability === "fs") return fs(operation, args); if (capability === "process") return processCapability(operation, args); + if (capability === "project-changes") return projectChangeCapability(operation, args); + if (capability === "project-change-test") return projectChangeTest(operation, args); throw new Error("Desktop test capability '" + capability + "' is not configured"); }, }); diff --git a/packages/node/src/process-worker-runtime.ts b/packages/node/src/process-worker-runtime.ts index c7bf9b4f..f9f4876b 100644 --- a/packages/node/src/process-worker-runtime.ts +++ b/packages/node/src/process-worker-runtime.ts @@ -181,6 +181,18 @@ function signalTree(child, signal) { catch { try { child.kill(signal); } catch {} } } +async function waitForProcessGroupExit(child) { + if (process.platform === "win32" || !child.pid) return; + while (true) { + try { process.kill(-child.pid, 0); } + catch (error) { + if (error && typeof error === "object" && error.code === "ESRCH") return; + throw error; + } + await new Promise(resolve => setTimeout(resolve, 20)); + } +} + function launchProcess(command, commandArgs, options, settled) { const child = spawn(command, commandArgs, { cwd: options.cwd, @@ -311,7 +323,12 @@ function launchProcess(command, commandArgs, options, settled) { task.exitTimer.unref(); } }); - child.once("close", (code, signal) => { + child.once("close", (code, signal) => { void (async () => { + // A POSIX root can close before all live descendants have stopped. + // stop() owns the whole detached process group, so its result is not + // terminal until that group has no live members. waitForTask() keeps this + // confirmation bounded and retains the handle when it cannot be proven. + if (task.stopping) await waitForProcessGroupExit(child); task.settled = true; if (task.timer) clearTimeout(task.timer); if (task.exitTimer) clearTimeout(task.exitTimer); @@ -326,8 +343,23 @@ function launchProcess(command, commandArgs, options, settled) { } settled(); if (task.failure) reject(task.failure); - else resolve(Object.freeze({code: code == null ? null : code, signal: signal == null ? null : signal, stdout: Buffer.concat(task.stdout).toString("utf8"), stderr: Buffer.concat(task.stderr).toString("utf8")})); - }); + else resolve(Object.freeze({ + code: code == null ? null : code, + // taskkill reports an exit code rather than a POSIX signal. The public + // Process contract reports the termination stop() requested, so callers + // get one portable answer instead of an OS implementation detail. + signal: signal == null && task.stopping && process.platform === "win32" ? "SIGTERM" : signal == null ? null : signal, + stdout: Buffer.concat(task.stdout).toString("utf8"), + stderr: Buffer.concat(task.stderr).toString("utf8"), + })); + })().catch((error) => { + if (!task.failure) task.failure = error instanceof Error ? error : new Error("Process group exit confirmation failed"); + task.settled = true; + if (task.timer) clearTimeout(task.timer); + if (task.exitTimer) clearTimeout(task.exitTimer); + settled(); + reject(task.failure); + }); }); }); task.timer = options.timeout === 0 ? null : setTimeout(() => { if (task.settled) return; diff --git a/packages/node/src/terminal-runtime.ts b/packages/node/src/terminal-runtime.ts index e3bca917..53a088f2 100644 --- a/packages/node/src/terminal-runtime.ts +++ b/packages/node/src/terminal-runtime.ts @@ -1,9 +1,8 @@ -// Application-facing proxy for the isolated fd terminal host. It captures all +// Application-facing proxy for the isolated terminal host. It captures all // validation, MessagePort and Worker operations before application code runs; -// stdin decoding and fd writes live in terminal-worker-runtime.ts. +// stdin ownership, decoding, and fd writes live in terminal-worker-runtime.ts. export const VELAR_NODE_TERMINAL_RUNTIME = String.raw` import { EventEmitter as __VelarTerminalEventEmitter } from "node:events"; -import { closeSync as __velarTerminalCloseSync, openSync as __velarTerminalOpenSync } from "node:fs"; import { MessageChannel as __VelarTerminalMessageChannel, MessagePort as __VelarTerminalMessagePort, Worker as __VelarTerminalWorker } from "node:worker_threads"; const __velarTerminalNativeArray = globalThis.Array; @@ -155,10 +154,6 @@ function __velarTerminalFail(error) { __velarTerminalExpectedWorkerExit = true; const terminated = __velarTerminalCall(__velarTerminalWorkerTerminate, __velarTerminalWorker, []); __velarTerminalCall(__velarTerminalPromiseThen, terminated, [() => null, () => null]); - if (__velarTerminalInputDescriptor >= 0 && __velarTerminalProcess.platform !== "win32") { - try { __velarTerminalCloseSync(__velarTerminalInputDescriptor); } catch {} - __velarTerminalInputDescriptor = -1; - } } function __velarTerminalMessage(value) { @@ -180,14 +175,6 @@ function __velarTerminalMessage(value) { } __velarTerminalClosing = false; __velarTerminalUpdateReference(); - if (__velarTerminalInputDescriptor >= 0 && __velarTerminalProcess.platform !== "win32") { - try { __velarTerminalCloseSync(__velarTerminalInputDescriptor); } - catch (error) { - const code = error && typeof error === "object" ? __velarTerminalOwnDescriptor(error, "code") : null; - if (!code || !("value" in code) || code.value !== "EBADF") throw error; - } - __velarTerminalInputDescriptor = -1; - } __velarTerminalCall(__velarTerminalMessagePortClose, __velarTerminalPort, []); __velarTerminalExpectedWorkerExit = true; const terminated = __velarTerminalCall(__velarTerminalWorkerTerminate, __velarTerminalWorker, []); @@ -221,15 +208,6 @@ const __velarTerminalReadyPromise = new __velarTerminalNativePromise((resolve, r }); const __velarTerminalChannel = new __VelarTerminalMessageChannel(); const __velarTerminalPort = __velarTerminalChannel.port1; -let __velarTerminalInputDescriptor = 0; -if (__velarTerminalProcess.platform !== "win32") { - try { __velarTerminalInputDescriptor = __velarTerminalOpenSync("/dev/fd/0", "r"); } - catch (error) { - const code = error && typeof error === "object" ? __velarTerminalOwnDescriptor(error, "code") : null; - if (!code || !("value" in code) || code.value !== "EACCES" && code.value !== "EBADF" && code.value !== "ENOENT") throw error; - __velarTerminalInputDescriptor = -1; - } -} __velarTerminalPort.onmessage = event => { try { __velarTerminalMessage(__velarTerminalCall(__velarTerminalMessageData, event, [])); } catch (error) { __velarTerminalFail(error); } @@ -238,7 +216,7 @@ __velarTerminalPort.onmessageerror = () => __velarTerminalFail(new __velarTermin __velarTerminalCall(__velarTerminalMessagePortStart, __velarTerminalPort, []); const __velarTerminalWorker = new __VelarTerminalWorker(WORKER_SOURCE, { eval: true, - workerData: {port: __velarTerminalChannel.port2, inputDescriptor: __velarTerminalInputDescriptor}, + workerData: {port: __velarTerminalChannel.port2}, transferList: [__velarTerminalChannel.port2], }); __velarTerminalCall(__velarTerminalEventOn, __velarTerminalWorker, ["error", error => __velarTerminalFail(error)]); diff --git a/packages/node/src/terminal-worker-runtime.ts b/packages/node/src/terminal-worker-runtime.ts index 6d074f32..3a40f5f0 100644 --- a/packages/node/src/terminal-worker-runtime.ts +++ b/packages/node/src/terminal-worker-runtime.ts @@ -1,24 +1,53 @@ -// Isolated fd-based terminal host. The worker never loads application code or -// packages; it owns stdin decoding and stdout/stderr writes below Node's shared -// Readable/Writable/EventEmitter prototypes. +const VELAR_NODE_TERMINAL_INPUT_SOURCE = String.raw` +process.stdin.pause(); +process.on("error", () => process.exit(0)); +const send = value => { + if (process.connected && typeof process.send === "function") { + process.send(value, error => { if (error) process.exit(0); }); + } +}; +process.stdin.on("data", data => send({kind: "input-data", data})); +process.stdin.on("end", () => { send({kind: "input-end"}); process.disconnect(); }); +process.stdin.on("error", () => { send({kind: "input-error"}); process.disconnect(); }); +process.on("message", value => { + if (!value || typeof value !== "object") return; + if (value.kind === "input-state" && typeof value.active === "boolean") { + if (value.active) process.stdin.resume(); + else process.stdin.pause(); + } else if (value.kind === "close") { + process.stdin.pause(); + process.exit(0); + } +}); +process.on("disconnect", () => process.exit(0)); +send({kind: "ready"}); +`.trimStart(); + +// Isolated terminal host. The Worker never loads application code or packages; +// an on-demand child owns the inherited stdin handle so a blocking pipe read is +// cancellable without exposing application-Realm stream prototypes. export const VELAR_NODE_TERMINAL_WORKER_SOURCE = String.raw` import { Buffer } from "node:buffer"; -import { createReadStream, write } from "node:fs"; +import { spawn } from "node:child_process"; +import { write } from "node:fs"; import { StringDecoder } from "node:string_decoder"; import { isatty } from "node:tty"; import { workerData } from "node:worker_threads"; const port = workerData.port; +const inputHostSource = ${JSON.stringify(VELAR_NODE_TERMINAL_INPUT_SOURCE)}; const maxTextBytes = 1024 * 1024; const maxQueuedLines = 256; const decoder = new StringDecoder("utf8"); -const inputDescriptor = workerData.inputDescriptor; const waiting = []; const queued = []; -let input = null; let queuedBytes = 0; let queueOverflowed = false; -let closed = inputDescriptor < 0; +let closed = false; +let inputHost = null; +let inputHostReady = false; +let inputHostEnded = false; +let inputHostActive = false; let failure = null; let lineParts = []; let lineBytes = 0; @@ -38,6 +67,53 @@ function respond(id, ok, value, error = null) { port.postMessage({kind: "response", id, ok, value, error}); } +function referenceInputHost(active) { + if (inputHost === null) return; + if (active) { + inputHost.ref(); + inputHost.channel?.ref(); + } else { + inputHost.channel?.unref(); + inputHost.unref(); + } +} + +function ensureInputHost() { + if (inputHost !== null || closed) return inputHost; + inputHost = spawn(process.execPath, ["--input-type=module", "--eval", inputHostSource], { + stdio: ["inherit", "ignore", "inherit", "ipc"], + serialization: "advanced", + windowsHide: true, + }); + inputHost.on("message", value => { + try { + if (!value || typeof value !== "object") throw new TypeError("Node terminal input host returned an invalid message"); + if (value.kind === "ready") { + inputHostReady = true; + inputHost.send({kind: "input-state", active: inputHostActive}); + } else if (value.kind === "input-data") acceptForwardedData(value); + else if (value.kind === "input-end") { inputHostEnded = true; endForwardedInput(); } + else if (value.kind === "input-error") { inputHostEnded = true; endForwardedInput(new Error("Terminal input failed")); } + else throw new TypeError("Node terminal input host returned an invalid message"); + } catch (error) { settleInput(error); } + }); + inputHost.on("error", error => settleInput(error)); + inputHost.on("exit", code => { + if (!closed && !inputHostEnded) settleInput(new Error("Node terminal input host exited unexpectedly with code " + code)); + }); + referenceInputHost(false); + return inputHost; +} + +function requestForwardedInput(active) { + if (closed || inputHostActive === active) return; + inputHostActive = active; + const host = active ? ensureInputHost() : inputHost; + if (host === null) return; + referenceInputHost(active); + if (inputHostReady) host.send({kind: "input-state", active}); +} + function requestOf(value) { if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Node terminal host received an invalid request"); const keys = Object.keys(value); @@ -79,6 +155,7 @@ function deliver(entry) { if (request) { if (entry.error) respond(request.id, false, null, errorRecord(entry.error)); else respond(request.id, true, entry.value); + if (waiting.length === 0) requestForwardedInput(false); return; } if (queueOverflowed) return; @@ -94,7 +171,7 @@ function deliver(entry) { } queued.push(entry); queuedBytes += entry.bytes; - input?.pause(); + requestForwardedInput(false); } function appendLine(text, start, end) { @@ -148,6 +225,7 @@ function settleInput(error = null) { if (closed) return; closed = true; failure = error; + requestForwardedInput(false); while (waiting.length > 0) { const request = waiting.shift(); if (error) respond(request.id, false, null, errorRecord(error)); @@ -155,29 +233,6 @@ function settleInput(error = null) { } } -function ensureInput() { - if (input !== null || closed) return input; - input = createReadStream("", {fd: inputDescriptor, autoClose: false}); - input.on("data", chunk => { - if (closed) return; - try { consume(decoder.write(chunk)); } - catch (error) { settleInput(error); input?.destroy(); return; } - if (waiting.length === 0) input?.pause(); - }); - input.on("error", error => settleInput(error)); - input.on("end", () => { - if (closed) return; - try { - const tail = decoder.end(); - if (tail) consume(tail); - if (lineParts.length > 0 || lineOverflowed) completeLine(); - settleInput(); - } catch (error) { settleInput(error); } - }); - input.pause(); - return input; -} - function acceptRead(id) { if (queued.length > 0) { const entry = queued.shift(); @@ -189,10 +244,26 @@ function acceptRead(id) { } if (failure) { respond(id, false, null, errorRecord(failure)); return; } if (closed) { respond(id, true, null); return; } - const stream = ensureInput(); - if (stream === null) { respond(id, true, null); return; } waiting.push({id}); - stream.resume(); + requestForwardedInput(true); +} + +function acceptForwardedData(value) { + if (closed || !value || typeof value !== "object" || !(value.data instanceof Uint8Array) + || value.data.byteLength > maxTextBytes) { + throw new TypeError("Node terminal host received invalid forwarded input"); + } + consume(decoder.write(value.data)); + if (waiting.length === 0) requestForwardedInput(false); +} + +function endForwardedInput(error = null) { + if (closed) return; + if (error !== null) { settleInput(error); return; } + const tail = decoder.end(); + if (tail) consume(tail); + if (lineParts.length > 0 || lineOverflowed) completeLine(); + settleInput(); } async function dispatch(value) { @@ -218,11 +289,10 @@ function closeInput() { while (waiting.length > 0) waiting.shift(); while (queued.length > 0) queued.shift(); queuedBytes = 0; - if (input === null || input.closed || input.destroyed) { - port.postMessage({kind: "closed", error: null}); - return; + requestForwardedInput(false); + if (inputHost !== null) { + try { inputHost.send({kind: "close"}); } catch {} } - input.destroy(); port.postMessage({kind: "closed", error: null}); } @@ -236,5 +306,6 @@ port.on("message", value => { }); port.on("messageerror", () => { throw new Error("Node terminal host received an unreadable request"); }); port.start(); +process.once("exit", () => { if (inputHost !== null) inputHost.kill("SIGKILL"); }); port.postMessage({kind: "ready", interactive: isatty(0) && isatty(1)}); `.trimStart(); diff --git a/packages/web/src/analyzer.ts b/packages/web/src/analyzer.ts index b7d57984..da6666be 100644 --- a/packages/web/src/analyzer.ts +++ b/packages/web/src/analyzer.ts @@ -27,6 +27,7 @@ import { type ValueType, } from "@velarscript/compiler/extension"; import { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX, browserTestImportGuidance } from "./browser-test.ts"; +import { cssTokens } from "./css-tokens.ts"; import { LOOK_ABSENT_MEDIA_SUBJECTS, LOOK_ARITHMETIC_HINT, @@ -660,11 +661,13 @@ function lookConditionTermCount(expression: Expression, negated = false): number } function firstRelativeCssUrl(source: string): string | null { - const withoutComments = source.replace(/\/\*[\s\S]*?\*\//gu, ""); - const pattern = /url\(\s*(["']?)([^"')]+)\1\s*\)/giu; - for (const match of withoutComments.matchAll(pattern)) { - const value = match[2]!.trim(); - if (value.startsWith("/") || value.startsWith("#") || value.startsWith("//") || /^[a-z][a-z0-9+.-]*:/iu.test(value)) continue; + for (const token of cssTokens(source)) { + if (token.kind !== "url") continue; + // A URL parser drops leading and trailing spaces, and an empty url() names + // the document itself rather than an asset. + const value = token.value.trim(); + if (value === "") continue; + if (value.startsWith("/") || value.startsWith("#") || /^[a-z][a-z0-9+.-]*:/iu.test(value)) continue; return value; } return null; @@ -698,28 +701,10 @@ function lookAdditiveType(left: ValueType, right: ValueType): ValueType | null { } function containsCssImport(source: string): boolean { - let sanitized = ""; - let quote = ""; - let blockComment = false; - for (let index = 0; index < source.length; index += 1) { - const character = source[index]!; - const next = source[index + 1] ?? ""; - if (blockComment) { - if (character === "*" && next === "/") { blockComment = false; sanitized += " "; index += 1; } - else sanitized += character === "\n" ? "\n" : " "; - continue; - } - if (quote) { - if (character === "\\") { sanitized += " "; index += 1; continue; } - if (character === quote) quote = ""; - sanitized += " "; - continue; - } - if (character === "/" && next === "*") { blockComment = true; sanitized += " "; index += 1; continue; } - if (character === "\"" || character === "'") { quote = character; sanitized += " "; continue; } - sanitized += character; + for (const token of cssTokens(source)) { + if (token.kind === "at-keyword" && token.name.toLowerCase() === "import") return true; } - return /(^|[;}\s])@import\b/iu.test(sanitized); + return false; } function checkRouteComponent(type: ValueType, sourceSpan: Span, subject: string, context: CompilerIntrinsicAnalysisContext): void { diff --git a/packages/web/src/ast.ts b/packages/web/src/ast.ts index 38077035..52be9bab 100644 --- a/packages/web/src/ast.ts +++ b/packages/web/src/ast.ts @@ -216,6 +216,49 @@ export type WebAwareExpression = CoreExpression | WebExpression; export type WebAwareStatement = CoreStatement | WebStatement; export type WebOwnedStatement = WebStatement | WebExposeDeclaration | WebMountedBlock | WebCleanupBlock; +/** + * D56 rule 129 — the Web extension's half of the statement-construct roster + * Core publishes as `CORE_STATEMENT_CONSTRUCTS`, reached through the extension + * protocol's `syntax` slot so the tour-coverage gate can require an + * extension's constructs without being taught this package's node names. + * + * `unsafe-css` contributes two keys rather than one because its `source` is a + * tagged union this package already owns: the external import and the inline + * block are two spellings the AST tells apart on its own. Requiring only the + * kind would let D53 rule 117's inline block hide behind the `import css + * unsafe` that predates it, which is exactly how the block reached a release + * with no example anywhere in `examples/`. + */ +export type WebStatementConstructKey = + | Exclude + | `ExtensionStatement:web:unsafe-css/${WebUnsafeCssSource["kind"]}`; + +export const WEB_STATEMENT_CONSTRUCTS = Object.freeze({ + "ExtensionStatement:web:component": "component Name:", + "ExtensionStatement:web:state": "state name = value", + "ExtensionStatement:web:computed": "computed name = value", + "ExtensionStatement:web:resource": "resource name = load()", + "ExtensionStatement:web:action": "action name():", + "ExtensionStatement:web:watch": "watch value as current:", + "ExtensionStatement:web:expose": "expose {member}", + "ExtensionStatement:web:mounted": "@mounted:", + "ExtensionStatement:web:cleanup": "@cleanup:", + "ExtensionStatement:web:unsafe-css/external": 'import css unsafe "./sheet.css" before look', + "ExtensionStatement:web:unsafe-css/inline": "unsafe css`…` after look", +} satisfies { readonly [Key in WebStatementConstructKey]: string }); + +/** + * The construct key of one parsed node, or null when this extension does not + * own it. The gate walks every node in a module and asks each installed + * extension, so this has to answer for Core nodes and for another extension's + * nodes without knowing them. + */ +export function webStatementConstructKey(node: { readonly kind: string }): WebStatementConstructKey | null { + if (!node.kind.startsWith("ExtensionStatement:web:")) return null; + if (node.kind !== "ExtensionStatement:web:unsafe-css") return node.kind as WebStatementConstructKey; + return `${node.kind}/${(node as WebUnsafeCssDeclaration).source.kind}`; +} + export function isWebStatement(statement: Statement | WebComponentItem): statement is WebOwnedStatement { return statement.kind.startsWith("ExtensionStatement:web:"); } diff --git a/packages/web/src/compiler.ts b/packages/web/src/compiler.ts index 8fbf8ff2..7193579b 100644 --- a/packages/web/src/compiler.ts +++ b/packages/web/src/compiler.ts @@ -1,6 +1,7 @@ import { optionalOf as optional, type ClassInfo, type CompilerExtension, type EnumInfo, type ModuleInterface, type ValueType } from "@velarscript/compiler"; import type { AnalysisContext, CompilerAnalysisExtension, CompilerEmitterOptions, CompilerLexicalExtension, LoweringHints, Token } from "@velarscript/compiler/extension"; import { inferWebIntrinsic, routeContextIdentity, VelarWebAnalyzer } from "./analyzer.ts"; +import { WEB_STATEMENT_CONSTRUCTS, webStatementConstructKey } from "./ast.ts"; import { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX, browserTestDrivingGuidance } from "./browser-test.ts"; import { WEB_VOID_ELEMENTS } from "./elements.ts"; import { WebJavaScriptEmitter } from "./emitter.ts"; @@ -566,6 +567,13 @@ export const velarCompilerExtension: CompilerExtension = Object.freeze({ return new VelarWebParser(tokens, lexicalExtensions); }, }), + // D56 rule 129: the parser above adds eleven statement constructs to the + // language, and a coverage gate that only reads vocabulary tables cannot see + // one of them. This is how they are required of `examples/tour/`. + syntax: Object.freeze({ + statementConstructs: WEB_STATEMENT_CONSTRUCTS, + statementConstructKey: webStatementConstructKey, + }), analyzer: Object.freeze({ create(context: AnalysisContext, extensions: readonly CompilerAnalysisExtension[]) { return new VelarWebAnalyzer(context, extensions); diff --git a/packages/web/src/css-tokens.ts b/packages/web/src/css-tokens.ts new file mode 100644 index 00000000..d64572a0 --- /dev/null +++ b/packages/web/src/css-tokens.ts @@ -0,0 +1,296 @@ +/** + * CSS token scanning for the D53 unsafe-CSS gates. + * + * Both gates ask a question about CSS *tokens*: "does this stylesheet declare + * an `@import` at-rule" and "does a `url()` name a relative address". Text + * scanning answers neither, and it fails in both directions at once: a `)` + * inside a quoted URL ends a regex match early, so `url("./mark).svg")` — a + * legal reference to a legal filename — matches nothing and walks past the + * gate into a production build that 404s; while a `url(...)` written inside a + * string literal, which is text and not a reference at all, matches and gets + * refused. One scanner, reading the token grammar, is what both gates need, + * so both read the stream produced here instead of writing a private regex. + * + * Coverage is CSS Syntax Level 3 tokenization as far as those two questions + * reach: comments, strings (escapes, line continuations, bad-string), ident + * sequences, at-keywords, function tokens, and both url forms (the unquoted + * url-token and the `url(` function over a string), including bad-url + * recovery. Selectors, declarations, at-rule blocks, and numeric detail stay + * unparsed — CSS remains raw and unowned under D53, and this is a reader of + * addresses, not a CSS parser. + */ + +/** A token one of the unsafe-CSS gates asks about. */ +export type CssToken = + /** `@import`, `@media`, … — the at-rule name, escapes already decoded. */ + | { readonly kind: "at-keyword"; readonly name: string } + /** A `url()` address, escapes decoded, exactly what a browser resolves. */ + | { readonly kind: "url"; readonly value: string }; + +const REPLACEMENT = "�"; +const MAXIMUM_CODE_POINT = 0x10_ff_ff; + +function isNewline(character: string): boolean { + return character === "\n" || character === "\r" || character === "\f"; +} + +function isWhitespace(character: string): boolean { + return character === " " || character === "\t" || isNewline(character); +} + +function isDigit(character: string): boolean { + return character >= "0" && character <= "9"; +} + +function isHexDigit(character: string): boolean { + return isDigit(character) || (character >= "a" && character <= "f") || (character >= "A" && character <= "F"); +} + +function isIdentStartCodePoint(character: string): boolean { + return (character >= "a" && character <= "z") + || (character >= "A" && character <= "Z") + || character === "_" + || character.charCodeAt(0) >= 0x80; +} + +function isIdentCodePoint(character: string): boolean { + return isIdentStartCodePoint(character) || isDigit(character) || character === "-"; +} + +/** U+0000–U+0008, U+000B, U+000E–U+001F, U+007F: these end a url token. */ +function isNonPrintable(character: string): boolean { + const code = character.charCodeAt(0); + return code <= 0x08 || code === 0x0b || (code >= 0x0e && code <= 0x1f) || code === 0x7f; +} + +class CssScanner { + private index = 0; + private readonly source: string; + + constructor(source: string) { + this.source = source; + } + + *tokens(): Generator { + while (this.index < this.source.length) { + const character = this.source[this.index]!; + if (character === "/" && this.source[this.index + 1] === "*") { + this.consumeComment(); + continue; + } + if (character === "\"" || character === "'") { + this.consumeString(character); + continue; + } + if (character === "@" && this.startsIdentSequence(this.index + 1)) { + this.index += 1; + yield { kind: "at-keyword", name: this.consumeIdentSequence() }; + continue; + } + if (isDigit(character)) { + // A number's trailing ident sequence is a unit, never a function: the + // `px` of `20px` must not be read as the head of a `url(`-alike. + this.consumeNumeric(); + continue; + } + if (this.startsIdentSequence(this.index)) { + const url = this.consumeIdentLike(); + if (url !== null) yield { kind: "url", value: url }; + continue; + } + this.index += 1; + } + } + + private consumeComment(): void { + const end = this.source.indexOf("*/", this.index + 2); + this.index = end === -1 ? this.source.length : end + 2; + } + + /** The string's value, or null when a newline made it a bad-string. */ + private consumeString(quote: string): string | null { + this.index += 1; + let value = ""; + while (this.index < this.source.length) { + const character = this.source[this.index]!; + if (character === quote) { + this.index += 1; + return value; + } + if (isNewline(character)) return null; + if (character === "\\") { + const next = this.source[this.index + 1]; + if (next === undefined) { + this.index += 1; + return value; + } + if (isNewline(next)) { + this.index += 1; + if (next === "\r" && this.source[this.index + 1] === "\n") this.index += 1; + this.index += 1; + continue; + } + value += this.consumeEscape(); + continue; + } + value += character; + this.index += 1; + } + return value; + } + + /** Consumes `\` plus its escape and returns the code point it names. */ + private consumeEscape(): string { + this.index += 1; + const first = this.source[this.index]; + if (first === undefined) return REPLACEMENT; + if (!isHexDigit(first)) { + const text = String.fromCodePoint(this.source.codePointAt(this.index)!); + this.index += text.length; + return text; + } + let hex = ""; + while (hex.length < 6 && this.index < this.source.length && isHexDigit(this.source[this.index]!)) { + hex += this.source[this.index]!; + this.index += 1; + } + const trailing = this.source[this.index]; + if (trailing !== undefined && isWhitespace(trailing)) { + if (trailing === "\r" && this.source[this.index + 1] === "\n") this.index += 1; + this.index += 1; + } + const code = Number.parseInt(hex, 16); + if (code === 0 || code > MAXIMUM_CODE_POINT || (code >= 0xd8_00 && code <= 0xdf_ff)) return REPLACEMENT; + return String.fromCodePoint(code); + } + + private isValidEscape(index: number): boolean { + if (this.source[index] !== "\\") return false; + const next = this.source[index + 1]; + return next === undefined || !isNewline(next); + } + + private startsIdentSequence(index: number): boolean { + const character = this.source[index]; + if (character === undefined) return false; + if (character === "-") { + const next = this.source[index + 1]; + if (next === undefined) return false; + if (isIdentStartCodePoint(next) || next === "-") return true; + return this.isValidEscape(index + 1); + } + if (isIdentStartCodePoint(character)) return true; + return this.isValidEscape(index); + } + + private consumeIdentSequence(): string { + let value = ""; + while (this.index < this.source.length) { + const character = this.source[this.index]!; + if (isIdentCodePoint(character)) { + value += character; + this.index += 1; + continue; + } + if (this.isValidEscape(this.index)) { + value += this.consumeEscape(); + continue; + } + break; + } + return value; + } + + private consumeNumeric(): void { + while (this.index < this.source.length && isDigit(this.source[this.index]!)) this.index += 1; + if (this.source[this.index] === "." && isDigit(this.source[this.index + 1] ?? "")) { + this.index += 1; + while (this.index < this.source.length && isDigit(this.source[this.index]!)) this.index += 1; + } + if (this.startsIdentSequence(this.index)) this.consumeIdentSequence(); + else if (this.source[this.index] === "%") this.index += 1; + } + + /** The address when this is a url token, null for every other ident. */ + private consumeIdentLike(): string | null { + const name = this.consumeIdentSequence(); + if (this.source[this.index] !== "(") return null; + this.index += 1; + if (name.toLowerCase() !== "url") return null; + let probe = this.index; + while (probe < this.source.length && isWhitespace(this.source[probe]!)) probe += 1; + const quote = this.source[probe]; + if (quote === "\"" || quote === "'") { + // `url( "…" )` is a function over a string, not a url token: the address + // is the string's value, so a `)` or a quote inside it is just content. + this.index = probe; + const value = this.consumeString(quote); + while (this.index < this.source.length && isWhitespace(this.source[this.index]!)) this.index += 1; + if (value === null || this.source[this.index] !== ")") return null; + this.index += 1; + return value; + } + return this.consumeUrlToken(); + } + + /** The unquoted url token's address, or null when it is a bad-url. */ + private consumeUrlToken(): string | null { + while (this.index < this.source.length && isWhitespace(this.source[this.index]!)) this.index += 1; + let value = ""; + while (this.index < this.source.length) { + const character = this.source[this.index]!; + if (character === ")") { + this.index += 1; + return value; + } + if (isWhitespace(character)) { + while (this.index < this.source.length && isWhitespace(this.source[this.index]!)) this.index += 1; + if (this.index >= this.source.length) return value; + if (this.source[this.index] === ")") { + this.index += 1; + return value; + } + this.consumeBadUrlRemnants(); + return null; + } + if (character === "\"" || character === "'" || character === "(" || isNonPrintable(character)) { + this.consumeBadUrlRemnants(); + return null; + } + if (character === "\\") { + if (this.isValidEscape(this.index)) { + value += this.consumeEscape(); + continue; + } + this.consumeBadUrlRemnants(); + return null; + } + value += character; + this.index += 1; + } + return value; + } + + private consumeBadUrlRemnants(): void { + while (this.index < this.source.length) { + if (this.source[this.index] === ")") { + this.index += 1; + return; + } + if (this.isValidEscape(this.index)) { + this.consumeEscape(); + continue; + } + this.index += 1; + } + } +} + +/** + * Yields the at-keyword and url tokens of a stylesheet. Every other token is + * still tokenized — that is the whole point, a string is skipped as a string + * and a comment as a comment — it is simply not reported. + */ +export function cssTokens(source: string): Generator { + return new CssScanner(source).tokens(); +} diff --git a/packages/web/src/inspection.ts b/packages/web/src/inspection.ts index c085b41d..53e40cc6 100644 --- a/packages/web/src/inspection.ts +++ b/packages/web/src/inspection.ts @@ -1,5 +1,4 @@ import { - type CompilerDependencyContext, type CompilerInspectionExtension, type CompilerInterfaceContext, type Expression, @@ -10,72 +9,9 @@ import { import { optionalOf } from "@velarscript/compiler"; import { LOOK_UNIT_TYPES } from "./look.ts"; import { exportedLookStaticValues, lookStaticIdentity } from "./look-static.ts"; -import { isWebExpression, isWebJsx, isWebKeyframes, isWebLook, isWebStatement, isWebUnit } from "./ast.ts"; +import { isWebJsx, isWebKeyframes, isWebLook, isWebStatement, isWebUnit } from "./ast.ts"; import { isWebComponentConstructor, isWebComputedExport, WEB_COMPUTED_EXPORT, webComponentConstructor, webNodeType } from "./types.ts"; -function visitDependencyExpression(expression: Expression, context: CompilerDependencyContext): boolean { - if (isWebLook(expression)) { - const visit = (entries: typeof expression.entries): void => { - for (const entry of entries) { - if (entry.kind === "LookProperty" || entry.kind === "LookSpread") context.visitExpression(entry.value); - else if (entry.kind === "LookIf") { - context.visitExpression(entry.condition); - visit(entry.thenEntries); - visit(entry.elseEntries); - } else visit(entry.entries); - } - }; - visit(expression.entries); - return true; - } - if (isWebKeyframes(expression)) { - for (const stop of expression.stops) for (const entry of stop.entries) context.visitExpression(entry.value); - return true; - } - if (isWebExpression(expression) && expression.kind === "ExtensionExpression:web:look-hook") return true; - if (isWebUnit(expression)) return true; - if (!isWebJsx(expression)) return false; - for (const attribute of expression.attributes) { - if (attribute.value && typeof attribute.value !== "string") context.visitExpression(attribute.value); - } - for (const child of expression.children) { - if (child.kind === "JSXExpressionChild") context.visitExpression(child.expression); - else if (child.kind === "ExtensionExpression:web:jsx") context.visitExpression(child); - } - return true; -} - -function visitDependencyStatement(statement: Statement, context: CompilerDependencyContext): boolean { - if (!isWebStatement(statement)) return false; - switch (statement.kind) { - case "ExtensionStatement:web:component": - for (const parameter of statement.parameters) if (parameter.defaultValue) context.visitExpression(parameter.defaultValue); - for (const item of statement.body) { - if (item.kind === "ExtensionStatement:web:mounted" || item.kind === "ExtensionStatement:web:cleanup") context.visitBlock(item.body); - else if (item.kind === "ExtensionStatement:web:expose") context.visitExpression(item.value); - else context.visitStatement(item); - } - return true; - case "ExtensionStatement:web:state": - case "ExtensionStatement:web:computed": - case "ExtensionStatement:web:resource": - context.visitExpression(statement.initializer); - return true; - case "ExtensionStatement:web:action": - for (const parameter of statement.parameters) if (parameter.defaultValue) context.visitExpression(parameter.defaultValue); - context.visitBlock(statement.body); - return true; - case "ExtensionStatement:web:watch": - context.visitExpression(statement.expression); - context.visitBlock(statement.body); - return true; - case "ExtensionStatement:web:unsafe-css": - return true; - default: - return false; - } -} - function contributeInterface(statement: Statement, context: CompilerInterfaceContext): boolean { if (!isWebStatement(statement)) return false; if (statement.kind === "ExtensionStatement:web:action") { @@ -132,8 +68,6 @@ function contributeInterface(statement: Statement, context: CompilerInterfaceCon } export const velarWebInspectionExtension: CompilerInspectionExtension = Object.freeze({ - visitDependencyExpression, - visitDependencyStatement, contributeInterface, exportAnnotations: exportedLookStaticValues, interfaceExportIdentity: (_name: string, value: unknown) => isWebComputedExport(value) ? "web:computed" : lookStaticIdentity(value), diff --git a/scripts/build-packages.mjs b/scripts/build-packages.mjs new file mode 100644 index 00000000..ea12cbb3 --- /dev/null +++ b/scripts/build-packages.mjs @@ -0,0 +1,44 @@ +import { spawn } from "node:child_process"; +import { dirname, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; +import { velarBuildOrder } from "./velar-packages.mjs"; + +/** + * Build every publishable workspace package that declares a build, in an order + * where each one follows the workspace packages it depends on. + * + * This replaces a literal npm script that chained six `npm run build + * --workspace …` invocations. That chain was a copy of what `packages/*` + * already says, and it was the third copy: `test:packages` packed a derived + * roster and then re-listed the same names by hand for its content checks and + * its clean install (A-024). A publishable package added to the workspace was + * packed on the day it existed and built on no day at all — so its `dist` was + * whatever the last manual build had left behind, or nothing. + * + * The order is derived, not preserved: `velarBuildOrder` reads each manifest's + * own `dependencies` and its own `scripts.build`. + */ + +const root = resolve(dirname(fileURLToPath(import.meta.url)), ".."); + +const order = await velarBuildOrder(root); +if (order.length === 0) throw new Error("no publishable workspace package declares a build script"); + +for (const package_ of order) { + await run(["run", "build", "--workspace", package_.name]); +} + +async function run(arguments_) { + const npm = process.env.npm_execpath; + const command = npm ? process.execPath : (process.platform === "win32" ? "npm.cmd" : "npm"); + const argv = npm ? [npm, ...arguments_] : arguments_; + const child = spawn(command, argv, { cwd: root, stdio: "inherit" }); + const code = await new Promise((resolveExit, rejectExit) => { + child.once("error", rejectExit); + child.once("exit", resolveExit); + }); + if (code !== 0) { + process.exitCode = code ?? 1; + throw new Error(`npm ${arguments_.join(" ")} failed (${code})`); + } +} diff --git a/scripts/check-documentation-examples.mjs b/scripts/check-documentation-examples.mjs index 3369fd96..dd972114 100644 --- a/scripts/check-documentation-examples.mjs +++ b/scripts/check-documentation-examples.mjs @@ -11,26 +11,42 @@ const root = resolve(dirname(fileURLToPath(import.meta.url)), ".."); // says how large the gap is; closing it needs the addresses, and a number // nobody can act on is halfway back to a silent gap. const detail = process.argv.includes("--partial"); +// Declared before the file walk below, which reports into it: `rootReadmes` +// pushes a failure when a checkout carries no README, and reaching that clause +// with `failures` still in its temporal dead zone crashed the gate with a +// ReferenceError instead of printing the failure it had just found. +const failures = []; const requested = process.argv.slice(2).filter((argument) => argument !== "--partial"); const files = requested.length > 0 ? requested.map((file) => resolve(file)) : [...await rootReadmes(root), ...await markdownFiles(join(root, "docs")), ...await packageReadmes(join(root, "packages"))]; -// Match the opening fence's exact backtick count so VelarScript layout-string -// examples may contain shorter Markdown fences as literal text. -const fence = /^(?`{3,})velar(?:[ \t]+(?[^\n]+))?[ \t]*\r?\n(?[\s\S]*?)^\k[ \t]*$/gmu; +// The fence *language* this gate owns. Everything about where a fence starts +// and ends is asked of the CommonMark scanner below rather than of a regex. +const VELAR_FENCE_LANGUAGE = "velar"; +// One Markdown line that may open or close a fence: up to three columns of +// indentation, then three or more backticks or tildes, then the info string. +const FENCE_LINE = /^(?[ \t]*)(?`{3,}|~{3,})(?.*)$/u; +// A line that *means* to open a VelarScript fence, whatever container it sits +// in. `>` is admitted so a block-quoted fence is recognised as a fence and +// reported by `unreadableVelarFences` rather than passing as ordinary prose. +const VELAR_FENCE_LINE = /^[ \t>]*(?:`{3,}|~{3,})[ \t]*velar(?:[ \t]|$)/u; // A fragment may declare the names it borrows in a Markdown comment standing // immediately before its fence — invisible to a reader, compiled by this gate. // D64 rule 167: the context a fragment needs in order to be checked in full is // context the reader does not need to see, so it goes here rather than being // spelled into the prose example. -const preambleComment = /^[ \t]*\r?$/gmu; +// It may be indented with its fence, up to the three columns CommonMark allows +// a fence — the comment has to stand immediately before the fence, so a rule +// that admits an indented fence and refuses an indented preamble would leave +// the comment unrecognised and therefore silently ignored, which is the same +// failure this gate is being repaired for. +const preambleComment = /^(?[ \t]{0,3})[ \t]*\r?$/gmu; // The diagnostic families the fragment rule reasons about; that rule, and why // each family is inherent to a fragment, is written out above // significantFragmentDiagnostics below. const UNRESOLVED_NAME_DIAGNOSTIC = "VEL3001"; const UNRESOLVED_TYPE_DIAGNOSTIC = "VEL4001"; const MODULE_RESOLUTION_PREFIX = "VEL6"; -const failures = []; let examples = 0; let fragments = 0; let declared = 0; @@ -47,18 +63,28 @@ const partialFences = []; for (const file of files) { const markdown = await readFile(file, "utf8"); - const preambles = preamblesIn(markdown, file); - for (const match of markdown.matchAll(fence)) { + const blocks = fencedCodeBlocks(markdown); + // A fence this scanner cannot reach is named, never skipped. The scanner's + // boundary is documented on fencedCodeBlocks; the whole point of A-022 is + // that an example nobody compiles must not also be an example nobody counts. + for (const unreadable of unreadableVelarFences(markdown, blocks)) { + failures.push(`${display(file)}:${unreadable.line}: this line opens a VelarScript fence inside a Markdown container this gate does not parse` + + " (a block quote, or a list item nested deeply enough to indent the fence four columns or more), so the example is never compiled." + + " Move it out of the container, or indent it at most three columns."); + } + const preambles = preamblesIn(markdown, file, blocks); + for (const block of blocks) { + if (block.language !== VELAR_FENCE_LANGUAGE) continue; examples += 1; - const metadata = (match.groups?.metadata ?? "").trim(); - const line = lineAt(markdown, match.index ?? 0); + const metadata = block.metadata; + const line = block.line; if (metadata !== "" && metadata !== "fragment") { failures.push(`${display(file)}:${line}: unknown VelarScript fence annotation '${metadata}'`); continue; } const fragment = metadata === "fragment"; if (fragment) fragments += 1; - const preamble = preambles.get(match.index ?? 0); + const preamble = preambles.get(block.openOffset); if (preamble !== undefined && !fragment) { failures.push(`${display(file)}:${line}: a velar-preamble comment stands before a complete example, which is already checked in full — delete the comment or mark the fence 'fragment'`); continue; @@ -67,7 +93,7 @@ for (const file of files) { // A declared preamble is compiled ahead of the fence's own text, so the // fragment resolves every name it borrows and is checked exactly as a // complete example is: no suppression, nothing typed `unknown` by default. - const source = `${preamble ?? ""}${match.groups?.source ?? ""}`; + const source = `${preamble ?? ""}${block.source}`; const suppress = fragment && preamble === undefined; // Every example — fragment or complete — is compiled as a whole module by @@ -150,23 +176,30 @@ function coverageReport() { * may separate them — so a comment that drifted away from its fence, or that * was never followed by one, is reported rather than silently ignored. */ -function preamblesIn(markdown, file) { +function preamblesIn(markdown, file, blocks) { const byFence = new Map(); // A preamble inside a code block is a preamble being *shown*, not declared — // this rule is written out in D64 itself, inside a fence, and documentation // about a mechanism must not trip the mechanism. - const quoted = codeBlockRanges(markdown); + const quoted = blocks.map((block) => [block.blockStart, block.blockEnd]); + // Keyed by the offset of the fence's first backtick or tilde, which is where + // skipping whitespace after the comment lands whether or not the fence is + // indented. + const velarFences = new Map(blocks + .filter((block) => block.language === VELAR_FENCE_LANGUAGE) + .map((block) => [block.openOffset, block])); for (const match of markdown.matchAll(preambleComment)) { if (quoted.some(([start, end]) => (match.index ?? 0) >= start && (match.index ?? 0) < end)) continue; const after = (match.index ?? 0) + match[0].length; const fenceStart = after + (markdown.slice(after).match(/^\s*/u)?.[0].length ?? 0); - const opensFence = (fenceStart === 0 || markdown[fenceStart - 1] === "\n") - && /^`{3,}velar(?:[ \t]|\r?\n)/u.test(markdown.slice(fenceStart)); - if (!opensFence) { + if (!velarFences.has(fenceStart)) { failures.push(`${display(file)}:${lineAt(markdown, match.index ?? 0)}: a velar-preamble comment must stand immediately before a \`\`\`velar fence`); continue; } - const source = match.groups?.source ?? ""; + // Dedented by the comment's own indentation, the same way its fence's + // content is: the preamble is compiled ahead of the example, and + // VelarScript reads indentation as structure. + const source = dedent(match.groups?.source ?? "", (match.groups?.indent ?? "").length); byFence.set(fenceStart, source.endsWith("\n") ? source : `${source}\n`); } return byFence; @@ -332,10 +365,142 @@ async function packageReadmes(directory) { return files.sort(); } -/** Every fenced code block in a Markdown file, as `[start, end)` offsets. */ -function codeBlockRanges(markdown) { - const block = /^(?`{3,}|~{3,})[^\n]*\r?\n[\s\S]*?^\k[ \t]*$/gmu; - return [...markdown.matchAll(block)].map((match) => [match.index ?? 0, (match.index ?? 0) + match[0].length]); +// ─── Reading Markdown fences as CommonMark defines them ────────────────────── +// +// What this replaces was a regex: +// +// /^(?`{3,})velar…^\k[ \t]*$/gmu +// +// and it asserted three things CommonMark does not. That the opening backticks +// sit at column 0 — CommonMark allows up to three columns of indentation, which +// is how a fence inside a list item is written. That the closing fence has +// *exactly* the opening fence's length — CommonMark requires only that it be at +// least as long. And that a fence is made of backticks — tildes open one too. +// All three errors run the same way: a legal example the gate never saw, never +// compiled, and never counted, under a headline that said every block was +// checked (A-022). It is the shape A-002 found in the CSS asset regex, where a +// regex stood in for a syntax and was wrong in both directions at once. +// +// The scanner below is not a Markdown parser. It reads §4.5 (fenced code +// blocks) and nothing else, and it is deliberate about where that stops: +// +// - Block *containers* — block quotes, and list items nested deeply enough to +// push their content four or more columns in — are not parsed. Inside one, a +// fence's indentation is measured from the container, not from column 0, and +// this scanner cannot see the container. Such a fence is not silently +// skipped: `unreadableVelarFences` names it and the gate goes red. A gap +// nobody prints is a gap nobody closes (D56 rule 129), and the whole defect +// here was a gate that skipped examples quietly. +// - Tabs count as four columns for the *indentation* test, but the content +// stripping removes spaces only. A tab in the stripped prefix of a fence +// inside a list item is out of scope, and CommonMark itself calls partial +// tab expansion an edge case. +// - Link reference definitions, HTML blocks and setext underlines cannot open +// or close a fence, so ignoring them changes no verdict here. + +/** Indentation in columns, with tabs advancing to the next multiple of four. */ +function indentColumns(indent) { + let columns = 0; + for (const character of indent) columns = character === "\t" ? columns + 4 - (columns % 4) : columns + 1; + return columns; +} + +/** Up to `columns` leading spaces removed, which is what CommonMark strips. */ +function dedentLine(line, columns) { + let stripped = 0; + while (stripped < columns && line[stripped] === " ") stripped += 1; + return line.slice(stripped); +} + +/** `dedentLine` over every line of a block of text. */ +function dedent(text, columns) { + return columns === 0 ? text : text.split("\n").map((line) => dedentLine(line, columns)).join("\n"); +} + +/** + * Every fenced code block in a Markdown document, in source order. + * + * Each block reports `language` (the info string's first word), `metadata` + * (the rest of it), `source` (the content with the opening fence's indentation + * removed), `openOffset` (the fence character itself, which is what a preamble + * comment's whitespace skip lands on), `blockStart`/`blockEnd` (the whole + * block including both fence lines) and `line`. + */ +function fencedCodeBlocks(markdown) { + const blocks = []; + const lines = markdown.split("\n"); + let offset = 0; + let open = null; + let content = []; + for (const raw of lines) { + const start = offset; + offset += raw.length + 1; + const text = raw.endsWith("\r") ? raw.slice(0, -1) : raw; + const match = FENCE_LINE.exec(text); + const indented = match ? indentColumns(match.groups.indent) : 0; + if (open === null) { + if (!match || indented > 3) continue; + const info = match.groups.info.trim(); + // "Info strings for backtick code blocks cannot contain backticks." + if (match.groups.fence.startsWith("`") && info.includes("`")) continue; + const [language = "", ...rest] = info.split(/[ \t]+/u); + open = { + character: match.groups.fence[0], + length: match.groups.fence.length, + indent: match.groups.indent.length, + language, + metadata: rest.join(" "), + openOffset: start + match.groups.indent.length, + blockStart: start, + line: lineAt(markdown, start), + }; + content = []; + continue; + } + const closes = match + && indented <= 3 + && match.groups.fence[0] === open.character + && match.groups.fence.length >= open.length + && match.groups.info.trim() === ""; + if (closes) { + blocks.push({ ...open, source: content.map((line) => `${line}\n`).join(""), blockEnd: start + raw.length + 1 }); + open = null; + continue; + } + // CommonMark removes up to as many leading spaces as the opening fence had. + // Not cosmetic: VelarScript is indentation-sensitive, so an indented fence + // yields a compilable module only if that prefix comes back off every line. + content.push(dedentLine(text, open.indent)); + } + // "If the end of the containing block is reached and no closing code fence + // has been found, the code block contains all of the lines after the opening + // code fence until the end of the containing block." + if (open !== null) { + blocks.push({ ...open, source: content.map((line) => `${line}\n`).join(""), blockEnd: markdown.length }); + } + return blocks; +} + +/** + * Lines that open a VelarScript fence the scanner above did not take as one. + * Everything inside an extracted block is excluded, so a fence *shown* as the + * content of another block — this repository's own documentation of the + * mechanism does exactly that — is not reported. + */ +function unreadableVelarFences(markdown, blocks) { + // A block's range covers both of its fence lines, so a fence the scanner did + // take is excluded by the same test that excludes a fence being quoted. + const covered = blocks.map((block) => [block.blockStart, block.blockEnd]); + const unreadable = []; + let offset = 0; + for (const raw of markdown.split("\n")) { + const start = offset; + offset += raw.length + 1; + if (covered.some(([from, to]) => start >= from && start < to)) continue; + const text = raw.endsWith("\r") ? raw.slice(0, -1) : raw; + if (VELAR_FENCE_LINE.test(text)) unreadable.push({ line: lineAt(markdown, start) }); + } + return unreadable; } function lineAt(text, offset) { diff --git a/scripts/check-runtime-boundary.mjs b/scripts/check-runtime-boundary.mjs index 34bfbd1f..d5aecce1 100644 --- a/scripts/check-runtime-boundary.mjs +++ b/scripts/check-runtime-boundary.mjs @@ -1,4 +1,4 @@ -import { readFile, readdir } from "node:fs/promises"; +import { readFile as readRawFile, readdir } from "node:fs/promises"; import { dirname, join, relative, resolve } from "node:path"; import { fileURLToPath } from "node:url"; import { @@ -591,7 +591,6 @@ if (/\bPromise\.(?:race|resolve)\s*\(/u.test(nodeHostRuntimeSource) } for (const phrase of [ 'import { EventEmitter as __VelarTerminalEventEmitter } from "node:events"', - 'import { closeSync as __velarTerminalCloseSync, openSync as __velarTerminalOpenSync } from "node:fs"', 'import { MessageChannel as __VelarTerminalMessageChannel, MessagePort as __VelarTerminalMessagePort, Worker as __VelarTerminalWorker } from "node:worker_threads"', "const __velarTerminalMaxPending = 256", "const __velarTerminalMessagePortPost =", @@ -605,13 +604,16 @@ for (const phrase of [ } } for (const phrase of [ - 'import { createReadStream, write } from "node:fs"', + 'import { spawn } from "node:child_process"', + 'import { write } from "node:fs"', 'import { StringDecoder } from "node:string_decoder"', 'import { workerData } from "node:worker_threads"', + "const inputHostSource =", "const maxQueuedLines = 256", - 'function ensureInput()', - 'input = createReadStream("", {fd: inputDescriptor, autoClose: false})', - 'input.on("data", chunk =>', + 'spawn(process.execPath, ["--input-type=module", "--eval", inputHostSource]', + 'serialization: "advanced"', + 'host.send({kind: "input-state", active})', + 'process.once("exit", () => { if (inputHost !== null) inputHost.kill("SIGKILL"); })', "write(fd, data", "port.postMessage({kind: \"ready\", interactive: isatty(0) && isatty(1)})", ]) { @@ -1911,6 +1913,8 @@ for (const phrase of [ '"hostCommand": "request-cancel"', 'const activeRequests = new Map()', 'function cancelActivity(activity)', + 'function setActivityCancellation(activity, cancel)', + 'if (activity.cancelled) cancel()', 'let hostProjectDirectory = __VELAR_PROJECT_DIRECTORY__', 'private final class ProjectDirectoryGrant', 'let panel = NSOpenPanel()', @@ -1992,6 +1996,14 @@ async function sourceFiles(directory) { return files.sort(); } +async function readFile(path, encoding) { + const source = await readRawFile(path, encoding); + // This gate inspects source contracts, not a checkout's native line-ending + // convention. Normalize before matching multiline runtime templates so the + // same committed source answers identically on Windows, macOS, and Linux. + return typeof source === "string" ? source.replace(/\r\n?/gu, "\n") : source; +} + function escapeRegex(value) { return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"); } diff --git a/scripts/check-tour-coverage.mjs b/scripts/check-tour-coverage.mjs index 0afd7bca..42838b68 100644 --- a/scripts/check-tour-coverage.mjs +++ b/scripts/check-tour-coverage.mjs @@ -13,6 +13,7 @@ import { isNodeOnlyModule } from "@velarscript/node/compiler"; import { resolveVelarProject } from "../packages/cli/src/config.ts"; import { compileProject } from "../packages/cli/src/project.ts"; import { standardModuleInterfaces } from "../packages/cli/src/standard-modules.ts"; +import { CORE_STATEMENT_CONSTRUCTS } from "../packages/compiler/src/ast.ts"; import { Lexer } from "../packages/compiler/src/lexer.ts"; import { forbiddenSourceIdentifiers } from "../packages/compiler/src/source-names.ts"; import { keywordKinds } from "../packages/compiler/src/token.ts"; @@ -27,6 +28,18 @@ import { LOOK_ABSENT_MEDIA_SUBJECTS, LOOK_EXCLUDED_PROPERTIES, LOOK_HOOKS, LOOK_ * vocabulary tables* and asserts, name by name, that each one is exercised in * `examples/tour/`. A missing name is named in the failure. * + * Seventeen of the eighteen categories below ask about a **name**. The + * eighteenth asks about a **construct**, and it exists because names turned out + * not to be enough: D53 rule 117 added `extern js(…)` and `unsafe js` out of + * `extern`, `js`, and `unsafe` — three keywords chapter 13 already exercised + * through `extern module` and `import js unsafe` — so two new declaration forms + * reached a release with no `.vel` file anywhere using them while this gate + * stayed green. A construct assembled from covered spellings is invisible to a + * spelling-by-spelling check. `statement-construct` reads the AST unions + * themselves (`CORE_STATEMENT_CONSTRUCTS`, and each extension's own roster + * through the protocol's `syntax` slot) so a form the parser can return has to + * appear in the tour. + * * Two disciplines hold the whole thing up, and both are easy to lose: * * 1. **No hand-kept list.** Every required name below is read out of a @@ -111,6 +124,12 @@ const FLOORS = Object.freeze({ // D55 rule 120: `def` and `type`. A form removed from the roster without a // ruling drops this below its floor rather than quietly checking less. "generic-declaration": 2, + // The 26 members of `CoreStatement` plus the 11 the Web extension's parser + // adds — ten node kinds, and `unsafe css` twice because its `source` is a + // tagged union whose two spellings are separately required. Removing a + // statement form from the language is what may lower this; an extension that + // stops publishing `syntax` fails on its own terms above. + "statement-construct": 37, "look-property": 225, "look-hook": 9, "look-target": 7, @@ -181,7 +200,10 @@ const exemptions = [ names: () => new Set(["velar/javascript", "velar/text-buffer"]), // Module categories are keyed ' ', so a whole module is // withheld by its source. - matches: (names, key) => names.has(key.slice(0, key.indexOf(" "))), + // module-export keys carry their module; namespace-member keys do not, so + // a whole module is withheld from the first by source and the second is + // matched by its `Namespace.member` spelling. + matches: (names, key) => names.has(moduleExportSource(key)), }, { label: "`import js` naming a real third-party npm package", @@ -208,10 +230,25 @@ const exemptions = [ // `core-vocabulary.ts` now, alongside every other required table. The list is // left in place rather than deleted: an empty list is the claim that today // there is no vocabulary this gate cannot reach, and the next hole goes here. -const unreachableTables = []; +const unreachableTables = [ + { + label: "statement spellings that share one AST node kind", + reason: "`extern js(…)` and `unsafe js` are one EmbeddedJavaScriptDeclaration told apart by a boolean, " + + "and `const`/`let`, `def`/`async def`, `class`/`abstract class`, `for`/`async for` are the same shape. " + + "No compiler-owned table enumerates those splits, so this category requires the *kind*: the tour writes both " + + "inline blocks, but removing one would not turn this gate red. The Web extension's `unsafe css` is the " + + "exception and shows what closing it would take — its `source` is a tagged union, so both of its spellings " + + "are separately required. Closing the rest means giving those nodes a discriminated form in `packages/**`.", + }, +]; const failures = []; const categories = new Map(); +// Names a module imports and never references, keyed exactly as the required +// inventory keys them. An unused import is not coverage (see observeModule), +// but it is the most likely *reason* a name is missing, so the failure says +// where the dead import stands instead of leaving the reader to grep. +const unusedImports = new Map(); function require_(category, key, spelling, table) { const entry = categories.get(category) ?? { required: new Map(), covered: new Set() }; @@ -230,6 +267,32 @@ function observe(category, key) { entry.covered.add(key); } +/** + * Module categories are keyed by (module, name) rather than by name alone: + * `velar/http` publishes `secretHeader` on Node and `formBody` on the Web, and + * one target's table would otherwise overwrite the other's. The separator is a + * character no module source and no identifier can contain. It is built here + * rather than spelled at each site because the four places that write or read + * these keys have to agree, and a copy of a key format drifts as silently as a + * copy of a name list does. + */ +function moduleExportKey(source, name) { + return `${source}\u0000${name}`; +} + +/** The module half of a `moduleExportKey`. */ +function moduleExportSource(key) { + const separator = key.indexOf("\u0000"); + return separator < 0 ? key : key.slice(0, separator); +} + +function recordUnusedImport(imported, path) { + const key = moduleExportKey(imported.source, imported.imported); + const where = unusedImports.get(key) ?? new Set(); + unusedImports.set(key, where); + where.add(display(path)); +} + // ── 1. Read the tour exactly as the compiler reads it ─────────────────────── const projectRoots = (await tourProjectRoots(tourRoot)).sort(); @@ -305,7 +368,15 @@ for (const projectRoot of projectRoots) { failures.push(`${display(path)}: no import reaches this module and it is not a '*.test.vel' root, so the compiler never checks it — import it from the tour entry`); continue; } - observeModule({ path, text, tokens: lexed.tokens, program: parsed.program, index, contextualKeywords }); + observeModule({ + path, + text, + tokens: lexed.tokens, + program: parsed.program, + index, + contextualKeywords, + syntaxExtensions: extensions.flatMap((extension) => extension.syntax ? [extension.syntax] : []), + }); } } @@ -340,9 +411,7 @@ for (const exemption of exemptions) { let checked = 0; const summary = []; for (const [category, entry] of [...categories].sort()) { - const missing = [...entry.required] - .filter(([key]) => !entry.covered.has(key)) - .map(([, item]) => item); + const missing = [...entry.required].filter(([key]) => !entry.covered.has(key)); checked += entry.required.size; const floor = FLOORS[category]; if (floor === undefined) { @@ -351,8 +420,10 @@ for (const [category, entry] of [...categories].sort()) { failures.push(`Category '${category}' required only ${entry.required.size} names; expected at least ${floor}. A vocabulary table read short or empty.`); } summary.push(` ${category.padEnd(22)} ${String(entry.required.size - missing.length).padStart(4)}/${String(entry.required.size).padEnd(4)} from ${entry.required.size === 0 ? "-" : tablesOf(entry)}`); - for (const item of missing.sort((left, right) => left.spelling.localeCompare(right.spelling))) { - failures.push(`${category}: ${item.spelling} — declared by ${[...item.tables].sort().join(", ")}, and no module in ${display(tourRoot)} uses it`); + for (const [key, item] of missing.sort((left, right) => left[1].spelling.localeCompare(right[1].spelling))) { + const imported = unusedImports.get(key); + failures.push(`${category}: ${item.spelling} — declared by ${[...item.tables].sort().join(", ")}, and no module in ${display(tourRoot)} uses it` + + (imported ? ` (${[...imported].sort().join(", ")} import${imported.size === 1 ? "s" : ""} the name and never reference${imported.size === 1 ? "s" : ""} it — an import is not a usage)` : "")); } } @@ -420,6 +491,13 @@ function requireTargetVocabulary(config) { for (const suffix of CORE_NUMERIC_SUFFIXES) { require_("numeric-suffix", suffix, `1${suffix}`, "CORE_NUMERIC_SUFFIXES in packages/compiler/src/core-vocabulary.ts"); } + // D53 rule 117's blind spot: the only category here that names a construct + // instead of a name. The roster is a mapped type over the `CoreStatement` + // union, so a declaration form the parser can return cannot be absent from + // it, and a form nothing in the tour writes is named below. + for (const [kind, spelling] of Object.entries(CORE_STATEMENT_CONSTRUCTS)) { + require_("statement-construct", kind, spelling, "CORE_STATEMENT_CONSTRUCTS in packages/compiler/src/ast.ts"); + } for (const extension of extensions) { for (const word of extension.lexical?.contextualKeywords ?? []) { @@ -434,6 +512,16 @@ function requireTargetVocabulary(config) { for (const name of extension.analysis?.globals?.keys() ?? []) { require_("extension-global", name, name, `${extension.id} analysis.globals`); } + // An extension's statements never join `CoreStatement`, so its own roster + // is the only table that can name them. Owning a parser and publishing no + // roster is the silent version of the hole this category closes, so it is + // a failure rather than an empty contribution. + if (extension.parser !== undefined && extension.syntax === undefined) { + failures.push(`Extension '${extension.id}' registers a parser but publishes no 'syntax.statementConstructs', so the statement forms it adds cannot be required of the tour`); + } + for (const [key, spelling] of Object.entries(extension.syntax?.statementConstructs ?? {})) { + require_("statement-construct", key, spelling, `${extension.id} syntax.statementConstructs`); + } } // The standard modules this target admits, and every name each publishes. const capabilities = new Set(extensions.flatMap((extension) => extension.capabilities ?? [])); @@ -471,7 +559,7 @@ function requireTargetVocabulary(config) { const namespace = permanentNamespaceCoveringModule(source, interface_.exports.keys()); for (const name of names) { if (namespace) require_("namespace-member", `${namespace}.${name}`, `${namespace}.${name}`, `${source} (${target})`); - else require_("module-export", `${source}\u0000${name}`, `import {${name}} from "${source}"`, `${source} (${target})`); + else require_("module-export", moduleExportKey(source, name), `import {${name}} from "${source}"`, `${source} (${target})`); } if (source === BROWSER_TEST_MODULE) { for (const [controller, type] of interface_.exports) { @@ -486,7 +574,7 @@ function requireTargetVocabulary(config) { // ── What the tour actually contains, judged after lexing and parsing ─────── -function observeModule({ path, tokens, program, index, contextualKeywords }) { +function observeModule({ path, tokens, program, index, contextualKeywords, syntaxExtensions }) { // (a) Hard keywords: the lexer's own verdict. A keyword inside a string or a // comment never becomes a token, so this cannot be forged by prose. const keywordSpellings = new Map(Object.entries(keywordKinds).map(([spelling, kind]) => [kind, spelling])); @@ -512,13 +600,34 @@ function observeModule({ path, tokens, program, index, contextualKeywords }) { // (c) Standard-module exports: what the project driver resolved, not what // the import line says. A namespace import counts for the members it is // actually read through, so `collections.groupBy(...)` covers `groupBy`. - const namespaceLocals = new Map(); - const webTestControllerLocals = new Map(); + // + // And not off the import line *at all*. An import proves a name + // resolves; it shows no signature and no usage, while this gate's + // contract — and its own failure text — is that every name is + // *exercised*. The named branch counted the specifier itself, so + // deleting the only call to `watchVisibility` and leaving its import + // standing left this category reporting 237/237 (A-023). A named import + // now waits for a resolved reference to its local binding. + // + // Both branches are keyed by the import's *symbol*, never by its local + // spelling. The namespace branch did wait for a real member read, but it + // matched the read by name, so a local record named `urls` declared in + // any inner scope forged `velar/url`'s exports from a read of itself — + // the same forgery the header of this file says a text search would + // allow and a resolved judgment would not. + const referencedSymbols = new Set(index.references.flatMap((reference) => reference.symbolId === null ? [] : [reference.symbolId])); + // Every identifier the analyzer resolved, by the offset it was written at. A + // member access records its object as a reference, so this is what tells + // `collections.groupBy(...)` from a shadowing local's member of the same name. + const symbolAt = new Map(index.references.map((reference) => [reference.span.start, reference.symbolId])); + const namespaceSources = new Map(); + const webTestControllers = new Map(); for (const imported of index.imports) { - if (imported.namespace) namespaceLocals.set(imported.local, imported.source); + if (imported.namespace) namespaceSources.set(imported.localSymbolId, imported.source); else { - observe("module-export", `${imported.source}\u0000${imported.imported}`); - if (imported.source === BROWSER_TEST_MODULE) webTestControllerLocals.set(imported.local, imported.imported); + if (!referencedSymbols.has(imported.localSymbolId)) recordUnusedImport(imported, path); + else observe("module-export", moduleExportKey(imported.source, imported.imported)); + if (imported.source === BROWSER_TEST_MODULE) webTestControllers.set(imported.localSymbolId, imported.imported); } } @@ -541,9 +650,12 @@ function observeModule({ path, tokens, program, index, contextualKeywords }) { observe("reserved-binding", base); } } - const source = namespaceLocals.get(base); - if (source !== undefined) observe("module-export", `${source}\u0000${node.property}`); - const controller = webTestControllerLocals.get(base); + // Which binding this member sits on, by the analyzer's verdict rather + // than by its spelling: a namespace import's own symbol, or nothing. + const object = symbolAt.get(node.object.span.start); + const source = namespaceSources.get(object); + if (source !== undefined) observe("module-export", moduleExportKey(source, node.property)); + const controller = webTestControllers.get(object); if (controller !== undefined && path.endsWith(WEB_TEST_TOUR_CHAPTER)) { observe("web-test-member", `${BROWSER_TEST_MODULE}\u0000${controller}\u0000${node.property}`); } @@ -554,6 +666,18 @@ function observeModule({ path, tokens, program, index, contextualKeywords }) { observe("extension-global", node.name); observe("reserved-binding", node.name); } + // A construct counts when the *parser* built its node, which is the same + // standard the rest of this file holds names to: `unsafe js` written in a + // comment or a string never becomes a node. Core forms are keyed by node + // kind; an extension refines its own key, so an inline `unsafe css` block + // and the `import css unsafe` that shares its node kind stay two entries. + if (typeof node.kind === "string") { + observe("statement-construct", node.kind); + for (const syntax of syntaxExtensions) { + const key = syntax.statementConstructKey(node); + if (key !== null) observe("statement-construct", key); + } + } if (node.kind === "LookProperty") observe("look-property", node.name); if (node.kind === "LookTarget") observe("look-target", node.name); if (typeof node.unit === "string") observe("numeric-suffix", node.unit); diff --git a/scripts/velar-packages.d.mts b/scripts/velar-packages.d.mts index 60070c99..06995d00 100644 --- a/scripts/velar-packages.d.mts +++ b/scripts/velar-packages.d.mts @@ -1,13 +1,38 @@ +/** A workspace `package.json`, as far as the toolchain gates read it. */ +export interface VelarPackageManifest { + readonly name: string; + readonly version: string; + readonly private?: boolean; + readonly type?: string; + readonly license?: string; + readonly main?: string; + readonly types?: string; + readonly bin?: string | Record; + readonly exports?: unknown; + readonly files?: readonly string[]; + readonly scripts?: Record; + readonly dependencies?: Record; + readonly peerDependencies?: Record; + readonly velar?: { readonly entry?: string; readonly extension?: unknown }; +} + /** One workspace package as its own `package.json` declares it. */ export interface VelarWorkspacePackage { readonly name: string; readonly version: string; readonly directory: string; readonly private: boolean; + readonly manifest: VelarPackageManifest; } /** Every workspace package under `packages`, in name order. */ export function velarPackages(root?: string): Promise; +/** Every publishable workspace package, in name order. */ +export function velarPublishedPackages(root?: string): Promise; + /** The publishable package names a complete offline install needs. */ export function velarPackageNames(root?: string): Promise; + +/** The publishable packages that declare a build, dependencies first. */ +export function velarBuildOrder(root?: string): Promise; diff --git a/scripts/velar-packages.mjs b/scripts/velar-packages.mjs index bdac4b10..08bf6e41 100644 --- a/scripts/velar-packages.mjs +++ b/scripts/velar-packages.mjs @@ -20,6 +20,15 @@ import { fileURLToPath } from "node:url"; * Publishability is read from each manifest's own `private` flag, so a package * added to the workspace joins the toolchain the day it exists, and one that * must stay unpublished says so where it is defined. + * + * A-024: deriving the *names* was only the first consumer. `test:packages` + * packed this roster and then rewrote the same eight names by hand for the + * content checks and for the clean install, and `gate:build:packages` held a + * sixth copy as a literal npm script — so a new publishable package was packed + * on the day it existed and content-checked, installed and built on no day at + * all. Every consumer reads this module now, and each record carries its whole + * manifest so a consumer can ask what the package promises rather than + * remembering it. */ const workspaceRoot = resolve(dirname(fileURLToPath(import.meta.url)), ".."); @@ -47,13 +56,53 @@ export async function velarPackages(root = workspaceRoot) { version: manifest.version, directory, private: manifest.private === true, + manifest, }); } if (found.length === 0) throw new Error("no workspace packages found under packages/"); return found.sort((left, right) => left.name.localeCompare(right.name)); } +/** Every publishable workspace package — what a release set is made of. */ +export async function velarPublishedPackages(root = workspaceRoot) { + return (await velarPackages(root)).filter((entry) => !entry.private); +} + /** The names a complete offline install needs — the answer the old lists spelled out. */ export async function velarPackageNames(root = workspaceRoot) { - return (await velarPackages(root)).filter((entry) => !entry.private).map((entry) => entry.name); + return (await velarPublishedPackages(root)).map((entry) => entry.name); +} + +/** + * The publishable packages that have to be compiled, in an order where every + * package follows the workspace packages it depends on. + * + * Both facts are read from the manifests: a package is built when it declares a + * `build` script, and it waits for the workspace packages named in its own + * `dependencies`. The npm script this replaces named six workspaces in a fixed + * chain, which was correct and was a copy — a seventh compiled package would + * have been packed by the release gate without ever having been built. + */ +export async function velarBuildOrder(root = workspaceRoot) { + const packages = await velarPublishedPackages(root); + const byName = new Map(packages.map((entry) => [entry.name, entry])); + const order = []; + const placed = new Set(); + const visiting = new Set(); + const visit = (entry) => { + if (placed.has(entry.name)) return; + if (visiting.has(entry.name)) throw new Error(`workspace dependency cycle through ${entry.name}`); + visiting.add(entry.name); + for (const dependency of Object.keys(entry.manifest.dependencies ?? {}).sort()) { + const workspace = byName.get(dependency); + if (workspace) visit(workspace); + } + visiting.delete(entry.name); + placed.add(entry.name); + if (entry.manifest.scripts?.build) order.push(entry); + }; + // `velarPackages` sorts by name, so the traversal — and therefore the build + // order — is the same on every machine. + for (const entry of packages) visit(entry); + return order; } diff --git a/tests/ci.acceptance.ts b/tests/ci.acceptance.ts index 11edc69b..822023d1 100644 --- a/tests/ci.acceptance.ts +++ b/tests/ci.acceptance.ts @@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises"; import { relative, resolve } from "node:path"; import test from "node:test"; import { velarProjects } from "../scripts/velar-projects.mjs"; +import { repositoryRoot } from "./repository-root.ts"; /** * Expands the `npm run` links inside a script so a gate is checked by what it @@ -72,8 +73,8 @@ test("[D61-156] the test gates discover example projects instead of naming them" // ...and that the discovery reaches the projects a list would have to be // told about, `examples/app` first among them. - const root = resolve(new URL("..", import.meta.url).pathname); - const discovered = (await velarProjects(resolve(root, "examples"))).map((project: string) => relative(root, project)); + const root = repositoryRoot; + const discovered = (await velarProjects(resolve(root, "examples"))).map((project: string) => relative(root, project).replaceAll("\\", "/")); for (const project of ["examples/app", "examples/tour/core", "examples/tour/desktop", "examples/tour/web"]) { assert.ok(discovered.includes(project), `${project} is not discovered by the project gates; found ${discovered.join(", ")}`); } diff --git a/tests/compiler.test.ts b/tests/compiler.test.ts index 4b1c6297..b938c19b 100644 --- a/tests/compiler.test.ts +++ b/tests/compiler.test.ts @@ -143,7 +143,10 @@ function assertDevServerExit(exitCode: number | null, stderr: string): void { } async function stopDevServer(child: ReturnType): Promise { - if (child.exitCode !== null) return; + // A signal-terminated ChildProcess keeps exitCode null. Windows reaps the + // server with SIGKILL because it has no POSIX SIGTERM lifecycle, so the + // after-hook must recognize signalCode as an already observed exit too. + if (child.exitCode !== null || child.signalCode !== null) return; await new Promise((resolve, reject) => { const timer = setTimeout(() => { child.kill("SIGKILL"); @@ -153,7 +156,10 @@ async function stopDevServer(child: ReturnType): Promise { clearTimeout(timer); resolve(); }); - child.kill("SIGTERM"); + // Windows has no POSIX SIGTERM lifecycle. Its CI contract is that the + // spawned server can be reaped, while graceful signal drainage remains + // covered on the two POSIX runners. + child.kill(process.platform === "win32" ? "SIGKILL" : "SIGTERM"); }); } @@ -1760,8 +1766,8 @@ const target: Type = Decoder() const arity = compile("type User:\n name: string\n\nconst target: Type = User\n"); assert.ok(arity.diagnostics.some((item) => item.code === "VEL2012" && /expects 1 type argument/u.test(item.message))); - const libraryPath = "/tmp/velar-runtime-type-package/library.vel"; - const consumerPath = "/tmp/velar-runtime-type-package/consumer.vel"; + const libraryPath = join(tmpdir(), "velar-runtime-type-package", "library.vel"); + const consumerPath = join(tmpdir(), "velar-runtime-type-package", "consumer.vel"); const project = await compileProject(consumerPath, new Map([ [libraryPath, ` export def decode(value: unknown, target: Type) -> T: @@ -1796,8 +1802,8 @@ const accepted: bool = accepts(user, User) assert.equal(symbols?.find((item) => item.name === "role")?.type, "Role"); assert.equal(symbols?.find((item) => item.name === "accepted")?.type, "bool"); - const renamedLibraryPath = "/tmp/velar-runtime-type-renamed-package/library.vel"; - const renamedConsumerPath = "/tmp/velar-runtime-type-renamed-package/consumer.vel"; + const renamedLibraryPath = join(tmpdir(), "velar-runtime-type-renamed-package", "library.vel"); + const renamedConsumerPath = join(tmpdir(), "velar-runtime-type-renamed-package", "consumer.vel"); const renamedProject = await compileProject(renamedConsumerPath, new Map([ [renamedLibraryPath, ` export type User: @@ -1822,7 +1828,7 @@ const user: Person = target.parse({name: "Ada"}) assert.ok(targetSymbol?.members.some((member) => member.name === "parse" && member.type === "(value: unknown) -> Person")); assert.equal(renamedSymbols?.find((item) => item.name === "user")?.type, "Person"); - const namespaceConsumerPath = "/tmp/velar-runtime-type-renamed-package/namespace-consumer.vel"; + const namespaceConsumerPath = join(tmpdir(), "velar-runtime-type-renamed-package", "namespace-consumer.vel"); const namespaceProject = await compileProject(namespaceConsumerPath, new Map([ [renamedLibraryPath, ` export type User: @@ -4422,8 +4428,8 @@ print(status) assert.equal(wideningExecution.status, 0, String(wideningExecution.stderr)); assert.equal(wideningExecution.stdout, "2\ndone\n"); - const libraryPath = "/tmp/velar-discriminated-events/protocol.vel"; - const consumerPath = "/tmp/velar-discriminated-events/consumer.vel"; + const libraryPath = join(tmpdir(), "velar-discriminated-events", "protocol.vel"); + const consumerPath = join(tmpdir(), "velar-discriminated-events", "consumer.vel"); const librarySource = ` export enum EventKind: text @@ -15412,7 +15418,7 @@ export const velarProjectExtension = Object.freeze({id: "shadow-extension", mani await assert.rejects( resolveVelarProject(project), - /project\/node_modules\/shadow-extension\/package\.json: installed package manifest must be an ordinary file/u, + /project[\\/]node_modules[\\/]shadow-extension[\\/]package\.json: installed package manifest must be an ordinary file/u, ); }); @@ -20884,6 +20890,15 @@ test("CLI source maps lead runtime stacks back to .vel source", async () => { assert.match(execution.stderr, new RegExp(`${sourcePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:2:`)); }); +test("Windows source paths become valid source-map file URLs and portable diagnostics", () => { + const sourcePath = "C:\\Users\\author\\project\\main.vel"; + const result = compileCore("const answer = 42\n", { path: sourcePath }); + const map = JSON.parse(result.sourceMap ?? "{}") as { sources?: readonly string[] }; + assert.deepEqual(map.sources, ["file:///C:/Users/author/project/main.vel"]); + const invalid = compileCore('const answer: number = "wrong"\n', { path: sourcePath }); + assert.match(formatDiagnostic(invalid.source, invalid.diagnostics[0]!), /^C:\/Users\/author\/project\/main\.vel:1:/u); +}); + test("source maps retain nested statement and expression columns", () => { const result = compileCore(` def choose(value: number) -> number: diff --git a/tests/desktop-runtime.test.ts b/tests/desktop-runtime.test.ts index 1f02079a..8454d6cf 100644 --- a/tests/desktop-runtime.test.ts +++ b/tests/desktop-runtime.test.ts @@ -18,7 +18,9 @@ function registerRuntimeType(value: T): T { return value; } -test("Desktop renderer proxies preserve pull-based process and HTTP streaming", async () => { +test("Desktop renderer proxies preserve pull-based process and HTTP streaming", { + skip: process.platform === "win32" ? "the 0.10 Desktop host publishes POSIX paths on macOS" : false, +}, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-runtime-")); const calls: Array<{ capability: string; operation: string; args: readonly unknown[]; timeout: number }> = []; const processChunks = new Map(); @@ -29,6 +31,9 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", const pendingRequests = new Map(); const pendingProcessRead = { resolve: null as ((value: unknown) => void) | null }; const languageServerMessages = ['{"jsonrpc":"2.0","id":1,"result":null}']; + const projectChangeRecords = new Map>(); + const projectChangeUpdates: unknown[] = []; + let hostileProjectChangeReads = 0; const stopWaitRace = { reject: null as ((error: Error) => void) | null }; let pendingProcessReadDelivered = false; let hostileResponseReads = 0; @@ -50,6 +55,25 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", Object.defineProperty(error, "phase", { value: phase, enumerable: true }); return error; }; + const projectChangeRecord = (lifecycle: string, sequence: number): Record => ({ + transactionId: "tx-editor-1", + sequence, + lifecycle, + reason: null, + intents: [{type: "replace_text", path: "src/main.vel", from: null, to: null, targetId: null, reason: "test"}], + patches: [{patchId: "patch-1", strategyId: "text", path: "src/main.vel", baseRevision: null, diff: "-old\n+new", changedLines: 2, risk: "low", operation: "replace_text"}], + changedFiles: ["src/main.vel"], + diff: "-old\n+new", + changedLines: 2, + risk: "low", + revisions: [{path: "src/main.vel", before: "before", after: "after"}], + createdAt: 1, + updatedAt: sequence, + appliedAt: lifecycle === "applied" || lifecycle === "rolled_back" ? 2 : null, + }); + const preparedProjectChange = projectChangeRecord("prepared", 1); + projectChangeRecords.set("tx-editor-1", preparedProjectChange); + projectChangeUpdates.push({changes: [preparedProjectChange], rescan: false}); const bridge = Object.freeze({ platform: "test", packaged: false, @@ -88,6 +112,31 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", result: { code: 143, signal: null, stdout: "", stderr: "" }, error: null, }; + if (capability === "project-changes") { + if (operation === "start") return 3_000_000_000; + if (operation === "list") { + const values = [...projectChangeRecords.values()]; + return {changes: values.slice(0, args[1] as number), truncated: values.length > (args[1] as number)}; + } + if (operation === "get") { + if (args[1] === "hostile") { + return Object.defineProperty({...preparedProjectChange}, "transactionId", { + enumerable: true, + get() { hostileProjectChangeReads += 1; return "hostile"; }, + }); + } + return projectChangeRecords.get(args[1] as string) ?? null; + } + if (operation === "subscribe") return projectChangeUpdates.shift() ?? null; + if (operation === "apply" || operation === "rollback") { + const transactionId = args[1] as string; + if (!projectChangeRecords.has(transactionId)) throw new Error("unknown project transaction"); + const change = projectChangeRecord(operation === "apply" ? "applied" : "rolled_back", operation === "apply" ? 2 : 3); + projectChangeRecords.set(transactionId, change); + return change; + } + if (operation === "close") return null; + } if (capability === "terminal" && operation === "open") { const handle = nextTerminalHandle++; terminalChunks.set(handle, ["terminal output\n", null]); @@ -661,13 +710,38 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", languageServer(): Promise<{ send(message: string): Promise; next(): Promise; close(): Promise }>; ProjectTask: { is(value: unknown): boolean; parse(value: unknown): unknown }; ProjectTaskCommand: Readonly<{ - check: "check"; test: "test"; build: "build"; fix: "fix"; package: "package"; run: "run"; + check: "check"; test: "test"; browserTest: "browserTest"; build: "build"; fix: "fix"; package: "package"; run: "run"; is(value: unknown): boolean; parse(value: unknown): unknown; values(): string[]; }>; ProjectTaskOutputChannel: Readonly<{ stdout: "stdout"; stderr: "stderr"; is(value: unknown): boolean; parse(value: unknown): unknown; values(): string[]; }>; + ProjectChanges: { is(value: unknown): boolean; parse(value: unknown): unknown }; + ProjectChangeLifecycle: Readonly<{ + prepared: "prepared"; validationFailed: "validationFailed"; rolledBack: "rolledBack"; + is(value: unknown): boolean; parse(value: unknown): unknown; values(): string[]; + }>; + ProjectChangeRisk: Readonly<{ + low: "low"; medium: "medium"; high: "high"; + is(value: unknown): boolean; parse(value: unknown): unknown; values(): string[]; + }>; + projectChanges(): Promise<{ + list(limit?: number): Promise<{changes: Array<{ + transactionId: string; + lifecycle: string; + diff: string; + intents: unknown[]; + patches: unknown[]; + changedFiles: string[]; + revisions: unknown[]; + }>; truncated: boolean}>; + get(transactionId: string): Promise<{transactionId: string; lifecycle: string; diff: string} | null>; + subscribe(): Promise<{changes: Array<{transactionId: string; lifecycle: string}>; rescan: boolean} | null>; + apply(transactionId: string): Promise<{lifecycle: string}>; + rollback(transactionId: string): Promise<{lifecycle: string}>; + close(): Promise; + }>; startProjectTask(command: "check" | "test" | "build" | "fix" | "package" | "run", args?: string[], options?: { timeout?: number; maxOutputBytes?: number }): Promise<{ pid: number; next(): Promise<{ channel: "stdout" | "stderr"; text: string } | null>; @@ -710,7 +784,8 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", // D60 rule 149: the two Desktop enums answer all three names charter // section 6 reserves, not only their members. `values` was the gap, and it // threw `is not a function` from code that compiled clean. - assert.deepEqual(desktopRuntime.ProjectTaskCommand.values(), ["check", "test", "build", "fix", "package", "run"]); + assert.equal(desktopRuntime.ProjectTaskCommand.browserTest, "browserTest"); + assert.deepEqual(desktopRuntime.ProjectTaskCommand.values(), ["check", "test", "browserTest", "build", "fix", "package", "run"]); assert.deepEqual(desktopRuntime.ProjectTaskOutputChannel.values(), ["stdout", "stderr"]); assert.notEqual(desktopRuntime.ProjectTaskCommand.values(), desktopRuntime.ProjectTaskCommand.values()); assert.equal(desktopRuntime.ProjectTaskCommand.is("check"), true); @@ -720,6 +795,35 @@ test("Desktop renderer proxies preserve pull-based process and HTTP streaming", assert.equal(desktopRuntime.ProjectTaskOutputChannel.is("stderr"), true); assert.equal(desktopRuntime.ProjectTaskOutputChannel.parse("stdout"), "stdout"); assert.throws(() => desktopRuntime.ProjectTaskOutputChannel.parse("both")); + assert.equal(desktopRuntime.ProjectChangeLifecycle.validationFailed, "validationFailed"); + assert.equal(desktopRuntime.ProjectChangeLifecycle.rolledBack, "rolledBack"); + assert.deepEqual(desktopRuntime.ProjectChangeLifecycle.values(), ["prepared", "amended", "validated", "validationFailed", "applied", "rolledBack", "discarded"]); + assert.equal(desktopRuntime.ProjectChangeRisk.high, "high"); + assert.deepEqual(desktopRuntime.ProjectChangeRisk.values(), ["low", "medium", "high"]); + const projectChanges = await desktopRuntime.projectChanges(); + assert.equal(desktopRuntime.ProjectChanges.is(projectChanges), true); + assert.equal(desktopRuntime.ProjectChanges.parse(projectChanges), projectChanges); + const changePage = await projectChanges.list(); + assert.equal(changePage.truncated, false); + assert.equal(Object.isFrozen(changePage.changes), false); + assert.equal(Object.isFrozen(changePage.changes[0]?.intents), false); + assert.equal(Object.isFrozen(changePage.changes[0]?.patches), false); + assert.equal(Object.isFrozen(changePage.changes[0]?.changedFiles), false); + assert.equal(Object.isFrozen(changePage.changes[0]?.revisions), false); + assert.equal(changePage.changes[0]?.transactionId, "tx-editor-1"); + assert.equal(changePage.changes[0]?.lifecycle, "prepared"); + assert.equal(changePage.changes[0]?.diff, "-old\n+new"); + assert.equal((await projectChanges.get("tx-editor-1"))?.lifecycle, "prepared"); + assert.equal((await projectChanges.subscribe())?.changes[0]?.lifecycle, "prepared"); + assert.equal(calls.find((call) => call.capability === "project-changes" && call.operation === "subscribe")?.timeout, 0); + assert.equal((await projectChanges.apply("tx-editor-1")).lifecycle, "applied"); + assert.equal((await projectChanges.rollback("tx-editor-1")).lifecycle, "rolledBack"); + await assert.rejects(projectChanges.get("hostile"), /enumerable data values/u); + assert.equal(hostileProjectChangeReads, 0); + await assert.rejects(projectChanges.list(101), /integer from 1 through 100/u); + assert.equal(await projectChanges.close(), null); + assert.equal(await projectChanges.close(), null); + await assert.rejects(projectChanges.get("tx-editor-1"), /closed/u); await assert.rejects(desktopRuntime.startProjectTask(desktopRuntime.ProjectTaskCommand.check, ["--unsafe"]), /Only a run project task accepts/u); const projectTask = await desktopRuntime.startProjectTask(desktopRuntime.ProjectTaskCommand.check, [], { timeout: 5000, maxOutputBytes: 65536 }); assert.equal(projectTask.pid, 720); @@ -1108,6 +1212,23 @@ test("Desktop CLI test host provides deterministic manifest-scoped process handl stdout: "[desktop-test] git --version\n", stderr: "", }); + const projectChangesHandle = await bridge.invoke("project-changes", "start", []) as number; + const seededUpdate = bridge.invoke("project-changes", "subscribe", [projectChangesHandle]) as Promise<{changes: Array<{transactionId: string; lifecycle: string}>; rescan: boolean}>; + assert.equal(await bridge.invoke("project-change-test", "seed", ["tx-browser", "prepared", "-old\n+new"]), null); + const seeded = await seededUpdate; + assert.equal(seeded.rescan, false); + assert.equal(seeded.changes[0]?.transactionId, "tx-browser"); + assert.equal(seeded.changes[0]?.lifecycle, "prepared"); + const projectChangesPage = await bridge.invoke("project-changes", "list", [projectChangesHandle, 50]) as {changes: Array<{transactionId: string; lifecycle: string}>; truncated: boolean}; + assert.equal(projectChangesPage.truncated, false); + assert.equal(projectChangesPage.changes[0]?.transactionId, "tx-browser"); + const appliedUpdate = bridge.invoke("project-changes", "subscribe", [projectChangesHandle]) as Promise<{changes: Array<{lifecycle: string}>}>; + assert.equal((await bridge.invoke("project-changes", "apply", [projectChangesHandle, "tx-browser"]) as {lifecycle: string}).lifecycle, "applied"); + assert.equal((await appliedUpdate).changes[0]?.lifecycle, "applied"); + const rolledBackUpdate = bridge.invoke("project-changes", "subscribe", [projectChangesHandle]) as Promise<{changes: Array<{lifecycle: string}>}>; + assert.equal((await bridge.invoke("project-changes", "rollback", [projectChangesHandle, "tx-browser"]) as {lifecycle: string}).lifecycle, "rolled_back"); + assert.equal((await rolledBackUpdate).changes[0]?.lifecycle, "rolled_back"); + assert.equal(await bridge.invoke("project-changes", "close", [projectChangesHandle]), null); await assert.rejects(bridge.invoke("process", "start", ["sh", [], {}]), /not granted/u); }); diff --git a/tests/desktop-worker.test.ts b/tests/desktop-worker.test.ts index 7fce3a85..73dec96f 100644 --- a/tests/desktop-worker.test.ts +++ b/tests/desktop-worker.test.ts @@ -1,5 +1,6 @@ import assert from "node:assert/strict"; import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process"; +import { createHash } from "node:crypto"; import { createServer, type Server } from "node:http"; import { mkdir, mkdtemp, readdir, readFile, realpath, rm, stat, symlink, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; @@ -10,9 +11,12 @@ import { pathToFileURL } from "node:url"; import { buildLanguageServerTool } from "../packages/cli/src/language-server-tool.ts"; import { buildProjectTaskTool } from "../packages/cli/src/project-task-tool.ts"; import { buildBuildEngineTool } from "../packages/cli/src/build-engine-tool.ts"; +import { FileProjectChangeFeed } from "@velaros-ai/project/changes"; +import { createProjectKernel } from "@velaros-ai/project/runtime"; const workerPath = resolve("packages/desktop/native/node/worker.js"); const temporaryPrefix = join(tmpdir(), "velar-desktop-"); +const desktopWorkerTest = process.platform === "win32" ? test.skip : test; // Every wait in this suite is bounded. The worker speaks over stdio pipes and // drives real child processes, PTYs and OS file watchers, so a single reply @@ -148,7 +152,7 @@ async function runBoundedCommand(executable: string, args: readonly string[], ti return output; } -test("Desktop owns one packaged official language-server lifecycle without process grants", { timeout: 90_000 }, async () => { +desktopWorkerTest("Desktop owns one packaged official language-server lifecycle without process grants", { timeout: 90_000 }, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-language-server-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -231,9 +235,14 @@ test("Desktop owns one packaged official language-server lifecycle without proce assert.equal(escapedLinkLog.method, "window/logMessage"); assert.match(escapedLinkLog.params.message, /outside the Desktop project grant/u); - const cancelledPull = client.beginCall("language-server", "next", [handle]); - client.cancelRequest(cancelledPull.id); - await assert.rejects(cancelledPull.result, /pull was cancelled|request was cancelled/u); + for (let attempt = 0; attempt < 4; attempt += 1) { + const cancelledPull = client.beginCall("language-server", "next", [handle]); + client.cancelRequest(cancelledPull.id); + await assert.rejects( + withDeadline(cancelledPull.result, "cancelled language-server pull", 5_000), + /pull was cancelled|request was cancelled/u, + ); + } assert.equal(await client.call("language-server", "send", [handle, JSON.stringify({ jsonrpc: "2.0", method: "textDocument/didOpen", @@ -297,7 +306,10 @@ test("Desktop owns one packaged official language-server lifecycle without proce } }); -test("Desktop owns permission-scoped PTY terminals with resize and crash reaping", { timeout: 240_000 }, async () => { +desktopWorkerTest("Desktop owns permission-scoped PTY terminals with resize and crash reaping", { + timeout: 240_000, + skip: process.platform !== "darwin" ? "the 0.10 PTY host is the macOS Swift host" : false, +}, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-terminal-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -380,7 +392,7 @@ test("Desktop owns permission-scoped PTY terminals with resize and crash reaping } }); -test("Desktop owns bounded packaged project tasks without executable grants", { timeout: 240_000 }, async () => { +desktopWorkerTest("Desktop owns bounded packaged project tasks without executable grants", { timeout: 240_000 }, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-project-task-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -457,7 +469,87 @@ test("Desktop owns bounded packaged project tasks without executable grants", { } }); -test("Desktop Node capability host enforces filesystem, process, and network grants", { timeout: 120_000 }, async () => { +desktopWorkerTest("Desktop owns durable finite project changes across Worker restarts", { timeout: 120_000 }, async () => { + const directory = await mkdtemp(join(tmpdir(), "velar-desktop-project-changes-")); + const project = join(directory, "project"); + const appData = join(directory, "app-data"); + await Promise.all([mkdir(project), mkdir(appData)]); + const notePath = join(project, "note.txt"); + await writeFile(notePath, "before\n", "utf8"); + const canonicalProject = await realpath(project); + const privateDirectory = join(appData, "project-transactions", createHash("sha256").update(canonicalProject).digest("hex")); + const statePath = join(privateDirectory, "transactions.json"); + const feedPath = join(privateDirectory, "changes.jsonl"); + const feed = new FileProjectChangeFeed({path: feedPath}); + let transactionId = ""; + try { + const owner = await createProjectKernel({root: canonicalProject, changeFeed: feed, transactionStatePath: statePath}); + const prepared = await owner.prepareEdit({ + operations: [{ + reason: "Desktop finite project change transport", + operation: {type: "replace_text", path: "note.txt", oldText: "before", newText: "after"}, + }], + }); + transactionId = prepared.transactionId; + const validation = await owner.validate({transactionId}); + assert.equal(validation.ok, true); + } finally { + feed.close(); + } + + const configPath = join(directory, "desktop.json"); + await writeFile(configPath, JSON.stringify({ + protocolVersion: 1, + permissions: {files: ["project"], processes: [], terminal: false, network: [], environment: [], secrets: []}, + }), "utf8"); + const open = (): WorkerClient => new WorkerClient(spawn(process.execPath, [workerPath, configPath, appData, project], {stdio: ["pipe", "pipe", "pipe"]})); + let client = open(); + try { + let handle = await client.call("project-changes", "start", []) as number; + assert.ok(handle >= 3_000_000_000 && handle <= 3_000_000_015); + const page = await client.call("project-changes", "list", [handle, 50]) as { + changes: Array<{transactionId: string; lifecycle: string; diff: string; changedFiles: string[]}>; + truncated: boolean; + }; + assert.equal(page.truncated, false); + assert.equal(page.changes[0]?.transactionId, transactionId); + assert.equal(page.changes[0]?.lifecycle, "validated"); + assert.deepEqual(page.changes[0]?.changedFiles, ["note.txt"]); + assert.match(page.changes[0]?.diff ?? "", /after/u); + assert.equal("root" in (page.changes[0] ?? {}), false); + assert.equal("transactionStatePath" in (page.changes[0] ?? {}), false); + + const appliedUpdate = client.call("project-changes", "subscribe", [handle]) as Promise<{changes: Array<{lifecycle: string}>; rescan: boolean}>; + const applied = await client.call("project-changes", "apply", [handle, transactionId]) as {lifecycle: string}; + assert.equal(applied.lifecycle, "applied"); + let observedApplied = await appliedUpdate; + if (observedApplied.changes[0]?.lifecycle !== "applied") { + observedApplied = await client.call("project-changes", "subscribe", [handle]) as typeof observedApplied; + } + assert.equal(observedApplied.changes[0]?.lifecycle, "applied"); + assert.equal(await readFile(notePath, "utf8"), "after\n"); + assert.equal(await client.call("project-changes", "close", [handle]), null); + await client.close(); + + client = open(); + handle = await client.call("project-changes", "start", []) as number; + const restored = await client.call("project-changes", "get", [handle, transactionId]) as {lifecycle: string}; + assert.equal(restored.lifecycle, "applied"); + const rolledBackUpdate = client.call("project-changes", "subscribe", [handle]) as Promise<{changes: Array<{lifecycle: string}>; rescan: boolean}>; + const rolledBack = await client.call("project-changes", "rollback", [handle, transactionId]) as {lifecycle: string}; + assert.equal(rolledBack.lifecycle, "rolled_back"); + assert.equal((await rolledBackUpdate).changes[0]?.lifecycle, "rolled_back"); + assert.equal(await readFile(notePath, "utf8"), "before\n"); + assert.equal(await client.call("project-changes", "close", [handle]), null); + assert.equal((await readdir(project)).some((name) => name.includes("transaction") || name.includes("change")), false); + assert.equal((await readdir(privateDirectory)).sort().join(","), "changes.jsonl,transactions.json"); + } finally { + await client.close(); + await rm(directory, {recursive: true, force: true}); + } +}); + +desktopWorkerTest("Desktop Node capability host enforces filesystem, process, and network grants", { timeout: 120_000 }, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-worker-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -855,7 +947,7 @@ test("Desktop Node capability host enforces filesystem, process, and network gra } }); -test("Desktop process grants work independently from filesystem grants and keep wire bounds", { timeout: 120_000 }, async () => { +desktopWorkerTest("Desktop process grants work independently from filesystem grants and keep wire bounds", { timeout: 120_000 }, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-process-only-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -1017,7 +1109,7 @@ setInterval(() => {}, 1000); } }); -test("Desktop capability host drains transferred process ownership before a fatal exit", { timeout: 90_000 }, async () => { +desktopWorkerTest("Desktop capability host drains transferred process ownership before a fatal exit", { timeout: 90_000 }, async () => { const directory = await mkdtemp(join(tmpdir(), "velar-desktop-worker-crash-")); const project = join(directory, "project"); const appData = join(directory, "app-data"); @@ -1028,7 +1120,10 @@ test("Desktop capability host drains transferred process ownership before a fata protocolVersion: 1, permissions: { files: [], processes: [basename(process.execPath)], network: [] }, }), "utf8"); - const source = await readFile(workerPath, "utf8"); + const source = (await readFile(workerPath, "utf8")).replace( + 'from "./project-transactions.js"', + `from ${JSON.stringify(pathToFileURL(resolve("packages/desktop/native/node/project-transactions.js")).href)}`, + ); const crashingSource = source.replace( 'task.kind = "process";\n processHandles.set(handle, task);\n // The native shell becomes the crash-recovery owner before the renderer\n // receives the public start/run result.\n respond({ protocolVersion: 1, hostEvent: "process-owned", owner, handle, pid: task.pid });', 'task.kind = "process";\n processHandles.set(handle, task);\n // The native shell becomes the crash-recovery owner before the renderer\n // receives the public start/run result.\n respond({ protocolVersion: 1, hostEvent: "process-owned", owner, handle, pid: task.pid }); setTimeout(() => { throw new Error("injected Desktop worker crash"); }, 100); await new Promise(() => {});', diff --git a/tests/desktop.test.ts b/tests/desktop.test.ts index ed8dccde..8802baaa 100644 --- a/tests/desktop.test.ts +++ b/tests/desktop.test.ts @@ -37,10 +37,11 @@ test("Desktop is one VelarScript project with Web syntax and no renderer/main so environment: ["LANG", "VELAR_DESKTOP_GENERATION_SMOKE"], secrets: ["OPENAI_API_KEY"], }, + build: { sizeBudgetBytes: 32 * 1024 * 1024 }, }, }, null, 2), "utf8"); await writeFile(join(projectRoot, "src", "main.vel"), ` -import {ProjectTaskCommand, ProjectTaskOutputChannel, appDataDirectory, openTerminal, platform, projectDirectory, selectedProjectDirectory, selectProjectDirectory, startProjectTask} from "velar/desktop" +import {ProjectChangeLifecycle, ProjectTaskCommand, ProjectTaskOutputChannel, appDataDirectory, openTerminal, platform, projectChanges, projectDirectory, selectedProjectDirectory, selectProjectDirectory, startProjectTask} from "velar/desktop" import {createText, exists, readText, watchFiles, writeText} from "velar/fs" import {get} from "velar/env" import {ProcessOutputChannel, run, start} from "velar/process" @@ -97,6 +98,14 @@ component App: const result = await task.wait() detail = output + result.stderr + action inspectChanges(): + const changes = await projectChanges() + const page = await changes.list(10) + for change in page.changes: + if change.lifecycle == ProjectChangeLifecycle.applied: + detail = change.transactionId + ":" + change.diff + await changes.close() + action openShell(): const session = await openTerminal({columns: 100, rows: 30}) await session.resize(120, 40) @@ -109,6 +118,7 @@ component App:

VelarScript Desktop

+

{detail}

@@ -140,8 +150,15 @@ mount(, "#app") assert.match(assets, /velar\.desktop\.bridge\.v1/u); assert.match(assets, /project-task/u); assert.match(assets, /startProjectTask/u); + assert.match(assets, /project-changes/u); + assert.match(assets, /ProjectChangeLifecycle/u); assert.match(assets, /openTerminal/u); + // The 0.10 native host is deliberately the macOS system-WebView host. + // Other platforms still prove the single-project compiler contract above; + // they must not pretend to package a host the product does not publish. + if (process.platform !== "darwin") return; + const packaged = spawnSync(process.execPath, [cli, "package"], { cwd: projectRoot, encoding: "utf8" }); assert.equal(packaged.status, 0, packaged.stderr); const desktopBuild = JSON.parse(await readFile(join(projectRoot, "dist", "desktop", "velar-desktop-build.json"), "utf8")) as { @@ -151,6 +168,7 @@ mount(, "#app") sizes: { hostBytes: number; rendererBytes: number; + capabilityHostBytes: number; languageServerBytes: number; projectTaskBytes: number; buildEngineBytes: number; @@ -179,6 +197,7 @@ mount(, "#app") assert.equal(desktopBuild.runtime.version, undefined); assert.equal(desktopBuild.runtime.executableHint, undefined); assert.ok(desktopBuild.sizes.hostBytes < 512 * 1024, JSON.stringify(desktopBuild.sizes)); + assert.ok(desktopBuild.sizes.capabilityHostBytes > 4 * 1024 * 1024, JSON.stringify(desktopBuild.sizes)); assert.ok(desktopBuild.sizes.languageServerBytes > 1024 * 1024, JSON.stringify(desktopBuild.sizes)); assert.ok(desktopBuild.sizes.projectTaskBytes > 1024 * 1024, JSON.stringify(desktopBuild.sizes)); assert.ok(desktopBuild.sizes.buildEngineBytes > 5 * 1024 * 1024, JSON.stringify(desktopBuild.sizes)); @@ -199,6 +218,8 @@ mount(, "#app") assert.deepEqual(hostConfig.terminalHost, { path: "host/terminal-host" }); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "language-server.js"))).byteLength > 1024 * 1024); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "project-task.js"))).byteLength > 1024 * 1024); + assert.equal(JSON.parse(await readFile(join(application, "Contents", "Resources", "host", "playwright-core", "package.json"), "utf8")).name, "playwright-core"); + assert.ok(JSON.parse(await readFile(join(application, "Contents", "Resources", "host", "playwright-core", "browsers.json"), "utf8")).browsers.length >= 3); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "build-engine"))).byteLength > 5 * 1024 * 1024); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "terminal-host"))).byteLength > 32 * 1024); assert.equal(hostConfig.nodeExecutableHint, undefined); diff --git a/tests/fixture-projects.test.ts b/tests/fixture-projects.test.ts index d85e7554..439732b5 100644 --- a/tests/fixture-projects.test.ts +++ b/tests/fixture-projects.test.ts @@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process"; import { join, relative, resolve } from "node:path"; import test from "node:test"; import { velarProjects } from "../scripts/velar-projects.mjs"; +import { repositoryRoot } from "./repository-root.ts"; /** * D56 rule 131 and D61 rule 156, applied to the other half of the tree. @@ -19,7 +20,7 @@ import { velarProjects } from "../scripts/velar-projects.mjs"; * proves is that all of them still check. */ -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); test("[D61-156] every fixture project under tests/fixtures still checks", async () => { diff --git a/tests/hardening-browser-esm-package.test.ts b/tests/hardening-browser-esm-package.test.ts index 01e44140..8b2d5577 100644 --- a/tests/hardening-browser-esm-package.test.ts +++ b/tests/hardening-browser-esm-package.test.ts @@ -4,9 +4,18 @@ import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node: import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import test from "node:test"; +import { isAbsoluteBrowserImportPath } from "../packages/cli/src/production-build.ts"; const cli = resolve("packages/cli/src/cli.ts"); +test("production import resolution keeps absolute host paths out of npm lookup", () => { + assert.equal(isAbsoluteBrowserImportPath("/workspace/src/main.vel"), true); + assert.equal(isAbsoluteBrowserImportPath("D:\\workspace\\src\\main.vel"), true); + assert.equal(isAbsoluteBrowserImportPath("\\\\server\\share\\src\\main.vel"), true); + assert.equal(isAbsoluteBrowserImportPath("browser-sdk"), false); + assert.equal(isAbsoluteBrowserImportPath("@scope/browser-sdk"), false); +}); + test("Desktop checks and bundles import-only ESM package roots and subpaths", async () => { const projectRoot = await mkdtemp(join(tmpdir(), "velar-desktop-import-only-")); try { diff --git a/tests/hardening-closing.test.ts b/tests/hardening-closing.test.ts index 1979c4fb..144859db 100644 --- a/tests/hardening-closing.test.ts +++ b/tests/hardening-closing.test.ts @@ -9,10 +9,11 @@ import { velarCompilerExtension } from "@velarscript/web/compiler"; import { compileProject } from "../packages/cli/src/project.ts"; import { standardModuleClosure, standardModuleSource, standardModuleSources } from "../packages/cli/src/standard-modules.ts"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; // Closing wave — D50 rules 97.2 and 97.3. -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; after(async () => { await removeTemporaryDirectories(); diff --git a/tests/hardening-d53-inline-css.test.ts b/tests/hardening-d53-inline-css.test.ts index a1fda0c5..17a93512 100644 --- a/tests/hardening-d53-inline-css.test.ts +++ b/tests/hardening-d53-inline-css.test.ts @@ -1,10 +1,17 @@ import assert from "node:assert/strict"; -import test from "node:test"; +import { spawnSync } from "node:child_process"; +import { mkdir, readdir, readFile, symlink, writeFile } from "node:fs/promises"; +import { join, resolve } from "node:path"; +import test, { after } from "node:test"; import { compile as compileCore, formatSource } from "@velarscript/compiler"; import type { Program } from "@velarscript/compiler/extension"; import type { WebUnsafeCssDeclaration } from "../packages/web/src/ast.ts"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { cssTokens, type CssToken } from "../packages/web/src/css-tokens.ts"; import { velarWebInspectionExtension } from "../packages/web/src/inspection.ts"; +import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; + +after(removeTemporaryDirectories); const compileWeb = (source: string, resourceContents: ReadonlyMap = new Map()) => compileCore(source, { extensions: [velarCompilerExtension], resourceContents }); @@ -142,3 +149,226 @@ test("[D53] Core does not parse CSS and points to an installed unsafe-block exte core.diagnostics.map((item) => `${item.code} ${item.message}`).join("\n"), ); }); + +// --------------------------------------------------------------------------- +// A-002 / A-003: both stylesheet gates read CSS tokens. +// +// One text scan used to answer both questions and got each one wrong in the +// opposite direction: a legal `)` inside a quoted URL ended the match early, +// so `url("./mark).svg")` walked past the gate and shipped an address that +// 404s once the stylesheet is extracted under assets/ (A-002, S1); and a +// `url(...)` written inside a string literal, which is text and not a +// reference, was refused (A-003). Sample-by-sample coverage is what let a +// scanner that never knew what a token was look tested, so the corpus below +// is organised by token shape -- quotes, escapes, comments, both url forms -- +// and runs in both directions. +// --------------------------------------------------------------------------- + +/** + * The addresses the relative-url gate refuses in one stylesheet body, asserted + * to be the same whether the CSS arrives inline or through an external file. + */ +function refusedCssUrls(css: string): readonly string[] { + const indented = css.split("\n").map((line) => ` ${line}`).join("\n"); + const inline = compileWeb(`unsafe css\`\n${indented}\n\` before look\n`); + const external = compileWeb('import css unsafe "./sheet.css" before look\n', new Map([["./sheet.css", css]])); + const addresses = (diagnostics: readonly { readonly code: string; readonly message: string }[]): string[] => diagnostics + .filter((item) => item.code === "VEL5037") + .map((item) => / uses relative url\((.*?)\); use a project-public /su.exec(item.message)?.[1]) + .filter((address): address is string => address !== undefined) + .map((address) => JSON.parse(address) as string); + assert.deepEqual(addresses(inline.diagnostics), addresses(external.diagnostics), css); + return addresses(inline.diagnostics); +} + +/** True when the hidden-dependency gate reads an @import at-rule in the body. */ +function refusesCssImport(css: string): boolean { + const indented = css.split("\n").map((line) => ` ${line}`).join("\n"); + const result = compileWeb(`unsafe css\`\n${indented}\n\` before look\n`); + return result.diagnostics.some((item) => item.code === "VEL5037" && /contains @import/u.test(item.message)); +} + +test("[D53/A-002] a legal ) or quote inside a URL cannot walk past the relative-address gate", () => { + const refused: readonly (readonly [string, string])[] = [ + // A-002 verbatim: a right parenthesis is a legal filename character, and + // inside a quoted URL it is content, not the end of the reference. + ['.icon { background-image: url("./mark).svg"); width: 20px; }', "./mark).svg"], + [".icon { background-image: url('./mark).svg'); }", "./mark).svg"], + ['.icon { background: url("./a(1).svg"); }', "./a(1).svg"], + // The other delimiter a text scan trips over: the opposite quote. + [".icon { background: url('./a\".svg'); }", "./a\".svg"], + ['.icon { background: url("./a\'.svg"); }', "./a'.svg"], + // An escape belongs to the token, and the address is the decoded one -- + // what the browser requests -- not the bytes around the backslash. + [".icon { background: url(./mark\\).svg); }", "./mark).svg"], + ['.icon { background: url("./mark\\29 .svg"); }', "./mark).svg"], + [".icon { background: url(./mark\\29 .svg); }", "./mark).svg"], + ['.icon { background: url("./mark\\".svg"); }', "./mark\".svg"], + // The reference survives whitespace, newlines, comments, and neighbours. + ['.icon {\n background:\n url(\n "./multi.svg"\n );\n}', "./multi.svg"], + ['.a { content: ")"; background: url("./after-a-paren.svg"); }', "./after-a-paren.svg"], + ['.a { background: url("./c.svg") /* trailing */; }', "./c.svg"], + ['.a { mask-image: url("/rooted.svg"), url("./second.svg"); }', "./second.svg"], + ['@font-face { font-family: A; src: url("./a.woff2") format("woff2"); }', "./a.woff2"], + ['.a { background: -webkit-image-set(url("./nested.png") 1x); }', "./nested.png"], + ['.a { width: 20px; background: url("./after-a-dimension.svg"); }', "./after-a-dimension.svg"], + [':root { --icon: url("./custom-property.svg"); }', "./custom-property.svg"], + ['@media print { .a { background: url("./in-an-at-rule.svg"); } }', "./in-an-at-rule.svg"], + ]; + for (const [css, address] of refused) assert.deepEqual(refusedCssUrls(css), [address], css); +}); + +test("[D53/A-003] url(...) written as text is text: strings and comments are not references", () => { + const accepted: readonly string[] = [ + // A-003 verbatim, then the same shape outside a `content` declaration. + '.label::before { content: "url(./not-an-asset.svg)"; }', + '[data-x="url(./not-an-asset.svg)"] { color: red; }', + ".label::before { content: 'url(./not-an-asset.svg)'; }", + '.a { content: "\\"url(./inside-an-escaped-quote.svg)\\""; }', + '/* url("./commented-out.svg") */ .a { color: red; }', + '/* content: "url(./commented-out.svg)" */ .a { color: red; }', + // `url(` at the tail of a longer identifier is a different function. + '.a { background: myurl("./not-the-url-function.svg"); }', + '.a { background: -my-url("./not-the-url-function.svg"); }', + // Addresses the ruling names as owned, including one an escape spells. + '.a { background: url("/public/a.svg"); }', + '.a { background: url(/public/a.svg); }', + '.a { fill: url("#gradient"); }', + '.a { background: url("data:image/svg+xml,%3Csvg%3E"); }', + '.a { background: url("https://example.com/a.svg"); }', + '.a { background: url("//example.com/a.svg"); }', + '.a { background: url("\\2f public/escaped-root.svg"); }', + // An empty url() names the document, and a bad-url or bad-string is a + // declaration the browser drops -- neither one ever fetches an asset. + ".a { background: url(); }", + '.a { background: url(""); }', + '.a { background: url("./bad\n-string.svg"); }', + '.a { background: ur/**/l("./two-idents.svg"); }', + ]; + for (const css of accepted) assert.deepEqual(refusedCssUrls(css), [], css); +}); + +test("[D53] the @import gate reads the same token stream as the address gate", () => { + assert.ok(refusesCssImport('@import "./theme.css";')); + assert.ok(refusesCssImport("@import url(./theme.css);")); + assert.ok(refusesCssImport('@media print {@import "./theme.css";}'), "no separator in front of the at-keyword"); + assert.ok(refusesCssImport('@\\69 mport "./theme.css";'), "an escaped at-keyword names the same at-rule"); + assert.ok(refusesCssImport('@IMPORT "./theme.css";'), "at-rule names are case-insensitive"); + assert.ok(!refusesCssImport('.a { content: "@import \\"./theme.css\\";"; }')); + assert.ok(!refusesCssImport('/* @import "./theme.css"; */ .a { color: red; }')); + assert.ok(!refusesCssImport('.a { background: url(/not-an-@import.svg); }')); + assert.ok(!refusesCssImport("@media print { .a { color: red; } }\n@layer base;\n@supports (display: grid) { .b { display: grid; } }")); +}); + +test("[D53] the CSS scanner reports url and at-keyword tokens over the CSS token grammar", () => { + const tokensOf = (css: string): readonly CssToken[] => [...cssTokens(css)]; + // Strings end at their own quote, and their content is never a token. + assert.deepEqual(tokensOf('a { content: "url(x) @import"; }'), []); + assert.deepEqual(tokensOf('a { content: "\\" url(x)"; }'), []); + assert.deepEqual(tokensOf('a { content: "url(\\\n x)"; }'), [], "a backslash-newline continues the string"); + // Comments are skipped whole, including an unterminated one. + assert.deepEqual(tokensOf('/* url(x) */ a { color: red; }'), []); + assert.deepEqual(tokensOf('/* url(x) a { background: url("./y.svg"); }'), []); + // Both url forms, with escapes decoded to the address a browser requests. + assert.deepEqual(tokensOf('a { background: url("./q).svg"); }'), [{ kind: "url", value: "./q).svg" }]); + assert.deepEqual(tokensOf("a { background: url(./u\\).svg); }"), [{ kind: "url", value: "./u).svg" }]); + assert.deepEqual(tokensOf('a { background: url("\\2f rooted.svg"); }'), [{ kind: "url", value: "/rooted.svg" }]); + assert.deepEqual(tokensOf('a { background: url( "./padded.svg" ); }'), [{ kind: "url", value: "./padded.svg" }]); + assert.deepEqual(tokensOf("a { background: url( ./padded.svg ); }"), [{ kind: "url", value: "./padded.svg" }]); + assert.deepEqual(tokensOf('a { background: url("./\u{1F600}.svg"); }'), [{ kind: "url", value: "./\u{1F600}.svg" }]); + // A bad-url and a bad-string are dropped declarations, not references. + assert.deepEqual(tokensOf('a { background: url(./bad url.svg); }'), []); + assert.deepEqual(tokensOf('a { background: url("./bad\n.svg"); }'), []); + assert.deepEqual(tokensOf('a { background: url("./missing-paren.svg" extra); }'), []); + // Recovery after a bad-url resumes at the next token, not mid-string. + assert.deepEqual(tokensOf('a { background: url(./bad url.svg); } b { background: url("./good.svg"); }'), [ + { kind: "url", value: "./good.svg" }, + ]); + // At-keywords, and the identifiers that only look like one. + assert.deepEqual(tokensOf('@media print { @import "./x.css"; }'), [ + { kind: "at-keyword", name: "media" }, + { kind: "at-keyword", name: "import" }, + ]); + assert.deepEqual(tokensOf('a { background: url(/a@import.svg); }'), [{ kind: "url", value: "/a@import.svg" }]); +}); + +const cliPath = resolve("packages/cli/src/cli.ts"); + +/** A minimal buildable Web project whose only stylesheet is the given CSS. */ +async function writeCssProject(directory: string, css: string, publicAssets: readonly string[]): Promise { + const scope = join(directory, "node_modules", "@velarscript"); + await mkdir(scope, { recursive: true }); + await symlink(resolve("packages/web"), join(scope, "web"), "dir"); + await mkdir(join(directory, "public"), { recursive: true }); + for (const asset of publicAssets) { + await writeFile(join(directory, "public", asset), '\n', "utf8"); + } + await writeFile(join(directory, "velar.json"), JSON.stringify({ formatVersion: 2, entry: "main.vel", extensions: ["@velarscript/web"] }), "utf8"); + await writeFile(join(directory, "main.vel"), [ + "unsafe css`", + ...css.split("\n").map((line) => ` ${line}`), + "` before look", + "", + "component App:", + ' return
Icon
', + "", + 'mount(, "#app")', + "", + ].join("\n"), "utf8"); +} + +function buildProject(directory: string): { readonly status: number | null; readonly output: string } { + const execution = spawnSync(process.execPath, [cliPath, "build", directory, "--out-dir", join(directory, "dist")], { + cwd: process.cwd(), + encoding: "utf8", + timeout: 300_000, + }); + return { status: execution.status, output: `${String(execution.stdout)}${String(execution.stderr)}` }; +} + +test("[D53/A-002] the extracted production stylesheet carries no address that would 404", async () => { + // The harm A-002 named lands on the build product, not on `velar check`: the + // stylesheet is extracted to a hashed file under assets/, so a relative + // address that read fine next to index.html resolves one directory deeper + // and 404s. Refusing it is therefore a claim about what dist/ contains. + const refused = await makeTemporaryDirectory("velar-css-relative-build-"); + await writeCssProject(refused, '.icon { background-image: url("./mark).svg"); width: 20px; height: 20px; }', ["mark).svg"]); + const refusedBuild = buildProject(refused); + assert.equal(refusedBuild.status, 1, refusedBuild.output); + assert.match(refusedBuild.output, /VEL5037/u); + assert.match(refusedBuild.output, /uses relative url\("\.\/mark\)\.svg"\)/u); + assert.deepEqual(await readdir(join(refused, "dist")).catch(() => []), [], "a refused stylesheet leaves no build product"); + + // The same file named the way the ruling asks builds, and every address in + // the stylesheet the browser actually loads resolves from the site root to + // a file the build really contains. + const built = await makeTemporaryDirectory("velar-css-rooted-build-"); + await writeCssProject(built, [ + '.icon { background-image: url("/mark).svg"); width: 20px; height: 20px; }', + '.escaped { background-image: url("\\2f mark\\29 .svg"); }', + '.inline { background-image: url("data:image/svg+xml,%3Csvg%3E"); }', + ].join("\n"), ["mark).svg"]); + const build = buildProject(built); + assert.equal(build.status, 0, build.output); + const assets = await readdir(join(built, "dist", "assets")); + const stylesheet = assets.find((name) => /^styles-[\da-f]+\.css$/u.test(name)); + assert.ok(stylesheet, JSON.stringify(assets)); + const styles = await readFile(join(built, "dist", "assets", stylesheet), "utf8"); + assert.match(styles, /url\("\/mark\)\.svg"\)/u); + const addresses = [...cssTokens(styles)].filter((token) => token.kind === "url").map((token) => token.value); + assert.equal(addresses.length, 3, styles); + for (const address of addresses) { + const rooted = address.startsWith("/") && !address.startsWith("//"); + assert.ok( + rooted || address.startsWith("#") || /^[a-z][a-z0-9+.-]*:/iu.test(address), + `${JSON.stringify(address)} in assets/${stylesheet} resolves against dist/assets/, not the site root`, + ); + if (rooted) { + assert.deepEqual( + await readFile(join(built, "dist", address.slice(1)), "utf8").then(() => "present", () => "missing"), + "present", + `${JSON.stringify(address)} is not in the build product`, + ); + } + } +}); diff --git a/tests/hardening-d59-d60-defects.test.ts b/tests/hardening-d59-d60-defects.test.ts index 5c168df7..5e9f21cb 100644 --- a/tests/hardening-d59-d60-defects.test.ts +++ b/tests/hardening-d59-d60-defects.test.ts @@ -6,6 +6,7 @@ import test, { after } from "node:test"; import { compile } from "@velarscript/compiler"; import { velarCompilerExtension as webCompilerExtension } from "../packages/web/src/compiler.ts"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; // --------------------------------------------------------------------------- // D59 rule 141 and D60 rule 148 — the two defects whose shape is "compiles @@ -13,7 +14,7 @@ import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary- // so every probe here runs the toolchain rather than reading its output. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); after(async () => { diff --git a/tests/hardening-d60-d61-surface.test.ts b/tests/hardening-d60-d61-surface.test.ts index 52a19134..5014de27 100644 --- a/tests/hardening-d60-d61-surface.test.ts +++ b/tests/hardening-d60-d61-surface.test.ts @@ -4,6 +4,7 @@ import { mkdir, symlink, writeFile } from "node:fs/promises"; import { join, resolve } from "node:path"; import test, { after } from "node:test"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; // --------------------------------------------------------------------------- // The four surface defects an author walks straight into: D61 rule 155 (a bool @@ -19,7 +20,7 @@ import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary- // and load-time facts and run the toolchain headless. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); after(removeTemporaryDirectories); diff --git a/tests/hardening-d64-doc-coverage.test.ts b/tests/hardening-d64-doc-coverage.test.ts index 56645009..7772a533 100644 --- a/tests/hardening-d64-doc-coverage.test.ts +++ b/tests/hardening-d64-doc-coverage.test.ts @@ -226,6 +226,137 @@ test("a preamble that lost its fence is reported rather than ignored", async () assert.match(complete.stderr, /already checked in full/u); }); +// --------------------------------------------------------------------------- +// A-022 — the fence *extractor*. Everything above tests what the gate does with +// an example once it has one; these test which examples it has at all. +// +// The extractor was a regex that fixed the opening backticks at column 0, that +// required the closing fence to have exactly the opening fence's length, and +// that knew only backticks. Every one of those is stricter than CommonMark, and +// every one of them fails the same way: a legal fence goes unextracted, +// uncompiled and uncounted, under a headline claiming every block was checked. +// A gate that skips an example silently is worse than no gate, because its +// number is read as an answer. The cases below are one per rule, each carrying +// an example that must fail — a fence that is extracted but valid would pass +// whether or not the extractor ever saw it. +// --------------------------------------------------------------------------- + +const brokenExample = "const broken: string = 1"; +const brokenDiagnostic = /Cannot assign number to string/u; + +test("[A-022] a fence indented inside a list item is extracted, dedented and compiled", async () => { + const run = await checkMarkdown("indented", [ + "- Nested example:", + "", + " ```velar", + ` ${brokenExample}`, + " print(broken)", + " ```", + "", + ].join("\n")); + assert.equal(run.status, 1, run.output); + // The dedent is load-bearing rather than cosmetic: VelarScript is + // indentation-sensitive, so a fence whose three spaces were not removed would + // fail with an indentation error instead of the type error the example has. + assert.match(run.stderr, brokenDiagnostic, run.output); +}); + +test("[A-022] a closing fence longer than its opening closes the block", async () => { + const run = await checkMarkdown("long-close", [ + "```velar", + brokenExample, + "print(broken)", + "````", + "", + ].join("\n")); + assert.equal(run.status, 1, run.output); + assert.match(run.stderr, brokenDiagnostic, run.output); +}); + +test("[A-022] a tilde fence is a fence", async () => { + const run = await checkMarkdown("tilde", [ + "~~~velar", + brokenExample, + "print(broken)", + "~~~", + "", + ].join("\n")); + assert.equal(run.status, 1, run.output); + assert.match(run.stderr, brokenDiagnostic, run.output); +}); + +test("[A-022] the headline counts the legal fences a regex could not reach", async () => { + // The reproduction as it was filed: one ordinary fence, then a second in a + // shape the old extractor could not see. The gate answered "Checked 1 …" and + // exit 0 — the number was wrong and the defective example was never compiled. + for (const second of [ + ["- Nested example:", "", " ```velar", " print(\"two\")", " ```"], + ["```velar", "print(\"two\")", "````"], + ["~~~velar", "print(\"two\")", "~~~"], + ]) { + const run = await checkMarkdown("counted-shapes", [ + "```velar", + "print(\"one\")", + "```", + "", + ...second, + "", + ].join("\n")); + assert.equal(run.status, 0, run.output); + assert.match(run.stdout, /Checked 2 VelarScript documentation examples \(2 complete, 0 fragments\)/u, run.output); + } +}); + +test("[A-022] a shorter fence inside a longer one stays content", async () => { + // The one thing the old regex got right, kept: a VelarScript example may show + // a Markdown fence as literal text, and CommonMark's "at least as long" rule + // preserves that because the inner fence is shorter than the opening one. + const run = await checkMarkdown("nested-fence", [ + "````velar", + "const markdown = \"", + " ```", + "\"", + "print(markdown)", + "````", + "", + ].join("\n")); + assert.equal(run.status, 0, run.output); + assert.match(run.stdout, /Checked 1 VelarScript documentation examples/u, run.output); +}); + +test("[A-022] a velar fence the extractor cannot reach is named, not skipped", async () => { + // The scanner reads CommonMark's fenced-code-block rules and nothing else, so + // a fence whose indentation is measured from a block container is out of its + // reach. That is a boundary, not a licence to skip: the gate says where the + // example is and goes red, because an example nobody compiles under a + // headline that claims otherwise is the whole defect. + for (const container of [ + ["> ```velar", "> print(\"quoted\")", "> ```"], + ["- Item:", "", " - Nested item:", "", " ```velar", " print(\"deep\")", " ```"], + ]) { + const run = await checkMarkdown("unreachable", [...container, ""].join("\n")); + assert.equal(run.status, 1, run.output); + assert.match(run.stderr, /opens a VelarScript fence inside a Markdown container this gate does not parse/u, run.output); + } +}); + +test("[A-022] a preamble attaches to an indented fence", async () => { + const run = await checkMarkdown("indented-preamble", [ + "- Nested example:", + "", + " ", + " ```velar fragment", + " print(total([1, 2, 3]))", + " ```", + "", + ].join("\n")); + assert.equal(run.status, 1, run.output); + assert.match(run.stderr, /Cannot (assign|return) number/u, run.output); +}); + test("a preamble shown inside a code block is documentation, not a declaration", async () => { // D64 itself writes the mechanism out inside a fence; documentation about a // mechanism must not trip the mechanism. diff --git a/tests/hardening-d65-look-keywords.test.ts b/tests/hardening-d65-look-keywords.test.ts index db3f73a9..ae7eaf9d 100644 --- a/tests/hardening-d65-look-keywords.test.ts +++ b/tests/hardening-d65-look-keywords.test.ts @@ -3,8 +3,10 @@ import { spawn } from "node:child_process"; import { mkdir, readFile, symlink, writeFile } from "node:fs/promises"; import { join, resolve } from "node:path"; import test, { after } from "node:test"; +import { pathToFileURL } from "node:url"; import { compile as compileCore } from "@velarscript/compiler"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; import { LOOK_KEYWORD_DECIDED_KINDS, @@ -33,7 +35,7 @@ import { // and asserts the module itself refuses to come up. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); const lookTable = join(root, "packages", "web", "src", "look.ts"); @@ -128,7 +130,7 @@ test("[D65-168] the table refuses to load when a keyword property has no closed // copy that failed to load for some unrelated reason. const control = join(directory, "control.mts"); await writeFile(control, source, "utf8"); - const loaded = await import(control) as { readonly LOOK_PROPERTY_KEYWORDS: ReadonlyMap> }; + const loaded = await import(pathToFileURL(control).href) as { readonly LOOK_PROPERTY_KEYWORDS: ReadonlyMap> }; assert.ok(loaded.LOOK_PROPERTY_KEYWORDS.get("strokeLinecap")?.has("butt")); const removed = source.replace(/^ {2}\["strokeLinecap".*\n/mu, ""); @@ -136,7 +138,7 @@ test("[D65-168] the table refuses to load when a keyword property has no closed const broken = join(directory, "broken.mts"); await writeFile(broken, removed, "utf8"); await assert.rejects( - () => import(broken), + () => import(pathToFileURL(broken).href), /Look property 'strokeLinecap' accepts string keywords and has no closed keyword set/u, ); }); diff --git a/tests/hardening-d66-repro.test.ts b/tests/hardening-d66-repro.test.ts index d3bf5dac..ca61e6dc 100644 --- a/tests/hardening-d66-repro.test.ts +++ b/tests/hardening-d66-repro.test.ts @@ -4,7 +4,9 @@ import { mkdir, readFile, readdir, realpath, writeFile } from "node:fs/promises" import { join, relative, resolve, sep } from "node:path"; import test, { after } from "node:test"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { DEFECT_REPORT_SECTIONS, reproductionHint } from "../packages/cli/src/reproduction.ts"; +import { portablePath } from "../packages/cli/src/test-output.ts"; // --------------------------------------------------------------------------- // D66 rulings 7A, 7B and 7D — the minimal-repro doctrine gets an exit. @@ -22,7 +24,7 @@ import { DEFECT_REPORT_SECTIONS, reproductionHint } from "../packages/cli/src/re // over a real project and reads the real bundle. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); after(removeTemporaryDirectories); @@ -109,7 +111,11 @@ test("D66 7A velar repro writes a reproduction that reproduces, and prints where for (const section of DEFECT_REPORT_SECTIONS) assert.ok(readme.includes(`## ${section}`), `the README must carry '${section}'`); // "What the compiler said" is pre-filled from the real run, verbatim apart // from the absolute paths this machine would otherwise leak. - assert.ok(readme.includes(diagnostics.split(directory + sep).join("").trimEnd()), + const bundledDiagnostics = diagnostics + .split(directory + sep).join("") + .split(`${portablePath(directory)}/`).join("") + .trimEnd(); + assert.ok(readme.includes(bundledDiagnostics), `the README must quote the diagnostics verbatim, got:\n${readme}`); assert.match(readme, /^Versions: velar \d+\.\d+\.\d+ · node v\d+\.\d+\.\d+ · \w+ \w+$/mu); assert.ok(readme.includes("npm install\nnpx velar check\n"), "the README must give the reproduce instructions"); @@ -123,9 +129,21 @@ test("D66 7A velar repro writes a reproduction that reproduces, and prints where test("D66 7A a reproduction carries no absolute host path and no environment data", async () => { // Discipline 2 of the ruling. The marker is in the project's own path, so a - // single leaked absolute path anywhere in the bundle fails this. + // single leaked absolute path anywhere in the bundle fails this. A dedicated + // environment sentinel proves the second half without treating a static + // product string such as the GitHub repository name as collected host data. + const environmentSentinel = "velar-d66-environment-sentinel-7d2b91c4"; + const previousSentinel = process.env.VELAR_D66_ENVIRONMENT_SENTINEL; + process.env.VELAR_D66_ENVIRONMENT_SENTINEL = environmentSentinel; const directory = await project("velar-d66-repro-nothing-collected-", failingProject); - const produced = run(["repro", directory]); + const produced = (() => { + try { + return run(["repro", directory]); + } finally { + if (previousSentinel === undefined) delete process.env.VELAR_D66_ENVIRONMENT_SENTINEL; + else process.env.VELAR_D66_ENVIRONMENT_SENTINEL = previousSentinel; + } + })(); assert.equal(produced.status, 0, produced.stderr); const bundle = join(directory, ".velar", "repro"); @@ -135,9 +153,7 @@ test("D66 7A a reproduction carries no absolute host path and no environment dat await realpath(directory), root, process.execPath, - ...Object.entries(process.env) - .filter(([name, value]) => value && value.length > 8 && !["PWD", "OLDPWD", "_"].includes(name)) - .map(([, value]) => value!), + environmentSentinel, ]; for (const file of await filesUnder(bundle)) { const content = await readFile(join(bundle, file), "utf8"); diff --git a/tests/hardening-d66-web-icon.test.ts b/tests/hardening-d66-web-icon.test.ts index 546cb903..5e982a21 100644 --- a/tests/hardening-d66-web-icon.test.ts +++ b/tests/hardening-d66-web-icon.test.ts @@ -4,6 +4,7 @@ import { mkdir, readFile, symlink, writeFile } from "node:fs/promises"; import { join, resolve } from "node:path"; import test, { after } from "node:test"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { createWebArtifacts } from "../packages/web/src/host.ts"; import { velarProjectExtension, webIconType, WEB_ICON_TYPES } from "../packages/web/src/project-config.ts"; @@ -24,7 +25,7 @@ import { velarProjectExtension, webIconType, WEB_ICON_TYPES } from "../packages/ // document it wrote. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); const markSvg = join(root, "assets", "brand", "velarscript-mark.svg"); diff --git a/tests/hardening-d67-look-completion.test.ts b/tests/hardening-d67-look-completion.test.ts index a5d0bcdc..cf69cad5 100644 --- a/tests/hardening-d67-look-completion.test.ts +++ b/tests/hardening-d67-look-completion.test.ts @@ -5,6 +5,7 @@ import { join, resolve } from "node:path"; import test, { after } from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; import { LOOK_ANIMATION_EASINGS, @@ -37,7 +38,7 @@ import { // down and the diagnostic reads it out. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); after(removeTemporaryDirectories); diff --git a/tests/hardening-d68-browser-geometry.test.ts b/tests/hardening-d68-browser-geometry.test.ts index 2a13f2a7..83a067fe 100644 --- a/tests/hardening-d68-browser-geometry.test.ts +++ b/tests/hardening-d68-browser-geometry.test.ts @@ -4,8 +4,9 @@ import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import test from "node:test"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function runCommand(command: string, arguments_: readonly string[]): Promise { return new Promise((resolvePromise, rejectPromise) => { diff --git a/tests/hardening-d68-iterate.test.ts b/tests/hardening-d68-iterate.test.ts index 8be2a888..5b6a2712 100644 --- a/tests/hardening-d68-iterate.test.ts +++ b/tests/hardening-d68-iterate.test.ts @@ -1,5 +1,6 @@ import assert from "node:assert/strict"; import { spawnSync } from "node:child_process"; +import { tmpdir } from "node:os"; import { join } from "node:path"; import test from "node:test"; import { compile } from "@velarscript/compiler"; @@ -534,7 +535,7 @@ def each(source: Handle): }); test("[D68 177] the contract crosses the module boundary with the class", async () => { - const root = "/velar-iterate-cross-module"; + const root = join(tmpdir(), "velar-iterate-cross-module"); const modules = new Map(Object.entries({ "bag.vel": [ "export class Bag:", diff --git a/tests/hardening-d69-d73-reactive-declarations.test.ts b/tests/hardening-d69-d73-reactive-declarations.test.ts index a2a2e9dd..e8f43501 100644 --- a/tests/hardening-d69-d73-reactive-declarations.test.ts +++ b/tests/hardening-d69-d73-reactive-declarations.test.ts @@ -3,8 +3,10 @@ import { spawn } from "node:child_process"; import { mkdir, symlink, writeFile } from "node:fs/promises"; import { join, resolve } from "node:path"; import test, { after } from "node:test"; +import { pathToFileURL } from "node:url"; import { applyMechanicalFixes, compile as compileCore } from "@velarscript/compiler"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { compileProject } from "../packages/cli/src/project.ts"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; import { @@ -31,7 +33,7 @@ import { WEB_OWNED_TYPE_NAMES } from "../packages/web/src/types.ts"; // tests/browser.acceptance.ts, whose fixture project this file's siblings feed. // --------------------------------------------------------------------------- -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); after(removeTemporaryDirectories); @@ -672,7 +674,7 @@ test("[D73-187] the load-time invariant is what holds the table, not a test", as const broken = join(await makeTemporaryDirectory("velar-d73-187-broken-"), "broken.mts"); await write(broken, removed, "utf8"); await assert.rejects( - () => import(broken), + () => import(pathToFileURL(broken).href), /Look property 'fontWeight' accepts string keywords and has no closed keyword set/u, ); }); diff --git a/tests/hardening-d74-mutable-props.test.ts b/tests/hardening-d74-mutable-props.test.ts index 6022d116..16cd7fce 100644 --- a/tests/hardening-d74-mutable-props.test.ts +++ b/tests/hardening-d74-mutable-props.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function compile(source: string) { return compileCore(source.trimStart(), { extensions: [velarCompilerExtension] }); diff --git a/tests/hardening-detached-async.test.ts b/tests/hardening-detached-async.test.ts index 75e07cc5..d6094436 100644 --- a/tests/hardening-detached-async.test.ts +++ b/tests/hardening-detached-async.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const FLOATING = "VEL4027"; const DETACHED_TYPE = "VEL4028"; diff --git a/tests/hardening-marathon-core.test.ts b/tests/hardening-marathon-core.test.ts index ca78d58d..dfd27eaa 100644 --- a/tests/hardening-marathon-core.test.ts +++ b/tests/hardening-marathon-core.test.ts @@ -7,11 +7,12 @@ import { join, resolve } from "node:path"; import { compile } from "@velarscript/compiler"; import { compileProject, compileProjectEntries, type ProjectResult } from "../packages/cli/src/project.ts"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; after(removeTemporaryDirectories); -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; // Fix wave 1 of the marathon defect ledger (docs/decisions/archive/MARATHON-DEFECTS.md): // the Core compiler and CLI items. Every test here is a regression probe for a @@ -33,7 +34,7 @@ function runClean(source: string): ReturnType { return execution; } -const projectRoot = "/velar-marathon-core-tests"; +const projectRoot = join(tmpdir(), "velar-marathon-core-tests"); function projectSources(modules: Readonly>): Map { return new Map(Object.entries(modules).map(([name, text]) => [join(projectRoot, name), text])); diff --git a/tests/hardening-marathon-web.test.ts b/tests/hardening-marathon-web.test.ts index 84e0ac65..89c8a233 100644 --- a/tests/hardening-marathon-web.test.ts +++ b/tests/hardening-marathon-web.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; // Fix wave 2 of the marathon defect ledger (docs/decisions/archive/MARATHON-DEFECTS.md): // the Web runtime items. Each probe stays at the level the ledger's evidence diff --git a/tests/hardening-module-cycles.test.ts b/tests/hardening-module-cycles.test.ts index cd6a0404..6ab09c12 100644 --- a/tests/hardening-module-cycles.test.ts +++ b/tests/hardening-module-cycles.test.ts @@ -10,7 +10,7 @@ import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; const CYCLE = "VEL3019"; const CYCLE_MESSAGE = /Move this read into a function, or extract the shared value into a third module; '\.\/[a-z-]+\.vel' has not initialized when this line runs/u; -const projectRoot = "/velar-module-cycle-tests"; +const projectRoot = join(tmpdir(), "velar-module-cycle-tests"); async function checkProject( modules: Readonly>, diff --git a/tests/hardening-module-graph-containers.test.ts b/tests/hardening-module-graph-containers.test.ts new file mode 100644 index 00000000..4cbebf03 --- /dev/null +++ b/tests/hardening-module-graph-containers.test.ts @@ -0,0 +1,549 @@ +/// A-010: dependency discovery kept its own switch over statement and +/// expression kinds, and a `import("./dep.vel")` written in a container that +/// switch had never been taught — `try`, `using`, a `test "…":` body, a class +/// getter, `@dispose:`, `@iterate:` — left its module out of the graph with a +/// clean compile and exit 0. The main instance turned "the module exists and +/// loads" into `false`; its siblings crashed at run time with +/// ERR_MODULE_NOT_FOUND. +/// +/// The old gate for dynamic imports varied the *target* and never the +/// *container*, so it verified that one example existed rather than that every +/// container × every path works. These tests are that matrix, and the +/// container list is derived rather than typed out: hand-listing containers is +/// the same mistake in a second place. +import assert from "node:assert/strict"; +import { spawnSync } from "node:child_process"; +import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import test from "node:test"; +import { fileURLToPath } from "node:url"; +import { astNodes, CORE_STATEMENT_CONSTRUCTS } from "../packages/compiler/src/ast.ts"; +import { Lexer } from "../packages/compiler/src/lexer.ts"; +import { Parser } from "../packages/compiler/src/parser.ts"; +// Inspection and the extension type come from the built package, because that +// is what the Web and Desktop extensions are compiled against; the source +// declarations are the same shape, but a class inside one is nominal across +// the two builds. +import { inspectModule } from "@velarscript/compiler"; +import type { CompilerExtension } from "@velarscript/compiler/extension"; +import { velarCompilerExtension as webCompilerExtension } from "../packages/web/src/compiler.ts"; +import { velarCompilerExtension as desktopCompilerExtension } from "../packages/desktop/src/compiler.ts"; + +const cliPath = fileURLToPath(new URL("../packages/cli/src/cli.ts", import.meta.url)); +const examples = fileURLToPath(new URL("../examples", import.meta.url)); + +/** + * Every kind Core's expression union spells. The AST's own discriminator + * convention supplies the rest: an extension node is disjoint from Core by its + * `ExtensionExpression:`/`ExtensionStatement:` prefix, and the statement + * roster is `CORE_STATEMENT_CONSTRUCTS`, which `tsc` refuses to accept as + * incomplete. + */ +const CORE_EXPRESSION_KINDS: ReadonlySet = new Set([ + "LiteralExpression", "FStringExpression", "IdentifierExpression", "SuperExpression", "DynamicImportExpression", + "ListExpression", "ObjectExpression", "SpreadExpression", "UnaryExpression", "TryExpression", "BinaryExpression", + "AssignmentExpression", "ComparisonChainExpression", "ConditionalExpression", "IsExpression", + "ArrowFunctionExpression", "CallExpression", "MemberExpression", "IndexExpression", +]); +const isExpressionKind = (kind: string): boolean => CORE_EXPRESSION_KINDS.has(kind) || kind.startsWith("ExtensionExpression:"); +const isStatementKind = (kind: string): boolean => Object.hasOwn(CORE_STATEMENT_CONSTRUCTS, kind) || kind.startsWith("ExtensionStatement:"); + +interface PlacedNode { + readonly node: { readonly kind: string; readonly span: { start: number; end: number } }; + /** + * The slot path from the program root down to this node: one + * `OwnerKind.field` step per node boundary, with keyless shapes on the way + * (a `Parameter`, a `ClassFieldDeclaration`) folded into the field name. A + * class getter's body is `ClassDeclaration.getters` then + * `FunctionDeclaration.body`, which is what tells it apart from a method's — + * the exact distinction A-010's hand-written walk lost. + */ + readonly chain: readonly string[]; +} + +/** The same structural descent `astNodes` performs, carrying each node's slot path. */ +function placedNodes(root: unknown): PlacedNode[] { + const found: PlacedNode[] = []; + const visit = (value: unknown, ownerKind: string, field: string, chain: readonly string[]): void => { + if (typeof value !== "object" || value === null) return; + if (Array.isArray(value)) { + for (const element of value) visit(element, ownerKind, field, chain); + return; + } + const kind = (value as { kind?: unknown }).kind; + if (typeof kind === "string") { + const next = [...chain, `${ownerKind}.${field}`]; + found.push({ node: value as PlacedNode["node"], chain: next }); + for (const [key, child] of Object.entries(value)) visit(child, kind, key, next); + return; + } + for (const [key, child] of Object.entries(value)) visit(child, ownerKind, `${field}.${key}`, chain); + }; + for (const [key, child] of Object.entries(root as object)) visit(child, "Program", key, []); + return found; +} + +function parseProgram(text: string, extensions: readonly CompilerExtension[]): unknown { + const lexical = extensions.flatMap((extension) => extension.lexical ? [extension.lexical] : []); + const lexed = new Lexer(text, lexical).lex(); + const parsed = extensions.find((extension) => extension.parser)?.parser?.create(lexed.tokens, lexical).parse() + ?? new Parser(lexed.tokens, lexical).parse(); + return parsed.program; +} + +/** + * The corpus the container roster is derived from. `examples/tour` is the one + * corpus a gate already requires to spell every statement construct, so a + * container that reaches the language reaches this list too; `examples/app` is + * the same syntax under real structure. + */ +const corpusDirectories: readonly { readonly directory: string; readonly extensions: readonly CompilerExtension[] }[] = [ + { directory: join(examples, "tour", "core"), extensions: [] }, + { directory: join(examples, "tour", "web"), extensions: [webCompilerExtension] }, + { directory: join(examples, "tour", "desktop"), extensions: [desktopCompilerExtension] }, + { directory: join(examples, "app", "src"), extensions: [webCompilerExtension] }, +]; + +/** + * One container the tour does not spell in a form a probe can reach: its only + * `expose` publishes shorthand fields, whose value span is the key's, so + * rewriting it produces `{import(...)}` — a key, not a value. + */ +const extraCorpusSource = ` +component Panel(title: string) exposes Handle: + def focus(): + pass + + expose {focus: focus, loaded: import("./dep.vel")} + return

{title}

+`; + +interface CorpusSource { + readonly path: string; + readonly text: string; + readonly extensions: readonly CompilerExtension[]; +} + +async function corpusSources(): Promise { + const sources: CorpusSource[] = []; + for (const corpus of corpusDirectories) { + for (const name of (await readdir(corpus.directory)).filter((item) => item.endsWith(".vel"))) { + const path = join(corpus.directory, name); + sources.push({ path, text: await readFile(path, "utf8"), extensions: corpus.extensions }); + } + } + sources.push({ path: join(examples, "tour", "web", "expose-probe.vel"), text: extraCorpusSource, extensions: [webCompilerExtension] }); + return sources; +} + +interface CorpusSlots { + /** Every slot in the corpus that holds a statement or an expression. */ + readonly containers: ReadonlySet; + /** Those of them that hold a statement — a code region rather than a value. */ + readonly regions: ReadonlySet; +} + +async function corpusContainerSlots(): Promise { + const containers = new Set(); + const regions = new Set(); + for (const source of await corpusSources()) { + for (const placed of placedNodes(parseProgram(source.text, source.extensions))) { + if (!isExpressionKind(placed.node.kind) && !isStatementKind(placed.node.kind)) continue; + containers.add(placed.chain.at(-1)!); + if (isStatementKind(placed.node.kind)) regions.add(placed.chain.at(-1)!); + } + } + return { containers, regions }; +} + +const slotOwner = (slot: string): string => slot.slice(0, slot.indexOf(".")); + +test("every dynamic import the parser produces reaches the module graph, in every container the corpus spells", async () => { + const sources = await corpusSources(); + // One probe per distinct slot path: rewrite the expression at that position + // into `import("./dep.vel")` and require the module graph to have it. The + // positions come from the parsed AST, so a container added to the language + // and written into the tour enters this matrix without a line here. + const probes = new Map(); + const containerSlots = new Set(); + for (const source of sources) { + for (const placed of placedNodes(parseProgram(source.text, source.extensions))) { + if (isExpressionKind(placed.node.kind) || isStatementKind(placed.node.kind)) containerSlots.add(placed.chain.at(-1)!); + if (!isExpressionKind(placed.node.kind)) continue; + const key = `${source.path}|${placed.chain.join(">")}`; + if (!probes.has(key)) probes.set(key, { ...source, placed }); + } + } + assert.ok(probes.size > 500, `the corpus produced only ${probes.size} probe positions`); + + const missed: string[] = []; + const refusals = new Map>(); + const covered = new Set(); + for (const probe of probes.values()) { + const { span } = probe.placed.node; + const spliced = `${probe.text.slice(0, span.start)}import("./dep.vel")${probe.text.slice(span.end)}`; + const inspection = inspectModule(spliced, { path: probe.path, extensions: probe.extensions }); + const landed = placedNodes(parseProgram(spliced, probe.extensions)).filter((placed) => placed.node.kind === "DynamicImportExpression" + && (placed.node as unknown as { source: string }).source === "./dep.vel"); + // Whatever the parser produced, the module graph must have it. This is the + // matrix assertion, and it needs no idea of what a container is. + if (landed.length > 0 && !inspection.dependencies.some((dependency) => dependency.dynamic && dependency.source === "./dep.vel")) { + missed.push(`${probe.placed.chain.join(">")} in ${probe.path}`); + continue; + } + const chain = probe.placed.chain.join(">"); + const here = landed.filter((placed) => placed.chain.join(">").startsWith(chain)); + if (inspection.diagnostics.length === 0 && here.length > 0) { + for (const placed of here) for (const slot of placed.chain) covered.add(slot); + continue; + } + // The position refuses a dynamic import — an assignment target, a match + // pattern, a shorthand field name — or the parser recovered it somewhere + // else entirely. That is the language's answer, read off the parser rather + // than written down here as an exception. + const reason = inspection.diagnostics[0] ? `${inspection.diagnostics[0].code} ${inspection.diagnostics[0].message}` : "parsed as something else"; + for (const slot of probe.placed.chain) refusals.set(slot, (refusals.get(slot) ?? new Set()).add(reason)); + } + assert.deepEqual(missed, [], `dependency discovery skipped ${missed.length} container(s)`); + + // Every container the corpus spells either holds a dynamic import that the + // graph found, or refuses to hold one at all — and the refusal is the + // parser's, quoted here rather than assumed. + const unexplained = [...containerSlots] + .filter((slot) => !covered.has(slot)) + .filter((slot) => (refusals.get(slot)?.size ?? 0) === 0); + assert.deepEqual(unexplained, [], "container slots with neither a dynamic import nor a refusal"); + const uncovered = [...containerSlots].filter((slot) => !covered.has(slot)).sort(); + assert.deepEqual(uncovered, ["MatchValuePattern.values"], "the only container a dynamic import cannot be written into"); + + // The six containers A-010 named, held by their own names so the matrix + // cannot lose its subject to a corpus edit. + for (const anchor of [ + "TryExpression.value", + "UsingDeclaration.initializer", + "TestDeclaration.body", + "ClassDeclaration.getters", + "ClassDisposeBlock.body", + "ClassIterateBlock.body", + ]) assert.ok(covered.has(anchor), `${anchor} left the matrix`); +}); + +test("dependency discovery reaches a container the compiler has never been taught", () => { + // The structural walk is what makes a *new* container safe, and a new + // container is by definition one no case here knows. This is that container: + // a node shape the compiler has never seen, nested three levels deep. + const program = { + kind: "Program", + body: [{ + kind: "ExtensionStatement:probe:box", + compartments: [{ shelves: [{ kind: "ExtensionExpression:probe:slot", value: { kind: "DynamicImportExpression", source: "./deep.vel", sourceSpan: { start: 0, end: 0 }, span: { start: 0, end: 0 } } }] }], + span: { start: 0, end: 0 }, + }], + span: { start: 0, end: 0 }, + }; + const found = [...astNodes(program)].filter((node) => node.kind === "DynamicImportExpression"); + assert.equal(found.length, 1); + assert.equal((found[0] as unknown as { source: string }).source, "./deep.vel"); +}); + +const depModule = (slug: string): string => `print("loaded ${slug}")\n\nexport const name = "${slug}"\n`; + +const containerModule = ` +/// Every AST container that can hold an expression, each holding one dynamic +/// import of a module of its own, so a container the module graph skips loses +/// exactly one module and nothing else. +/// +/// \`runContainers()\` evaluates all of them, so \`velar run\` and \`velar test\` +/// reach every container rather than merely compiling it. + +type Dep: + readonly name: string + +let detached = false + +async def record(pending: Promise) -> string: + const loaded = await pending + return loaded.name + +async def detach(pending: Promise): + const loaded = await pending + detached = loaded.name == "async-statement" + +// VariableDeclaration.initializer +const variableInitializer = await import("./dep-variable-initializer.vel") + +let released = "none" + +class Owned: + constructor(const label: string): + pass + + @dispose: + // ClassDeclaration.dispose + released = await record(import("./dep-class-dispose.vel")) + +class Box: + // ClassDeclaration.fields.initializer + const fieldPending: Promise = import("./dep-class-field.vel") + let iteratePending: Promise = import("./dep-class-iterate-seed.vel") + let initPending: Promise + let items: List = ["one"] + + // ClassDeclaration.parameters.defaultValue + constructor(const seeded: Promise = import("./dep-class-parameter-default.vel")): + // ClassDeclaration.initialization + self.initPending = import("./dep-class-initialization.vel") + + // ClassDeclaration.getters + get getterPending() -> Promise: + return import("./dep-class-getter.vel") + + // ClassDeclaration.methods + async def methodBody() -> string: + return await record(import("./dep-class-method.vel")) + + // ClassDeclaration.iterate + @iterate: + self.iteratePending = import("./dep-class-iterate.vel") + return self.items + +// FunctionDeclaration.parameters.defaultValue +async def functionParameterDefault(pending: Promise = import("./dep-function-parameter-default.vel")) -> List: + // FunctionDeclaration.body + const inBody = await record(import("./dep-function-body.vel")) + return [await record(pending), inBody] + +// ReturnStatement.value +async def returnValue() -> Dep: + return await import("./dep-return-value.vel") + +async def branches() -> List: + let seen: List = [] + // IfStatement.condition + if (await import("./dep-if-condition.vel")).name == "if-condition": + // IfStatement.thenBody + seen.append(await record(import("./dep-if-then.vel"))) + else: + seen.append("unreachable") + if released == "impossible": + seen.append("unreachable") + else: + // IfStatement.elseBody + seen.append(await record(import("./dep-if-else.vel"))) + return seen + +async def loops() -> List: + let seen: List = [] + let rounds = 0 + // WhileStatement.condition + while rounds < 1 and (await import("./dep-while-condition.vel")).name == "while-condition": + // WhileStatement.body + seen.append(await record(import("./dep-while-body.vel"))) + rounds += 1 + // ForStatement.iterable + for item in [(await import("./dep-for-iterable.vel")).name]: + // ForStatement.body + seen.append(f"{item} {await record(import("./dep-for-body.vel"))}") + return seen + +async def matching() -> List: + let seen: List = [] + // MatchStatement.value + match (await import("./dep-match-value.vel")).name: + // MatchStatement.cases.guard + case _ if (await import("./dep-match-guard.vel")).name == "never": + seen.append("unreachable") + case _: + // MatchStatement.cases.body + seen.append(await record(import("./dep-match-body.vel"))) + return seen + +async def failures() -> List: + let seen: List = [] + try: + // TryStatement.tryBody + seen.append(await record(import("./dep-try-body.vel"))) + // ThrowStatement.value + throw Error((await import("./dep-throw-value.vel")).name) + catch error: + // TryStatement.catchBody + seen.append(f"{error.message} {await record(import("./dep-catch-body.vel"))}") + finally: + // TryStatement.finallyBody + seen.append(await record(import("./dep-finally-body.vel"))) + return seen + +async def assertions() -> List: + let seen: List = [] + // AssertStatement.condition + assert (await import("./dep-assert-condition.vel")).name == "assert-condition" + let unmet = false + try: + // AssertStatement.message — a message is evaluated only when the + // assertion fails, so only a failing one runs the container. + assert unmet else (await import("./dep-assert-message.vel")).name + catch error: + seen.append(error.message) + return seen + +async def assignments() -> List: + let last = "none" + // AssignmentStatement.value + last = (await import("./dep-assignment-value.vel")).name + let store: Record = {} + // AssignmentStatement.target + store[(await import("./dep-assignment-target.vel")).name] = last + return [last, store["assignment-target"] ?? "missing"] + +async def statements() -> List: + // ExpressionStatement.expression + print(f"container expression {(await import("./dep-expression-statement.vel")).name}") + // AsyncStatement.expression + async detach(import("./dep-async-statement.vel")) + return ["statements"] + +async def owned() -> List: + // UsingDeclaration.initializer + using resource = Owned((await import("./dep-using-initializer.vel")).name) + return [resource.label] + +export async def runContainers() -> List: + let seen: List = [] + const box = Box() + for item in box: + seen.append(item) + seen.append(variableInitializer.name) + seen.append(await record(box.fieldPending)) + seen.append(await record(box.seeded)) + seen.append(await record(box.initPending)) + seen.append(await record(box.getterPending)) + seen.append(await box.methodBody()) + seen.append(await record(box.iteratePending)) + for name in await functionParameterDefault(): + seen.append(name) + seen.append((await returnValue()).name) + for name in await branches(): + seen.append(name) + for name in await loops(): + seen.append(name) + for name in await matching(): + seen.append(name) + for name in await failures(): + seen.append(name) + for name in await assertions(): + seen.append(name) + for name in await assignments(): + seen.append(name) + for name in await statements(): + seen.append(name) + for name in await owned(): + seen.append(name) + seen.append(released) + let waited = 0 + while not detached and waited < 2000: + await Promise.sleep(5ms) + waited += 1 + seen.append(f"detached {detached}") + return seen +`.trimStart(); + +const entryModule = ` +/// The entry: \`velar run\` drives every container in ./containers.vel. + +import {runContainers} from "./containers.vel" + +for name in await runContainers(): + print(f"container {name}") +`.trimStart(); + +const testModule = ` +/// The same containers under \`velar test\`, plus the one container only a test +/// module has: the test body itself. + +import {runContainers} from "./containers.vel" + +test "every container's dynamic import resolves under velar test": + // TestDeclaration.body + const loaded = await import("./dep-test-body.vel") + assert loaded.name == "test-body" + const names = await runContainers() + assert names.size > 0 +`.trimStart(); + +test("every container carries its dynamic import through check, run, build, and test", async () => { + const directory = await mkdtemp(join(tmpdir(), "velar-module-graph-containers-")); + try { + await writeFile(join(directory, "velar.json"), JSON.stringify({ formatVersion: 2, entry: "main.vel", extensions: [] }), "utf8"); + await writeFile(join(directory, "containers.vel"), containerModule, "utf8"); + await writeFile(join(directory, "main.vel"), entryModule, "utf8"); + await writeFile(join(directory, "matrix.test.vel"), testModule, "utf8"); + + // The dynamic imports are read back out of the AST rather than listed: the + // slug in each path is one container's marker in every path's output, and + // the chain each import sits on is what the container roster is matched + // against below. + const slots = new Map(); + for (const [name, text] of [["containers.vel", containerModule], ["matrix.test.vel", testModule]] as const) { + for (const placed of placedNodes(parseProgram(text, []))) { + if (placed.node.kind !== "DynamicImportExpression") continue; + slots.set((placed.node as unknown as { source: string }).source, placed.chain); + } + void name; + } + for (const source of slots.keys()) { + const slug = source.replace(/^\.\/dep-/u, "").replace(/\.vel$/u, ""); + await writeFile(join(directory, `dep-${slug}.vel`), depModule(slug), "utf8"); + } + const runtimeSlugs = [...slots.keys()] + .filter((source) => source !== "./dep-test-body.vel") + .map((source) => source.replace(/^\.\/dep-/u, "").replace(/\.vel$/u, "")); + assert.ok(runtimeSlugs.length > 30, `only ${runtimeSlugs.length} containers were spelled`); + + // Derived roster: every container the corpus spells that belongs to the + // statement side of the AST — a slot a statement owns, or one holding a + // code region, which is what `@dispose:`, `@iterate:` and `constructor:` + // are (their blocks are neither statement nor expression nodes, so owner + // alone would leave out two of the six containers A-010 named). Extension + // statements are excluded: they have no `velar run` of their own, and the + // corpus matrix above already walks them. + // A new core container that reaches the tour fails this until the project + // above spells it too. + const spelled = new Set([...slots.values()].flatMap((chain) => [...chain])); + const corpus = await corpusContainerSlots(); + const required = [...corpus.containers] + .filter((slot) => isStatementKind(slotOwner(slot)) || corpus.regions.has(slot)) + .filter((slot) => !slotOwner(slot).startsWith("ExtensionStatement:")) + .sort(); + assert.ok(required.length > 30, `the corpus derived only ${required.length} core containers`); + assert.deepEqual(required.filter((slot) => !spelled.has(slot)), [], "core containers with no dynamic import in the matrix project"); + + const modules = (await readdir(directory)).filter((name) => name.endsWith(".vel")); + const checked = spawnSync(process.execPath, [cliPath, "check", directory], { encoding: "utf8" }); + assert.equal(checked.status, 0, checked.stderr); + // Every module in this project is reachable through exactly one container, + // so the count is the per-container assertion for `check`. + assert.match(checked.stdout, new RegExp(`Checked ${modules.length} modules`, "u")); + + const ran = spawnSync(process.execPath, [cliPath, "run", directory], { encoding: "utf8" }); + assert.equal(ran.status, 0, ran.stderr); + assert.deepEqual(runtimeSlugs.filter((slug) => !ran.stdout.includes(`loaded ${slug}`)), [], "containers whose module never loaded under velar run"); + assert.match(ran.stdout, /container detached true/u); + + const tested = spawnSync(process.execPath, [cliPath, "test", directory], { encoding: "utf8" }); + assert.equal(tested.status, 0, tested.stderr); + assert.match(tested.stdout, /1 passed, 0 failed/u); + assert.deepEqual([...runtimeSlugs, "test-body"].filter((slug) => !tested.stdout.includes(`loaded ${slug}`)), [], "containers whose module never loaded under velar test"); + + const output = join(directory, "dist"); + const built = spawnSync(process.execPath, [cliPath, "build", directory, "--out-dir", output], { encoding: "utf8" }); + assert.equal(built.status, 0, built.stderr); + const emitted = new Set(await readdir(output)); + assert.deepEqual(runtimeSlugs.filter((slug) => !emitted.has(`dep-${slug}.js`)), [], "containers whose module was not emitted by velar build"); + // A test module is not part of a production build, so its container's + // module is the one that must *not* be there. + assert.ok(!emitted.has("dep-test-body.js")); + } finally { + await rm(directory, { recursive: true, force: true }); + } +}); diff --git a/tests/hardening-reactivity.test.ts b/tests/hardening-reactivity.test.ts index faf20091..79c97d2d 100644 --- a/tests/hardening-reactivity.test.ts +++ b/tests/hardening-reactivity.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function compile(source: string) { return compileCore(source, { extensions: [velarCompilerExtension] }); diff --git a/tests/hardening-spelling.test.ts b/tests/hardening-spelling.test.ts index 5e686977..6ac3da71 100644 --- a/tests/hardening-spelling.test.ts +++ b/tests/hardening-spelling.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore, formatSource } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function compile(source: string) { return compileCore(source, { extensions: [velarCompilerExtension] }); diff --git a/tests/hardening-value-semantics.test.ts b/tests/hardening-value-semantics.test.ts index bddd137f..205a8cc8 100644 --- a/tests/hardening-value-semantics.test.ts +++ b/tests/hardening-value-semantics.test.ts @@ -1,6 +1,8 @@ import assert from "node:assert/strict"; import { spawnSync } from "node:child_process"; +import { tmpdir } from "node:os"; import test from "node:test"; +import { repositoryRoot } from "./repository-root.ts"; import { join, resolve } from "node:path"; import { compile } from "@velarscript/compiler"; import { compileProject } from "../packages/cli/src/project.ts"; @@ -37,7 +39,7 @@ function rejects(source: string, pattern: RegExp): void { assert.ok(matched, `${source}\nexpected ${String(pattern)}, received ${JSON.stringify(result.diagnostics.map((item) => item.message))}`); } -const projectRoot = "/velar-value-semantics-tests"; +const projectRoot = join(tmpdir(), "velar-value-semantics-tests"); function projectSources(modules: Readonly>): Map { return new Map(Object.entries(modules).map(([name, text]) => [join(projectRoot, name), text])); @@ -332,7 +334,7 @@ print(str(rows.sorted(by=row => row.name).size)) test("[D42 65] exactly one predicate answers \"is this ordered\"", async () => { const analyzer = await import("node:fs/promises") - .then((fs) => fs.readFile(resolve(new URL("..", import.meta.url).pathname, "packages/compiler/src/analyzer.ts"), "utf8")); + .then((fs) => fs.readFile(resolve(repositoryRoot, "packages/compiler/src/analyzer.ts"), "utf8")); // Four mechanisms giving three answers was the structural root of ORD-1/2/3. // The retired names must not come back. assert.ok(!/defaultSortableType/u.test(analyzer), "defaultSortableType came back"); diff --git a/tests/hardening-wave-c2.test.ts b/tests/hardening-wave-c2.test.ts index 2ea5e21b..df136341 100644 --- a/tests/hardening-wave-c2.test.ts +++ b/tests/hardening-wave-c2.test.ts @@ -421,7 +421,11 @@ class TimeoutError extends Error: // NEW-D8 — `velar fix` reports what it changed // --------------------------------------------------------------------------- -test("[NEW-D8] a failed write is named and the rewrites that already landed are still reported", async () => { +test("[NEW-D8] a failed write is named and the rewrites that already landed are still reported", { + // chmod does not make a file unwritable on Windows; the contract is covered + // on both POSIX CI hosts while the rest of `velar fix` remains cross-platform. + skip: process.platform === "win32", +}, async () => { const project = await cliProject({ "src/other.vel": "export const c: Array = [3]\n", "src/main.vel": ` diff --git a/tests/hardening-wave-m-test-blocks.test.ts b/tests/hardening-wave-m-test-blocks.test.ts index 6416ec84..bcb4352b 100644 --- a/tests/hardening-wave-m-test-blocks.test.ts +++ b/tests/hardening-wave-m-test-blocks.test.ts @@ -5,11 +5,12 @@ import { mkdir, writeFile } from "node:fs/promises"; import { join, resolve } from "node:path"; import { compile } from "@velarscript/compiler"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; import { after } from "node:test"; // D39 item 53 — `test "name":` blocks. -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; after(async () => { await removeTemporaryDirectories(); diff --git a/tests/hardening-wave-z2.test.ts b/tests/hardening-wave-z2.test.ts index e3c3acb4..8ebe9527 100644 --- a/tests/hardening-wave-z2.test.ts +++ b/tests/hardening-wave-z2.test.ts @@ -1,5 +1,6 @@ import assert from "node:assert/strict"; import { spawnSync } from "node:child_process"; +import { tmpdir } from "node:os"; import { join } from "node:path"; import test from "node:test"; import { applyMechanicalFixes, compile } from "@velarscript/compiler"; @@ -7,7 +8,7 @@ import { TEXT_NAMESPACE_MEMBERS } from "@velarscript/compiler/extension"; import { compileProject, type ProjectResult } from "../packages/cli/src/project.ts"; import { standardModuleInterfaces, standardModuleSources } from "../packages/cli/src/standard-modules.ts"; -const projectRoot = "/velar-wave-z2-modules"; +const projectRoot = join(tmpdir(), "velar-wave-z2-modules"); async function checkProject(modules: Readonly>, entry: string): Promise { const overrides = new Map(Object.entries(modules).map(([name, text]) => [join(projectRoot, name), text])); diff --git a/tests/hardening-web-runtime.test.ts b/tests/hardening-web-runtime.test.ts index ab5922ec..5bcadbc4 100644 --- a/tests/hardening-web-runtime.test.ts +++ b/tests/hardening-web-runtime.test.ts @@ -4,8 +4,9 @@ import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import test from "node:test"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; // Wave N-2w of the Web surface audit (docs/decisions/archive/COMPLETENESS-AUDITS.md, // 审计九): the Web runtime hotfixes. Each regression runs at the level the diff --git a/tests/hardening-web-surface.test.ts b/tests/hardening-web-surface.test.ts index fce3a1c1..db9df150 100644 --- a/tests/hardening-web-surface.test.ts +++ b/tests/hardening-web-surface.test.ts @@ -6,6 +6,7 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { velarCompilerExtension, webModuleInterfaces } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; // Wave N-2c: the Web surface items of completeness audits nine, ten, and eleven // (docs/decisions/archive/COMPLETENESS-AUDITS.md) plus D47 rule 84. Each probe sits at the @@ -14,7 +15,7 @@ import { velarCompilerExtension, webModuleInterfaces } from "../packages/web/src // two Look forms that stay reactive, real computed layout from Look lengths, // bind member paths, and bind:group -- run in Chromium. -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function compile(text: string) { const imports = new Map(); diff --git a/tests/hardening-web-syntax.test.ts b/tests/hardening-web-syntax.test.ts index 6379dcd5..6aa8c82a 100644 --- a/tests/hardening-web-syntax.test.ts +++ b/tests/hardening-web-syntax.test.ts @@ -6,8 +6,9 @@ import { join, resolve } from "node:path"; import test from "node:test"; import { compile as compileCore } from "@velarscript/compiler"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +import { repositoryRoot } from "./repository-root.ts"; -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; function compile(source: string) { return compileCore(source, { extensions: [velarCompilerExtension] }); diff --git a/tests/installed-browser.acceptance.ts b/tests/installed-browser.acceptance.ts index 18834ae5..fd9f7dcb 100644 --- a/tests/installed-browser.acceptance.ts +++ b/tests/installed-browser.acceptance.ts @@ -4,52 +4,29 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import { fileURLToPath } from "node:url"; +import { velarPackageNames } from "../scripts/velar-packages.mjs"; const root = resolve(fileURLToPath(new URL("..", import.meta.url))); const directory = await mkdtemp(join(tmpdir(), "velar-installed-browser-")); try { - const compiler = await pack("@velarscript/compiler"); - const node = await pack("@velarscript/node"); - const web = await pack("@velarscript/web"); - const create = await pack("create-velar"); - const cli = await pack("@velarscript/cli"); - const desktop = await pack("@velarscript/desktop"); - const textBuffer = await pack("@velarscript/text-buffer"); - const scriptAnalysis = await pack("@velarscript/script-analysis"); + // A-024: this file held the fifth copy of the eight-package roster — one + // literal `pack()` list and four literal install lists — while + // `docs/contributing/continuous-integration.md` said the installed set is + // derived from `packages/*`. A publishable package added to the workspace + // was packed, content-checked and installed by `test:packages` on the day it + // existed, and never entered the installed-toolchain acceptance at all. + const tarballs: string[] = []; + for (const name of await velarPackageNames(root)) tarballs.push(join(directory, await pack(name))); + /** Every packed tarball, as one `npm install` takes them. */ + const install = (extra: readonly string[], cwd: string) => + runNpm(["install", ...extra, "--ignore-scripts", "--no-audit", "--no-fund", ...tarballs], cwd); await writeFile(join(directory, "package.json"), "{}\n", "utf8"); - await runNpm([ - "install", - "--ignore-scripts", - "--no-audit", - "--no-fund", - join(directory, compiler), - join(directory, node), - join(directory, web), - join(directory, create), - join(directory, cli), - join(directory, desktop), - join(directory, textBuffer), - join(directory, scriptAnalysis), - ], directory); + await install([], directory); const installedCli = join(directory, "node_modules", "@velarscript", "cli", "dist", "cli.js"); const application = join(directory, "Team & App"); await run(process.execPath, [installedCli, "create", application], directory); - await runNpm([ - "install", - "--save-dev", - "--ignore-scripts", - "--no-audit", - "--no-fund", - join(directory, compiler), - join(directory, node), - join(directory, web), - join(directory, create), - join(directory, cli), - join(directory, desktop), - join(directory, textBuffer), - join(directory, scriptAnalysis), - ], application); + await install(["--save-dev"], application); await writeFile(join(application, "src", "web-contract.vel"), ` import {onError} from "velar/app" import {environment} from "velar/browser" @@ -95,21 +72,7 @@ mount(, "#app") const documentation = join(directory, "Product Docs"); await run(process.execPath, [installedCli, "create", documentation, "--template", "docs"], directory); - await runNpm([ - "install", - "--save-dev", - "--ignore-scripts", - "--no-audit", - "--no-fund", - join(directory, compiler), - join(directory, node), - join(directory, web), - join(directory, create), - join(directory, cli), - join(directory, desktop), - join(directory, textBuffer), - join(directory, scriptAnalysis), - ], documentation); + await install(["--save-dev"], documentation); await runNpm(["run", "format:check"], documentation); await runNpm(["run", "check"], documentation); await runNpm(["test"], documentation); @@ -121,21 +84,7 @@ mount(, "#app") const component = join(directory, "Info Card"); await run(process.execPath, [installedCli, "create", component, "--template", "component"], directory); - await runNpm([ - "install", - "--save-dev", - "--ignore-scripts", - "--no-audit", - "--no-fund", - join(directory, compiler), - join(directory, node), - join(directory, web), - join(directory, create), - join(directory, cli), - join(directory, desktop), - join(directory, textBuffer), - join(directory, scriptAnalysis), - ], component); + await install(["--save-dev"], component); const componentManifest = JSON.parse(await readFile(join(component, "package.json"), "utf8")) as { files: string[]; velar: { entry: string }; diff --git a/tests/module-enum-surface.test.ts b/tests/module-enum-surface.test.ts index bc2b9bd6..cda39123 100644 --- a/tests/module-enum-surface.test.ts +++ b/tests/module-enum-surface.test.ts @@ -10,6 +10,7 @@ import { velarCompilerExtension as desktopExtension } from "../packages/desktop/ import { velarNodeCompilerExtension as nodeExtension } from "../packages/node/src/compiler.ts"; import { velarCompilerExtension as webExtension } from "../packages/web/src/compiler.ts"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; // --------------------------------------------------------------------------- // D60 rule 149 — the derived gate that pins a registration to its runtime. @@ -124,6 +125,8 @@ test("[D60-149] the extensions still register the module-provided enums this gat // sweep. The list grows with the language; it may not silently shrink. const covered = enums.map((item) => `${item.label} ${item.specifier} ${item.name}`).sort(); assert.deepEqual(covered, [ + "@velarscript/desktop velar/desktop ProjectChangeLifecycle", + "@velarscript/desktop velar/desktop ProjectChangeRisk", "@velarscript/desktop velar/desktop ProjectTaskCommand", "@velarscript/desktop velar/desktop ProjectTaskOutputChannel", "@velarscript/desktop velar/http HttpTransportPhase", @@ -173,8 +176,6 @@ for (const item of enums) { // callable from VelarScript rather than from a Node import. // --------------------------------------------------------------------------- -const repositoryRoot = resolve(new URL("..", import.meta.url).pathname); - test("[D60-149] velar/http's enum answers all three names inside a built page", { timeout: 300_000 }, async () => { const directory = await makeTemporaryDirectory("velar-enum-browser-"); await mkdir(join(directory, "src"), { recursive: true }); diff --git a/tests/node-platform.test.ts b/tests/node-platform.test.ts index bcff56a2..ce93d0d6 100644 --- a/tests/node-platform.test.ts +++ b/tests/node-platform.test.ts @@ -4,6 +4,7 @@ import { ChildProcess, spawn } from "node:child_process"; import { EventEmitter } from "node:events"; import { createServer } from "node:http"; import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { createConnection } from "node:net"; import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import { StringDecoder } from "node:string_decoder"; @@ -70,6 +71,26 @@ async function materializeNodeRuntimeDependencies( const WATCHED_CHANGE_RETRIGGER_MS = 250; const WATCHED_CHANGE_TIMEOUT_MS = 30_000; +function receivesTcpToken(port: number, token: string): Promise { + return new Promise((resolveProbe) => { + const socket = createConnection({ host: "127.0.0.1", port }); + let received = ""; + let settled = false; + const finish = (result: boolean): void => { + if (settled) return; + settled = true; + clearTimeout(timer); + socket.destroy(); + resolveProbe(result); + }; + const timer = setTimeout(() => finish(false), 1000); + socket.setEncoding("utf8"); + socket.on("data", (chunk) => { received += chunk; }); + socket.once("end", () => finish(received === token)); + socket.once("error", () => finish(false)); + }); +} + /** * Awaits one reported filesystem change, re-triggering it while the pull is * outstanding. `fs.watch` with `recursive: true` arms its macOS FSEvents @@ -178,7 +199,7 @@ print(childOutput) }); test("Node HTTP and serve typed parsing reject Promise-assimilated result shapes", async () => { - const entry = "/tmp/velar-node-http-parse-hazard/main.vel"; + const entry = join(tmpdir(), "velar-node-http-parse-hazard", "main.vel"); const source = ` import {http} from "velar/http" import {ServeRequest} from "velar/serve" @@ -428,6 +449,7 @@ test("Node terminal worker releases idle imports and close cancels a pending fd try { const source = nodeModuleSources.get("velar/terminal"); assert.ok(source); + assert.match(source, /spawn\(process\.execPath/u); await writeFile(join(directory, "terminal.mjs"), source, "utf8"); await writeFile(join(directory, "idle.mjs"), ` import {terminal} from "./terminal.mjs"; @@ -1574,26 +1596,21 @@ test("Node process and HTTP runtimes preserve secret, cancellation, timeout, and const running = await processRuntime.start(process.execPath, ["-e", "setTimeout(() => {}, 10000)"], { timeout: 0 }); await running.stop(); assert.equal((await running.wait()).signal, "SIGTERM"); - const tree = await processRuntime.start(process.execPath, ["-e", "const {spawn}=require('node:child_process'); const child=spawn(process.execPath,['-e','setTimeout(()=>{},10000)'],{stdio:['ignore','inherit','inherit']}); process.stdout.write(String(child.pid)); setTimeout(()=>{},10000)"], { timeout: 0 }); - await new Promise(resolve => setTimeout(resolve, 50)); - await tree.stop(); - const treeResult = await tree.wait(); - const descendantPid = Number(treeResult.stdout); - assert.equal(Number.isSafeInteger(descendantPid), true); - // `stop()` kills the whole tree, but the host reaps it asynchronously, so the - // descendant can still be present the instant `wait()` resolves — observed - // under a loaded full-suite run, not when this file runs alone. The contract - // is that the descendant goes away with its owner, not that it is already - // gone on the first sample, so poll for ESRCH within a bounded window. - let descendantProbe: unknown = null; - for (let attempt = 0; attempt < 100; attempt += 1) { - try { process.kill(descendantPid, 0); await new Promise((resolveWait) => setTimeout(resolveWait, 20)); } - catch (error) { descendantProbe = error; break; } + const descendantToken = `velar-descendant-${process.pid}-${Date.now()}`; + const descendantSource = `const {createServer}=require("node:net"); const server=createServer(socket=>socket.end(${JSON.stringify(descendantToken)})); server.listen(0,"127.0.0.1",()=>process.stdout.write(String(server.address().port)+"\\n"));`; + const tree = await processRuntime.start(process.execPath, ["-e", `const {spawn}=require("node:child_process"); const child=spawn(process.execPath,["-e",${JSON.stringify(descendantSource)}],{stdio:["ignore","pipe","inherit"]}); child.stdout.on("data",chunk=>process.stdout.write(chunk)); setTimeout(()=>{},10000);`], { timeout: 0 }); + let descendantPortText = ""; + while (!descendantPortText.includes("\n")) { + const output = await tree.next(); + assert.ok(output); + if (output.channel === "stdout") descendantPortText += output.text; } - assert.ok( - descendantProbe instanceof Error && "code" in descendantProbe && descendantProbe.code === "ESRCH", - "stopping a process must reap its descendant tree", - ); + const descendantPort = Number(descendantPortText.trim()); + assert.equal(Number.isSafeInteger(descendantPort), true); + assert.equal(await receivesTcpToken(descendantPort, descendantToken), true, "the descendant capability must be live before stop"); + await tree.stop(); + await tree.wait(); + assert.equal(await receivesTcpToken(descendantPort, descendantToken), false, "a completed stop must retire descendant capabilities"); if (process.platform !== "win32") { const timeoutDirectory = await mkdtemp(join(tmpdir(), "velar-process-timeout-")); diff --git a/tests/package-contract.test.ts b/tests/package-contract.test.ts new file mode 100644 index 00000000..23564932 --- /dev/null +++ b/tests/package-contract.test.ts @@ -0,0 +1,201 @@ +import assert from "node:assert/strict"; +import { spawnSync } from "node:child_process"; +import { mkdir, readFile, writeFile } from "node:fs/promises"; +import { dirname, join, resolve } from "node:path"; +import test, { after } from "node:test"; +import { fileURLToPath } from "node:url"; +import { velarBuildOrder, velarPublishedPackages } from "../scripts/velar-packages.mjs"; +import { declaredEntryPaths, declaredImportSpecifiers, packageContentFailures, type PackedPackage } from "./package-contract.ts"; +import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; + +// --------------------------------------------------------------------------- +// A-024 — `test:packages` is the release boundary, and it was checking a set it +// had stopped deriving. `velarPackageNames()` produced the roster, `pack()` +// consumed it, and everything after `pack()` re-spelled the same eight names by +// hand: content checks over six of them, an install listing eight literal +// tarball paths, and a sixth copy in the `gate:build:packages` npm script. +// +// The probe that found it added one publishable package with no LICENSE, no +// README, no `dist`, and an `exports` pointing at a file that does not exist. +// `npm run test:packages` printed "VelarScript packed toolchain consumer +// acceptance passed" and exited 0, while the same package's tarball held +// exactly one file and a clean consumer importing it died with +// ERR_MODULE_NOT_FOUND. +// +// These tests rebuild that package and prove the contract now refuses it, in +// both places the old gate waved it through: the tarball's contents, and a real +// consumer's `import`. +// --------------------------------------------------------------------------- + +const root = resolve(dirname(fileURLToPath(import.meta.url)), ".."); + +after(removeTemporaryDirectories); + +/** The manifest from the A-024 reproduction, verbatim. */ +const brokenManifest = { + name: "@velarscript/broken-probe", + version: "0.10.0", + license: "UNLICENSED", + type: "module", + exports: "./dist/does-not-exist.js", +} as const; + +function npm(arguments_: readonly string[], cwd: string): { status: number | null; stdout: string; stderr: string } { + const execpath = process.env.npm_execpath; + const execution = execpath + ? spawnSync(process.execPath, [execpath, ...arguments_], { cwd, encoding: "utf8", timeout: 300_000 }) + : spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", arguments_, { cwd, encoding: "utf8", timeout: 300_000 }); + return { status: execution.status, stdout: execution.stdout ?? "", stderr: execution.stderr ?? "" }; +} + +/** A package directory, packed for real, reported the way `npm pack` reports it. */ +async function packageOf(manifest: object, files: Record = {}): Promise<{ directory: string; packed: PackedPackage }> { + const directory = join(await makeTemporaryDirectory("velar-package-contract-"), "package"); + await mkdir(directory, { recursive: true }); + await writeFile(join(directory, "package.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8"); + for (const [path, content] of Object.entries(files)) { + await mkdir(dirname(join(directory, path)), { recursive: true }); + await writeFile(join(directory, path), content, "utf8"); + } + const result = npm(["pack", "--dry-run", "--json", "--ignore-scripts", directory], directory); + assert.equal(result.status, 0, result.stderr); + const packed = JSON.parse(result.stdout) as PackedPackage[]; + assert.equal(packed.length, 1, result.stdout); + return { directory, packed: packed[0]! }; +} + +test("[A-024] a crippled publishable package fails the content contract", async () => { + const { packed } = await packageOf(brokenManifest); + // The reproduction's own evidence: one file in the tarball. + assert.equal(packed.files.length, 1, JSON.stringify(packed.files)); + const failures = packageContentFailures(brokenManifest, packed); + assert.ok(failures.some((failure) => failure.includes("no LICENSE")), failures.join("\n")); + assert.ok(failures.some((failure) => failure.includes("no README.md")), failures.join("\n")); + assert.ok( + failures.some((failure) => failure.includes("points at 'dist/does-not-exist.js', which is not in the tarball")), + failures.join("\n"), + ); +}); + +test("[A-024] a crippled publishable package fails a clean consumer's import", async () => { + // The other half, and the one that matters on release day: the package + // installs without complaint and the first `import` of it fails. The gate's + // consumer step imports every specifier each manifest publishes, derived the + // same way, so this package cannot reach a consumer un-imported. + const { directory } = await packageOf(brokenManifest); + const consumer = await makeTemporaryDirectory("velar-broken-consumer-"); + await writeFile(join(consumer, "package.json"), `${JSON.stringify({ name: "broken-consumer", private: true, type: "module" }, null, 2)}\n`, "utf8"); + const installed = join(consumer, "node_modules", "@velarscript", "broken-probe"); + await mkdir(installed, { recursive: true }); + // Installed the way npm lays a tarball down, without asking a registry for + // anything: this test must run on a machine with no network. + await writeFile(join(installed, "package.json"), await readFile(join(directory, "package.json"), "utf8"), "utf8"); + + const specifiers = declaredImportSpecifiers(brokenManifest); + assert.deepEqual(specifiers, ["@velarscript/broken-probe"]); + const execution = spawnSync(process.execPath, [ + "--input-type=module", + "--eval", + specifiers.map((specifier) => `await import(${JSON.stringify(specifier)});`).join("\n"), + ], { cwd: consumer, encoding: "utf8", timeout: 300_000 }); + assert.equal(execution.status, 1, `${execution.stdout ?? ""}${execution.stderr ?? ""}`); + assert.match(execution.stderr ?? "", /ERR_MODULE_NOT_FOUND/u); +}); + +test("[A-024] a package that keeps its promises passes both halves", async () => { + // The contract has to be satisfiable, or the test above proves only that it + // refuses everything. + const manifest = { + name: "velar-contract-probe", + version: "0.10.0", + license: "Apache-2.0", + type: "module", + files: ["dist", "README.md"], + exports: { ".": { types: "./dist/index.d.ts", default: "./dist/index.js" } }, + bin: { "contract-probe": "./dist/cli.js" }, + }; + const { packed } = await packageOf(manifest, { + LICENSE: "Apache License\n", + "README.md": "# probe\n", + "dist/index.js": "export const value = 1\n", + "dist/index.d.ts": "export declare const value: number;\n", + "dist/cli.js": "#!/usr/bin/env node\n", + }); + assert.deepEqual(packageContentFailures(manifest, packed), []); +}); + +test("[A-024] the contract is derived from the manifest, not from a list of names", async () => { + // A subpath nobody has written before is required the day a manifest names + // it. This is the property the old gate lost: its checks named packages, so + // they could only ever check the packages somebody had named. + const manifest = { + name: "velar-contract-probe", + version: "0.10.0", + type: "module", + exports: { + ".": { default: "./dist/index.js" }, + "./brand-new-subpath": { types: "./dist/brand-new.d.ts", default: "./dist/brand-new.js" }, + }, + velar: { entry: "src/index.vel" }, + }; + assert.deepEqual(declaredEntryPaths(manifest), [ + "dist/index.js", + "dist/brand-new.d.ts", + "dist/brand-new.js", + "src/index.vel", + ]); + assert.deepEqual(declaredImportSpecifiers(manifest), ["velar-contract-probe", "velar-contract-probe/brand-new-subpath"]); + const { packed } = await packageOf(manifest, { LICENSE: "x\n", "README.md": "x\n", "dist/index.js": "export const value = 1\n" }); + const failures = packageContentFailures(manifest, packed); + assert.ok(failures.some((failure) => failure.includes("dist/brand-new.js")), failures.join("\n")); + assert.ok(failures.some((failure) => failure.includes("src/index.vel")), failures.join("\n")); +}); + +test("[A-024] every publishable package that declares a build is built, dependencies first", async () => { + // The third copy of the roster was the `gate:build:packages` npm script, six + // workspaces chained by hand. A publishable package added with a build script + // would have been packed and content-checked against a `dist` nothing built. + const published = await velarPublishedPackages(root); + const order = await velarBuildOrder(root); + const built = order.map((package_) => package_.name); + const shouldBuild = published.filter((package_) => package_.manifest.scripts?.build).map((package_) => package_.name); + assert.deepEqual([...built].sort(), [...shouldBuild].sort(), "a publishable package declares a build the gate does not run"); + for (const [index, package_] of order.entries()) { + const workspaceDependencies = Object.keys(package_.manifest.dependencies ?? {}).filter((name) => built.includes(name)); + for (const dependency of workspaceDependencies) { + assert.ok(built.indexOf(dependency) < index, `${package_.name} is built before its workspace dependency ${dependency}`); + } + } + const manifest = JSON.parse(await readFile(join(root, "package.json"), "utf8")) as { scripts: Record }; + assert.equal(manifest.scripts["gate:build:packages"], "node scripts/build-packages.mjs"); +}); + +test("[A-024] the release gate walks the derived roster", async () => { + // Structural, and deliberately so: what went wrong was not a wrong list, it + // was a second list. The acceptance script may name a package to make a + // specific claim about it — `native/macos/VelarDesktopHost.swift` is a fact + // about Desktop alone — but the roster it walks has to be the derived one. + const acceptance = await readFile(join(root, "tests", "package.acceptance.ts"), "utf8"); + assert.match(acceptance, /const published = await velarPublishedPackages\(root\)/u); + assert.match(acceptance, /published\.flatMap\(\(package_\) => packageContentFailures\(package_\.manifest, named\(package_\.name\)\)\)/u); + assert.match(acceptance, /\.\.\.published\.map\(\(package_\) => join\(directory, named\(package_\.name\)\.filename\)\)/u); + // And no tarball path is spelled out beside them. + assert.doesNotMatch(acceptance, /join\(directory, (?:compiler|node|web|create|cli|desktop|textBuffer|scriptAnalysis)\.filename\)/u); +}); + +test("[A-024] every acceptance script that installs the toolchain derives its set", async () => { + // The first repair covered `package.acceptance.ts` and left the copy in + // `installed-browser.acceptance.ts` standing — one literal `pack()` list and + // four literal install lists — under a documentation sentence that already + // claimed the browser job installs the derived set. Naming both files here is + // the point: a meta-test that reads one file is itself a hand-kept list. + for (const name of ["package.acceptance.ts", "installed-browser.acceptance.ts"]) { + const source = await readFile(join(root, "tests", name), "utf8"); + assert.match(source, /velar-packages\.mjs/u, `${name} installs the toolchain without reading the derived roster`); + assert.doesNotMatch( + source, + /await pack\("(?:@velarscript\/[a-z-]+|create-velar)"\)/u, + `${name} packs a package by literal name; pack whatever packages/* publishes`, + ); + } +}); diff --git a/tests/package-contract.ts b/tests/package-contract.ts new file mode 100644 index 00000000..82121bbb --- /dev/null +++ b/tests/package-contract.ts @@ -0,0 +1,114 @@ +import type { VelarPackageManifest } from "../scripts/velar-packages.mjs"; + +// --------------------------------------------------------------------------- +// A-024 — what a published VelarScript package must contain, derived from what +// the package itself promises. +// +// `test:packages` packed a derived roster (`velarPackageNames`) and then wrote +// the same eight names out again by hand: the content checks walked six of +// them, the clean install listed eight tarball paths, and `gate:build:packages` +// held a sixth copy. The commit that derived the roster said a new package +// "joins the gate the day it exists"; that was true of `pack()` and of nothing +// after it. A publishable package with no LICENSE, no README, no `dist`, and an +// `exports` pointing at a file that does not exist passed the whole gate with +// exit 0 while a real consumer importing it got ERR_MODULE_NOT_FOUND. +// +// So the contract below asks the manifest, not a list. Every path a manifest +// promises a consumer — `main`, `types`, `bin`, every string leaf of `exports`, +// `velar.entry` — must be inside the tarball, and every specifier those +// promises create must resolve after a clean install. A package that publishes +// a new export subpath is checked for it without anybody editing this file, and +// a package added to the workspace is checked at all. +// --------------------------------------------------------------------------- + +/** One file inside a packed tarball, as `npm pack --json` reports it. */ +export interface PackedFile { + readonly path: string; +} + +/** One packed tarball, as `npm pack --json` reports it. */ +export interface PackedPackage { + readonly filename: string; + readonly files: readonly PackedFile[]; +} + +/** Every file path a manifest promises a consumer, in declaration order. */ +export function declaredEntryPaths(manifest: VelarPackageManifest): string[] { + const paths: string[] = []; + const add = (value: unknown): void => { + if (typeof value !== "string" || value === "") return; + const path = value.startsWith("./") ? value.slice(2) : value; + if (!paths.includes(path)) paths.push(path); + }; + add(manifest.main); + add(manifest.types); + // `exports` is a tree of conditions whose leaves are all file targets, so the + // walk is structural: a condition this file has never heard of is still read. + const walk = (value: unknown): void => { + if (typeof value === "string") return add(value); + if (Array.isArray(value)) return void value.forEach(walk); + if (value !== null && typeof value === "object") return void Object.values(value).forEach(walk); + }; + walk(manifest.exports); + if (typeof manifest.bin === "string") add(manifest.bin); + else for (const value of Object.values(manifest.bin ?? {})) add(value); + add(manifest.velar?.entry); + return paths; +} + +/** + * The import specifiers a clean consumer must be able to resolve. A `.vel` + * source package publishes no JavaScript entry point — the Vel toolchain reads + * its `velar.entry` — so it contributes none, and its entry file is checked as + * a path instead. + */ +export function declaredImportSpecifiers(manifest: VelarPackageManifest): string[] { + const exports = manifest.exports; + if (typeof exports === "string") return [manifest.name]; + if (exports === null || typeof exports !== "object" || Array.isArray(exports)) { + return manifest.main !== undefined ? [manifest.name] : []; + } + const specifiers: string[] = []; + for (const key of Object.keys(exports)) { + // A subpath key starts with '.'; anything else is a condition name at the + // top level, which means the whole object describes the '.' entry. + if (!key.startsWith(".")) return [manifest.name]; + if (key.includes("*")) continue; + specifiers.push(key === "." ? manifest.name : `${manifest.name}/${key.slice(2)}`); + } + return specifiers; +} + +/** A `*` target matched against the tarball's file list. */ +function matchesPattern(pattern: string, paths: readonly string[]): boolean { + const expression = new RegExp(`^${pattern.split("*").map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("[^\\n]*")}$`, "u"); + return paths.some((path) => expression.test(path)); +} + +/** + * Everything wrong with one published package, as a list of sentences. Empty + * means the package satisfies what it promises; the caller decides how loudly + * to say so. + */ +export function packageContentFailures(manifest: VelarPackageManifest, packed: PackedPackage): string[] { + const paths = packed.files.map((file) => file.path); + const failures: string[] = []; + const has = (path: string): boolean => paths.includes(path); + // Every published package carries its licence and its public README. Neither + // is declared in `files` — npm includes them — so an empty package fails here + // before anything else is examined. + if (!has("LICENSE")) failures.push(`${manifest.name}: the tarball carries no LICENSE`); + if (!has("README.md")) failures.push(`${manifest.name}: the tarball carries no README.md`); + const declared = declaredEntryPaths(manifest); + if (declared.length === 0) { + failures.push(`${manifest.name}: the manifest promises a consumer no entry point at all — no 'main', 'types', 'exports', 'bin' or 'velar.entry'`); + } + for (const path of declared) { + const present = path.includes("*") ? matchesPattern(path, paths) : has(path); + if (!present) failures.push(`${manifest.name}: the manifest points at '${path}', which is not in the tarball (${paths.length} file${paths.length === 1 ? "" : "s"} packed)`); + } + for (const path of paths) { + if (/(?:^|\/)tests?(?:\/|$)/u.test(path)) failures.push(`${manifest.name}: the tarball ships '${path}'; tests are not published`); + } + return failures; +} diff --git a/tests/package.acceptance.ts b/tests/package.acceptance.ts index 2cbe2f9e..200f8f68 100644 --- a/tests/package.acceptance.ts +++ b/tests/package.acceptance.ts @@ -4,7 +4,8 @@ import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import { spawn } from "node:child_process"; import { fileURLToPath, pathToFileURL } from "node:url"; -import { velarPackageNames } from "../scripts/velar-packages.mjs"; +import { velarPublishedPackages } from "../scripts/velar-packages.mjs"; +import { declaredEntryPaths, declaredImportSpecifiers, packageContentFailures, type PackedPackage } from "./package-contract.ts"; const root = resolve(fileURLToPath(new URL("..", import.meta.url))); const directory = await mkdtemp(join(tmpdir(), "velar-packages-")); @@ -15,8 +16,16 @@ try { // that has to be kept level with it. A package added to the workspace is // packed by this gate the day it exists, and an install that needs it cannot // silently go untested. - const packed = new Map>>(); - for (const name of await velarPackageNames(root)) packed.set(name, await pack(name)); + // + // A-024: the roster was derived and then immediately re-spelled by hand for + // everything that came after `pack()`. The content checks walked six of the + // eight names, the install listed all eight as literal tarball paths, and a + // package that had neither LICENSE, README, `dist`, nor the file its own + // `exports` pointed at sailed through both while a real consumer importing it + // failed with ERR_MODULE_NOT_FOUND. Everything below walks `published`. + const published = await velarPublishedPackages(root); + const packed = new Map(); + for (const package_ of published) packed.set(package_.name, await pack(package_.name)); const named = (name: string) => { const entry = packed.get(name); assert.ok(entry, `packages/* no longer publishes ${name}; this gate assumed it does`); @@ -28,14 +37,17 @@ try { const create = named("create-velar"); const cli = named("@velarscript/cli"); const desktop = named("@velarscript/desktop"); - const textBuffer = named("@velarscript/text-buffer"); - const scriptAnalysis = named("@velarscript/script-analysis"); - for (const package_ of [compiler, node, web, create, cli, desktop]) { - assert.ok(package_.files.some((file) => file.path === "LICENSE")); - assert.ok(package_.files.some((file) => file.path === "README.md")); - assert.ok(package_.files.some((file) => file.path.startsWith("dist/") && file.path.endsWith(".js"))); - assert.ok(package_.files.some((file) => file.path.startsWith("dist/") && file.path.endsWith(".d.ts"))); - assert.ok(!package_.files.some((file) => /(?:^|\/)tests?(?:\/|$)/u.test(file.path))); + // What every published package must contain, asked of each manifest rather + // than of a list: its licence, its README, and every file it points a + // consumer at through `main`, `types`, `exports`, `bin` or `velar.entry`. + const contentFailures = published.flatMap((package_) => packageContentFailures(package_.manifest, named(package_.name))); + assert.deepEqual(contentFailures, [], `packed packages do not contain what their manifests promise:\n${contentFailures.join("\n")}`); + // The compiled packages additionally publish types beside their JavaScript. + // Derived the same way: a package that promises a `.d.ts` anywhere in its + // manifest is one that must ship types. + for (const package_ of published) { + if (!declaredEntryPaths(package_.manifest).some((path) => path.endsWith(".d.ts"))) continue; + assert.ok(named(package_.name).files.some((file) => file.path.endsWith(".d.ts")), `${package_.name} promises types and packs none`); } assert.ok(cli.files.some((file) => file.path === "dist/browser-test-runner.js")); assert.ok(cli.files.some((file) => file.path === "dist/production-verifier.js")); @@ -43,12 +55,6 @@ try { assert.ok(cli.files.some((file) => file.path === "dist/deployment-verifier.js")); assert.ok(!cli.files.some((file) => file.path.startsWith("stdlib/"))); assert.ok(cli.files.some((file) => file.path === "skill/ai-skill.md")); - assert.ok(textBuffer.files.some((file) => file.path === "LICENSE")); - assert.ok(textBuffer.files.some((file) => file.path === "README.md")); - assert.ok(textBuffer.files.some((file) => file.path === "src/index.vel")); - assert.ok(scriptAnalysis.files.some((file) => file.path === "LICENSE")); - assert.ok(scriptAnalysis.files.some((file) => file.path === "README.md")); - assert.ok(scriptAnalysis.files.some((file) => file.path === "src/index.vel")); assert.ok(compiler.files.some((file) => file.path === "dist/framework-host.js")); assert.ok(compiler.files.some((file) => file.path === "dist/application-package-host.js")); assert.ok(node.files.some((file) => file.path === "dist/compiler.js")); @@ -61,19 +67,33 @@ try { assert.ok(desktop.files.some((file) => file.path === "native/macos/VelarTerminalHost.swift")); await writeFile(join(directory, "package.json"), "{}\n", "utf8"); + // The complete set, from the same derived roster that packed it. A tarball + // list written out here is a list that stops matching `packages/*`. await runNpm([ "install", "--ignore-scripts", "--no-audit", "--no-fund", - join(directory, compiler.filename), - join(directory, node.filename), - join(directory, web.filename), - join(directory, create.filename), - join(directory, cli.filename), - join(directory, desktop.filename), - join(directory, textBuffer.filename), - join(directory, scriptAnalysis.filename), + ...published.map((package_) => join(directory, named(package_.name).filename)), + ], directory); + + // What the installed set actually offers a consumer, asked of the manifests: + // every file each one points at must be on disk, and every specifier each one + // publishes must import. A package whose `exports` names a file that was + // never built installs without complaint and fails at the first `import`, + // which is exactly the release-day failure this gate exists to prevent. + for (const package_ of published) { + for (const path of declaredEntryPaths(package_.manifest)) { + if (path.includes("*")) continue; + await readFile(join(directory, "node_modules", ...package_.name.split("/"), path)); + } + } + const specifiers = published.flatMap((package_) => declaredImportSpecifiers(package_.manifest)); + assert.ok(specifiers.length >= published.length, `the installed set publishes only ${specifiers.length} import specifiers`); + await run(process.execPath, [ + "--input-type=module", + "--eval", + `${specifiers.map((specifier) => `await import(${JSON.stringify(specifier)});`).join("\n")}\nconsole.log("resolved");`, ], directory); const installedCli = join(directory, "node_modules", "@velarscript", "cli", "dist", "cli.js"); @@ -226,7 +246,7 @@ print(f"{str(script.analysis().diagnostics.size)}:{str(script.referencesAt(refer const desktopApi = await run(process.execPath, [ "--input-type=module", "--eval", - "import {VELAR_DESKTOP_API_VERSION,VELAR_DESKTOP_MODULES,velarDesktopFramework} from '@velarscript/desktop'; import {velarCompilerExtension} from '@velarscript/desktop/compiler'; import {velarFrameworkHost} from '@velarscript/desktop/host'; const desktop=velarCompilerExtension.modules?.sources.get('velar/desktop') ?? ''; const fs=velarCompilerExtension.modules?.sources.get('velar/fs') ?? ''; const http=velarCompilerExtension.modules?.sources.get('velar/http') ?? ''; if (VELAR_DESKTOP_API_VERSION !== '0.10' || !VELAR_DESKTOP_MODULES.includes('velar/desktop') || velarDesktopFramework.programmingModel !== 'single-project' || velarCompilerExtension.contract?.kind !== 'application' || velarFrameworkHost.id !== '@velarscript/desktop' || !desktop.includes('export async function startProjectTask') || !desktop.includes('ProjectTaskCommand') || !desktop.includes('ProjectTaskOutputChannel') || !desktop.includes('export async function openTerminal') || !desktop.includes('TerminalSession') || !fs.includes('export async function createText') || !fs.includes('export async function replaceTextIfMatches') || !fs.includes('export async function watchFiles') || !fs.includes('invoke(\"watchNext\", [this.handle], 0)') || !http.includes('__velarAssertJson') || !http.includes('__velarJsonStringify') || !http.includes('HTTP options fields must be enumerable data values') || !http.includes('HttpTransportError') || !http.includes('HttpTransportPhase') || !http.includes('responseOf') || !http.includes('maxResponseChunks')) process.exit(1); console.log(velarDesktopFramework.name)", + "import {VELAR_DESKTOP_API_VERSION,VELAR_DESKTOP_MODULES,velarDesktopFramework} from '@velarscript/desktop'; import {velarCompilerExtension} from '@velarscript/desktop/compiler'; import {velarFrameworkHost} from '@velarscript/desktop/host'; const desktop=velarCompilerExtension.modules?.sources.get('velar/desktop') ?? ''; const fs=velarCompilerExtension.modules?.sources.get('velar/fs') ?? ''; const http=velarCompilerExtension.modules?.sources.get('velar/http') ?? ''; if (VELAR_DESKTOP_API_VERSION !== '0.10' || !VELAR_DESKTOP_MODULES.includes('velar/desktop') || velarDesktopFramework.programmingModel !== 'single-project' || velarCompilerExtension.contract?.kind !== 'application' || velarFrameworkHost.id !== '@velarscript/desktop' || !desktop.includes('export async function startProjectTask') || !desktop.includes('ProjectTaskCommand') || !desktop.includes('ProjectTaskOutputChannel') || !desktop.includes('export async function projectChanges') || !desktop.includes('ProjectChangeLifecycle') || !desktop.includes('ProjectChangeRisk') || !desktop.includes('export async function openTerminal') || !desktop.includes('TerminalSession') || !fs.includes('export async function createText') || !fs.includes('export async function replaceTextIfMatches') || !fs.includes('export async function watchFiles') || !fs.includes('invoke(\"watchNext\", [this.handle], 0)') || !http.includes('__velarAssertJson') || !http.includes('__velarJsonStringify') || !http.includes('HTTP options fields must be enumerable data values') || !http.includes('HttpTransportError') || !http.includes('HttpTransportPhase') || !http.includes('responseOf') || !http.includes('maxResponseChunks')) process.exit(1); console.log(velarDesktopFramework.name)", ], directory); assert.equal(desktopApi.stdout, "@velarscript/desktop\n"); @@ -240,7 +260,7 @@ print(f"{str(script.analysis().diagnostics.size)}:{str(script.referencesAt(refer outDir: "dist/renderer", publicDir: "public", extensions: ["@velarscript/desktop"], - desktop: { productName: "Packed Desktop", identifier: "dev.velarscript.packed" }, + desktop: { productName: "Packed Desktop", identifier: "dev.velarscript.packed", build: {sizeBudgetBytes: 32 * 1024 * 1024} }, }), "utf8"); await writeFile(join(desktopProject, "src", "main.vel"), ` import {platform} from "velar/desktop" @@ -293,6 +313,8 @@ mount(, "#app") assert.ok((await readFile(packagedLanguageServer)).byteLength > 1024 * 1024); assert.ok((await readFile(packagedTerminalHost)).byteLength > 32 * 1024); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "project-task.js"))).byteLength > 1024 * 1024); + assert.equal(JSON.parse(await readFile(join(application, "Contents", "Resources", "host", "playwright-core", "package.json"), "utf8")).name, "playwright-core"); + assert.ok(JSON.parse(await readFile(join(application, "Contents", "Resources", "host", "playwright-core", "browsers.json"), "utf8")).browsers.length >= 3); assert.ok((await readFile(join(application, "Contents", "Resources", "host", "build-engine"))).byteLength > 5 * 1024 * 1024); await probeLanguageServer(packagedLanguageServer, desktopProject); assert.equal(hostConfiguration.nodeExecutableHint, undefined); @@ -455,11 +477,6 @@ for (const value of [ ]); } -interface PackedPackage { - readonly filename: string; - readonly files: readonly { readonly path: string }[]; -} - async function pack(workspace: string): Promise { const result = await runNpm(["pack", "--ignore-scripts", "--workspace", workspace, "--pack-destination", directory, "--json"], root); const packed = JSON.parse(result.stdout) as PackedPackage[]; diff --git a/tests/performance-runtime.test.ts b/tests/performance-runtime.test.ts index 8a7ebfb8..3fc0c751 100644 --- a/tests/performance-runtime.test.ts +++ b/tests/performance-runtime.test.ts @@ -5,6 +5,7 @@ import { join, resolve } from "node:path"; import { spawnSync } from "node:child_process"; import test, { after } from "node:test"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; +import { repositoryRoot } from "./repository-root.ts"; after(removeTemporaryDirectories); @@ -26,10 +27,14 @@ after(removeTemporaryDirectories); // measurement next to it. They are regression gates, not targets: a budget is // only ever tightened after the measured baseline moves. -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; + +// The corpus and ratios remain identical on hosted CI; only wall-clock ceilings +// receive one explicit allowance for shared-runner scheduling noise. +const timeBudget = (milliseconds: number): number => milliseconds * (process.env.CI ? 3 : 1); /** Wall-clock ceiling for one benchmark, covering compilation and execution. */ -const BENCHMARK_WALL_CLOCK_BUDGET_MS = 20_000; +const BENCHMARK_WALL_CLOCK_BUDGET_MS = timeBudget(20_000); function median(values: readonly number[]): number { assert.ok(values.length > 0, "a benchmark dimension reported no samples"); @@ -214,13 +219,13 @@ test("emitted equality holds the SameValueZero hot-loop budget", { timeout: 180_ // Baseline 2026-08-12: number 20.9ms (2.09ns/comparison) for 10M `==` on // numbers, which the analyzer cannot prove NaN-free so every one calls // __velarSameValueZero. - assert.ok(numberElapsed < 63, `SameValueZero numeric equality exceeded its budget -- ${context}`); + assert.ok(numberElapsed < timeBudget(63), `SameValueZero numeric equality exceeded its budget -- ${context}`); // Baseline 2026-08-12: string 15.1ms (1.51ns/comparison). Elided to ===. - assert.ok(stringElapsed < 45, `elided string equality exceeded its budget -- ${context}`); + assert.ok(stringElapsed < timeBudget(45), `elided string equality exceeded its budget -- ${context}`); // Baseline 2026-08-12: enum 20.4ms (2.04ns/comparison). Also elided to ===; // the gap to the string case is the frozen-object property load an enum // member read costs, not equality work. - assert.ok(enumElapsed < 62, `elided enum equality exceeded its budget -- ${context}`); + assert.ok(enumElapsed < timeBudget(62), `elided enum equality exceeded its budget -- ${context}`); // Baseline 2026-08-12: ratio 1.32 to 1.41 across runs, so SameValueZero // costs roughly 0.6ns per comparison once V8 inlines it. This bound is the // diagnostic that separates "equality lowering regressed" from "the whole @@ -397,23 +402,23 @@ test("emitted collection operations hold their large-List and Map/Set budgets", // the match. A List the compiler did not build therefore pays full // validation once instead of on every read. // append 29.4ms (294ns/item) - assert.ok(append < 90, `List.append exceeded its budget -- ${context}`); + assert.ok(append < timeBudget(90), `List.append exceeded its budget -- ${context}`); // index 22.8ms (228ns/read) - assert.ok(index < 70, `List index reads exceeded their budget -- ${context}`); + assert.ok(index < timeBudget(70), `List index reads exceeded their budget -- ${context}`); // map 9.7ms, filter 8.8ms, sorted 15.9ms, measured 2026-08-12 after every // callback operation's snapshot (__velarCopyList) took the owned fast path. // Before that the snapshot revalidated the whole List and then re-read every // element through a second descriptor, so `map` paid roughly three // allocations per element before the first callback ran: map 16.6ms, // filter 15.9ms, sorted 24.0ms. - assert.ok(mapped < 30, `List.map exceeded its budget -- ${context}`); - assert.ok(filtered < 27, `List.filter exceeded its budget -- ${context}`); - assert.ok(sorted < 48, `List.sorted exceeded its budget -- ${context}`); + assert.ok(mapped < timeBudget(30), `List.map exceeded its budget -- ${context}`); + assert.ok(filtered < timeBudget(27), `List.filter exceeded its budget -- ${context}`); + assert.ok(sorted < timeBudget(48), `List.sorted exceeded its budget -- ${context}`); // Map.set 22.0ms (220ns/insert), Map.get 14.2ms (142ns/lookup) - assert.ok(mapInsert < 70, `Map.set exceeded its budget -- ${context}`); - assert.ok(mapLookup < 45, `Map.get exceeded its budget -- ${context}`); + assert.ok(mapInsert < timeBudget(70), `Map.set exceeded its budget -- ${context}`); + assert.ok(mapLookup < timeBudget(45), `Map.get exceeded its budget -- ${context}`); // Set.add 14.2ms (142ns/insert) - assert.ok(setInsert < 45, `Set.add exceeded its budget -- ${context}`); + assert.ok(setInsert < timeBudget(45), `Set.add exceeded its budget -- ${context}`); // Set.has 11.3ms (113ns/lookup), measured 2026-08-12 after the Map/Set brand // probe stopped identifying a non-Map by catching the TypeError the Map // `size` getter throws. The probe is still the only unforgeable, cross-realm @@ -421,7 +426,7 @@ test("emitted collection operations hold their large-List and Map/Set budgets", // object, so it runs once per object and is answered from a WeakMap after // that. Before the fix this dimension measured 190.0ms (1.90us/lookup), // roughly thirteen times Map.get for the same work. - assert.ok(setLookup < 34, `Set.has exceeded its budget -- ${context}`); + assert.ok(setLookup < timeBudget(34), `Set.has exceeded its budget -- ${context}`); // rangeIndex 42.9ms for 200,000 index reads of the 2,000-item List `range()` // returns (214ns/read), measured 2026-08-12. This case used to be left out // of the gate deliberately: only mutating methods and map/filter/slice/sorted @@ -429,7 +434,7 @@ test("emitted collection operations hold their large-List and Map/Set budgets", // library revalidated all 2,000 elements on every single read and the same // 200,000 reads took 39,796ms (199us/read) -- quadratic document scanning // hiding behind an ordinary index expression. - assert.ok(rangeIndex < 130, `index reads of a standard-library List exceeded their budget -- ${context}`); + assert.ok(rangeIndex < timeBudget(130), `index reads of a standard-library List exceeded their budget -- ${context}`); assert.ok(performance.now() - started < BENCHMARK_WALL_CLOCK_BUDGET_MS, `the collection benchmark took ${(performance.now() - started).toFixed(0)}ms end to end`); @@ -541,15 +546,15 @@ test("emitted string and value methods hold their large-corpus budgets", { timeo // for the same 300 slices (~510us each), which made any code that scans a // document by slicing quadratic. The budget stays well above the measured // value because the dimension is now dominated by fixed per-call overhead. - assert.ok(slice < 12, `String.slice exceeded its budget -- ${context}`); + assert.ok(slice < timeBudget(12), `String.slice exceeded its budget -- ${context}`); // search 31.6ms for 4,000 String.has calls (~7.9us each, half of them a // full scan for an absent needle). Delegates to native indexOf, and is the // noisiest dimension in this file (25.9ms to 35.2ms across runs). - assert.ok(search < 100, `String.has exceeded its budget -- ${context}`); + assert.ok(search < timeBudget(100), `String.has exceeded its budget -- ${context}`); // pad 13.6ms for 200,000 padStart calls (~68ns each) - assert.ok(pad < 42, `String.padStart exceeded its budget -- ${context}`); + assert.ok(pad < timeBudget(42), `String.padStart exceeded its budget -- ${context}`); // split 58.3ms for 20 splits into 32,001 parts (~2.9ms each) - assert.ok(split < 180, `String.split exceeded its budget -- ${context}`); + assert.ok(split < timeBudget(180), `String.split exceeded its budget -- ${context}`); assert.ok(performance.now() - started < BENCHMARK_WALL_CLOCK_BUDGET_MS, `the text benchmark took ${(performance.now() - started).toFixed(0)}ms end to end`); @@ -671,19 +676,19 @@ test("emitted reactive updates hold the 10k-update throughput budget", { timeout // push 9.4ms per 10,000 mutate -> flush -> observer cycles (940ns each, // one microtask turn per update since each awaits tick()). The marathon // fix wave 2 did not move this dimension: the microtask turn dominates it. - assert.ok(push < 30, `reactive observer notification exceeded its budget -- ${context}`); + assert.ok(push < timeBudget(30), `reactive observer notification exceeded its budget -- ${context}`); // pull 1.9ms per 10,000 mutate -> computed recomputations (190ns each), // from 2.0ms before the reactive read path stopped linking primitives and // stopped rebuilding a dependency Set per observer run (marathon beta-9). - assert.ok(pull < 6, `computed recomputation exceeded its budget -- ${context}`); + assert.ok(pull < timeBudget(6), `computed recomputation exceeded its budget -- ${context}`); // write 4.2ms per 10,000 writes of one field of a nine-field reactive record // (420ns each), from 48.6ms (4,858ns each) before the write path stopped // running the containment probe -- two thrown-and-caught exceptions plus a // descriptor walk -- for primitive values (marathon beta-7). - assert.ok(write < 13, `deep record field writes exceeded their budget -- ${context}`); + assert.ok(write < timeBudget(13), `deep record field writes exceeded their budget -- ${context}`); // read 3.7ms per 10,000 two-field deep reads (370ns each), from 4.1ms // (marathon beta-9's early primitive bail on the proxy read path). - assert.ok(read < 12, `deep record field reads exceeded their budget -- ${context}`); + assert.ok(read < timeBudget(12), `deep record field reads exceeded their budget -- ${context}`); assert.ok(performance.now() - started < BENCHMARK_WALL_CLOCK_BUDGET_MS, `the reactive benchmark took ${(performance.now() - started).toFixed(0)}ms end to end`); diff --git a/tests/performance.test.ts b/tests/performance.test.ts index b330cfec..dbeaf22a 100644 --- a/tests/performance.test.ts +++ b/tests/performance.test.ts @@ -11,6 +11,10 @@ import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary- after(removeTemporaryDirectories); +// Hosted CI runners share noisier CPU and I/O than the reference development +// machine. Keep the exact corpus and asymptotic checks there, with a single +// explicit 3x wall-clock allowance instead of platform-specific exceptions. +const timeBudget = (milliseconds: number): number => milliseconds * (process.env.CI ? 3 : 1); test("application-scale incremental budget recompiles only the reverse dependency closure", async () => { const directory = await makeTemporaryDirectory("velar-scale-"); @@ -34,7 +38,7 @@ test("application-scale incremental budget recompiles only the reverse dependenc assert.equal(first.project.stats.moduleCount, 121); assert.equal(first.project.stats.compiledModules, 121); assert.equal(first.project.stats.reusedModules, 0); - assert.ok(first.project.stats.durationMs < 5_000, `initial compile took ${first.project.stats.durationMs}ms`); + assert.ok(first.project.stats.durationMs < timeBudget(5_000), `initial compile took ${first.project.stats.durationMs}ms`); assert.equal(first.activity.workspaceScans, 1); assert.equal(first.activity.filesRead, 121); @@ -56,7 +60,7 @@ test("application-scale incremental budget recompiles only the reverse dependenc assert.equal(rebuilt.project.stats.compiledModules, 41); assert.equal(rebuilt.project.stats.reusedModules, 80); assert.equal(rebuilt.project.stats.affectedModules, 41); - assert.ok(rebuilt.project.stats.durationMs < 2_000, `incremental compile took ${rebuilt.project.stats.durationMs}ms`); + assert.ok(rebuilt.project.stats.durationMs < timeBudget(2_000), `incremental compile took ${rebuilt.project.stats.durationMs}ms`); }); test("session-persistent workspace search meets the 20k-file first and complete-result budgets", async () => { @@ -73,7 +77,7 @@ test("session-persistent workspace search meets the 20k-file first and complete- const firstElapsed = performance.now() - firstStarted; assert.equal(first.matches.length, 1); assert.equal(first.limitReached, true); - assert.ok(firstElapsed < 300, `20k-file first result took ${firstElapsed}ms`); + assert.ok(firstElapsed < timeBudget(300), `20k-file first result took ${firstElapsed}ms`); const completeStarted = performance.now(); const complete = await index.search("searchNeedle", { maximumResults: 1_000 }); @@ -81,7 +85,7 @@ test("session-persistent workspace search meets the 20k-file first and complete- assert.equal(complete.matches.length, 100); assert.equal(complete.filesSearched, 20_000); assert.equal(complete.limitReached, false); - assert.ok(completeElapsed < 3_000, `20k-file complete search took ${completeElapsed}ms`); + assert.ok(completeElapsed < timeBudget(3_000), `20k-file complete search took ${completeElapsed}ms`); let cancelled = false; const cancelledSearch = index.search("absentNeedle", { maximumResults: 1_000, cancelled: () => cancelled }); @@ -107,7 +111,7 @@ test("session-persistent workspace search meets the 20k-file first and complete- assert.equal(update.recordsRemoved, 4_096); assert.equal(update.indexedFiles, 20_000); assert.ok(heartbeat > 0, "20k/4096 workspace invalidation did not yield to the host"); - assert.ok(updateElapsed < 3_000, `20k/4096 workspace invalidation took ${updateElapsed}ms`); + assert.ok(updateElapsed < timeBudget(3_000), `20k/4096 workspace invalidation took ${updateElapsed}ms`); assert.ok(peakRss - rssBefore < 64 * 1024 * 1024, `20k/4096 workspace invalidation grew RSS by ${peakRss - rssBefore} bytes`); await assert.rejects(index.update(new Set(Array.from({ length: 4_097 }, (_, item) => join(root, `overflow-${item}.ts`)))), @@ -155,8 +159,8 @@ print(f"{str(source.size)}|{str(service.analysis().tokens.size)}|{str(initialEla const [size, tokens, initialElapsed, updateElapsed, restartOffset, codePointsRead, tokensReused] = metrics as [number, number, number, number, number, number, number]; assert.ok(size >= 1024 * 1024, `script fixture was only ${size} code points`); assert.ok(tokens > 300_000); - assert.ok(initialElapsed < 5_000, `1 MiB script analysis took ${initialElapsed}ms`); - assert.ok(updateElapsed < 2_000, `1 MiB tail update took ${updateElapsed}ms`); + assert.ok(initialElapsed < timeBudget(5_000), `1 MiB script analysis took ${initialElapsed}ms`); + assert.ok(updateElapsed < timeBudget(2_000), `1 MiB tail update took ${updateElapsed}ms`); assert.equal(restartOffset, size); assert.equal(codePointsRead, "// tail\n".length); assert.ok(tokensReused > 300_000); @@ -201,29 +205,30 @@ test("language server maps 1 MiB script semantic tokens in one bounded coordinat }; try { send({ jsonrpc: "2.0", id: 1, method: "initialize", params: { capabilities: { general: { positionEncodings: ["utf-32"] } } } }); - await waitFor((message) => message.id === 1, 10_000); + await waitFor((message) => message.id === 1, timeBudget(10_000)); send({ jsonrpc: "2.0", method: "initialized", params: {} }); const text = "const value = 1;\n" + "value + 1;\n".repeat(95_324); const uri = pathToFileURL(join(tmpdir(), "velar-script-semantic-scale.ts")).href; const openedAt = performance.now(); send({ jsonrpc: "2.0", method: "textDocument/didOpen", params: { textDocument: { uri, languageId: "typescript", version: 1, text } } }); const diagnostics = await waitFor((message) => message.method === "textDocument/publishDiagnostics" - && (message.params as { uri?: string } | undefined)?.uri === uri, 10_000); + && (message.params as { uri?: string } | undefined)?.uri === uri, timeBudget(10_000)); assert.deepEqual((diagnostics.params as { diagnostics: unknown[] }).diagnostics, []); - assert.ok(performance.now() - openedAt < 8_000, "1 MiB script diagnostics exceeded the language-server budget"); + assert.ok(performance.now() - openedAt < timeBudget(8_000), "1 MiB script diagnostics exceeded the language-server budget"); const semanticAt = performance.now(); send({ jsonrpc: "2.0", id: 2, method: "textDocument/semanticTokens/full", params: { textDocument: { uri } } }); - const semantic = await waitFor((message) => message.id === 2, 4_000); + const semantic = await waitFor((message) => message.id === 2, timeBudget(4_000)); const data = (semantic.result as { data: number[] }).data; assert.equal(data.length % 5, 0); assert.ok(data.length > 30_000 && data.length <= 50_000); - assert.ok(performance.now() - semanticAt < 2_000, "1 MiB script semantic-token mapping exceeded the linear coordinate budget"); + assert.ok(performance.now() - semanticAt < timeBudget(2_000), "1 MiB script semantic-token mapping exceeded the linear coordinate budget"); send({ jsonrpc: "2.0", id: 3, method: "shutdown", params: null }); - await waitFor((message) => message.id === 3, 5_000); + await waitFor((message) => message.id === 3, timeBudget(5_000)); send({ jsonrpc: "2.0", method: "exit", params: null }); child.stdin.end(); const code = await new Promise((resolveExit, rejectExit) => { - const timer = setTimeout(() => rejectExit(new Error("Language server did not exit within 5 seconds")), 5_000); + const timeout = timeBudget(5_000); + const timer = setTimeout(() => rejectExit(new Error(`Language server did not exit within ${timeout}ms`)), timeout); child.once("exit", (value) => { clearTimeout(timer); resolveExit(value); }); }); assert.equal(code, 0, stderr); diff --git a/tests/project-task-invocation.test.ts b/tests/project-task-invocation.test.ts index 6d60077d..9c029264 100644 --- a/tests/project-task-invocation.test.ts +++ b/tests/project-task-invocation.test.ts @@ -1,13 +1,20 @@ import assert from "node:assert/strict"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; import test from "node:test"; -import { projectTaskCliArguments, projectTaskCommands } from "../packages/cli/src/project-task-invocation.ts"; +import { + projectTaskBrowserWorkerCliArguments, + projectTaskCliArguments, + projectTaskCommands, +} from "../packages/cli/src/project-task-invocation.ts"; const root = "/project"; test("Desktop project tasks map a closed capability vocabulary to exact CLI arguments", () => { - assert.deepEqual(projectTaskCommands, ["check", "test", "build", "fix", "package", "run"]); + assert.deepEqual(projectTaskCommands, ["check", "test", "browserTest", "build", "fix", "package", "run"]); assert.deepEqual(projectTaskCliArguments(["check", root]), ["check", root]); assert.deepEqual(projectTaskCliArguments(["test", root]), ["test", root]); + assert.deepEqual(projectTaskCliArguments(["browserTest", root]), ["test", root, "--browser=all"]); assert.deepEqual(projectTaskCliArguments(["build", root]), ["build", root]); assert.deepEqual(projectTaskCliArguments(["fix", root]), ["fix", root]); assert.deepEqual(projectTaskCliArguments(["package", root]), ["package", root]); @@ -27,3 +34,31 @@ test("Desktop project tasks reject anything outside the finite owner contract", assert.equal(projectTaskCliArguments(arguments_), "invalid package-owned task invocation"); } }); + +test("Desktop project tasks admit only the official supervised browser worker shape", () => { + const limits = JSON.stringify({ processTimeoutMs: 300000 }); + const browserSite = join(tmpdir(), "velar-browser-tests-owner", "site"); + assert.deepEqual( + projectTaskBrowserWorkerCliArguments(["test", root, "--browser=all"], limits), + ["test", root, "--browser=all"], + ); + assert.deepEqual( + projectTaskBrowserWorkerCliArguments( + ["build", root, "--out-dir", browserSite], + limits, + ), + ["build", root, "--out-dir", browserSite], + ); + for (const [arguments_, marker] of [ + [["test", root, "--browser=all"], undefined], + [["test", root, "--browser=all"], "null"], + [["test", "relative", "--browser=all"], limits], + [["test", root, "--browser=unknown"], limits], + [["test", root, "--browser=all", "escape"], limits], + [["publish", root, "--browser=all"], limits], + [["build", root, "--out-dir", "/tmp/not-a-browser-owner/site"], limits], + [["build", root, "--out-dir", "/tmp/velar-browser-tests-owner/escape"], limits], + ] as const) { + assert.match(String(projectTaskBrowserWorkerCliArguments(arguments_, marker)), /invalid supervised browser-test/u); + } +}); diff --git a/tests/repository-root.ts b/tests/repository-root.ts new file mode 100644 index 00000000..d65ac8ac --- /dev/null +++ b/tests/repository-root.ts @@ -0,0 +1,3 @@ +import { fileURLToPath } from "node:url"; + +export const repositoryRoot = fileURLToPath(new URL("..", import.meta.url)); diff --git a/tests/runtime-boundary.test.ts b/tests/runtime-boundary.test.ts index 1033c8f8..5fc045d1 100644 --- a/tests/runtime-boundary.test.ts +++ b/tests/runtime-boundary.test.ts @@ -12,6 +12,16 @@ import { } from "@velarscript/compiler/extension"; import { velarCompilerExtension } from "../packages/web/src/compiler.ts"; +function executeModule(source: string) { + // Passing generated programs through `--eval` is bounded by the host's + // command-line size (notably Linux ARG_MAX). stdin is the portable module + // source boundary and keeps this test about the runtime ABI it owns. + return spawnSync(process.execPath, ["--input-type=module"], { + input: source, + encoding: "utf8", + }); +} + test("compiler-owned UTF-8 sizing matches transport encoding semantics", () => { const runtime = new Function(`${VELAR_UTF8_RUNTIME}\nreturn { byteLength: __velarUtf8ByteLength, declaredLength: __velarDeclaredLength };`)() as { byteLength(value: string): number; @@ -73,7 +83,7 @@ test("Desktop capability worker independently enforces shared HTTP response meta test("an incompatible pre-existing runtime registry fails closed", () => { const web = compileCore("component App:\n return
Ready
\n", { extensions: [velarCompilerExtension] }); assert.deepEqual(web.diagnostics, []); - const execution = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const execution = executeModule(` Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_RUNTIME_REGISTRY_KEY)}), { value: Object.freeze({ version: "incompatible" }), enumerable: false, @@ -81,7 +91,7 @@ Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_RUNTIME_REGI writable: false, }); ${web.code ?? ""} -`], { encoding: "utf8" }); +`); assert.notEqual(execution.status, 0); assert.match(String(execution.stderr), /VelarScript Web runtime (?:ownership|values) is invalid/u); }); @@ -95,7 +105,7 @@ export def cross(value: unknown) -> unknown: return identity(value) `.trimStart()); assert.deepEqual(core.diagnostics, []); - const execution = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const execution = executeModule(` ${core.code ?? ""} const plain = {}; const first = cross(plain) === plain; @@ -125,7 +135,7 @@ const original = runtime.toRaw; Object.defineProperty(globalThis.Object, "getOwnPropertyDescriptor", { value() { throw new Error("late ambient lookup"); } }); const third = cross(proxy) === raw && runtime.toRaw === original; console.log(first + "|" + second + "|" + third); -`], { encoding: "utf8" }); +`); assert.equal(execution.status, 0, execution.stderr); assert.equal(execution.stdout.trim(), "true|true|true"); }); @@ -138,7 +148,7 @@ identity({}) `.trimStart()); assert.deepEqual(core.diagnostics, []); const appUrl = `data:text/javascript;base64,${Buffer.from(core.code ?? "").toString("base64")}`; - const execution = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const execution = executeModule(` let reads = 0; const runtime = Object.create(null); Object.defineProperty(runtime, "version", { value: ${JSON.stringify(VELAR_RUNTIME_SCHEMA_VERSION)}, enumerable: false, configurable: false, writable: false }); @@ -149,7 +159,7 @@ Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_RUNTIME_REGI }); try { await import(${JSON.stringify(appUrl)}); } catch (error) { console.log(reads + "|" + error.message); } -`], { encoding: "utf8" }); +`); assert.equal(execution.status, 0, execution.stderr); assert.equal(execution.stdout.trim(), "0|VelarScript reactive runtime field 'toRaw' is invalid"); }); @@ -165,7 +175,7 @@ const valid = User.parse({name: "Ada"}) assert.match(core.code ?? "", /const __velarTypeSymbolFor = globalThis\.Symbol\.for;/u); assert.match(core.code ?? "", new RegExp(escapeRegex(JSON.stringify(VELAR_TYPE_REGISTRY_KEY)), "u")); - const accessor = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const accessor = executeModule(` let reads = 0; Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_TYPE_REGISTRY_KEY)}), { get() { reads += 1; return new WeakSet(); }, @@ -177,11 +187,11 @@ ${core.code ?? ""} } catch (error) { console.log(reads + "|" + error.message); } -`], { encoding: "utf8" }); +`); assert.equal(accessor.status, 0, accessor.stderr); assert.equal(accessor.stdout.trim(), "0|VelarScript runtime type registry descriptor is invalid"); - const mutable = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const mutable = executeModule(` Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_TYPE_REGISTRY_KEY)}), { value: new WeakSet(), enumerable: false, @@ -193,11 +203,11 @@ ${core.code ?? ""} } catch (error) { console.log(error.message); } -`], { encoding: "utf8" }); +`); assert.equal(mutable.status, 0, mutable.stderr); assert.equal(mutable.stdout.trim(), "VelarScript runtime type registry descriptor is invalid"); - const poisonedMethod = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const poisonedMethod = executeModule(` const registry = new WeakSet(); let reads = 0; Object.defineProperty(registry, "add", { get() { reads += 1; throw new Error("poisoned add"); } }); @@ -209,11 +219,11 @@ Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(VELAR_TYPE_REGISTR }); ${core.code ?? ""} console.log(reads); -`], { encoding: "utf8" }); +`); assert.equal(poisonedMethod.status, 0, poisonedMethod.stderr); assert.equal(poisonedMethod.stdout.trim(), "0"); - const capturedHosts = spawnSync(process.execPath, ["--input-type=module", "--eval", ` + const capturedHosts = executeModule(` ${VELAR_TYPE_REGISTRY_RUNTIME} const NativeTypeError = TypeError; const known = __velarRegisterRuntimeType(Object.freeze({ name: "known" })); @@ -235,7 +245,7 @@ console.log(__velarRequireRuntimeType(__velarRegisterRuntimeType(later), "verify try { __velarRequireRuntimeType(forged, "verify"); } catch (error) { console.log(error instanceof NativeTypeError, error.message); } console.log(poisonCalls); -`], { encoding: "utf8" }); +`); assert.equal(capturedHosts.status, 0, capturedHosts.stderr); assert.equal(capturedHosts.stdout, [ "true", diff --git a/tests/tour-coverage.test.ts b/tests/tour-coverage.test.ts index 00c42299..271a2da2 100644 --- a/tests/tour-coverage.test.ts +++ b/tests/tour-coverage.test.ts @@ -4,8 +4,12 @@ import { cp, readFile, rm, writeFile } from "node:fs/promises"; import { dirname, join, resolve } from "node:path"; import test, { after } from "node:test"; import { fileURLToPath } from "node:url"; +import { CORE_STATEMENT_CONSTRUCTS } from "../packages/compiler/src/ast.ts"; import { CORE_CONTEXTUAL_KEYWORD_WORDS, CORE_NUMERIC_SUFFIXES } from "../packages/compiler/src/core-vocabulary.ts"; import { keywordKinds } from "../packages/compiler/src/token.ts"; +import { velarCompilerExtension as desktopCompilerExtension } from "../packages/desktop/src/compiler.ts"; +import { WEB_STATEMENT_CONSTRUCTS, webStatementConstructKey, type WebUnsafeCssDeclaration } from "../packages/web/src/ast.ts"; +import { velarCompilerExtension as webCompilerExtension } from "../packages/web/src/compiler.ts"; import { LOOK_PROPERTIES, LOOK_TARGETS } from "../packages/web/src/look.ts"; import { makeTemporaryDirectory, removeTemporaryDirectories } from "./temporary-directory.ts"; @@ -52,6 +56,7 @@ test("the coverage gate passes on the tour and reports what it examined", () => "hard-keyword", "contextual-keyword", "reserved-binding", "numeric-suffix", "extension-global", "permanent-namespace", "prelude-name", "namespace-member", "module-export", "type-parameter-bound", "web-test-member", "look-property", "look-hook", "look-target", "look-media-feature", + "statement-construct", ]) { const line = output.split("\n").find((item) => item.trimStart().startsWith(`${category} `)); assert.ok(line, `${category} is missing from the gate's report:\n${output}`); @@ -93,12 +98,67 @@ test("[D62-157/158] the gate requires Core's own contextual keywords and numeric `the gate required fewer contextual keywords than Core alone declares:\n${output}`); assert.ok(required("numeric-suffix") >= CORE_NUMERIC_SUFFIXES.length, `the gate required fewer numeric suffixes than Core alone declares:\n${output}`); - // And the gate no longer prints either as a hole it cannot reach. - assert.match(output, /Not reverse-queryable \(holes, not exemptions\):\n\s+none\b/u); + // And the gate no longer prints either as a hole it cannot reach. The one + // hole it does print is not a vocabulary: it is the statement *spellings* + // that share a single AST node kind, which the construct category below + // requires by kind and cannot split. + assert.match(output, /Not reverse-queryable \(holes, not exemptions\):\n\s+statement spellings that share one AST node kind\b/u); assert.doesNotMatch(output, /Core's own contextual keywords/u); assert.doesNotMatch(output, /Core's built-in numeric suffixes/u); }); +test("[D53-117] the gate requires every statement construct the compiler can parse", () => { + // The blind spot this category closes: `extern js(…)` and `unsafe js` are + // assembled from `extern`, `js`, and `unsafe` — three keywords chapter 13 + // already exercised through `extern module` and `import js unsafe` — so two + // declaration forms reached a release with no `.vel` file anywhere using + // them while seventeen name-by-name categories all stayed green. A construct + // spelled out of covered spellings is invisible to a spelling check. + const { status, output } = runGate(tour); + assert.equal(status, 0, output); + const line = output.split("\n").find((item) => item.trimStart().startsWith("statement-construct ")); + assert.ok(line, `the gate reports no statement-construct category:\n${output}`); + const counts = /(?\d+)\/(?\d+)/u.exec(line)?.groups; + assert.ok(counts, `statement-construct reports no counts:\n${line}`); + // Compared against the rosters themselves rather than against a number: + // Core's is a mapped type over the `CoreStatement` union, and the Web + // extension's over its own, so a construct added to either union raises both + // sides of this assertion together. + const required = Object.keys(CORE_STATEMENT_CONSTRUCTS).length + Object.keys(WEB_STATEMENT_CONSTRUCTS).length; + assert.equal(Number(counts.required), required, `the gate required ${counts.required} constructs; Core and Web declare ${required}:\n${output}`); + assert.equal(counts.covered, counts.required, `the tour does not write every construct:\n${line}`); +}); + +test("[D53-117] an extension that owns a parser publishes the constructs its parser adds", () => { + // An extension's statements never join `CoreStatement`, so its own roster is + // the only table that can name them, and the gate treats a parser without one + // as a failure rather than as an empty contribution. + for (const extension of [webCompilerExtension, desktopCompilerExtension]) { + assert.ok(extension.parser, `${extension.id} no longer registers a parser; retarget this test`); + assert.ok(extension.syntax, `${extension.id} owns a parser but publishes no statement-construct roster`); + assert.ok(Object.keys(extension.syntax.statementConstructs).length > 0, `${extension.id} publishes an empty roster`); + } + // `unsafe css` is the one statement whose node kind spells two constructs, + // and its `source` is a tagged union the Web extension already owns — so the + // inline block cannot be covered by the `import css unsafe` beside it. + const span = { start: 0, end: 1 }; + const inline: WebUnsafeCssDeclaration = { + kind: "ExtensionStatement:web:unsafe-css", + source: { kind: "inline", css: ".inline {}", span }, + placement: "after", + span, + }; + const external: WebUnsafeCssDeclaration = { + kind: "ExtensionStatement:web:unsafe-css", + source: { kind: "external", path: "./external.css", span }, + placement: "before", + span, + }; + assert.equal(webStatementConstructKey(inline), "ExtensionStatement:web:unsafe-css/inline"); + assert.equal(webStatementConstructKey(external), "ExtensionStatement:web:unsafe-css/external"); + assert.equal(webStatementConstructKey({ kind: "VariableDeclaration" }), null); +}); + test("removing one spelling from the tour turns the gate red and names it", async () => { // One deletion per vocabulary family, each the smallest edit that removes the // spelling and nothing else. The expected message is the whole point: a gate @@ -130,11 +190,28 @@ test("removing one spelling from the tour turns the gate red and names it", asyn ], }, { + // Three sites now, not two: the inline block spells `css` as well, so + // deleting only the imports leaves the word covered. Deleting every site + // necessarily takes both `unsafe-css` constructs with it, and the gate + // names those too — the assertion is that it names *this*. family: "an extension's contextual keyword", expected: "contextual-keyword: css", edits: [ { file: "web/08-look-escape.vel", replace: 'import css unsafe "./before.css" before look\n', replacement: "" }, { file: "web/08-look-escape.vel", replace: 'import css unsafe "./after.css" after look\n', replacement: "" }, + { + file: "web/08-look-escape.vel", + replace: "unsafe css`\n" + + " @media print {\n" + + " .tour-cascade-counter {\n" + + " break-inside: avoid;\n" + + " orphans: 3;\n" + + " widows: 3;\n" + + " }\n" + + " }\n" + + "` after look\n\n", + replacement: "", + }, ], }, { @@ -162,6 +239,76 @@ test("removing one spelling from the tour turns the gate red and names it", asyn { file: "web/13-browser.browser.test.vel", replace: ' await browser.open("/section/units")\n', replacement: " pass\n" }, ], }, + { + // Both spellings go in one edit because they share a node kind, which is + // the granularity limit the gate prints as a hole. Each replacement is an + // ordinary VelarScript declaration of the same name and type, so the + // chapter still compiles and the gate goes red for the construct alone. + family: "an inline JavaScript block", + expected: "statement-construct: extern js(capture: T)", + edits: [ + { + file: "core/13-javascript-boundary.vel", + replace: "const tokenBytes = 16\n\nextern js(tokenBytes: number)`\n" + + " export function randomToken() {\n" + + " const buffer = new Uint8Array(tokenBytes)\n" + + " globalThis.crypto.getRandomValues(buffer)\n" + + ' return Array.from(buffer, (byte) => byte.toString(16).padStart(2, "0")).join("")\n' + + " }\n" + + "`:\n" + + " export def randomToken() -> string\n", + replacement: "def randomToken() -> string:\n return \"deadbeef\"\n", + }, + { + file: "core/13-javascript-boundary.vel", + replace: "unsafe js`\n" + + " export function engineReport() {\n" + + " return { arch: globalThis.process.arch, node: globalThis.process.versions.node }\n" + + " }\n" + + "`\n", + replacement: "def engineReport() -> unknown:\n return {arch: \"arm64\", node: \"24\"}\n", + }, + ], + }, + { + // The two `import css unsafe` lines stay. They share this block's node + // kind and would satisfy a gate that required the kind, which is exactly + // how the inline form reached a release with no example. + family: "an inline CSS block whose external sibling remains", + expected: "statement-construct: unsafe css", + edits: [{ + file: "web/08-look-escape.vel", + replace: "unsafe css`\n" + + " @media print {\n" + + " .tour-cascade-counter {\n" + + " break-inside: avoid;\n" + + " orphans: 3;\n" + + " widows: 3;\n" + + " }\n" + + " }\n" + + "` after look\n\n", + replacement: "", + }], + }, + { + // A-023: the `module-export` category had no red case at all. This is the + // ordinary direction — the name leaves the tour entirely — and the test + // below is its other half, where only the *usage* leaves. + family: "a standard-module export", + expected: 'module-export: import {watchVisibility} from "velar/browser"', + edits: [ + { + file: "web/10-browser-forms-files.vel", + replace: " watchVisibility(setVisible),\n", + replacement: ' watchMedia("(max-width: 719px)", setVisible),\n', + }, + { + file: "web/10-browser-forms-files.vel", + replace: ', watchVisibility} from "velar/browser"', + replacement: '} from "velar/browser"', + }, + ], + }, { family: "a velar/web-test computed-style control", expected: "web-test-member: browser.style", @@ -188,6 +335,68 @@ test("removing one spelling from the tour turns the gate red and names it", asyn } }); +test("[A-023] an import is not a usage: the name stays imported and the gate still goes red", async () => { + // The other direction of the case above, and the one the gate was missing. + // `observeModule` waited for a real `MemberExpression` before crediting a + // namespace import, but credited every *named* import the moment it parsed — + // so deleting the only call to `watchVisibility` while leaving its specifier + // in the import list left `module-export` reporting 237/237 and exit 0. + // + // An import proves a name resolves. It shows no signature and no usage, and + // this gate's own failure text says a name is missing when "no module uses + // it". Testing only the deletion of imports is what let the two sentences + // drift apart: every red case here removed a spelling from the source, and + // none of them removed a *use* while the spelling stayed. + const directory = await copyOfTour(); + await mutate( + directory, + "web/10-browser-forms-files.vel", + " watchVisibility(setVisible),\n", + ' watchMedia("(max-width: 719px)", setVisible),\n', + ); + const source = await readFile(join(directory, "web", "10-browser-forms-files.vel"), "utf8"); + assert.ok(source.includes("watchVisibility}"), `the import specifier must survive this mutation:\n${source}`); + assert.equal(source.match(/watchVisibility/gu)?.length, 1, "watchVisibility must remain exactly once, as an import and nowhere else"); + const { status, output } = runGate(directory); + assert.equal(status, 1, `the gate counted an unused import as coverage:\n${output}`); + assert.ok(output.includes('module-export: import {watchVisibility} from "velar/browser"'), `the gate did not name it:\n${output}`); + // And it says *why*, because "no module uses it" beside a visible import line + // is the one message a reader would disbelieve. + assert.match(output, /10-browser-forms-files\.vel imports the name and never references it — an import is not a usage/u); + await rm(directory, { recursive: true, force: true }); +}); + +test("[A-023] a namespace member is credited to the namespace, not to its spelling", async () => { + // The other half of the same defect. The namespace branch did wait for a + // real member read — but it matched the read by the import's *local name*, + // so any binding spelled the same in any inner scope forged the module's + // exports out of a read of itself. That is the forgery this file's header + // says a text search would allow and a resolved judgment would not. + const directory = await copyOfTour(); + // First make one export genuinely uncovered, so the gate has something to be + // wrong about: `velar/url`'s `encode` reaches the tour only through chapter + // 14's named import. + await mutate(directory, "core/14-files-and-host.vel", "import {decode, encode, isExternal,", "import {decode, isExternal,"); + await mutate(directory, "core/14-files-and-host.vel", 'const encoded = encode("a b&c")', 'const encoded = decode("a%20b")'); + const missing = runGate(directory); + assert.equal(missing.status, 1, missing.output); + assert.ok(missing.output.includes('module-export: import {encode} from "velar/url"'), missing.output); + + // Now forge it: chapter 12 holds `import * as urls from "velar/url"`, and a + // local record named `urls` in a function body used to satisfy the whole + // module's inventory through `urls.encode`. + await mutate( + directory, + "core/12-modules.vel", + 'const joinedUrl = urls.join("https://example.test", "api", "v1")', + 'const joinedUrl = urls.join("https://example.test", "api", "v1")\n\ndef forgeCoverage() -> string:\n const urls = {encode: "forged"}\n return urls.encode\n', + ); + const forged = runGate(directory); + assert.equal(forged.status, 1, `a shadowing local forged coverage of a module export:\n${forged.output}`); + assert.ok(forged.output.includes('module-export: import {encode} from "velar/url"'), forged.output); + await rm(directory, { recursive: true, force: true }); +}); + test("the gate refuses a chapter no import reaches", async () => { // D56 rule 128: `velar check` never looks at a module the entry cannot reach, // so a chapter added without an import in `main.vel` would silently lose the diff --git a/tests/web-error-paths.test.ts b/tests/web-error-paths.test.ts index 044c3344..85881578 100644 --- a/tests/web-error-paths.test.ts +++ b/tests/web-error-paths.test.ts @@ -2,6 +2,7 @@ import assert from "node:assert/strict"; import { spawn } from "node:child_process"; import { join, resolve } from "node:path"; import test from "node:test"; +import { repositoryRoot } from "./repository-root.ts"; /** * D56 rule 131 — a fixture is not an example. @@ -27,7 +28,7 @@ import test from "node:test"; * three engines. */ -const root = resolve(new URL("..", import.meta.url).pathname); +const root = repositoryRoot; const cli = join(root, "packages", "cli", "src", "cli.ts"); const fixture = join(root, "tests", "fixtures", "web-error-paths");