rooklang 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,235 @@
+# Changelog
+
+**English** · [Русский](CHANGELOG.ru.md)
+
+What changed in each version of `rooklang`: the language, the compiler, the runtime and the VS Code
+extension. The road to 1.0 is in [docs/roadmap.md](docs/roadmap.md).
+
+**Versions before 1.0.** A minor version (0.4.0) may break code that compiled before, and says how
+to change it under **Breaking**. A patch version (0.3.5) never does: it adds and fixes only.
+
+## 0.5.0 — 2026-10-31
+
+What a team that builds a browser game in Rook, with Bun and Vite, found missing or broken.
+
+### Breaking
+
+- A component changes a property that is not bound neither by assigning it nor in place:
+  `todo.done = true`, `bind:value={todo.title}` and `items.push(x)` on a property are errors, since
+  the object is the parent's and its markup did not know of the change. Declare the property bound,
+  `comp TodoItem(bind todo Todo)`, and pass it with `bind:todo={todo}`; the item of a `{for}` loop
+  can now be bound so.
+- `export const Rows = Inner` of a component without a type is an error: its `.d.ts` lost the
+  properties. Write `export { Rows } from "./rows.rk"`, or give the constant a component type.
+
+### Added
+
+- Default values of the parameters of functions, methods, constructors, `func` literals and arrow
+  functions, as properties of components have them: `func greet(name string = "you", times = 1)`.
+- Rest parameters, `func log(level string, ...parts []any)`, and in function types,
+  `func(string, ...[]any)`.
+- Tagged templates, `` sql`select * from users where id = ${id}` ``, checked against the parameters
+  of the tag.
+- `export { Row, Rows } from "./rows.rk"` and `export * from "./rows.rk"`, with components,
+  decorators and state.
+- Object destructuring in `const` and `let`: `const { name, size: bytes, ...rest } = file`.
+- Methods in object literals: `{ fetch(req Request) Response { ... } }`.
+- `x!` takes a value not to be `null`, as in TypeScript.
+- `void`, for `Promise<void>` in interfaces and generics, and `never`, the result of a function
+  that never returns; a call of one narrows types as `throw` does, `process.exit(1)` included.
+- `bind:item={item}` for the item of a `{for}` loop: changes in place update the list, and a new
+  value replaces the item in it.
+- Imports of `.rk` and `.ts` modules by the aliases of `package.json` (`"imports"`, `#ui/button.rk`)
+  and of `tsconfig.json` (`"paths"`, `@/ui/button.rk`) are typed, and built with `.js`.
+- A conditional expression can be split with `?` and `:` at the start of the lines.
+- `func(a, b number) number` groups the parameters of a function type, as in Go.
+- An object type is the result of a function when its body follows, `func names() { [string]: string } { ... }`.
+- `type` is a keyword only before the name of a type at the start of a statement: variables,
+  parameters and fields can be named `type`.
+- The npm package has the changelog.
+
+### Fixed
+
+- A function of a component that changes state and that markup gives to a child, `act={copy}`,
+  or that an arrow given to it calls, `act={() => show("x")}`, updates the markup: it was taken for
+  code that renders, which updates nothing.
+- Importing `describe` and `it` from Vitest overflowed the stack, then took two minutes: the types of
+  `.d.ts` files that refer to themselves are substituted when they are used. Messages print a long
+  type inside another one as `{ ... }`.
+- The types of `@types/bun`: the global `Bun` and the module `bun` were untyped, and the options of
+  `Bun.serve({ fetch: req => ... })` give `req` its type.
+- A callback whose result in a `.d.ts` is `any` or `void | T`, `ws.onopen = () => { ... }`, and a
+  function whose result is `any` may end without `return`.
+- A line that ends with `>` of type arguments, `votes Map<string, number>`, ends the declaration.
+- A field of a class sees a constant of its module with a written type or a literal value,
+  `limit = LIMIT`.
+- Clearer errors for `` `${x++}` ``, type arguments in a call, `load<number>(1)`, and several
+  results of a conditional expression, `a ? two() : one()`.
+
+### The site
+
+- The site is deployed with each release of npm, not with each push to `main`, so it describes the
+  version that `npm install` gets.
+
+## 0.4.2 — 2026-10-31
+
+### Fixed
+
+- A function literal given to a child component, `<Plus add={() => { items++ }} />`, updates the
+  markup each time it is called. When the state it read changed, the parent gave the child the
+  function again, written without its updates: from the second call on, the state changed but the
+  page did not. A function declared with `func` in the body was not affected.
+
+## 0.4.1 — 2026-10-30
+
+### Added
+
+- Bun: the plugin `rooklang/bun`, preloaded with `preload = ["rooklang/bun/register"]` in
+  `bunfig.toml`, compiles `.rk` modules when they load, for `bun app.rk`, imports from TypeScript,
+  `bun --hot` and `bun test`, goroutines included. `rook run` under the runtime of Bun,
+  `bun --bun rook run app.rk`, runs the program in Bun, `--watch` too; it used to fail on
+  `registerHooks`, which Bun does not have.
+- The VS Code extension has the version of the package it carries, 0.4.1, and the stores get each
+  release: it was 0.1.0 there, with the compiler of 17 October. When the `rooklang` installed in a
+  project is older than its copy, which then checks the files with errors for newer syntax, the
+  status bar marks it and the extension offers to install the new version with the package
+  manager of the project.
+
+### Fixed
+
+- A worker of `go` that fails before it starts, as when its module does not load, fails the calls
+  that wait for it: they used to wait forever while the pool started worker after worker.
+
+## 0.4.0 — 2026-10-29
+
+### Breaking
+
+- `mount` is written without parentheses, like `effect`: `mount { ... }`. `mount() { ... }` is an
+  error that shows the new form.
+- `mount` cleans up with `defer`, as an effect does, and returns nothing: write
+  `defer clearInterval(timer)` instead of `return () => clearInterval(timer)`. `defer f(x)` takes
+  `x` at once; for a value that comes later, `defer { editor?.dispose() }` reads it when it runs.
+
+- A public member of a decorator is read as `@visible.shown`, without `get`: `get(@visible.shown)`
+  is now an error that shows the new form. Decorators are experimental, so the old form is not kept.
+  Write `@visible.shown` everywhere, in markup too: `{if @visible.shown { ... }}`.
+
+### Added
+
+- State of a module (experimental): `state items []Item = []` or `export state` at the top level
+  of a module is shared by its components. The components that read it are updated when it changes
+  anywhere in the module, through names that refer into it too (`for item in items`); they listen
+  while they are on the page. Other modules read it and change it only with the functions of its
+  module: `items.push(x)` there is an error that says so.
+- Bound properties (experimental): `comp Drawer(bind open bool = false)` changes `open` as its
+  state, and `<Drawer bind:open={menu} />` writes the changes, in place ones too, into the parent's
+  `menu`. Without `bind:` the property is the component's own state.
+- `class` takes a list of classes, `class={[styles.tab, active ? styles.active : null]}`: `null`s
+  and empty strings are left out.
+- A `bool` in `aria-*` and other attributes without a DOM property is written as `"true"` or
+  `"false"`, as ARIA expects; this is now documented and tested.
+
+- A decorator can include others: `dec card(title string) includes framed(title), likes { ... }`
+  applies them with it, above its own body, and their arguments see its parameters. The component
+  reads their public members through it, `@card.count`; `@card` counts as `@likes` applied, for
+  `needs` and for applying twice. An exported decorator cannot include others yet.
+- `public ref` in a decorator: the component reads the element of the wrapper as `@framed.box`.
+  The ref is read-only, its element is not: `@framed.box.title = "Card"`.
+- A `derived` of several statements is a block that returns the value:
+  `derived summary string { ...; return text }`. The type may be left out, and is then inferred
+  from the `return`s. In JS the block becomes a function, called first and by the updates of what
+  it reads; assigning state in it is an error. A `{` after the name of a `derived` now starts the
+  block, so an object type goes in parentheses there: `derived p ({ x number }) = ...`.
+- Tagged unions (experimental): comparing a tag, a field with a literal type in every member of a
+  union, narrows the union. After `if d.kind == "courier"` the fields of `Courier` can be read, and
+  so in `else`, after a branch that returns, in `switch d.kind` and in `{if}` and `{switch}` of
+  markup. An object literal where such a union is expected is checked as the member its tag
+  chooses: `{ kind: "pickup", shop: "Main st." }` fits `Pickup | Courier`, and a kind of no member
+  is an error that lists the kinds.
+- Paths of data fields from a variable, a parameter, `state`, `derived` or a module `const` narrow
+  like the variable: `if user.boss != null` gives `user.boss.name`, without an intermediate
+  `const`; `typeof` and `instanceof` narrow them too. An assignment to the path, its start or its
+  tag ends the narrowing, one to another field does not; getters, `a[i]` and `?.` are not paths.
+  The hint for a nullable
+  `<page.other />` now shows `{if page.other != null { <page.other /> }}`.
+- Keys of lists in markup: `{for todo in todos with key todo.id { ... }}` finds the blocks again
+  by the key, so a list loaded again from a server keeps its blocks and the state of the
+  components in them.
+- The browser compiler, which the playground uses, knows `AbortController`, `AbortSignal` and
+  `ImageData` as types too: `signal AbortSignal` compiles there.
+- The VS Code extension checks a file with the `rooklang` installed next to it, so the editor shows
+  the errors of the version that `rook build` runs; in an untrusted workspace, and without an
+  installed one, it uses its own copy. The status bar shows which compiler checked the file.
+- [docs/roadmap.md](docs/roadmap.md): where Rook stands and the road to 1.0, with what the
+  language is to have by then.
+
+### Fixed
+
+- The error of `decode` for a union names the member whose tag fits: `{ "kind": "square" }` of
+  `Circle | Square` gives `side: missing`, not `kind: expected "circle", got "square"`. A tag that
+  fits no member lists all of them: `kind: expected "circle" | "square", got "oval"`.
+- A literal type or a union of them, `type Status "shown" | "aborted"`, goes into an attribute
+  without a DOM property, `data-status={status}`.
+- With `runtime: "inline"`, as in the playground, a function of the program named like one of the
+  runtime, such as `check`, no longer replaces it.
+
+## 0.3.4 — 2026-10-26
+
+### Added
+
+- `decode<T>(json)`: checks JSON from outside against a type when the program runs.
+- `try` as an expression: what JS throws becomes the error value.
+- `error(msg, err)` wraps an error, as `%w` of Go.
+- `signal(...)`, `done(abortSignal)` and `abortSignal(ch)`: signals of the process and cancellation
+  as channels.
+- Topics, `topic<T>(name)`: values between the tabs of a site.
+- `for` over async iterables: streams of Node, `readline`, cursors.
+- `data class`: instances that go to goroutines with their class and methods.
+- Getters and setters, `readonly`, `abstract` classes, `if` with an initializer, labels, regular
+  expression literals.
+- Source maps: stack traces, in goroutines too, show the lines of the `.rk` file.
+- `rook run --watch`: runs the program again when a file of it changes.
+- Goroutines run under Vitest, which tests `.rk` modules with the Vite plugin.
+- The VS Code extension completes names that other `.rk` files of the package export and adds
+  their imports, and offers a quick fix that imports an undefined name.
+
+### Fixed
+
+- An array, a string or a `Set` goes where a `.d.ts` expects `Iterable<T>`.
+- The type parameters of a tuple `[K, V]` of a `.d.ts` are inferred by position:
+  `new Map([["a", 1]])` is a `Map<string, number>`.
+
+## 0.3.3 — 2026-10-18
+
+### Breaking
+
+- In `const user, err = load(id)` of a function of `(User, error)`, `user` is a `?User` until
+  `err` is checked: such a function may now `return null, err`. Check the error before the value,
+  `if err != null { return }`.
+
+### Changed
+
+- `go for` splits the array into four parts per processor, each to the first free worker.
+- `for i, x in items` over an array goes over its indexes instead of the pairs of `entries()`,
+  which is faster.
+
+### Fixed
+
+- `for i, c in s` over a string numbers its characters instead of throwing a `TypeError`.
+- The workers of `rook run` no longer load the compiler.
+
+## 0.3.2 — 2026-10-17
+
+### Breaking
+
+- The compiled code imports its runtime from `rooklang/runtime` instead of having it in every
+  module, so `rooklang` is a dependency of the project, not only of the build:
+  `npm install rooklang`.
+
+### Added
+
+- Queues: `queue T`, made by `queue<T>()` and `queue<T>(items)`.
+- Streams and channels: `chan(stream)` and `stream(ch)`.
+- The VS Code extension, published from CI.
+
+Earlier versions are in the history of the repository.

