svelte-shaker 0.18.0 → 0.18.1

package/dist/crawl-dRCzCERA.d.ts

@@ -0,0 +1,43 @@
+import { d as ParseCache, n as ComponentId, t as AnalyzeInput, u as Parse } from "./ir-BDouNmBm.js";
+//#region src/crawl.d.ts
+type Resolve = (source: string, importer: ComponentId) => Promise<ComponentId | null> | ComponentId | null;
+type ReadFile = (id: ComponentId) => Promise<string> | string;
+interface ImportInfo {
+  value: string;
+  local: string;
+  /** `default` for a default import, the exported name for a named import, or
+   * `*` for a namespace import. */
+  imported: string;
+}
+/**
+ * The three per-file facts the crawl needs to resolve edges — import specifiers,
+ * rendered `<Local>` tag names, and `<ns.X>` member tag names. `null` when the file
+ * has no instance script (nothing to attribute), matching the crawl's skip.
+ */
+interface CrawlFacts {
+  imports: ImportInfo[];
+  renderedTags: Set<string>;
+  memberTags: Set<string>;
+}
+/**
+ * Source of {@link CrawlFacts} for one `(id, code)`. The default is a JS parse +
+ * extraction ({@link jsCrawlFacts}); the native engine passes a provider backed by
+ * `ShakeSession` facts, so the crawl resolves the SAME edges without the JS parse.
+ */
+type FactsProvider = (id: ComponentId, code: string) => CrawlFacts | null;
+/**
+ * The Shell-side resolution + IO layer (docs/RUST-MIGRATION.md §2.1): BFS-crawl
+ * the component graph from `entries`, resolving every import edge and reading
+ * every reachable `.svelte` file up front, into a batched {@link AnalyzeInput}.
+ *
+ * This is the half that STAYS in JS — it owns `this.resolve` / file IO for Vite
+ * ecosystem compat (docs ARCHITECTURE §5/§9) — so the engine ({@link
+ * analyzeInput}) consumes its output with no callback across the boundary.  The
+ * traversal mirrors the old crawl exactly: direct default-`.svelte` children and
+ * the barrel children a file actually RENDERS are followed (an unrendered barrel
+ * import is never crawled — its `<Comp/>` site cannot exist, so it cannot taint a
+ * value set), keeping the produced model set — and thus the output — identical.
+ */
+declare function buildAnalyzeInput(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[], factsProvider?: FactsProvider): Promise<AnalyzeInput>;
+//#endregion
+export { Resolve as n, buildAnalyzeInput as r, ReadFile as t };

package/dist/{dev-only.d.ts → dev-only-vMKGdavE.d.ts}

@@ -1,4 +1,5 @@
-import type { ComponentId } from './ir.js';
+import { n as ComponentId } from "./ir-BDouNmBm.js";
+//#region src/dev-only.d.ts
 /**
  * Files treated as DEV-ONLY by default: colocated tests, mocks, and Storybook
  * stories — files that never ship, so their call sites must not count toward the
@@ -7,9 +8,9 @@ import type { ComponentId } from './ir.js';
  * not for narrowing app coverage, and the shipped-file-matching failure mode).
  * Passing `devOnly` REPLACES this list; `devOnly: []` counts every file.
  */
-export declare const DEFAULT_DEV_ONLY: readonly string[];
+declare const DEFAULT_DEV_ONLY: readonly string[];
 /** Predicate over an ABSOLUTE path: `true` when the file is dev-only (discounted by a scan). */
-export type DevOnlyFilter = (file: ComponentId) => boolean;
+type DevOnlyFilter = (file: ComponentId) => boolean;
 /**
  * Compile dev-only `patterns` into a {@link DevOnlyFilter}.  Each candidate path is
  * matched (with `picomatch`) as its `base`-relative, posix-normalized form, so the
@@ -20,4 +21,6 @@ export type DevOnlyFilter = (file: ComponentId) => boolean;
  * Defaults to {@link DEFAULT_DEV_ONLY}; an empty `patterns` array matches nothing, so
  * `devOnly: []` counts every file (the pre-`devOnly` behavior).
  */
-export declare function compileDevOnly(base: string, patterns?: readonly string[]): DevOnlyFilter;
+declare function compileDevOnly(base: string, patterns?: readonly string[]): DevOnlyFilter;
+//#endregion
+export { DevOnlyFilter as n, compileDevOnly as r, DEFAULT_DEV_ONLY as t };

