rooklang 0.3.3 → 0.4.0

package/dist/checker/functions.js

@@ -1,11 +1,11 @@
 import { Scope } from "./context.js";
-import { ControlFlowChecker } from "./control-flow.js";
 import { isTerminating } from "./flow.js";
 import { isUntyped, callSignature } from "./helpers.js";
 import { awaitedResults, isPromise } from "./promise.js";
+import { TaggedUnionChecker } from "./tagged-unions.js";
 import { commonType, containsTypeParam, func, nonNull, UNKNOWN, } from "./types.js";
 // Bodies of functions, arrow functions and func literals, and the results they return.
-export class FunctionChecker extends ControlFlowChecker {
+export class FunctionChecker extends TaggedUnionChecker {
     /**
      * Checks a function body and returns its result types: the declared ones, or those inferred from
      * the `return` statements when `results` is `null`.
@@ -30,7 +30,9 @@ export class FunctionChecker extends ControlFlowChecker {
             // A generic function: its type parameters are types in its body.
             for (const typeParam of type.typeParams)
                 this.scope.types.set(typeParam.name, typeParam);
-            params.forEach((param, i) => this.declareValue(param.name, options.paramKind ?? 'param', type.params[i] ?? UNKNOWN));
+            params.forEach((param, i) => 
+            // A bound property of a component, `bind active string`, changes as its state does.
+            this.declareValue(param.name, param.bind ? 'state' : (options.paramKind ?? 'param'), type.params[i] ?? UNKNOWN));
             if (body.kind === 'BlockStatement') {
                 this.checkStatementList(body.body, false);
                 options.inspect?.(this.scope);
@@ -87,9 +89,11 @@ export class FunctionChecker extends ControlFlowChecker {
     }
     stableFlow() {
         const flow = new Map();
-        for (const [binding, type] of this.flow) {
+        // A path keeps its narrowing when its variable does, like `user.boss` of a constant `user`.
+        for (const [place, type] of this.flow) {
+            const { binding } = place;
             if (binding.kind === 'const' || !this.assigned.has(binding.name))
-                flow.set(binding, type);
+                flow.set(place, type);
         }
         return flow;
     }

package/dist/checker/helpers.d.ts

@@ -11,7 +11,10 @@ export declare function ownStatements(body: ast.BlockStatement): ast.Statement[]
  * the type of a DOM node), lists of them, or null.
  */
 export declare function isContent(given: Type, node: Type): boolean;
-/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+/**
+ * Values that setAttribute accepts: text, numbers, bools, or null to leave it out. A literal is
+ * one of them, and so is a union of such, `type Status "shown" | "aborted"`.
+ */
 export declare function isAttributeValue(type: Type): boolean;
 export declare function isUntyped(type: Type): boolean;
 export declare function isNumeric(type: Type): boolean;
@@ -26,7 +29,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

@@ -61,7 +61,10 @@ export function isContent(given, node) {
             return false;
     }
 }
-/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+/**
+ * Values that setAttribute accepts: text, numbers, bools, or null to leave it out. A literal is
+ * one of them, and so is a union of such, `type Status "shown" | "aborted"`.
+ */
 export function isAttributeValue(type) {
     const value = nonNull(type);
     return (isUntyped(value) ||
@@ -69,8 +72,10 @@ export function isAttributeValue(type) {
         value.kind === 'number' ||
         value.kind === 'bigint' ||
         value.kind === 'bool' ||
+        value.kind === 'literal' ||
         value.kind === 'null' ||
-        value.kind === 'never');
+        value.kind === 'never' ||
+        (value.kind === 'union' && value.types.every(isAttributeValue)));
 }
 export function isUntyped(type) {
     return type.kind === 'any' || type.kind === 'unknown';
@@ -123,12 +128,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 +147,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/imports.js

@@ -54,8 +54,11 @@ export class ImportChecker extends CheckerBase {
             if (!found) {
                 this.error(`"${name}" is not exported by "${specifier}"`, specifierNode.imported);
             }
-            if (value !== undefined)
-                this.declareValue(specifierNode.local, 'import', value);
+            if (value !== undefined) {
+                const binding = this.declareValue(specifierNode.local, 'import', value);
+                if (exports.shared?.has(name))
+                    binding.shared = specifier;
+            }
             if (type !== undefined)
                 this.declareType(specifierNode.local, type);
             if (decorator !== undefined)

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

@@ -2,6 +2,8 @@ import type * as ast from '../ast.ts';
 import { BytesChecker } from './bytes.ts';
 export declare abstract class LoopChecker extends BytesChecker {
     protected checkForIn(node: ast.ForInStatement): void;
+    /** `with key todo.id`: a string or a number, by which the blocks of the list are found again. */
+    private checkListKey;
     /**
      * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
      * gets the second, as with a Map; of one, there is no key.

package/dist/checker/loops.js

@@ -1,10 +1,10 @@
-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 +26,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 +51,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;
         }
@@ -58,13 +77,22 @@ export class LoopChecker extends BytesChecker {
             if (node.key)
                 this.declareValue(node.key, 'loop', key);
             this.declareValue(node.value, 'loop', value);
-            this.dropNarrowing(assignedNames(node.body));
+            if (node.withKey)
+                this.checkListKey(node.withKey);
+            this.dropNarrowing(node.body);
             const entry = this.flow;
             this.flow = new Map(entry);
             this.checkBlock(node.body.body);
             this.flow = entry;
         });
     }
+    /** `with key todo.id`: a string or a number, by which the blocks of the list are found again. */
+    checkListKey(key) {
+        const type = this.checkValue(key);
+        if (!isListKey(type)) {
+            this.error(`the key of a list must be a string or a number, not ${typeToString(type)}: e.g. "with key todo.id"`, key);
+        }
+    }
     /**
      * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
      * gets the second, as with a Map; of one, there is no key.
@@ -80,3 +108,20 @@ export class LoopChecker extends BytesChecker {
         return [UNKNOWN, taken[0] ?? UNKNOWN];
     }
 }
+/** A key of a list: a string, a number, a literal of one or a union of them. */
+function isListKey(type) {
+    switch (type.kind) {
+        case 'string':
+        case 'number':
+        case 'bigint':
+        case 'any':
+        case 'unknown':
+            return true;
+        case 'literal':
+            return typeof type.value !== 'boolean';
+        case 'union':
+            return type.types.every(isListKey);
+        default:
+            return false;
+    }
+}

package/dist/checker/markup.js

@@ -4,8 +4,10 @@ import { domProperty, elementType } from "./dom.js";
 import { svgElementType } from "./dom-svg.js";
 import { isContent, isAttributeValue, isUntyped } from "./helpers.js";
 import { OperatorChecker } from "./operators.js";
-import { BOOL, func, STRING, typeToString } from "./types.js";
+import { arrayOf, BOOL, func, nullable, STRING, typeToString } from "./types.js";
 // Markup: elements, their children and attributes, `bind:` and event handlers.
+/** The type of a list of classes, `class={[styles.tab, active ? styles.active : null]}`. */
+const CLASS_LIST = arrayOf(nullable(STRING));
 export class MarkupChecker extends OperatorChecker {
     /** Whether the markup being checked is inside `<svg>`: its elements are SVG then. */
     inSvg = false;
@@ -98,7 +100,17 @@ export class MarkupChecker extends OperatorChecker {
         }
         if (value?.kind === 'EventHandler')
             return;
-        const valueType = value === null ? BOOL : value.kind === 'StringLiteral' ? STRING : this.checkValue(value);
+        const list = name === 'class' && value?.kind === 'ArrayLiteral' ? CLASS_LIST : null;
+        const valueType = value === null
+            ? BOOL
+            : value.kind === 'StringLiteral'
+                ? STRING
+                : this.checkValue(value, list);
+        // `class={[styles.tab, active ? styles.active : null]}`: the classes that are not null.
+        if (name === 'class' && valueType.kind === 'array') {
+            this.expectAssignable(valueType, CLASS_LIST, value, ' for attribute "class"');
+            return;
+        }
         if (name === 'style') {
             if (!isUntyped(valueType) && valueType.kind !== 'string' && valueType.kind !== 'object') {
                 this.error(`style must be a string or an object, not ${typeToString(valueType)}`, attribute);

package/dist/checker/members.js

@@ -16,6 +16,7 @@ export class MemberChecker extends DecoratorMemberChecker {
                 return [this.checkSuperCall(node), false];
             let [callee, shortCircuits] = this.chainPart(node.callee);
             this.checkDecoratorMutation(node);
+            this.checkSharedMutation(node);
             if (isNullable(callee)) {
                 if (node.optional)
                     shortCircuits = true;
@@ -39,7 +40,15 @@ export class MemberChecker extends DecoratorMemberChecker {
         }
         if (node.kind === 'MemberExpression') {
             const member = this.findMember(object, node.property.name, node.property);
-            return [member === 'any' ? ANY : (member?.type ?? UNKNOWN), shortCircuits];
+            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);
+            }
+            const type = member === 'any' ? ANY : (member?.type ?? UNKNOWN);
+            return [this.pathType(node, object, type), shortCircuits];
         }
         const keyed = this.keyedIndex(object, node.index);
         if (keyed)

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/shared-state.d.ts

@@ -0,0 +1,11 @@
+import type * as ast from '../ast.ts';
+import { ImportChecker } from './imports.ts';
+export declare abstract class SharedStateChecker extends ImportChecker {
+    /** `items = []` or `items[0].done = true` in a module that imported `items`. */
+    protected checkSharedWrite(target: ast.Expression): boolean;
+    /** `items.push(x)`: a method that changes state that another module shares. */
+    protected checkSharedMutation(node: ast.CallExpression): void;
+    /** The import that a target writes into, `items` of `items[0].done`, if it is shared state. */
+    private importedShared;
+    private sharedError;
+}

package/dist/checker/shared-state.js

@@ -0,0 +1,37 @@
+import { mayChange } from "../methods.js";
+import { ImportChecker } from "./imports.js";
+// State shared by components: `state items []Item = []` at the top level of a module. Its module
+// changes it anywhere; other modules import it to read, and change it only by calling a function
+// of its module, so that the module keeps its data consistent, as a decorator keeps its state.
+export class SharedStateChecker extends ImportChecker {
+    /** `items = []` or `items[0].done = true` in a module that imported `items`. */
+    checkSharedWrite(target) {
+        const shared = this.importedShared(target);
+        if (shared)
+            this.sharedError(shared, target);
+        return shared !== null;
+    }
+    /** `items.push(x)`: a method that changes state that another module shares. */
+    checkSharedMutation(node) {
+        const { callee } = node;
+        if (callee.kind !== 'MemberExpression')
+            return;
+        const shared = this.importedShared(callee.object);
+        if (shared && mayChange(this.typeOfChecked(callee.object), callee.property.name)) {
+            this.sharedError(shared, node);
+        }
+    }
+    /** The import that a target writes into, `items` of `items[0].done`, if it is shared state. */
+    importedShared(target) {
+        let root = target;
+        while (root.kind === 'MemberExpression' || root.kind === 'IndexExpression')
+            root = root.object;
+        if (root.kind !== 'Identifier')
+            return null;
+        const binding = this.lookupValue(root.name);
+        return binding?.shared ? binding : null;
+    }
+    sharedError(binding, node) {
+        this.error(`"${binding.name}" is state of "${binding.shared}", which is read-only here; change it with a function that "${binding.shared}" exports`, node);
+    }
+}

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;
+}