package/CHANGELOG.ru.md

@@ -0,0 +1,235 @@
+# Список изменений
+
+[English](CHANGELOG.md) · **Русский**
+
+Что изменилось в каждой версии `rooklang`: язык, компилятор, рантайм и расширение VS Code. Путь к
+1.0 описан в [docs/roadmap.ru.md](docs/roadmap.ru.md).
+
+**Версии до 1.0.** Минорная версия (0.4.0) может сломать код, который раньше компилировался, и
+говорит, как его поменять, в разделе **Ломающие изменения**. Патч (0.3.5) никогда не ломает: он
+только добавляет и исправляет.
+
+## 0.5.0 — 2026-10-31
+
+Что нашла команда, которая пишет на Rook браузерную игру с Bun и Vite: чего не хватало и что не
+работало.
+
+### Ломающие изменения
+
+- Компонент не меняет несвязанное свойство ни присваиванием, ни на месте: `todo.done = true`,
+  `bind:value={todo.title}` и `items.push(x)` для свойства — ошибки, потому что объект принадлежит
+  родителю, а его разметка об изменении не знала. Объявите свойство связанным,
+  `comp TodoItem(bind todo Todo)`, и передайте его через `bind:todo={todo}`; теперь так можно
+  связать и элемент цикла `{for}`.
+- `export const Rows = Inner` для компонента без типа — ошибка: его `.d.ts` терял свойства.
+  Пишите `export { Rows } from "./rows.rk"` или дайте константе тип компонента.
+
+### Добавлено
+
+- Значения по умолчанию у параметров функций, методов, конструкторов, литералов `func` и стрелочных
+  функций, как у свойств компонентов: `func greet(name string = "you", times = 1)`.
+- Остаток аргументов, `func log(level string, ...parts []any)`, и в типах функций,
+  `func(string, ...[]any)`.
+- Теговые шаблоны, `` sql`select * from users where id = ${id}` ``, которые проверяются по
+  параметрам тега.
+- `export { Row, Rows } from "./rows.rk"` и `export * from "./rows.rk"` — с компонентами,
+  декораторами и состоянием.
+- Деструктуризация объектов в `const` и `let`: `const { name, size: bytes, ...rest } = file`.
+- Методы в объектных литералах: `{ fetch(req Request) Response { ... } }`.
+- `x!` считает значение не `null`, как в TypeScript.
+- `void` — для `Promise<void>` в интерфейсах и обобщённых типах, и `never` — результат функции,
+  которая не возвращается; её вызов сужает типы, как `throw`, в том числе `process.exit(1)`.
+- `bind:item={item}` для элемента цикла `{for}`: изменения на месте обновляют список, а новое
+  значение заменяет в нём элемент.
+- Импорты `.rk`- и `.ts`-модулей по алиасам из `package.json` (`"imports"`, `#ui/button.rk`) и
+  `tsconfig.json` (`"paths"`, `@/ui/button.rk`) типизированы и собираются с `.js`.
+- Условное выражение можно переносить, начиная строки с `?` и `:`.
+- `func(a, b number) number` группирует параметры типа функции, как в Go.
+- Объектный тип — результат функции, если за ним идёт тело: `func names() { [string]: string } { ... }`.
+- `type` — ключевое слово только перед именем типа в начале оператора: переменные, параметры и
+  поля можно называть `type`.
+- В npm-пакете есть список изменений.
+
+### Исправлено
+
+- Функция компонента, которая меняет состояние и которую разметка передаёт дочернему компоненту,
+  `act={copy}`, или которую вызывает переданная ему стрелка, `act={() => show("x")}`, обновляет
+  разметку: её принимали за код отрисовки, который ничего не обновляет.
+- Импорт `describe` и `it` из Vitest переполнял стек, а затем проверялся две минуты: типы
+  `.d.ts`, которые ссылаются сами на себя, подставляются, когда используются. Длинный тип внутри
+  другого сообщения печатают как `{ ... }`.
+- Типы `@types/bun`: глобальный `Bun` и модуль `bun` были без типов, а в
+  `Bun.serve({ fetch: req => ... })` у `req` теперь есть тип.
+- Колбэк, у которого в `.d.ts` результат `any` или `void | T`, `ws.onopen = () => { ... }`, и
+  функция с результатом `any` могут закончиться без `return`.
+- Строка, которая кончается на `>` аргументов типа, `votes Map<string, number>`, завершает
+  объявление.
+- Поле класса видит константу своего модуля с записанным типом или литеральным значением,
+  `limit = LIMIT`.
+- Понятные ошибки для `` `${x++}` ``, аргументов типа в вызове, `load<number>(1)`, и нескольких
+  результатов условного выражения, `a ? two() : one()`.
+
+### Сайт
+
+- Сайт выкладывается с каждым выпуском в npm, а не с каждым пушем в `main`, поэтому описывает ту
+  версию, которую ставит `npm install`.
+
+## 0.4.2 — 2026-10-31
+
+### Исправлено
+
+- Функция-литерал, переданная дочернему компоненту, `<Plus add={() => { items++ }} />`, обновляет
+  разметку при каждом вызове. Когда менялось состояние, которое она читала, родитель передавал
+  ребёнку функцию заново — уже без обновлений: начиная со второго вызова состояние менялось, а
+  страница нет. Функции, объявленной в теле через `func`, это не касалось.
+
+## 0.4.1 — 2026-10-30
+
+### Добавлено
+
+- Bun: плагин `rooklang/bun`, который подключают заранее строкой
+  `preload = ["rooklang/bun/register"]` в `bunfig.toml`, компилирует `.rk`-модули при загрузке —
+  для `bun app.rk`, импортов из TypeScript, `bun --hot` и `bun test`, с горутинами. `rook run` под
+  рантаймом Bun, `bun --bun rook run app.rk`, выполняет программу в Bun, и с `--watch` тоже; раньше
+  он падал на `registerHooks`, которого в Bun нет.
+- У расширения VS Code та же версия, что у пакета, который оно несёт, — 0.4.1, и в магазины
+  попадает каждый выпуск: там была 0.1.0 с компилятором от 17 октября. Если `rooklang`,
+  установленный в проекте, старше его копии — и тогда новый синтаксис подчёркивается как ошибка, —
+  строка состояния отмечает это, а расширение предлагает поставить новую версию менеджером пакетов
+  проекта.
+
+### Исправлено
+
+- Воркер `go`, который упал до старта — например, потому что его модуль не загрузился, — отклоняет
+  вызовы, которые его ждут: раньше они ждали вечно, а пул запускал воркер за воркером.
+
+## 0.4.0 — 2026-10-29
+
+### Ломающие изменения
+
+- `mount` пишется без скобок, как `effect`: `mount { ... }`. `mount() { ... }` — ошибка, которая
+  показывает новую запись.
+- `mount` убирает за собой через `defer`, как эффект, и ничего не возвращает: пишите
+  `defer clearInterval(timer)` вместо `return () => clearInterval(timer)`. `defer f(x)` берёт `x`
+  сразу; для значения, которое появится позже, `defer { editor?.dispose() }` читает его при
+  выполнении.
+
+- Публичный член декоратора читают как `@visible.shown`, без `get`: `get(@visible.shown)` теперь
+  ошибка, которая показывает новую запись. Декораторы экспериментальные, поэтому старая запись не
+  сохраняется. Пишите `@visible.shown` везде, и в разметке тоже: `{if @visible.shown { ... }}`.
+
+### Добавлено
+
+- Состояние модуля (экспериментально): `state items []Item = []` или `export state` на верхнем
+  уровне модуля делят его компоненты. Компоненты, которые его читают, обновляются, когда оно
+  меняется где угодно в модуле, в том числе через имена, которые указывают внутрь него
+  (`for item in items`); они слушают, пока они на странице. Другие модули его читают и меняют только
+  функциями его модуля: `items.push(x)` там — ошибка, которая это подсказывает.
+- Связанные свойства (экспериментально): `comp Drawer(bind open bool = false)` меняет `open` как
+  своё состояние, а `<Drawer bind:open={menu} />` записывает изменения, в том числе на месте, в
+  `menu` родителя. Без `bind:` свойство — собственное состояние компонента.
+- `class` принимает список классов, `class={[styles.tab, active ? styles.active : null]}`: `null` и
+  пустые строки выпадают.
+- `bool` в `aria-*` и других атрибутах без DOM-свойства записывается как `"true"` или `"false"`,
+  как ждёт ARIA; теперь это описано и проверено тестом.
+
+- Декоратор может включать другие: `dec card(title string) includes framed(title), likes { ... }`
+  применяет их вместе с собой, выше своего тела, а их аргументы видят его параметры. Компонент
+  читает их публичные члены через него, `@card.count`; `@card` считается применённым `@likes` — для
+  `needs` и для повторного применения. Экспортированный декоратор пока не может включать другие.
+- `public ref` в декораторе: компонент читает элемент обёртки как `@framed.box`. Сам ref только для
+  чтения, его элемент — нет: `@framed.box.title = "Card"`.
+- `derived` из нескольких операторов — блок, который возвращает значение:
+  `derived summary string { ...; return text }`. Тип можно не писать, тогда он выводится из
+  `return`. В JS блок становится функцией, которую вызывают сначала и в обновлениях того, что он
+  читает; присвоить в нём состояние — ошибка. `{` после имени `derived` теперь начинает блок,
+  поэтому объектный тип там пишут в скобках: `derived p ({ x number }) = ...`.
+- Tagged unions (экспериментально): сравнение метки, поля с литеральным типом у каждого члена
+  union, сужает union. После `if d.kind == "courier"` можно читать поля `Courier`, и так же в
+  `else`, после ветки с `return`, в `switch d.kind` и в `{if}` и `{switch}` разметки. Объектный
+  литерал там, где ожидается такой union, проверяется как член, который выбирает его метка:
+  `{ kind: "pickup", shop: "Main st." }` подходит к `Pickup | Courier`, а вид, которого нет ни у
+  одного члена, — ошибка со списком видов.
+- Пути полей с данными от переменной, параметра, `state`, `derived` или `const` модуля сужаются
+  так же, как переменная: `if user.boss != null` даёт `user.boss.name` без промежуточной `const`;
+  `typeof` и `instanceof` их тоже сужают. Присваивание пути, его начала или его метки сбрасывает
+  сужение, присваивание другого поля — нет; геттеры, `a[i]` и `?.` путями не считаются. Подсказка для `<page.other />`, который
+  может быть null, теперь показывает `{if page.other != null { <page.other /> }}`.
+- Ключи списков в разметке: `{for todo in todos with key todo.id { ... }}` находит блоки заново по
+  ключу, так что список, заново загруженный с сервера, сохраняет свои блоки и состояние компонентов
+  в них.
+- Браузерный компилятор, которым пользуется песочница, знает `AbortController`, `AbortSignal` и
+  `ImageData` и как типы: `signal AbortSignal` там компилируется.
+- Расширение VS Code проверяет файл тем `rooklang`, который установлен рядом с ним, так что редактор
+  показывает ошибки той версии, которую запускает `rook build`; в недоверенной рабочей области и без
+  установленного пакета — своей копией. Строка состояния показывает, какой компилятор проверил файл.
+- [docs/roadmap.ru.md](docs/roadmap.ru.md): где Rook сейчас и путь к 1.0, и что к тому времени
+  должно быть в языке.
+
+### Исправлено
+
+- Ошибка `decode` для union называет член, чья метка подошла: `{ "kind": "square" }` для
+  `Circle | Square` даёт `side: missing`, а не `kind: expected "circle", got "square"`. Метка, которая
+  не подошла ни к одному члену, перечисляет их все: `kind: expected "circle" | "square", got "oval"`.
+- Литеральный тип или их объединение, `type Status "shown" | "aborted"`, можно передать в атрибут
+  без DOM-свойства, `data-status={status}`.
+- С `runtime: "inline"`, как в песочнице, функция программы с тем же именем, что у функции
+  рантайма, например `check`, больше её не подменяет.
+
+## 0.3.4 — 2026-10-26
+
+### Добавлено
+
+- `decode<T>(json)`: проверяет JSON снаружи по типу, когда программа работает.
+- `try` как выражение: то, что бросает JS, становится значением ошибки.
+- `error(msg, err)` оборачивает ошибку, как `%w` в Go.
+- `signal(...)`, `done(abortSignal)` и `abortSignal(ch)`: сигналы процесса и отмена как каналы.
+- Топики, `topic<T>(name)`: значения между вкладками сайта.
+- `for` по асинхронным итерируемым: потоки Node, `readline`, курсоры.
+- `data class`: экземпляры, которые уходят в горутины вместе со своим классом и методами.
+- Геттеры и сеттеры, `readonly`, абстрактные классы, `if` с инициализатором, метки, литералы
+  регулярных выражений.
+- Source maps: стектрейсы, в горутинах тоже, показывают строки `.rk`-файла.
+- `rook run --watch`: запускает программу заново, когда меняется её файл.
+- Горутины работают под Vitest, который тестирует `.rk`-модули с плагином Vite.
+- Расширение VS Code дополняет имена, которые экспортируют другие `.rk`-файлы пакета, и добавляет
+  их импорты, а для неопределённого имени предлагает исправление, которое его импортирует.
+
+### Исправлено
+
+- Массив, строку или `Set` можно передать туда, где `.d.ts` ждёт `Iterable<T>`.
+- Параметры типа кортежа `[K, V]` из `.d.ts` выводятся по позиции: `new Map([["a", 1]])` — это
+  `Map<string, number>`.
+
+## 0.3.3 — 2026-10-18
+
+### Ломающие изменения
+
+- В `const user, err = load(id)` функции с `(User, error)` значение `user` имеет тип `?User`, пока
+  не проверен `err`: такая функция теперь может вернуть `return null, err`. Проверяйте ошибку раньше
+  значения: `if err != null { return }`.
+
+### Изменено
+
+- `go for` делит массив на четыре части на процессор, каждую — первому свободному воркеру.
+- `for i, x in items` по массиву идёт по индексам, а не по парам `entries()`: так быстрее.
+
+### Исправлено
+
+- `for i, c in s` по строке нумерует её символы, а не бросает `TypeError`.
+- Воркеры `rook run` больше не загружают компилятор.
+
+## 0.3.2 — 2026-10-17
+
+### Ломающие изменения
+
+- Скомпилированный код импортирует рантайм из `rooklang/runtime`, а не держит его в каждом модуле,
+  так что `rooklang` — зависимость проекта, а не только сборки: `npm install rooklang`.
+
+### Добавлено
+
+- Очереди: `queue T`, создаются через `queue<T>()` и `queue<T>(items)`.
+- Потоки и каналы: `chan(stream)` и `stream(ch)`.
+- Расширение VS Code, которое публикуется из CI.
+
+Более ранние версии — в истории репозитория.