package/dist/index.d.ts

@@ -1,13 +1,163 @@
-import { type ReadFile, type Resolve } from './crawl.js';
-import { type Parse } from './parse.js';
-import { type MonomorphizeOptions, type MonomorphizeResult, type OwnSize } from './mono.js';
-import type { ComponentId } from './ir.js';
-export type { ComponentId, AnalyzeInput, InputFile, ResolvedEdge, EdgeKind, EditResult, } from './ir.js';
-export type { Resolve, ReadFile } from './crawl.js';
-export type { Parse, Root } from './parse.js';
-export { analyze } from './analyze.js';
-export { buildAnalyzeInput } from './crawl.js';
-export { DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type OwnSize } from './mono.js';
+import { a as EditResult, c as ResolvedEdge, f as Root, i as EdgeKind, l as AnyNode, n as ComponentId, o as InputFile, r as ComponentPlan, s as Literal, t as AnalyzeInput, u as Parse } from "./ir-BDouNmBm.js";
+import { n as Resolve, r as buildAnalyzeInput, t as ReadFile } from "./crawl-dRCzCERA.js";
+import { i as OwnSize, n as MonomorphizeOptions, r as MonomorphizeResult, t as DEFAULT_MONO_OPTIONS } from "./mono-gDUeXt7W.js";
+//#region src/model.d.ts
+/**
+ * The set of input names a child component can ever OBSERVE at runtime (reverse
+ * analysis).  In runes there is no `$$props`/`$$restProps`, so a
+ * component reads an input only through its `$props()` destructure:
+ *  - `{ kind: 'names' }` — a clean, rest-free ObjectPattern `$props()` (or no
+ *    `$props()` at all, giving the empty set): the child can observe EXACTLY
+ *    these declared external names, so a call-site input NOT in the set can
+ *    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, `$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.
+ */
+type ReachableInputs = {
+  kind: "all";
+} | {
+  kind: "names";
+  names: Set<string>;
+};
+/** One declared prop in a `$props()` destructuring. */
+interface PropDecl {
+  /** The EXTERNAL prop name — the destructure KEY (`prop` in `prop: alias`).
+   * Call sites pass this name, so value sets / dropping key off it. */
+  name: string;
+  /**
+   * The LOCAL binding name the entry introduces in the body — the destructure
+   * VALUE (`alias` in `prop: alias`, or the bare name for a shorthand `prop`),
+   * or `null` when the entry binds a NESTED pattern (`prop: { x }`) rather than a
+   * single identifier.  Body and template references use THIS name, not {@link
+   * name}, so folding/substitution must look props up by it (`prop` and its alias
+   * `alias` can even be different entities — e.g. a same-named import).  A `null`
+   * local is never foldable: there is no single identifier to substitute or drop.
+   */
+  local: string | null;
+  /** The `Property` node inside the `ObjectPattern` (for surgical removal). */
+  property: AnyNode;
+  /** Default value expression, if `name = <default>`. */
+  defaultExpr?: AnyNode | undefined;
+}
+/** Everything we learn from parsing one component, reused by the transform. */
+interface FileModel {
+  id: ComponentId;
+  code: string;
+  ast: Root;
+  /**
+   * Tag name a call site renders -> resolved child component id.  Holds every
+   * attributable edge into this file: a bare local for a direct `.svelte`
+   * default or a simple barrel/named import (`Sub`), and a dotted member for a
+   * namespace render (`ns.Sub`).  {@link collectChildCalls} keys `<Tag .../>`
+   * sites off this map, so every kind feeds the child's value set.
+   */
+  imports: Map<string, ComponentId>;
+  /** Declared props, or `null` if the component has no `$props()` pattern. */
+  props: PropDecl[] | null;
+  /** The `let { ... } = $props()` declaration + its pattern, for editing. */
+  propsDeclaration?: AnyNode | undefined;
+  propsPattern?: AnyNode | undefined;
+  hasRestProp: boolean;
+  /**
+   * The inputs this component can observe.  Drives the reverse pass:
+   * a call site of THIS component may drop an input outside {@link
+   * ReachableInputs}.  Computed syntactically from the `$props()` shape.
+   */
+  reachableInputs: ReachableInputs;
+  /**
+   * EXTERNAL names of props this component DECLARES but never READS (unread
+   * declared props): destructured out of a clean `$props()` yet with zero
+   * value-position reference to their local binding anywhere in the instance
+   * script or template.  Such a
+   * prop is invisible to the child, so its call-site attribute is dead and — when
+   * safe — the declaration can be dropped.  Source-only (independent of the call
+   * sites), so it is computed ONCE here, never inside the fixpoint; the transform
+   * gates its use on the component's plan not being bailed.
+   */
+  unreadDeclaredProps: Set<string>;
+  /**
+   * Every `<Child .../>` instance THIS component renders, with the child it
+   * resolves to and the AST node (so the fixpoint can test whether the site
+   * falls inside a dead `{#if}` span of this component — docs §2.1).
+   */
+  childCalls: ChildCall[];
+  /**
+   * Names this component binds OUTSIDE the `$props()` pattern — local `let` /
+   * `function` declarations in the instance script, and every template-scope
+   * binder (`{#each … as ctx, i}`, destructure patterns, `{#snippet name(p)}`,
+   * `{#await … then v}` / `{:catch e}`, `let:` directives).  A declared prop
+   * whose name collides with any of these is a DIFFERENT entity inside that
+   * scope, so folding/substituting/dropping it would corrupt the binding (and
+   * often produce invalid Svelte).  We therefore never fold such a prop.
+   */
+  shadowedNames: Set<string>;
+  /**
+   * Names that appear as a `{@debug …}` argument.  Svelte requires those to be
+   * bare identifiers, so substituting a folded literal there is invalid and
+   * dropping the prop dangles the reference — we never fold a prop named here.
+   */
+  debugNames: Set<string>;
+  /**
+   * Names the component WRITES TO — reassigns (`p = …`, `p += …`), mutates with
+   * `++`/`--`, destructure-assigns (`({ p } = obj)`), or two-way `bind:`s.  A
+   * written prop is not a constant even when every call site passes the same
+   * literal: the write changes it at runtime, so folding it would substitute the
+   * literal into the write's target (`"a" = …`, `0++`, `bind:value={"a"}`) —
+   * invalid Svelte — and, more importantly, silently change what renders after
+   * the write.  We never fold such a prop, exactly like a shadowed one.
+   */
+  writtenNames: Set<string>;
+  /**
+   * Owner-local bindings that are provably a single primitive CONSTANT, keyed by
+   * the LOCAL name a forwarded call-site expression references (docs §13.1
+   * interprocedural pass-through).  Merged into the owner's fold env so that
+   * `<Child {count}/>` — where `count` is an unmutated `let count = $state(0)` or
+   * a `const count = 0` — folds in the child exactly as a call-site literal would,
+   * feeding BOTH constant fold and value-set narrowing.  A static property of the
+   * source (independent of the fixpoint's plans), so it is computed ONCE here.
+   * See {@link computeScriptConstEnv} for the (conservative) admission rules.
+   */
+  scriptConstEnv: ReadonlyMap<string, Literal>;
+  /**
+   * Resolved ids of CHILD components this file leaks as a value (escape, docs
+   * §4.1) — e.g. `<svelte:component this={Child}>`.  `analyze` unions these
+   * across the program and bails every escaped component completely, since its
+   * prop profile can no longer be observed from `<Child .../>` sites alone.
+   */
+  escapedComponents: Set<ComponentId>;
+  /** Reasons this whole component must be left untouched. */
+  bailReasons: string[];
+}
+/** One `<Child .../>` instance rendered by a component. */
+interface ChildCall {
+  childId: ComponentId;
+  node: AnyNode;
+}
+//#endregion
+//#region src/analyze.d.ts
+interface AnalyzeResult {
+  models: Map<ComponentId, FileModel>;
+  plans: Map<ComponentId, ComponentPlan>;
+}
+/**
+ * Crawl the component graph from `entries` and compute a plan per component,
+ * iterating to a whole-program fixpoint (docs §2.1).
+ *
+ * The crucial cascade: a `<Child/>` that lives inside a branch we fold away must
+ * NOT count toward the child's prop profile.  Excluding it can shrink the
+ * child's value sets and enable more folding, which can fold away yet more
+ * branches.  So we parse every component once, then alternate between
+ *   (a) collecting call sites that are NOT inside a current dead span, and
+ *   (b) recomputing plans (and hence dead spans) from that usage,
+ * until the plans stop changing.
+ */
+declare function analyze(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, escaped?: ComponentId[]): Promise<AnalyzeResult>;
+//#endregion
+//#region src/index.d.ts
 /**
  * Whole-program shake: crawl the component graph from `entry`, decide what to
  * fold, and return the shaken source for every reachable `.svelte` file.
@@ -18,21 +168,21 @@ export { DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type OwnSize } from './
  * Node callers use `fsResolve` / `fs.readFileSync` from `svelte-shaker/node`.
  * See docs/ARCHITECTURE.md §5 — this is the Engine; the Shell owns resolution.
  */
