rooklang 0.3.2 → 0.3.4

package/dist/checker/flow.js

@@ -1,4 +1,4 @@
-import { containsBreak } from "../walk.js";
+import { containsBreak } from "../breaks.js";
 import { BIGINT, BOOL, isNullable, nonNull, NULL, NUMBER, STRING, typesEqual, union, unionMembers, } from "./types.js";
 // Control flow for the checker: how conditions narrow the types of variables, and which statements
 // execution never continues after.
@@ -96,18 +96,22 @@ export function isTerminating(node) {
         case 'IfStatement':
             return (node.alternate !== null && isTerminating(node.consequent) && isTerminating(node.alternate));
         case 'ForStatement':
-            return node.condition === null && !containsBreak(node.body.body);
+            return node.condition === null && !containsBreak(node.body.body, node.label ?? null);
         case 'SwitchStatement':
             return (node.cases.some((switchCase) => switchCase.tests.length === 0) &&
                 node.cases.every((switchCase) => {
                     const last = switchCase.body.at(-1);
-                    return last !== undefined && isTerminating(last) && !containsBreak(switchCase.body);
+                    return (last !== undefined &&
+                        isTerminating(last) &&
+                        !containsBreak(switchCase.body, node.label ?? null));
                 }));
         // A select runs one of its cases, waiting for one if there is no default.
         case 'SelectStatement':
             return node.cases.every((selectCase) => {
                 const last = selectCase.body.at(-1);
-                return last !== undefined && isTerminating(last) && !containsBreak(selectCase.body);
+                return (last !== undefined &&
+                    isTerminating(last) &&
+                    !containsBreak(selectCase.body, node.label ?? null));
             });
         case 'TryStatement':
             return ((isTerminating(node.block) && (!node.handler || isTerminating(node.handler.body))) ||

package/dist/checker/helpers.d.ts

@@ -26,7 +26,7 @@ export declare function callSignature(type: Type): FunctionType | null;
 /** Whether the expected type has literal members: then a literal gets a literal type. */
 export declare function expectsLiteral(expected: Type | null): boolean;
 export declare function countValues(count: number): string;
-/** A call, or `await` of a call or of `go`: it may give several values. */
+/** A call, `decode<T>(x)`, `try`, or `await` of a call or of `go`: it may give several values. */
 export declare function isCall(node: ast.Expression): boolean;
 /** How to name an expression in messages: `divide()`, `stats.minMax()`, or `this expression`. */
 export declare function callName(node: ast.Expression): string;

package/dist/checker/helpers.js

@@ -123,12 +123,15 @@ export function countValues(count) {
         return 'no values';
     return count === 1 ? '1 value' : `${count} values`;
 }
-/** A call, or `await` of a call or of `go`: it may give several values. */
+/** A call, `decode<T>(x)`, `try`, or `await` of a call or of `go`: it may give several values. */
 export function isCall(node) {
     if (node.kind === 'UnaryExpression' && node.operator === 'await') {
         return node.argument.kind === 'CallExpression' || node.argument.kind === 'GoExpression';
     }
-    return node.kind === 'CallExpression';
+    // `return decode<User>(body)` and `return try f()` pass on the value and the error.
+    return (node.kind === 'CallExpression' ||
+        node.kind === 'DecodeExpression' ||
+        node.kind === 'TryExpression');
 }
 /** How to name an expression in messages: `divide()`, `stats.minMax()`, or `this expression`. */
 export function callName(node) {
@@ -139,6 +142,10 @@ export function callName(node) {
         return callName(node.call);
     if (node.kind === 'StreamChanExpression')
         return 'chan(stream)';
+    if (node.kind === 'DecodeExpression')
+        return 'decode';
+    if (node.kind === 'TryExpression')
+        return 'try';
     if (node.kind !== 'CallExpression')
         return 'this expression';
     const { callee } = node;

package/dist/checker/iterables.d.ts

@@ -1,5 +1,7 @@
-import type { ObjectType, Type } from './types.ts';
+import { type ObjectType, type Type } from './types.ts';
 /** `Map<K, V>` or `ReadonlyMap<K, V>`: `for key, value in m`, and `for value in m` for the values. */
 export declare function isMap(type: Type): boolean;
 /** The key and the value of `for key, value in x`: of a Map, or of an array-like with positions. */
 export declare function loopEntry(type: ObjectType): [Type, Type] | null;
+/** What `for v in x` waits for, of an async iterable that cannot be gone over at once, or null. */
+export declare function asyncIterated(type: Type): Type | null;

package/dist/checker/iterables.js

@@ -1,5 +1,8 @@
+import { bindParams, substitute } from "./types.js";
 // What `for ... in` goes over besides arrays, strings and channels: the iterables of the lib files,
 // whose values come from `[Symbol.iterator]()`. A Map gives its keys and values, as a map in Go.
+// An async iterable, such as a stream of Node, gives the values that the Promises of
+// `[Symbol.asyncIterator]()` give, and the loop waits for them, as `for await` of JS.
 /** `Map<K, V>` or `ReadonlyMap<K, V>`: `for key, value in m`, and `for value in m` for the values. */
 export function isMap(type) {
     const name = type.kind === 'object' ? (type.instanceOf?.template.name ?? type.name) : null;
@@ -15,3 +18,13 @@ export function loopEntry(type) {
     // A typed array or a NodeList has positions, and `entries()`, as an array has.
     return numberIndex && type.members.has('entries') ? [{ kind: 'number' }, iterates] : null;
 }
+/** What `for v in x` waits for, of an async iterable that cannot be gone over at once, or null. */
+export function asyncIterated(type) {
+    if (type.kind === 'object')
+        return type.iterates ? null : (type.asyncIterates ?? null);
+    if (type.kind !== 'class' || !type.info.asyncIterates)
+        return null;
+    // TypeScript lists inherited members with the type arguments of the base class already.
+    const { info } = type;
+    return substitute(info.asyncIterates, bindParams(info.typeParams, type.args ?? info.typeParams));
+}

package/dist/checker/iterators.d.ts

@@ -8,6 +8,9 @@ export declare abstract class IteratorChecker extends GoForChecker {
     /** The rules of iterators in the whole program; Checker.run calls it. */
     protected checkIterators(): void;
     private checkIterator;
-    /** Where `yield` is used in the body of an iterator; `nested` inside a function in it. */
+    /**
+     * Where `yield` is used in the body of an iterator: `nested` inside a function in it, or in `try`,
+     * which compiles to a function that runs its expression (codegen/try.ts).
+     */
     private checkYields;
 }

package/dist/checker/iterators.js

@@ -68,14 +68,21 @@ export class IteratorChecker extends GoForChecker {
         if (!yieldsBool) {
             this.error('the yield of an iterator is func(T) bool or func(K, V) bool, e.g. func(yield func(number) bool)', type ?? param);
         }
-        this.checkYields(node.body, false);
+        if (node.body)
+            this.checkYields(node.body, false);
     }
-    /** Where `yield` is used in the body of an iterator; `nested` inside a function in it. */
+    /**
+     * Where `yield` is used in the body of an iterator: `nested` inside a function in it, or in `try`,
+     * which compiles to a function that runs its expression (codegen/try.ts).
+     */
     checkYields(node, nested) {
         if (isYieldCall(node)) {
-            if (nested) {
+            if (nested === 'function') {
                 this.error('yield is called in a function inside the iterator: a JS generator yields only in its own body, so loop there, e.g. for x in items { if !yield(x) { return } }', node.callee);
             }
+            else if (nested === 'try') {
+                this.error('yield cannot be in try, which compiles to a function: a JS generator yields only in its own body, so call yield outside of it', node.callee);
+            }
             for (const argument of node.arguments)
                 this.checkYields(argument, nested);
             return;
@@ -89,7 +96,8 @@ export class IteratorChecker extends GoForChecker {
             isIterator(node.params)) {
             return;
         }
-        const inner = nested || NESTED.has(node.kind);
+        const inner = nested ||
+            (NESTED.has(node.kind) ? 'function' : node.kind === 'TryExpression' ? 'try' : false);
         forEachChild(node, (child) => this.checkYields(child, inner));
     }
 }

package/dist/checker/json.d.ts

@@ -0,0 +1,5 @@
+import { type Type } from './types.ts';
+/** Why a value of the type cannot come from JSON, or null if it can. */
+export declare function notDecoded(type: Type, seen?: Set<Type>): string | null;
+/** Whether a value of the type is always a string: then decode reads it as JSON text. */
+export declare function isText(type: Type): boolean;

package/dist/checker/json.js

@@ -0,0 +1,92 @@
+import { isQueue, isTopic, memberNames, typedArrayOf, typeToString } from "./types.js";
+// What JSON can hold, for `decode<T>(x)` (decode.ts): numbers, strings, bool, null, literals,
+// arrays, unions and objects without methods. A string is JSON text to decode.
+/** Types that JSON has no way to hold, by name, with what to decode instead. */
+const NOT_IN_JSON = new Map([
+    ['Date', 'JSON has no Date: decode a string and make the Date from it, e.g. new Date(s)'],
+    ['Map', 'JSON has no Map: decode an object or an array of pairs and make the Map from it'],
+    ['Set', 'JSON has no Set: decode an array and make the Set from it, e.g. new Set(items)'],
+    ['RegExp', 'JSON has no RegExp: decode a string and make it with new RegExp(s)'],
+    ['Promise', 'a Promise cannot come from JSON'],
+    ['chan', 'a channel cannot come from JSON'],
+    ['chan<-', 'a channel cannot come from JSON'],
+    ['<-chan', 'a channel cannot come from JSON'],
+]);
+/** Why a value of the type cannot come from JSON, or null if it can. */
+export function notDecoded(type, seen = new Set()) {
+    if (seen.has(type))
+        return null;
+    seen.add(type);
+    const inner = (types) => {
+        for (const each of types) {
+            const reason = notDecoded(each, seen);
+            if (reason !== null)
+                return reason;
+        }
+        return null;
+    };
+    switch (type.kind) {
+        case 'number':
+        case 'string':
+        case 'bool':
+        case 'null':
+        case 'literal':
+        case 'any':
+        case 'unknown':
+            return null;
+        case 'bigint':
+            return 'JSON has no bigint: decode a string and make it with BigInt(s)';
+        case 'nullable':
+            return inner([type.type]);
+        case 'array':
+            return inner([type.element]);
+        case 'union':
+            return inner(type.types);
+        case 'param':
+            return `${type.name} is a type parameter: decode needs a type known when the program compiles`;
+        case 'function':
+            return 'a function cannot come from JSON';
+        case 'component':
+            return 'a component cannot come from JSON';
+        case 'classValue':
+            return `the class ${type.info.name} cannot come from JSON`;
+        case 'class':
+            return (NOT_IN_JSON.get(type.info.name) ??
+                `decode gives plain objects, without the methods of the class ${type.info.name}: decode an interface with its fields`);
+        case 'object': {
+            const name = type.instanceOf?.template.name ?? type.name;
+            const known = name === null ? undefined : NOT_IN_JSON.get(name);
+            if (known !== undefined)
+                return known;
+            if (isQueue(type))
+                return 'JSON has no queue: decode an array and make the queue from it';
+            if (isTopic(type))
+                return 'a topic cannot come from JSON';
+            if (typedArrayOf(type) !== null)
+                return `JSON has no ${typeToString(type)}`;
+            if (type.call || type.construct) {
+                return `${typeToString(type)} is a function and cannot come from JSON`;
+            }
+            const members = [...memberNames(type.members)].flatMap((name) => type.members.get(name) ?? []);
+            if (members.some((member) => member.method)) {
+                return `${typeToString(type)} has methods, and JSON gives only data: decode an interface with its fields`;
+            }
+            return inner([...members.map((member) => member.type), ...(type.index ? [type.index] : [])]);
+        }
+        default:
+            return `${typeToString(type)} cannot come from JSON`;
+    }
+}
+/** Whether a value of the type is always a string: then decode reads it as JSON text. */
+export function isText(type) {
+    switch (type.kind) {
+        case 'string':
+            return true;
+        case 'literal':
+            return typeof type.value === 'string';
+        case 'union':
+            return type.types.every(isText);
+        default:
+            return false;
+    }
+}

package/dist/checker/loops.js

@@ -1,10 +1,11 @@
 import { assignedNames } from "../names.js";
 import { BytesChecker } from "./bytes.js";
 import { chanDirection, elementOf, isChan } from "./channel.js";
-import { isMap, loopEntry } from "./iterables.js";
-import { ANY, isNullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
+import { asyncIterated, isMap, loopEntry } from "./iterables.js";
+import { ANY, isNullable, isTopic, NUMBER, STRING, topicElement, typeToString, UNKNOWN, } from "./types.js";
 // `for ... in`: over arrays, strings, the iterables of the lib files (a Map gives its keys and
-// values), channels, which wait for their values, and iterators, `func(yield func(T) bool)`.
+// values), channels and async iterables, such as the streams of Node, which wait for their values,
+// and iterators, `func(yield func(T) bool)`.
 export class LoopChecker extends BytesChecker {
     checkForIn(node) {
         const iterable = this.checkValue(node.iterable);
@@ -26,6 +27,16 @@ export class LoopChecker extends BytesChecker {
                 this.error(`${typeToString(iterable)} has no keys: loop over its values, e.g. "for value in items"`, node.key);
             }
         }
+        else if (asyncIterated(iterable) !== null) {
+            // `for await` of JS: each value waits for the Promise of next().
+            value = asyncIterated(iterable);
+            if (this.fn && !this.fn.isAsync) {
+                this.error(`"for ... in" ${typeToString(iterable)} waits for its values, so it is allowed only in async functions and at the top level of a module`, node.iterable);
+            }
+            if (node.key) {
+                this.error(`${typeToString(iterable)} has no keys: loop over its values, e.g. "for value in items"`, node.key);
+            }
+        }
         else if (iterable.kind === 'function' && iterable.iterator) {
             [key, value] = this.yielded(iterable, node);
         }
@@ -41,6 +52,15 @@ export class LoopChecker extends BytesChecker {
             if (node.key)
                 this.error('a channel has no keys: write "for value in ch"', node.key);
         }
+        else if (isTopic(iterable)) {
+            // Each value waits for another tab to send one, until the topic is closed.
+            value = topicElement(iterable);
+            if (this.fn && !this.fn.isAsync) {
+                this.error('"for ... in" a topic waits for its values, so it is allowed only in async functions and at the top level of a module', node.iterable);
+            }
+            if (node.key)
+                this.error('a topic has no keys: write "for value in t"', node.key);
+        }
         else if (iterable.kind === 'string') {
             value = STRING;
         }

package/dist/checker/members.js

@@ -39,6 +39,13 @@ export class MemberChecker extends DecoratorMemberChecker {
         }
         if (node.kind === 'MemberExpression') {
             const member = this.findMember(object, node.property.name, node.property);
+            const { name } = node.property;
+            if (member !== 'any' && member?.accessor === 'set') {
+                this.error(`cannot read "${name}": it has a setter and no getter`, node.property);
+            }
+            else if (member !== 'any' && member?.abstract && node.object.kind === 'SuperExpression') {
+                this.error(`super.${name} is abstract in ${member.owner?.name ?? 'the base class'}: it has no code to run`, node.property);
+            }
             return [member === 'any' ? ANY : (member?.type ?? UNKNOWN), shortCircuits];
         }
         const keyed = this.keyedIndex(object, node.index);

package/dist/checker/operators.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { ExpressionChecker } from './expressions.ts';
+import { ArrayLiteralChecker } from './array-literals.ts';
 import { type Type } from './types.ts';
-export declare abstract class OperatorChecker extends ExpressionChecker {
+export declare abstract class OperatorChecker extends ArrayLiteralChecker {
     /** In the operation of a `select` case, a channel may be null: that case never goes on. */
     protected inSelectCase: boolean;
     protected checkUnary(node: ast.UnaryExpression): Type;

package/dist/checker/operators.js

@@ -1,12 +1,12 @@
 import { bigintBinary, bigintUnary } from "./bigint.js";
-import { ExpressionChecker } from "./expressions.js";
+import { ArrayLiteralChecker } from "./array-literals.js";
 import { withNarrowing } from "./flow.js";
 import { isUntyped, isNumeric, instanceTypeOf } from "./helpers.js";
 import { chanDirection, elementOf, isChan, received } from "./channel.js";
 import { awaited } from "./promise.js";
-import { ANY, BOOL, commonType, isAssignable, isComparable, isNullable, nonNull, nullable, NUMBER, STRING, typeToString, UNKNOWN, widenLiterals, } from "./types.js";
+import { ANY, BOOL, commonType, isAssignable, isComparable, isNullable, isTopic, nonNull, nullable, NUMBER, STRING, topicElement, typeToString, UNKNOWN, widenLiterals, } from "./types.js";
 // Unary, binary and conditional operators.
-export class OperatorChecker extends ExpressionChecker {
+export class OperatorChecker extends ArrayLiteralChecker {
     /** In the operation of a `select` case, a channel may be null: that case never goes on. */
     inSelectCase = false;
     checkUnary(node) {
@@ -19,8 +19,8 @@ export class OperatorChecker extends ExpressionChecker {
                 return STRING;
             // What the Promise gives; the results of an async function are unpacked from it.
             case 'await':
-                if (isChan(type)) {
-                    this.error('"await" does not wait for a channel: receive from it, e.g. "<-ch"', node);
+                if (isChan(type) || isTopic(type)) {
+                    this.error(`"await" does not wait for a ${isChan(type) ? 'channel' : 'topic'}: receive from it, e.g. "<-ch"`, node);
                 }
                 return awaited(type);
             case '<-': {
@@ -31,6 +31,8 @@ export class OperatorChecker extends ExpressionChecker {
                     }
                     return received(elementOf(channel));
                 }
+                if (isTopic(channel))
+                    return received(topicElement(channel));
                 if (!isUntyped(type)) {
                     this.error(`"<-" receives from a channel, not from ${typeToString(type)}`, node.argument);
                 }

package/dist/checker/queues.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import { ChannelChecker } from './channels.ts';
+import { SignalChecker } from './signals.ts';
 import { type Type } from './types.ts';
-export declare abstract class QueueChecker extends ChannelChecker {
+export declare abstract class QueueChecker extends SignalChecker {
     protected checkQueue(node: ast.QueueExpression): Type;
 }

package/dist/checker/queues.js

@@ -1,9 +1,9 @@
-import { ChannelChecker } from "./channels.js";
+import { SignalChecker } from "./signals.js";
 import { isUntyped } from "./helpers.js";
 import { arrayOf, queueOf, typeToString } from "./types.js";
 // Queues: `queue<number>()` makes an empty one, `queue<number>(items)` one with the values of an
 // array or of another iterable. The members of `queue T` are in types/queue.ts.
-export class QueueChecker extends ChannelChecker {
+export class QueueChecker extends SignalChecker {
     checkQueue(node) {
         const element = this.resolveType(node.element);
         if (node.items) {

package/dist/checker/resolution.js

@@ -2,7 +2,7 @@ import { holdsBigInts, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { chanOf } from "./channel.js";
 import { ClassChecker } from "./classes.js";
 import { CONTENT } from "./dom.js";
-import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, queueOf, substitute, typeToString, union, UNKNOWN, } from "./types.js";
+import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, queueOf, topicOf, substitute, typeToString, union, UNKNOWN, } from "./types.js";
 // Type annotations as types: names, aliases, generics with their arguments; and the type a variable gets from its value.
 export class TypeResolver extends ClassChecker {
     resolveType(node) {
@@ -17,6 +17,8 @@ export class TypeResolver extends ClassChecker {
                 return chanOf(this.resolveType(node.element), node.direction);
             case 'QueueType':
                 return queueOf(this.resolveType(node.element));
+            case 'TopicType':
+                return topicOf(this.resolveType(node.element));
             case 'NullableType':
                 return nullable(this.resolveType(node.type));
             case 'FuncType':
@@ -81,8 +83,8 @@ export class TypeResolver extends ClassChecker {
         if (entry === undefined) {
             this.error(this.lookupValue(name.name)
                 ? `"${name.name}" is a value, not a type`
-                : name.name === 'queue'
-                    ? 'a queue type is written with the type of its values after it, e.g. "queue number"'
+                : name.name === 'queue' || name.name === 'topic'
+                    ? `a ${name.name} type is written with the type of its values after it, e.g. "${name.name} number"`
                     : `unknown type "${name.name}"`, name);
             return UNKNOWN;
         }

package/dist/checker/signals.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { ChannelChecker } from './channels.ts';
+import { type Type } from './types.ts';
+export declare abstract class SignalChecker extends ChannelChecker {
+    protected checkCall(node: ast.CallExpression, callee: Type, expected?: Type | null): Type;
+    /** `signal("SIGINT", "SIGTERM")`: at least one name, and the names are those of signals. */
+    private checkSignalNames;
+}

package/dist/checker/signals.js

@@ -0,0 +1,48 @@
+import { ChannelChecker, typeName } from "./channels.js";
+import { isUntyped } from "./helpers.js";
+import { isNullable, typeToString } from "./types.js";
+// Signals and cancellation as channels (runtime/signals.js): `signal("SIGTERM")` gets the signals
+// of the process, `done(request.signal)` the reason of an AbortSignal, and `abortSignal(stop)` is an
+// AbortSignal that aborts when the channel gets a value or is closed. Their types are in
+// builtins.ts; the names that signal() takes, the AbortSignal that done() takes and the type that
+// abortSignal() gives, from the library if it has one, are here.
+const SIGNAL = /^SIG[A-Z0-9]+$/;
+export class SignalChecker extends ChannelChecker {
+    checkCall(node, callee, expected = null) {
+        const result = super.checkCall(node, callee, expected);
+        const { callee: name } = node;
+        if (name.kind !== 'Identifier' ||
+            this.lookupValue(name.name) !== this.globals.values.get(name.name)) {
+            return result;
+        }
+        switch (name.name) {
+            case 'signal':
+                this.checkSignalNames(node);
+                return result;
+            case 'done': {
+                const [argument] = node.arguments;
+                const type = argument && argument.kind !== 'SpreadElement' && this.checkedTypes.get(argument);
+                if (argument && type && !isUntyped(type) && typeName(type) !== 'AbortSignal') {
+                    this.error(`done() takes an AbortSignal, such as request.signal, not ${typeToString(type)}${isNullable(type) ? ': check it for null first' : ''}`, argument);
+                }
+                return result;
+            }
+            // An AbortSignal of the library, for `fetch(url, { signal: abortSignal(stop) })`.
+            case 'abortSignal':
+                return this.options.library?.type('AbortSignal') ?? result;
+            default:
+                return result;
+        }
+    }
+    /** `signal("SIGINT", "SIGTERM")`: at least one name, and the names are those of signals. */
+    checkSignalNames(node) {
+        if (node.arguments.length === 0) {
+            this.error('signal() takes the signals to listen to, e.g. signal("SIGINT", "SIGTERM")', node);
+        }
+        for (const argument of node.arguments) {
+            if (argument.kind === 'StringLiteral' && !SIGNAL.test(argument.value)) {
+                this.error(`"${argument.value}" is not the name of a signal: they start with SIG, e.g. signal("SIGINT", "SIGTERM")`, argument);
+            }
+        }
+    }
+}

package/dist/checker/statements.d.ts

@@ -23,6 +23,11 @@ export declare abstract class StatementChecker extends AssignmentChecker {
     private checkDelete;
     protected checkBlock(statements: readonly ast.Statement[]): void;
     protected checkVariableDeclaration(node: ast.VariableDeclaration): void;
+    /**
+     * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
+     * be null. Variables of `let` may be assigned apart, so only constants are linked.
+     */
+    private linkError;
     /** The types of the variables of a declaration: the written one, or those of their values. */
     private initializerTypes;
 }

package/dist/checker/statements.js

@@ -1,3 +1,4 @@
+import { guardedByError } from "./error-results.js";
 import { AssignmentChecker } from "./assignments.js";
 import { isUntyped, isNumeric, ownStatements } from "./helpers.js";
 import { func, hasZeroValue, isNullable, nonNull, nullable, typeToString, UNKNOWN, } from "./types.js";
@@ -182,8 +183,26 @@ export class StatementChecker extends AssignmentChecker {
                     this.flow.set(binding, nonNull(type));
                 }
             });
+            if (node.keyword === 'const' && !declared)
+                this.linkError(node, bindings);
         });
     }
+    /**
+     * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
+     * be null. Variables of `let` may be assigned apart, so only constants are linked.
+     */
+    linkError(node, bindings) {
+        const results = node.values.length === 1 ? this.typeOfChecked(node.values[0]) : null;
+        const error = bindings.at(-1);
+        if (results?.kind !== 'tuple' || results.types.length !== bindings.length || !error)
+            return;
+        const guarded = guardedByError(results.types).flatMap((i) => bindings[i] ?? []);
+        if (guarded.length === 0)
+            return;
+        error.guards = guarded;
+        for (const binding of guarded)
+            binding.guardedBy = error;
+    }
     /** The types of the variables of a declaration: the written one, or those of their values. */
     initializerTypes(node, declared) {
         const { names, values } = node;

package/dist/checker/topics.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { QueueChecker } from './queues.ts';
+import { type Type } from './types.ts';
+export declare abstract class TopicChecker extends QueueChecker {
+    protected checkTopic(node: ast.TopicExpression): Type;
+}

package/dist/checker/topics.js

@@ -0,0 +1,17 @@
+import { QueueChecker } from "./queues.js";
+import { notBroadcast } from "./transfer.js";
+import { STRING, topicOf } from "./types.js";
+// Topics: `topic<T>(name)` makes one, and its values go to the other tabs of the site as copies,
+// so they must be data without channels. `t <- v` sends (channels.ts), `<-t` receives
+// (operators.ts) and `for v in t` receives them until it is closed (loops.ts).
+export class TopicChecker extends QueueChecker {
+    checkTopic(node) {
+        const element = this.resolveType(node.element);
+        const reason = notBroadcast(element);
+        if (reason !== null) {
+            this.error(`the values of a topic go to other tabs as copies: ${reason}`, node.element);
+        }
+        this.expectAssignable(this.checkValue(node.name, STRING), STRING, node.name);
+        return topicOf(element);
+    }
+}

package/dist/checker/transfer.d.ts

@@ -2,4 +2,6 @@ import { type Type } from './types.ts';
 /** Buffers and their views: copied whole, or moved by `transfer(x)` (channels.ts). */
 export declare const BUFFERS: readonly string[];
 /** Why a value of the type cannot be copied to a worker, or null if it can. */
-export declare function notCopied(type: Type, seen?: Set<Type>): string | null;
+export declare function notCopied(type: Type, seen?: Set<Type>, tab?: boolean): string | null;
+/** Why a value of the type cannot go to another tab through a topic, or null if it can. */
+export declare function notBroadcast(type: Type): string | null;

package/dist/checker/transfer.js

@@ -1,6 +1,7 @@
 import { isQueue, memberNames, queueElement, typeToString } from "./types.js";
 // What can go to a worker and back: a worker gets a copy of each value (the structured clone of
-// postMessage), and a copy has the data of a value but not its methods.
+// postMessage), and a copy has the data of a value but not its methods. What goes to another tab
+// through a topic is a copy as well, and it cannot hold a channel.
 /** Buffers and their views: copied whole, or moved by `transfer(x)` (channels.ts). */
 export const BUFFERS = [
     'ArrayBuffer',
@@ -23,6 +24,8 @@ const COPIED = new Set([
     'chan',
     'chan<-',
     '<-chan',
+    // A topic is copied as its name, and the other thread listens to it on its own.
+    'topic',
     'Map',
     'Set',
     'Date',
@@ -35,13 +38,13 @@ const COPIED = new Set([
     ...BUFFERS,
 ]);
 /** Why a value of the type cannot be copied to a worker, or null if it can. */
-export function notCopied(type, seen = new Set()) {
+export function notCopied(type, seen = new Set(), tab = false) {
     if (seen.has(type))
         return null;
     seen.add(type);
     const inner = (types) => {
         for (const each of types) {
-            const reason = notCopied(each, seen);
+            const reason = notCopied(each, seen, tab);
             if (reason !== null)
                 return reason;
         }
@@ -61,15 +64,28 @@ export function notCopied(type, seen = new Set()) {
             return 'a component cannot be copied';
         case 'classValue':
             return `the class ${type.info.name} cannot be copied`;
+        // A data class goes with its class (runtime/classes.js), but not to another tab, which may not
+        // have it.
         case 'class':
-            return type.info.name === 'Error'
-                ? null
+            if (type.info.name === 'Error')
+                return null;
+            if (type.info.data === true) {
+                return tab
+                    ? `${typeToString(type)} cannot go to another tab, which may not have its class: send an object of an interface`
+                    : inner(type.args ?? []);
+            }
+            return type.info.data === false && !tab
+                ? `a copy of ${typeToString(type)} would lose its class and methods: mark it to keep them, e.g. data class ${type.info.name}`
                 : `a copy of ${typeToString(type)} would lose its class and methods`;
         case 'object': {
             // A queue goes as its values, and the other thread makes a queue of them (src/runtime/threads.js).
             if (isQueue(type))
                 return inner([queueElement(type)]);
             const name = type.instanceOf?.template.name ?? type.name;
+            // The id of a channel means something only to the workers of the tab that made it.
+            if (tab && (name === 'chan' || name === 'chan<-' || name === '<-chan')) {
+                return `${typeToString(type)} cannot go to another tab: a channel works only within one`;
+            }
             if (name !== null && COPIED.has(name))
                 return inner(type.instanceOf?.args ?? []);
             if (type.call || type.construct)
@@ -84,3 +100,7 @@ export function notCopied(type, seen = new Set()) {
             return null;
     }
 }
+/** Why a value of the type cannot go to another tab through a topic, or null if it can. */
+export function notBroadcast(type) {
+    return notCopied(type, new Set(), true);
+}

package/dist/checker/try.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { DecodeChecker } from './decode.ts';
+import { type Type } from './types.ts';
+export declare abstract class TryChecker extends DecodeChecker {
+    protected checkTryExpression(node: ast.TryExpression): Type;
+}