rooklang 0.3.3 → 0.3.4

package/dist/codegen/control-statements.js

@@ -1,8 +1,8 @@
 import { isChan } from "../checker/channel.js";
-import { isMap } from "../checker/iterables.js";
-import { typedArrayOf } from "../checker/types.js";
+import { asyncIterated, isMap } from "../checker/iterables.js";
+import { isTopic, typedArrayOf } from "../checker/types.js";
 import { declaredIn } from "../names.js";
-import { containsBreak } from "../walk.js";
+import { containsBreak } from "../breaks.js";
 import { declarationsOf, endsWithJump } from "./analysis.js";
 import { SimpleStatementEmitter } from "./simple-statements.js";
 import { ARROW, BINARY, POSTFIX } from "./syntax.js";
@@ -11,6 +11,9 @@ import { ARROW, BINARY, POSTFIX } from "./syntax.js";
 const FIXED = new Set(['const', 'import', 'loop']);
 export class ControlStatementEmitter extends SimpleStatementEmitter {
     ifStatement(node) {
+        const { init } = node;
+        if (init)
+            return this.withInit(init, () => this.line(this.ifStatement({ ...node, init: null })));
         let text = `if (${this.expression(node.condition, 0)}) ${this.blockStatement(node.consequent)}`;
         if (node.alternate?.kind === 'IfStatement') {
             // The condition of `else if` is evaluated only when the first one is false.
@@ -22,6 +25,20 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
         }
         return text;
     }
+    /**
+     * `if const v = f(); v > 0 { }` → `{ const v = f(); if (v > 0) { } }`: a block keeps the
+     * variables of the initializer to the statement, which `emit` writes.
+     */
+    withInit(init, emit) {
+        return this.block(() => this.withScope(declarationsOf([init]), () => {
+            this.statement(init);
+            this.withHoisting(true, emit);
+        }));
+    }
+    /** `outer: for (...)`: the label goes on the loop itself, after what is hoisted before it. */
+    labeled(node, text) {
+        return node.label ? `${this.label(node.label)}: ${text}` : text;
+    }
     loopBody(body) {
         return this.withBreakTarget(null, () => this.blockStatement(body));
     }
@@ -37,10 +54,10 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 node.update ? this.simpleStatement(node.update) : '',
             ]);
             if (node.init === null && node.update === null) {
-                this.line(`while (${condition || 'true'}) ${this.loopBody(node.body)}`);
+                this.line(this.labeled(node, `while (${condition || 'true'}) ${this.loopBody(node.body)}`));
                 return;
             }
-            this.line(`for (${init}; ${condition}; ${update}) ${this.loopBody(node.body)}`);
+            this.line(this.labeled(node, `for (${init}; ${condition}; ${update}) ${this.loopBody(node.body)}`));
         });
     }
     /** A statement inside a `for` header, without the `;`. */
@@ -57,7 +74,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             case 'ExpressionStatement':
                 return this.expression(node.expression, 0);
             case 'SendStatement':
-                return `await $$send(${this.expression(node.channel, ARROW)}, ${this.expression(node.value, ARROW)})`;
+                return this.send(node);
         }
     }
     /**
@@ -72,9 +89,14 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             const value = this.name(node.value.name);
             const iterable = this.options.types?.get(node.iterable);
             let head;
-            // A channel gives its values as they come, until it is closed.
-            if (iterable && isChan(iterable)) {
-                this.line(`for await (const ${value} of $$range(${this.expression(node.iterable, ARROW)})) ${this.loopBody(node.body)}`);
+            // An async iterable, such as a stream of Node, gives its values as their Promises do.
+            if (iterable && asyncIterated(iterable) !== null) {
+                this.line(this.labeled(node, `for await (const ${value} of ${this.expression(node.iterable, POSTFIX)}) ${this.loopBody(node.body)}`));
+                return;
+            }
+            // A channel gives its values as they come, until it is closed, and so does a topic.
+            if (iterable && (isChan(iterable) || isTopic(iterable))) {
+                this.line(this.labeled(node, `for await (const ${value} of $$Channel.range(${this.receivedFrom(node.iterable)})) ${this.loopBody(node.body)}`));
                 return;
             }
             // An iterator is a generator function: called, it gives a lazy JS iterator, of pairs if its
@@ -117,7 +139,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             else {
                 head = `const ${this.pair(node.key, node.value)} of ${this.expression(node.iterable, POSTFIX)}.entries()`;
             }
-            this.line(`for (${head}) ${this.loopBody(node.body)}`);
+            this.line(this.labeled(node, `for (${head}) ${this.loopBody(node.body)}`));
         });
     }
     /** `[i, v]` of a loop over pairs; `_` leaves its place empty. */