-export declare function svelteShaker(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parse?: Parse, escaped?: ComponentId[]): Promise<Record<ComponentId, string>>;
+declare function svelteShaker(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parse?: Parse, escaped?: ComponentId[]): Promise<Record<ComponentId, string>>;
 /** The full output of a shake including monomorphization specialization. */
-export interface ShakeResult {
-    /**
-     * Whole-program output: shaken source per `.svelte` file.  With monomorphization OFF this is
-     * byte-for-byte identical to {@link svelteShaker}; with monomorphization ON, owner files
-     * whose call sites were specialized have those sites rewritten to import a
-     * variant via `variantSpecifier(variantId)`.
-     */
-    files: Record<ComponentId, string>;
-    /** monomorphization specialized variants + call-site bindings (empty when monomorphization is off). */
-    mono: MonomorphizeResult;
+interface ShakeResult {
+  /**
+   * Whole-program output: shaken source per `.svelte` file.  With monomorphization OFF this is
+   * byte-for-byte identical to {@link svelteShaker}; with monomorphization ON, owner files
+   * whose call sites were specialized have those sites rewritten to import a
+   * variant via `variantSpecifier(variantId)`.
+   */
+  files: Record<ComponentId, string>;
+  /** monomorphization specialized variants + call-site bindings (empty when monomorphization is off). */
+  mono: MonomorphizeResult;
 }
 /** Build the module specifier a rewritten call site imports a variant from. */
-export type VariantSpecifier = (variantId: string) => string;
+type VariantSpecifier = (variantId: string) => string;
 /**
  * Whole-program shake WITH optional monomorphization (docs §3 "monomorphization").
  *
@@ -43,4 +193,6 @@ export type VariantSpecifier = (variantId: string) => string;
  * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
  * superset of the default behavior, so existing consumers are unaffected.
  */
-export declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[], ownSize?: OwnSize): Promise<ShakeResult>;
+declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[], ownSize?: OwnSize): Promise<ShakeResult>;
+//#endregion
+export { type AnalyzeInput, type ComponentId, DEFAULT_MONO_OPTIONS, type EdgeKind, type EditResult, type InputFile, type MonomorphizeOptions, type OwnSize, type Parse, type ReadFile, type Resolve, type ResolvedEdge, type Root, ShakeResult, VariantSpecifier, analyze, buildAnalyzeInput, svelteShaker, svelteShakerWithMono };

