rooklang 0.3.2 → 0.3.4

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,9 +1,11 @@
-/** Where compiled code imports the runtime from. */
-export declare const RUNTIME_MODULE = "rooklang/runtime";
 /** 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. */
@@ -12,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,19 +1,22 @@
+import { RUNTIME_MODULE } from "../runtime-module.js";
 import { RUNTIME_FILES } from "../runtime/sources.js";
-// The runtime of generated code, src/runtime. A module imports the names of it that its code uses
-// from "rooklang/runtime"; with `runtime: 'inline'` the files that have them are put into the
-// module instead, for code that runs without imports, such as that of the playground. A module
-// keeps what is its own: the start of its workers, whose URL a bundler must see in it, the `go`
-// that uses it, and the CSS of its components.
-/** Where compiled code imports the runtime from. */
-export const RUNTIME_MODULE = 'rooklang/runtime';
-/** 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;
@@ -64,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);',
     ];
@@ -78,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 [
@@ -92,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)}`));',
         '}',
     ];

package/dist/codegen/simple-statements.d.ts

@@ -1,13 +1,12 @@
 import type * as ast from '../ast.ts';
-import { CallEmitter } from './calls.ts';
+import { TryEmitter } from './try.ts';
 /** Statements: lists and blocks of them, variables, assignments, `return`; the others are in later layers. */
