@elaraai/east-diagnostics 1.0.4

package/dist/src/rules/no-let-const-in-expression.js

@@ -0,0 +1,51 @@
+import { matchBlockBuilderCall } from "../block-builder.js";
+const NAME = "no-let-const-in-expression";
+const CODE = 990008;
+// `$.let` / `$.const` declare a variable in the block (a statement-like effect)
+// and return the expression handle. The only correct position is the initializer
+// of a JS `const`/`let`. Used anywhere else — as an argument (`$.if($.let(...))`),
+// a chain target (`$.let(...).add(1n)`), or an operand — it buries a declaration
+// inside an expression. Type-checks fine, so the checker won't catch it.
+export const noLetConstInExpression = {
+    name: NAME,
+    code: CODE,
+    description: "Require $.let/$.const to be bound to a const; disallow using the result inline in an expression.",
+    check(node, ctx) {
+        const match = matchBlockBuilderCall(node, ctx);
+        if (match === undefined)
+            return;
+        const t = ctx.ts;
+        const call = match.call;
+        // Walk out of wrapping parentheses.
+        let current = call;
+        let parent = current.parent;
+        while (parent !== undefined && t.isParenthesizedExpression(parent)) {
+            current = parent;
+            parent = parent.parent;
+        }
+        if (parent === undefined)
+            return;
+        // Flag only when the result is consumed inline: a chain target
+        // (`$.let(...).add(1n)`), an index target, an operator operand, or an
+        // argument to another call (`$.if($.let(...))`). A const/let initializer,
+        // a bare statement, `return $.const(...)`, and a concise arrow body are all
+        // valid and stay silent.
+        const usedInExpression = (t.isPropertyAccessExpression(parent) && parent.expression === current) ||
+            (t.isElementAccessExpression(parent) && parent.expression === current) ||
+            (t.isBinaryExpression(parent) && (parent.left === current || parent.right === current)) ||
+            (t.isCallExpression(parent) && parent.arguments.some((arg) => arg === current));
+        if (!usedInExpression)
+            return;
+        const sf = ctx.sourceFile;
+        const start = call.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: call.getEnd() - start,
+            messageText: `\`$.${match.method}\` declares a variable — bind it to a \`const\` first (\`const x = $.${match.method}(value, Type)\`), don't use the result inline (e.g. \`$.if($.let(...))\` or \`$.let(...).add(...)\`).`,
+            category: "warning",
+        });
+    },
+};
+//# sourceMappingURL=no-let-const-in-expression.js.map

package/dist/src/rules/no-let-const-in-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-let-const-in-expression.js","sourceRoot":"","sources":["../../../src/rules/no-let-const-in-expression.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,gFAAgF;AAChF,iFAAiF;AACjF,mFAAmF;AACnF,iFAAiF;AACjF,yEAAyE;AACzE,MAAM,CAAC,MAAM,sBAAsB,GAAa;IAC9C,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,WAAW,EACT,kGAAkG;IACpG,KAAK,CAAC,IAAI,EAAE,GAAG;QACb,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC/C,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO;QAEhC,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QACjB,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAExB,oCAAoC;QACpC,IAAI,OAAO,GAAY,IAAI,CAAC;QAC5B,IAAI,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC5B,OAAO,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC;YACnE,OAAO,GAAG,MAAM,CAAC;YACjB,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QACzB,CAAC;QACD,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QAEjC,+DAA+D;QAC/D,sEAAsE;QACtE,0EAA0E;QAC1E,4EAA4E;QAC5E,yBAAyB;QACzB,MAAM,gBAAgB,GACpB,CAAC,CAAC,CAAC,0BAA0B,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC;YACvE,CAAC,CAAC,CAAC,yBAAyB,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC;YACtE,CAAC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC;YACvF,CAAC,CAAC,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,gBAAgB;YAAE,OAAO;QAE9B,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChC,GAAG,CAAC,MAAM,CAAC;YACT,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,KAAK;YACL,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK;YAC7B,WAAW,EAAE,OAAO,KAAK,CAAC,MAAM,wEAAwE,KAAK,CAAC,MAAM,uGAAuG;YAC3N,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/src/rules/no-redundant-east-cast.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const noRedundantEastCast: EastRule;
+//# sourceMappingURL=no-redundant-east-cast.d.ts.map

