rooklang 0.0.0-stage → 0.3.0

package/dist/codegen/statements.js

@@ -0,0 +1,142 @@
+import { isIterator } from "../iterators.js";
+import { decoratedName, moduleNamesOf } from "../decorators.js";
+import { inlinePackages } from "../inline-packages.js";
+import { packageExports } from "./imported.js";
+import { ParallelLoopEmitter } from "./parallel.js";
+import { ARROW, POSTFIX } from "./syntax.js";
+/**
+ * Imports and classes; with the layers below, all statements and declarations. A decorator of
+ * another module is not a value, but its code uses names of its module: the import brings them
+ * under hidden names, `import { $$visible$log } from "./visible.js"`, which that module exports.
+ * So does an inlined component of another module; a called one brings its function, `$$Card`.
+ */
+export class StatementEmitter extends ParallelLoopEmitter {
+    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);
+        const clauses = [];
+        if (node.defaultImport && used(node.defaultImport)) {
+            clauses.push(this.name(node.defaultImport.name));
+        }
+        if (node.namespaceImport && used(node.namespaceImport)) {
+            clauses.push(`* as ${this.name(node.namespaceImport.name)}`);
+        }
+        const named = node.namedImports
+            .filter((specifier) => used(specifier.local))
+            .map((specifier) => {
+            const local = this.name(specifier.local.name);
+            return specifier.imported.name === local ? local : `${specifier.imported.name} as ${local}`;
+        });
+        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 inlined = this.inlinedImports.get(specifier.local.name);
+            if (inlined) {
+                for (const [exported, local] of inlined.imports)
+                    hidden(exported, local);
+            }
+            else if (component) {
+                hidden(`$$${component.node.name.name}`, this.functionNames.get(component.node));
+            }
+            const decorator = this.options.decorators?.get(specifier.local.name);
+            if (!decorator || !this.appliedDecorators.has(specifier.local.name))
+                continue;
+            for (const name of decorator.moduleNames) {
+                named.push(decoratedName(decorator.node.name.name, name));
+            }
+            for (const [exported, local] of this.decoratorImports.get(specifier.local.name)?.imports ??
+                []) {
+                hidden(exported, local);
+            }
+        }
+        if (named.length > 0)
+            clauses.push(`{ ${named.join(', ')} }`);
+        const importsNames = node.defaultImport !== null || node.namespaceImport !== null || node.namedImports.length > 0;
+        if (importsNames && clauses.length === 0)
+            return;
+        const source = this.importPath(node.source);
+        this.line(clauses.length > 0 ? `import ${clauses.join(', ')} from ${source};` : `import ${source};`);
+    }
+    /**
+     * `export { log as $$visible$log }`: the names of the module that the code of exported
+     * decorators uses, and that of exported components when other modules inline them.
+     */
+    hiddenExports() {
+        const exports = new Map();
+        for (const statement of this.program.body) {
+            if (statement.kind !== 'DecoratorDeclaration' || !statement.exported)
+                continue;
+            for (const name of moduleNamesOf(statement, this.program)) {
+                exports.set(decoratedName(statement.name.name, name), this.name(name));
+            }
+        }
+        const packages = inlinePackages(this.program);
+        const decorators = [...packages.decorators].filter((entry) => entry[1] !== null);
+        for (const found of [packages.components, new Map(decorators)]) {
+            for (const [exported, local] of packageExports(found, (name) => this.name(name))) {
+                exports.set(exported, local);
+            }
+        }
+        if (exports.size === 0)
+            return;
+        const names = [...exports].map(([exported, local]) => exported === local ? exported : `${local} as ${exported}`);
+        this.blankLine();
+        this.line(`export { ${names.join(', ')} };`);
+    }
+    importPath(source) {
+        const path = source.value;
+        if (this.options.rewriteImports && /^\.{1,2}\//.test(path) && path.endsWith('.rk')) {
+            return JSON.stringify(`${path.slice(0, -'.rk'.length)}.js`);
+        }
+        return source.raw;
+    }
+    classDeclaration(node) {
+        const exported = node.exported ? 'export ' : '';
+        const superClass = node.superClass
+            ? ` extends ${this.expression(node.superClass, POSTFIX)}`
+            : '';
+        const body = this.block(() => {
+            let previous;
+            for (const member of node.members) {
+                const bothFields = previous?.kind === 'FieldDeclaration' && member.kind === 'FieldDeclaration';
+                if (previous && (!bothFields || this.blankLineBetween(previous, member)))
+                    this.blankLine();
+                this.classMember(member);
+                previous = member;
+            }
+        });
+        this.line(`${exported}class ${this.name(node.name.name)}${superClass} ${body}`);
+    }
+    /** Visibility modifiers are checked by the compiler and do not exist in the output. */
+    classMember(member) {
+        switch (member.kind) {
+            case 'FieldDeclaration': {
+                // Field values are part of the class body, where no statements can go.
+                const fieldValue = member.value;
+                const value = fieldValue
+                    ? this.withHoisting(false, () => this.expression(fieldValue, ARROW))
+                    : member.type
+                        ? this.zeroValue(member.type)
+                        : null;
+                const prefix = member.isStatic ? 'static ' : '';
+                this.line(`${prefix}${member.name.name}${value === null ? '' : ` = ${value}`};`);
+                break;
+            }
+            case 'ConstructorDeclaration': {
+                const [params, body] = this.func(member.params, member.body);
+                this.line(`constructor(${params}) ${body}`);
+                break;
+            }
+            case 'MethodDeclaration': {
+                const [params, body] = this.func(member.params, member.body);
+                const modifiers = `${member.isStatic ? 'static ' : ''}${member.async ? 'async ' : ''}`;
+                const star = isIterator(member.params) ? '*' : '';
+                this.line(`${modifiers}${star}${member.name.name}(${params}) ${body}`);
+                break;
+            }
+        }
+    }
+}