@@ -148,10 +170,20 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             else
                 this.blockStatements(node.body.body);
         }));
-        this.line(`for (let ${key} = 0${init}; ${key} < ${items}.length; ${key}++) ${body}`);
+        this.line(this.labeled(node, `for (let ${key} = 0${init}; ${key} < ${items}.length; ${key}++) ${body}`));
+    }
+    switchStatement(node) {
+        const { init, discriminant } = node;
+        if (init) {
+            this.line(this.withInit(init, () => this.switchStatement({ ...node, init: null })));
+        }
+        else if (discriminant === null)
+            this.taglessSwitch(node);
+        else
+            this.valueSwitch(node, discriminant);
     }
     /** Each `case` ends with an implicit `break`; a case with declarations gets its own block. */
-    switchStatement(node, discriminant) {
+    valueSwitch(node, discriminant) {
         const head = `switch (${this.expression(discriminant, 0)})`;
         const body = this.withBreakTarget(null, () => this.block(() => {
             node.cases.forEach((switchCase, i) => {
@@ -178,7 +210,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 }
             });
         }));
-        this.line(`${head} ${body}`);
+        this.line(this.labeled(node, `${head} ${body}`));
     }
     /**
      * `select`: $$select gives the index of the case that went on and what it received, and a
@@ -189,7 +221,10 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             if (operation === null)
                 return [];
             if (operation.kind === 'UnaryExpression') {
-                return [`{ channel: ${this.expression(operation.argument, ARROW)} }`];
+                const zero = this.receivedZero(operation.argument);
+                return [
+                    `{ channel: ${this.receivedFrom(operation.argument)}${zero !== 'null' ? `, zero: ${zero}` : ''} }`,
+                ];
             }
             const channel = this.expression(operation.channel, ARROW);
             return [`{ channel: ${channel}, value: ${this.expression(operation.value, ARROW)} }`];
@@ -197,7 +232,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
         const hasDefault = node.cases.some((selectCase) => selectCase.operation === null);
         let index = 0;
         const select = this.block(() => {
-            this.line(`const [$$case, $$received, $$ok] = await $$select([${operations.join(', ')}], ${hasDefault});`);
+            this.line(`const [$$case, $$received, $$ok] = await $$Channel.select([${operations.join(', ')}], ${hasDefault});`);
             const body = this.withBreakTarget(null, () => this.block(() => {
                 for (const { names, operation, body: statements } of node.cases) {
                     const label = operation === null ? 'default:' : `case ${index++}:`;
@@ -223,7 +258,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             }));
             this.line(`switch ($$case) ${body}`);
         });
-        this.line(select);
+        this.line(this.labeled(node, select));
     }
     /**
      * `switch { case cond: ... }` becomes an if/else chain. A `break` inside it must leave the
@@ -232,9 +267,11 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
     taglessSwitch(node) {
         const cases = node.cases.filter((switchCase) => switchCase.tests.length > 0);
         const fallback = node.cases.find((switchCase) => switchCase.tests.length === 0);
-        const label = node.cases.some((switchCase) => containsBreak(switchCase.body))
-            ? `$$switch${++this.labels}`
-            : null;
+        const label = node.label
+            ? this.label(node.label)
+            : node.cases.some((switchCase) => containsBreak(switchCase.body))
+                ? `$$switch${++this.labels}`
+                : null;
         const text = this.withBreakTarget(label, () => {
             const caseBlock = (body) => this.block(() => this.blockStatements(body));
             const branches = cases.map((switchCase) => {

package/dist/codegen/decode.d.ts

@@ -0,0 +1,14 @@
+import type * as ast from '../ast.ts';
+import { CallEmitter } from './calls.ts';
+export declare abstract class DecodeEmitter extends CallEmitter {
+    /** The constants of the object types that decode checks against, by type, in order. */
+    private readonly decodeTypes;
+    /** `$$decodeJson(text, type)` for a string, `$$decode(value, type)` for a value from JS. */
+    protected decode(node: ast.DecodeExpression): string;
+    /** The constants of the object types, for the start of the module. */
+    protected decodeTypeLines(): string[];
+    /** A type as runtime/decode.js has it: `"string"`, `{ array: "number" }`, `$$typeUser`. */
+    private shape;
+    /** The constant of an object type, made the first time it is used. */
+    private objectType;
+}

