rooklang 0.3.1 → 0.3.2

package/dist/checker/untyped-globals.js

@@ -0,0 +1,47 @@
+// JS globals that the checker knows by name only, without types: everything about them is `any`.
+// With TypeScript's lib files (in Node) the library types them; the browser compiler of the
+// playground has only these names.
+export const UNTYPED_GLOBALS = [
+    'Object',
+    'Array',
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Symbol',
+    'Reflect',
+    'Proxy',
+    'Intl',
+    'globalThis',
+    'process',
+    'Buffer',
+    'URL',
+    'URLSearchParams',
+    'TextEncoder',
+    'TextDecoder',
+    // Streams, and what makes them: chan(stream) and stream(ch) work with them.
+    'ReadableStream',
+    'WritableStream',
+    'TransformStream',
+    'TextEncoderStream',
+    'TextDecoderStream',
+    'Blob',
+    'Response',
+    'Request',
+    'Headers',
+    'AbortController',
+    'fetch',
+    'structuredClone',
+    'queueMicrotask',
+    'window',
+    'document',
+    'navigator',
+    'location',
+    'localStorage',
+    'sessionStorage',
+    'crypto',
+    'performance',
+];

package/dist/codegen/attributes.js

@@ -88,7 +88,6 @@ export class AttributeEmitter extends UpdateEmitter {
             this.setLive(live, value, (text) => `${element}.setAttribute(${quoted}, ${text});`);
         }
         else if (live && live.dependencies(value).size > 0) {
-            this.helpers.add('attribute');
             this.setLive(live, value, (text) => `$$attribute(${element}, ${quoted}, ${text});`);
         }
         else {

package/dist/codegen/calls.d.ts

@@ -19,4 +19,13 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
      */
     protected make(node: ast.MakeExpression): string;
     protected conversion(node: ast.ConversionExpression): string;
+    /** `chan<number>(10)`: the channel keeps the zero value that a closed one gives. */
+    protected chan(node: ast.ChanExpression): string;
+    /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
+    protected queue(node: ast.QueueExpression): string;
+    /**
+     * `chan(stream, size)`: the channel keeps the zero value of its values, as `chan<T>(size)` does,
+     * from the type of the stream that the checker found; without it, null.
+     */
+    protected streamChan(node: ast.StreamChanExpression): string;
 }

package/dist/codegen/calls.js

@@ -97,10 +97,50 @@ export class CallEmitter extends ExpressionEmitter {
         const bytes = size === 1
             ? this.expression(node.length, ARROW)
             : `${size} * ${this.expression(node.length, BINARY['*'] + 1)}`;
-        this.helpers.add('shared');
         return `new ${typed}($$shared(${bytes}))`;
     }
     conversion(node) {
         return `new TextEncoder().encode(${this.expression(node.argument, 0)})`;
     }
+    /** `chan<number>(10)`: the channel keeps the zero value that a closed one gives. */
+    chan(node) {
+        const size = node.size ? this.expression(node.size, ARROW) : '0';
+        return `$$chan(${size}, ${this.zeroValue(node.element) ?? 'null'})`;
+    }
+    /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
+    queue(node) {
+        return `new $$Queue(${node.items ? this.expression(node.items, ARROW) : ''})`;
+    }
+    /**
+     * `chan(stream, size)`: the channel keeps the zero value of its values, as `chan<T>(size)` does,
+     * from the type of the stream that the checker found; without it, null.
+     */
+    streamChan(node) {
+        const stream = this.expression(node.stream, ARROW);
+        const size = node.size ? this.expression(node.size, ARROW) : '0';
+        const type = this.options.types?.get(node);
+        const channel = type?.kind === 'tuple' ? type.types[0] : undefined;
+        const element = channel?.kind === 'object' ? channel.instanceOf?.args[0] : undefined;
+        return `$$fromStream(${stream}, ${size}, ${element ? zeroOf(element) : 'null'})`;
+    }
+}
+/** The zero value of a type, as zeroValue gives for a type as written. */
+function zeroOf(type) {
+    const typed = typedArrayOf(type);
+    if (typed !== null)
+        return `new ${typed}()`;
+    switch (type.kind) {
+        case 'number':
+            return '0';
+        case 'bigint':
+            return '0n';
+        case 'string':
+            return '""';
+        case 'bool':
+            return 'false';
+        case 'array':
+            return '[]';
+        default:
+            return 'null';
+    }
 }