package/dist/aliases.d.ts

@@ -0,0 +1,2 @@
+/** The absolute path of the `.rk` module `specifier` imported from `fromFile`, or null. */
+export declare function resolveRookModule(fromFile: string, specifier: string): string | null;

package/dist/aliases.js

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+// Where a `.rk` module that an import names is: a relative path, a subpath import of package.json,
+// `#ui/button.rk` with "imports": { "#ui/*": "./src/ui/*" }, or a path of tsconfig.json,
+// `@/ui/button.rk` with "paths": { "@/*": ["./src/*"] }, which Vite and TypeScript resolve too.
+/** The absolute path of the `.rk` module `specifier` imported from `fromFile`, or null. */
+export function resolveRookModule(fromFile, specifier) {
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        return resolve(dirname(fromFile), specifier);
+    }
+    if (specifier.startsWith('#')) {
+        const found = nearest(fromFile, 'package.json');
+        const imports = found?.json.imports;
+        const target = imports && match(imports, specifier);
+        return found && typeof target === 'string' ? resolve(found.dir, target) : null;
+    }
+    const found = nearest(fromFile, 'tsconfig.json');
+    const options = found?.json.compilerOptions;
+    const target = options?.paths && match(options.paths, specifier);
+    return found && typeof target === 'string'
+        ? resolve(found.dir, options?.baseUrl ?? '.', target)
+        : null;
+}
+/** The target of the first pattern that fits, with its `*` filled in. */
+function match(patterns, specifier) {
+    for (const [pattern, value] of Object.entries(patterns)) {
+        const target = firstTarget(value);
+        const star = pattern.indexOf('*');
+        if (target === null)
+            continue;
+        if (star === -1) {
+            if (pattern === specifier)
+                return target;
+            continue;
+        }
+        const prefix = pattern.slice(0, star);
+        const suffix = pattern.slice(star + 1);
+        if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) {
+            return target.replace('*', specifier.slice(prefix.length, specifier.length - suffix.length));
+        }
+    }
+    return null;
+}
+/** A path, the first of a list, or that of the conditions `import` or `default`. */
+function firstTarget(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return firstTarget(value[0]);
+    if (value && typeof value === 'object') {
+        const conditions = value;
+        return firstTarget(conditions.import ?? conditions.default ?? null);
+    }
+    return null;
+}
+/** The nearest file of this name above `fromFile`, read as JSON with comments, as tsconfig.json is. */
+function nearest(fromFile, name) {
+    for (let dir = dirname(fromFile);; dir = dirname(dir)) {
+        let text = null;
+        try {
+            text = readFileSync(join(dir, name), 'utf8');
+        }
+        catch {
+            // Not in this directory.
+        }
+        if (text !== null) {
+            try {
+                return { dir, json: JSON.parse(withoutComments(text)) };
+            }
+            catch {
+                return null;
+            }
+        }
+        if (dirname(dir) === dir)
+            return null;
+    }
+}
+/** JSON without the comments and trailing commas that tsconfig.json may have. */
+function withoutComments(text) {
+    return text
+        .replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (part) => part.startsWith('"') ? part : '')
+        .replace(/,(\s*[}\]])/g, '$1');
+}