package/dist/codegen/decode.js

@@ -0,0 +1,93 @@
+import { isText } from "../checker/json.js";
+import { memberNames, typeToString } from "../checker/types.js";
+import { CallEmitter } from "./calls.js";
+import { ARROW } from "./syntax.js";
+// `decode<User>(body)`: the type, which the checker found, becomes data that the runtime checks the
+// value against (runtime/decode.js). An object type is a constant of the module, `$$typeUser`,
+// written before its code (js.ts), so that types that refer to themselves or each other can do so,
+// and the value of each call is only its name: `$$decodeJson(body, $$typeUser)`.
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+export class DecodeEmitter extends CallEmitter {
+    /** The constants of the object types that decode checks against, by type, in order. */
+    decodeTypes = new Map();
+    /** `$$decodeJson(text, type)` for a string, `$$decode(value, type)` for a value from JS. */
+    decode(node) {
+        const argument = this.expression(node.argument, ARROW);
+        const result = this.options.types?.get(node);
+        const type = result?.kind === 'tuple' ? result.types[0] : undefined;
+        // Without the types of the checker nothing is checked (runtime/decode.js).
+        if (type === undefined)
+            return `$$decode(${argument}, null)`;
+        const given = this.options.types?.get(node.argument);
+        const decode = given !== undefined && isText(given) ? '$$decodeJson' : '$$decode';
+        return `${decode}(${argument}, ${this.shape(type)})`;
+    }
+    /** The constants of the object types, for the start of the module. */
+    decodeTypeLines() {
+        return [...this.decodeTypes.values()].flatMap(({ lines }) => lines);
+    }
+    /** A type as runtime/decode.js has it: `"string"`, `{ array: "number" }`, `$$typeUser`. */
+    shape(type) {
+        switch (type.kind) {
+            case 'number':
+            case 'string':
+            case 'bool':
+            case 'any':
+                return `"${type.kind}"`;
+            case 'null':
+                return '{ literal: [null] }';
+            case 'literal':
+                return `{ literal: [${JSON.stringify(type.value)}] }`;
+            case 'nullable':
+                return `{ nullable: ${this.shape(type.type)} }`;
+            case 'array':
+                return `{ array: ${this.shape(type.element)} }`;
+            case 'union': {
+                // The literals of a union are one list, as `"admin" | "user"` reads.
+                const literals = type.types.flatMap((each) => each.kind === 'literal' ? [each.value] : []);
+                const others = type.types.filter((each) => each.kind !== 'literal');
+                const shapes = [
+                    ...(literals.length > 0 ? [`{ literal: [${literals.map(json).join(', ')}] }`] : []),
+                    ...others.map((each) => this.shape(each)),
+                ];
+                return shapes.length === 1 ? shapes[0] : `{ union: [${shapes.join(', ')}] }`;
+            }
+            case 'object':
+                return type.index && [...memberNames(type.members)].length === 0
+                    ? `{ record: ${this.shape(type.index)} }`
+                    : this.objectType(type);
+            // The checker lets no other type through.
+            default:
+                return '"any"';
+        }
+    }
+    /** The constant of an object type, made the first time it is used. */
+    objectType(type) {
+        const known = this.decodeTypes.get(type);
+        if (known)
+            return known.name;
+        // `$$type` itself is the function of the runtime that makes them.
+        const written = type.instanceOf?.template.name ?? type.name ?? 'Object';
+        const base = `$$type${written.replace(/[^\w$]/g, '')}`;
+        const taken = new Set([...this.decodeTypes.values()].map(({ name }) => name));
+        let name = base;
+        for (let i = 2; taken.has(name); i++)
+            name = `${base}${i}`;
+        const entry = { name, lines: [] };
+        // Registered before its fields, which may refer to it.
+        this.decodeTypes.set(type, entry);
+        const fields = [...memberNames(type.members)].flatMap((field) => {
+            const member = type.members.get(field);
+            const key = IDENTIFIER.test(field) ? field : json(field);
+            return member ? [`  ${key}: ${this.shape(member.type)},`] : [];
+        });
+        entry.lines =
+            fields.length === 0
+                ? [`const ${name} = $$type(${json(typeToString(type))}, () => ({}));`]
+                : [`const ${name} = $$type(${json(typeToString(type))}, () => ({`, ...fields, '}));'];
+        return name;
+    }
+}
+function json(value) {
+    return JSON.stringify(value);
+}