package/dist/codegen/component-values.js

@@ -52,7 +52,6 @@ export class ComponentValueEmitter extends ComponentPropsEmitter {
         finally {
             this.fixedComponents.delete(node);
         }
-        this.helpers.add('dynamic');
         this.line(`const [${name}, ${update}] = $$dynamic(${this.liveFunction(value)}, ${create});`);
         live.depend(live.dependencies(node), `${update}();`);
         return name;

package/dist/codegen/components.js

@@ -78,7 +78,6 @@ export class ComponentEmitter extends StyleEmitter {
      * it changes updates the markup.
      */
     mountStatement(node) {
-        this.helpers.add('mount');
         this.inHandler++;
         try {
             const [, body] = this.withRendering(0, () => this.func([], node.body));

package/dist/codegen/control-flow.js

@@ -26,19 +26,16 @@ export class ControlFlowEmitter extends ElementEmitter {
                 const [choose, blocks] = statement.kind === 'IfStatement'
                     ? this.ifBranches(statement, live)
                     : this.switchBranches(statement, live);
-                this.helpers.add('branches');
                 call = `$$branches(${choose}, [${blocks.join(', ')}])`;
                 break;
             }
             case 'ForInStatement': {
-                this.helpers.add('list');
                 const items = this.liveFunction(statement.iterable);
                 call = `$$list(${items}, ${this.blockCreator(statement.body.body, live, statement)})`;
                 break;
             }
             case 'ForStatement':
                 // Without items to find the blocks by, the loop runs again and creates new content.
-                this.helpers.add('content');
                 call = `$$content(${this.loopContent(statement)})`;
                 break;
         }

package/dist/codegen/control-statements.js

@@ -53,7 +53,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             case 'ExpressionStatement':
                 return this.expression(node.expression, 0);
             case 'SendStatement':
-                this.helpers.add('chan');
                 return `await $$send(${this.expression(node.channel, ARROW)}, ${this.expression(node.value, ARROW)})`;
         }
     }
@@ -71,7 +70,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             let head;
             // A channel gives its values as they come, until it is closed.
             if (iterable && isChan(iterable)) {
-                this.helpers.add('chan');
                 this.line(`for await (const ${value} of $$range(${this.expression(node.iterable, ARROW)})) ${this.loopBody(node.body)}`);
                 return;
             }
@@ -92,7 +90,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 if (iterable && isMap(iterable))
                     values += '.values()';
                 else if (untyped) {
-                    this.helpers.add('values');
                     values = `$$values(${values})`;
                 }
                 head = `const ${value} of ${values}`;
@@ -140,7 +137,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
      * switch runs the case; a `break` inside it leaves the select, as in Go. `default` is -1.
      */
     selectStatement(node) {
-        this.helpers.add('chan');
         const operations = node.cases.flatMap(({ operation }) => {
             if (operation === null)
                 return [];

package/dist/codegen/creation.d.ts

@@ -2,11 +2,11 @@ import type * as ast from '../ast.ts';
 import { AttributeEmitter } from './attributes.ts';
 import type { Live } from './reactive.ts';
 /**
- * The creation of elements. In a module that creates many of them (see ELEMENT_HELPER_LIMIT in
- * js.ts) an element is created by a helper together with the attributes it has from the start:
- * `$$element("a", { href: "/", className: "link" }, { "aria-label": label })` takes the place of
- * a `createElement` and a statement for each attribute. The first object holds properties, the
- * second attributes set with setAttribute; an SVG element has only attributes.
+ * The creation of elements. An element is created by a function of the runtime together with the
+ * attributes it has from the start: `$$element("a", { href: "/", className: "link" },
+ * { "aria-label": label })` takes the place of a `createElement` and a statement for each
+ * attribute. The first object holds properties, the second attributes set with setAttribute; an
+ * SVG element has only attributes.
  */
 /** Attributes given to the helper that creates an element, which need no statements of their own. */
 export interface Creation {
@@ -15,10 +15,8 @@ export interface Creation {
     scoped: boolean;
 }
 export declare abstract class CreationEmitter extends AttributeEmitter {
-    /** The elements the code creates, counted where it creates them, not as often as it runs. */
-    createdElements: number;
     /**
-     * Writes `declaration = <a new element>`. With the helper it is given the attributes before the
+     * Writes `declaration = <a new element>`. It is given the attributes before the
      * first spread, which may override them, except those that need more than a value: handlers,
      * `bind:`, styles, properties of web components and attributes that may be null. `scopeClass`
      * is the class of the style for an element without a class attribute.

package/dist/codegen/creation.js

@@ -2,21 +2,14 @@ import { domProperty } from "../checker/dom.js";
 import { AttributeEmitter } from "./attributes.js";
 import { ARROW } from "./syntax.js";
 export class CreationEmitter extends AttributeEmitter {
-    /** The elements the code creates, counted where it creates them, not as often as it runs. */
-    createdElements = 0;
     /**
-     * Writes `declaration = <a new element>`. With the helper it is given the attributes before the
+     * Writes `declaration = <a new element>`. It is given the attributes before the
      * first spread, which may override them, except those that need more than a value: handlers,
      * `bind:`, styles, properties of web components and attributes that may be null. `scopeClass`
      * is the class of the style for an element without a class attribute.
      */
     createWith(declaration, element, tag, svg, attributes, live, scope, scopeClass) {
         const covered = new Set();
-        this.createdElements++;
-        if (!this.options.elementHelper) {
-            this.line(`${declaration} = ${this.createElement(tag, svg)};`);
-            return { covered, scoped: false };
-        }
         const entries = [];
         for (const attribute of attributes) {
             if (attribute.kind === 'JsxSpreadAttribute')
@@ -48,13 +41,11 @@ export class CreationEmitter extends AttributeEmitter {
         const attributesObject = object(true);
         const args = [JSON.stringify(tag)];
         if (svg) {
-            this.helpers.add('svgElement');
             if (attributesObject)
                 args.push(attributesObject);
             this.line(`${declaration} = $$svgElement(${args.join(', ')});`);
         }
         else {
-            this.helpers.add('element');
             if (properties || attributesObject)
                 args.push(properties ?? '{}');
             if (attributesObject)

package/dist/codegen/early-returns.js

@@ -94,7 +94,6 @@ export class EarlyReturnEmitter extends ComponentValueEmitter {
             this.line(`${effect.name}();`);
             if (effect.cleanups === null)
                 continue;
-            this.helpers.add('owner');
             this.line(`$$onRemove(() => $$runDeferred(${effect.cleanups}.splice(0)));`);
         }
     }

package/dist/codegen/elements.js

@@ -93,7 +93,6 @@ export class ElementEmitter extends CreationEmitter {
                 this.line(`${target} = document.createDocumentFragment();`);
             }
             else if (preset) {
-                this.createdElements++;
                 this.line(`${target} = ${preset.name} ?? ${this.createElement(tag, svg)};`);
             }
             else {
@@ -217,7 +216,6 @@ export class ElementEmitter extends CreationEmitter {
                         }
                         case 'unknown':
                             flush();
-                            this.helpers.add('append');
                             this.line(`$$append(${element}, ${this.expression(expression, ARROW)});`);
                             break;
                     }
@@ -258,7 +256,6 @@ export class ElementEmitter extends CreationEmitter {
         }
         const name = `$$content${id}`;
         const update = `$$updateContent${id}`;
-        this.helpers.add('content');
         this.line(`const [${name}, ${update}] = $$content(${this.liveFunction(expression)});`);
         live.depend(sources, `${update}();`);
         return name;

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,15 @@
+/** Where compiled code imports the runtime from. */
+export declare const RUNTIME_MODULE = "rooklang/runtime";
+/** How a module gets the runtime: by an import, or with the code of the runtime in it. */
+export type RuntimeMode = 'import' | 'inline';
+/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
+export declare const PREDECLARED: ReadonlySet<string>;
+/** 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[];