svelte-shaker 0.14.0 → 0.14.1

package/dist/analyze.d.ts

@@ -18,8 +18,10 @@ export type ReadFileSync = (id: ComponentId) => string;
  *    never be seen and is safe to drop;
  *  - `{ kind: 'all' }` — anything we cannot pin down: a `...rest` (captures
  *    undeclared inputs), an Identifier/Array binding (`let p = $props()`),
- *    more than one `$props()` call, or `$props()` outside a `let <pat> = …`
- *    declarator.  Then any input might be observed, so nothing is dropped.
+ *    more than one `$props()` call, `$props()` outside a `let <pat> = …`
+ *    declarator, or a component that observes slotted content outside `$props()`
+ *    — a legacy `<slot>` element or a `$$slots` read (both legal in runes mode).
+ *    Then any input might be observed, so nothing is dropped.
  */
 export type ReachableInputs = {
     kind: 'all';
@@ -275,8 +277,9 @@ export interface UnpassedProp {
  *    spread that could set it (`readCallSite` already folds `bind:`, known
  *    spreads, and `children`/snippet body into `explicit`/`hadSpread`);
  *  - a component in `input.escaped` — one the Shell knows has a consumer OUTSIDE
- *    the `.svelte` graph (a `.ts`/`.js` call site, or a user `preserve`, docs
- *    §4.2) — is skipped, because that consumer may pass a prop the crawl cannot see.
+ *    the `.svelte` graph (a call site in a non-`.svelte` module, or a user
+ *    `preserve`, docs §4.2) — is skipped, because that consumer may pass a prop
+ *    the crawl cannot see.
  *
  * Missing a `.svelte` EDGE (e.g. an unfollowed barrel) only DROPS call sites, so it
  * can only make this UNDER-report (the component looks unused and is skipped). The

package/dist/analyze.js

@@ -29,22 +29,22 @@ function fixpointIterationBound(componentCount) {
 /** Bail reason stamped on a component leaked as a value (docs §4.1 escape). */
 const ESCAPE_REASON = 'escapes as value (e.g. <svelte:component this={X}>)';
 /** Bail reason stamped on a component with a consumer OUTSIDE the analyzed
- * `.svelte` graph — a `.ts`/`.js` call site the crawl cannot parse, or a
- * user-declared `preserve` (docs §4.2, {@link AnalyzeInput.escaped}).  Kept
- * byte-identical to the Rust engine's constant so the two agree. */
-const EXTERNAL_ESCAPE_REASON = 'has a consumer outside the analyzed .svelte graph';
+ * `.svelte` graph — a call site in a non-`.svelte` module the crawl cannot
+ * parse, or a user-declared `preserve` (docs §4.2, {@link AnalyzeInput.escaped}).
+ * Kept byte-identical to the Rust engine's constant so the two agree. */
+const MODULE_ESCAPE_REASON = 'has a consumer outside the analyzed .svelte graph';
 /**
- * Stamp {@link EXTERNAL_ESCAPE_REASON} on every model in `escaped` that exists in
+ * Stamp {@link MODULE_ESCAPE_REASON} on every model in `escaped` that exists in
  * the program — the single injection point both the whole-program shake and
  * {@link findNeverPassedProps} share (docs §4.2).  Ids not in the program are
- * ignored (a stale `preserve` entry or a scanned `.ts` import to a component
- * outside the crawl is simply a no-op, never an error).
+ * ignored (a stale `preserve` entry or a scanned import to a component outside
+ * the crawl is simply a no-op, never an error).
  */
-function stampExternalEscapes(models, escaped) {
+function stampModuleEscapes(models, escaped) {
     for (const id of escaped ?? []) {
         const model = models.get(id);
-        if (model && !model.bailReasons.includes(EXTERNAL_ESCAPE_REASON))
-            model.bailReasons.push(EXTERNAL_ESCAPE_REASON);
+        if (model && !model.bailReasons.includes(MODULE_ESCAPE_REASON))
+            model.bailReasons.push(MODULE_ESCAPE_REASON);
     }
 }
 /**
@@ -86,9 +86,10 @@ export function analyzeInput(input, parseCache) {
         if (model && !model.bailReasons.includes(ESCAPE_REASON))
             model.bailReasons.push(ESCAPE_REASON);
     }
-    // Components with consumers outside the `.svelte` graph (a `.ts`/`.js` call site
-    // or a user `preserve`, docs §4.2) join the same whole-component escape bail.
-    stampExternalEscapes(models, input.escaped);
+    // Components with consumers outside the `.svelte` graph (a call site in a
+    // non-`.svelte` module or a user `preserve`, docs §4.2) join the same
+    // whole-component escape bail.
+    stampModuleEscapes(models, input.escaped);
     return { models, plans: planFixpoint(models) };
 }
 /**
@@ -499,8 +500,9 @@ export function deadSpansForPlans(models, plans) {
  *    spread that could set it (`readCallSite` already folds `bind:`, known
  *    spreads, and `children`/snippet body into `explicit`/`hadSpread`);
  *  - a component in `input.escaped` — one the Shell knows has a consumer OUTSIDE
- *    the `.svelte` graph (a `.ts`/`.js` call site, or a user `preserve`, docs
- *    §4.2) — is skipped, because that consumer may pass a prop the crawl cannot see.
+ *    the `.svelte` graph (a call site in a non-`.svelte` module, or a user
+ *    `preserve`, docs §4.2) — is skipped, because that consumer may pass a prop
+ *    the crawl cannot see.
  *
  * Missing a `.svelte` EDGE (e.g. an unfollowed barrel) only DROPS call sites, so it
  * can only make this UNDER-report (the component looks unused and is skipped). The
@@ -521,9 +523,10 @@ export function findNeverPassedProps(input) {
         if (model && !model.bailReasons.includes(ESCAPE_REASON))
             model.bailReasons.push(ESCAPE_REASON);
     }
-    // External consumers (`.ts`/`.js` call sites or `preserve`) escape too, so a prop
-    // they pass is never mis-reported as never-passed (docs §4.2).
-    stampExternalEscapes(models, input.escaped);
+    // Consumers outside the `.svelte` graph (non-`.svelte` module call sites or
+    // `preserve`) escape too, so a prop they pass is never mis-reported as
+    // never-passed (docs §4.2).
+    stampModuleEscapes(models, input.escaped);
     // Every textual call site counts (no cascade dead-span filtering): a prop passed
     // only at a folded-away site is still author-written, so we do not flag it.
     const usage = buildUsage(models, new Map());
@@ -666,7 +669,7 @@ function buildModelFromInput(file, edges, parseCache) {
             }
         }
     }
-    const reachableInputs = computeReachableInputs(instance, props, hasRestProp, propsPattern);
+    const reachableInputs = computeReachableInputs(instance, props, hasRestProp, propsPattern, usesLegacySlotInputs(ast));
     const childCalls = collectChildCalls(ast, imports);
     const { shadowedNames, debugNames, writtenNames } = collectTemplateBindings(ast, instance, propsDeclaration);
     const unreadDeclaredProps = computeUnreadDeclaredProps(ast, instance, props, propsPattern, shadowedNames, debugNames, writtenNames);
@@ -1832,7 +1835,15 @@ function parseModuleBody(code, id) {
  * `$props.id()` (a member call) is NOT a `$props()` call — the props object never
  * leaks through it — so it does not count and does not affect the result.
  */
-function computeReachableInputs(instance, props, hasRestProp, propsPattern) {
+function computeReachableInputs(instance, props, hasRestProp, propsPattern, usesSlotInputs) {
+    // A legacy `<slot>` (or a bare `$$slots` read) observes slotted content —
+    // inputs that arrive OUTSIDE `$props()` (in Svelte 5 terms, the synthetic
+    // `children` input and named-slot / `let:` inputs a call site supplies as body
+    // content).  The `$props()` shape cannot model them, so the reverse pass must
+    // treat every input as observable, or it would delete the slot-carrying body at
+    // each call site.  This holds whether or not an instance script exists.
+    if (usesSlotInputs)
+        return { kind: 'all' };
     // No instance script -> no `$props()` -> the component reads no input at all.
     if (!instance)
         return { kind: 'names', names: new Set() };
@@ -1853,6 +1864,32 @@ function computeReachableInputs(instance, props, hasRestProp, propsPattern) {
         return { kind: 'all' };
     return { kind: 'names', names: new Set(props.map((p) => p.name)) };
 }
+/** True when the component observes slotted content outside `$props()`: a legacy
+ * `<slot>` element, or a read of the `$$slots` identifier (legal in runes mode,
+ * unlike `$$props`/`$$restProps`).  Either signal means {@link
+ * computeReachableInputs} cannot model the inputs and must fall back to ALL.
+ * `$$slots` can appear in the instance script OR a template expression
+ * (`{#if $$slots.default}`), so both trees are scanned; its `$$` prefix cannot be
+ * a user binding, so no shadowing check is needed. */
+function usesLegacySlotInputs(ast) {
+    return (nodeSignalsSlotInputs(ast.fragment) || (!!ast.instance && nodeSignalsSlotInputs(ast.instance)));
+}
+function nodeSignalsSlotInputs(root) {
+    let found = false;
+    walk(root, null, {
+        SlotElement(_node, { stop }) {
+            found = true;
+            stop();
+        },
+        Identifier(node, { stop }) {
+            if (node.name === '$$slots') {
+                found = true;
+                stop();
+            }
+        },
+    });
+    return found;
+}
 /** True when a `$props()` ObjectPattern binds a prop whose external name is not a
  * plain identifier (a string-literal or computed key), so {@link declared_props}
  * did not capture it. */

package/dist/engine.d.ts

@@ -53,7 +53,7 @@ export declare class DevShaker {
     /** Current slimmed output per `.svelte` id (the live shake result). */
     private output;
     constructor(files: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mode?: DevMode, parse?: Parse, escaped?: ComponentId[]);
-    /** Replace the external-escape set (docs §4.2).  The Shell calls this before
+    /** Replace the module-escape set (docs §4.2).  The Shell calls this before
      * {@link update} when a non-`.svelte` module changed the set of components
      * reached from `.ts`/`.js`, so the next shake bails them. */
     setEscaped(escaped: ComponentId[]): void;

package/dist/engine.js

@@ -38,7 +38,7 @@ export class DevShaker {
         this.parse = parse;
         this.escaped = escaped;
     }
-    /** Replace the external-escape set (docs §4.2).  The Shell calls this before
+    /** Replace the module-escape set (docs §4.2).  The Shell calls this before
      * {@link update} when a non-`.svelte` module changed the set of components
      * reached from `.ts`/`.js`, so the next shake bails them. */
     setEscaped(escaped) {

package/dist/escape-scan.js

@@ -115,7 +115,7 @@ function moduleImportSpecifiers(code, id) {
  * A module that cannot be read or parsed is collected into `unscannable` (NOT
  * silently dropped): a call site inside it is invisible, so the caller must warn.
  */
-async function collectExternalEscapes(modules, resolve, readFile) {
+async function collectModuleEscapes(modules, resolve, readFile) {
     const escaped = new Set();
     const unscannable = new Set();
     for (const id of modules) {
@@ -181,7 +181,7 @@ export function matchPreserve(preserve, root, components) {
  * `svelte-shaker/node`).
  */
 export async function computeEscapedComponents(opts) {
-    const { escaped, unscannable } = await collectExternalEscapes(opts.entryDirs.flatMap(collectNonSvelteModules), opts.resolve, opts.readFile);
+    const { escaped, unscannable } = await collectModuleEscapes(opts.entryDirs.flatMap(collectNonSvelteModules), opts.resolve, opts.readFile);
     const { matched, unmatched } = partitionPreserve(opts.preserve, opts.root, opts.components);
     for (const id of matched)
         escaped.add(id);

package/dist/ir.d.ts

@@ -43,8 +43,9 @@ export interface AnalyzeInput {
      * this set (its FS scan cannot parse `.ts` call sites); the engine unions it
      * into the same whole-component escape bail auto-detected escapes use, so these
      * components are never folded and never reported as never-passed — while their
-     * OWN call sites still count toward their children.  Omitted/`[]` means "no
-     * external consumers", keeping the output byte-for-byte unchanged.
+     * OWN call sites still count toward their children.  Omitted/`[]` means every
+     * consumer is inside the crawled `.svelte` graph, keeping the output
+     * byte-for-byte unchanged.
      */
     escaped?: ComponentId[];
 }

package/dist/unread.js

@@ -81,7 +81,8 @@ export function collectUnread(models, plans) {
     // (b): a prop is droppable when it survived every site's veto (and had the
     // structural gates).  A child with NO call sites keeps every `true` here — safe,
     // since the child does not read the prop, so its own render is unchanged whether
-    // it is declared or not (and external consumers, if any, bail the child).
+    // it is declared or not (and a consumer outside the `.svelte` graph, if any,
+    // bails the child).
     for (const [id, perProp] of dropEligible) {
         const set = new Set();
         for (const [name, ok] of perProp)

package/package.json

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