package/dist/codegen/emitter.d.ts

@@ -1,42 +1,8 @@
 import type * as ast from '../ast.ts';
-import type { Type } from '../checker/types.ts';
-import { type DecoratorSource } from '../decorators.ts';
-import type { InlinePackage } from '../inline-packages.ts';
-import { type ImportedComponent, type LocalizedPackage } from './imported.ts';
+import { type LocalizedPackage } from './imported.ts';
 import type { Root } from '../refs.ts';
-import type { StyleModule } from '../style-modules.ts';
 import type { BindingKind } from './analysis.ts';
-import type { RuntimeMode } from './runtime.ts';
-export interface JsOptions {
-    /** The Rook source, used to keep the blank lines between statements. */
-    source: string;
-    /** Replace `.rk` with `.js` in relative import paths, for output written next to the sources. */
-    rewriteImports: boolean;
-    /** Types from the checker, when it ran; without them the generated code is more general. */
-    types?: WeakMap<ast.Expression, Type> | undefined;
-    /** Decorators imported from other modules, by name: their code is inlined here. */
-    decorators?: ReadonlyMap<string, ImportedDecorator> | undefined;
-    /** Components imported from other modules, by name: called, or inlined when they are small. */
-    components?: ReadonlyMap<string, ImportedComponent> | undefined;
-    /** Components of the module that become functions, since inlining them adds too many lines. */
-    functions?: ReadonlySet<string> | undefined;
-    /** The CSS modules the module imports, by their paths as written. */
-    styleModules?: ReadonlyMap<string, StyleModule> | undefined;
-    /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
-    goroutines?: {
-        workerUrl: string;
-    } | {
-        targets: readonly string[];
-    } | undefined;
-    /** How the module gets the runtime it uses: imported, by default, or in it (runtime.ts). */
-    runtime?: RuntimeMode | undefined;
-}
-/** A decorator of another module, with the types of the expressions of that module. */
-export interface ImportedDecorator extends DecoratorSource {
-    types: WeakMap<ast.Expression, Type> | null;
-    /** The components of that module its code uses, which go with it into the components here. */
-    inline: InlinePackage | null;
-}
+import type { JsOptions } from './options.ts';
 /** How a function implements its `defer` statements. */
 export type DeferMode = 'none' | 'try' | 'stack' | 'effect';
 interface FunctionContext {
@@ -54,10 +20,11 @@ interface FunctionContext {
  * The base of the JS generator: the output buffer, scopes of declared names and the state of the
  * current function. The generator is split into layers, each adding to the previous one:
  *
- *     Emitter → ExpressionEmitter → CallEmitter → SimpleStatementEmitter → ControlStatementEmitter
- *       → ParallelLoopEmitter → StatementEmitter → UpdateEmitter → AttributeEmitter
- *       → CreationEmitter → ElementEmitter → ControlFlowEmitter → ComponentPropsEmitter
- *       → ComponentValueEmitter → EarlyReturnEmitter → RefEmitter
+ *     Emitter → ExpressionEmitter → CallEmitter → DecodeEmitter → TryEmitter
+ *       → SimpleStatementEmitter → ControlStatementEmitter → ParallelLoopEmitter
+ *       → StatementEmitter → UpdateEmitter → AttributeEmitter → CreationEmitter → ElementEmitter
+ *       → ControlFlowEmitter → ComponentPropsEmitter → ComponentValueEmitter
+ *       → EarlyReturnEmitter → RefEmitter
  *       → StyleEmitter → ComponentEmitter → WebComponentEmitter → FunctionEmitter → JsGenerator
  */
 export declare abstract class Emitter {
@@ -100,7 +67,7 @@ export declare abstract class Emitter {
     /** The decorators that components of the module apply, by name. */
     protected readonly appliedDecorators: Set<string>;
     /** Copies of the code of other modules: their positions are in the sources of those. */
-    private readonly foreign;
+    protected readonly foreign: WeakSet<ast.Node>;
     /** Components of other modules inlined here, by name, with what their packages bring. */
     protected readonly inlinedImports: Map<string, LocalizedPackage>;
     /** The components that decorators of other modules bring, by the names of the decorators. */
@@ -123,6 +90,8 @@ export declare abstract class Emitter {
     protected lookup(name: string): BindingKind | undefined;
     /** The JS name for a Rook name. */
     protected name(name: string): string;
+    /** Labels are names of their own in JS, which cannot be reserved words either. */
+    protected label(name: ast.Identifier): string;
     protected params(params: ast.Parameter[]): string;
     protected withFunction<T>(mode: DeferMode, params: ast.Parameter[], emit: () => T): T;
     protected withHoisting<T>(hoist: boolean, emit: () => T): T;

package/dist/codegen/emitter.js

@@ -9,10 +9,11 @@ import { JS_RESERVED, JS_UNDECLARABLE } from "./syntax.js";
  * The base of the JS generator: the output buffer, scopes of declared names and the state of the
  * current function. The generator is split into layers, each adding to the previous one:
  *
- *     Emitter → ExpressionEmitter → CallEmitter → SimpleStatementEmitter → ControlStatementEmitter
- *       → ParallelLoopEmitter → StatementEmitter → UpdateEmitter → AttributeEmitter
- *       → CreationEmitter → ElementEmitter → ControlFlowEmitter → ComponentPropsEmitter
- *       → ComponentValueEmitter → EarlyReturnEmitter → RefEmitter
+ *     Emitter → ExpressionEmitter → CallEmitter → DecodeEmitter → TryEmitter
+ *       → SimpleStatementEmitter → ControlStatementEmitter → ParallelLoopEmitter
+ *       → StatementEmitter → UpdateEmitter → AttributeEmitter → CreationEmitter → ElementEmitter
+ *       → ControlFlowEmitter → ComponentPropsEmitter → ComponentValueEmitter
+ *       → EarlyReturnEmitter → RefEmitter
  *       → StyleEmitter → ComponentEmitter → WebComponentEmitter → FunctionEmitter → JsGenerator
  */
 export class Emitter {
@@ -250,6 +251,10 @@ export class Emitter {
         const rename = JS_RESERVED.has(name) || (JS_UNDECLARABLE.has(name) && this.lookup(name) !== undefined);
         return rename ? `${name}$` : name;
     }
+    /** Labels are names of their own in JS, which cannot be reserved words either. */
+    label(name) {
+        return JS_RESERVED.has(name.name) ? `${name.name}$` : name.name;
+    }
     params(params) {
         // Several `_` parameters would be duplicate names in JS.
         const blanks = params.filter((param) => param.name.name === '_').length;

package/dist/codegen/expressions.d.ts

@@ -21,6 +21,15 @@ export declare abstract class ExpressionEmitter extends Emitter {
     protected abstract chan(node: ast.ChanExpression): string;
     protected abstract streamChan(node: ast.StreamChanExpression): string;
     protected abstract queue(node: ast.QueueExpression): string;
+    protected abstract topic(node: ast.TopicExpression): string;
+    /** `go f(x)`; implemented by CallEmitter. */
+    protected abstract go(node: ast.GoExpression): string;
+    /** `decode<T>(x)`; implemented by DecodeEmitter. */
+    protected abstract decode(node: ast.DecodeExpression): string;
+    /** `try x`, with the precedence of its code; implemented by TryEmitter. */
+    protected abstract tryValue(node: ast.TryExpression): [string, number];
+    /** `<-x` without its `await`; implemented by CallEmitter. */
+    protected abstract receive(node: ast.Expression, withOk: boolean): string;
     /** `<-ch` that gives `[value, ok]`, in `v, ok = <-ch`. */
     protected readonly commaOk: WeakSet<ast.Expression>;
     /** `items[i]` in a part of `go for`, which is `items[$$i]` there (parallel.ts). */

package/dist/codegen/expressions.js

@@ -1,5 +1,4 @@
 import { decoratedName } from "../decorators.js";
-import { goCaptures, goParams, goTarget } from "../goroutines.js";
 import { isIterator, usesThis } from "../iterators.js";
 import { containsElement, startsWithObjectLiteral } from "./analysis.js";
 import { Emitter } from "./emitter.js";
@@ -59,8 +58,9 @@ export class ExpressionEmitter extends Emitter {
                     return [this.functionNames.get(component) ?? `$$${component.name.name}`, PRIMARY];
                 }
                 // `close(ch)` and the like are predeclared; JS has a `close` of its own, the window's.
-                if (PREDECLARED.has(node.name) && this.lookup(node.name) === undefined) {
-                    return [`$$${node.name}`, PRIMARY];
+                const predeclared = PREDECLARED.get(node.name);
+                if (predeclared !== undefined && this.lookup(node.name) === undefined) {
+                    return [predeclared, PRIMARY];
                 }
                 // The predeclared `error` used as a value is JS's `Error`, which also works without `new`.
                 return [this.isBuiltinError(node) ? 'Error' : this.name(node.name), PRIMARY];
@@ -69,6 +69,8 @@ export class ExpressionEmitter extends Emitter {
             case 'BigIntLiteral':
             case 'StringLiteral':
                 return [node.raw, PRIMARY];
+            case 'RegExpLiteral':
+                return [`/${node.pattern}/${node.flags}`, PRIMARY];
             case 'TemplateLiteral':
                 return [this.template(node), PRIMARY];
             case 'BooleanLiteral':
@@ -112,23 +114,14 @@ export class ExpressionEmitter extends Emitter {
                 return [this.streamChan(node), POSTFIX];
             case 'QueueExpression':
                 return [this.queue(node), POSTFIX];
-            // The worker module has the function under the same name, a literal under the name given to
-            // it, after the local names it uses; the arguments are copied there. In the worker module a
-            // literal runs in the same worker, with copies of those names as its first parameters.
-            case 'GoExpression': {
-                const { callee } = node.call;
-                const literal = callee.kind === 'FuncExpression' ? callee : null;
-                const captured = literal ? goCaptures(this.program, node) : [];
-                const args = [
-                    ...captured.map((name) => this.name(name)),
-                    this.elements(node.call.arguments),
-                ];
-                // Without type checking, a callee that is neither fails when the call runs.
-                const fn = literal && this.inWorker
-                    ? this.expression({ ...literal, params: [...goParams(literal, captured), ...literal.params] }, ARROW)
-                    : JSON.stringify(goTarget(this.program, node));
-                return [`$$go(${fn}, [${args.filter((arg) => arg !== '').join(', ')}])`, POSTFIX];
-            }
+            case 'TopicExpression':
+                return [this.topic(node), POSTFIX];
+            case 'GoExpression':
+                return [this.go(node), POSTFIX];
+            case 'DecodeExpression':
+                return [this.decode(node), POSTFIX];
+            case 'TryExpression':
+                return this.tryValue(node);
             case 'UnaryExpression':
                 return [this.unary(node), UNARY];
             case 'BinaryExpression':
@@ -221,10 +214,8 @@ export class ExpressionEmitter extends Emitter {
         });
     }
     unary(node) {
-        if (node.operator === '<-') {
-            const channel = this.expression(node.argument, ARROW);
-            return `await $$receive(${channel}${this.commaOk.has(node) ? ', true' : ''})`;
-        }
+        if (node.operator === '<-')
+            return `await ${this.receive(node.argument, this.commaOk.has(node))}`;
         const argument = this.expression(node.argument, UNARY);
         if (node.operator === 'typeof' || node.operator === 'await') {
             return `${node.operator} ${argument}`;

package/dist/codegen/js.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import type { JsOptions } from './emitter.ts';
-export type { JsOptions } from './emitter.ts';
+import type { JsOptions } from './options.ts';
+export type { JsOptions } from './options.ts';
 /** A component whose inlined copies add more lines than this to its module becomes a function. */
 export declare const INLINE_LIMIT = 100;
 /**

package/dist/codegen/js.js

@@ -62,12 +62,14 @@ class JsGenerator extends FunctionEmitter {
         // What is the module's own: its `go`, and the CSS of its components for their shadow roots.
         const own = [
             ...(/(?<![.\w$])\$\$go(?![\w$])/.test(rest.join('\n'))
-                ? moduleGo(inWorker ? null : (goroutines?.workerUrl ?? ''))
+                ? moduleGo(inWorker ? null : (goroutines?.workerUrl ?? ''), goroutines && 'nodeLoader' in goroutines ? goroutines.nodeLoader : undefined)
                 : []),
             ...(styles.length > 0 ? ['const $$styles = [];'] : []),
         ];
+        // The types that decode checks against, before the code that may decode at the top level.
+        const types = this.decodeTypeLines();
         const mode = this.options.runtime ?? 'import';
-        const runtime = runtimeCode(runtimeNames([...own, ...styles, ...rest].join('\n')), mode);
+        const runtime = runtimeCode(runtimeNames([...own, ...types, ...styles, ...rest].join('\n')), mode);
         if (runtime.length === 0 && own.length === 0 && styles.length === 0) {
             return this.lines.length === 0 ? '' : `${this.lines.join('\n')}\n`;
         }
@@ -79,6 +81,7 @@ class JsGenerator extends FunctionEmitter {
             mode === 'import' ? [...head, ...runtime] : head,
             mode === 'inline' ? runtime : [],
             own,
+            types,
             styles,
             rest,
         ].filter((section) => section.length > 0);

package/dist/codegen/options.d.ts

@@ -0,0 +1,40 @@
+import type * as ast from '../ast.ts';
+import type { Type } from '../checker/types.ts';
+import type { DecoratorSource } from '../decorators.ts';
+import type { InlinePackage } from '../inline-packages.ts';
+import type { StyleModule } from '../style-modules.ts';
+import type { ImportedComponent } from './imported.ts';
+import type { RuntimeMode } from './runtime.ts';
+export interface JsOptions {
+    /** The Rook source, used to keep the blank lines between statements. */
+    source: string;
+    /** Replace `.rk` with `.js` in relative import paths, for output written next to the sources. */
+    rewriteImports: boolean;
+    /** Types from the checker, when it ran; without them the generated code is more general. */
+    types?: WeakMap<ast.Expression, Type> | undefined;
+    /** Decorators imported from other modules, by name: their code is inlined here. */
+    decorators?: ReadonlyMap<string, ImportedDecorator> | undefined;
+    /** Components imported from other modules, by name: called, or inlined when they are small. */
+    components?: ReadonlyMap<string, ImportedComponent> | undefined;
+    /** Components of the module that become functions, since inlining them adds too many lines. */
+    functions?: ReadonlySet<string> | undefined;
+    /** The CSS modules the module imports, by their paths as written. */
+    styleModules?: ReadonlyMap<string, StyleModule> | undefined;
+    /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
+    goroutines?: {
+        workerUrl: string;
+        nodeLoader?: string | undefined;
+    } | {
+        targets: readonly string[];
+    } | undefined;
+    /** How the module gets the runtime it uses: imported, by default, or in it (runtime.ts). */
+    runtime?: RuntimeMode | undefined;
+    /** The data classes of the module, whose imports stay even if only types use them. */
+    dataClasses?: ReadonlySet<string> | undefined;
+}
+/** A decorator of another module, with the types of the expressions of that module. */
+export interface ImportedDecorator extends DecoratorSource {
+    types: WeakMap<ast.Expression, Type> | null;
+    /** The components of that module its code uses, which go with it into the components here. */
+    inline: InlinePackage | null;
+}

package/dist/codegen/options.js

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

package/dist/codegen/runtime.d.ts

@@ -1,7 +1,11 @@
 /** How a module gets the runtime: by an import, or with the code of the runtime in it. */
 export type RuntimeMode = 'import' | 'inline';
-/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
-export declare const PREDECLARED: ReadonlySet<string>;
+/**
+ * Predeclared names of goroutines and channels, and what they are in JS: `close(ch)` is
+ * `$$Channel.close(ch)`, and `Channel` itself is `$$Channel`, so that the names of a program stay
+ * its own.
+ */
+export declare const PREDECLARED: ReadonlyMap<string, string>;
 /** The names of the runtime that code uses, in order. */
 export declare function runtimeNames(code: string): string[];
 /** What gives a module these names of the runtime: an import, or the files that have them. */
@@ -10,4 +14,4 @@ export declare function runtimeCode(names: readonly string[], mode: RuntimeMode)
  * The `go` of a module: in a module, a call in a worker that starts with its worker module; in the
  * worker module, a call in the same worker, of a function of `$$goroutines`.
  */
-export declare function moduleGo(workerUrl: string | null): string[];
+export declare function moduleGo(workerUrl: string | null, nodeLoader?: string): string[];

package/dist/codegen/runtime.js

@@ -1,13 +1,22 @@
 import { RUNTIME_MODULE } from "../runtime-module.js";
 import { RUNTIME_FILES } from "../runtime/sources.js";
-/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
-export const PREDECLARED = new Set([
-    'after',
-    'cancel',
-    'close',
-    'stream',
-    'tick',
-    'transfer',
+/**
+ * Predeclared names of goroutines and channels, and what they are in JS: `close(ch)` is
+ * `$$Channel.close(ch)`, and `Channel` itself is `$$Channel`, so that the names of a program stay
+ * its own.
+ */
+export const PREDECLARED = new Map([
+    ['abortSignal', '$$Channel.abortSignal'],
+    ['after', '$$Channel.after'],
+    ['cancel', '$$cancel'],
+    ['Channel', '$$Channel'],
+    ['close', '$$Channel.close'],
+    ['done', '$$Channel.done'],
+    ['signal', '$$Channel.signal'],
+    ['stream', '$$Channel.stream'],
+    ['tick', '$$Channel.tick'],
+    ['Topic', '$$Topic'],
+    ['transfer', '$$transfer'],
 ]);
 /** A name of generated code, but not a member: `$$chan(...)`, and not `channel.$$chan`. */
 const NAME = /(?<![.\w$])\$\$[A-Za-z_][\w$]*/g;
@@ -58,12 +67,12 @@ export function runtimeCode(names, mode) {
  * The `go` of a module: in a module, a call in a worker that starts with its worker module; in the
  * worker module, a call in the same worker, of a function of `$$goroutines`.
  */
-export function moduleGo(workerUrl) {
+export function moduleGo(workerUrl, nodeLoader) {
     if (workerUrl === null) {
         return ['const $$go = (fn, args) => $$goHere($$goroutines, fn, args);'];
     }
     return [
-        ...startWorker(workerUrl),
+        ...startWorker(workerUrl, nodeLoader),
         '',
         'const $$go = (name, args) => $$goWorker($$startWorker, name, args);',
     ];
@@ -72,9 +81,14 @@ export function moduleGo(workerUrl) {
  * The start of a worker of a module: a Web Worker, or a worker thread of Node. Node takes only the
  * path of a `file:` URL, without the query of `app.rk?goroutines`, so its worker starts with a
  * module that imports the whole URL. An absolute URL, such as the Blob of the playground, is used
- * as it is.
+ * as it is. With `nodeLoader`, as under Vitest, the worker of Node imports the loader of `.rk`
+ * files first, since its thread has neither Vite nor the loader of `rook run`.
  */
-function startWorker(url) {
+function startWorker(url, nodeLoader) {
+    // The loader registers its hooks when it runs, so the module comes after it, by a dynamic import.
+    const code = nodeLoader === undefined
+        ? '`import ${JSON.stringify(url.href)};`'
+        : `\`import ${JSON.stringify(nodeLoader)}; await import(\${JSON.stringify(url.href)});\``;
     const base = /^[a-z][a-z\d+.-]*:/i.test(url) ? '' : ', import.meta.url';
     const workerUrl = `new URL(${JSON.stringify(url)}${base})`;
     return [
@@ -86,7 +100,7 @@ function startWorker(url) {
         '  const { Worker: NodeWorker } = await import(/* @vite-ignore */ threads);',
         // Vite bundles the Web Worker; this URL is only for Node.
         `  const url = new URL(/* @vite-ignore */ ${JSON.stringify(url)}${base});`,
-        '  const code = `import ${JSON.stringify(url.href)};`;',
+        `  const code = ${code};`,
         '  return new NodeWorker(new URL(`data:text/javascript,${encodeURIComponent(code)}`));',
         '}',
     ];