package/dist/ast/declarations.d.ts

@@ -26,6 +26,16 @@ export interface ImportSpecifier extends NodeBase {
     imported: Identifier;
     local: Identifier;
 }
+/**
+ * `export { Row, Rows } from "./rows.rk"` or `export * from "./rows.rk"`: names of another module,
+ * which this one exports but does not see itself, as in JS.
+ */
+export interface ExportFromDeclaration extends NodeBase {
+    kind: 'ExportFromDeclaration';
+    /** `null` for `export *`; `imported` is the name there, `local` the one it is exported under. */
+    specifiers: ImportSpecifier[] | null;
+    source: StringLiteral;
+}
 /** `func divide(a, b number) (number, error) { ... }` */
 export interface FuncDeclaration extends NodeBase {
     kind: 'FuncDeclaration';
@@ -142,6 +152,14 @@ export interface VariableDeclaration extends NodeBase {
      * component stops at it, as at other functions. Its result type is `type`; `values` is empty.
      */
     body: FuncExpression | null;
+    /**
+     * `const { name, size: bytes, ...rest } = file`: the key of the field that each name takes, in
+     * the order of `names`; with `rest`, the last name gets the other fields.
+     */
+    pattern?: {
+        keys: (Identifier | StringLiteral)[];
+        rest: boolean;
+    };
 }
 /** `class Admin extends User implements Shape { ... }` */
 export interface ClassDeclaration extends NodeBase {

package/dist/ast/expressions.d.ts

@@ -1,7 +1,18 @@
 import type { NodeBase, Parameter } from './declarations.ts';
 import type { ElementExpression, TypeNode } from './markup.ts';
 import type { BlockStatement } from './statements.ts';
-export type Expression = Identifier | NumberLiteral | BigIntLiteral | StringLiteral | RegExpLiteral | TemplateLiteral | BooleanLiteral | NullLiteral | ThisExpression | SuperExpression | ArrayLiteral | ObjectLiteral | FuncExpression | ArrowFunction | UnaryExpression | BinaryExpression | ConditionalExpression | CallExpression | NewExpression | MemberExpression | IndexExpression | ElementExpression | DecoratorMember | AsExpression | GoExpression | ChanExpression | StreamChanExpression | QueueExpression | TopicExpression | DecodeExpression | TryExpression | ConversionExpression | MakeExpression;
+export type Expression = Identifier | NumberLiteral | BigIntLiteral | StringLiteral | RegExpLiteral | TemplateLiteral | BooleanLiteral | NullLiteral | ThisExpression | SuperExpression | ArrayLiteral | ObjectLiteral | FuncExpression | ArrowFunction | UnaryExpression | BinaryExpression | ConditionalExpression | CallExpression | NewExpression | MemberExpression | IndexExpression | ElementExpression | DecoratorMember | AsExpression | GoExpression | ChanExpression | StreamChanExpression | QueueExpression | TopicExpression | DecodeExpression | TryExpression | ConversionExpression | MakeExpression | NonNullExpression | TaggedTemplateExpression;
+/** `user!`: the value is taken not to be null, as in TypeScript; nothing is checked at runtime. */
+export interface NonNullExpression extends NodeBase {
+    kind: 'NonNullExpression';
+    expression: Expression;
+}
+/** sql`select ... ${id}`: the function gets the strings and the values, as in JS. */
+export interface TaggedTemplateExpression extends NodeBase {
+    kind: 'TaggedTemplateExpression';
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
 /**
  * `[]byte("rook")`: the UTF-8 bytes of a string. `string(data)`, the way back, is a call, since
  * `string` may be the name of a value.
@@ -156,6 +167,8 @@ export interface Property extends NodeBase {
     key: Identifier | StringLiteral;
     value: Expression;
     shorthand: boolean;
+    /** `fetch(req Request) Response { ... }`: a method, whose value is a FuncExpression. */
+    method?: true;
 }
 /** `...xs` in array literals, object literals and call arguments. */
 export interface SpreadElement extends NodeBase {

package/dist/ast/markup.d.ts

@@ -101,6 +101,8 @@ export interface NullableType extends NodeBase {
 export interface FuncType extends NodeBase {
     kind: 'FuncType';
     params: TypeNode[];
+    /** `func(string, ...[]any)`: the array of the arguments after the others. */
+    rest?: TypeNode;
     results: TypeNode[];
     /** `func(yield func(T) bool)`: its one parameter is named `yield`, so it is an iterator. */
     iterator?: boolean;

package/dist/ast/statements.d.ts

@@ -1,7 +1,7 @@
-import type { ClassDeclaration, ComponentDeclaration, DecoratorDeclaration, FuncDeclaration, ImportDeclaration, InterfaceDeclaration, NodeBase, TypeAliasDeclaration, VariableDeclaration } from './declarations.ts';
+import type { ClassDeclaration, ComponentDeclaration, DecoratorDeclaration, ExportFromDeclaration, FuncDeclaration, ImportDeclaration, InterfaceDeclaration, NodeBase, TypeAliasDeclaration, VariableDeclaration } from './declarations.ts';
 import type { CallExpression, Expression, Identifier, UnaryExpression } from './expressions.ts';
 import type { JsxElementStatement } from './markup.ts';
-export type Statement = ImportDeclaration | FuncDeclaration | ComponentDeclaration | DecoratorDeclaration | VariableDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | BlockStatement | ExpressionStatement | AssignmentStatement | IncDecStatement | ReturnStatement | IfStatement | ForStatement | ForInStatement | SwitchStatement | BreakStatement | ContinueStatement | ThrowStatement | TryStatement | DeferStatement | MountStatement | EffectStatement | StyleStatement | DeleteStatement | JsxElementStatement | SendStatement | SelectStatement;
+export type Statement = ImportDeclaration | ExportFromDeclaration | FuncDeclaration | ComponentDeclaration | DecoratorDeclaration | VariableDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | BlockStatement | ExpressionStatement | AssignmentStatement | IncDecStatement | ReturnStatement | IfStatement | ForStatement | ForInStatement | SwitchStatement | BreakStatement | ContinueStatement | ThrowStatement | TryStatement | DeferStatement | MountStatement | EffectStatement | StyleStatement | DeleteStatement | JsxElementStatement | SendStatement | SelectStatement;
 /** Statements allowed in the `init` and `update` parts of a `for` header. */
 export type SimpleStatement = VariableDeclaration | ExpressionStatement | AssignmentStatement | IncDecStatement | DeleteStatement | SendStatement;
 /**