rooklang 0.3.1 → 0.3.3

package/dist/codegen/emitter.d.ts

@@ -6,7 +6,7 @@ import { type ImportedComponent, type LocalizedPackage } from './imported.ts';
 import type { Root } from '../refs.ts';
 import type { StyleModule } from '../style-modules.ts';
 import type { BindingKind } from './analysis.ts';
-import type { Helper } from './helpers.ts';
+import type { RuntimeMode } from './runtime.ts';
 export interface JsOptions {
     /** The Rook source, used to keep the blank lines between statements. */
     source: string;
@@ -22,14 +22,14 @@ export interface JsOptions {
     functions?: ReadonlySet<string> | undefined;
     /** The CSS modules the module imports, by their paths as written. */
     styleModules?: ReadonlyMap<string, StyleModule> | undefined;
-    /** Create elements with their attributes by a helper, $$element; see creation.ts. */
-    elementHelper?: boolean | undefined;
     /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
     goroutines?: {
         workerUrl: string;
     } | {
         targets: readonly string[];
     } | undefined;
+    /** How the module gets the runtime it uses: imported, by default, or in it (runtime.ts). */
+    runtime?: RuntimeMode | undefined;
 }
 /** A decorator of another module, with the types of the expressions of that module. */
 export interface ImportedDecorator extends DecoratorSource {
@@ -67,8 +67,6 @@ export declare abstract class Emitter {
     private level;
     private readonly scopes;
     protected fn: FunctionContext;
-    /** Helpers that the module must define, such as $$runDeferred. */
-    protected readonly helpers: Set<Helper>;
     /**
      * Whether code for the current expression may be written before the statement that contains it.
      * Elements use this to be created in statements of their own; it is off where an expression is

package/dist/codegen/emitter.js

@@ -27,8 +27,6 @@ export class Emitter {
         temps: 0,
         breakTargets: [],
     };
-    /** Helpers that the module must define, such as $$runDeferred. */
-    helpers = new Set();
     /**
      * Whether code for the current expression may be written before the statement that contains it.
      * Elements use this to be created in statements of their own; it is off where an expression is

package/dist/codegen/expressions.d.ts

@@ -18,11 +18,14 @@ export declare abstract class ExpressionEmitter extends Emitter {
     protected abstract arrayLiteral(node: ast.ArrayLiteral): string;
     protected abstract conversion(node: ast.ConversionExpression): string;
     protected abstract make(node: ast.MakeExpression): string;
+    protected abstract chan(node: ast.ChanExpression): string;
+    protected abstract streamChan(node: ast.StreamChanExpression): string;
+    protected abstract queue(node: ast.QueueExpression): string;
     /** `<-ch` that gives `[value, ok]`, in `v, ok = <-ch`. */
     protected readonly commaOk: WeakSet<ast.Expression>;
     /** `items[i]` in a part of `go for`, which is `items[$$i]` there (parallel.ts). */
     protected readonly partElements: Set<ast.Expression>;
-    /** In the worker module, `go` runs in the same worker (go-helpers.ts). */
+    /** In the worker module, `go` runs in the same worker (runtime.ts). */
     protected get inWorker(): boolean;
     /** `v, ok = <-ch`: two variables from a single receive. */
     protected markCommaOk(count: number, values: readonly ast.Expression[]): void;

package/dist/codegen/expressions.js

@@ -3,7 +3,7 @@ import { goCaptures, goParams, goTarget } from "../goroutines.js";
 import { isIterator, usesThis } from "../iterators.js";
 import { containsElement, startsWithObjectLiteral } from "./analysis.js";
 import { Emitter } from "./emitter.js";
-import { PREDECLARED } from "./helpers.js";
+import { PREDECLARED } from "./runtime.js";
 import { ARROW, BINARY, CONDITIONAL, POSTFIX, PRIMARY, UNARY } from "./syntax.js";
 /** Expressions, with the parentheses that JS operator precedence requires. */
 export class ExpressionEmitter extends Emitter {
@@ -11,7 +11,7 @@ export class ExpressionEmitter extends Emitter {
     commaOk = new WeakSet();
     /** `items[i]` in a part of `go for`, which is `items[$$i]` there (parallel.ts). */
     partElements = new Set();
-    /** In the worker module, `go` runs in the same worker (go-helpers.ts). */
+    /** In the worker module, `go` runs in the same worker (runtime.ts). */
     get inWorker() {
         return this.options.goroutines !== undefined && 'targets' in this.options.goroutines;
     }
@@ -59,9 +59,7 @@ 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.
-                const helper = Object.hasOwn(PREDECLARED, node.name) ? PREDECLARED[node.name] : undefined;
-                if (helper && this.lookup(node.name) === undefined) {
-                    this.helpers.add(helper);
+                if (PREDECLARED.has(node.name) && this.lookup(node.name) === undefined) {
                     return [`$$${node.name}`, PRIMARY];
                 }
                 // The predeclared `error` used as a value is JS's `Error`, which also works without `new`.
@@ -108,12 +106,12 @@ export class ExpressionEmitter extends Emitter {
             }
             case 'ArrowFunction':
                 return [this.arrowFunction(node), ARROW];
-            // `chan<number>(10)`: the channel keeps the zero value that a closed one gives.
-            case 'ChanExpression': {
-                const size = node.size ? this.expression(node.size, ARROW) : '0';
-                this.helpers.add('chan');
-                return [`$$chan(${size}, ${this.zeroValue(node.element) ?? 'null'})`, POSTFIX];
-            }
+            case 'ChanExpression':
+                return [this.chan(node), POSTFIX];
+            case 'StreamChanExpression':
+                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.
@@ -129,7 +127,6 @@ export class ExpressionEmitter extends Emitter {
                 const fn = literal && this.inWorker
                     ? this.expression({ ...literal, params: [...goParams(literal, captured), ...literal.params] }, ARROW)
                     : JSON.stringify(goTarget(this.program, node));
-                this.helpers.add(this.inWorker ? 'goLocal' : 'go');
                 return [`$$go(${fn}, [${args.filter((arg) => arg !== '').join(', ')}])`, POSTFIX];
             }
             case 'UnaryExpression':
@@ -225,7 +222,6 @@ export class ExpressionEmitter extends Emitter {
     }
     unary(node) {
         if (node.operator === '<-') {
-            this.helpers.add('chan');
             const channel = this.expression(node.argument, ARROW);
             return `await $$receive(${channel}${this.commaOk.has(node) ? ', true' : ''})`;
         }

package/dist/codegen/functions.js

@@ -22,7 +22,6 @@ export class FunctionEmitter extends WebComponentEmitter {
                         this.statementsWithDefers(body.body);
                     }
                     else if (mode === 'stack') {
-                        this.helpers.add('runDeferred');
                         this.line('const $$defer = [];');
                         const statements = this.block(() => this.statements(body.body));
                         const finalizer = this.block(() => this.line('$$runDeferred($$defer);'));
@@ -60,7 +59,6 @@ export class FunctionEmitter extends WebComponentEmitter {
     effectBody(body, cleanups) {
         return this.withFunction('effect', [], () => {
             this.fn.deferList = cleanups;
-            this.helpers.add('runDeferred');
             return this.block(() => this.withScope(declarationsOf(body.body), () => {
                 this.line(`$$runDeferred(${cleanups}.splice(0));`);
                 this.statements(body.body);

package/dist/codegen/js.d.ts

@@ -3,18 +3,11 @@ import type { JsOptions } from './emitter.ts';
 export type { JsOptions } from './emitter.ts';
 /** A component whose inlined copies add more lines than this to its module becomes a function. */
 export declare const INLINE_LIMIT = 100;
-/**
- * A module whose code creates more elements than this creates them with $$element, which takes
- * their attributes: its definition takes less than the statements it saves.
- */
-export declare const ELEMENT_HELPER_LIMIT = 20;
 /**
  * Generates a readable ES module from a program that has parsed without errors. A component is
  * inlined where it is used, unless that adds more than INLINE_LIMIT lines compared to a function
  * and its calls. The module is generated again with each such candidate as a function, and the one
  * that saves the most goes first: that changes the sizes of the components inside it. A component
  * of another module is a candidate too; its function is in that module, and counts as one copy.
- * Then, if the code creates more than ELEMENT_HELPER_LIMIT elements, it is generated again with
- * the helper that creates them.
  */
 export declare function generateJs(program: ast.Program, options: JsOptions): string;

package/dist/codegen/js.js

@@ -1,31 +1,16 @@
 import { declarationsOf } from "./analysis.js";
 import { FunctionEmitter } from "./functions.js";
-import { startWorker } from "./go-helpers.js";
-import { HELPER_NEEDS, HELPERS } from "./helpers.js";
+import { moduleGo, runtimeCode, runtimeNames } from "./runtime.js";
 /** A component whose inlined copies add more lines than this to its module becomes a function. */
 export const INLINE_LIMIT = 100;
-/**
- * A module whose code creates more elements than this creates them with $$element, which takes
- * their attributes: its definition takes less than the statements it saves.
- */
-export const ELEMENT_HELPER_LIMIT = 20;
 /**
  * Generates a readable ES module from a program that has parsed without errors. A component is
  * inlined where it is used, unless that adds more than INLINE_LIMIT lines compared to a function
  * and its calls. The module is generated again with each such candidate as a function, and the one
  * that saves the most goes first: that changes the sizes of the components inside it. A component
  * of another module is a candidate too; its function is in that module, and counts as one copy.
- * Then, if the code creates more than ELEMENT_HELPER_LIMIT elements, it is generated again with
- * the helper that creates them.
  */
 export function generateJs(program, options) {
-    const { code, functions, elements } = chooseFunctions(program, options);
-    if (elements <= ELEMENT_HELPER_LIMIT)
-        return code;
-    return new JsGenerator(program, { ...options, functions, elementHelper: true }).generate();
-}
-/** The code with the components that become functions; see generateJs. */
-function chooseFunctions(program, options) {
     const functions = new Set();
     const generate = (names) => {
         const generator = new JsGenerator(program, { ...options, functions: names });
@@ -47,14 +32,13 @@ function chooseFunctions(program, options) {
             if (saved > INLINE_LIMIT && (!best || saved > best.saved))
                 best = { ...trial, name, saved };
         }
-        if (!best) {
-            return { code: current.code, functions, elements: current.generator.createdElements };
-        }
+        if (!best)
+            return current.code;
         functions.add(best.name);
         current = best;
     }
 }
-/** The whole module: its statements, plus the helpers that its code needs. */
+/** The whole module: its statements, plus the runtime that its code needs. */
 class JsGenerator extends FunctionEmitter {
     generate() {
         this.withScope(declarationsOf(this.program.body), () => {
@@ -63,51 +47,41 @@ class JsGenerator extends FunctionEmitter {
             this.hiddenExports();
         });
         const { goroutines } = this.options;
+        const inWorker = goroutines !== undefined && 'targets' in goroutines;
         // The worker module runs the functions that `go` calls (see goroutines.ts).
-        if (goroutines && 'targets' in goroutines) {
+        if (inWorker) {
             const names = goroutines.targets.map((name) => this.name(name));
-            this.helpers.add('serve');
             this.lines.push('', `const $$goroutines = { ${names.join(', ')} };`, '$$serve($$goroutines);');
         }
+        let imports = 0;
+        while (this.lines[imports]?.startsWith('import '))
+            imports++;
+        const rest = this.lines.slice(imports);
         // The CSS of the components goes before the code, so that the page has it before the markup.
         const styles = this.styleRegistrations();
-        let lines = this.lines;
-        if (styles.length > 0)
-            this.helpers.add('style');
-        if (this.helpers.size > 0) {
-            const needed = new Set();
-            const add = (helper) => {
-                if (needed.has(helper))
-                    return;
-                needed.add(helper);
-                for (const other of HELPER_NEEDS[helper] ?? [])
-                    add(other);
-            };
-            for (const helper of this.helpers)
-                add(helper);
-            const workerUrl = goroutines && 'workerUrl' in goroutines ? goroutines.workerUrl : '';
-            const helpers = [...needed]
-                .sort()
-                .flatMap((helper, i) => [
-                ...(i > 0 ? [''] : []),
-                ...HELPERS[helper],
-                ...(helper === 'go' ? ['', ...startWorker(workerUrl)] : []),
-            ]);
-            let imports = 0;
-            while (lines[imports]?.startsWith('import '))
-                imports++;
-            const rest = lines.slice(imports);
-            while (rest[0] === '')
-                rest.shift();
-            lines = [
-                ...lines.slice(0, imports),
-                ...(imports > 0 ? [''] : []),
-                ...helpers,
-                ...(styles.length > 0 ? ['', ...styles] : []),
-                ...(rest.length > 0 ? [''] : []),
-                ...rest,
-            ];
+        // 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 ?? ''))
+                : []),
+            ...(styles.length > 0 ? ['const $$styles = [];'] : []),
+        ];
+        const mode = this.options.runtime ?? 'import';
+        const runtime = runtimeCode(runtimeNames([...own, ...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`;
         }
-        return lines.length === 0 ? '' : `${lines.join('\n')}\n`;
+        while (rest[0] === '')
+            rest.shift();
+        // The import of the runtime goes with the other imports; the runtime itself, after them.
+        const head = this.lines.slice(0, imports);
+        const sections = [
+            mode === 'import' ? [...head, ...runtime] : head,
+            mode === 'inline' ? runtime : [],
+            own,
+            styles,
+            rest,
+        ].filter((section) => section.length > 0);
+        return `${sections.flatMap((section, i) => [...(i > 0 ? [''] : []), ...section]).join('\n')}\n`;
     }
 }

package/dist/codegen/parallel.js

@@ -4,7 +4,7 @@ import { declaredIn } from "../names.js";
 import { ControlStatementEmitter } from "./control-statements.js";
 import { ARROW } from "./syntax.js";
 // `go for i, v in items { ... }`: `await $$goFor("$$goroutine0", items, ...)` splits the array into
-// parts and runs each as a goroutine (go-helpers.ts). In the worker module, the function of a part
+// parts and runs each as a goroutine (src/runtime/go.js). In the worker module, the function of a part
 // loops over it: `i` is the index in the whole array, from `$$from`, the index of the part's first
 // element, and `items[i]` is `items[$$i]`, the index in the part. The part goes back if the body
 // writes into it; a typed array is moved back, not copied.
@@ -24,9 +24,7 @@ export class ParallelLoopEmitter extends ControlStatementEmitter {
             this.expression(node.iterable, ARROW),
             ...goCaptures(this.program, node).map((name) => this.name(name)),
         ];
-        this.helpers.add('goFor');
-        this.helpers.add(this.inWorker ? 'goLocal' : 'go');
-        this.line(`await $$goFor(${args.join(', ')});`);
+        this.line(`await $$goFor($$go, ${args.join(', ')});`);
     }
     /** The loop over a part, in the function of the worker module that runs it. */
     partLoop(node, loop) {

package/dist/codegen/refs.js

@@ -65,7 +65,6 @@ export class RefEmitter extends EarlyReturnEmitter {
             const scopeClass = scope && !hasClass(element) ? scope : null;
             let creation = { covered: new Set(), scoped: false };
             if (preset) {
-                this.createdElements++;
                 this.line(`const ${name} = ${preset.name} ?? ${this.createElement(tag, svg)};`);
             }
             else {

package/dist/codegen/runtime.d.ts

@@ -0,0 +1,13 @@
+/** 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>;
+/** 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. */
+export declare function runtimeCode(names: readonly string[], mode: RuntimeMode): string[];
+/**
+ * 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[];

package/dist/codegen/runtime.js

@@ -0,0 +1,93 @@
+import { RUNTIME_MODULE } from "../runtime-module.js";
+import { RUNTIME_FILES } from "../runtime/sources.js";
+/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
+export const PREDECLARED = new Set([
+    'after',
+    'cancel',
+    'close',
+    'stream',
+    'tick',
+    'transfer',
+]);
+/** A name of generated code, but not a member: `$$chan(...)`, and not `channel.$$chan`. */
+const NAME = /(?<![.\w$])\$\$[A-Za-z_][\w$]*/g;
+const files = new Map();
+const owners = new Map();
+for (const [file, source] of Object.entries(RUNTIME_FILES)) {
+    const needs = [...source.matchAll(/^import [^;]* from '\.\/(\w+\.js)';$/gm)].map((match) => match[1]);
+    for (const match of source.matchAll(/^export (?:async )?(?:function\*?|class|const|let) (\$\$\w+)/gm)) {
+        owners.set(match[1], file);
+    }
+    const code = source
+        .replace(/^import [^;]*;\n+/gm, '')
+        .replace(/^export /gm, '')
+        .trimEnd();
+    files.set(file, { code, needs });
+}
+/** The names of the runtime that code uses, in order. */
+export function runtimeNames(code) {
+    return [...new Set(code.match(NAME))].filter((name) => owners.has(name)).sort();
+}
+/** What gives a module these names of the runtime: an import, or the files that have them. */
+export function runtimeCode(names, mode) {
+    if (names.length === 0)
+        return [];
+    if (mode === 'import') {
+        const line = `import { ${names.join(', ')} } from "${RUNTIME_MODULE}";`;
+        return line.length <= 100
+            ? [line]
+            : ['import {', ...names.map((name) => `  ${name},`), `} from "${RUNTIME_MODULE}";`];
+    }
+    const needed = new Set();
+    const add = (file) => {
+        if (needed.has(file))
+            return;
+        needed.add(file);
+        for (const other of files.get(file).needs)
+            add(other);
+    };
+    for (const name of names)
+        add(owners.get(name));
+    // The files only declare, but for a few that register what a thread shares, so their order does
+    // not matter: the one of RUNTIME_FILES.
+    return [...files]
+        .filter(([file]) => needed.has(file))
+        .flatMap(([, { code }], i) => [...(i > 0 ? [''] : []), ...code.split('\n')]);
+}
+/**
+ * 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) {
+    if (workerUrl === null) {
+        return ['const $$go = (fn, args) => $$goHere($$goroutines, fn, args);'];
+    }
+    return [
+        ...startWorker(workerUrl),
+        '',
+        'const $$go = (name, args) => $$goWorker($$startWorker, name, args);',
+    ];
+}
+/**
+ * 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.
+ */
+function startWorker(url) {
+    const base = /^[a-z][a-z\d+.-]*:/i.test(url) ? '' : ', import.meta.url';
+    const workerUrl = `new URL(${JSON.stringify(url)}${base})`;
+    return [
+        'async function $$startWorker() {',
+        '  if (typeof Worker === "function") {',
+        `    return new Worker(${workerUrl}, { type: "module" });`,
+        '  }',
+        '  const threads = "node:worker_threads";',
+        '  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)};`;',
+        '  return new NodeWorker(new URL(`data:text/javascript,${encodeURIComponent(code)}`));',
+        '}',
+    ];
+}

package/dist/codegen/simple-statements.js

@@ -140,7 +140,6 @@ export class SimpleStatementEmitter extends CallEmitter {
             // Waits until the channel takes the value.
             case 'SendStatement': {
                 const channel = this.expression(node.channel, ARROW);
-                this.helpers.add('chan');
                 this.line(`await $$send(${channel}, ${this.expression(node.value, ARROW)});`);
                 break;
             }
@@ -190,6 +189,9 @@ export class SimpleStatementEmitter extends CallEmitter {
                     : undefined;
                 return typed === undefined ? '[]' : `new ${typed}()`;
             }
+            // An empty queue, as `[]` is an empty array.
+            case 'QueueType':
+                return 'new $$Queue()';
             case 'FuncType':
             case 'ComponentType':
             case 'ChanType':

package/dist/codegen/styles.d.ts

@@ -33,7 +33,7 @@ export declare abstract class StyleEmitter extends RefEmitter {
      */
     protected styleModuleImport(node: ast.ImportDeclaration): boolean;
     /**
-     * The objects of the CSS modules, and `$$style(id, css)` for them and for every style of a
+     * The objects of the CSS modules, and `$$style($$styles, id, css)` for them and for every style of a
      * component the module uses: modules first, so that components can override them.
      */
     protected styleRegistrations(): string[];

package/dist/codegen/styles.js

@@ -38,13 +38,13 @@ export class StyleEmitter extends RefEmitter {
         return true;
     }
     /**
-     * The objects of the CSS modules, and `$$style(id, css)` for them and for every style of a
+     * The objects of the CSS modules, and `$$style($$styles, id, css)` for them and for every style of a
      * component the module uses: modules first, so that components can override them.
      */
     styleRegistrations() {
         const register = (id, css) => {
             const text = css.replace(/[`\\]|\$\{/g, (match) => `\\${match}`);
-            return `$$style(${JSON.stringify(id)}, \`${text}\`);`;
+            return `$$style($$styles, ${JSON.stringify(id)}, \`${text}\`);`;
         };
         return [
             ...this.moduleObjects,

package/dist/codegen/web-components.js

@@ -22,7 +22,6 @@ export class WebComponentEmitter extends ComponentEmitter {
         }
     }
     webComponentClass(component) {
-        this.helpers.add('owner');
         const name = component.name.name;
         const className = `$$${name}Element`;
         const props = component.params.filter((param) => param.name.name !== 'children');

package/dist/compile.d.ts

@@ -1,5 +1,6 @@
 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 StyleModule } from './style-modules.ts';
 export interface CoreCompileOptions {
@@ -21,6 +22,12 @@ 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;
+    /**
+     * 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;
 }
 /**
  * Where the worker module of a module is: a `.worker.js` next to its `.js`, or, where `.rk`

package/dist/compile.js

@@ -41,6 +41,7 @@ export function compileModule(source, options = {}) {
         rewriteImports,
         types,
         styleModules,
+        runtime: options.runtime,
         ...importedCode(program, options.importModule),
     };
     const code = generateJs(program, {

package/dist/completion.js

@@ -17,7 +17,8 @@ const STRINGS = new Set([
     'CssText',
 ]);
 const VALUE_KEYWORDS = KEYWORDS.filter((keyword) => !RESERVED.has(keyword));
-const TYPE_KEYWORDS = ['func', 'comp', 'chan'];
+// `queue` is a type of its own only in a type: elsewhere it is a name.
+const TYPE_KEYWORDS = ['func', 'comp', 'chan', 'queue'];
 /** 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 = {}) {

package/dist/index.d.ts

@@ -21,6 +21,8 @@ export interface CompileOptions {
     workerUrl?: 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. */
+    runtime?: 'import' | 'inline';
 }
 export declare function compile(source: string, options?: CompileOptions): CompileResult;
 /**

package/dist/index.js

@@ -18,6 +18,7 @@ export function compile(source, options = {}) {
         workerUrl: options.workerUrl ?? workerUrl(filename ?? 'main.rk', rewriteImports),
         typeCheck: options.typeCheck ?? true,
         declarations: options.declarations ?? false,
+        runtime: options.runtime,
     });
 }
 /**

package/dist/loader.js

@@ -1,18 +1,19 @@
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { registerHooks } from 'node:module';
-import { join } from 'node:path';
+import { createRequire, registerHooks } from 'node:module';
+import { extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { isMainThread } from 'node:worker_threads';
-import { displayPath } from "./build.js";
-import { compileFile } from "./compile-file.js";
+import { RUNTIME_MODULE } from "./runtime-module.js";
 // `rook run` imports this module first (`node --import`): Node then imports `.rk` files,
 // compiled when they load, and `app.rk?goroutines` is the worker module of `go` in app.rk.
 // The worker threads of `go` import it too, since they get the `--import` of the process. The main
 // thread compiles a module before any worker needs it, so it leaves the code of each module and
 // of its worker module in ROOK_RUN_CACHE, a directory of the run, and the workers take it from
-// there: compiling again, with the types, would take each of them as long. ROOK_NO_CHECK turns
-// type checking off, and ROOK_MARKUP, 1 or 0, markup and components on or off for every file.
+// there: compiling again, with the types, would take each of them as long. So a worker does not
+// even load the compiler, which takes ~80 ms, unless a module is missing from the cache; the hooks
+// are synchronous, so it is loaded with require(). ROOK_NO_CHECK turns type checking off, and
+// ROOK_MARKUP, 1 or 0, markup and components on or off for every file.
 const typeCheck = process.env['ROOK_NO_CHECK'] === undefined;
 const markupSetting = process.env['ROOK_MARKUP'];
 const markup = markupSetting === undefined ? undefined : markupSetting === '1';
@@ -21,7 +22,17 @@ const cache = process.env['ROOK_RUN_CACHE'];
 function cached(url) {
     return cache ? join(cache, `${createHash('sha1').update(url).digest('hex')}.js`) : null;
 }
+// The compiled code imports the runtime of this compiler, wherever the program is.
+const runtime = import.meta.resolve(RUNTIME_MODULE);
+const require = createRequire(import.meta.url);
+// The files next to this one: .ts in src, .js in the dist of the package.
+const extension = extname(fileURLToPath(import.meta.url));
 registerHooks({
+    resolve(specifier, context, nextResolve) {
+        if (specifier === RUNTIME_MODULE)
+            return { url: runtime, shortCircuit: true };
+        return nextResolve(specifier, context);
+    },
     load(url, context, nextLoad) {
         const { protocol, pathname, search } = new URL(url);
         if (protocol !== 'file:' || !pathname.endsWith('.rk'))
@@ -31,6 +42,8 @@ registerHooks({
             return { format: 'module', source: readFileSync(file, 'utf8'), shortCircuit: true };
         }
         const moduleUrl = new URL(pathname, url).href;
+        const { displayPath } = require(`./build${extension}`);
+        const { compileFile } = require(`./compile-file${extension}`);
         const path = displayPath(fileURLToPath(moduleUrl));
         const result = compileFile(path, {
             rewriteImports: false,

package/dist/parser/base.d.ts

@@ -23,7 +23,7 @@ export declare abstract class ParserBase {
     protected abstract parseClass(start: number, exported: boolean): ast.ClassDeclaration;
     protected abstract parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
     protected abstract parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
-    protected abstract canStartType(): boolean;
+    protected abstract canStartType(offset?: number): boolean;
     protected abstract parseType(): ast.TypeNode;
     protected abstract parseTypeArgs(): ast.TypeNode[];
     protected abstract parseTypeMembers(): ast.TypeMember[];
@@ -35,6 +35,8 @@ export declare abstract class ParserBase {
     protected abstract parseArrayLiteral(): ast.ArrayLiteral;
     protected abstract parseConversion(): ast.ConversionExpression;
     protected abstract parseMake(): ast.MakeExpression;
+    protected abstract parseStreamChan(start: number): ast.StreamChanExpression;
+    protected abstract parseQueue(): ast.QueueExpression | null;
     protected abstract parseArrowFunction(async?: boolean): ast.ArrowFunction;
     protected abstract parseFuncExpression(async?: boolean): ast.FuncExpression;
     protected abstract parseIdentifier(what?: string): ast.Identifier;