rooklang 0.3.4 → 0.4.0

package/dist/checker/control-flow.js

@@ -1,10 +1,11 @@
-import { assignedNames } from "../names.js";
-import { NARROWABLE } from "./context.js";
-import { narrowByTypeof, literalValue, withoutLiteral, withNarrowing, mergeFlows, leaves, } from "./flow.js";
+import { assignedNames, assignedPaths, pathOf } from "../names.js";
+import { NARROWABLE, placeOf } from "./context.js";
+import { narrowByTypeof, literalValue, withoutLiteral, withNarrowing, mergeFlows, leaves, forgetWritten, withoutAssigned, } from "./flow.js";
 import { instanceTypeOf } from "./helpers.js";
 import { StatementChecker } from "./statements.js";
 import { ANY, BOOL, isAssignable, isComparable, isNullable, isSubclass, literal, nonNull, NULL, typeToString, union, unionMembers, widenLiterals, } from "./types.js";
-// if, for, switch and try, and how conditions narrow the types of variables in the branches.
+// if, for, switch and try, and how conditions narrow the types of variables and paths in the
+// branches.
 export class ControlFlowChecker extends StatementChecker {
     checkIf(node) {
         if (this.checkWithInit(node.init, () => this.checkIf({ ...node, init: null })))
@@ -39,8 +40,8 @@ export class ControlFlowChecker extends StatementChecker {
         this.withScope(() => {
             if (node.init)
                 this.checkSimpleStatement(node.init);
-            // Variables assigned in the loop may change between iterations.
-            this.dropNarrowing(assignedNames(node));
+            // Variables and paths assigned in the loop may change between iterations.
+            this.dropNarrowing(node);
             const entry = this.flow;
             if (node.condition)
                 this.checkCondition(node.condition);
@@ -71,7 +72,7 @@ export class ControlFlowChecker extends StatementChecker {
         if (this.checkWithInit(node.init, () => this.checkSwitch({ ...node, init: null })))
             return;
         const discriminant = node.discriminant ? this.checkValue(node.discriminant) : null;
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         for (const switchCase of node.cases) {
             this.flow = entry;
@@ -89,7 +90,7 @@ export class ControlFlowChecker extends StatementChecker {
                 ? switchCase.tests.length === 1
                     ? this.narrow(switchCase.tests[0], true)
                     : []
-                : this.narrowCase(node, switchCase, entry);
+                : this.narrowCase(node, switchCase);
             this.flow = withNarrowing(entry, narrowing);
             this.checkBlock(switchCase.body);
         }
@@ -99,18 +100,18 @@ export class ControlFlowChecker extends StatementChecker {
      * `switch filter { case "all": ... default: ... }`: in a case the discriminant has the literals
      * of its tests, in `default` the literals of no case.
      */
-    narrowCase(node, switchCase, entry) {
-        const binding = node.discriminant ? this.narrowableBinding(node.discriminant) : undefined;
-        if (!binding?.type)
+    narrowCase(node, switchCase) {
+        const target = node.discriminant ? this.narrowable(node.discriminant) : undefined;
+        if (!target)
             return [];
-        const current = entry.get(binding) ?? binding.type;
+        const { place, type: current } = target;
         if (!unionMembers(nonNull(current)).some((member) => member.kind === 'literal'))
             return [];
         if (switchCase.tests.length > 0) {
             const values = switchCase.tests.map(literalValue);
             if (values.some((value) => value === undefined))
                 return [];
-            return [[binding, union(values.map((value) => literal(value)))]];
+            return [[place, union(values.map((value) => literal(value)))]];
         }
         let rest = current;
         for (const other of node.cases) {
@@ -120,10 +121,10 @@ export class ControlFlowChecker extends StatementChecker {
                     rest = withoutLiteral(rest, value);
             }
         }
-        return [[binding, rest]];
+        return [[place, rest]];
     }
     checkTry(node) {
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         this.flow = new Map(entry);
         this.checkBlock(node.block.body);
@@ -157,7 +158,7 @@ export class ControlFlowChecker extends StatementChecker {
                         : '';
         this.error(`condition must be bool, not ${typeToString(type)}${hint}`, node);
     }
-    /** Variables whose type is narrowed when `node` evaluates to `assumeTrue`. */
+    /** Variables and paths whose type is narrowed when `node` evaluates to `assumeTrue`. */
     narrow(node, assumeTrue) {
         if (node.kind === 'UnaryExpression' && node.operator === '!') {
             return this.narrow(node.argument, !assumeTrue);
@@ -183,17 +184,21 @@ export class ControlFlowChecker extends StatementChecker {
         // `x != null` when true, `x == null` when false: `x` is not null.
         if ((operator === '!=' && assumeTrue) || (operator === '==' && !assumeTrue)) {
             const target = right.kind === 'NullLiteral' ? left : left.kind === 'NullLiteral' ? right : null;
-            const binding = target ? this.narrowableBinding(target) : undefined;
-            if (binding?.type)
-                return [[binding, nonNull(this.flow.get(binding) ?? binding.type)]];
+            const found = target ? this.narrowable(target) : undefined;
+            if (found)
+                return [[found.place, nonNull(found.type)]];
         }
         // `err == null` when true, `err != null` when false: the values returned with `err` are not
         // null (error-results.ts).
         if ((operator === '==' && assumeTrue) || (operator === '!=' && !assumeTrue)) {
             const target = right.kind === 'NullLiteral' ? left : left.kind === 'NullLiteral' ? right : null;
             const guards = target ? this.narrowableBinding(target)?.guards : undefined;
-            if (guards)
-                return guards.map((value) => [value, nonNull(this.flow.get(value) ?? value.type)]);
+            if (guards) {
+                return guards.map((value) => {
+                    const place = placeOf(value);
+                    return [place, nonNull(this.flow.get(place) ?? value.type)];
+                });
+            }
         }
         if (operator === 'instanceof')
             return this.narrowInstanceof(left, right, assumeTrue);
@@ -208,41 +213,41 @@ export class ControlFlowChecker extends StatementChecker {
                 ? [right, left]
                 : [null, null];
         if (check && tag?.kind === 'StringLiteral') {
-            const binding = this.narrowableBinding(check.argument);
-            if (!binding?.type)
+            const found = this.narrowable(check.argument);
+            if (!found)
                 return [];
-            const type = narrowByTypeof(this.flow.get(binding) ?? binding.type, tag.value, equal);
-            return type ? [[binding, type]] : [];
+            const type = narrowByTypeof(found.type, tag.value, equal);
+            return type ? [[found.place, type]] : [];
         }
         // `filter == "all"`: narrows a type with literals in it.
         const value = literalValue(right) ?? literalValue(left);
         const target = literalValue(right) !== undefined ? left : right;
-        const binding = value === undefined ? undefined : this.narrowableBinding(target);
-        if (value === undefined || !binding?.type)
+        const found = value === undefined ? undefined : this.narrowable(target);
+        if (value === undefined || !found)
             return [];
-        const current = this.flow.get(binding) ?? binding.type;
+        const { place, type: current } = found;
         if (!unionMembers(nonNull(current)).some((member) => member.kind === 'literal'))
             return [];
-        return [[binding, equal ? literal(value) : withoutLiteral(current, value)]];
+        return [[place, equal ? literal(value) : withoutLiteral(current, value)]];
     }
     /** `x instanceof Date`: an instance of the class when true, the rest of a union when false. */
     narrowInstanceof(left, right, assumeTrue) {
-        const binding = this.narrowableBinding(left);
+        const found = this.narrowable(left);
         const classType = this.typeOfChecked(right);
         const instance = instanceTypeOf(classType);
-        if (!binding?.type || !instance)
+        if (!found || !instance)
             return [];
-        const current = this.flow.get(binding) ?? binding.type;
+        const { place, type: current } = found;
         const members = unionMembers(nonNull(current));
         if (assumeTrue) {
             const kept = members.filter((member) => isAssignable(member, instance));
-            return [[binding, kept.length > 0 ? union(kept) : instance]];
+            return [[place, kept.length > 0 ? union(kept) : instance]];
         }
         // A class keeps what is not its subclass; a DOM interface what is not assignable to it.
         const kept = members.filter((member) => classType.kind === 'classValue'
             ? !(member.kind === 'class' && isSubclass(member.info, classType.info))
             : !isAssignable(member, instance));
-        return [[binding, union(isNullable(current) ? [...kept, NULL] : kept)]];
+        return [[place, union(isNullable(current) ? [...kept, NULL] : kept)]];
     }
     nullError(node) {
         const name = node.kind === 'Identifier' ? node.name : null;
@@ -259,13 +264,16 @@ export class ControlFlowChecker extends StatementChecker {
         const binding = this.lookupValue(node.name);
         return binding && NARROWABLE.has(binding.kind) ? binding : undefined;
     }
-    /** An assignment to a variable ends its narrowing. */
+    /** An assignment to a variable ends its narrowing; one to a path, that of the paths it changes. */
     forget(target) {
-        const binding = this.narrowableBinding(target);
-        if (binding)
-            this.flow.delete(binding);
+        const path = pathOf(target);
+        const binding = path ? this.lookupValue(path[0]) : undefined;
+        if (path && binding && NARROWABLE.has(binding.kind)) {
+            forgetWritten(this.flow, binding, path.slice(1).join('.'), (place, field) => this.isTagOf(place, field));
+        }
     }
-    dropNarrowing(names) {
-        this.flow = new Map([...this.flow].filter(([binding]) => !names.has(binding.name)));
+    /** Ends the narrowing of what `node` assigns: before a loop, or a statement with several ways. */
+    dropNarrowing(node) {
+        this.flow = withoutAssigned(this.flow, assignedNames(node), assignedPaths(node), (place, field) => this.isTagOf(place, field));
     }
 }

package/dist/checker/declarations.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { ImportChecker } from './imports.ts';
+import { SharedStateChecker } from './shared-state.ts';
 import { type FunctionType, type ObjectType, type Type, type TypeParam } from './types.ts';
-export declare abstract class DeclarationChecker extends ImportChecker {
+export declare abstract class DeclarationChecker extends SharedStateChecker {
     /**
      * Declares the names of a statement list first (so functions, classes and types can be used
      * before their declaration), then checks the statements in order. Function and method bodies are

package/dist/checker/declarations.js

@@ -3,12 +3,12 @@ import { isIterator } from "../iterators.js";
 import { collectValueNames } from "../names.js";
 import { recursiveComponents } from "../recursion.js";
 import { Scope } from "./context.js";
-import { ImportChecker } from "./imports.js";
+import { SharedStateChecker } from "./shared-state.js";
 import { awaited, isPromise, promiseOf } from "./promise.js";
 import { createClass, func, typeToString, UNKNOWN, } from "./types.js";
 // Declarations of a list of statements: imports, types, functions, components, decorators and
 // classes, declared before the statements are checked, so that they can refer to each other.
-export class DeclarationChecker extends ImportChecker {
+export class DeclarationChecker extends SharedStateChecker {
     /**
      * Declares the names of a statement list first (so functions, classes and types can be used
      * before their declaration), then checks the statements in order. Function and method bodies are
@@ -95,6 +95,7 @@ export class DeclarationChecker extends ImportChecker {
                         freeNames: null,
                         wrapper: null,
                         needed: [],
+                        included: [],
                         moduleNames: [],
                         expressionTypes: null,
                         inline: null,

package/dist/checker/decorator-exports.js

@@ -20,6 +20,10 @@ export class DecoratorExportChecker extends DecoratorWrapperChecker {
         // Other modules can read the variables of this one, but not assign them.
         const assigned = assignedNames(node.body);
         for (const used of info.moduleNames) {
+            if (this.moduleScope.values.get(used)?.kind === 'state') {
+                this.error(`@${name} is exported, so its code cannot read "${used}", state of its module, yet: read it in a component of the module and pass it to @${name} as an argument`, node.name);
+                continue;
+            }
             if (!assigned.has(used))
                 continue;
             this.error(`@${name} is exported, so it cannot change "${used}" of its module: other modules can only read it; change it in a function of the module`, node.name);

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

@@ -0,0 +1,9 @@
+import type { DecoratorInfo } from './context.ts';
+import { DecoratorChecker } from './decorators.ts';
+export declare abstract class DecoratorIncludeChecker extends DecoratorChecker {
+    protected resolveDecoratorParams(info: DecoratorInfo): void;
+    /** The decorators it includes are checked before it: see orderByNeeds. */
+    protected checkDecoratorBody(info: DecoratorInfo): void;
+    /** The public members of the decorators it includes become its own; each name comes once. */
+    private addIncludedMembers;
+}

package/dist/checker/decorator-includes.js

@@ -0,0 +1,71 @@
+import { DecoratorChecker } from "./decorators.js";
+import { UNKNOWN } from "./types.js";
+// Decorators that include others, `dec shop(margin string) includes visible(margin), cart { ... }`:
+// those are applied with it, above its own body, their arguments see its parameters, and their
+// public members are its own for the component, `@shop.count`.
+export class DecoratorIncludeChecker extends DecoratorChecker {
+    resolveDecoratorParams(info) {
+        super.resolveDecoratorParams(info);
+        const { node } = info;
+        const current = node.name.name;
+        const included = new Set();
+        for (const use of node.includes) {
+            const name = use.name.name;
+            const other = this.decorators.get(name);
+            if (name === current)
+                this.error(`@${name} cannot include itself`, use.name);
+            else if (included.has(name))
+                this.error(`@${name} is included twice: name it once`, use.name);
+            else if (node.needs.some((need) => need.name === name)) {
+                this.error(`@${current} both needs and includes @${name}: includes is enough`, use.name);
+            }
+            else if (!other)
+                this.error(`unknown decorator @${name}`, use.name);
+            else
+                info.included.push(other);
+            included.add(name);
+        }
+    }
+    /** The decorators it includes are checked before it: see orderByNeeds. */
+    checkDecoratorBody(info) {
+        super.checkDecoratorBody(info);
+        const { node } = info;
+        const params = node.params.map((param, i) => [
+            param.name,
+            info.params[i] ?? UNKNOWN,
+        ]);
+        for (const use of node.includes) {
+            const included = this.decorators.get(use.name.name);
+            if (included)
+                this.checkDecoratorArguments(use, included, params);
+        }
+        this.addIncludedMembers(info);
+        // A module that applies it would need the code of those it includes too.
+        if (node.exported && node.includes.length > 0) {
+            const names = node.includes.map((use) => `@${use.name.name}`).join(' ');
+            this.error(`@${node.name.name} is exported, so it cannot include decorators yet: apply them before it, e.g. ${names} @${node.name.name} comp ...`, node.includes[0]);
+        }
+    }
+    /** The public members of the decorators it includes become its own; each name comes once. */
+    addIncludedMembers(info) {
+        const current = info.node.name.name;
+        const from = new Map();
+        for (const included of info.included) {
+            const name = included.node.name.name;
+            const use = info.node.includes.find((each) => each.name.name === name);
+            for (const [member, found] of included.members) {
+                const other = from.get(member);
+                if (other !== undefined) {
+                    this.error(`@${current} gets "${member}" from both @${other} and @${name}: rename one of them`, use);
+                }
+                else if (info.members.has(member)) {
+                    this.error(`@${current} declares "${member}", which it also gets from @${name}: rename one of them`, use);
+                }
+                else {
+                    info.members.set(member, found);
+                    from.set(member, name);
+                }
+            }
+        }
+    }
+}

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

@@ -1,26 +1,24 @@
 import type * as ast from '../ast.ts';
-import type { DecoratorInfo, PublicMember } from './context.ts';
-import { DecoratorChecker } from './decorators.ts';
+import { type DecoratorInfo, type PublicMember } from './context.ts';
+import { DecoratorIncludeChecker } from './decorator-includes.ts';
 import { type Type } from './types.ts';
-export declare abstract class DecoratorMemberChecker extends DecoratorChecker {
-    /** `@visible.show`: a public function; state and constants are read with `get`. */
+export declare abstract class DecoratorMemberChecker extends DecoratorIncludeChecker {
+    /** `@visible.shown` or `@visible.show`: public state, a constant or a function. */
     protected checkDecoratorMember(node: ast.DecoratorMember): Type;
-    /** `get(@visible.shown)`: public state or a constant. */
-    protected checkDecoratorGet(node: ast.DecoratorGet): Type;
     /**
      * A public member of a decorator applied to the component being checked, or of one that the
      * decorator being checked needs.
      */
     protected findDecoratorMember(node: ast.DecoratorMember): PublicMember | null;
-    /** `get(@cart.count)` in `dec cartBadge() needs cart`. */
+    /** `@cart.count` in `dec cartBadge() needs cart`. */
     protected neededMember(node: ast.DecoratorMember, decorator: ast.DecoratorDeclaration): PublicMember | null;
     protected publicMember(node: ast.DecoratorMember, info: DecoratorInfo): PublicMember | 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.
      */
     protected checkDecoratorWrite(target: ast.Expression): boolean;
-    /** `get(@cart.items).push(x)`: a method that changes the array. */
+    /** `@cart.items.push(x)`: a method that changes the array. */
     protected checkDecoratorMutation(node: ast.CallExpression): void;
     protected readOnlyError(member: ast.DecoratorMember, node: ast.NodeBase): void;
     /** `card.count` without `@`: `card` is not a value, but a decorator may have that name. */

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.