rooklang 0.3.4 → 0.4.1

package/dist/checker/decorator-members.js

@@ -1,27 +1,14 @@
 import { ARRAY_MUTATORS } from "../methods.js";
-import { DecoratorChecker } from "./decorators.js";
+import { withIncluded } from "./context.js";
+import { DecoratorIncludeChecker } from "./decorator-includes.js";
 import { nonNull, UNKNOWN } from "./types.js";
 // The public members of decorators, in the components they are applied to: `@visible.show()` calls
-// a function, `get(@visible.shown)` reads state or a constant, and none of them can be changed
-// outside the decorator.
-export class DecoratorMemberChecker extends DecoratorChecker {
-    /** `@visible.show`: a public function; state and constants are read with `get`. */
+// a function, `@visible.shown` reads state or a constant, and none of them can be changed outside
+// the decorator.
+export class DecoratorMemberChecker extends DecoratorIncludeChecker {
+    /** `@visible.shown` or `@visible.show`: public state, a constant or a function. */
     checkDecoratorMember(node) {
-        const member = this.findDecoratorMember(node);
-        if (member && member.kind !== 'func') {
-            const { decorator, member: name } = node;
-            this.error(`read "${name.name}" of @${decorator.name} with get(@${decorator.name}.${name.name})`, node);
-        }
-        return member?.type ?? UNKNOWN;
-    }
-    /** `get(@visible.shown)`: public state or a constant. */
-    checkDecoratorGet(node) {
-        const member = this.findDecoratorMember(node.target);
-        if (member?.kind === 'func') {
-            const { decorator, member: name } = node.target;
-            this.error(`"${name.name}" of @${decorator.name} is a function: call it, @${decorator.name}.${name.name}()`, node);
-        }
-        return member?.type ?? UNKNOWN;
+        return this.findDecoratorMember(node)?.type ?? UNKNOWN;
     }
     /**
      * A public member of a decorator applied to the component being checked, or of one that the
@@ -38,6 +25,13 @@ export class DecoratorMemberChecker extends DecoratorChecker {
             return null;
         }
         const info = component.decorators.find((decorator) => decorator.node.name.name === name);
+        // `@cart.count` of the `cart` that `@shop` includes is `@shop.count`.
+        const via = component.decorators.find((decorator) => withIncluded(decorator.included).some((each) => each.node.name.name === name));
+        if (!info && via) {
+            const combined = via.node.name.name;
+            this.error(`"${member}" of @${name} comes through @${combined}: write @${combined}.${member}`, node);
+            return null;
+        }
         if (!info) {
             this.error(this.decorators.has(name)
                 ? `@${name} is not applied to ${component.node.name.name}: write @${name} before comp`
@@ -46,7 +40,7 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         }
         return this.publicMember(node, info);
     }
-    /** `get(@cart.count)` in `dec cartBadge() needs cart`. */
+    /** `@cart.count` in `dec cartBadge() needs cart`. */
     neededMember(node, decorator) {
         const name = node.decorator.name;
         const current = decorator.name.name;
@@ -54,8 +48,9 @@ export class DecoratorMemberChecker extends DecoratorChecker {
             this.error(`inside @${name} its members are used by their names: ${node.member.name}`, node);
             return null;
         }
-        if (!decorator.needs.some((need) => need.name === name)) {
-            this.error(`@${current} can use @${name} only if it needs it: write "needs ${name}" after its parameters`, node.decorator);
+        const uses = [...decorator.needs, ...decorator.includes.map((use) => use.name)];
+        if (!uses.some((used) => used.name === name)) {
+            this.error(`@${current} can use @${name} only if it needs or includes it: write "needs ${name}" after its parameters`, node.decorator);
             return null;
         }
         const info = this.decorators.get(name);
@@ -74,18 +69,22 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         return found ?? null;
     }
     /**
-     * Members of a decorator are read-only outside it: `get(@cart.count) = 0`, `get(@cart.items)[0]
-     * = x`. Returns whether `target` is one of them.
+     * Members of a decorator are read-only outside it: `@cart.count = 0`, `@cart.items[0] = x`.
+     * Returns whether `target` is one of them.
      */
     checkDecoratorWrite(target) {
         const root = decoratorRoot(target);
         if (!root)
             return false;
-        if (this.findDecoratorMember(root))
+        const member = this.findDecoratorMember(root);
+        // A ref always points to its element, but the element is the page's: `@framed.box.title = x`.
+        if (member?.kind === 'ref' && target !== root)
+            return false;
+        if (member)
             this.readOnlyError(root, target);
         return true;
     }
-    /** `get(@cart.items).push(x)`: a method that changes the array. */
+    /** `@cart.items.push(x)`: a method that changes the array. */
     checkDecoratorMutation(node) {
         const { callee } = node;
         if (callee.kind !== 'MemberExpression')
@@ -118,17 +117,15 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         const member = node.property.name;
         this.error(info.members.get(member)?.kind === 'func'
             ? `"${name}" is not defined; to call a function of @${name} write @${name}.${member}()`
-            : `"${name}" is not defined; to read public state of @${name} write get(@${name}.${member})`, object);
+            : `"${name}" is not defined; to read public state of @${name} write @${name}.${member}`, object);
         return true;
     }
 }
-/** The member of a decorator that `get(@cart.items)[0].done` starts with, if any. */
+/** The member of a decorator that `@cart.items[0].done` starts with, if any. */
 function decoratorRoot(node) {
     switch (node.kind) {
         case 'DecoratorMember':
             return node;
-        case 'DecoratorGet':
-            return node.target;
         case 'MemberExpression':
         case 'IndexExpression':
             return decoratorRoot(node.object);

package/dist/checker/decorator-wrappers.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentInfo, DecoratorInfo } from './context.ts';
+import { type ComponentInfo, type DecoratorInfo } from './context.ts';
 import { StyleChecker } from './styles.ts';
 import { type Type } from './types.ts';
 type WrapperInfo = NonNullable<DecoratorInfo['wrapper']>;

package/dist/checker/decorator-wrappers.js

@@ -1,4 +1,5 @@
 import { decoratorNames, wrapperBody, wrapperOf } from "../decorators.js";
+import { withIncluded } from "./context.js";
 import { isUntyped, ownStatements } from "./helpers.js";
 import { StyleChecker } from "./styles.js";
 import { isAssignable, typeToString, UNKNOWN } from "./types.js";
@@ -78,7 +79,7 @@ export class DecoratorWrapperChecker extends StyleChecker {
         }
     }
     wrappedType(info, own, seen) {
-        return info.decorators.reduceRight((type, decorator) => (decorator.wrapper ? this.wrapperResult(decorator.wrapper, seen) : type), own);
+        return withIncluded(info.decorators).reduceRight((type, decorator) => (decorator.wrapper ? this.wrapperResult(decorator.wrapper, seen) : type), own);
     }
     /** What a wrapper gives, found without checking it again, like the markup of a component. */
     wrapperResult(wrapper, seen) {
@@ -96,7 +97,7 @@ export class DecoratorWrapperChecker extends StyleChecker {
     checkWrappedTypes(info) {
         let type = this.ownResult(info, new Set());
         let source = null;
-        for (const decorator of [...info.decorators].reverse()) {
+        for (const decorator of withIncluded(info.decorators).reverse()) {
             const { wrapper } = decorator;
             if (!wrapper)
                 continue;

package/dist/checker/decorators.d.ts

@@ -1,11 +1,14 @@
 import type * as ast from '../ast.ts';
-import type { ComponentInfo, DecoratorInfo, Scope } from './context.ts';
+import { type ComponentInfo, type DecoratorInfo, type Scope } from './context.ts';
 import { DecoratorExportChecker } from './decorator-exports.ts';
+import { type Type } from './types.ts';
 export declare abstract class DecoratorChecker extends DecoratorExportChecker {
     protected resolveDecoratorParams(info: DecoratorInfo): void;
     /** `needs cart, auth`: other decorators, each once. */
     protected checkNeedsDeclaration(info: DecoratorInfo): void;
-    /** Decorators after the ones they need. A cycle of needs is an error: none can be first. */
+    /**
+     * Decorators after the ones they need or include. A cycle is an error: none can be first.
+     */
     protected orderByNeeds(decorators: readonly DecoratorInfo[]): DecoratorInfo[];
     /**
      * The body is checked once, by itself: it does not see the components it is applied to. Its
@@ -15,11 +18,17 @@ export declare abstract class DecoratorChecker extends DecoratorExportChecker {
     protected collectMembers(info: DecoratorInfo, scope: Scope): void;
     /**
      * The decorators before `comp`: they exist, are applied once and below the ones they need, get
-     * valid arguments, and their wrappers get what they can take.
+     * valid arguments, and their wrappers get what they can take. Those that a decorator includes
+     * are applied with it, above it.
      */
     protected checkDecoratorUses(info: ComponentInfo): void;
-    /** Arguments are positional and see the properties of the component, as its body does. */
-    protected checkDecoratorArguments(use: ast.DecoratorUse, decorator: DecoratorInfo, info: ComponentInfo): void;
+    /** Applied once, below the ones it needs; `via` is the decorator that includes it. */
+    private checkApplied;
+    /**
+     * Arguments are positional and see `params`: the properties of the component, as its body does,
+     * or the parameters of the decorator that includes this one.
+     */
+    protected checkDecoratorArguments(use: ast.DecoratorUse, decorator: DecoratorInfo, scope: readonly [ast.Identifier, Type][]): void;
     /**
      * The code of the decorator and its arguments go into the component's body, so the names of the
      * module they use must not be hidden there by the component's declarations.

package/dist/checker/decorators.js

@@ -1,5 +1,6 @@
 import { freeNames } from "../names.js";
 import { forEachChild } from "../walk.js";
+import { withIncluded, } from "./context.js";
 import { DecoratorExportChecker } from "./decorator-exports.js";
 import { lookupIn, ownStatements } from "./helpers.js";
 import { func, UNKNOWN } from "./types.js";
@@ -42,7 +43,9 @@ export class DecoratorChecker extends DecoratorExportChecker {
             needed.add(name);
         }
     }
-    /** Decorators after the ones they need. A cycle of needs is an error: none can be first. */
+    /**
+     * Decorators after the ones they need or include. A cycle is an error: none can be first.
+     */
     orderByNeeds(decorators) {
         const order = [];
         const path = [];
@@ -51,13 +54,17 @@ export class DecoratorChecker extends DecoratorExportChecker {
                 return;
             const at = path.indexOf(info);
             if (at >= 0) {
-                const cycle = path.slice(at).map((each) => `@${each.node.name.name}`);
-                const steps = cycle.map((name, i) => `${name} needs ${cycle[(i + 1) % cycle.length]}`);
-                this.error(`decorators cannot need each other: ${steps.join(', ')}; remove one of the needs`, info.node.name);
+                const cycle = path.slice(at);
+                const steps = cycle.map((each, i) => {
+                    const next = cycle[(i + 1) % cycle.length];
+                    const how = each.included.includes(next) ? 'includes' : 'needs';
+                    return `@${each.node.name.name} ${how} @${next.node.name.name}`;
+                });
+                this.error(`decorators cannot need or include each other: ${steps.join(', ')}; remove one of them`, info.node.name);
                 return;
             }
             path.push(info);
-            for (const needed of info.needed)
+            for (const needed of [...info.needed, ...info.included])
                 visit(needed);
             path.pop();
             order.push(info);
@@ -112,8 +119,7 @@ export class DecoratorChecker extends DecoratorExportChecker {
             }
             else if (statement.kind === 'VariableDeclaration' &&
                 statement.isPublic &&
-                statement.keyword !== 'let' &&
-                statement.keyword !== 'ref') {
+                statement.keyword !== 'let') {
                 for (const name of statement.names)
                     add(name, statement.keyword);
             }
@@ -121,10 +127,16 @@ export class DecoratorChecker extends DecoratorExportChecker {
     }
     /**
      * The decorators before `comp`: they exist, are applied once and below the ones they need, get
-     * valid arguments, and their wrappers get what they can take.
+     * valid arguments, and their wrappers get what they can take. Those that a decorator includes
+     * are applied with it, above it.
      */
     checkDecoratorUses(info) {
-        const applied = new Set();
+        // The decorator that each one is applied with, for those that another includes.
+        const applied = new Map();
+        const props = info.node.params.map((param) => [
+            param.name,
+            info.props.get(param.name.name)?.type ?? UNKNOWN,
+        ]);
         for (const use of info.node.decorators) {
             const name = use.name.name;
             const decorator = this.decorators.get(name);
@@ -132,23 +144,39 @@ export class DecoratorChecker extends DecoratorExportChecker {
                 this.error(`unknown decorator @${name}`, use.name);
                 continue;
             }
-            if (applied.has(decorator))
-                this.error(`@${name} is applied twice: apply it once`, use);
-            // The body of a decorator may read the state of those it needs right away.
-            for (const needed of decorator.needed) {
-                if (applied.has(needed))
-                    continue;
-                const other = needed.node.name.name;
-                this.error(`@${name} needs @${other} above it: @${other} @${name} comp ...`, use);
+            for (const each of withIncluded([decorator])) {
+                const via = each === decorator ? null : name;
+                this.checkApplied(each, via, applied, use);
+                applied.set(each, via);
+                this.checkInlinedNames(use, each, info);
             }
-            applied.add(decorator);
-            this.checkDecoratorArguments(use, decorator, info);
-            this.checkInlinedNames(use, decorator, info);
+            this.checkDecoratorArguments(use, decorator, props);
         }
         this.checkWrappedTypes(info);
     }
-    /** Arguments are positional and see the properties of the component, as its body does. */
-    checkDecoratorArguments(use, decorator, info) {
+    /** Applied once, below the ones it needs; `via` is the decorator that includes it. */
+    checkApplied(decorator, via, applied, use) {
+        const name = decorator.node.name.name;
+        const where = (other) => (other === null ? '' : ` (it is in @${other})`);
+        if (applied.has(decorator)) {
+            const before = applied.get(decorator) ?? null;
+            this.error(before === null && via === null
+                ? `@${name} is applied twice: apply it once`
+                : `@${name} is applied twice${where(via ?? before)}: apply it once`, use);
+        }
+        // The body of a decorator may read the state of those it needs right away.
+        for (const needed of decorator.needed) {
+            if (applied.has(needed))
+                continue;
+            const other = needed.node.name.name;
+            this.error(`@${name}${where(via)} needs @${other} above it: @${other} @${via ?? name} comp ...`, use);
+        }
+    }
+    /**
+     * Arguments are positional and see `params`: the properties of the component, as its body does,
+     * or the parameters of the decorator that includes this one.
+     */
+    checkDecoratorArguments(use, decorator, scope) {
         const name = use.name.name;
         const { params } = decorator.node;
         const extra = use.arguments[params.length];
@@ -157,9 +185,8 @@ export class DecoratorChecker extends DecoratorExportChecker {
             this.error(params.length === 0 ? `@${name} takes no arguments` : `@${name} takes ${count}`, extra);
         }
         this.withScope(() => {
-            for (const param of info.node.params) {
-                this.declareValue(param.name, 'prop', info.props.get(param.name.name)?.type ?? UNKNOWN);
-            }
+            for (const [param, type] of scope)
+                this.declareValue(param, 'prop', type);
             params.forEach((param, i) => {
                 const type = decorator.params[i] ?? UNKNOWN;
                 const arg = use.arguments[i];

package/dist/checker/expressions.d.ts

@@ -1,5 +1,5 @@
 import type * as ast from '../ast.ts';
-import type { ComponentInfo } from './context.ts';
+import { type ComponentInfo } from './context.ts';
 import { FunctionChecker } from './functions.ts';
 import { type ComponentType, type Type } from './types.ts';
 export declare abstract class ExpressionChecker extends FunctionChecker {

package/dist/checker/expressions.js

@@ -1,3 +1,4 @@
+import { placeOf } from "./context.js";
 import { FunctionChecker } from "./functions.js";
 import { expectsLiteral, callName, isUntyped } from "./helpers.js";
 import { ANY, BIGINT, BOOL, hasUntypedBase, instanceMembers, isAssignable, literal, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
@@ -90,8 +91,6 @@ export class ExpressionChecker extends FunctionChecker {
                 return this.checkElement(node);
             case 'DecoratorMember':
                 return this.checkDecoratorMember(node);
-            case 'DecoratorGet':
-                return this.checkDecoratorGet(node);
             case 'MemberExpression':
             case 'IndexExpression':
             case 'CallExpression': {
@@ -130,7 +129,7 @@ export class ExpressionChecker extends FunctionChecker {
             this.error(`"${node.name}" is used before its declaration`, node);
             return UNKNOWN;
         }
-        return this.flow.get(binding) ?? binding.type;
+        return this.flow.get(placeOf(binding)) ?? binding.type;
     }
     thisType(node) {
         if (!this.cls) {
@@ -155,10 +154,11 @@ export class ExpressionChecker extends FunctionChecker {
     }
     checkObjectLiteral(node, expected) {
         let target = expected ? nonNull(expected) : null;
-        // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it.
+        // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it, or
+        // the one that its tag chooses, `{ kind: "pickup" }` of `Pickup | Courier`.
         if (target?.kind === 'union') {
             const objects = target.types.filter((type) => type.kind === 'object' || type.kind === 'class');
-            target = objects.length === 1 ? objects[0] : null;
+            target = objects.length === 1 ? objects[0] : this.taggedMember(node, objects, target);
         }
         const index = target?.kind === 'object' ? target.index : undefined;
         const targetMembers = target?.kind === 'object'
@@ -168,7 +168,8 @@ export class ExpressionChecker extends FunctionChecker {
                 : null;
         const members = new Map();
         const written = new Set();
-        let untyped = false;
+        // A tag of no member is reported once, not again where the literal is used.
+        let untyped = target?.kind === 'unknown';
         for (const property of node.properties) {
             if (property.kind === 'SpreadElement') {
                 const spread = this.checkValue(property.argument);

package/dist/checker/flow.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import type { Flow, Narrowing } from './context.ts';
-import { type Type } from './types.ts';
+import type { Binding, Flow, Narrowing, Place } from './context.ts';
+import { type LiteralType, type Type } from './types.ts';
 /** What `typeof` gives for every value of a type, or `null` when it may give several things. */
 export declare function typeofTag(type: Type): string | null;
 /** The type after `typeof x == tag` is found true (`matches`) or false. */
@@ -9,8 +9,30 @@ export declare function narrowByTypeof(type: Type, tag: string, matches: boolean
 export declare function literalValue(node: ast.Expression): string | number | boolean | undefined;
 /** A type without one literal value: what is left after `x != "all"`. */
 export declare function withoutLiteral(type: Type, value: string | number | boolean): Type;
+/**
+ * A union after a comparison of its tag, a field with literal types in each member: `tags` has the
+ * values the tag may have in each member, `values` those it is compared with. When `equal`, the
+ * members whose tag may be one of the values remain; otherwise those whose tag may be another one.
+ */
+export declare function narrowByTag(type: Type, tags: readonly (readonly LiteralType['value'][])[], values: readonly LiteralType['value'][], equal: boolean): Type;
+/**
+ * Whether `field` is a tag of what `place` was declared as: then an assignment to it may change
+ * the member of the union that the place was narrowed to.
+ */
+export type IsTag = (place: Place, field: string) => boolean;
+/**
+ * Whether an assignment to the fields `written` of a variable ends the narrowing of `place`, a
+ * path of the same variable or the variable itself (the empty path): it writes the path, its
+ * start or a tag of it. `"delivery.kind"` ends the narrowing of `"delivery"`, which may come from
+ * that tag; `"delivery.floor"` does not.
+ */
+export declare function overwrites(written: string, place: Place, isTag: IsTag): boolean;
+/** Ends the narrowing that an assignment to `binding` or to its fields `written` changes. */
+export declare function forgetWritten(flow: Flow, binding: Binding, written: string, isTag: IsTag): void;
+/** The flow without what assignments to the variables `names` and the paths `paths` change. */
+export declare function withoutAssigned(flow: Flow, names: ReadonlySet<string>, paths: ReadonlySet<string>, isTag: IsTag): Flow;
 export declare function withNarrowing(flow: Flow, narrowing: Narrowing): Flow;
-/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+/** Narrowing that holds after both branches: the places narrowed the same way in both. */
 export declare function mergeFlows(a: Flow, b: Flow): Flow;
 /** Go's terminating statements: execution never continues after them. */
 export declare function isTerminating(node: ast.Statement): boolean;

package/dist/checker/flow.js

@@ -1,7 +1,7 @@
 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.
+// Control flow for the checker: how conditions narrow the types of variables and paths, and which
+// statements execution never continues after.
 /** What a value of unknown type is after `typeof x == tag`. */
 const PRIMITIVE_TAGS = new Map([
     ['string', STRING],
@@ -67,19 +67,59 @@ export function withoutLiteral(type, value) {
     const kept = unionMembers(nonNull(type)).filter((member) => !(member.kind === 'literal' && member.value === value));
     return union(isNullable(type) ? [...kept, NULL] : kept);
 }
+/**
+ * A union after a comparison of its tag, a field with literal types in each member: `tags` has the
+ * values the tag may have in each member, `values` those it is compared with. When `equal`, the
+ * members whose tag may be one of the values remain; otherwise those whose tag may be another one.
+ */
+export function narrowByTag(type, tags, values, equal) {
+    const kept = unionMembers(nonNull(type)).filter((_, i) => {
+        const tag = tags[i] ?? [];
+        return equal
+            ? tag.some((value) => values.includes(value))
+            : !tag.every((value) => values.includes(value));
+    });
+    return union(!equal && isNullable(type) ? [...kept, NULL] : kept);
+}
+/**
+ * Whether an assignment to the fields `written` of a variable ends the narrowing of `place`, a
+ * path of the same variable or the variable itself (the empty path): it writes the path, its
+ * start or a tag of it. `"delivery.kind"` ends the narrowing of `"delivery"`, which may come from
+ * that tag; `"delivery.floor"` does not.
+ */
+export function overwrites(written, place, isTag) {
+    const { path } = place;
+    if (written === '' || written === path || path.startsWith(`${written}.`))
+        return true;
+    const field = path === '' ? written : written.startsWith(`${path}.`) ? written.slice(path.length + 1) : null;
+    return field !== null && !field.includes('.') && isTag(place, field);
+}
+/** Ends the narrowing that an assignment to `binding` or to its fields `written` changes. */
+export function forgetWritten(flow, binding, written, isTag) {
+    for (const place of flow.keys()) {
+        if (place.binding === binding && overwrites(written, place, isTag))
+            flow.delete(place);
+    }
+}
+/** The flow without what assignments to the variables `names` and the paths `paths` change. */
+export function withoutAssigned(flow, names, paths, isTag) {
+    const written = [...paths].map((path) => path.split('.'));
+    return new Map([...flow].filter(([place]) => !names.has(place.binding.name) &&
+        !written.some(([root, ...fields]) => root === place.binding.name && overwrites(fields.join('.'), place, isTag))));
+}
 export function withNarrowing(flow, narrowing) {
     const result = new Map(flow);
-    for (const [binding, type] of narrowing)
-        result.set(binding, type);
+    for (const [place, type] of narrowing)
+        result.set(place, type);
     return result;
 }
-/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+/** Narrowing that holds after both branches: the places narrowed the same way in both. */
 export function mergeFlows(a, b) {
     const result = new Map();
-    for (const [binding, type] of a) {
-        const other = b.get(binding);
+    for (const [place, type] of a) {
+        const other = b.get(place);
         if (other && typesEqual(type, other))
-            result.set(binding, type);
+            result.set(place, type);
     }
     return result;
 }

package/dist/checker/functions.d.ts

@@ -1,8 +1,8 @@
 import type * as ast from '../ast.ts';
 import { type BindingKind, Scope, type Flow } from './context.ts';
-import { ControlFlowChecker } from './control-flow.ts';
+import { TaggedUnionChecker } from './tagged-unions.ts';
 import { type FunctionType, type Type } from './types.ts';
-export declare abstract class FunctionChecker extends ControlFlowChecker {
+export declare abstract 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`.

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;

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';

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/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.