package/dist/src/rules/no-redundant-east-cast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-redundant-east-cast.d.ts","sourceRoot":"","sources":["../../../src/rules/no-redundant-east-cast.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAU5C,eAAO,MAAM,mBAAmB,EAAE,QAkCjC,CAAC"}

package/dist/src/rules/no-redundant-east-cast.js

@@ -0,0 +1,44 @@
+import { matchBlockBuilderCall } from "../block-builder.js";
+const NAME = "no-redundant-east-cast";
+const CODE = 990001;
+// `$.let` / `$.const` two-arg overload is `(<T>(expr: SubtypeExprOrValue<NoInfer<T>>, type: T) => ...)`:
+// `NoInfer<T>` makes the East type argument drive inference, so a TS cast on the
+// value is dead weight. (The one-arg overload infers from the value, where a
+// cast *would* matter — hence we only fire when the type argument is present.)
+export const noRedundantEastCast = {
+    name: NAME,
+    code: CODE,
+    description: "Disallow a TypeScript cast on the value argument of $.let/$.const when the East type argument is present (the type argument already drives inference).",
+    check(node, ctx) {
+        const match = matchBlockBuilderCall(node, ctx);
+        if (match === undefined || match.args.length < 2)
+            return;
+        const t = ctx.ts;
+        const value = match.args[0];
+        if (value === undefined)
+            return;
+        let inner;
+        if (t.isAsExpression(value))
+            inner = value.expression;
+        else if (t.isTypeAssertionExpression(value))
+            inner = value.expression;
+        if (inner === undefined)
+            return;
+        const sf = ctx.sourceFile;
+        const start = value.getStart(sf);
+        const length = value.getEnd() - start;
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length,
+            messageText: `Redundant cast: \`$.${match.method}\` infers the value type from the East type argument; drop the \`as …\` on the value.`,
+            category: "warning",
+            fix: {
+                description: "Remove redundant cast",
+                changes: [{ start, length, newText: inner.getText(sf) }],
+            },
+        });
+    },
+};
+//# sourceMappingURL=no-redundant-east-cast.js.map

package/dist/src/rules/no-redundant-east-cast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-redundant-east-cast.js","sourceRoot":"","sources":["../../../src/rules/no-redundant-east-cast.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,yGAAyG;AACzG,iFAAiF;AACjF,6EAA6E;AAC7E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAa;IAC3C,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,WAAW,EACT,wJAAwJ;IAC1J,KAAK,CAAC,IAAI,EAAE,GAAG;QACb,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC/C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO;QAEzD,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QACjB,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO;QAEhC,IAAI,KAAgC,CAAC;QACrC,IAAI,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC;YAAE,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC;aACjD,IAAI,CAAC,CAAC,yBAAyB,CAAC,KAAK,CAAC;YAAE,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC;QACtE,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO;QAEhC,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC;QAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACjC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC;QACtC,GAAG,CAAC,MAAM,CAAC;YACT,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,KAAK;YACL,MAAM;YACN,WAAW,EAAE,uBAAuB,KAAK,CAAC,MAAM,uFAAuF;YACvI,QAAQ,EAAE,SAAS;YACnB,GAAG,EAAE;gBACH,WAAW,EAAE,uBAAuB;gBACpC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;aACzD;SACF,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/src/rules/no-reinlined-east-binding.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const noReinlinedEastBinding: EastRule;
+//# sourceMappingURL=no-reinlined-east-binding.d.ts.map

package/dist/src/rules/no-reinlined-east-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reinlined-east-binding.d.ts","sourceRoot":"","sources":["../../../src/rules/no-reinlined-east-binding.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAsB5C,eAAO,MAAM,sBAAsB,EAAE,QAuDpC,CAAC"}

package/dist/src/rules/no-reinlined-east-binding.js

