rooklang 0.3.3 → 0.4.0

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.d.ts

@@ -9,6 +9,11 @@ import { ParallelLoopEmitter } from './parallel.ts';
 export declare abstract class StatementEmitter extends ParallelLoopEmitter {
     /** A CSS module: its object and CSS go with the styles (StyleEmitter), not to an import. */
     protected abstract styleModuleImport(node: ast.ImportDeclaration): boolean;
+    private sharedReads;
+    /** State of the module: the updates of the components that read it are kept beside it. */
+    protected emitStatement(node: ast.Statement): void;
+    /** Whether the components or decorators of the module read `name`, and so listen to it. */
+    protected readsShared(name: string): boolean;
     protected importDeclaration(node: ast.ImportDeclaration): void;
     /**
      * `export { log as $$visible$log }`: the names of the module that the code of exported

package/dist/codegen/statements.js

@@ -1,8 +1,11 @@
+import { isSuperCall } from "../checker/helpers.js";
 import { isIterator } from "../iterators.js";
 import { decoratedName, moduleNamesOf } from "../decorators.js";
 import { inlinePackages } from "../inline-packages.js";
 import { packageExports } from "./imported.js";
+import { readNames } from "./mutations.js";
 import { ParallelLoopEmitter } from "./parallel.js";
+import { listenersName } from "./shared.js";
 import { ARROW, POSTFIX } from "./syntax.js";
 /**
  * Imports and classes; with the layers below, all statements and declarations. A decorator of
@@ -11,12 +14,42 @@ import { ARROW, POSTFIX } from "./syntax.js";
  * So does an inlined component of another module; a called one brings its function, `$$Card`.
  */
 export class StatementEmitter extends ParallelLoopEmitter {
+    sharedReads = null;
+    /** State of the module: the updates of the components that read it are kept beside it. */
+    emitStatement(node) {
+        super.emitStatement(node);
+        if (node.kind !== 'VariableDeclaration' || node.keyword !== 'state')
+            return;
+        if (!this.program.body.includes(node))
+            return;
+        const exported = node.exported ? 'export ' : '';
+        for (const name of node.names) {
+            const listeners = this.shared.listeners.get(name.name);
+            if (listeners)
+                this.line(`${exported}const ${listeners} = new Set();`);
+        }
+    }
+    /** Whether the components or decorators of the module read `name`, and so listen to it. */
+    readsShared(name) {
+        if (!this.sharedReads) {
+            this.sharedReads = new Set();
+            for (const statement of this.program.body) {
+                if (statement.kind === 'ComponentDeclaration' ||
+                    statement.kind === 'DecoratorDeclaration') {
+                    readNames(statement, this.sharedReads);
+                }
+            }
+        }
+        return this.sharedReads.has(name);
+    }
     importDeclaration(node) {
         if (this.styleModuleImport(node))
             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));
@@ -33,6 +66,11 @@ export class StatementEmitter extends ParallelLoopEmitter {
         const hidden = (exported, local) => named.push(exported === local ? exported : `${exported} as ${local}`);
         for (const specifier of node.namedImports) {
             const component = this.options.components?.get(specifier.local.name);
+            const state = this.options.shared?.get(specifier.local.name);
+            // State of that module: the components here that read it listen to its changes.
+            if (state !== undefined && this.readsShared(specifier.local.name)) {
+                hidden(listenersName(state), this.shared.listeners.get(specifier.local.name));
+            }
             const inlined = this.inlinedImports.get(specifier.local.name);
             if (inlined) {
                 for (const [exported, local] of inlined.imports)
@@ -100,7 +138,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 +150,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 +173,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/codegen/updates.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
 import { type Type } from '../checker/types.ts';
-import type { Reactive, Source, Write } from './reactive.ts';
+import { type Reactive, type Source, type Write } from './reactive.ts';
 import { StatementEmitter } from './statements.ts';
 /**
  * Updates after changes of component state. Each state variable gets an update function; every
@@ -19,8 +19,13 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     protected rendering: number;
-    /** After a statement that changes state, the update of what depends on it. */
+    /**
+     * After a statement that changes state of the module, the updates of the components that read
+     * it; code that renders markup changes none, as with the state of a component.
+     */
     protected statement(node: ast.Statement): void;
+    /** After a statement that changes state, the update of what depends on it. */
+    private statementWithUpdates;
     protected changesState(body: ast.Expression): boolean;
     protected withRendering<T>(rendering: number, emit: () => T): T;
     /** Records a place that changes a source and returns its marker; see resolveMarkers. */
@@ -45,7 +50,10 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
  * update statement, or by nothing when no markup depends on the source.
  */
 export declare function resolveMarkers(block: string, reactive: Reactive): string;
-/** The update statements that a place changing the source needs, the computations first. */
+/**
+ * The update statements that a place changing the source needs: the computations, the call that
+ * gives a bound property to the parent, then the updates of the nodes.
+ */
 export declare function needed(source: Source, write: Write): string[];
 /** One place changes the source, after the markup exists, and needs one update statement. */
 export declare function inlinesUpdate(source: Source): boolean;

package/dist/codegen/updates.js

@@ -1,6 +1,8 @@
 import { widenLiterals } from "../checker/types.js";
+import { updatesOf } from "./reactive.js";
 import { StatementEmitter } from "./statements.js";
 import { startsWithObjectLiteral } from "./analysis.js";
+import { sharedWrites } from "./shared.js";
 import { ARROW } from "./syntax.js";
 /**
  * Updates after changes of component state. Each state variable gets an update function; every
@@ -19,8 +21,37 @@ export class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     rendering = 0;
-    /** After a statement that changes state, the update of what depends on it. */
+    /**
+     * After a statement that changes state of the module, the updates of the components that read
+     * it; code that renders markup changes none, as with the state of a component.
+     */
     statement(node) {
+        const shared = this.rendering > 0 ? [] : sharedWrites(node, this.shared, (each) => this.typeOf(each));
+        if (shared.length === 0) {
+            this.statementWithUpdates(node);
+            return;
+        }
+        const notify = () => {
+            for (const name of shared)
+                this.line(`$$changed(${this.shared.listeners.get(name)});`);
+        };
+        if (node.kind !== 'ReturnStatement' && node.kind !== 'ThrowStatement') {
+            this.statementWithUpdates(node);
+            notify();
+            return;
+        }
+        // The value is computed first, then the updates run, then the function leaves.
+        const values = node.kind === 'ThrowStatement' ? [node.argument] : node.values;
+        const temp = this.temp();
+        this.withHoisting(true, () => {
+            const rendered = values.map((value) => this.expression(value, ARROW));
+            this.line(`const ${temp} = ${rendered.length === 1 ? rendered[0] : `[${rendered.join(', ')}]`};`);
+        });
+        notify();
+        this.line(`${node.kind === 'ThrowStatement' ? 'throw' : 'return'} ${temp};`);
+    }
+    /** After a statement that changes state, the update of what depends on it. */
+    statementWithUpdates(node) {
         const { reactive } = this;
         if (reactive && this.fn === reactive.setup && reactive.declaresRenderFunction(node)) {
             this.withRendering(this.rendering + 1, () => super.statement(node));
@@ -33,6 +64,9 @@ export class UpdateEmitter extends StatementEmitter {
             for (const source of changed) {
                 for (const computation of source.computations)
                     this.line(computation);
+                // The parent of a bound property gets the value the body gave it.
+                if (source.bound)
+                    this.line(source.bound);
             }
             return;
         }
@@ -137,7 +171,14 @@ export function resolveMarkers(block, reactive) {
     const sources = new Map();
     for (const source of reactive.sources.values())
         sources.set(source.id, source);
-    return block.replace(/^([ \t]*)\uE000(\d+)(?::(\d+))?\uE001;\n/gm, (line, indent, id, skip) => {
+    // `$$watch(...)` of state of the module stays if something depends on it.
+    const listened = block.replace(/^([ \t]*)\uE004(\d+)\uE004(.*)\n/gm, (line, indent, id, text) => {
+        const source = sources.get(Number(id));
+        if (!source)
+            return line;
+        return updatesOf(source).length > 0 ? `${indent}${text}\n` : '';
+    });
+    return listened.replace(/^([ \t]*)\uE000(\d+)(?::(\d+))?\uE001;\n/gm, (line, indent, id, skip) => {
         const source = sources.get(Number(id));
         if (!source)
             return line;
@@ -148,9 +189,16 @@ export function resolveMarkers(block, reactive) {
         return `${indent}${text}\n`;
     });
 }
-/** The update statements that a place changing the source needs, the computations first. */
+/**
+ * The update statements that a place changing the source needs: the computations, the call that
+ * gives a bound property to the parent, then the updates of the nodes.
+ */
 export function needed(source, write) {
-    return [...source.computations, ...source.dependents.filter((_, i) => i !== write.skip)];
+    return [
+        ...source.computations,
+        ...(source.bound ? [source.bound] : []),
+        ...source.dependents.filter((_, i) => i !== write.skip),
+    ];
 }
 /** One place changes the source, after the markup exists, and needs one update statement. */
 export function inlinesUpdate(source) {

package/dist/codegen/web-components.d.ts

@@ -6,8 +6,8 @@ import { ComponentEmitter } from './components.ts';
  * have their values.
  *
  * The element renders the component into its shadow root when it is connected. When it is
- * disconnected and not put back in the same task, the component is removed: the functions
- * returned by `mount()` run. Moving the element keeps its markup.
+ * disconnected and not put back in the same task, the component is removed: what its
+ * `mount` deferred runs. Moving the element keeps its markup.
  *
  * Every property except `children` is a JS property of the element; its setter updates the markup.
  * Strings, numbers and bools also have attributes: `item-count="3"` sets `itemCount` to 3, and a

package/dist/codegen/web-components.js

@@ -6,8 +6,8 @@ import { ComponentEmitter } from "./components.js";
  * have their values.
  *
  * The element renders the component into its shadow root when it is connected. When it is
- * disconnected and not put back in the same task, the component is removed: the functions
- * returned by `mount()` run. Moving the element keeps its markup.
+ * disconnected and not put back in the same task, the component is removed: what its
+ * `mount` deferred runs. Moving the element keeps its markup.
  *
  * Every property except `children` is a JS property of the element; its setter updates the markup.
  * Strings, numbers and bools also have attributes: `item-count="3"` sets `itemCount` to 3, and a

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 }),
     };
 }
 /**
@@ -89,11 +102,12 @@ export function prepareCheck(program, options) {
 }
 /**
  * What the module imports from other `.rk` modules for the generator: decorators, whose code is
- * inlined, and components, which are called or inlined.
+ * inlined, components, which are called or inlined, and state, whose changes it listens to.
  */
 function importedCode(program, importModule) {
     const found = new Map();
     const components = new Map();
+    const shared = new Map();
     for (const statement of program.body) {
         if (statement.kind !== 'ImportDeclaration' || !statement.source.value.endsWith('.rk')) {
             continue;
@@ -103,6 +117,9 @@ function importedCode(program, importModule) {
         const decorators = exports?.decorators;
         for (const specifier of statement.namedImports) {
             const component = exports?.components?.get(specifier.imported.name);
+            if (exports?.shared?.has(specifier.imported.name)) {
+                shared.set(specifier.local.name, specifier.imported.name);
+            }
             if (component) {
                 components.set(specifier.local.name, {
                     node: component.node,
@@ -122,7 +139,7 @@ function importedCode(program, importModule) {
             });
         }
     }
-    return { decorators: found, components };
+    return { decorators: found, components, shared };
 }
 /** The CSS modules that the program imports, read and parsed, or what is wrong with them. */
 function readStyleModules(program, read) {

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)