ivue 2.5.0 → 2.6.0

package/skills/ivue/ivue-standards-check.ts

@@ -22,7 +22,7 @@
  * skip-list vocabulary, and the constitution in one gesture:
  *
  *   class $HouseGate extends CheckStandard.$Class {
- *     static get house_rule(): StandardCheck { … }
+ *     static get house_rule(): CheckStandard.StandardCheck { … }
  *     static get checks() { return [...super.checks, this.house_rule]; }
  *     static get proofs() { return { ...super.proofs, [this.house_rule.name]: … }; }
  *   }
@@ -43,167 +43,6 @@ import { parse as parseSfc } from '@vue/compiler-sfc';
 import { parse as parseTemplate, NodeTypes, type ElementNode, type TemplateChildNode } from '@vue/compiler-dom';
 import { Static } from '../../lib/Static';
 
-// ---------------------------------------------------------------------------
-// public types
-
-export interface Finding {
-  check: string;
-  file: string;
-  line: number;
-  message: string;
-}
-
-export type StaticTransform = <Class extends new (...arguments_: any[]) => any>(targetClass: Class) => Class;
-
-export interface GateOptions {
-  cwd: string;
-  sourceRoots: string[];
-  testGlobs: string[];
-  skipListPath?: string;
-  /** programmatic severity overrides (the declarative home is the gate
-   * class's `severities` getter): demoted to warnings — reported, never
-   * blocking … */
-  warnChecks?: string[];
-  /** … or disabled — not executed, announced in the summary */
-  offChecks?: string[];
-  /** the `Static` used by the runtime probe; defaults to this package's own */
-  staticImplementation?: StaticTransform | null;
-}
-
-export interface GateResult {
-  /** blocking findings — checks at severity error */
-  findings: Finding[];
-  /** findings from checks demoted to warn — reported, never blocking */
-  warnings: Finding[];
-  suppressed: Finding[];
-  sources: string[];
-  tests: string[];
-  unenforced: string[];
-  /** checks turned off for this run — announced, never silent */
-  off: string[];
-}
-
-export interface StandardCheck {
-  /** The identity: a plain declarative sentence, used verbatim everywhere. */
-  name: string;
-  /** false = registered in the manifest but not enforced yet; the report says so. */
-  enforced: boolean;
-  run(context: GateContext): Finding[];
-}
-
-/** One permanent proof fixture: a small checkout the gate runs over. */
-export interface CheckProofArm {
-  /** repo-relative path → file text; sources under `src/` by convention */
-  files: Record<string, string>;
-  /** package.json for the fixture checkout (default: an ivue consumer) */
-  manifest?: Record<string, unknown>;
-  /** GateOptions overrides for this arm (e.g. a broken staticImplementation) */
-  options?: Partial<GateOptions>;
-  /** red arms: each pattern must match at least one of the check's findings */
-  expectFindings?: (RegExp | string)[];
-  /** red arms: exact number of findings the check must produce */
-  expectCount?: number;
-  /** arms with warn-demoted checks: each pattern must match a warning */
-  expectWarnings?: (RegExp | string)[];
-  /** red arms for population refusals: run() must throw matching this */
-  expectThrows?: RegExp;
-}
-
-/** A check's constitution entry: its claim, its boundary, and both arms. */
-export interface CheckProof {
-  claim: string;
-  impossibility: string;
-  red: CheckProofArm[];
-  green: CheckProofArm[];
-}
-
-export interface ProveReport {
-  problems: string[];
-  ran: { red: number; green: number };
-}
-
-export interface SourceUnit {
-  path: string;
-  relativePath: string;
-  text: string;
-  lines: string[];
-  ast: ts.SourceFile;
-}
-
-/** A `.vue` single-file component: its script setup as TS plus every template expression. */
-export interface ComponentUnit {
-  path: string;
-  relativePath: string;
-  text: string;
-  script: SourceUnit | null;
-  /** 1-based line of the script block's first line in the .vue file */
-  scriptLine: number;
-  expressions: TemplateExpression[];
-}
-
-export interface TemplateExpression {
-  code: string;
-  line: number;
-  kind: string;
-}
-
-export interface GateContext {
-  cwd: string;
-  /** absolute source roots, as discovered */
-  sourceRoots: string[];
-  sources: SourceUnit[];
-  tests: SourceUnit[];
-  components: ComponentUnit[];
-  testGlobs: string[];
-  staticImplementation: StaticTransform | null;
-}
-
-interface ClassFile {
-  unit: SourceUnit;
-  rawClass: ts.ClassDeclaration;
-  rawName: string;
-  publicName: string;
-  namespace: ts.ModuleDeclaration | null;
-  anchorInitializer: ts.Expression | null;
-  classInitializer: ts.Expression | null;
-  hasInstanceType: boolean;
-  isReactive: boolean;
-  isStaticAnchored: boolean;
-}
-
-interface GeneratorHeader {
-  present: boolean;
-  firstContent: boolean;
-  goal: string;
-  formal: string;
-  described: string;
-  orderedRegisters: boolean;
-  bothRegisters: boolean;
-  subjects: { path: string; line: number }[];
-  domainClaims: Map<string, { symbol: string; claim: string; line: number }>;
-  domainSymbols: Set<string>;
-  impossibilities: Map<string, number>;
-  contractLinks: { text: string; file: string; anchor: string; line: number }[];
-  endLine: number;
-}
-
-interface ProofAnnotation {
-  type: 'domain' | 'impossible' | 'record';
-  symbol?: string;
-  claim?: string;
-  name?: string;
-  contractPath?: string;
-  line: number;
-  bound: boolean;
-}
-
-interface SkipRow {
-  path: string;
-  check: string;
-  reason: string;
-  line: number;
-}
-
 // ---------------------------------------------------------------------------
 // the gate class — statics only; getters carry data, methods carry behavior
 