@@ -0,0 +1,79 @@
+import { isEastExprType } from "../east-type.js";
+import { matchBlockBuilderCall } from "../block-builder.js";
+import { enclosingBlockScope } from "../block-scope.js";
+const NAME = "no-reinlined-east-binding";
+const CODE = 990010;
+// An East `Expr` is a value tree, not a slot. Bound to a JS `const`/`let` and
+// referenced more than once inside the same East block, it is *re-inlined* at
+// each use — the tree is duplicated, so it is re-evaluated per use and (for
+// mutable values) gets a fresh identity each time. `$.let`/`$.const` introduce
+// a single block binding evaluated once and referenced by name, which is the
+// only way to get single-evaluation + shared identity. So multi-use JS bindings
+// of an `Expr` are an error, not a style nit.
+//
+// Scoped to the hazard: a single use is a harmless alias / single-pass argument,
+// and inline composition (`Stack.VStack([A(), B(), …])`) never binds, so neither
+// trips. Re-inlining only duplicates within one East block tree, so the count is
+// bucketed per enclosing East block scope (an `East.function` body or, for JSX
+// authoring, a `<Reactive>{$ => …}}` / `ui(…)` BlockBuilder callback).
+export const noReinlinedEastBinding = {
+    name: NAME,
+    code: CODE,
+    description: "An East Expr bound to a JS const/let and reused inside an East block is re-inlined per use — bind it once with $.let/$.const.",
+    check(node, ctx) {
+        const t = ctx.ts;
+        if (!t.isVariableDeclaration(node))
+            return;
+        if (!t.isIdentifier(node.name))
+            return;
+        if (node.initializer === undefined)
+            return;
+        let init = node.initializer;
+        while (t.isParenthesizedExpression(init))
+            init = init.expression;
+        // `$.let(...)` / `$.const(...)` is the correct form — never flag it.
+        if (matchBlockBuilderCall(init, ctx) !== undefined)
+            return;
+        // Aliasing an existing binding (`const a = b`) re-inlines nothing; the root
+        // binding, if unbound, is flagged at its own declaration.
+        if (t.isIdentifier(init))
+            return;
+        // Only Expr-typed bindings re-inline. Types (`StructType(...)`), plain JS
+        // objects, callbacks held for a single handoff, etc. are fine.
+        if (!isEastExprType(ctx.checker.getTypeAtLocation(init)))
+            return;
+        const declSymbol = ctx.checker.getSymbolAtLocation(node.name);
+        if (declSymbol === undefined)
+            return;
+        const name = node.name.text;
+        const perBody = new Map();
+        const visit = (n) => {
+            if (t.isIdentifier(n) && n !== node.name && n.text === name) {
+                if (ctx.checker.getSymbolAtLocation(n) === declSymbol) {
+                    const body = enclosingBlockScope(n, ctx);
+                    if (body !== undefined)
+                        perBody.set(body, (perBody.get(body) ?? 0) + 1);
+                }
+            }
+            t.forEachChild(n, visit);
+        };
+        visit(ctx.sourceFile);
+        let maxInBody = 0;
+        for (const count of perBody.values())
+            if (count > maxInBody)
+                maxInBody = count;
+        if (maxInBody < 2)
+            return;
+        const sf = ctx.sourceFile;
+        const start = node.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: node.getEnd() - start,
+            messageText: "This East expression is bound to a JS `const`/`let` and used more than once inside an East block, so it is re-inlined — and re-evaluated, with a fresh identity for mutable values — at each use. Bind it once with `$.const`/`$.let`.",
+            category: "error",
+        });
+    },
+};
+//# sourceMappingURL=no-reinlined-east-binding.js.map

package/dist/src/rules/no-reinlined-east-binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reinlined-east-binding.js","sourceRoot":"","sources":["../../../src/rules/no-reinlined-east-binding.ts"],"names":[],"mappings":"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"}

package/dist/src/rules/no-relative-src-import.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const noRelativeSrcImport: EastRule;
+//# sourceMappingURL=no-relative-src-import.d.ts.map

package/dist/src/rules/no-relative-src-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-relative-src-import.d.ts","sourceRoot":"","sources":["../../../src/rules/no-relative-src-import.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAW5C,eAAO,MAAM,mBAAmB,EAAE,QA6BjC,CAAC"}

package/dist/src/rules/no-relative-src-import.js

