rooklang 0.3.4 → 0.4.1

package/README.md

@@ -58,10 +58,12 @@ close(results)
 The guide with examples and a playground: <https://qwern-9876r.github.io/RookLang/>.
 Specification: [docs/spec.md](docs/spec.md), design of components:
 [docs/components.md](docs/components.md), an example: [examples/hello.rk](examples/hello.rk).
+Where Rook stands and the road to 1.0: [docs/roadmap.md](docs/roadmap.md); what changed in each
+version: [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
-Rook needs Node.js ≥ 24.
+Rook needs Node.js ≥ 24 or [Bun](#bun).
 
 ```sh
 npm install rooklang
@@ -75,7 +77,8 @@ The compiled code imports what channels, goroutines and markup need from `rookla
 the package is a dependency of the project, not only of its build.
 
 From code, the compiler is `import { compile } from 'rooklang'`. The package also has the
-[Vite](#vite) plugin, `rooklang/vite`, and `rooklang/browser`, the compiler without the
+[Vite](#vite) plugin, `rooklang/vite`, the [Bun](#bun) plugin, `rooklang/bun`, and
+`rooklang/browser`, the compiler without the
 TypeScript compiler for running in a browser, as in the site's playground: there imports are not
 type checked.
 
@@ -208,6 +211,34 @@ import { add } from './math.rk';
 it('adds', () => expect(add(1, 2)).toBe(3));
 ```
 
+## Bun
+
+Rook works in Bun too: `bun add rooklang`, then `bunx rook build app.rk` or `bunx rook run
+app.rk`. Under the runtime of Bun, `bun --bun rook run app.rk`, the program runs in Bun.
+
+To let Bun load `.rk` modules itself, preload the plugin `rooklang/bun` in `bunfig.toml`:
+
+```toml
+preload = ["rooklang/bun/register"]
+
+[test]
+preload = ["rooklang/bun/register"]
+```
+
+Then `bun app.rk` runs a module, TypeScript imports `.rk` modules, `bun --watch` and `bun --hot`
+follow them, and `bun test` runs tests of them; goroutines work there too. The plugin itself is
+`import { rook } from 'rooklang/bun'`, for `Bun.plugin(rook())` or `Bun.build({ plugins: [rook()] })`;
+a bundle of `Bun.build` cannot have the workers of `go` yet, so build those with `rook build` or
+Vite.
+
+```ts
+// math.test.ts
+import { expect, test } from 'bun:test';
+import { add } from './math.rk';
+
+test('adds', () => expect(add(1, 2)).toBe(3));
+```
+
 ## Conventions
 
 - Imports are written with the `.ts` extension (`import { x } from './lexer.ts'`).

package/README.ru.md

@@ -58,10 +58,12 @@ close(results)
 Руководство с примерами и песочницей: <https://qwern-9876r.github.io/RookLang/ru/>.
 Спецификация: [docs/spec.ru.md](docs/spec.ru.md), концепция компонентов:
 [docs/components.ru.md](docs/components.ru.md), пример: [examples/hello.rk](examples/hello.rk).
+Где Rook сейчас и путь к 1.0: [docs/roadmap.ru.md](docs/roadmap.ru.md); что изменилось в каждой
+версии: [CHANGELOG.ru.md](CHANGELOG.ru.md).
 
 ## Установка
 
-Нужен Node.js ≥ 24.
+Нужен Node.js ≥ 24 или [Bun](#bun).
 
 ```sh
 npm install rooklang
@@ -75,7 +77,8 @@ npx rook run --watch app.rk          # и запускать снова, ког
 `rooklang/runtime`, поэтому пакет — зависимость проекта, а не только его сборки.
 
 Из кода компилятор подключается как `import { compile } from 'rooklang'`. Ещё в пакете есть
-плагин для [Vite](#vite) — `rooklang/vite` — и `rooklang/browser`: компилятор без
+плагин для [Vite](#vite) — `rooklang/vite`, — плагин для [Bun](#bun) — `rooklang/bun` — и
+`rooklang/browser`: компилятор без
 компилятора TypeScript, для работы в браузере, как в песочнице сайта; импорты там не проверяются
 по типам.
 
@@ -208,6 +211,34 @@ import { add } from './math.rk';
 it('adds', () => expect(add(1, 2)).toBe(3));
 ```
 
+## Bun
+
+Rook работает и в Bun: `bun add rooklang`, потом `bunx rook build app.rk` или `bunx rook run
+app.rk`. Под рантаймом Bun, `bun --bun rook run app.rk`, программа выполняется в Bun.
+
+Чтобы Bun сам загружал `.rk`-модули, плагин `rooklang/bun` подключают заранее в `bunfig.toml`:
+
+```toml
+preload = ["rooklang/bun/register"]
+
+[test]
+preload = ["rooklang/bun/register"]
+```
+
+Тогда `bun app.rk` запускает модуль, TypeScript импортирует `.rk`-модули, `bun --watch` и
+`bun --hot` следят за ними, а `bun test` запускает их тесты; горутины там тоже работают. Сам плагин —
+`import { rook } from 'rooklang/bun'`, для `Bun.plugin(rook())` или
+`Bun.build({ plugins: [rook()] })`; в бандле `Bun.build` воркеров `go` пока быть не может, поэтому
+такой код собирают `rook build` или Vite.
+
+```ts
+// math.test.ts
+import { expect, test } from 'bun:test';
+import { add } from './math.rk';
+
+test('adds', () => expect(add(1, 2)).toBe(3));
+```
+
 ## Соглашения
 
 - Импорты пишутся с расширением `.ts` (`import { x } from './lexer.ts'`).

package/dist/ast/declarations.d.ts

@@ -1,4 +1,4 @@
-import type { Expression, Identifier, StringLiteral } from './expressions.ts';
+import type { Expression, FuncExpression, Identifier, StringLiteral } from './expressions.ts';
 import type { TypeMember, TypeNode, TypeReference } from './markup.ts';
 import type { BlockStatement, Statement } from './statements.ts';
 export interface NodeBase {
@@ -57,6 +57,11 @@ export interface Parameter extends NodeBase {
      * properties, which `{...attrs}` puts on one of its elements.
      */
     rest?: true;
+    /**
+     * `bind active string`: a property of a component that it may change. `bind:active={tab}`
+     * writes the changes into the parent's `tab`; without it the property is the component's state.
+     */
+    bind?: true;
     /**
      * `constructor(private name string)`: the parameter is a property too, which the constructor
      * assigns, as in TypeScript.
@@ -97,6 +102,11 @@ export interface DecoratorDeclaration extends NodeBase {
     params: Parameter[];
     /** `needs cart, auth`: the decorators whose public members it uses; they are applied above it. */
     needs: Identifier[];
+    /**
+     * `includes visible(margin), cart`: decorators applied with it, above its own body, whose
+     * arguments see its parameters. Their public members are its own for the component, `@shop.count`.
+     */
+    includes: DecoratorUse[];
     body: BlockStatement;
 }
 /** `@visible("300px")` or `@visible` before `comp`; the arguments are positional. */
@@ -118,14 +128,20 @@ export interface VariableDeclaration extends NodeBase {
     exported: boolean;
     keyword: 'let' | 'const' | 'state' | 'derived' | 'ref';
     /**
-     * `public state`, `public derived` or `public const` in a decorator: the component reads it with
-     * `get(@name.x)`.
+     * `public state`, `public derived` or `public const` in a decorator: the component reads it as
+     * `@name.x`.
      */
     isPublic: boolean;
     /** `_` is an ordinary identifier here; the checker treats it as "skip this value". */
     names: Identifier[];
     type: TypeNode | null;
     values: Expression[];
+    /**
+     * `derived summary string { ...; return text }`: the block that computes a derived value, a
+     * function without parameters, so that what looks for the `return`s, `defer`s and `break`s of a
+     * component stops at it, as at other functions. Its result type is `type`; `values` is empty.
+     */
+    body: FuncExpression | null;
 }
 /** `class Admin extends User implements Shape { ... }` */
 export interface ClassDeclaration extends NodeBase {

package/dist/ast/expressions.d.ts

@@ -1,7 +1,7 @@
 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 | DecoratorGet | 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;
 /**
  * `[]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.
@@ -231,16 +231,12 @@ export interface IndexExpression extends NodeBase {
     optional: boolean;
 }
 /**
- * `@visible.shown`: a public member of a decorator applied to the component. The names belong to
- * the decorator, not to any scope, so walkers do not visit them as identifiers.
+ * `@visible.shown` or `@visible.show()`: a public member of a decorator applied to the component,
+ * read or called. The names belong to the decorator, not to any scope, so walkers do not visit them
+ * as identifiers.
  */
 export interface DecoratorMember extends NodeBase {
     kind: 'DecoratorMember';
     decorator: Identifier;
     member: Identifier;
 }
-/** `get(@visible.shown)`: reads public state or a constant of a decorator. */
-export interface DecoratorGet extends NodeBase {
-    kind: 'DecoratorGet';
-    target: DecoratorMember;
-}

package/dist/ast/statements.d.ts

@@ -86,6 +86,8 @@ export interface ForInStatement extends NodeBase {
     key: Identifier | null;
     value: Identifier;
     iterable: Expression;
+    /** `with key todo.id` of a `{for}` in markup: what its blocks are found again by. */
+    withKey?: Expression;
     body: BlockStatement;
     go?: boolean;
 }
@@ -156,7 +158,7 @@ export interface DeferStatement extends NodeBase {
     body: CallExpression | BlockStatement;
 }
 /**
- * `mount() { ... }` at the top level of a component: runs once the component's markup is in the
+ * `mount { ... }` at the top level of a component: runs once the component's markup is in the
  * document. It may return a function, which runs when `{if}`, `{switch}` or `{for}` removes the
  * markup.
  */

package/dist/bun-register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bun-register.js

@@ -0,0 +1,9 @@
+import { rook } from "./bun.js";
+// `preload = ["rooklang/bun/register"]` in bunfig.toml: Bun then compiles `.rk` modules when they
+// load, in `bun app.rk`, in imports from TypeScript and in `bun test` (bun.ts). `rook run` under
+// Bun preloads it too, and the workers of `go` import it before their module.
+const { Bun } = globalThis;
+if (Bun === undefined) {
+    throw new Error('rooklang/bun/register is for Bun; in Node, rook run compiles .rk files');
+}
+Bun.plugin(rook());

package/dist/bun.d.ts

@@ -0,0 +1,34 @@
+/** What a plugin of Bun is given, of what Rook uses: the package needs no types of Bun. */
+interface PluginBuilder {
+    onResolve(constraints: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: {
+        path: string;
+        importer: string;
+    }) => {
+        path: string;
+        namespace?: string;
+    }): void;
+    onLoad(constraints: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: {
+        path: string;
+    }) => {
+        contents: string;
+        loader: 'js';
+    }): void;
+}
+export interface BunPlugin {
+    name: string;
+    setup(build: PluginBuilder): void;
+}
+export interface RookBunOptions {
+    /** Check types before generating code. Defaults to `true`. */
+    typeCheck?: boolean;
+    /** Markup and components; by default as the package.json of the file says. */
+    markup?: boolean;
+}
+export declare function rook(options?: RookBunOptions): BunPlugin;
+export {};

package/dist/bun.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isMainThread } from 'node:worker_threads';
+import { displayPath } from "./build.js";
+import { compileFile } from "./compile-file.js";
+import { cachedFile, listFiles, withMap } from "./run-cache.js";
+import { RUNTIME_MODULE } from "./runtime-module.js";
+// The plugin of Bun: `bun app.rk`, `import "./cart.rk"` from TypeScript and `bun test` compile the
+// `.rk` modules when they load, as `rook run` does in Node (loader.ts). `preload =
+// ["rooklang/bun/register"]` in bunfig.toml registers it (bun-register.ts), and so does
+// `rook run` under Bun.
+//
+// `app.rk.goroutines.js` is the worker module of `go` in app.rk: Bun drops the query of
+// `app.rk?goroutines` before a plugin sees it, as Vite does (vite.ts). A Web Worker of Bun has no
+// preload and loads its module without the plugins, so it starts with a module that registers the
+// plugin first (startWorker in codegen/runtime.ts). The main thread compiles a module once and
+// leaves its code and that of its worker module in ROOK_RUN_CACHE, a directory of the run, which
+// the workers take instead of compiling again; without a run of `rook run`, the plugin makes one
+// and removes it when the process ends.
+/** The worker module of `go` in a module, `app.rk.goroutines.js`, next to it. */
+const GOROUTINES = '.goroutines.js';
+// The files next to this one: .ts in src, .js in the dist of the package.
+const extension = extname(fileURLToPath(import.meta.url));
+// The worker of `go` registers the plugin with this module before it imports its module.
+const register = new URL(`./bun-register${extension}`, import.meta.url).href;
+// The compiled code imports the runtime of this compiler, wherever the program is, by its URL: a
+// worker of Bun does not give a plugin the bare `rooklang/runtime`, and looks for the package.
+const runtimeImport = `from "${RUNTIME_MODULE}";`;
+const runtime = `from ${JSON.stringify(import.meta.resolve(RUNTIME_MODULE))};`;
+export function rook(options = {}) {
+    return {
+        name: 'rook',
+        setup(build) {
+            build.onResolve({ filter: /\.rk\.goroutines\.js$/ }, (args) => ({
+                path: args.path.startsWith('file:')
+                    ? fileURLToPath(args.path)
+                    : resolve(dirname(args.importer), args.path),
+                namespace: 'rook-goroutines',
+            }));
+            build.onLoad({ filter: /.*/, namespace: 'rook-goroutines' }, (args) => ({
+                contents: load(args.path.slice(0, -GOROUTINES.length), true, options),
+                loader: 'js',
+            }));
+            build.onLoad({ filter: /\.rk$/ }, (args) => ({
+                contents: load(args.path, false, options),
+                loader: 'js',
+            }));
+        },
+    };
+}
+/**
+ * The code of a module or of its worker module, from the cache of the run when it is there. The
+ * key has the time the file was changed, since `bun --hot` loads a changed module again.
+ */
+function load(path, worker, options) {
+    const url = `${pathToFileURL(path).href}#${statSync(path).mtimeMs}`;
+    const cache = runCache();
+    const file = cachedFile(cache, worker ? `${url}${GOROUTINES}` : url);
+    if (existsSync(file))
+        return readFileSync(file, 'utf8');
+    const result = compile(path, options);
+    const code = withMap(result.code.replaceAll(runtimeImport, runtime), result.map);
+    const workerCode = withMap((result.worker ?? '').replaceAll(runtimeImport, runtime), result.workerMap);
+    if (isMainThread) {
+        // The CSS modules it imports; the .rk modules are listed when they are loaded.
+        const read = result.dependencies.map((each) => resolve(dirname(path), each));
+        listFiles(cache, [path, ...read.filter((each) => existsSync(each))]);
+        writeFileSync(cachedFile(cache, url), code);
+        writeFileSync(cachedFile(cache, `${url}${GOROUTINES}`), workerCode);
+    }
+    return worker ? workerCode : code;
+}
+function compile(path, options) {
+    return compileFile(displayPath(path), {
+        rewriteImports: false,
+        typeCheck: options.typeCheck ?? process.env['ROOK_NO_CHECK'] === undefined,
+        markup: options.markup ?? markupSetting(),
+        quiet: !isMainThread,
+        workerUrl: `./${basename(path)}${GOROUTINES}`,
+        nodeLoader: register,
+    });
+}
+/** ROOK_MARKUP of `rook run`, 1 or 0, turns markup on or off for every file. */
+function markupSetting() {
+    const setting = process.env['ROOK_MARKUP'];
+    return setting === undefined ? undefined : setting === '1';
+}
+/** The directory of the run: that of `rook run`, or one of this process, which its workers share. */
+function runCache() {
+    const existing = process.env['ROOK_RUN_CACHE'];
+    if (existing !== undefined)
+        return existing;
+    const dir = mkdtempSync(join(tmpdir(), 'rook-bun-'));
+    process.env['ROOK_RUN_CACHE'] = dir;
+    process.on('exit', () => rmSync(dir, { recursive: true, force: true }));
+    return dir;
+}

package/dist/checker/assignments.d.ts

@@ -2,6 +2,8 @@ import type * as ast from '../ast.ts';
 import { InitializerChecker } from './initializers.ts';
 import { type Type } from './types.ts';
 export declare abstract class AssignmentChecker extends InitializerChecker {
+    /** The name of the `derived` whose block is being checked: it computes, so it changes no state. */
+    protected derivedBlock: string | null;
     /**
      * `a, b = f()` or `return f()`: the call must return exactly `count` values. Returns their
      * types.

package/dist/checker/assignments.js

@@ -1,3 +1,4 @@
+import { placeOf } from "./context.js";
 import { guardedByError, unpackedResults } from "./error-results.js";
 import { isUntyped, countValues, callName, isCall } from "./helpers.js";
 import { InitializerChecker } from "./initializers.js";
@@ -5,6 +6,8 @@ import { BOOL, ANY, isAssignable, isNullable, nonNull, nullable, typeToString, U
 // Where values go: assignments to variables, fields and elements, and `return`. Both unpack a call
 // that returns several values.
 export class AssignmentChecker extends InitializerChecker {
+    /** The name of the `derived` whose block is being checked: it computes, so it changes no state. */
+    derivedBlock = null;
     /**
      * `a, b = f()` or `return f()`: the call must return exactly `count` values. Returns their
      * types.
@@ -66,13 +69,13 @@ export class AssignmentChecker extends InitializerChecker {
             const binding = this.narrowableBinding(target);
             const declared = binding?.type;
             if (binding && declared && isNullable(declared) && !isNullable(valueTypes[i] ?? UNKNOWN)) {
-                this.flow.set(binding, nonNull(declared));
+                this.flow.set(placeOf(binding), nonNull(declared));
             }
         });
     }
     /** The type a value assigned to `target` must have. */
     checkTarget(target) {
-        if (this.checkDecoratorWrite(target))
+        if (this.checkDecoratorWrite(target) || this.checkSharedWrite(target))
             return UNKNOWN;
         switch (target.kind) {
             case 'Identifier': {
@@ -92,13 +95,16 @@ export class AssignmentChecker extends InitializerChecker {
                 else if (binding.kind === 'ref') {
                     this.error(`cannot assign to "${target.name}": a ref always points to its element`, target);
                 }
+                else if (binding.kind === 'state' && this.derivedBlock !== null) {
+                    this.error(`derived "${this.derivedBlock}" cannot change the state "${target.name}": change it in an event handler or an effect`, target);
+                }
                 else if (binding.kind === 'loop') {
                     this.error(`cannot assign to loop variable "${target.name}"`, target);
                 }
                 else if (binding.kind === 'prop') {
                     this.error(this.decorator
                         ? `cannot assign to "${target.name}": parameters of a decorator are read-only`
-                        : `cannot assign to "${target.name}": component properties are read-only; to change the parent's state, pass a function`, target);
+                        : `cannot assign to "${target.name}": component properties are read-only; to change it, declare it with bind, e.g. comp ${this.component?.node.name.name ?? 'Tabs'}(bind ${target.name} ...)`, target);
                 }
                 else if (binding.kind !== 'let' &&
                     binding.kind !== 'state' &&

package/dist/checker/base.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
 import type { Diagnostic } from '../diagnostics.ts';
-import { type CheckOptions, type BindingKind, type Binding, type ComponentInfo, type DecoratorInfo, type AliasEntry, Scope, type FunctionContext, type ClassContext, type Flow } from './context.ts';
+import { type CheckOptions, type BindingKind, type Binding, type ComponentInfo, type DecoratorInfo, type AliasEntry, Scope, type FunctionContext, type ClassContext, type Flow, type Place } from './context.ts';
 import { type ClassInfo, type FunctionType, type Member, type Type, type TypeParam } from './types.ts';
 export declare abstract class CheckerBase {
     protected abstract checkClassBodies(node: ast.ClassDeclaration, info: ClassInfo): void;
@@ -18,6 +18,13 @@ export declare abstract class CheckerBase {
     protected abstract checkTry(node: ast.TryStatement): void;
     protected abstract forget(target: ast.Expression): void;
     protected abstract narrowableBinding(node: ast.Expression): Binding | undefined;
+    /** A variable or a path of data fields that conditions narrow, with its type at this point. */
+    protected abstract narrowable(node: ast.Expression): {
+        place: Place;
+        type: Type;
+    } | undefined;
+    /** Whether an assignment to `field` of `place` may change the member of a union it is. */
+    protected abstract isTagOf(place: Place, field: string): boolean;
     /** The error for a value that may be null where it must not be. */
     protected abstract nullError(node: ast.Expression): void;
     protected abstract checkFunction(params: readonly ast.Parameter[], type: FunctionType, results: Type[] | null, body: ast.BlockStatement | ast.Expression, options?: {
@@ -44,7 +51,6 @@ export declare abstract class CheckerBase {
     protected abstract orderByNeeds(decorators: readonly DecoratorInfo[]): DecoratorInfo[];
     protected abstract wrappedType(info: ComponentInfo, own: Type, seen: Set<ComponentInfo>): Type;
     protected abstract checkDecoratorMember(node: ast.DecoratorMember): Type;
-    protected abstract checkDecoratorGet(node: ast.DecoratorGet): Type;
     protected abstract checkDecoratorWrite(target: ast.Expression): boolean;
     protected abstract checkComponentUse(node: ast.ElementExpression, tag: ast.Identifier): Type;
     protected abstract checkRefDeclaration(node: ast.VariableDeclaration): void;

package/dist/checker/base.js

@@ -4,9 +4,9 @@ import { Scope, globalScope, } from "./context.js";
 import { DOCUMENT_FRAGMENT, eventType, HTML_ELEMENT, NODE } from "./dom.js";
 import { explainMismatch, isAssignable, LazyMap, memberNames, nonNull, property, typeToString, UNKNOWN, } from "./types.js";
 // The type checker is a chain of layers, one per area, like the code generator: base → imports →
-// declarations → class members → classes → resolution → initializers → assignments → statements → control flow →
-// functions → expressions → array literals → operators → markup → forwarding → components → component values →
-// refs → styles → decorator wrappers → decorator exports → decorators → decorator members →
+// shared state → declarations → class members → classes → resolution → initializers → assignments → statements → control flow →
+// tagged unions → functions → expressions → array literals → operators → markup → forwarding → component bindings → components → component values →
+// refs → styles → decorator wrappers → decorator exports → decorators → decorator includes → decorator members →
 // members → calls → goroutines → channels → signals → queues → topics → decode → try → bytes → loops → go for →
 // iterators → closing → completion → Checker (checker.ts). Statements, expressions and markup
 // check each other recursively, so methods of later layers that earlier ones call are declared

package/dist/checker/builtins.js

@@ -6,7 +6,7 @@ import { chanOf } from "./channel.js";
 import { CHANNEL_OBJECT, TOPIC_OBJECT } from "./channel-objects.js";
 import { PROMISE } from "./promise.js";
 import { BUFFERS } from "./transfer.js";
-import { UNTYPED_GLOBALS } from "./untyped-globals.js";
+import { UNTYPED_CLASSES, UNTYPED_GLOBALS } from "./untyped-globals.js";
 import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NUMBER, nullable, property, STRING, topicOf, union, } from "./types.js";
 // Types of the JS standard library that Rook programs use most. Anything not listed here
 // can still be reached through the untyped globals below.
@@ -249,7 +249,10 @@ export const GLOBAL_VALUES = new Map([
     ['cancel', func([ANY], [])],
     ['Channel', CHANNEL_OBJECT],
     ['Topic', TOPIC_OBJECT],
-    ...[...UNTYPED_GLOBALS, ...BUFFERS].map((name) => [name, ANY]),
+    ...[...UNTYPED_GLOBALS, ...UNTYPED_CLASSES, ...BUFFERS].map((name) => [
+        name,
+        ANY,
+    ]),
 ]);
 /** Built-in types that a library from TypeScript's lib files replaces: untyped ones and the DOM. */
 export const LIBRARY_TYPES = new Set([
@@ -260,6 +263,7 @@ export const LIBRARY_TYPES = new Set([
     'Promise',
     'URL',
     'Event',
+    ...UNTYPED_CLASSES,
     ...BUFFERS,
     ...[...DOM_TYPES.keys()].filter((name) => name !== 'Content'),
     ...SVG_TYPES.keys(),
@@ -278,7 +282,7 @@ export const GLOBAL_TYPES = new Map([
     ['any', ANY],
     ['error', ERROR],
     ['Error', ERROR_CLASS.instance],
-    ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...BUFFERS].map((name) => [name, ANY]),
+    ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...UNTYPED_CLASSES, ...BUFFERS].map((name) => [name, ANY]),
     ['Promise', PROMISE],
     ...DOM_TYPES,
     ...SVG_TYPES,

package/dist/checker/channels.js

@@ -1,4 +1,3 @@
-import { assignedNames } from "../names.js";
 import { cannotWait } from "../parser/syntax.js";
 import { chanDirection, chanOf, elementOf, isChan } from "./channel.js";
 import { GoroutineChecker } from "./goroutines.js";
@@ -115,7 +114,7 @@ export class ChannelChecker extends GoroutineChecker {
             : ANY;
     }
     checkSelect(node) {
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         for (const { names, operation, body } of node.cases) {
             this.flow = new Map(entry);

package/dist/checker/classes.js

@@ -195,6 +195,7 @@ export class ClassChecker extends ClassMemberChecker {
             types: new Map(),
             decorators: new Map(),
             components: new Map(),
+            shared: new Set(),
         };
         const declarations = { values: new Map(), types: new Map() };
         const valueOf = (name) => this.moduleScope.values.get(name)?.type ?? UNKNOWN;
@@ -217,6 +218,8 @@ export class ClassChecker extends ClassMemberChecker {
                 case 'VariableDeclaration':
                     for (const name of statement.names) {
                         add(statement.exported, 'values', name.name, valueOf(name.name));
+                        if (statement.exported && statement.keyword === 'state')
+                            exports.shared.add(name.name);
                     }
                     break;
                 case 'ClassDeclaration':
@@ -230,7 +233,10 @@ export class ClassChecker extends ClassMemberChecker {
                 case 'ComponentDeclaration': {
                     const info = this.moduleScope.values.get(statement.name.name)?.component;
                     if (statement.exported && info?.node === statement) {
-                        info.inline = this.modulePackages().components.get(info.node.name.name) ?? null;
+                        const found = this.modulePackages().components.get(info.node.name.name) ?? null;
+                        // Code that reads state another module shares listens to it here, so it stays here.
+                        const shared = found?.moduleNames.some((name) => this.moduleScope.values.get(name)?.shared !== undefined);
+                        info.inline = shared ? null : found;
                         info.expressionTypes = this.checkedTypes;
                         exports.components.set(statement.name.name, info);
                     }

package/dist/checker/closing.js

@@ -4,7 +4,7 @@ import { IteratorChecker } from "./iterators.js";
 const OPERATIONS = new Set(['send', 'receive', 'range', 'stream', 'publish', 'listen', 'try']);
 const MESSAGES = {
     chan: (name) => `"${name}" is never closed: close it when nothing more is sent, e.g. close(${name})`,
-    topic: (name) => `"${name}" is never closed, and a topic listens until it is closed: close it when it is no longer needed, e.g. close(${name}), in a component in the function that mount() returns`,
+    topic: (name) => `"${name}" is never closed, and a topic listens until it is closed: close it when it is no longer needed, e.g. close(${name}); a component closes it with defer close(${name}) in mount`,
     tick: (name) => `"${name}" is never closed, and a tick runs until it is closed: e.g. close(${name})`,
     signal: (name) => `"${name}" is never closed, and it keeps the program running until it is: close it once the signal has come, e.g. close(${name})`,
 };

package/dist/checker/completion.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
 import { ClosingChecker } from './closing.ts';
-import type { CompletionResult } from './context.ts';
+import { type CompletionResult } from './context.ts';
 import { type Type } from './types.ts';
 export declare abstract class CompletionChecker extends ClosingChecker {
     protected completion: CompletionResult | null;

package/dist/checker/completion.js

@@ -1,5 +1,6 @@
 import { ClosingChecker } from "./closing.js";
 import { ARRAY_MEMBERS, ATTRIBUTE_NAMES, BIGINT_MEMBERS, BOOL_MEMBERS, EVENT_ATTRIBUTES, HTML_TAGS, NUMBER_MEMBERS, STRING_MEMBERS, } from "./completion-names.js";
+import { placeOf, } from "./context.js";
 import { isSubclass, literalBase, memberNames, memberTypeOf, nonNull, typeToString, union, UNKNOWN, } from "./types.js";
 // Completion in editors (src/completion.ts): the editor writes the name `options.completion` where
 // the cursor is, and this layer lists what can be written there when the check reaches that name:
@@ -79,7 +80,7 @@ export class CompletionChecker extends ClosingChecker {
         if (component) {
             return { name, kind: 'component', detail: typeToString(this.componentValue(component)) };
         }
-        const type = binding.type && (this.flow.get(binding) ?? binding.type);
+        const type = binding.type && (this.flow.get(placeOf(binding)) ?? binding.type);
         const detail = type ? { detail: typeToString(type) } : {};
         if (kind === 'function' || type?.kind === 'function')
             return { name, kind: 'function', ...detail };

package/dist/checker/component-bindings.d.ts

@@ -0,0 +1,7 @@
+import type * as ast from '../ast.ts';
+import type { ComponentInfo } from './context.ts';
+import { ForwardingChecker } from './forwarding.ts';
+export declare abstract class ComponentBindingChecker extends ForwardingChecker {
+    /** `bind:active={tab}` on a component; adds the name of the property to `given`. */
+    protected checkPropBinding(attribute: ast.JsxAttribute, info: ComponentInfo, component: string, given: Set<string>): void;
+}

package/dist/checker/component-bindings.js

@@ -0,0 +1,45 @@
+import { attrsParam } from "../attrs.js";
+import { ForwardingChecker } from "./forwarding.js";
+import { isUntyped } from "./helpers.js";
+import { isAssignable, typeToString } from "./types.js";
+// Bound properties: `comp Tabs(bind active string)` may change `active`, and
+// `<Tabs bind:active={tab} />` writes those changes into the parent's `tab`, as `bind:value` of an
+// input does. The value goes both ways, so the variable and the property have the same type.
+export class ComponentBindingChecker extends ForwardingChecker {
+    /** `bind:active={tab}` on a component; adds the name of the property to `given`. */
+    checkPropBinding(attribute, info, component, given) {
+        const name = attribute.name.name.slice('bind:'.length);
+        const prop = info.props.get(name);
+        const { value } = attribute;
+        if (given.has(name))
+            this.error(`duplicate property "${name}"`, attribute.name);
+        given.add(name);
+        if (!prop) {
+            this.error(attrsParam(info.node)
+                ? `${attribute.name.name} does not go through the attributes of <${component}>`
+                : `<${component}> has no property "${name}" to bind`, attribute.name);
+        }
+        else if (!prop.bind) {
+            this.error(`"${name}" of <${component}> is not bound: the component declares it with bind to change it, e.g. comp ${component}(bind ${name} ...)`, attribute.name);
+        }
+        if (value === null || value.kind === 'StringLiteral' || value.kind === 'EventHandler') {
+            this.error(`"bind:${name}" needs a variable in braces, e.g. bind:${name}={${name}}`, attribute);
+            return;
+        }
+        const bindable = (value.kind === 'Identifier' && value.name !== '_') ||
+            ((value.kind === 'MemberExpression' || value.kind === 'IndexExpression') && !value.optional);
+        if (!bindable) {
+            this.checkValue(value);
+            this.error(`"bind:${name}" needs a variable or a field to write to`, value);
+            return;
+        }
+        const type = this.checkTarget(value);
+        this.checkedTypes.set(value, type);
+        if (!prop?.bind || isUntyped(type) || isUntyped(prop.type))
+            return;
+        // The parent gives its value, and the component writes its own back.
+        if (!isAssignable(type, prop.type) || !isAssignable(prop.type, type)) {
+            this.error(`cannot bind ${typeToString(type)} to "${name}" of <${component}>, which is ${typeToString(prop.type)}`, value);
+        }
+    }
+}