svelte-shaker 0.15.1 → 0.15.3

package/dist/analyze.js

@@ -1,7 +1,7 @@
 import { parseCached, parseModuleProgram, walk, } from './parse.js';
-import { emptyPlan, } from './ir.js';
+import { emptyPlan, isFoldableValue, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
-import { evaluate, setVar } from './eval.js';
+import { evaluate, literalValue, setVar, unwrapTsAssertions } from './eval.js';
 const isSvelte = (source) => source.endsWith('.svelte');
 /** Floor for the fixpoint iteration bound (see {@link fixpointIterationBound}). */
 const MIN_FIXPOINT_ITERATIONS = 10;
@@ -856,6 +856,11 @@ function computeScriptConstEnv(ast, instance, moduleScript, propsDeclaration, wr
  * rune call — is evaluated verbatim, so a non-value rune simply falls to unknown.
  */
 function evalDeclaratorValue(init, env) {
+    // `const x = $state(0) as T` wraps the rune in a `TSAsExpression`; erase the
+    // (runtime-transparent) assertion first so the `$state`/`$state.raw` unwrap
+    // below and `evaluate` both see the real initializer, same as a parser that
+    // strips the assertion would.
+    init = unwrapTsAssertions(init) ?? undefined;
     if (isStateRuneCall(init)) {
         const arg = init?.arguments?.[0];
         if (arg == null)
@@ -1081,9 +1086,13 @@ function collectTemplateBindings(ast, instance, propsDeclaration) {
 function collectWrittenNames(node, out) {
     if (node.type === 'AssignmentExpression')
         addPatternNames(node.left, out);
-    else if (node.type === 'UpdateExpression' && node.argument?.type === 'Identifier') {
-        if (node.argument.name)
-            out.add(node.argument.name);
+    else if (node.type === 'UpdateExpression') {
+        // `x!++` keeps the `!` as a `TSNonNullExpression` around the target (only a
+        // bare `x = …` LHS is normalized to the identifier), so read through it or the
+        // write goes uncounted and the name is wrongly admitted as a constant.
+        const arg = unwrapTsAssertions(node.argument);
+        if (arg?.type === 'Identifier' && arg.name)
+            out.add(arg.name);
     }
 }
 /**
@@ -1091,6 +1100,11 @@ function collectWrittenNames(node, out) {
  * Handles bare identifiers, object/array destructuring, defaults and rest.
  */
 function addPatternNames(pattern, out) {
+    // A non-null-asserted assignment target keeps its `TSNonNullExpression` wrapper
+    // in every position but a bare `x = …` LHS — `x! += 1`, `[x!] = a`, `({k: x!} =
+    // o)` — so peel it here (the one choke point every pattern position recurses
+    // through) to count the write against the bare name.
+    pattern = unwrapTsAssertions(pattern) ?? undefined;
     if (!pattern)
         return;
     switch (pattern.type) {
@@ -1467,8 +1481,14 @@ function literalAttrValue(value) {
         const part = parts[0];
         if (part.type === 'Text')
             return { known: true, value: (part.data ?? part.raw ?? '') };
-        if (part.type === 'ExpressionTag' && part.expression?.type === 'Literal') {
-            return { known: true, value: part.expression.value };
+        if (part.type === 'ExpressionTag') {
+            // Recognize `prop={'x' as const}` as the literal it wraps, so the write is
+            // classified NON-dynamic identically to a parser that strips the assertion.
+            // Both paths already fold the value (via the expr fallback), but the
+            // `dynamic` flag itself must match — mono's `specializableShape` reads it.
+            const expr = unwrapTsAssertions(part.expression);
+            if (expr?.type === 'Literal')
+                return literalValue(expr);
         }
         return { known: false };
     }
@@ -1529,7 +1549,9 @@ function buildPlan(model, u, ownerEnv) {
             continue;
         // constant fold: a clean singleton value set is the foldable case.
         if (set.values.length === 1) {
-            plan.constFold.set(decl.name, set.values[0]);
+            const only = set.values[0];
+            if (isFoldableValue(only))
+                plan.constFold.set(decl.name, only);
             continue;
         }
         // value-set narrowing: >= 2 distinct literals with no dynamic/⊤ contribution is a fully
@@ -1608,10 +1630,18 @@ function valueSetFor(decl, sites, ownerEnv) {
     return { values, dynamic, top };
 }
 function literalDefault(expr) {
+    // A default like `= 500 as const` reaches here as a `TSAsExpression`; the
+    // assertion erases at runtime, so read through it to the bare default value.
+    expr = unwrapTsAssertions(expr) ?? undefined;
     if (!expr)
         return { known: true, value: undefined }; // omitted default -> undefined
+    // `literalValue` is the same gate `literalAttrValue` and `evaluate` use: a
+    // BigInt/RegExp default (no faithful source form) or a `null` that is really
+    // `1e999` surviving JSON transport must stay UNKNOWN here too, or a call site
+    // that merely omits the prop reintroduces the crash/misfold this default path
+    // exists to prevent.
     if (expr.type === 'Literal')
-        return { known: true, value: expr.value };
+        return literalValue(expr);
     if (expr.type === 'Identifier' && expr.name === 'undefined')
         return { known: true, value: undefined };
     return { known: false };

package/dist/eval.d.ts

@@ -6,6 +6,21 @@ export type EvalResult = {
 } | {
     known: false;
 };
+/**
+ * Strip TypeScript assertion wrappers — `x as T` (`TSAsExpression`), `x!`
+ * (`TSNonNullExpression`), `x satisfies T` (`TSSatisfiesExpression`) — down to
+ * the runtime expression they wrap, recursing so `('a' as const)!` becomes `'a'`.
+ *
+ * These are compile-time-only type operators: they are erased before any code
+ * runs and do not touch the operand's value, so interpreting the operand IS
+ * interpreting the whole expression (docs/ARCHITECTURE.md §2.2 — the value the
+ * expression abstracts to is exactly the operand's). The engine runs on the
+ * `lang="ts"` source with types preserved (§6.3), so svelte/compiler hands it
+ * these nodes verbatim; a parser that erases them (rsvelte today) yields the bare
+ * operand instead. Unwrapping here folds both ASTs identically — the
+ * parser-neutrality contract every value-interpreting entry point relies on.
+ */
+export declare function unwrapTsAssertions(node: AnyNode | null | undefined): AnyNode | null | undefined;
 /**
  * A deliberately tiny, total constant evaluator over an ESTree expression,
  * given an environment of statically-known identifiers.  It never throws and
@@ -16,6 +31,21 @@ export type EvalResult = {
  * unknown on non-distributive ops), just without the interprocedural lattice.
  */
 export declare function evaluate(node: AnyNode | null | undefined, env: ReadonlyMap<string, Literal>): EvalResult;
+/**
+ * The `Literal` value of an ESTree `Literal` node, or unknown when the node
+ * carries a value outside that union.  This is the ONLY door through which a
+ * parsed value enters the engine, so it is where the union is enforced:
+ *
+ *  - **RegExp / BigInt literals** (`/x/g`, `1n`) hold a `RegExp` / `bigint` in
+ *    `value` — no faithful literal source form, and `JSON.stringify` throws on
+ *    the latter and flattens the former to `{}`.  Both carry a discriminator.
+ *  - **`value: null`** is ambiguous: an AST that reached us as JSON (the rsvelte
+ *    parser crosses a WASM boundary that way) cannot represent `Infinity`, so
+ *    `1e999` arrives indistinguishable from a genuine `null` except by `raw`.
+ *
+ * Anything unproven stays unknown, which costs one fold — never a wrong one.
+ */
+export declare function literalValue(node: AnyNode): EvalResult;
 /**
  * Sound set-aware predicate.  `constEnv` holds props collapsed to a single
  * literal (`constFold`); `setEnv` holds props whose reachable value set is known

package/dist/eval.js

@@ -1,4 +1,27 @@
 const UNKNOWN = { known: false };
+/**
+ * Strip TypeScript assertion wrappers — `x as T` (`TSAsExpression`), `x!`
+ * (`TSNonNullExpression`), `x satisfies T` (`TSSatisfiesExpression`) — down to
+ * the runtime expression they wrap, recursing so `('a' as const)!` becomes `'a'`.
+ *
+ * These are compile-time-only type operators: they are erased before any code
+ * runs and do not touch the operand's value, so interpreting the operand IS
+ * interpreting the whole expression (docs/ARCHITECTURE.md §2.2 — the value the
+ * expression abstracts to is exactly the operand's). The engine runs on the
+ * `lang="ts"` source with types preserved (§6.3), so svelte/compiler hands it
+ * these nodes verbatim; a parser that erases them (rsvelte today) yields the bare
+ * operand instead. Unwrapping here folds both ASTs identically — the
+ * parser-neutrality contract every value-interpreting entry point relies on.
+ */
+export function unwrapTsAssertions(node) {
+    let current = node;
+    while (current?.type === 'TSAsExpression' ||
+        current?.type === 'TSNonNullExpression' ||
+        current?.type === 'TSSatisfiesExpression') {
+        current = current.expression;
+    }
+    return current;
+}
 /**
  * A deliberately tiny, total constant evaluator over an ESTree expression,
  * given an environment of statically-known identifiers.  It never throws and
@@ -9,11 +32,12 @@ const UNKNOWN = { known: false };
  * unknown on non-distributive ops), just without the interprocedural lattice.
  */
 export function evaluate(node, env) {
+    node = unwrapTsAssertions(node);
     if (!node)
         return UNKNOWN;
     switch (node.type) {
         case 'Literal':
-            return { known: true, value: node.value };
+            return literalValue(node);
         case 'Identifier': {
             const name = node.name ?? '';
             if (name === 'undefined')
@@ -108,6 +132,30 @@ export function evaluate(node, env) {
             return UNKNOWN;
     }
 }
+/**
+ * The `Literal` value of an ESTree `Literal` node, or unknown when the node
+ * carries a value outside that union.  This is the ONLY door through which a
+ * parsed value enters the engine, so it is where the union is enforced:
+ *
+ *  - **RegExp / BigInt literals** (`/x/g`, `1n`) hold a `RegExp` / `bigint` in
+ *    `value` — no faithful literal source form, and `JSON.stringify` throws on
+ *    the latter and flattens the former to `{}`.  Both carry a discriminator.
+ *  - **`value: null`** is ambiguous: an AST that reached us as JSON (the rsvelte
+ *    parser crosses a WASM boundary that way) cannot represent `Infinity`, so
+ *    `1e999` arrives indistinguishable from a genuine `null` except by `raw`.
+ *
+ * Anything unproven stays unknown, which costs one fold — never a wrong one.
+ */
+export function literalValue(node) {
+    if (node.regex !== undefined || node.bigint !== undefined)
+        return UNKNOWN;
+    const v = node.value;
+    if (v === null)
+        return node.raw === 'null' ? { known: true, value: null } : UNKNOWN;
+    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+        return { known: true, value: v };
+    return UNKNOWN;
+}
 /**
  * Sound set-aware predicate.  `constEnv` holds props collapsed to a single
  * literal (`constFold`); `setEnv` holds props whose reachable value set is known
@@ -126,6 +174,7 @@ export function evaluateWithSets(node, constEnv, setEnv) {
 }
 /** Evaluate a boolean condition to a Kleene truth over the value sets. */
 function evalTri(node, constEnv, setEnv) {
+    node = unwrapTsAssertions(node);
     if (!node)
         return 'unknown';
     switch (node.type) {
@@ -193,8 +242,11 @@ function equalityTri(left, right, constEnv, setEnv, loose) {
  * set pass-through (analyze.ts) all decide it through this, so they stay in lockstep.
  */
 export function setVar(node, setEnv) {
-    if (node?.type === 'Identifier' && node.name && setEnv.has(node.name))
-        return setEnv.get(node.name);
+    // A `variant as const` / `variant!` reference is still a bare read of `variant`
+    // (the assertion erases at runtime), so it narrows like the identifier it wraps.
+    const bare = unwrapTsAssertions(node);
+    if (bare?.type === 'Identifier' && bare.name && setEnv.has(bare.name))
+        return setEnv.get(bare.name);
     return null;
 }
 /**

package/dist/ir.d.ts

@@ -131,4 +131,18 @@ export interface ComponentPlan {
      */
     valueSets: Map<string, PropValueSet>;
 }
+/**
+ * Whether a proven value may be SUBSTITUTED into the residual as a constant.
+ *
+ * Every member of {@link Literal} has a faithful source form except `-0`: the
+ * Svelte compiler constant-folds the expression it is spliced into and loses the
+ * sign of zero there (`{1 / n}` renders `-Infinity` with `n = -0` at runtime,
+ * but the folded `{1 / (-0)}` compiles to a literal `Infinity`).  Emitting it
+ * would therefore change what renders even though the value we proved is right,
+ * so a `-0`-valued prop is simply left alone — one missed fold, no risk.
+ *
+ * Narrowing is unaffected: a narrowed prop stays dynamic and is never
+ * substituted, and the comparisons it feeds use real JS semantics.
+ */
+export declare function isFoldableValue(value: Literal): boolean;
 export declare function emptyPlan(id: ComponentId): ComponentPlan;

package/dist/ir.js

@@ -3,6 +3,22 @@
 // See docs/ARCHITECTURE.md §5.1.  This is the M0 (walking-skeleton) subset:
 // only the pieces basic1 exercises, but shaped so later levels slot in.
 // ----------------------------------------------------------------------
+/**
+ * Whether a proven value may be SUBSTITUTED into the residual as a constant.
+ *
+ * Every member of {@link Literal} has a faithful source form except `-0`: the
+ * Svelte compiler constant-folds the expression it is spliced into and loses the
+ * sign of zero there (`{1 / n}` renders `-Infinity` with `n = -0` at runtime,
+ * but the folded `{1 / (-0)}` compiles to a literal `Infinity`).  Emitting it
+ * would therefore change what renders even though the value we proved is right,
+ * so a `-0`-valued prop is simply left alone — one missed fold, no risk.
+ *
+ * Narrowing is unaffected: a narrowed prop stays dynamic and is never
+ * substituted, and the comparisons it feeds use real JS semantics.
+ */
+export function isFoldableValue(value) {
+    return !Object.is(value, -0);
+}
 export function emptyPlan(id) {
     return {
         id,

package/dist/mono.d.ts

@@ -1,6 +1,6 @@
 import { type FileModel } from './analyze.js';
 import { type AnyNode } from './parse.js';
-import type { ComponentId, ComponentPlan, Literal } from './ir.js';
+import { type ComponentId, type ComponentPlan, type Literal } from './ir.js';
 /** Tuning knobs for monomorphization (docs §8.1, §13.2).  All have sound defaults. */
 export interface MonomorphizeOptions {
     /** Master switch.  Default OFF — every existing behavior is unchanged. */

package/dist/mono.js

@@ -60,6 +60,7 @@ import { inSpans } from './dead.js';
 import { shakeBody } from './transform.js';
 import { readCallSite, deadSpansForPlans, isFoldBlockedName, } from './analyze.js';
 import { parseSvelte, walk } from './parse.js';
+import { isFoldableValue } from './ir.js';
 export const DEFAULT_MONO_OPTIONS = {
     enabled: false,
     maxVariants: 8,
@@ -418,6 +419,8 @@ function specializableShape(node, child, plan) {
         // override — exactly the analysis's "safely explicit" condition.
         if (explicit.dynamic || !explicit.afterLastSpread)
             continue;
+        if (!isFoldableValue(explicit.value))
+            continue; // no safe source form — exactly as constant fold
         shape.set(name, explicit.value);
     }
     return shape;

package/dist/parse.d.ts

@@ -75,6 +75,13 @@ export interface AnyNode {
     kind?: string | undefined;
     /** ObjectExpression `Property` shorthand-method flag (`{ m() {} }`). */
     method?: boolean | undefined;
+    /** ESTree `Literal` discriminators, present only on a RegExp (`/x/g`) or
+     * BigInt (`1n`) literal — neither of which carries a foldable `value`. */
+    regex?: {
+        pattern: string;
+        flags: string;
+    } | undefined;
+    bigint?: string | undefined;
     value?: unknown;
 }
 export interface Root extends AnyNode {

package/dist/transform.js

@@ -1014,8 +1014,29 @@ function setDefault(map, key) {
 function isSpace(ch) {
     return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
 }
+/** Source text for a folded value, faithful for every member of {@link Literal}
+ * (the union {@link evaluate} admits).  Always an expression, so it drops into
+ * both substitution positions unchanged. */
 function literalSource(value) {
     if (value === undefined)
         return 'undefined';
+    if (typeof value === 'number')
+        return numberSource(value);
+    return JSON.stringify(value);
+}
+/**
+ * `JSON.stringify` flattens `Infinity`/`-Infinity`/`NaN` to `null`, so those get
+ * an explicit form.  Written as arithmetic rather than the `Infinity`/`NaN`
+ * globals because the substituted text lands in the CALLEE's scope, where a
+ * local of either name would silently capture it; `(0/0)` cannot be shadowed.
+ * (`-0`, the fourth lossy case, never reaches here — see `isFoldableValue`.)
+ */
+function numberSource(value) {
+    if (Number.isNaN(value))
+        return '(0/0)';
+    if (value === Infinity)
+        return '(1/0)';
+    if (value === -Infinity)
+        return '(-1/0)';
     return JSON.stringify(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",