package/dist/codegen/styles.d.ts

@@ -0,0 +1,54 @@
+import type * as ast from '../ast.ts';
+import { type ComponentStyle } from '../styles.ts';
+import { RefEmitter } from './refs.ts';
+/**
+ * `style { ... }` of components and decorators. The elements of their own markup get the class of
+ * the style; the module adds the CSS of every style whose elements it creates with `$$style`, at
+ * its start; values from code are CSS variables, set on the element the component returns once
+ * it is created and again when what they read changes.
+ *
+ * Inlined code is a copy: of a decorator for the components it is applied to, of a component of
+ * another module. Copies are found by the nodes as written, `originOf`.
+ */
+/** The style of a component or a decorator as written. */
+interface Owner {
+    name: string;
+    style: ComponentStyle;
+}
+export declare abstract class StyleEmitter extends RefEmitter {
+    /** The styles by the elements and the `style` blocks of their own code; made on first use. */
+    private owners;
+    /** The styles whose elements the module creates, in the order of first use. */
+    protected readonly usedStyles: Set<Owner>;
+    /** The CSS modules the module imports: the objects of their classes, and their CSS. */
+    private readonly moduleObjects;
+    private readonly moduleStyles;
+    /** The CSS variables of the component being written, and whether its updates are added. */
+    private styleValues;
+    /** The class of the style an element of markup belongs to, if its owner has one. */
+    protected scopeOf(node: ast.ElementExpression): string | null;
+    /**
+     * `import styles from "./button.module.css"` becomes the object of its classes, and its CSS is
+     * added with the styles of the components.
+     */
+    protected styleModuleImport(node: ast.ImportDeclaration): boolean;
+    /**
+     * The objects of the CSS modules, and `$$style(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[];
+    /** Writes the code of a component, whose result is `result`, with its CSS variables. */
+    protected withStyles<T>(component: ast.ComponentDeclaration, result: string, emit: () => T): T;
+    /** Sets the CSS variables on the element the component created. */
+    protected setStyleValues(result: string): void;
+    /** The updates of the CSS variables go with those of what they read. */
+    protected registerStyleValues(): void;
+    private setValue;
+    /**
+     * The CSS variables of a component as it is inlined: its own `style` blocks and copies of those
+     * of its decorators, whose values are renamed for it.
+     */
+    private valuesOf;
+    private ownersByNode;
+}
+export {};

package/dist/codegen/styles.js