@@ -0,0 +1,40 @@
+const NAME = "no-relative-src-import";
+const CODE = 990007;
+const DEEP_PACKAGE_SRC = /^@elaraai\/[^/]+\/src(\/|$)/;
+const RELATIVE_SRC = /\/src(\/|$)/;
+// Tests and examples must import East packages by their published name
+// (`@elaraai/east`), not reach into a package's `src/` via a relative path or a
+// deep `/src` specifier — those bypass the package's public API surface.
+export const noRelativeSrcImport = {
+    name: NAME,
+    code: CODE,
+    description: "Import East packages by published name, not via ../src or a deep /src path.",
+    check(node, ctx) {
+        const t = ctx.ts;
+        let specifier;
+        if (t.isImportDeclaration(node))
+            specifier = node.moduleSpecifier;
+        else if (t.isExportDeclaration(node))
+            specifier = node.moduleSpecifier;
+        else
+            return;
+        if (specifier === undefined || !t.isStringLiteral(specifier))
+            return;
+        const text = specifier.text;
+        const relativeIntoSrc = text.startsWith(".") && RELATIVE_SRC.test(text);
+        const deepPackageSrc = DEEP_PACKAGE_SRC.test(text);
+        if (!relativeIntoSrc && !deepPackageSrc)
+            return;
+        const sf = ctx.sourceFile;
+        const start = specifier.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: specifier.getEnd() - start,
+            messageText: "Import East packages by their published name (e.g. `@elaraai/east`), not a relative `../src/...` path or a deep `/src` import.",
+            category: "warning",
+        });
+    },
+};
+//# sourceMappingURL=no-relative-src-import.js.map

package/dist/src/rules/no-relative-src-import.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-relative-src-import.js","sourceRoot":"","sources":["../../../src/rules/no-relative-src-import.ts"],"names":[],"mappings":"AAOA,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,MAAM,gBAAgB,GAAG,6BAA6B,CAAC;AACvD,MAAM,YAAY,GAAG,aAAa,CAAC;AAEnC,uEAAuE;AACvE,gFAAgF;AAChF,yEAAyE;AACzE,MAAM,CAAC,MAAM,mBAAmB,GAAa;IAC3C,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,WAAW,EAAE,6EAA6E;IAC1F,KAAK,CAAC,IAAI,EAAE,GAAG;QACb,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QACjB,IAAI,SAAoC,CAAC;QACzC,IAAI,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAAE,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC;aAC7D,IAAI,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAAE,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC;;YAClE,OAAO;QAEZ,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC;YAAE,OAAO;QACrE,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QAC5B,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxE,MAAM,cAAc,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,eAAe,IAAI,CAAC,cAAc;YAAE,OAAO;QAEhD,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC;QAC1B,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACrC,GAAG,CAAC,MAAM,CAAC;YACT,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,KAAK;YACL,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,KAAK;YAClC,WAAW,EACT,gIAAgI;YAClI,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/src/rules/no-ts-helpers-in-east.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const noTsHelpersInEast: EastRule;
+//# sourceMappingURL=no-ts-helpers-in-east.d.ts.map

package/dist/src/rules/no-ts-helpers-in-east.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-ts-helpers-in-east.d.ts","sourceRoot":"","sources":["../../../src/rules/no-ts-helpers-in-east.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAiB5C,eAAO,MAAM,iBAAiB,EAAE,QAsC/B,CAAC"}

package/dist/src/rules/no-ts-helpers-in-east.js

@@ -0,0 +1,50 @@
+import { isEastExprType } from "../east-type.js";
+const NAME = "no-ts-helpers-in-east";
+const CODE = 990010;
+// A TypeScript helper that constructs East values — a `function`/`const` whose
+// return type is an East `Expr` — should be inlined at each call site;
+// repetition is preferred over a `node()`/`link()`-style builder.
+//
+// Keyed on *declarations* (function declarations and `const fn = (…) => …`),
+// which excludes every inline callback (East.function bodies, `.map`, event
+// handlers are bare arrow *arguments*, never declarations). Note: a component
+// factory (`createButton(): ExprType<UIComponentType>`) is structurally
+// identical, so this rule is APPLICATION-SCOPED — the daemon must not run it on
+// East library-factory packages. Hence it is exported separately, not in the
+// default `allRules`.
+export const noTsHelpersInEast = {
+    name: NAME,
+    code: CODE,
+    description: "Disallow TypeScript helpers that build East values (functions returning an East expression); inline at the call site.",
+    check(node, ctx) {
+        const t = ctx.ts;
+        let fnLike;
+        let reportNode;
+        if (t.isFunctionDeclaration(node) && node.body !== undefined && node.name !== undefined) {
+            fnLike = node;
+            reportNode = node.name;
+        }
+        else if (t.isVariableDeclaration(node) &&
+            node.initializer !== undefined &&
+            (t.isArrowFunction(node.initializer) || t.isFunctionExpression(node.initializer))) {
+            fnLike = node.initializer;
+            reportNode = node.name;
+        }
+        if (fnLike === undefined || reportNode === undefined)
+            return;
+        const signature = ctx.checker.getSignatureFromDeclaration(fnLike);
+        if (signature === undefined || !isEastExprType(signature.getReturnType()))
+            return;
+        const sf = ctx.sourceFile;
+        const start = reportNode.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: reportNode.getEnd() - start,
+            messageText: "This TypeScript helper builds an East value (it returns an East expression). Inline the construction at each call site instead of factoring it into a helper — repetition is preferred.",
+            category: "warning",
+        });
+    },
+};
+//# sourceMappingURL=no-ts-helpers-in-east.js.map