@@ -214,7 +53,7 @@ class $CheckStandard {
 
   static readonly BANNED_NAMES = new Set([
     'inst', 'qty', 'agg', 'nv', 'ov', 'val', 'arr', 'obj', 'fn', 'cb', 'el', 'evt', 'tmp', 'idx', 'err',
-    'num', 'str', 'ctx', 'res', 'msg', 'cnt', 'len', 'ret', 'prev', 'old',
+    'num', 'str', 'ctx', 'res', 'msg', 'cnt', 'len', 'ret', 'prev', 'old', 'ci', 'ri',
   ]);
 
   static readonly DOMAIN_TERMS = new Set(['px', 'id', 'fx', 'x', 'y', 'z']);
@@ -254,7 +93,7 @@ class $CheckStandard {
   // -------------------------------------------------------------------------
   // the checks — the getter name is the snake_case of the sentence name
 
-  static get exactly_one_reactive_source_is_installed(): StandardCheck {
+  static get exactly_one_reactive_source_is_installed(): CheckStandard.StandardCheck {
     return this.defineCheck('exactly_one_reactive_source_is_installed', (context) => {
       const vendored = context.sources.filter((unit) => /export\s+function\s+Reactive\s*[<(]/.test(unit.text) || /export\s*\{[^}]*\bReactive\b[^}]*\}\s*from/.test(unit.text));
       const manifests = new Set<string>();
@@ -288,9 +127,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_public_class_publishes_its_namespace_manifest(): StandardCheck {
+  static get a_public_class_publishes_its_namespace_manifest(): CheckStandard.StandardCheck {
     return this.defineCheck('a_public_class_publishes_its_namespace_manifest', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const unwrap = (expression: ts.Expression): ts.Expression => {
         let current = expression;
         while (ts.isSatisfiesExpression(current) || ts.isAsExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
@@ -336,9 +175,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_class_file_is_named_after_its_class(): StandardCheck {
+  static get a_class_file_is_named_after_its_class(): CheckStandard.StandardCheck {
     return this.defineCheck('a_class_file_is_named_after_its_class', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -350,9 +189,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_class_file_holds_only_imports_class_namespace_and_types(): StandardCheck {
+  static get a_class_file_holds_only_imports_class_namespace_and_types(): CheckStandard.StandardCheck {
     return this.defineCheck('a_class_file_holds_only_imports_class_namespace_and_types', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -374,7 +213,14 @@ class $CheckStandard {
             if (!seenClass) findings.push(this.finding(this.a_class_file_holds_only_imports_class_namespace_and_types, unit, this.lineOf(unit, statement), `namespace ${classFile.publicName} precedes its class ${classFile.rawName}`));
             continue;
           }
-          if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isEnumDeclaration(statement)) continue;
+          // `interface $Box extends ReactiveHelpers {}` merges the engine's
+          // helpers into the class's own instance type — it is the class's
+          // second half, not a type outside the namespace
+          if (ts.isInterfaceDeclaration(statement) && statement.name.text === classFile.rawName) continue;
+          if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isEnumDeclaration(statement)) {
+            findings.push(this.finding(this.a_class_file_holds_only_imports_class_namespace_and_types, unit, this.lineOf(unit, statement), `\`${statement.name.text}\` is a type outside the namespace — every type a class file declares is a member of \`namespace ${classFile.publicName}\` (export type / interface), read as \`${classFile.publicName}.${statement.name.text}\``));
+            continue;
+          }
           if (ts.isExportDeclaration(statement) && statement.isTypeOnly) continue;
           findings.push(this.finding(this.a_class_file_holds_only_imports_class_namespace_and_types, unit, this.lineOf(unit, statement), 'behavior or data outside the class seam — move it into the class (static get / method) or its namespace'));
         }
@@ -383,9 +229,36 @@ class $CheckStandard {
     });
   }
 
-  static get behavior_lives_on_the_prototype_not_in_fields(): StandardCheck {
+  static get the_namespace_holds_identity_and_types_only(): CheckStandard.StandardCheck {
+    return this.defineCheck('the_namespace_holds_identity_and_types_only', (context) => {
+      const findings: CheckStandard.Finding[] = [];
+      for (const unit of context.sources) {
+        const classFile = this.classFileOf(unit);
+        if (!classFile?.namespace?.body || !ts.isModuleBlock(classFile.namespace.body)) continue;
+        for (const statement of classFile.namespace.body.statements) {
+          if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isEnumDeclaration(statement)) continue;
+          if (ts.isExportDeclaration(statement) && statement.isTypeOnly) continue;
+          if (ts.isVariableStatement(statement)) {
+            const names = statement.declarationList.declarations.map((declaration) => (ts.isIdentifier(declaration.name) ? declaration.name.text : '?'));
+            const identity = names.every((name) => name === '$Class' || name === 'Class');
+            if (identity) continue;
+            findings.push(this.finding(this.the_namespace_holds_identity_and_types_only, unit, this.lineOf(unit, statement), `\`${names.join(', ')}\` is runtime data in namespace ${classFile.publicName} — a parallel world the class mechanics cannot reach (not inherited, not overridable, not swapped with Class); move it onto the class as a static getter`));
+            continue;
+          }
+          if (ts.isFunctionDeclaration(statement)) {
+            findings.push(this.finding(this.the_namespace_holds_identity_and_types_only, unit, this.lineOf(unit, statement), `\`${statement.name?.text ?? 'function'}\` is behavior in namespace ${classFile.publicName} — move it onto the class as a static method`));
+            continue;
+          }
+          findings.push(this.finding(this.the_namespace_holds_identity_and_types_only, unit, this.lineOf(unit, statement), `namespace ${classFile.publicName} holds a runtime statement — the namespace is \`$Class\`, \`Class\` and types only`));
+        }
+      }
+      return findings;
+    });
+  }
+
+  static get behavior_lives_on_the_prototype_not_in_fields(): CheckStandard.StandardCheck {
     return this.defineCheck('behavior_lives_on_the_prototype_not_in_fields', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -398,9 +271,9 @@ class $CheckStandard {
     });
   }
 
-  static get construction_goes_through_the_namespace_class_slot(): StandardCheck {
+  static get construction_goes_through_the_namespace_class_slot(): CheckStandard.StandardCheck {
     return this.defineCheck('construction_goes_through_the_namespace_class_slot', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         this.forEachDescendant(unit.ast, (node) => {
           if (ts.isNewExpression(node)) {
@@ -410,17 +283,22 @@ class $CheckStandard {
             if (ts.isPropertyAccessExpression(callee) && callee.name.text === '$Class')
               findings.push(this.finding(this.construction_goes_through_the_namespace_class_slot, unit, this.lineOf(unit, node), `\`new ${callee.getText(unit.ast)}()\` constructs the anchor — construct \`.Class\``));
           }
+          // `reactive(new X.Class())` bare is the proxy-on-the-standard-path
+          // mistake; `reactive(new X.Class() as X.Instance)` is the sanctioned
+          // interop form (a store's optional reactive() view) — the cast is
+          // what makes the unwrapped writes typecheck, so its presence is
+          // the signal that the author chose the concession knowingly.
           if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'reactive' && node.arguments[0] && ts.isNewExpression(node.arguments[0]))
-            findings.push(this.finding(this.construction_goes_through_the_namespace_class_slot, unit, this.lineOf(unit, node), '`reactive(new …)` wraps an instance — instances are raw; no proxy on the standard path'));
+            findings.push(this.finding(this.construction_goes_through_the_namespace_class_slot, unit, this.lineOf(unit, node), '`reactive(new …)` wraps an instance without the Instance cast — instances are raw; a reactive() view is `reactive(new X.Class() as X.Instance)`'));
         });
       }
       return findings;
     });
   }
 
-  static get the_anchor_is_static_only_when_statics_exist(): StandardCheck {
+  static get the_anchor_is_static_only_when_statics_exist(): CheckStandard.StandardCheck {
     return this.defineCheck('the_anchor_is_static_only_when_statics_exist', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile?.namespace || !classFile.anchorInitializer) continue;
@@ -435,13 +313,13 @@ class $CheckStandard {
     });
   }
 
-  static get static_binds_methods_and_caches_dollar_getters_per_receiver(): StandardCheck {
+  static get static_binds_methods_and_caches_dollar_getters_per_receiver(): CheckStandard.StandardCheck {
     return this.defineCheck('static_binds_methods_and_caches_dollar_getters_per_receiver', (context) => {
-      const unit: SourceUnit | undefined = context.sources[0];
-      const probe = (message: string): Finding => ({ check: 'static_binds_methods_and_caches_dollar_getters_per_receiver', file: 'ivue/extras', line: 0, message: `${message} (probed from ${unit?.relativePath ?? 'the gate'})` });
+      const unit: CheckStandard.SourceUnit | undefined = context.sources[0];
+      const probe = (message: string): CheckStandard.Finding => ({ check: 'static_binds_methods_and_caches_dollar_getters_per_receiver', file: 'ivue/extras', line: 0, message: `${message} (probed from ${unit?.relativePath ?? 'the gate'})` });
       const StaticUnderTest = context.staticImplementation;
       if (!StaticUnderTest) return [probe('`Static` could not be loaded from ivue/extras — the runtime probe did not run')];
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       let cacheRuns = 0;
       class $Probe {
         static get $cache() {
@@ -466,9 +344,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_shared_store_is_a_static_readonly_field(): StandardCheck {
+  static get a_shared_store_is_a_static_readonly_field(): CheckStandard.StandardCheck {
     return this.defineCheck('a_shared_store_is_a_static_readonly_field', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -493,9 +371,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_derived_static_getter_is_lower_camel_case(): StandardCheck {
+  static get a_derived_static_getter_is_lower_camel_case(): CheckStandard.StandardCheck {
     return this.defineCheck('a_derived_static_getter_is_lower_camel_case', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const isLiteral = (expression: ts.Expression): boolean => {
         if (ts.isNumericLiteral(expression) || ts.isStringLiteralLike(expression) || ts.isRegularExpressionLiteral(expression) || expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) return true;
         if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken) return isLiteral(expression.operand);
@@ -504,6 +382,9 @@ class $CheckStandard {
         if (ts.isArrayLiteralExpression(expression)) return expression.elements.every((element) => ts.isExpression(element) && isLiteral(element));
         if (ts.isObjectLiteralExpression(expression)) return expression.properties.every((property) => ts.isPropertyAssignment(property) && isLiteral(property.initializer));
         if (ts.isAsExpression(expression)) return isLiteral(expression.expression);
+        // A reference to another SCREAMING constant — `this.X`, `Other.Class.X` — is
+        // a constant too: a knobs tree composed of parts' constants stays a constant.
+        if (ts.isPropertyAccessExpression(expression)) return /^[A-Z][A-Z0-9_]*$/.test(expression.name.text) && expression.name.text.includes('_');
         return false;
       };
       for (const unit of context.sources) {
@@ -516,16 +397,16 @@ class $CheckStandard {
           const returned = member.body.statements.find(ts.isReturnStatement)?.expression;
           if (returned && isLiteral(returned)) continue;
           const camel = name.toLowerCase().replace(/_(\w)/g, (whole, letter: string) => letter.toUpperCase());
-          findings.push(this.finding(this.a_derived_static_getter_is_lower_camel_case, unit, this.lineOf(unit, member), `static get ${name}() derives its value — a derived getter is lowerCamel (\`${camel}\`); SCREAMING_SNAKE is for literal tunable constants`));
+          findings.push(this.finding(this.a_derived_static_getter_is_lower_camel_case, unit, this.lineOf(unit, member), `static get ${name}() derives its value — a derived getter is lowerCamel (\`${camel}\`); SCREAMING_SNAKE is for tunable constants: literals, or other SCREAMING constants composed`));
         }
       }
       return findings;
     });
   }
 
-  static get static_reads_go_through_self_not_the_base_class(): StandardCheck {
+  static get static_reads_go_through_self_not_the_base_class(): CheckStandard.StandardCheck {
     return this.defineCheck('static_reads_go_through_self_not_the_base_class', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -543,16 +424,16 @@ class $CheckStandard {
     });
   }
 
-  static get mutable_state_is_a_ref_returning_getter(): StandardCheck {
+  static get mutable_state_is_a_ref_returning_getter(): CheckStandard.StandardCheck {
     return this.defineCheck('mutable_state_is_a_ref_returning_getter', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         // A plain namespace class (no Reactive) holds plain state — there
         // is no reactivity for a field write to trigger.
         if (!classFile?.isReactive) continue;
         for (const member of classFile.rawClass.members) {
-          if (!ts.isPropertyDeclaration(member) || this.isStaticMember(member) || this.isReadonlyMember(member)) continue;
+          if (!ts.isPropertyDeclaration(member) || this.isStaticMember(member) || this.isReadonlyMember(member) || this.isDeclaredMember(member)) continue;
           const initializer = member.initializer;
           const fromFactory =
             !!initializer &&
@@ -568,9 +449,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_ref_is_read_and_written_through_value(): StandardCheck {
+  static get a_ref_is_read_and_written_through_value(): CheckStandard.StandardCheck {
     return this.defineCheck('a_ref_is_read_and_written_through_value', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -587,9 +468,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_derivation_is_a_plain_getter_unless_computed_is_justified(): StandardCheck {
+  static get a_derivation_is_a_plain_getter_unless_computed_is_justified(): CheckStandard.StandardCheck {
     return this.defineCheck('a_derivation_is_a_plain_getter_unless_computed_is_justified', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -607,15 +488,15 @@ class $CheckStandard {
     });
   }
 
-  static get a_composable_is_injected_by_a_one_call_dollar_getter(): StandardCheck {
+  static get a_composable_is_injected_by_a_one_call_dollar_getter(): CheckStandard.StandardCheck {
     return this.defineCheck('a_composable_is_injected_by_a_one_call_dollar_getter', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
         for (const member of classFile.rawClass.members) {
           if (ts.isPropertyDeclaration(member) && member.initializer && ts.isCallExpression(member.initializer) && ts.isIdentifier(member.initializer.expression) && /^use[A-Z]/.test(member.initializer.expression.text))
-            findings.push(this.finding(this.a_composable_is_injected_by_a_one_call_dollar_getter, unit, this.lineOf(unit, member), `\`${this.memberName(member)} = ${member.initializer.expression.text}()\` runs at construction — inject it as \`private get $${this.memberName(member)}() { return ${member.initializer.expression.text}() }\``));
+            findings.push(this.finding(this.a_composable_is_injected_by_a_one_call_dollar_getter, unit, this.lineOf(unit, member), `\`${this.memberName(member)} = ${member.initializer.expression.text}()\` runs at construction — inject it as \`protected get $${this.memberName(member)}() { return ${member.initializer.expression.text}() }\``));
           if (ts.isGetAccessorDeclaration(member) && this.memberName(member).startsWith('$') && member.body) {
             const statements = member.body.statements;
             const single = statements.length === 1 && ts.isReturnStatement(statements[0]) && !!statements[0].expression && (ts.isCallExpression(statements[0].expression) || ts.isNewExpression(statements[0].expression) || ts.isPropertyAccessExpression(statements[0].expression));
@@ -628,11 +509,11 @@ class $CheckStandard {
     });
   }
 
-  static get instance_types_only_unwrapping_surfaces(): StandardCheck {
+  static get instance_types_only_unwrapping_surfaces(): CheckStandard.StandardCheck {
     return this.defineCheck('instance_types_only_unwrapping_surfaces', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const RAW_CONTAINERS = new Set(['Array', 'ReadonlyArray', 'Map', 'Set', 'WeakMap', 'ref', 'shallowRef', 'Ref', 'ShallowRef']);
-      const inspect = (unit: SourceUnit, report: (line: number, message: string) => void) => {
+      const inspect = (unit: CheckStandard.SourceUnit, report: (line: number, message: string) => void) => {
         this.forEachDescendant(unit.ast, (node) => {
           if (ts.isTypeReferenceNode(node)) {
             const tail = this.qualifiedTail(node);
@@ -659,9 +540,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_component_has_one_model_owner(): StandardCheck {
+  static get a_component_has_one_model_owner(): CheckStandard.StandardCheck {
     return this.defineCheck('a_component_has_one_model_owner', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const component of context.components) {
         if (!component.script) continue;
         const constructions = this.modelConstructions(component);
@@ -671,9 +552,9 @@ class $CheckStandard {
     });
   }
 
-  static get script_setup_is_wiring_only(): StandardCheck {
+  static get script_setup_is_wiring_only(): CheckStandard.StandardCheck {
     return this.defineCheck('script_setup_is_wiring_only', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const component of context.components) {
         if (!component.script) continue;
         for (const statement of component.script.ast.statements) {
@@ -690,9 +571,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_lifecycle_hook_delegates_to_one_method(): StandardCheck {
+  static get a_lifecycle_hook_delegates_to_one_method(): CheckStandard.StandardCheck {
     return this.defineCheck('a_lifecycle_hook_delegates_to_one_method', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const component of context.components) {
         if (!component.script) continue;
         this.forEachDescendant(component.script.ast, (node) => {
@@ -709,9 +590,9 @@ class $CheckStandard {
     });
   }
 
-  static get the_state_destructure_is_total(): StandardCheck {
+  static get the_state_destructure_is_total(): CheckStandard.StandardCheck {
     return this.defineCheck('the_state_destructure_is_total', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const component of context.components) {
         if (!component.script) continue;
         const props = this.propNames(component);
@@ -755,9 +636,43 @@ class $CheckStandard {
     });
   }
 
-  static get template_expressions_carry_no_logic(): StandardCheck {
+  static get one_handler_per_event(): CheckStandard.StandardCheck {
+    return this.defineCheck('one_handler_per_event', (context) => {
+      const findings: CheckStandard.Finding[] = [];
+      const visit = (nodes: TemplateChildNode[], component: CheckStandard.ComponentUnit, offset: number) => {
+        for (const node of nodes) {
+          if (node.type !== NodeTypes.ELEMENT) continue;
+          const element = node as ElementNode;
+          const handlers = new Map<string, string[]>();
+          for (const property of element.props) {
+            if (property.type !== NodeTypes.DIRECTIVE || property.name !== 'on') continue;
+            if (!property.arg || property.arg.type !== NodeTypes.SIMPLE_EXPRESSION || !property.arg.isStatic) continue;
+            if (!property.exp || property.exp.type !== NodeTypes.SIMPLE_EXPRESSION) continue;
+            const handler = property.exp.content.trim();
+            const events = handlers.get(handler) ?? [];
+            events.push(property.arg.content);
+            handlers.set(handler, events);
+          }
+          for (const [handler, events] of handlers) {
+            if (events.length < 2) continue;
+            findings.push(this.componentFinding(this.one_handler_per_event, component, element.loc.start.line + offset, `\`@${events.join('` and `@')}\` bind one handler (\`${handler}\`) — one DOM event, one handler named for the event: give each its own method, a one-line delegate where they coincide, so a subclass can extend either alone`));
+          }
+          visit(element.children, component, offset);
+        }
+      };
+      for (const component of context.components) {
+        const { descriptor } = parseSfc(component.text, { filename: component.path });
+        if (!descriptor.template) continue;
+        const templateAst = parseTemplate(descriptor.template.content, { comments: false });
+        visit(templateAst.children, component, descriptor.template.loc.start.line - 1);
+      }
+      return findings;
+    });
+  }
+
+  static get template_expressions_carry_no_logic(): CheckStandard.StandardCheck {
     return this.defineCheck('template_expressions_carry_no_logic', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const isNamedRead = (expression: ts.Expression): boolean => {
         if (ts.isIdentifier(expression) || expression.kind === ts.SyntaxKind.ThisKeyword) return true;
         if (ts.isPropertyAccessExpression(expression)) return isNamedRead(expression.expression);
@@ -799,20 +714,41 @@ class $CheckStandard {
     });
   }
 
-  static get watch_lifetime_matches_the_instance_owner(): StandardCheck {
+  static get watch_lifetime_matches_the_instance_owner(): CheckStandard.StandardCheck {
     return this.defineCheck('watch_lifetime_matches_the_instance_owner', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const componentScoped = new Set<string>();
       for (const component of context.components) for (const construction of this.modelConstructions(component)) componentScoped.add(construction.namespace);
-      const outliving = new Set<string>();
+      // A class constructed INSIDE a component-scoped class (its constructor
+      // or a `$`-getter touched there) shares that component's lifetime —
+      // the host is the seam; close over hosts to a fixpoint.
+      const constructedInside = new Map<string, Set<string>>();
+      const constructedElsewhere = new Set<string>();
       for (const unit of context.sources) {
+        const classFile = this.classFileOf(unit);
         this.forEachDescendant(unit.ast, (node) => {
           if (!ts.isNewExpression(node) || !ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== 'Class' || !ts.isIdentifier(node.expression.expression)) return;
-          outliving.add(node.expression.expression.text);
+          const constructed = node.expression.expression.text;
+          let ancestor: ts.Node | undefined = node.parent;
+          while (ancestor && ancestor !== classFile?.rawClass) ancestor = ancestor.parent;
+          if (classFile && ancestor === classFile.rawClass) {
+            if (!constructedInside.has(classFile.publicName)) constructedInside.set(classFile.publicName, new Set());
+            constructedInside.get(classFile.publicName)!.add(constructed);
+          } else constructedElsewhere.add(constructed);
         });
-        const classFile = this.classFileOf(unit);
-        if (classFile?.namespace?.body && ts.isModuleBlock(classFile.namespace.body) && classFile.namespace.body.statements.some((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === 'use')) outliving.add(classFile.publicName);
+        if (classFile?.namespace?.body && ts.isModuleBlock(classFile.namespace.body) && classFile.namespace.body.statements.some((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === 'use')) constructedElsewhere.add(classFile.publicName);
+        if (classFile && classFile.rawClass.members.some((member) => ts.isMethodDeclaration(member) && this.isStaticMember(member) && this.memberName(member) === 'use')) constructedElsewhere.add(classFile.publicName);
       }
+      let grew = true;
+      while (grew) {
+        grew = false;
+        for (const [host, constructed] of constructedInside) {
+          if (!componentScoped.has(host)) continue;
+          for (const name of constructed) if (!componentScoped.has(name)) { componentScoped.add(name); grew = true; }
+        }
+      }
+      const outliving = new Set<string>(constructedElsewhere);
+      for (const [host, constructed] of constructedInside) if (!componentScoped.has(host)) for (const name of constructed) outliving.add(name);
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile) continue;
@@ -820,6 +756,7 @@ class $CheckStandard {
         let usesDollarWatch = false;
         let usesPlainWatch = false;
         let hasDisposePath = false;
+        let hasScopeBridge = false;
         let dollarLine = 0;
         let plainLine = 0;
         this.forEachDescendant(classFile.rawClass, (node) => {
@@ -837,12 +774,18 @@ class $CheckStandard {
               usesPlainWatch = true;
               plainLine ||= this.lineOf(unit, node);
             }
-            if (callee.text === 'onScopeDispose') hasDisposePath = true;
+            if (callee.text === 'onScopeDispose') {
+              hasDisposePath = true;
+              hasScopeBridge = true;
+            }
           }
         });
         const isComponentScoped = componentScoped.has(name) && !outliving.has(name);
         const isOutliving = outliving.has(name);
-        if (isComponentScoped && usesDollarWatch) findings.push(this.finding(this.watch_lifetime_matches_the_instance_owner, unit, dollarLine, `${classFile.rawName} is constructed in a component's setup but uses \`this.$watch\` — its scope would outlive unmount; use plain \`watch\` (the component scope reaps it)`));
+        // the guide's bridge — `getCurrentScope() && onScopeDispose(() =>
+        // this.dispose())` — is the sanctioned way for an outliving-shaped
+        // class to be constructed inside a component as well
+        if (isComponentScoped && usesDollarWatch && !hasScopeBridge) findings.push(this.finding(this.watch_lifetime_matches_the_instance_owner, unit, dollarLine, `${classFile.rawName} is constructed in a component's setup but uses \`this.$watch\` — its scope would outlive unmount; use plain \`watch\` (the component scope reaps it)`));
         if (isOutliving && usesPlainWatch) findings.push(this.finding(this.watch_lifetime_matches_the_instance_owner, unit, plainLine, `${classFile.rawName} outlives components (constructed outside setup) but uses plain \`watch\` — there is no component scope to reap it; use \`this.$watch\``));
         if (usesDollarWatch && !hasDisposePath) findings.push(this.finding(this.watch_lifetime_matches_the_instance_owner, unit, dollarLine, `${classFile.rawName} registers \`$watch\` effects but has no dispose path — call \`$stopEffects()\` from an owner method, or auto-wire \`onScopeDispose\``));
       }
@@ -850,9 +793,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_reactive_closure_delegates_to_one_method(): StandardCheck {
+  static get a_reactive_closure_delegates_to_one_method(): CheckStandard.StandardCheck {
     return this.defineCheck('a_reactive_closure_delegates_to_one_method', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const reactiveCallees = new Set(['computed', 'watch', 'watchEffect', '$watch', '$watchEffect']);
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
@@ -884,9 +827,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_store_is_used_lazily_and_swapped_at_the_class_slot(): StandardCheck {
+  static get a_store_is_used_lazily_and_swapped_at_the_class_slot(): CheckStandard.StandardCheck {
     return this.defineCheck('a_store_is_used_lazily_and_swapped_at_the_class_slot', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         this.forEachDescendant(unit.ast, (node) => {
           if (ts.isNewExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'Class' && !this.isInsideFunctionBody(node))
@@ -894,7 +837,7 @@ class $CheckStandard {
           if (ts.isParameter(node) && node.type && ts.isConstructorDeclaration(node.parent)) {
             const tail = this.qualifiedTail(node.type);
             if (tail && (tail.member === 'Instance' || tail.member === 'Model') && ts.isIdentifier(node.name) && /^(app|store|session|root|shell)$/i.test(node.name.text))
-              findings.push(this.finding(this.a_store_is_used_lazily_and_swapped_at_the_class_slot, unit, this.lineOf(unit, node), `constructor takes the shared model \`${node.name.text}: ${tail.namespace}.${tail.member}\` — reach for it with \`private get $${node.name.text}() { return ${tail.namespace}.use() }\``));
+              findings.push(this.finding(this.a_store_is_used_lazily_and_swapped_at_the_class_slot, unit, this.lineOf(unit, node), `constructor takes the shared model \`${node.name.text}: ${tail.namespace}.${tail.member}\` — reach for it with \`protected get $${node.name.text}() { return ${tail.namespace}.use() }\``));
           }
         });
       }
@@ -917,9 +860,9 @@ class $CheckStandard {
     });
   }
 
-  static get keyed_state_creates_on_read_and_peeks_on_write(): StandardCheck {
+  static get keyed_state_creates_on_read_and_peeks_on_write(): CheckStandard.StandardCheck {
     return this.defineCheck('keyed_state_creates_on_read_and_peeks_on_write', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const REF_TYPES = /\b(?:Ref|ShallowRef|ComputedRef|WritableComputedRef)\s*</;
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
@@ -945,9 +888,9 @@ class $CheckStandard {
     });
   }
 
-  static get a_generic_reactive_class_casts_its_constructor(): StandardCheck {
+  static get a_generic_reactive_class_casts_its_constructor(): CheckStandard.StandardCheck {
     return this.defineCheck('a_generic_reactive_class_casts_its_constructor', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const classFile = this.classFileOf(unit);
         if (!classFile?.namespace?.body || !classFile.rawClass.typeParameters?.length || !classFile.isReactive) continue;
@@ -962,9 +905,9 @@ class $CheckStandard {
     });
   }
 
-  static get cross_module_class_reads_happen_inside_bodies(): StandardCheck {
+  static get cross_module_class_reads_happen_inside_bodies(): CheckStandard.StandardCheck {
     return this.defineCheck('cross_module_class_reads_happen_inside_bodies', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       for (const unit of context.sources) {
         const imported = this.importedBindings(unit);
         if (!imported.size) continue;
@@ -982,7 +925,13 @@ class $CheckStandard {
           if (!ts.isPropertyAccessExpression(node) || !ts.isIdentifier(node.expression)) return;
           if (!imported.has(node.expression.text)) return;
           if (node.name.text !== 'Class' && node.name.text !== '$Class') return;
-          if (node.parent && ts.isExpressionWithTypeArguments(node.parent) && node.name.text === '$Class') return;
+          if (node.name.text === '$Class') {
+            // `extends X.$Class` — also through a cast, `extends (X.$Class as typeof X.$Class)<T>`,
+            // which a generic subclass needs to keep its type parameter
+            let heritage: ts.Node = node.parent;
+            while (heritage && (ts.isAsExpression(heritage) || ts.isParenthesizedExpression(heritage))) heritage = heritage.parent;
+            if (heritage && ts.isExpressionWithTypeArguments(heritage)) return;
+          }
           if (this.isInsideFunctionBody(node)) return;
           findings.push(this.finding(this.cross_module_class_reads_happen_inside_bodies, unit, this.lineOf(unit, node), `\`${node.getText(unit.ast)}\` is read at module evaluation — read it inside a getter or method body (any load order then resolves)`));
         });
@@ -991,10 +940,10 @@ class $CheckStandard {
     });
   }
 
-  static get declarations_use_full_descriptive_names(): StandardCheck {
+  static get declarations_use_full_descriptive_names(): CheckStandard.StandardCheck {
     return this.defineCheck('declarations_use_full_descriptive_names', (context) => {
-      const findings: Finding[] = [];
-      const inspect = (unit: SourceUnit) => {
+      const findings: CheckStandard.Finding[] = [];
+      const inspect = (unit: CheckStandard.SourceUnit) => {
         this.forEachDescendant(unit.ast, (node) => {
           let identifier: ts.Identifier | null = null;
           if ((ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node)) && ts.isIdentifier(node.name)) identifier = node.name;
@@ -1010,16 +959,29 @@ class $CheckStandard {
       };
       for (const unit of context.sources) inspect(unit);
       for (const unit of context.tests) inspect(unit);
+      // a `v-for` alias is a declaration the template makes — same rule
+      for (const component of context.components) {
+        for (const alias of component.forAliases) {
+          for (const name of alias.names) {
+            const bare = name.replace(/^[$_]+/, '');
+            if (name === '_' || (bare.length === 1 && !this.DOMAIN_TERMS.has(bare)) || this.BANNED_NAMES.has(bare.toLowerCase()))
+              findings.push(this.componentFinding(this.declarations_use_full_descriptive_names, component, alias.line, `\`${name}\` as a \`v-for\` alias — unfold to the domain word (row, cell, column, index…); single letters and abbreviations are not names`));
+          }
+        }
+      }
       return findings;
     });
   }
 
-  static get class_members_are_ordered_and_spaced(): StandardCheck {
+  static get class_members_are_ordered_and_spaced(): CheckStandard.StandardCheck {
     return this.defineCheck('class_members_are_ordered_and_spaced', (context) => {
-      const findings: Finding[] = [];
+      const findings: CheckStandard.Finding[] = [];
       const rank = (member: ts.ClassElement): number => {
         if (this.isStaticMember(member)) return 0;
         if (ts.isConstructorDeclaration(member)) return 1;
+        // a `declare` member is a type statement (the engine installs the
+        // value at Reactive()); it reads first, with the statics
+        if (ts.isPropertyDeclaration(member) && this.isDeclaredMember(member)) return 0;
         if (ts.isPropertyDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) return 2;
         return 3;
       };
@@ -1057,7 +1019,7 @@ class $CheckStandard {
 
 
 
-  static get the_population_and_skip_list_are_exact(): StandardCheck {
+  static get the_population_and_skip_list_are_exact(): CheckStandard.StandardCheck {
     // enforced by run() itself; its findings and refusals carry this name
     return this.defineCheck('the_population_and_skip_list_are_exact', () => []);
   }
@@ -1065,12 +1027,13 @@ class $CheckStandard {
 
   /** The manifest, in the Standard's order — reads through `this`, so a
    * subclass's overridden or added check getters flow into it. */
-  static get checks(): readonly StandardCheck[] {
+  static get checks(): readonly CheckStandard.StandardCheck[] {
     return [
       this.exactly_one_reactive_source_is_installed,
       this.a_public_class_publishes_its_namespace_manifest,
       this.a_class_file_is_named_after_its_class,
       this.a_class_file_holds_only_imports_class_namespace_and_types,
+      this.the_namespace_holds_identity_and_types_only,
       this.behavior_lives_on_the_prototype_not_in_fields,
       this.construction_goes_through_the_namespace_class_slot,
       this.the_anchor_is_static_only_when_statics_exist,
@@ -1088,6 +1051,7 @@ class $CheckStandard {
       this.a_lifecycle_hook_delegates_to_one_method,
       this.the_state_destructure_is_total,
       this.template_expressions_carry_no_logic,
+      this.one_handler_per_event,
       this.watch_lifetime_matches_the_instance_owner,
       this.a_reactive_closure_delegates_to_one_method,
       this.a_store_is_used_lazily_and_swapped_at_the_class_slot,
@@ -1238,7 +1202,7 @@ export namespace Tooltip {
 import { Reactive } from 'ivue';
 
 class $Sheet {
-  private readonly cellVersions = new Map<number, Ref<number>>();
+  protected readonly cellVersions = new Map<number, Ref<number>>();
 
   trackCell(cellKey: number): void {
     let versionRef = this.cellVersions.get(cellKey);
@@ -1291,7 +1255,7 @@ export namespace Scroller {
 
   /** The constitution: every check's claim, impossibility, and both
    * permanent proof arms — per receiver, extended alongside `checks`. */
-  static get proofs(): Readonly<Record<string, CheckProof>> {
+  static get proofs(): Readonly<Record<string, CheckStandard.CheckProof>> {
     const fixture = this.$fixtures;
     const grammar = this.$grammar;
     const contractName = `demo${grammar.CONTRACT_SUFFIX}`;
@@ -1340,10 +1304,16 @@ export namespace Scroller {
         green: [{ files: { ...box, 'src/Widget.ts': "class $WidgetPart {\n  spin() {\n    return 1;\n  }\n}\n\nclass $Widget {\n  get part() {\n    return new $WidgetPart();\n  }\n}\n\nexport namespace Widget {\n  export const $Class = $Widget;\n  export let Class = $Class;\n}\n" } }],
       },
       'a_class_file_holds_only_imports_class_namespace_and_types': {
-        claim: 'If a file is a class file, then its top level is imports, the class, its namespace, and type declarations, nothing else',
+        claim: 'If a file is a class file, then its top level is imports, the class, and its namespace, nothing else — every type it declares is a namespace member',
         impossibility: 'a file breaking a_class_file_holds_only_imports_class_namespace_and_types passes the gate',
-        red: [{ files: { 'src/Box.ts': `${fixture.validClass}\nconst DEFAULT_WIDTH = 4;\nexport function widen(box: Box.Instance) { return box.area; }\n` }, expectFindings: [/outside the class seam/], expectCount: 2 }],
-        green: [{ files: { 'src/Box.ts': `${fixture.validClass}\nexport type BoxSeed = { width: number };\nexport interface BoxEmits { (event: 'grown'): void }\n` } }],
+        red: [{ files: { 'src/Box.ts': `${fixture.validClass}\nconst DEFAULT_WIDTH = 4;\nexport function widen(box: Box.Instance) { return box.area; }\nexport type BoxSeed = { width: number };\n` }, expectFindings: [/outside the class seam/, /`BoxSeed` is a type outside the namespace/], expectCount: 3 }],
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace('  export type Instance = typeof Class.Instance;\n', '  export type Instance = typeof Class.Instance;\n  export type Seed = { width: number };\n  export interface Emits {\n    (event: \'grown\'): void;\n  }\n') } }, { files: { 'src/Box.ts': fixture.validClass.replace("import { Reactive } from 'ivue';", "import { Reactive, type ReactiveHelpers } from 'ivue';").replace('    watch(\n      () => this.height.value,', '    getCurrentScope() && onScopeDispose(() => this.$stopEffects());\n    this.$watch(\n      () => this.height.value,').replace("import { ref, watch } from 'vue';", "import { getCurrentScope, onScopeDispose, ref, watch } from 'vue';").replace('\nexport namespace Box {', '\ninterface $Box extends ReactiveHelpers {}\n\nexport namespace Box {') } }],
+      },
+      'the_namespace_holds_identity_and_types_only': {
+        claim: 'If a class file has a namespace, then the namespace holds $Class, Class, and type declarations, never runtime data or behavior (which live on the class as statics)',
+        impossibility: 'a file breaking the_namespace_holds_identity_and_types_only passes the gate',
+        red: [{ files: { 'src/Box.ts': fixture.validClass.replace('  export type Instance = typeof Class.Instance;\n', '  export type Instance = typeof Class.Instance;\n  export const DEFAULT_WIDTH = 4;\n  const SEEDS = [1, 2];\n  export function widen(box: Box.Instance) {\n    return box.area + SEEDS.length;\n  }\n') }, expectFindings: [/`DEFAULT_WIDTH` is runtime data in namespace Box/, /`SEEDS` is runtime data/, /`widen` is behavior in namespace Box/], expectCount: 3 }],
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace('  export type Instance = typeof Class.Instance;\n', '  export type Instance = typeof Class.Instance;\n  export type Model = InstanceType<typeof Class>;\n  export interface Seed {\n    width: number;\n  }\n') } }],
       },
       'behavior_lives_on_the_prototype_not_in_fields': {
         claim: 'If a class member is a function, then it is a method, never a function-valued field',
@@ -1352,7 +1322,7 @@ export namespace Scroller {
         green: [{ files: box }],
       },
       'construction_goes_through_the_namespace_class_slot': {
-        claim: 'If an instance is created, then it is new X.Class, never new dollar-X, new X.dollar-Class, or reactive-wrapped construction',
+        claim: 'If an instance is created, then it is new X.Class, never new dollar-X, new X.dollar-Class, or bare reactive-wrapped construction; reactive(new X.Class() as X.Instance) is the sanctioned view',
         impossibility: 'a file breaking construction_goes_through_the_namespace_class_slot passes the gate',
         red: [{
           files: {
@@ -1366,6 +1336,12 @@ export namespace Scroller {
             ...box,
             'src/BoxFactory.ts': "import { Box } from './Box';\n\nclass $BoxFactory {\n  make() {\n    return new Box.Class({ width: 1 });\n  }\n}\n\nexport namespace BoxFactory {\n  export const $Class = $BoxFactory;\n  export let Class = $Class;\n}\n",
           },
+        }, {
+          // the sanctioned reactive() view: the Instance cast marks the concession
+          files: {
+            ...box,
+            'src/BoxView.ts': "import { reactive } from 'vue';\nimport { Box } from './Box';\n\nclass $BoxView {\n  make() {\n    return reactive(new Box.Class({ width: 1 }) as Box.Instance);\n  }\n}\n\nexport namespace BoxView {\n  export const $Class = $BoxView;\n  export let Class = $Class;\n}\n",
+          },
         }],
       },
       'the_anchor_is_static_only_when_statics_exist': {
@@ -1384,7 +1360,7 @@ export namespace Scroller {
         claim: "If the consumer's Static transforms a class, then its static methods are bound with stable identity and its dollar getters run once per receiver class",
         impossibility: 'a file breaking static_binds_methods_and_caches_dollar_getters_per_receiver passes the gate',
         red: [
-          { files: box, options: { staticImplementation: (<Class,>(targetClass: Class) => targetClass) as StaticTransform }, expectFindings: [/does not bind static methods/, /does not cache a dollar getter once per receiver/] },
+          { files: box, options: { staticImplementation: (<Class,>(targetClass: Class) => targetClass) as CheckStandard.StaticTransform }, expectFindings: [/does not bind static methods/, /does not cache a dollar getter once per receiver/] },
           { files: box, options: { staticImplementation: null }, expectFindings: [/could not be loaded/] },
         ],
         green: [{ files: box }],
@@ -1407,10 +1383,10 @@ export namespace Scroller {
         }],
       },
       'a_derived_static_getter_is_lower_camel_case': {
-        claim: 'If a static getter derives its value from other members or classes, then its name is lowerCamel, and SCREAMING_SNAKE remains for literal tunable constants',
+        claim: 'If a static getter derives its value from other members or classes, then its name is lowerCamel, and SCREAMING_SNAKE remains for tunable constants: literals, or other SCREAMING constants composed',
         impossibility: 'a file breaking a_derived_static_getter_is_lower_camel_case passes the gate',
         red: [{ files: { 'src/Clock.ts': fixture.staticClass.replace('  static now() {', '  static get SCAN_LIMIT_HOURS() {\n    return Number(this.$zone.length) * 24;\n  }\n\n  static now() {') }, expectFindings: [/derives its value — a derived getter is lowerCamel \(`scanLimitHours`\)/] }],
-        green: [{ files: { 'src/Clock.ts': fixture.staticClass.replace('  static now() {', '  static get RETRY_LIMIT() {\n    return 3;\n  }\n\n  static get EMAIL_PATTERN() {\n    return /a+b/;\n  }\n\n  static get scanLimitHours() {\n    return Number(this.$zone.length) * 24;\n  }\n\n  static now() {') } }],
+        green: [{ files: { 'src/Clock.ts': fixture.staticClass.replace('  static now() {', '  static get RETRY_LIMIT() {\n    return 3;\n  }\n\n  static get EMAIL_PATTERN() {\n    return /a+b/;\n  }\n\n  static get KNOBS() {\n    return { retries: this.RETRY_LIMIT, pattern: Clock.Class.EMAIL_PATTERN };\n  }\n\n  static get scanLimitHours() {\n    return Number(this.$zone.length) * 24;\n  }\n\n  static now() {') } }],
       },
       'static_reads_go_through_self_not_the_base_class': {
         claim: 'If instance code reads its own statics, then it reads this.self, never the base class name or a per-site constructor cast',
@@ -1424,7 +1400,7 @@ export namespace Scroller {
         red: [{ files: { 'src/Box.ts': fixture.validClass.replace('  get height() {', '  count = 0;\n\n  get height() {') }, expectFindings: [/`count` is a mutable plain field/] }],
         // Db.ts is a PLAIN namespace class (no Reactive) — plain mutable
         // fields are its legitimate state; nothing reactive to trigger.
-        green: [{ files: { 'src/Box.ts': fixture.validClass.replace("import { ref, watch } from 'vue';", "import { ref, shallowRef, watch } from 'vue';").replace('  get width() {', '  get rows() {\n    return shallowRef<number[]>([]);\n  }\n  get width() {'), 'src/Db.ts': "class $Db {\n  connectionCount = 0;\n\n  open() {\n    this.connectionCount++;\n  }\n}\n\nexport namespace Db {\n  export const $Class = $Db;\n  export let Class = $Class;\n}\n" } }],
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace("import { ref, watch } from 'vue';", "import { ref, shallowRef, watch } from 'vue';").replace('  get width() {', '  get rows() {\n    return shallowRef<number[]>([]);\n  }\n  get width() {'), 'src/Db.ts': "class $Db {\n  connectionCount = 0;\n\n  open() {\n    this.connectionCount++;\n  }\n}\n\nexport namespace Db {\n  export const $Class = $Db;\n  export let Class = $Class;\n}\n" } }, { files: { 'src/Box.ts': fixture.validClass.replace('class $Box {\n', 'class $Box {\n  declare $watch: typeof watch;\n\n') } }],
       },
       'a_ref_is_read_and_written_through_value': {
         claim: 'If class code writes a Ref getter, then it writes .value, never assigns over the getter',
@@ -1505,7 +1481,17 @@ export namespace Scroller {
           },
           expectFindings: [/`area` is a plain getter/, /`grow` is a method/, /`width` shadows the prop/, /reaches a Ref through the instance/],
         }],
-        green: [{ files: { ...box, 'src/Box.vue': fixture.validSfc } }],
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace("import { ref, watch } from 'vue';", "import { ref, watch, type Ref } from 'vue';").replace('  get width() {', '  get forwardedHeight(): Ref<number> {\n    return this.height;\n  }\n  get width() {'), 'src/Box.vue': fixture.validSfc.replace('const { height } = box;', 'const { height, forwardedHeight } = box;') } }, { files: { ...box, 'src/Box.vue': fixture.validSfc } }],
+      },
+      'one_handler_per_event': {
+        claim: 'If a template binds DOM events on one element, then no two events share a handler: a cancel gets its own method that may delegate to the lift, so a subclass can extend either alone',
+        impossibility: 'a file breaking one_handler_per_event passes the gate',
+        red: [{
+          files: { ...box, 'src/Box.vue': fixture.validSfc.replace('<button @click="box.grow()">grow</button>', '<button @pointerup="box.grow" @pointercancel="box.grow">grow</button>') },
+          expectFindings: [/`@pointerup` and `@pointercancel` bind one handler/],
+          expectCount: 1,
+        }],
+        green: [{ files: { ...box, 'src/Box.vue': fixture.validSfc.replace('<button @click="box.grow()">grow</button>', '<button @pointerup="box.grow" @pointercancel="box.cancelGrow">grow</button>') } }],
       },
       'template_expressions_carry_no_logic': {
         claim: 'If a template expression is written, then it is a named read, a method call, or a structural branch, never a comparison, ternary, negation, or built string',
@@ -1530,7 +1516,7 @@ export namespace Scroller {
           },
           expectFindings: [/constructed in a component's setup but uses `this\.\$watch`/, /no dispose path/, /outlives components .* but uses plain `watch`/],
         }],
-        green: [{
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace("import { ref, watch } from 'vue';", "import { getCurrentScope, onScopeDispose, ref, watch } from 'vue';").replace('    watch(\n      () => this.height.value,', '    getCurrentScope() && onScopeDispose(() => this.$stopEffects());\n    this.$watch(\n      () => this.height.value,'), 'src/Box.vue': fixture.validSfc } }, { files: { ...box, 'src/Host.ts': "import { Reactive } from 'ivue';\nimport { Box } from './Box';\n\nclass $Host {\n  constructor() {\n    void this.$box;\n  }\n\n  protected get $box() {\n    return new Box.Class({ width: 2 });\n  }\n}\n\nexport namespace Host {\n  export const $Class = $Host;\n  export let Class = Reactive($Class);\n  export type Instance = typeof Class.Instance;\n}\n", 'src/Host.vue': "<script setup lang=\"ts\">\nimport { Host } from './Host';\n\nconst host = new Host.Class();\n\ndefineExpose(host as Host.Instance);\n</script>\n\n<template>\n  <div />\n</template>\n" } }, {
           files: {
             ...box,
             'src/Box.vue': fixture.validSfc,
@@ -1587,6 +1573,10 @@ export namespace Scroller {
           // main.ts exports nothing — a composition root evaluates after its
           // whole import graph, so its module-evaluation Class read is safe
           files: { ...box, 'src/Shelf.ts': "import { Reactive } from 'ivue';\nimport { Box } from './Box';\n\nclass $Shelf extends Box.$Class {\n  make() {\n    return new Box.Class({ width: 1 });\n  }\n}\n\nexport namespace Shelf {\n  export const $Class = $Shelf;\n  export let Class = Reactive($Class);\n  export type Instance = typeof Class.Instance;\n}\n", 'src/main.ts': "import { Box } from './Box';\n\nconst rootBox = new Box.Class({ width: 1 });\nvoid rootBox.area;\n" },
+        }, {
+          // a generic subclass keeps its type parameter by extending through a cast —
+          // `extends (X.$Class as typeof X.$Class)<T>` is still the heritage read
+          files: { ...box, 'src/Shelf.ts': "import { Reactive } from 'ivue';\nimport { Box } from './Box';\n\nclass $Shelf<T> extends (Box.$Class as typeof Box.$Class) {\n  make(item: T) {\n    return item;\n  }\n}\n\nexport namespace Shelf {\n  export const $Class = $Shelf;\n  export let Class = Reactive($Class);\n  export type Instance = typeof Class.Instance;\n}\n" },
         }],
       },
       'declarations_use_full_descriptive_names': {
@@ -1599,8 +1589,13 @@ export namespace Scroller {
           },
           expectFindings: [/`nv`/, /`e`/, /`inst`/, /`_`/],
           expectCount: 4,
+        }, {
+          // a `v-for` alias is a declaration too
+          files: { ...box, 'src/Box.vue': fixture.validSfc.replace('<button @click="box.grow()">grow</button>', '<ul><li v-for="(r, i) in box.rows" :key="i">{{ r }}</li></ul>\n  <button @click="box.grow()">grow</button>') },
+          expectFindings: [/`r` as a `v-for` alias/, /`i` as a `v-for` alias/],
+          expectCount: 2,
         }],
-        green: [{ files: { 'src/Box.ts': fixture.validClass.replace('  grow() {', '  offset(px: number, id: string) {\n    return `${id}:${px}`;\n  }\n\n  grow() {'), 'src/Box.test.ts': fixture.validTest } }],
+        green: [{ files: { 'src/Box.ts': fixture.validClass.replace('  grow() {', '  offset(px: number, id: string) {\n    return `${id}:${px}`;\n  }\n\n  grow() {'), 'src/Box.test.ts': fixture.validTest } }, { files: { ...box, 'src/Box.vue': fixture.validSfc.replace('<button @click="box.grow()">grow</button>', '<ul><li v-for="(row, index) in box.rows" :key="index">{{ row }}</li></ul>\n  <button @click="box.grow()">grow</button>') } }],
       },
       'class_members_are_ordered_and_spaced': {
         claim: 'If a class is written, then statics precede the constructor, the constructor precedes getters, methods come last and are separated by blank lines',
@@ -1644,15 +1639,15 @@ export namespace Scroller {
   // -------------------------------------------------------------------------
   // behavior — methods (async welcome here; the getters above carry data)
 
-  static defineCheck(name: string, run: (context: GateContext) => Finding[]): StandardCheck {
+  static defineCheck(name: string, run: (context: CheckStandard.GateContext) => CheckStandard.Finding[]): CheckStandard.StandardCheck {
     return { name, enforced: true, run };
   }
 
-  static finding(check: StandardCheck, unit: SourceUnit, line: number, message: string): Finding {
+  static finding(check: CheckStandard.StandardCheck, unit: CheckStandard.SourceUnit, line: number, message: string): CheckStandard.Finding {
     return { check: check.name, file: unit.relativePath, line, message };
   }
 
-  static componentFinding(check: StandardCheck, component: ComponentUnit, line: number, message: string): Finding {
+  static componentFinding(check: CheckStandard.StandardCheck, component: CheckStandard.ComponentUnit, line: number, message: string): CheckStandard.Finding {
     return { check: check.name, file: component.relativePath, line, message };
   }
 
@@ -1682,7 +1677,7 @@ export namespace Scroller {
     }
   }
 
-  static toUnit(cwd: string, path: string): SourceUnit {
+  static toUnit(cwd: string, path: string): CheckStandard.SourceUnit {
     const text = readFileSync(path, 'utf8');
     return {
       path,
@@ -1693,11 +1688,12 @@ export namespace Scroller {
     };
   }
 
-  static lineOf(unit: SourceUnit, node: ts.Node): number {
+  static lineOf(unit: CheckStandard.SourceUnit, node: ts.Node): number {
     return unit.ast.getLineAndCharacterOfPosition(node.getStart(unit.ast)).line + 1;
   }
 
-  static collectTemplateExpressions(nodes: TemplateChildNode[], into: TemplateExpression[]): void {
+  static collectTemplateExpressions(nodes: TemplateChildNode[], into: CheckStandard.TemplateExpression[], aliases: CheckStandard.ForAliases[] = []): void {
+    const aliasNames = (text: string) => text.match(/[A-Za-z_$][\w$]*/g) ?? [];
     for (const node of nodes) {
       if (node.type === NodeTypes.INTERPOLATION && node.content.type === NodeTypes.SIMPLE_EXPRESSION) {
         into.push({ code: node.content.content, line: node.loc.start.line, kind: 'interpolation' });
@@ -1708,31 +1704,34 @@ export namespace Scroller {
           if (this.TEMPLATE_IGNORED_DIRECTIVES.has(property.name)) continue;
           let code = property.exp.content;
           if (property.name === 'for') {
-            const source = /\s+(?:in|of)\s+([\s\S]+)$/.exec(code);
+            const source = /^([\s\S]*?)\s+(?:in|of)\s+([\s\S]+)$/.exec(code);
             if (!source) continue;
-            code = source[1];
+            aliases.push({ names: aliasNames(source[1]), line: property.exp.loc.start.line });
+            code = source[2];
           }
           into.push({ code, line: property.exp.loc.start.line, kind: property.name });
         }
-        this.collectTemplateExpressions(element.children, into);
+        this.collectTemplateExpressions(element.children, into, aliases);
       } else if (node.type === NodeTypes.IF) {
         for (const branch of node.branches) {
           if (branch.condition && branch.condition.type === NodeTypes.SIMPLE_EXPRESSION) into.push({ code: branch.condition.content, line: branch.loc.start.line, kind: 'if' });
-          this.collectTemplateExpressions(branch.children, into);
+          this.collectTemplateExpressions(branch.children, into, aliases);
         }
       } else if (node.type === NodeTypes.FOR) {
         if (node.source.type === NodeTypes.SIMPLE_EXPRESSION) into.push({ code: node.source.content, line: node.loc.start.line, kind: 'for' });
-        this.collectTemplateExpressions(node.children, into);
+        const names = [node.valueAlias, node.keyAlias, node.objectIndexAlias].flatMap((alias) => (alias && alias.type === NodeTypes.SIMPLE_EXPRESSION ? aliasNames(alias.content) : []));
+        if (names.length) aliases.push({ names, line: node.loc.start.line });
+        this.collectTemplateExpressions(node.children, into, aliases);
       }
     }
   }
 
-  static toComponent(cwd: string, path: string): ComponentUnit {
+  static toComponent(cwd: string, path: string): CheckStandard.ComponentUnit {
     const text = readFileSync(path, 'utf8');
     const { descriptor } = parseSfc(text, { filename: path });
     const scriptBlock = descriptor.scriptSetup;
     const scriptLine = scriptBlock ? scriptBlock.loc.start.line : 0;
-    const script: SourceUnit | null = scriptBlock
+    const script: CheckStandard.SourceUnit | null = scriptBlock
       ? {
           path,
           relativePath: relative(cwd, path).replaceAll('\\', '/'),
@@ -1741,14 +1740,16 @@ export namespace Scroller {
           ast: ts.createSourceFile(path, scriptBlock.content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
         }
       : null;
-    const expressions: TemplateExpression[] = [];
+    const expressions: CheckStandard.TemplateExpression[] = [];
+    const forAliases: CheckStandard.ForAliases[] = [];
     if (descriptor.template) {
       const templateAst = parseTemplate(descriptor.template.content, { comments: false });
-      this.collectTemplateExpressions(templateAst.children, expressions);
+      this.collectTemplateExpressions(templateAst.children, expressions, forAliases);
       const offset = descriptor.template.loc.start.line - 1;
       for (const expression of expressions) expression.line += offset;
+      for (const alias of forAliases) alias.line += offset;
     }
-    return { path, relativePath: relative(cwd, path).replaceAll('\\', '/'), text, script, scriptLine, expressions };
+    return { path, relativePath: relative(cwd, path).replaceAll('\\', '/'), text, script, scriptLine, expressions, forAliases };
   }
 
   /** A template expression parsed as one TypeScript expression (null when it does not parse). */
@@ -1761,12 +1762,12 @@ export namespace Scroller {
     return expression;
   }
 
-  static componentLine(component: ComponentUnit, node: ts.Node): number {
+  static componentLine(component: CheckStandard.ComponentUnit, node: ts.Node): number {
     return component.script ? this.lineOf(component.script, node) + component.scriptLine - 1 : 1;
   }
 
   /** `const box = new Box.Class(…)` bindings in a component's script setup. */
-  static modelConstructions(component: ComponentUnit): { variable: string; namespace: string; node: ts.Node }[] {
+  static modelConstructions(component: CheckStandard.ComponentUnit): { variable: string; namespace: string; node: ts.Node }[] {
     const constructions: { variable: string; namespace: string; node: ts.Node }[] = [];
     if (!component.script) return constructions;
     for (const statement of component.script.ast.statements) {
@@ -1781,7 +1782,7 @@ export namespace Scroller {
   }
 
   /** Names declared by `defineProps<{ … }>()` / `withDefaults(defineProps<{ … }>(), …)`. */
-  static propNames(component: ComponentUnit): Set<string> {
+  static propNames(component: CheckStandard.ComponentUnit): Set<string> {
     const names = new Set<string>();
     if (!component.script) return names;
     this.forEachDescendant(component.script.ast, (node) => {
@@ -1798,7 +1799,7 @@ export namespace Scroller {
     return names;
   }
 
-  static classFileOf(unit: SourceUnit): ClassFile | null {
+  static classFileOf(unit: CheckStandard.SourceUnit): CheckStandard.ClassFile | null {
     const dollarClasses = unit.ast.statements.filter(
       (statement): statement is ts.ClassDeclaration =>
         ts.isClassDeclaration(statement) && !!statement.name && statement.name.text.startsWith('$'),
@@ -1851,7 +1852,7 @@ export namespace Scroller {
     };
   }
 
-  static classFileByNamespace(context: GateContext, namespace: string): ClassFile | null {
+  static classFileByNamespace(context: CheckStandard.GateContext, namespace: string): CheckStandard.ClassFile | null {
     for (const unit of context.sources) {
       const classFile = this.classFileOf(unit);
       if (classFile?.publicName === namespace) return classFile;
@@ -1867,6 +1868,12 @@ export namespace Scroller {
     return !!(ts.getCombinedModifierFlags(member as ts.Declaration) & ts.ModifierFlags.Readonly);
   }
 
+  /** `declare` on a class member: a type-only statement with no runtime —
+   *  how a class names the `$watch` / `$stopEffects` the engine installs. */
+  static isDeclaredMember(member: ts.ClassElement): boolean {
+    return !!ts.getModifiers(member as ts.HasModifiers)?.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword);
+  }
+
   static memberName(member: ts.ClassElement): string {
     return member.name && (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) ? member.name.text : '';
   }
@@ -1917,19 +1924,29 @@ export namespace Scroller {
     return isThisMethod ? body : null;
   }
 
+  /** `Ref<…>`, `ShallowRef<…>`, `ComputedRef<…>`, `WritableComputedRef<…>` as a
+   *  declared return type. */
+  static isRefTypeNode(type: ts.TypeNode): boolean {
+    return ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && ['Ref', 'ShallowRef', 'ComputedRef', 'WritableComputedRef'].includes(type.typeName.text);
+  }
+
   static refFactoryName(expression: ts.Expression | undefined): string | null {
     if (!expression || !ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression)) return null;
     const name = expression.expression.text;
     return ['ref', 'shallowRef', 'computed', 'toRef'].includes(name) ? name : null;
   }
 
-  /** Getter names of a class whose body returns a Ref factory call. */
+  /** Getter names of a class whose body returns a Ref factory call, or
+   *  that declare a Ref return type — a FORWARDED cell (`get x(): Ref<number>
+   *  { return this.$mouse.x }`) is the same cell as its source, and the
+   *  annotation is how the author says so. */
   static refGetterNames(rawClass: ts.ClassDeclaration): Set<string> {
     const names = new Set<string>();
     for (const member of rawClass.members) {
       if (!ts.isGetAccessorDeclaration(member) || !member.body) continue;
       const returned = member.body.statements.find(ts.isReturnStatement);
       if (returned && this.refFactoryName(returned.expression)) names.add(this.memberName(member));
+      else if (member.type && this.isRefTypeNode(member.type)) names.add(this.memberName(member));
     }
     return names;
   }
@@ -1939,7 +1956,7 @@ export namespace Scroller {
     node.forEachChild((child) => this.forEachDescendant(child, visit));
   }
 
-  static importedBindings(unit: SourceUnit): Set<string> {
+  static importedBindings(unit: CheckStandard.SourceUnit): Set<string> {
     const names = new Set<string>();
     for (const statement of unit.ast.statements) {
       if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
@@ -1967,10 +1984,10 @@ export namespace Scroller {
     return false;
   }
 
-  static parseHeader(unit: SourceUnit): GeneratorHeader {
+  static parseHeader(unit: CheckStandard.SourceUnit): CheckStandard.GeneratorHeader {
     const grammar = this.$grammar;
     const text = unit.text;
-    const header: GeneratorHeader = {
+    const header: CheckStandard.GeneratorHeader = {
       present: text.includes(grammar.GENERATOR),
       firstContent: false,
       goal: '',
@@ -2028,10 +2045,10 @@ export namespace Scroller {
     return header;
   }
 
-  static parseProofs(unit: SourceUnit, header: GeneratorHeader): ProofAnnotation[] {
+  static parseProofs(unit: CheckStandard.SourceUnit, header: CheckStandard.GeneratorHeader): CheckStandard.ProofAnnotation[] {
     const grammar = this.$grammar;
-    const proofs: ProofAnnotation[] = [];
-    let pending: ProofAnnotation[] = [];
+    const proofs: CheckStandard.ProofAnnotation[] = [];
+    let pending: CheckStandard.ProofAnnotation[] = [];
     let documentationOpen = false;
     for (let index = header.endLine; index < unit.lines.length; index++) {
       const line = unit.lines[index];
@@ -2108,7 +2125,7 @@ export namespace Scroller {
   /** The run's final severity per check: the receiver's `severities`
    * defaults, overridden by the run's --warn/--off. Unknown names and a
    * check assigned both warn and off are refused. */
-  static resolveSeverities(options: GateOptions): Map<string, 'warn' | 'off'> {
+  static resolveSeverities(options: CheckStandard.GateOptions): Map<string, 'warn' | 'off'> {
     const known = this.checkNames;
     const resolved = new Map<string, 'warn' | 'off'>();
     for (const [name, severity] of Object.entries(this.severities)) {
@@ -2128,7 +2145,7 @@ export namespace Scroller {
     return resolved;
   }
 
-  static readSkipList(cwd: string, path: string): SkipRow[] {
+  static readSkipList(cwd: string, path: string): CheckStandard.SkipRow[] {
     const absolute = isAbsolute(path) ? path : resolve(cwd, path);
     if (!existsSync(absolute)) throw new CheckStandard.GateUsageError(`skip-list not found: ${path}`);
     let parsed: unknown;
@@ -2138,7 +2155,7 @@ export namespace Scroller {
       throw new CheckStandard.GateUsageError(`skip-list ${path}: not valid JSON (${(error as Error).message}) — the skip list is a JSON array of { path, check, reason }`);
     }
     if (!Array.isArray(parsed)) throw new CheckStandard.GateUsageError(`skip-list ${path}: the skip list is a JSON array of { path, check, reason }`);
-    const rows: SkipRow[] = [];
+    const rows: CheckStandard.SkipRow[] = [];
     const seen = new Set<string>();
     const knownNames = this.checkNames;
     parsed.forEach((entry, index) => {
@@ -2158,13 +2175,13 @@ export namespace Scroller {
   }
 
   /** Discover, check, apply the skip-list. Throws GateUsageError on a refused population. */
-  static run(options: GateOptions): GateResult {
+  static run(options: CheckStandard.GateOptions): CheckStandard.GateResult {
     const cwd = resolve(options.cwd);
     if (!options.sourceRoots.length) throw new CheckStandard.GateUsageError('at least one --source-root is required');
     const testMatchers = options.testGlobs.map((glob) => ({ glob, regexp: this.globToRegExp(glob) }));
-    const sources: SourceUnit[] = [];
-    const tests: SourceUnit[] = [];
-    const components: ComponentUnit[] = [];
+    const sources: CheckStandard.SourceUnit[] = [];
+    const tests: CheckStandard.SourceUnit[] = [];
+    const components: CheckStandard.ComponentUnit[] = [];
     const isTest = (relativePath: string) => testMatchers.some((matcher) => matcher.regexp.test(relativePath));
     for (const root of options.sourceRoots) {
       const absoluteRoot = isAbsolute(root) ? root : resolve(cwd, root);
@@ -2199,7 +2216,7 @@ export namespace Scroller {
     const skips = options.skipListPath ? this.readSkipList(cwd, options.skipListPath) : [];
     const severities = this.resolveSeverities(options);
 
-    const context: GateContext = {
+    const context: CheckStandard.GateContext = {
       cwd,
       sourceRoots: options.sourceRoots.map((root) => (isAbsolute(root) ? root : resolve(cwd, root))),
       sources,
@@ -2208,16 +2225,16 @@ export namespace Scroller {
       testGlobs: options.testGlobs,
       staticImplementation: options.staticImplementation ?? null,
     };
-    const raw: Finding[] = [];
+    const raw: CheckStandard.Finding[] = [];
     for (const entry of this.checks) {
       if (!entry.enforced || severities.get(entry.name) === 'off') continue;
       raw.push(...entry.run(context));
     }
 
-    const findings: Finding[] = [];
-    const warnings: Finding[] = [];
-    const suppressed: Finding[] = [];
-    const used = new Set<SkipRow>();
+    const findings: CheckStandard.Finding[] = [];
+    const warnings: CheckStandard.Finding[] = [];
+    const suppressed: CheckStandard.Finding[] = [];
+    const used = new Set<CheckStandard.SkipRow>();
     for (const item of raw) {
       const row = skips.find((skip) => skip.check === item.check && skip.path === item.file);
       if (row) {
@@ -2234,7 +2251,7 @@ export namespace Scroller {
         findings.push({ check: this.the_population_and_skip_list_are_exact.name, file: options.skipListPath ?? 'skip-list', line: row.line, message });
       }
     }
-    const byPlace = (first: Finding, second: Finding) => first.file.localeCompare(second.file) || first.line - second.line;
+    const byPlace = (first: CheckStandard.Finding, second: CheckStandard.Finding) => first.file.localeCompare(second.file) || first.line - second.line;
     findings.sort(byPlace);
     warnings.sort(byPlace);
     return {
@@ -2251,7 +2268,7 @@ export namespace Scroller {
   /** Run the receiver's whole constitution: every check's red and green
    * arms through run(), refusing a manifest whose check lacks them.
    * `only` isolates one check by name — its arms and nothing else. */
-  static prove(options?: { completenessOnly?: boolean; only?: string }): ProveReport {
+  static prove(options?: { completenessOnly?: boolean; only?: string }): CheckStandard.ProveReport {
     const problems: string[] = [];
     const ran = { red: 0, green: 0 };
     const proofs = this.proofs;
@@ -2263,7 +2280,7 @@ export namespace Scroller {
       }
     }
     for (const check of selected) {
-      const asGetter = (this as unknown as Record<string, StandardCheck | undefined>)[check.name];
+      const asGetter = (this as unknown as Record<string, CheckStandard.StandardCheck | undefined>)[check.name];
       if (asGetter?.name !== check.name) problems.push(`${check.name}: the name is not its getter — one snake_case form is the whole identity (getter, finding label, skip token, severity key)`);
       const proof = proofs[check.name];
       if (!proof) {
@@ -2285,7 +2302,7 @@ export namespace Scroller {
               writeFileSync(join(checkout, path), text);
             }
             const hasTests = Object.keys(arm.files).some((path) => path.endsWith('.test.ts'));
-            const gateOptions: GateOptions = {
+            const gateOptions: CheckStandard.GateOptions = {
               cwd: checkout,
               sourceRoots: ['src'],
               testGlobs: hasTests ? ['src/**/*.test.ts'] : [],
@@ -2299,8 +2316,8 @@ export namespace Scroller {
             // own severities getter must not bend the arm: the check's
             // warnings fold back into its findings.
             const armTestsSeverity = !!arm.options && ('warnChecks' in arm.options || 'offChecks' in arm.options);
-            let findings: Finding[] = [];
-            let warnings: Finding[] = [];
+            let findings: CheckStandard.Finding[] = [];
+            let warnings: CheckStandard.Finding[] = [];
             let thrown: Error | null = null;
             try {
               const result = this.run(gateOptions);
@@ -2399,7 +2416,7 @@ name, duplicate or stale skip row). Paths in findings are relative to the cwd.`;
         return 2;
       }
     }
-    let result: GateResult;
+    let result: CheckStandard.GateResult;
     try {
       result = this.run({ cwd, sourceRoots, testGlobs, skipListPath, staticImplementation: Static });
     } catch (error) {
@@ -2425,6 +2442,174 @@ export namespace CheckStandard {
   export const $Class = Static($CheckStandard);
   export let Class = $Class;
 
+  /* Types — the gate's public vocabulary, one seam */
+
+  export interface Finding {
+    check: string;
+    file: string;
+    line: number;
+    message: string;
+  }
+
+  export type StaticTransform = <Class extends new (...arguments_: any[]) => any>(targetClass: Class) => Class;
+
+  export interface GateOptions {
+    cwd: string;
+    sourceRoots: string[];
+    testGlobs: string[];
+    skipListPath?: string;
+    /** programmatic severity overrides (the declarative home is the gate
+     * class's `severities` getter): demoted to warnings — reported, never
+     * blocking … */
+    warnChecks?: string[];
+    /** … or disabled — not executed, announced in the summary */
+    offChecks?: string[];
+    /** the `Static` used by the runtime probe; defaults to this package's own */
+    staticImplementation?: StaticTransform | null;
+  }
+
+  export interface GateResult {
+    /** blocking findings — checks at severity error */
+    findings: Finding[];
+    /** findings from checks demoted to warn — reported, never blocking */
+    warnings: Finding[];
+    suppressed: Finding[];
+    sources: string[];
+    tests: string[];
+    unenforced: string[];
+    /** checks turned off for this run — announced, never silent */
+    off: string[];
+  }
+
+  export interface StandardCheck {
+    /** The identity: a plain declarative sentence, used verbatim everywhere. */
+    name: string;
+    /** false = registered in the manifest but not enforced yet; the report says so. */
+    enforced: boolean;
+    run(context: GateContext): Finding[];
+  }
+
+  /** One permanent proof fixture: a small checkout the gate runs over. */
+  export interface CheckProofArm {
+    /** repo-relative path → file text; sources under `src/` by convention */
+    files: Record<string, string>;
+    /** package.json for the fixture checkout (default: an ivue consumer) */
+    manifest?: Record<string, unknown>;
+    /** GateOptions overrides for this arm (e.g. a broken staticImplementation) */
+    options?: Partial<GateOptions>;
+    /** red arms: each pattern must match at least one of the check's findings */
+    expectFindings?: (RegExp | string)[];
+    /** red arms: exact number of findings the check must produce */
+    expectCount?: number;
+    /** arms with warn-demoted checks: each pattern must match a warning */
+    expectWarnings?: (RegExp | string)[];
+    /** red arms for population refusals: run() must throw matching this */
+    expectThrows?: RegExp;
+  }
+
+  /** A check's constitution entry: its claim, its boundary, and both arms. */
+  export interface CheckProof {
+    claim: string;
+    impossibility: string;
+    red: CheckProofArm[];
+    green: CheckProofArm[];
+  }
+
+  export interface ProveReport {
+    problems: string[];
+    ran: { red: number; green: number };
+  }
+
+  export interface SourceUnit {
+    path: string;
+    relativePath: string;
+    text: string;
+    lines: string[];
+    ast: ts.SourceFile;
+  }
+
+  /** A `.vue` single-file component: its script setup as TS plus every template expression. */
+  export interface ComponentUnit {
+    path: string;
+    relativePath: string;
+    text: string;
+    script: SourceUnit | null;
+    /** 1-based line of the script block's first line in the .vue file */
+    scriptLine: number;
+    expressions: TemplateExpression[];
+    /** every `v-for` alias (value, key, index) with the line it is declared on */
+    forAliases: ForAliases[];
+  }
+
+  export interface ForAliases {
+    names: string[];
+    line: number;
+  }
+
+  export interface TemplateExpression {
+    code: string;
+    line: number;
+    kind: string;
+  }
+
+  export interface GateContext {
+    cwd: string;
+    /** absolute source roots, as discovered */
+    sourceRoots: string[];
+    sources: SourceUnit[];
+    tests: SourceUnit[];
+    components: ComponentUnit[];
+    testGlobs: string[];
+    staticImplementation: StaticTransform | null;
+  }
+
+  export interface ClassFile {
+    unit: SourceUnit;
+    rawClass: ts.ClassDeclaration;
+    rawName: string;
+    publicName: string;
+    namespace: ts.ModuleDeclaration | null;
+    anchorInitializer: ts.Expression | null;
+    classInitializer: ts.Expression | null;
+    hasInstanceType: boolean;
+    isReactive: boolean;
+    isStaticAnchored: boolean;
+  }
+
+  export interface GeneratorHeader {
+    present: boolean;
+    firstContent: boolean;
+    goal: string;
+    formal: string;
+    described: string;
+    orderedRegisters: boolean;
+    bothRegisters: boolean;
+    subjects: { path: string; line: number }[];
+    domainClaims: Map<string, { symbol: string; claim: string; line: number }>;
+    domainSymbols: Set<string>;
+    impossibilities: Map<string, number>;
+    contractLinks: { text: string; file: string; anchor: string; line: number }[];
+    endLine: number;
+  }
+
+  export interface ProofAnnotation {
+    type: 'domain' | 'impossible' | 'record';
+    symbol?: string;
+    claim?: string;
+    name?: string;
+    contractPath?: string;
+    line: number;
+    bound: boolean;
+  }
+
+  export interface SkipRow {
+    path: string;
+    check: string;
+    reason: string;
+    line: number;
+  }
+
+
   export class GateUsageError extends Error {}
 
   // Entry detection that survives every runner AND subclass gates. The