@@ -0,0 +1,157 @@
+import { originOf } from "../decorator-copy.js";
+import { componentStyle, ownElements, scopedCss, styleBlocks, } from "../styles.js";
+import { RefEmitter } from "./refs.js";
+export class StyleEmitter extends RefEmitter {
+    /** The styles by the elements and the `style` blocks of their own code; made on first use. */
+    owners = null;
+    /** The styles whose elements the module creates, in the order of first use. */
+    usedStyles = new Set();
+    /** The CSS modules the module imports: the objects of their classes, and their CSS. */
+    moduleObjects = [];
+    moduleStyles = [];
+    /** The CSS variables of the component being written, and whether its updates are added. */
+    styleValues = null;
+    /** The class of the style an element of markup belongs to, if its owner has one. */
+    scopeOf(node) {
+        const owner = this.ownersByNode().get(originOf(node));
+        if (!owner)
+            return null;
+        this.usedStyles.add(owner);
+        return owner.style.scope;
+    }
+    /**
+     * `import styles from "./button.module.css"` becomes the object of its classes, and its CSS is
+     * added with the styles of the components.
+     */
+    styleModuleImport(node) {
+        const module = this.options.styleModules?.get(node.source.value);
+        if (!module)
+            return false;
+        if (node.defaultImport) {
+            const fields = [...module.classes].map(([name, local]) => {
+                const key = /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+                return `${key}: ${JSON.stringify(local)}`;
+            });
+            this.moduleObjects.push(`const ${this.name(node.defaultImport.name)} = { ${fields.join(', ')} };`);
+        }
+        this.moduleStyles.push(module);
+        return true;
+    }
+    /**
+     * The objects of the CSS modules, and `$$style(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 [
+            ...this.moduleObjects,
+            ...this.moduleStyles.map((module) => register(`rook-module-${module.id}`, module.css)),
+            ...[...this.usedStyles].map(({ style }) => register(style.scope, scopedCss(style))),
+        ];
+    }
+    /** Writes the code of a component, whose result is `result`, with its CSS variables. */
+    withStyles(component, result, emit) {
+        const saved = this.styleValues;
+        const values = this.valuesOf(component);
+        this.styleValues = values.length > 0 ? { result, values, registered: false } : null;
+        try {
+            return emit();
+        }
+        finally {
+            this.styleValues = saved;
+        }
+    }
+    /** Sets the CSS variables on the element the component created. */
+    setStyleValues(result) {
+        for (const value of this.styleValues?.values ?? [])
+            this.line(this.setValue(result, value));
+    }
+    /** The updates of the CSS variables go with those of what they read. */
+    registerStyleValues() {
+        const { reactive, styleValues } = this;
+        if (!reactive || !styleValues || styleValues.registered)
+            return;
+        styleValues.registered = true;
+        for (const value of styleValues.values) {
+            const sources = new Set();
+            for (const part of value.declaration.value) {
+                if (typeof part !== 'number')
+                    continue;
+                for (const source of reactive.dependencies(value.values[part]))
+                    sources.add(source);
+            }
+            if (sources.size > 0)
+                reactive.depend(sources, this.setValue(styleValues.result, value));
+        }
+    }
+    setValue(result, { variable, declaration, values }) {
+        const { value } = declaration;
+        const only = value.length === 1 && typeof value[0] === 'number' ? value[0] : null;
+        const text = only !== null
+            ? this.liveExpression(values[only])
+            : `\`${value
+                .map((part) => typeof part === 'number'
+                ? `\${${this.liveExpression(values[part])}}`
+                : part.replace(/[`\\]|\$\{/g, (match) => `\\${match}`))
+                .join('')}\``;
+        return `${result}.style.setProperty(${JSON.stringify(variable)}, ${text});`;
+    }
+    /**
+     * The CSS variables of a component as it is inlined: its own `style` blocks and copies of those
+     * of its decorators, whose values are renamed for it.
+     */
+    valuesOf(component) {
+        const groups = new Map();
+        for (const block of styleBlocks(component.body)) {
+            const owner = this.ownersByNode().get(originOf(block));
+            if (owner)
+                groups.set(owner, [...(groups.get(owner) ?? []), block]);
+        }
+        return [...groups].flatMap(([owner, blocks]) => {
+            const body = { kind: 'BlockStatement', body: blocks, start: 0, end: 0 };
+            // The same text as the original: the same variables, with the values of this copy.
+            const copy = componentStyle(owner.name, body);
+            return [...copy.variables].map(([declaration, variable]) => ({
+                variable,
+                declaration,
+                values: copy.values,
+            }));
+        });
+    }
+    ownersByNode() {
+        if (this.owners)
+            return this.owners;
+        const owners = new Map();
+        const add = (node) => {
+            const style = componentStyle(node.name.name, node.body);
+            if (!style)
+                return;
+            const owner = { name: node.name.name, style };
+            for (const element of ownElements(node.body))
+                owners.set(element, owner);
+            for (const block of styleBlocks(node.body))
+                owners.set(block, owner);
+        };
+        for (const statement of this.program.body) {
+            if (statement.kind === 'ComponentDeclaration' || statement.kind === 'DecoratorDeclaration') {
+                add(statement);
+            }
+        }
+        // The code of other modules that is inlined here, as written there.
+        for (const source of [
+            ...(this.options.decorators?.values() ?? []),
+            ...(this.options.components?.values() ?? []),
+        ]) {
+            add(source.node);
+            for (const node of source.inline?.components.values() ?? [])
+                add(node);
+            for (const decorator of source.inline?.decorators.values() ?? [])
+                add(decorator.node);
+        }
+        this.owners = owners;
+        return owners;
+    }
+}