package/dist/src/rules/no-ts-helpers-in-east.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-ts-helpers-in-east.js","sourceRoot":"","sources":["../../../src/rules/no-ts-helpers-in-east.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,+EAA+E;AAC/E,uEAAuE;AACvE,kEAAkE;AAClE,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,8EAA8E;AAC9E,wEAAwE;AACxE,gFAAgF;AAChF,6EAA6E;AAC7E,sBAAsB;AACtB,MAAM,CAAC,MAAM,iBAAiB,GAAa;IACzC,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,WAAW,EACT,uHAAuH;IACzH,KAAK,CAAC,IAAI,EAAE,GAAG;QACb,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QAEjB,IAAI,MAA2C,CAAC;QAChD,IAAI,UAA+B,CAAC;QACpC,IAAI,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACxF,MAAM,GAAG,IAAI,CAAC;YACd,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC;QACzB,CAAC;aAAM,IACL,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC;YAC7B,IAAI,CAAC,WAAW,KAAK,SAAS;YAC9B,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EACjF,CAAC;YACD,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC;YAC1B,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC;QACzB,CAAC;QACD,IAAI,MAAM,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS;YAAE,OAAO;QAE7D,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;QAClE,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC;YAAE,OAAO;QAElF,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC;QAC1B,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACtC,GAAG,CAAC,MAAM,CAAC;YACT,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,KAAK;YACL,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,GAAG,KAAK;YACnC,WAAW,EACT,yLAAyL;YAC3L,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/src/rules/no-unexecuted-east-expression.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const noUnexecutedEastExpression: EastRule;
+//# sourceMappingURL=no-unexecuted-east-expression.d.ts.map

package/dist/src/rules/no-unexecuted-east-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unexecuted-east-expression.d.ts","sourceRoot":"","sources":["../../../src/rules/no-unexecuted-east-expression.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAY5C,eAAO,MAAM,0BAA0B,EAAE,QAuCxC,CAAC"}

package/dist/src/rules/no-unexecuted-east-expression.js

@@ -0,0 +1,50 @@
+import { isEastExprType, isBlockBuilderType } from "../east-type.js";
+const NAME = "no-unexecuted-east-expression";
+const CODE = 990009;
+// A bare expression statement whose value is an East `Expr` is dead: East
+// expressions are pure values, so unless executed with `$( … )` or bound with
+// `$.let`/`$.const`, the statement has no effect. Catches both calling an
+// effectful function without `$()` (`log(msg);`) and `East.value(x);` standing
+// alone. The `$( … )` / `$.x( … )` execution forms return `void`, and are
+// excluded explicitly so renamed builders never false-positive.
+export const noUnexecutedEastExpression = {
+    name: NAME,
+    code: CODE,
+    description: "Flag a bare East expression statement that is never executed with $() or bound — it has no effect.",
+    check(node, ctx) {
+        const t = ctx.ts;
+        if (!t.isExpressionStatement(node))
+            return;
+        const expr = node.expression;
+        // Exclude any statement rooted in the block builder `$`: `$(...)`, `$.if(...)`,
+        // chained `$.if(...).else(...)`, `$.try(...).catch(...)`, etc. Walk down the
+        // call/member chain to its base receiver and check that.
+        let root = expr;
+        for (;;) {
+            if (t.isCallExpression(root)) {
+                root = root.expression;
+            }
+            else if (t.isPropertyAccessExpression(root) || t.isElementAccessExpression(root)) {
+                root = root.expression;
+            }
+            else {
+                break;
+            }
+        }
+        if (isBlockBuilderType(ctx.checker.getTypeAtLocation(root)))
+            return;
+        if (!isEastExprType(ctx.checker.getTypeAtLocation(expr)))
+            return;
+        const sf = ctx.sourceFile;
+        const start = expr.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: expr.getEnd() - start,
+            messageText: "This East expression is never executed or bound, so it has no effect. Wrap it in `$( … )` to run it for its effect, or bind it with `$.let` / `$.const`.",
+            category: "warning",
+        });
+    },
+};
+//# sourceMappingURL=no-unexecuted-east-expression.js.map

