rooklang 0.3.3 → 0.3.4

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 }),
     };
 }
 /**

package/dist/completion.d.ts

@@ -1,10 +1,12 @@
-import { type Completion } from './checker/checker.ts';
+import { type Completion, type CompletionContext } from './checker/checker.ts';
 import { type CoreCompileOptions } from './compile.ts';
-export type { Completion, CompletionContext } from './checker/checker.ts';
+export type { Completion, CompletionContext, TextEdit } from './checker/checker.ts';
 export interface CompletionList {
     /** Offsets of what the chosen item replaces: the part of the name before the cursor. */
     start: number;
     end: number;
+    /** What the cursor is in; none where nothing is suggested or the check did not reach it. */
+    context?: CompletionContext;
     items: Completion[];
 }
 export declare function completeModule(source: string, offset: number, options?: CoreCompileOptions): CompletionList;

package/dist/completion.js

@@ -1,9 +1,8 @@
-import { check } from "./checker/checker.js";
+import { check, } from "./checker/checker.js";
 import { prepareCheck } from "./compile.js";
 import { tokenize } from "./lexer/lexer.js";
 import { KEYWORDS } from "./lexer/token.js";
 import { parse } from "./parser/parser.js";
-import { RESERVED } from "./parser/syntax.js";
 import { forEachChild } from "./walk.js";
 const CURSOR = '$$cursor';
 const STRINGS = new Set([
@@ -15,10 +14,11 @@ const STRINGS = new Set([
     'JsxText',
     'JsxString',
     'CssText',
+    'RegExp',
 ]);
-const VALUE_KEYWORDS = KEYWORDS.filter((keyword) => !RESERVED.has(keyword));
+const VALUE_KEYWORDS = KEYWORDS;
 // `queue` is a type of its own only in a type: elsewhere it is a name.
-const TYPE_KEYWORDS = ['func', 'comp', 'chan', 'queue'];
+const TYPE_KEYWORDS = ['func', 'comp', 'chan', 'queue', 'topic'];
 /** Keywords only at the start of a statement at the top level of a component or a decorator. */
 const COMPONENT_KEYWORDS = ['state', 'derived', 'ref', 'style', 'effect', 'mount'];
 export function completeModule(source, offset, options = {}) {
@@ -55,7 +55,12 @@ export function completeModule(source, offset, options = {}) {
         const { program } = parse(text, { markup: options.markup ?? true });
         const result = completeIn(program, options);
         if (result) {
-            return { start, end: offset, items: withKeywords(result, statementKeywords(program)) };
+            return {
+                start,
+                end: offset,
+                context: result.context,
+                items: withKeywords(result, statementKeywords(program)),
+            };
         }
         // The cursor is where a name is declared, `let ti|`: nothing to suggest.
         if (pathTo(program, CURSOR).length > 0)

package/dist/declarations.js

@@ -137,7 +137,7 @@ class DeclarationPrinter {
             switch (member.kind) {
                 case 'FieldDeclaration': {
                     const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
-                    const modifiers = this.modifiers(member.visibility, member.isStatic);
+                    const modifiers = this.modifiers(member.visibility, member.isStatic, member.readonly);
                     // As in the declaration files TypeScript writes, private members have no type.
                     if (member.visibility === 'private')
                         lines.push(`${modifiers}${member.name.name};`);
@@ -147,6 +147,17 @@ class DeclarationPrinter {
                 }
                 case 'ConstructorDeclaration': {
                     const modifiers = this.modifiers(member.visibility, false);
+                    // The parameters that are properties are declared as fields, as TypeScript writes them.
+                    member.params.forEach((param, i) => {
+                        const { property } = param;
+                        const type = info.ctor?.params[i];
+                        if (!property)
+                            return;
+                        const field = `${this.modifiers(property.visibility, false, property.readonly)}${param.name.name}`;
+                        lines.push(property.visibility === 'private' || !type
+                            ? `${field};`
+                            : `${field}: ${tsType(type)};`);
+                    });
                     if (info.ctor) {
                         lines.push(`${modifiers}constructor${parameters(member.params, info.ctor)};`);
                     }
@@ -154,8 +165,11 @@ class DeclarationPrinter {
                 }
                 case 'MethodDeclaration': {
                     const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
-                    const modifiers = this.modifiers(member.visibility, member.isStatic);
-                    if (member.visibility === 'private')
+                    const modifiers = this.modifiers(member.visibility, member.isStatic) +
+                        (member.abstract ? 'abstract ' : '');
+                    if (member.accessor)
+                        lines.push(accessor(member, modifiers, found?.type));
+                    else if (member.visibility === 'private')
                         lines.push(`${modifiers}${member.name.name}();`);
                     else if (found?.type.kind === 'function') {
                         lines.push(`${modifiers}${member.name.name}${this.signature(member.params, found.type)};`);
@@ -164,10 +178,11 @@ class DeclarationPrinter {
                 }
             }
         }
-        this.lines.push(`${exported}declare class ${jsName(node.name.name)}${this.typeParams(info.typeParams)}${heritage} {`, ...lines.map((line) => `    ${line}`), '}');
+        this.lines.push(`${exported}declare ${node.abstract ? 'abstract ' : ''}class ${jsName(node.name.name)}${this.typeParams(info.typeParams)}${heritage} {`, ...lines.map((line) => `    ${line}`), '}');
     }
-    modifiers(visibility, isStatic) {
-        return `${visibility === 'public' ? '' : `${visibility} `}${isStatic ? 'static ' : ''}`;
+    modifiers(visibility, isStatic, readonly) {
+        return (`${visibility === 'public' ? '' : `${visibility} `}${isStatic ? 'static ' : ''}` +
+            (readonly ? 'readonly ' : ''));
     }
     /** `<T, U extends Shape>` */
     typeParams(params) {
@@ -191,6 +206,17 @@ function parameters(params, type) {
     });
     return `(${list.join(', ')})`;
 }
+/** `get area(): number;` or `set area(v: number);`; a private one, as TypeScript writes it, untyped. */
+function accessor(node, modifiers, type) {
+    const head = `${modifiers}${node.accessor} ${node.name.name}`;
+    const param = jsName(node.params[0]?.name.name ?? 'value');
+    if (node.visibility === 'private' || !type) {
+        return node.accessor === 'get' ? `${head}();` : `${head}(${param});`;
+    }
+    return node.accessor === 'get'
+        ? `${head}(): ${tsType(type)};`
+        : `${head}(${param}: ${tsType(type)});`;
+}
 /** `Base` or `events.EventEmitter` in `extends`; other expressions cannot be written in types. */
 function expressionName(node) {
     if (node.kind === 'Identifier')

package/dist/decorator-copy.js

@@ -47,7 +47,10 @@ export function renamer(renames, copied, other = {}) {
     const generic = (node, hidden) => {
         const result = {};
         for (const [key, value] of Object.entries(node)) {
-            if (Array.isArray(value)) {
+            // Labels are not values: `outer: for` and `break outer` keep their names.
+            if (key === 'label')
+                result[key] = value;
+            else if (Array.isArray(value)) {
                 result[key] = value.map((item) => (isNode(item) ? copy(item, hidden) : item));
             }
             else {
@@ -106,7 +109,7 @@ export function renamer(renames, copied, other = {}) {
                 return done({
                     ...node,
                     params: node.params.map((param) => copy(param, inner)),
-                    body: copy(node.body, inner),
+                    body: node.body && copy(node.body, inner),
                 }, node);
             }
             case 'FieldDeclaration':

package/dist/goroutines.d.ts

@@ -34,4 +34,4 @@ export declare function reach(program: ast.Program, names: Iterable<string>): Re
  * The program of the worker module: the imports and the declarations that the functions `targets`
  * reach, unexported, since the worker module is only loaded by the worker.
  */
-export declare function workerProgram(program: ast.Program, targets: readonly string[]): ast.Program;
+export declare function workerProgram(program: ast.Program, targets: readonly string[], dataClasses?: Iterable<string>): ast.Program;

package/dist/goroutines.js

@@ -165,9 +165,10 @@ export function reach(program, names) {
  * The program of the worker module: the imports and the declarations that the functions `targets`
  * reach, unexported, since the worker module is only loaded by the worker.
  */
-export function workerProgram(program, targets) {
+export function workerProgram(program, targets, dataClasses = []) {
     const lifted = { ...program, body: [...program.body, ...literalFunctions(program)] };
-    const { statements, imports } = reach(lifted, targets);
+    // The data classes come too, so that their instances get their class here (runtime/classes.js).
+    const { statements, imports } = reach(lifted, [...targets, ...dataClasses]);
     const body = [];
     for (const [statement, names] of imports) {
         body.push({
@@ -229,8 +230,8 @@ function usedNames(statement) {
                     if (member.value)
                         add(freeNames({ params: [], body: block([expression(member.value)]) }));
                 }
-                else {
-                    add(freeNames(member));
+                else if (member.body) {
+                    add(freeNames({ params: member.params, body: member.body }));
                 }
             }
             return names;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { type CompileResult } from './compile.ts';
 import { type CompletionList } from './completion.ts';
+export { importFixes, type ImportFix } from './auto-import.ts';
 export type { CompileResult } from './compile.ts';
-export type { Completion, CompletionList } from './completion.ts';
+export type { Completion, CompletionList, TextEdit } from './completion.ts';
 export type { Diagnostic } from './diagnostics.ts';
 export { formatDiagnostic } from './diagnostics.ts';
 export { SourceFile } from './source.ts';
@@ -19,6 +20,8 @@ export interface CompileOptions {
     declarations?: boolean;
     /** Where the worker module of `go` is, relative to the module; see workerUrl() in compile.ts. */
     workerUrl?: string;
+    /** A module that a worker thread of Node imports first, to load `.rk` files (vite.ts). */
+    nodeLoader?: string;
     /** Markup and components; by default as the package.json of the file says (src/config.ts). */
     markup?: boolean;
     /** Import the runtime from "rooklang/runtime", the default, or put it into the module. */
@@ -27,7 +30,8 @@ export interface CompileOptions {
 export declare function compile(source: string, options?: CompileOptions): CompileResult;
 /**
  * What can be written at `offset` in a module, for editors: names, members, types, tags and
- * attributes. The imports are read from disk, like those of `compile`.
+ * attributes, and after them the names that other modules of the package export, with the imports
+ * they need. The imports are read from disk, like those of `compile`.
  */
 export declare function complete(source: string, offset: number, options?: {
     filename?: string;

package/dist/index.js

@@ -1,10 +1,12 @@
+import { importCompletions } from "./auto-import.js";
 import { compileModule, workerUrl, } from "./compile.js";
 import { completeModule } from "./completion.js";
 import { markupFor } from "./config.js";
 import { loadModuleExports } from "./modules.js";
 import { readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { importDeclarations, libraryFor } from "./typescript/importer.js";
+export { importFixes } from "./auto-import.js";
 export { formatDiagnostic } from "./diagnostics.js";
 export { SourceFile } from "./source.js";
 export function compile(source, options = {}) {
@@ -16,20 +18,27 @@ export function compile(source, options = {}) {
         markup,
         rewriteImports,
         workerUrl: options.workerUrl ?? workerUrl(filename ?? 'main.rk', rewriteImports),
+        nodeLoader: options.nodeLoader,
         typeCheck: options.typeCheck ?? true,
         declarations: options.declarations ?? false,
         runtime: options.runtime,
+        sourceName: filename === undefined ? undefined : basename(filename),
     });
 }
 /**
  * What can be written at `offset` in a module, for editors: names, members, types, tags and
- * attributes. The imports are read from disk, like those of `compile`.
+ * attributes, and after them the names that other modules of the package export, with the imports
+ * they need. The imports are read from disk, like those of `compile`.
  */
 export function complete(source, offset, options = {}) {
-    return completeModule(source, offset, {
-        ...filesOf(options.filename, true, options.markup),
-        markup: options.markup ?? markupFor(options.filename),
+    const { filename } = options;
+    const list = completeModule(source, offset, {
+        ...filesOf(filename, true, options.markup),
+        markup: options.markup ?? markupFor(filename),
     });
+    if (filename === undefined)
+        return list;
+    return { ...list, items: [...list.items, ...importCompletions(source, filename, list)] };
 }
 /** Reading what a module imports: other modules, declarations, CSS modules and the library. */
 function filesOf(filename, typeCheck, markup) {