-export declare abstract class SimpleStatementEmitter extends CallEmitter {
+export declare abstract class SimpleStatementEmitter extends TryEmitter {
     protected abstract forInStatement(node: ast.ForInStatement): void;
     protected abstract selectStatement(node: ast.SelectStatement): void;
     protected abstract forStatement(node: ast.ForStatement): void;
     protected abstract ifStatement(node: ast.IfStatement): string;
-    protected abstract switchStatement(node: ast.SwitchStatement, discriminant: ast.Expression): void;
-    protected abstract taglessSwitch(node: ast.SwitchStatement): void;
+    protected abstract switchStatement(node: ast.SwitchStatement): void;
     protected abstract tryStatement(node: ast.TryStatement): string;
     protected abstract classDeclaration(node: ast.ClassDeclaration): void;
     protected abstract importDeclaration(node: ast.ImportDeclaration): void;
@@ -29,7 +28,14 @@ export declare abstract class SimpleStatementEmitter extends CallEmitter {
     /** A block's statements in a new scope, without the braces; `then` writes more code in it. */
     protected blockStatements(statements: readonly ast.Statement[], then?: () => void): void;
     protected blockStatement(node: ast.BlockStatement): string;
+    /**
+     * The start of the statement being written, which its first line gets as a mark for the source
+     * map (source-map.ts). Imports have none, since the import of the runtime goes among them, and
+     * neither does the code of other modules, whose places are in their own sources.
+     */
+    private sourceMark;
     protected statement(node: ast.Statement): void;
+    protected line(text: string): void;
     protected emitStatement(node: ast.Statement): void;
     /** `let a, b = 1, 2` → `let a = 1, b = 2`; `const q, err = f()` → `const [q, err] = f()`. */
     protected variableDeclaration(node: ast.VariableDeclaration): string;

package/dist/codegen/simple-statements.js

@@ -1,10 +1,11 @@
 import { isIterator } from "../iterators.js";
+import { sourceMark } from "../source-map.js";
 import { holdsBigInts, TYPED_ARRAYS, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { declarationsOf } from "./analysis.js";
-import { CallEmitter } from "./calls.js";
+import { TryEmitter } from "./try.js";
 import { ARROW, arrayPattern, POSTFIX } from "./syntax.js";
 /** Statements: lists and blocks of them, variables, assignments, `return`; the others are in later layers. */
-export class SimpleStatementEmitter extends CallEmitter {
+export class SimpleStatementEmitter extends TryEmitter {
     /** Counter for the labels of switches compiled to if/else. */
     labels = 0;
     statements(list) {
@@ -34,8 +35,34 @@ export class SimpleStatementEmitter extends CallEmitter {
     blockStatement(node) {
         return this.block(() => this.blockStatements(node.body));
     }
+    /**
+     * The start of the statement being written, which its first line gets as a mark for the source
+     * map (source-map.ts). Imports have none, since the import of the runtime goes among them, and
+     * neither does the code of other modules, whose places are in their own sources.
+     */
+    sourceMark = null;
     statement(node) {
-        this.withHoisting(true, () => this.emitStatement(node));
+        // A statement may write the statements inside it first, as a function writes its body before
+        // its first line: then the mark waits for that line.
+        const outer = this.sourceMark;
+        this.sourceMark =
+            node.kind === 'ImportDeclaration' || this.foreign.has(node) ? null : node.start;
+        try {
+            this.withHoisting(true, () => this.emitStatement(node));
+        }
+        finally {
+            this.sourceMark = outer;
+        }
+    }
+    // The marks of the updates of components stand alone in their lines (updates.ts).
+    line(text) {
+        if (this.sourceMark === null || text.startsWith('\uE000')) {
+            super.line(text);
+            return;
+        }
+        const mark = sourceMark(this.sourceMark);
+        this.sourceMark = null;
+        super.line(mark + text);
     }
     emitStatement(node) {
         switch (node.kind) {
@@ -115,18 +142,15 @@ export class SimpleStatementEmitter extends CallEmitter {
                 this.selectStatement(node);
                 break;
             case 'SwitchStatement':
-                if (node.discriminant === null)
-                    this.taglessSwitch(node);
-                else
-                    this.switchStatement(node, node.discriminant);
+                this.switchStatement(node);
                 break;
             case 'BreakStatement': {
-                const label = this.fn.breakTargets.at(-1);
+                const label = node.label ? this.label(node.label) : this.fn.breakTargets.at(-1);
                 this.line(label ? `break ${label};` : 'break;');
                 break;
             }
             case 'ContinueStatement':
-                this.line('continue;');
+                this.line(node.label ? `continue ${this.label(node.label)};` : 'continue;');
                 break;
             case 'ThrowStatement':
                 this.line(`throw ${this.expression(node.argument, 0)};`);
@@ -137,12 +161,9 @@ export class SimpleStatementEmitter extends CallEmitter {
             case 'DeferStatement':
                 this.deferStatement(node);
                 break;
-            // Waits until the channel takes the value.
-            case 'SendStatement': {
-                const channel = this.expression(node.channel, ARROW);
-                this.line(`await $$send(${channel}, ${this.expression(node.value, ARROW)});`);
+            case 'SendStatement':
+                this.line(`${this.send(node)};`);
                 break;
-            }
             case 'MountStatement':
                 this.mountStatement(node);
                 break;
@@ -192,9 +213,13 @@ export class SimpleStatementEmitter extends CallEmitter {
             // An empty queue, as `[]` is an empty array.
             case 'QueueType':
                 return 'new $$Queue()';
+            // Closed, the same for all types: what is sent to them goes nowhere.
+            case 'ChanType':
+                return '$$Channel.EMPTY';
+            case 'TopicType':
+                return '$$Topic.EMPTY';
             case 'FuncType':
             case 'ComponentType':
-            case 'ChanType':
             case 'ObjectType':
             case 'UnionType':
             case 'LiteralType':

package/dist/codegen/statements.js

@@ -1,3 +1,4 @@
+import { isSuperCall } from "../checker/helpers.js";
 import { isIterator } from "../iterators.js";
 import { decoratedName, moduleNamesOf } from "../decorators.js";
 import { inlinePackages } from "../inline-packages.js";
@@ -16,7 +17,9 @@ export class StatementEmitter extends ParallelLoopEmitter {
             return;
         // Imports used only as types (e.g. interfaces) do not exist at runtime, and neither do
         // components: a component used as a value is its function, imported below.
-        const used = (name) => this.valueNames.has(name.name) && !this.options.components?.has(name.name);
+        // A data class, even used only as a type, registers itself where it is imported.
+        const used = (name) => (this.valueNames.has(name.name) || this.options.dataClasses?.has(name.name) === true) &&
+            !this.options.components?.has(name.name);
         const clauses = [];
         if (node.defaultImport && used(node.defaultImport)) {
             clauses.push(this.name(node.defaultImport.name));
@@ -100,7 +103,10 @@ export class StatementEmitter extends ParallelLoopEmitter {
             : '';
         const body = this.block(() => {
             let previous;
+            // An abstract method has no code: only the subclasses have it.
             for (const member of node.members) {
+                if (member.kind === 'MethodDeclaration' && member.abstract)
+                    continue;
                 const bothFields = previous?.kind === 'FieldDeclaration' && member.kind === 'FieldDeclaration';
                 if (previous && (!bothFields || this.blankLineBetween(previous, member)))
                     this.blankLine();
@@ -109,6 +115,12 @@ export class StatementEmitter extends ParallelLoopEmitter {
             }
         });
         this.line(`${exported}class ${this.name(node.name.name)}${superClass} ${body}`);
+        // A data class is registered, so that its instances get it back in another thread
+        // (runtime/classes.js); the id is the same in the worker module, which has a copy of it.
+        if (node.data) {
+            const id = `${node.name.name}:${hash(this.options.source.slice(node.start, node.end))}`;
+            this.line(`$$dataClass(${this.name(node.name.name)}, ${JSON.stringify(id)});`);
+        }
     }
     /** Visibility modifiers are checked by the compiler and do not exist in the output. */
     classMember(member) {
@@ -126,17 +138,65 @@ export class StatementEmitter extends ParallelLoopEmitter {
                 break;
             }
             case 'ConstructorDeclaration': {
-                const [params, body] = this.func(member.params, member.body);
+                const [params, body] = this.func(member.params, assignProperties(member));
                 this.line(`constructor(${params}) ${body}`);
                 break;
             }
             case 'MethodDeclaration': {
+                if (!member.body)
+                    break;
                 const [params, body] = this.func(member.params, member.body);
-                const modifiers = `${member.isStatic ? 'static ' : ''}${member.async ? 'async ' : ''}`;
-                const star = isIterator(member.params) ? '*' : '';
+                const modifiers = `${member.isStatic ? 'static ' : ''}${member.async ? 'async ' : ''}` +
+                    (member.accessor ? `${member.accessor} ` : '');
+                const star = isIterator(member.params) && !member.accessor ? '*' : '';
                 this.line(`${modifiers}${star}${member.name.name}(${params}) ${body}`);
                 break;
             }
         }
     }
 }
+/**
+ * The body of a constructor whose parameters are properties, `constructor(private name string)`:
+ * it assigns them first, `this.name = name`, or right after `super(...)` in a derived class.
+ */
+function assignProperties(node) {
+    const assignments = node.params.flatMap((param) => {
+        if (!param.property)
+            return [];
+        const at = { start: param.start, end: param.end };
+        const self = { kind: 'ThisExpression', ...at };
+        const target = {
+            kind: 'MemberExpression',
+            object: self,
+            property: param.name,
+            optional: false,
+            ...at,
+        };
+        return [
+            {
+                kind: 'AssignmentStatement',
+                operator: '=',
+                targets: [target],
+                values: [param.name],
+                ...at,
+            },
+        ];
+    });
+    if (assignments.length === 0)
+        return node.body;
+    const statements = node.body.body;
+    const after = statements.findIndex(isSuperCall) + 1;
+    return {
+        ...node.body,
+        body: [...statements.slice(0, after), ...assignments, ...statements.slice(after)],
+    };
+}
+/** FNV-1a of a text, as 8 hex digits: an id that changes only with the text. */
+function hash(text) {
+    let value = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        value ^= text.charCodeAt(i);
+        value = Math.imul(value, 0x01000193) >>> 0;
+    }
+    return value.toString(16).padStart(8, '0');
+}

package/dist/codegen/try.d.ts

@@ -0,0 +1,5 @@
+import type * as ast from '../ast.ts';
+import { DecodeEmitter } from './decode.ts';
+export declare abstract class TryEmitter extends DecodeEmitter {
+    protected tryValue(node: ast.TryExpression): [string, number];
+}

package/dist/codegen/try.js

@@ -0,0 +1,40 @@
+import { isErrorType } from "../checker/error-results.js";
+import { forEachChild } from "../walk.js";
+import { startsWithObjectLiteral } from "./analysis.js";
+import { DecodeEmitter } from "./decode.js";
+import { ARROW, POSTFIX, UNARY } from "./syntax.js";
+// `try expr`: the expression runs in a function that the runtime calls inside try/catch
+// (runtime/try.js), `$$catch(() => JSON.parse(text))`. One that waits is an async function, whose
+// rejected Promise is caught as well: `await $$catchAsync(async () => await fetch(url))`. The runtime
+// is told how many values the expression gives, and whether the last of them is an error already.
+export class TryEmitter extends DecodeEmitter {
+    tryValue(node) {
+        // The expression may not run to the end, so it creates no elements in advance.
+        const code = this.withHoisting(false, () => this.expression(node.argument, ARROW));
+        const body = startsWithObjectLiteral(node.argument) ? `(${code})` : code;
+        const type = this.options.types?.get(node.argument);
+        let results = '';
+        if (type?.kind === 'void' || (type !== undefined && isErrorType(type))) {
+            results = type.kind === 'void' ? ', 0' : ', 1, true';
+        }
+        else if (type?.kind === 'tuple') {
+            results = `, ${type.types.length}${isErrorType(type.types.at(-1)) ? ', true' : ''}`;
+        }
+        return waits(node.argument)
+            ? [`await $$catchAsync(async () => ${body}${results})`, UNARY]
+            : [`$$catch(() => ${body}${results})`, POSTFIX];
+    }
+}
+/** Whether the expression waits, with `await` or `<-`, outside the functions in it. */
+function waits(node) {
+    if (node.kind === 'UnaryExpression' && (node.operator === 'await' || node.operator === '<-')) {
+        return true;
+    }
+    if (node.kind === 'FuncExpression' || node.kind === 'ArrowFunction')
+        return false;
+    let found = false;
+    forEachChild(node, (child) => {
+        found ||= waits(child);
+    });
+    return found;
+}

package/dist/compile.d.ts

@@ -2,6 +2,7 @@ import type * as ast from './ast.ts';
 import { type CheckOptions, type ImportResult, type Library } from './checker/checker.ts';
 import type { RuntimeMode } from './codegen/runtime.ts';
 import type { Diagnostic } from './diagnostics.ts';
+import { type SourceMap } from './source-map.ts';
 import { type StyleModule } from './style-modules.ts';
 export interface CoreCompileOptions {
     /** Replace `.rk` with `.js` in relative import paths. Defaults to `true`. */
@@ -22,12 +23,16 @@ export interface CoreCompileOptions {
     readStyleModule?: ((specifier: string) => string | null) | undefined;
     /** Where the worker module of `go` is, relative to the module; see workerUrl(). */
     workerUrl?: string | undefined;
+    /** A module that a worker thread of Node imports first, to load `.rk` files (vite.ts). */
+    nodeLoader?: string | undefined;
     /**
      * How the code gets the runtime of Rook: `import`, the default, imports it from
      * "rooklang/runtime"; `inline` puts the parts it uses into the module, for code that runs
      * without imports (src/codegen/runtime.ts).
      */
     runtime?: RuntimeMode | undefined;
+    /** The name of the source in the source maps, `app.rk`. */
+    sourceName?: string | undefined;
 }
 /**
  * Where the worker module of a module is: a `.worker.js` next to its `.js`, or, where `.rk`
@@ -45,6 +50,10 @@ export interface CompileResult {
     dependencies: string[];
     /** The `.d.ts` for the module, with the `declarations` option. */
     declarations?: string;
+    /** Where the lines of `code` come from in the source, when there is code. */
+    map?: SourceMap;
+    /** That of the worker module. */
+    workerMap?: SourceMap;
     /** The worker module that runs the functions `go` calls, when the module has `go`. */
     worker?: string;
 }

package/dist/compile.js

@@ -3,6 +3,7 @@ import { property, STRING } from "./checker/types.js";
 import { generateJs } from "./codegen/js.js";
 import { printDeclarations } from "./declarations.js";
 import { goroutines, goTarget, workerProgram } from "./goroutines.js";
+import { withoutMarks } from "./source-map.js";
 import { parse } from "./parser/parser.js";
 import { isStyleModule, styleModule, unusedClasses } from "./style-modules.js";
 /**
@@ -24,6 +25,8 @@ export function compileModule(source, options = {}) {
         return { code: '', diagnostics: problems, warnings: [], dependencies };
     let types;
     let declarations;
+    // Without the checker, only the data classes that the module declares are known.
+    let dataClasses = new Set(program.body.flatMap((each) => each.kind === 'ClassDeclaration' && each.data ? [each.name.name] : []));
     let warnings = [];
     if (options.typeCheck ?? true) {
         const checked = check(program, checkOptions);
@@ -32,6 +35,7 @@ export function compileModule(source, options = {}) {
             return { code: '', diagnostics: checked.diagnostics, warnings, dependencies };
         }
         types = checked.types;
+        dataClasses = checked.dataClasses;
         if (options.declarations)
             declarations = printDeclarations(program, checked);
     }
@@ -42,25 +46,34 @@ export function compileModule(source, options = {}) {
         types,
         styleModules,
         runtime: options.runtime,
+        dataClasses,
         ...importedCode(program, options.importModule),
     };
-    const code = generateJs(program, {
+    const sourceName = options.sourceName ?? 'main.rk';
+    const main = withoutMarks(generateJs(program, {
         ...jsOptions,
-        goroutines: { workerUrl: options.workerUrl ?? workerUrl('main.rk', rewriteImports) },
-    });
+        goroutines: {
+            workerUrl: options.workerUrl ?? workerUrl('main.rk', rewriteImports),
+            nodeLoader: options.nodeLoader,
+        },
+    }), source, sourceName);
     const targets = [
         ...new Set(goroutines(program).flatMap((node) => goTarget(program, node) ?? [])),
     ];
     const worker = targets.length > 0
-        ? generateJs(workerProgram(program, targets), { ...jsOptions, goroutines: { targets } })
+        ? withoutMarks(generateJs(workerProgram(program, targets, dataClasses), {
+            ...jsOptions,
+            goroutines: { targets },
+        }), source, sourceName)
         : undefined;
     return {
-        code,
+        code: main.code,
         diagnostics: [],
         warnings,
         dependencies,
         ...(declarations ? { declarations } : {}),
-        ...(worker === undefined ? {} : { worker }),
+        map: main.map,
+        ...(worker === undefined ? {} : { worker: worker.code, workerMap: worker.map }),
     };
 }
 /**