package/dist/src/rules/no-unexecuted-east-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unexecuted-east-expression.js","sourceRoot":"","sources":["../../../src/rules/no-unexecuted-east-expression.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,0EAA0E;AAC1E,8EAA8E;AAC9E,0EAA0E;AAC1E,+EAA+E;AAC/E,0EAA0E;AAC1E,gEAAgE;AAChE,MAAM,CAAC,MAAM,0BAA0B,GAAa;IAClD,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,WAAW,EACT,oGAAoG;IACtG,KAAK,CAAC,IAAI,EAAE,GAAG;QACb,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QACjB,IAAI,CAAC,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC;YAAE,OAAO;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;QAE7B,gFAAgF;QAChF,6EAA6E;QAC7E,yDAAyD;QACzD,IAAI,IAAI,GAAY,IAAI,CAAC;QACzB,SAAS,CAAC;YACR,IAAI,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;YACzB,CAAC;iBAAM,IAAI,CAAC,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,CAAC;gBACnF,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;YACzB,CAAC;iBAAM,CAAC;gBACN,MAAM;YACR,CAAC;QACH,CAAC;QACD,IAAI,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAAE,OAAO;QAEpE,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAAE,OAAO;QAEjE,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChC,GAAG,CAAC,MAAM,CAAC;YACT,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,IAAI;YACV,KAAK;YACL,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK;YAC7B,WAAW,EACT,0JAA0J;YAC5J,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/src/rules/prefer-explicit-east-type.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const preferExplicitEastType: EastRule;
+//# sourceMappingURL=prefer-explicit-east-type.d.ts.map

package/dist/src/rules/prefer-explicit-east-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-explicit-east-type.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-explicit-east-type.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AAiCtD,eAAO,MAAM,sBAAsB,EAAE,QAiCpC,CAAC"}

package/dist/src/rules/prefer-explicit-east-type.js

@@ -0,0 +1,60 @@
+import { matchBlockBuilderCall } from "../block-builder.js";
+const NAME = "prefer-explicit-east-type";
+const CODE = 990002;
+function isEmptyNewMapOrSet(node, t) {
+    if (!t.isNewExpression(node) || !t.isIdentifier(node.expression))
+        return false;
+    const ctor = node.expression.text;
+    if (ctor !== "Map" && ctor !== "Set")
+        return false;
+    return node.arguments === undefined || node.arguments.length === 0;
+}
+function isRawValueLiteral(node, t) {
+    return (t.isNumericLiteral(node) ||
+        t.isBigIntLiteral(node) ||
+        t.isStringLiteralLike(node) ||
+        node.kind === t.SyntaxKind.TrueKeyword ||
+        node.kind === t.SyntaxKind.FalseKeyword ||
+        node.kind === t.SyntaxKind.NullKeyword ||
+        t.isArrayLiteralExpression(node) ||
+        t.isObjectLiteralExpression(node) ||
+        t.isNewExpression(node));
+}
+// The one-arg `$.let(x)` / `$.const(x)` form infers the East type from the JS
+// value. That is fine when `x` is already an East expression (type fully
+// determined), but for an under-determined literal — `[]`, `{}`, `new Map()` —
+// the inferred type is `never`/empty and almost always wrong. Nudge toward the
+// explicit two-arg form. Stays silent on East expressions so `$.let(arr.sum())`
+// is not flagged.
+export const preferExplicitEastType = {
+    name: NAME,
+    code: CODE,
+    description: "Encourage passing the East type as the second argument to $.let/$.const for raw JS values whose East type is under-determined.",
+    check(node, ctx) {
+        const match = matchBlockBuilderCall(node, ctx);
+        if (match === undefined || match.args.length !== 1)
+            return;
+        const t = ctx.ts;
+        const value = match.args[0];
+        if (value === undefined)
+            return;
+        const underDetermined = (t.isArrayLiteralExpression(value) && value.elements.length === 0) ||
+            (t.isObjectLiteralExpression(value) && value.properties.length === 0) ||
+            isEmptyNewMapOrSet(value, t);
+        const mode = ctx.options.preferExplicitEastType?.mode ?? "under-determined";
+        const flag = underDetermined || (mode === "all-raw-values" && isRawValueLiteral(value, t));
+        if (!flag)
+            return;
+        const sf = ctx.sourceFile;
+        const start = value.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: value.getEnd() - start,
+            messageText: `Provide the East type as the second argument to \`$.${match.method}\` — e.g. \`$.${match.method}([], ArrayType(FloatType))\` — to pin the value type; it is under-determined from the value alone.`,
+            category: "suggestion",
+        });
+    },
+};
+//# sourceMappingURL=prefer-explicit-east-type.js.map