package/dist/index.js

@@ -1,75 +1 @@
-import { analyze, analyzeInput } from './analyze.js';
-import { buildAnalyzeInput } from './crawl.js';
-import {} from './parse.js';
-import { transformAll } from './transform.js';
-import { transformAllWithMono } from './mono-rewrite.js';
-import { monomorphize, DEFAULT_MONO_OPTIONS, } from './mono.js';
-import { shakeWithRevertCascade } from './revert-cascade.js';
-export { analyze } from './analyze.js';
-export { buildAnalyzeInput } from './crawl.js';
-export { DEFAULT_MONO_OPTIONS } from './mono.js';
-/**
- * Whole-program shake: crawl the component graph from `entry`, decide what to
- * fold, and return the shaken source for every reachable `.svelte` file.
- *
- * `resolve` / `readFile` are injected so the engine stays environment-free —
- * it has NO `node:*` imports, so it runs unchanged in the browser (the
- * playground passes an in-memory file map). A Vite plugin passes `this.resolve`;
- * Node callers use `fsResolve` / `fs.readFileSync` from `svelte-shaker/node`.
- * See docs/ARCHITECTURE.md §5 — this is the Engine; the Shell owns resolution.
- */
-export async function svelteShaker(entries, resolve, readFile, parse, escaped = []) {
-    const { models, plans } = await analyzeWith(entries, resolve, readFile, parse, escaped);
-    return shakeWithRevertCascade(models, plans, (p) => transformAll(models, p));
-}
-/**
- * Crawl + analyze with an optional non-default parser ({@link Parse}).  When
- * `parse` is given (the Vite plugin's `parser: 'rsvelte'` path), each file is
- * parsed ONCE into a shared cache during the crawl and that cache is reused by the
- * analysis — so the alternate parser drives the whole engine with no second parse.
- * When omitted, this is exactly `analyze(entries, resolve, readFile)` (the default
- * svelte/compiler path, byte-for-byte unchanged).
- */
-async function analyzeWith(entries, resolve, readFile, parse, escaped = []) {
-    if (!parse)
-        return analyze(entries, resolve, readFile, escaped);
-    const cache = new Map();
-    const input = await buildAnalyzeInput(entries, resolve, readFile, cache, parse, escaped);
-    return analyzeInput(input, cache);
-}
-/**
- * Whole-program shake WITH optional monomorphization (docs §3 "monomorphization").
- *
- * `mono` carries the specialized variants (id -> residual source) and the call
- * sites bound to them; `files` is the wired owner source.  The Shell resolves
- * `variantSpecifier(id)` to a virtual module whose source is
- * `mono.variants.get(id)!.code`.  With `mono.enabled` false (default) nothing is
- * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
- * superset of the default behavior, so existing consumers are unaffected.
- */
-export async function svelteShakerWithMono(entries, resolve, readFile, mono = DEFAULT_MONO_OPTIONS, variantSpecifier = (id) => id, parse, escaped = [], ownSize) {
-    const { models, plans } = await analyzeWith(entries, resolve, readFile, parse, escaped);
-    // The cascade may re-run the transform with force-bailed plans, so recompute
-    // monomorphization inside it: a bailed component must not be specialized either.
-    // `lastResult` captures the mono result of the final (converged or no-op) pass.
-    // On the no-op fallback the emitted owner files are the untouched originals —
-    // they import no variant — so any variants `lastResult` still lists are simply
-    // never requested.
-    let lastResult;
-    const files = shakeWithRevertCascade(models, plans, (p) => {
-        // Thread the shake entries through so the net-win gate can compute module
-        // reachability from them (docs §3 monomorphization, §13.2).
-        lastResult = monomorphize(models, p, mono, entries, ownSize);
-        // With no bindings the wired pass and the base pass are identical, so reuse
-        // the plain transform to keep the default path byte-for-byte unchanged.
-        return lastResult.bindings.length === 0
-            ? transformAll(models, p)
-            : transformAllWithMono(models, p, lastResult.bindings.map((b) => ({
-                owner: b.owner,
-                node: b.node,
-                variantId: b.variantId,
-                foldedProps: b.foldedProps,
-            })), variantSpecifier);
-    });
-    return { files, mono: lastResult };
-}
+import{c as e,i as t,n,o as r,t as i}from"./src-5VY_edrh.js";export{t as DEFAULT_MONO_OPTIONS,r as analyze,e as buildAnalyzeInput,i as svelteShaker,n as svelteShakerWithMono};