package/dist/codegen/syntax.d.ts

@@ -0,0 +1,18 @@
+import type * as ast from '../ast.ts';
+export declare const ARROW = 1;
+export declare const CONDITIONAL = 2;
+export declare const UNARY = 14;
+export declare const POSTFIX = 17;
+export declare const PRIMARY = 18;
+export declare const BINARY: Readonly<Record<ast.BinaryOperator, number>>;
+/** Names that Rook allows but strict-mode JS reserves; they get a `$` suffix. */
+export declare const JS_RESERVED: ReadonlySet<string>;
+/** Names that strict-mode JS can read but not declare. */
+export declare const JS_UNDECLARABLE: ReadonlySet<string>;
+/** `[a, , c]`; skipped (empty) elements at the end are dropped: `[q, ]` → `[q]`. */
+export declare function arrayPattern(elements: readonly string[]): string;
+/** A statement written at block level goes one level deeper into a function. */
+export declare function indentMore(text: string): string;
+/** `count` → `Count`, for generated names like `$$updateCount3`. */
+export declare function upperFirst(name: string): string;
+export declare function lowerFirst(name: string): string;

package/dist/codegen/syntax.js

@@ -0,0 +1,70 @@
+// Facts about the JS syntax that the generated code must respect.
+// Operator precedence: an operand whose precedence is lower than required gets parentheses.
+export const ARROW = 1;
+export const CONDITIONAL = 2;
+export const UNARY = 14;
+export const POSTFIX = 17;
+export const PRIMARY = 18;
+export const BINARY = {
+    '??': 3,
+    '||': 3,
+    '&&': 4,
+    '|': 5,
+    '^': 6,
+    '&': 7,
+    '==': 8,
+    '!=': 8,
+    '<': 9,
+    '>': 9,
+    '<=': 9,
+    '>=': 9,
+    instanceof: 9,
+    '<<': 10,
+    '>>': 10,
+    '>>>': 10,
+    '+': 11,
+    '-': 11,
+    '*': 12,
+    '/': 12,
+    '%': 12,
+    '**': 13,
+};
+/** Names that Rook allows but strict-mode JS reserves; they get a `$` suffix. */
+export const JS_RESERVED = new Set([
+    'debugger',
+    'delete',
+    'do',
+    'enum',
+    'function',
+    'implements',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+/** Names that strict-mode JS can read but not declare. */
+export const JS_UNDECLARABLE = new Set(['eval', 'arguments']);
+/** `[a, , c]`; skipped (empty) elements at the end are dropped: `[q, ]` → `[q]`. */
+export function arrayPattern(elements) {
+    let end = elements.length;
+    while (end > 0 && elements[end - 1] === '')
+        end--;
+    return `[${elements.slice(0, end).join(', ')}]`;
+}
+/** A statement written at block level goes one level deeper into a function. */
+export function indentMore(text) {
+    return text.replace(/\n/g, '\n  ');
+}
+/** `count` → `Count`, for generated names like `$$updateCount3`. */
+export function upperFirst(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+export function lowerFirst(name) {
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}

package/dist/codegen/thread-helpers.d.ts

@@ -0,0 +1,2 @@
+export type ThreadHelper = 'threads';
+export declare const THREAD_HELPERS: Readonly<Record<ThreadHelper, readonly string[]>>;

package/dist/codegen/thread-helpers.js

@@ -0,0 +1,198 @@
+// What threads share: a channel is data, `{ $$chan: id, size, zero }`, copied to other threads like
+// any value, and what it holds lives in the thread that made it, whose key starts its id. Each
+// thread has a registry of its channels and of its ports to the other threads, shared by its
+// modules; the operations of a thread on the channels of another go straight to that thread
+// through a MessagePort, which the main thread sets up on the first need (go-helpers.ts).
+export const THREAD_HELPERS = {
+    threads: [
+        '// The state of this thread that its modules share: the channels it made, its ports to the other',
+        '// threads by their keys, and the requests that wait for an answer.',
+        'function $$registry() {',
+        '  return (globalThis[Symbol.for("rook.threads")] ??= {',
+        '    key: Math.random().toString(36).slice(2),',
+        '    channels: 0,',
+        '    states: new Map(),',
+        '    held: new FinalizationRegistry((id) => $$hold(id, -1)),',
+        '    ports: new Map(),',
+        '    pins: new Map(),',
+        '    idle: null,',
+        '    waiting: new Map(),',
+        '    gone: new Set(),',
+        '    main: null,',
+        '    requests: new Map(),',
+        '    asks: 0,',
+        '    selects: new Map(),',
+        '    moved: new WeakSet(),',
+        '    cancels: new WeakMap(),',
+        '    handle: null,',
+        '  });',
+        '}',
+        '',
+        '// The key of the thread that made a channel, which keeps what it holds.',
+        'function $$ownerOf(id) {',
+        '  return id.slice(0, id.lastIndexOf(":"));',
+        '}',
+        '',
+        '// Sends a message to a thread. The channels in it are counted first, as the thread gets copies,',
+        '// and the buffers of transfer() move there. A message waits for the port of a thread that has just',
+        '// started.',
+        'function $$post(key, message) {',
+        '  const registry = $$registry();',
+        '  if (registry.gone.has(key)) return;',
+        '  const { channels, moved } = $$walk(message);',
+        '  for (const channel of channels) $$hold(channel.$$chan, 1);',
+        '  const port = registry.ports.get(key);',
+        '  if (port) return port.postMessage(message, moved);',
+        '  if (!registry.waiting.has(key)) registry.waiting.set(key, []);',
+        '  registry.waiting.get(key).push([message, moved]);',
+        '}',
+        '',
+        '// A request to a thread, answered by a message with its number.',
+        'function $$ask(key, message) {',
+        '  const registry = $$registry();',
+        '  if (registry.gone.has(key)) return Promise.reject($$stopped());',
+        '  $$pin(key, 1);',
+        '  return new Promise((resolve, reject) => {',
+        '    const ask = registry.asks++;',
+        '    registry.requests.set(ask, { resolve, reject, key });',
+        '    $$post(key, { ...message, ask });',
+        '  });',
+        '}',
+        '',
+        '// A thread that this one waits for keeps the program running: in Node, its worker or port is',
+        '// referenced while some request or select waits for it.',
+        'function $$pin(key, count) {',
+        '  const registry = $$registry();',
+        '  const pins = (registry.pins.get(key) ?? 0) + count;',
+        '  registry.pins.set(key, pins);',
+        '  const port = registry.ports.get(key);',
+        '  if (pins > 0) port?.ref?.();',
+        '  else if (registry.idle) registry.idle(key);',
+        '  else port?.unref?.();',
+        '}',
+        '',
+        'function $$stopped() {',
+        '  return new Error("the goroutine that made the channel has stopped");',
+        '}',
+        '',
+        '// A port to a thread: messages that waited for it go now.',
+        'function $$connect(key, port, listen) {',
+        '  const registry = $$registry();',
+        '  registry.ports.set(key, port);',
+        '  if (registry.pins.get(key) > 0) port.ref?.();',
+        '  if (listen) {',
+        '    const receive = (data) => $$incoming(key, data);',
+        '    if (port.on) {',
+        '      port.on("message", receive);',
+        '      if (!(registry.pins.get(key) > 0)) port.unref?.();',
+        '    } else {',
+        '      port.onmessage = (event) => receive(event.data);',
+        '    }',
+        '  }',
+        '  for (const [message, moved] of registry.waiting.get(key) ?? []) port.postMessage(message, moved);',
+        '  registry.waiting.delete(key);',
+        '}',
+        '',
+        '// A thread has stopped: what waits for it fails, and what it waited for is dropped.',
+        'function $$gone(key) {',
+        '  const registry = $$registry();',
+        '  registry.gone.add(key);',
+        '  registry.ports.get(key)?.close?.();',
+        '  registry.ports.delete(key);',
+        '  registry.waiting.delete(key);',
+        '  for (const [ask, request] of registry.requests) {',
+        '    if (request.key !== key) continue;',
+        '    registry.requests.delete(ask);',
+        '    request.reject($$stopped());',
+        '  }',
+        '  for (const [id, state] of registry.states) {',
+        '    const alive = (entry) => (entry.select?.key ?? entry.from) !== key;',
+        '    state.receivers = state.receivers.filter(alive);',
+        '    state.senders = state.senders.filter(alive);',
+        '    registry.handle?.pump(id);',
+        '  }',
+        '}',
+        '',
+        '// A message from another thread: an answer to a request, or an operation on a channel of this one.',
+        'function $$incoming(key, data) {',
+        '  const registry = $$registry();',
+        '  $$adopt(data);',
+        '  if ("answer" in data) {',
+        '    const request = registry.requests.get(data.answer);',
+        '    registry.requests.delete(data.answer);',
+        '    if (request) $$pin(request.key, -1);',
+        '    if ("error" in data) request?.reject(data.error);',
+        '    else request?.resolve(data.value);',
+        '  } else if (data.op === "hold") {',
+        '    $$hold(data.channel, data.count);',
+        '  } else if ("op" in data) {',
+        '    registry.handle.message(key, data);',
+        '  }',
+        '}',
+        '',
+        '// Each value of a channel, in any thread, holds it: the thread that made it forgets it when none',
+        '// is left. A thread counts the channels of a value before a copy of it goes to another thread, and',
+        '// a copy lets go of them when it is collected.',
+        'function $$hold(id, count) {',
+        '  const registry = $$registry();',
+        '  const owner = $$ownerOf(id);',
+        '  if (owner !== registry.key) return $$post(owner, { op: "hold", channel: id, count });',
+        '  const state = registry.states.get(id);',
+        '  if (!state) return;',
+        '  state.holders += count;',
+        '  if (state.holders <= 0) registry.states.delete(id);',
+        '}',
+        '',
+        'function $$adopt(value) {',
+        '  const { held } = $$registry();',
+        '  for (const channel of $$walk(value).channels) held.register(channel, channel.$$chan);',
+        '}',
+        '',
+        '// A copy in this thread. One that `own` the runtime, such as the arguments of `go` that wait for',
+        '// a worker, moves its buffers on.',
+        'function $$copy(value, own = false) {',
+        '  const { channels, moved } = $$walk(value);',
+        '  for (const channel of channels) $$hold(channel.$$chan, 1);',
+        '  const copy = structuredClone(value, { transfer: moved });',
+        '  const { held } = $$registry();',
+        '  for (const channel of $$walk(copy, own).channels) held.register(channel, channel.$$chan);',
+        '  return copy;',
+        '}',
+        '',
+        '// `transfer(x)`: the buffer of x moves to the thread that a value with it goes to, instead of a',
+        '// copy; here it is left empty.',
+        'function $$transfer(value) {',
+        '  $$registry().moved.add(ArrayBuffer.isView(value) ? value.buffer : value);',
+        '  return value;',
+        '}',
+        '',
+        '// The channels in a value, each of which becomes a copy in the thread that gets the value, and the',
+        '// buffers that move there.',
+        'function $$walk(value, own = false, found = { channels: new Set(), moved: [] }, seen = new Set()) {',
+        '  if (typeof value !== "object" || value === null || seen.has(value)) return found;',
+        '  seen.add(value);',
+        '  const buffer =',
+        '    value instanceof ArrayBuffer ? value : ArrayBuffer.isView(value) ? value.buffer : null;',
+        '  // A SharedArrayBuffer is shared with the other thread, not moved.',
+        '  if (buffer && !(buffer instanceof ArrayBuffer)) return found;',
+        '  if (buffer) {',
+        '    const { moved } = $$registry();',
+        '    if (own) moved.add(buffer);',
+        '    if (moved.has(buffer) && !found.moved.includes(buffer)) found.moved.push(buffer);',
+        '    return found;',
+        '  }',
+        '  if (typeof value.$$chan === "string") {',
+        '    found.channels.add(value);',
+        '    return found;',
+        '  }',
+        '  const items =',
+        '    value instanceof Map',
+        '      ? [...value.keys(), ...value.values()]',
+        '      : value instanceof Set || Array.isArray(value)',
+        '        ? value',
+        '        : Object.values(value);',
+        '  for (const item of items) $$walk(item, own, found, seen);',
+        '  return found;',
+        '}',
+    ],
+};