package/dist/src/rules/prefer-explicit-east-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-explicit-east-type.js","sourceRoot":"","sources":["../../../src/rules/prefer-explicit-east-type.ts"],"names":[],"mappings":"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"}

package/dist/src/rules/prefer-jsx-over-factory-call.d.ts

@@ -0,0 +1,3 @@
+import type { EastRule } from "../types.js";
+export declare const preferJsxOverFactoryCall: EastRule;
+//# sourceMappingURL=prefer-jsx-over-factory-call.d.ts.map

package/dist/src/rules/prefer-jsx-over-factory-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-jsx-over-factory-call.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-jsx-over-factory-call.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAyB,MAAM,aAAa,CAAC;AAoHnE,eAAO,MAAM,wBAAwB,EAAE,QA0CtC,CAAC"}

package/dist/src/rules/prefer-jsx-over-factory-call.js

@@ -0,0 +1,141 @@
+const NAME = "prefer-jsx-over-factory-call";
+const CODE = 990012;
+// The signal that a `Foo.Root(...)` factory call has a `<Foo>` JSX tag form is
+// not the import path — it's the RESULT TYPE. Every UI component factory's
+// `.Root(...)` returns the same type a JSX element evaluates to (`JSX.Element`
+// for this file's JSX runtime). So a `.Root(...)` whose result is that element
+// type is, by construction, authorable as a tag — independent of which package
+// it came from. This keys on the type, so it generalises to any JSX-producing
+// factory and needs no per-package list.
+// Resolving `JSX.Element` walks the filesystem, so memoize it per file (the
+// SourceFile is rebuilt on every program, so the key is naturally invalidated).
+// `null` records "no JSX element type here" so we don't re-resolve on each call.
+const jsxElementCache = new WeakMap();
+/** The `JSX.Element` type for `sourceFile`'s active JSX runtime, or undefined. */
+function jsxElementType(ctx) {
+    const cached = jsxElementCache.get(ctx.sourceFile);
+    if (cached !== undefined)
+        return cached ?? undefined;
+    const computed = computeJsxElementType(ctx);
+    jsxElementCache.set(ctx.sourceFile, computed ?? null);
+    return computed;
+}
+function computeJsxElementType(ctx) {
+    const t = ctx.ts;
+    const elementOf = (ns) => {
+        const el = ctx.checker.getExportsOfModule(ns).find((s) => s.name === "Element");
+        return el ? ctx.checker.getDeclaredTypeOfSymbol(el) : undefined;
+    };
+    // Classic / global runtime: a visible `JSX` namespace (global or imported).
+    const resolveName = ctx.checker.resolveName;
+    const globalNs = resolveName?.("JSX", ctx.sourceFile, t.SymbolFlags.Namespace, false);
+    if (globalNs !== undefined) {
+        const fromGlobal = elementOf(globalNs);
+        if (fromGlobal !== undefined)
+            return fromGlobal;
+    }
+    // Automatic runtime (`jsx: react-jsx` + `jsxImportSource`): the `JSX` namespace
+    // lives in `<source>/jsx-runtime`, not globally. Resolve that module and read
+    // its `JSX.Element`. Needs the program for compiler options + resolution.
+    const program = ctx.program;
+    if (program === undefined)
+        return undefined;
+    const options = program.getCompilerOptions();
+    const base = jsxImportSourceFor(options, ctx.sourceFile, t);
+    if (base === undefined)
+        return undefined;
+    // Resolve exactly as TypeScript does. The host checks the program's loaded
+    // source files first (so in-memory programs resolve), then falls through to
+    // `ts.sys` for everything else on disk (package.json `exports`, node_modules).
+    const resolutionHost = {
+        fileExists: (f) => program.getSourceFile(f) !== undefined || t.sys.fileExists(f),
+        readFile: (f) => program.getSourceFile(f)?.text ?? t.sys.readFile(f),
+        directoryExists: (d) => t.sys.directoryExists(d),
+        getCurrentDirectory: () => t.sys.getCurrentDirectory(),
+        getDirectories: (d) => t.sys.getDirectories(d),
+    };
+    if (t.sys.realpath !== undefined)
+        resolutionHost.realpath = (p) => t.sys.realpath(p);
+    const resolved = t.resolveModuleName(`${base}/jsx-runtime`, ctx.sourceFile.fileName, options, resolutionHost).resolvedModule?.resolvedFileName;
+    if (resolved === undefined)
+        return undefined;
+    const runtimeSf = program.getSourceFile(resolved);
+    const moduleSym = runtimeSf ? ctx.checker.getSymbolAtLocation(runtimeSf) : undefined;
+    if (moduleSym === undefined)
+        return undefined;
+    const jsxNs = ctx.checker.getExportsOfModule(moduleSym).find((s) => s.name === "JSX");
+    return jsxNs ? elementOf(jsxNs) : undefined;
+}
+/** The JSX import source in effect for `sourceFile` (per-file pragma overrides). */
+function jsxImportSourceFor(options, sourceFile, t) {
+    const pragmas = sourceFile.pragmas;
+    const pragma = pragmas?.get("jsximportsource");
+    const fromPragma = Array.isArray(pragma)
+        ? pragma[pragma.length - 1]?.arguments?.factory
+        : pragma?.arguments?.factory;
+    if (fromPragma !== undefined)
+        return fromPragma;
+    // Only the automatic runtime carries an implicit import source.
+    if (options.jsx !== t.JsxEmit.ReactJSX && options.jsx !== t.JsxEmit.ReactJSXDev)
+        return undefined;
+    return options.jsxImportSource ?? "react";
+}
+/** True when `a` and `b` are the same type (mutually assignable). */
+function sameType(a, b, checker) {
+    const c = checker;
+    if (c.isTypeAssignableTo === undefined)
+        return a === b; // older TS: identity only
+    return c.isTypeAssignableTo(a, b) && c.isTypeAssignableTo(b, a);
+}
+// In a `.tsx` file, `Foo.Root(...)` on a plain identifier whose result is the
+// file's JSX element type is the un-migrated form — author it as `<Foo>`. Gated:
+// JSX file only; `Ident.Root(...)` on a bare identifier (so `Slice.Frame.Root(...)`
+// / `Slice.config(...)` never match); and the call's result type is JSX.Element
+// (so a `.Root` returning anything else — a config object, a number — is silent).
+export const preferJsxOverFactoryCall = {
+    name: NAME,
+    code: CODE,
+    description: "In a .tsx file, prefer the <Foo> JSX tag over a factory's Foo.Root(...) when the call produces a JSX element.",
+    check(node, ctx) {
+        const t = ctx.ts;
+        if (ctx.sourceFile.languageVariant !== t.LanguageVariant.JSX)
+            return;
+        if (!t.isCallExpression(node))
+            return;
+        const callee = node.expression;
+        if (!t.isPropertyAccessExpression(callee))
+            return;
+        if (callee.name.text !== "Root")
+            return;
+        if (!t.isIdentifier(callee.expression))
+            return;
+        const factoryIdent = callee.expression;
+        const element = jsxElementType(ctx);
+        if (element === undefined)
+            return;
+        const result = ctx.checker.getTypeAtLocation(node);
+        if (!sameType(result, element, ctx.checker))
+            return;
+        // The tag is named after the factory's *exported* name, not the local
+        // binding — so an aliased import (`import { Box as BoxFactory }`) still
+        // suggests `<Box>`, not `<BoxFactory>`.
+        let tagName = factoryIdent.text;
+        const sym = ctx.checker.getSymbolAtLocation(factoryIdent);
+        if (sym !== undefined && (sym.flags & t.SymbolFlags.Alias) !== 0) {
+            const target = ctx.checker.getAliasedSymbol(sym);
+            if (target.name.length > 0)
+                tagName = target.name;
+        }
+        const sf = ctx.sourceFile;
+        const start = callee.getStart(sf);
+        ctx.report({
+            ruleName: NAME,
+            code: CODE,
+            start,
+            length: callee.getEnd() - start,
+            messageText: `Author this with the \`<${tagName}>\` JSX tag instead of \`${factoryIdent.text}.Root(...)\` — in a .tsx file the JSX tag is the authoring surface (the call already produces a JSX element).`,
+            category: "suggestion",
+        });
+    },
+};
+//# sourceMappingURL=prefer-jsx-over-factory-call.js.map