package/dist/ir-BDouNmBm.d.ts

@@ -0,0 +1,225 @@
+//#region src/parse.d.ts
+/**
+ * A deliberately loose view of the Svelte + ESTree AST: only the fields this
+ * engine reads, each optional.  Avoiding an index signature keeps named access
+ * compatible with `noPropertyAccessFromIndexSignature` while still letting us
+ * walk an untyped tree.  `value` is `unknown` because it means different things
+ * on `Literal` (a literal) vs `Attribute` (true | node | node[]).
+ */
+interface AnyNode {
+  type: string;
+  start: number;
+  end: number;
+  test?: AnyNode | undefined;
+  consequent?: AnyNode | undefined;
+  alternate?: AnyNode | null | undefined;
+  expression?: AnyNode | undefined;
+  argument?: AnyNode | undefined;
+  left?: AnyNode | undefined;
+  right?: AnyNode | undefined;
+  callee?: AnyNode | undefined;
+  id?: AnyNode | undefined;
+  init?: AnyNode | undefined;
+  key?: AnyNode | undefined;
+  property?: AnyNode | undefined;
+  /** MemberExpression object (`$state` in `$state.raw`). */
+  object?: AnyNode | undefined;
+  source?: AnyNode | undefined;
+  local?: AnyNode | undefined;
+  /** ImportSpecifier / ExportSpecifier exported-name slot. */
+  imported?: AnyNode | undefined;
+  exported?: AnyNode | undefined;
+  typeAnnotation?: AnyNode | undefined;
+  content?: AnyNode | undefined;
+  fragment?: AnyNode | null | undefined;
+  instance?: AnyNode | null | undefined;
+  module?: AnyNode | null | undefined;
+  css?: AnyNode | null | undefined;
+  context?: AnyNode | undefined;
+  error?: AnyNode | null | undefined;
+  then?: AnyNode | null | undefined;
+  catch?: AnyNode | null | undefined;
+  declaration?: AnyNode | undefined;
+  prelude?: AnyNode | undefined;
+  block?: AnyNode | null | undefined;
+  combinator?: AnyNode | null | undefined;
+  args?: AnyNode | null | undefined;
+  attributes?: AnyNode[] | undefined;
+  properties?: AnyNode[] | undefined;
+  members?: AnyNode[] | undefined;
+  body?: AnyNode[] | undefined;
+  declarations?: AnyNode[] | undefined;
+  /** CallExpression / NewExpression arguments (`0` in `$state(0)`). */
+  arguments?: (AnyNode | null)[] | undefined;
+  specifiers?: AnyNode[] | undefined;
+  nodes?: AnyNode[] | undefined;
+  /** SnippetBlock parameters; ArrayPattern elements; DebugTag identifiers. */
+  parameters?: AnyNode[] | undefined;
+  /** Function / arrow ESTree parameters (`function f(a, b)`, `(a) => …`). */
+  params?: AnyNode[] | undefined;
+  elements?: (AnyNode | null)[] | undefined;
+  identifiers?: AnyNode[] | undefined;
+  /** CSS StyleSheet/SelectorList/ComplexSelector children, Block children. */
+  children?: AnyNode[] | undefined;
+  /** RelativeSelector simple selectors (ClassSelector, TypeSelector, …). */
+  selectors?: AnyNode[] | undefined;
+  name?: string | undefined;
+  /** EachBlock loop index variable name (a bare string, e.g. `i`). */
+  index?: string | undefined;
+  operator?: string | undefined;
+  raw?: string | undefined;
+  data?: string | undefined;
+  computed?: boolean | undefined;
+  shorthand?: boolean | undefined;
+  elseif?: boolean | undefined;
+  /** ObjectExpression `Property` accessor kind (`init` / `get` / `set`). */
+  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;
+}
+interface Root extends AnyNode {
+  fragment: AnyNode;
+}
+/**
+ * Content-keyed parse cache: a hit returns the IDENTICAL AST for unchanged
+ * source, so the dev engine re-parses only the files that actually changed
+ * (docs/RUST-MIGRATION.md §2.2 — `parse(id)` is the cached input query, the
+ * dominant cost an edit avoids).  Keyed by content, so a stale entry can never
+ * return an AST whose byte offsets disagree with the source: a code mismatch
+ * forces a re-parse.
+ */
+type ParseCache = Map<string, {
+  code: string;
+  ast: Root;
+}>;
+/**
+ * A `.svelte` -> modern-AST parser, swappable for the default {@link parseSvelte}
+ * (svelte/compiler).  The engine reads only the AST it returns, so any parser that
+ * emits svelte/compiler's modern shape (UTF-16 `start`/`end`) can drive it — the
+ * Vite plugin's `parser: 'rsvelte'` option supplies rsvelte's parser (the
+ * `@rsvelte/compiler` WASM build) here (docs/RUST-MIGRATION.md §6).
+ */
+type Parse = (code: string, filename: string) => Root;
+//#endregion
+//#region src/ir.d.ts
+/** Resolved absolute path of a `.svelte` file. */
+type ComponentId = string;
+/** A statically-known literal value a prop can take. */
+type Literal = string | number | boolean | null | undefined;
+/**
+ * How an imported local name binds to a child `.svelte` component.  All three
+ * kinds are attributable — the `local` they carry is the exact tag name a call
+ * site renders (`Child` for the first two, the dotted `ns.Child` for the third),
+ * so {@link AnalyzeInput} drives the child's value set off every one of them.
+ */
+type EdgeKind = "default-svelte" | "barrel" | "namespace";
+/** One reachable `.svelte` source the engine will model. */
+interface InputFile {
+  id: ComponentId;
+  code: string;
+}
+/**
+ * One resolved import edge: in `from`, the tag name `local` renders the child
+ * `.svelte` `to`.  `local` is the literal tag a call site uses — a bare name for
+ * `default-svelte`/`barrel` (`<Child/>`) or a dotted member for `namespace`
+ * (`<ns.Child/>`) — so the engine attributes `<local .../>` sites by name lookup.
+ */
+interface ResolvedEdge {
+  from: ComponentId;
+  local: string;
+  to: ComponentId;
+  kind: EdgeKind;
+}
+/**
+ * The fully-resolved, batched input to the engine (docs §2.1).  `files` is every
+ * reachable `.svelte` (barrel `.js`/`.ts` are consumed during resolution and do
+ * not appear here); `edges` are already resolved to absolute ids; `entries` is
+ * the call-site-completeness set (the Shell's FS scan) and the monomorphization net-win roots.
+ */
+interface AnalyzeInput {
+  files: InputFile[];
+  edges: ResolvedEdge[];
+  entries: ComponentId[];
+  /**
+   * Components with at least one consumer OUTSIDE the analyzed `.svelte` graph —
+   * a call site in a `.ts`/`.js` module (`mount(Comp, …)`, a lazy `import()`), or
+   * a user-declared `preserve` (docs/ARCHITECTURE.md §4.2).  The Shell computes
+   * 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 every
+   * consumer is inside the crawled `.svelte` graph, keeping the output
+   * byte-for-byte unchanged.
+   */
+  escaped?: ComponentId[];
+}
+/**
+ * The delta the dev engine returns after applying file changes (docs §2.1, the
+ * `vite dev` incremental path).  `changed` maps each component whose SLIMMED
+ * OUTPUT changed to its new source — a SUPERSET of the edited files, because a
+ * call-site edit can change a child's residual without the child being touched
+ * (the HMR module-graph divergence the Shell must widen for).  `removed` lists
+ * components no longer in the program (deleted or now unreachable).
+ */
+interface EditResult {
+  changed: Record<ComponentId, string>;
+  removed: ComponentId[];
+}
+/**
+ * The set of literal values one declared prop is seen to take across the whole
+ * program (default included for sites that omit it), plus the two ways it can
+ * escape the lattice.  This is the value-set foundation later levels narrow on
+ * (docs §2.2 `multi`, §3 value-set narrowing): `constFold` is just the `size === 1 && !dynamic
+ * && !top` projection of it.  Kept on the plan as groundwork — no level yet
+ * consumes the multi-element / `dynamic` cases.
+ */
+interface PropValueSet {
+  /** Distinct literals observed (dedup'd; `undefined`/`null` are distinct). */
+  values: Literal[];
+  /** A non-literal value was passed somewhere (used, value not statically known). */
+  dynamic: boolean;
+  /**
+   * ⊤: a call-site spread may set this prop (docs §4.1 partial bail), so the
+   * value set is really "all values" and the prop must not be folded.
+   */
+  top: boolean;
+}
+/** What the analysis decides to do to one component. */
+interface ComponentPlan {
+  id: ComponentId;
+  /** Whole-component bail (accessors / customElement / escape). */
+  bail: boolean;
+  reasons: string[];
+  /**
+   * unused-prop fold / constant fold: props that collapse to a single constant.  Under the "攻め"
+   * default (docs §12-2) these are folded in the body, dropped from the
+   * `$props()` signature, and their attributes are removed at every call site.
+   */
+  constFold: Map<string, Literal>;
+  /**
+   * value-set narrowing (docs §3): props whose reachable value set is a
+   * known set of >= 2 distinct literals (no `dynamic`/`top` contribution).  We
+   * delete branches the prop can provably never reach (e.g. a `variant ===
+   * 'danger'` arm when `variant ∈ {'primary','secondary'}`), but — unlike
+   * `constFold` — the prop is still genuinely used/dynamic, so it is NOT
+   * substituted and NOT dropped from the `$props()` signature.  Singletons stay
+   * in `constFold`; these two maps are disjoint.
+   */
+  narrow: Map<string, Literal[]>;
+  /**
+   * Per-declared-prop value-set foundation (see {@link PropValueSet}).  Present
+   * for every declared prop the analysis reasoned about; `constFold` is its
+   * singleton projection and `narrow` is its multi-element projection.
+   */
+  valueSets: Map<string, PropValueSet>;
+}
+//#endregion
+export { EditResult as a, ResolvedEdge as c, ParseCache as d, Root as f, EdgeKind as i, AnyNode as l, ComponentId as n, InputFile as o, ComponentPlan as r, Literal as s, AnalyzeInput as t, Parse as u };