svelte-docinfo 0.4.1 → 0.5.0

package/dist/postprocess.js

@@ -32,9 +32,56 @@ const posixifyArray = (arr) => {
     }
     return changed ?? arr;
 };
+/**
+ * Build the `(module, name)` → declaration lookup used for `aliasOf`-chain
+ * walking. Key format: `` `${modulePath}\n${name}` `` — `\n` can't appear in
+ * either part.
+ */
+const buildDeclarationIndex = (modules) => {
+    const byIdentity = new Map();
+    for (const mod of modules) {
+        for (const declaration of mod.declarations) {
+            byIdentity.set(`${mod.path}\n${declaration.name}`, declaration);
+        }
+    }
+    return byIdentity;
+};
+/**
+ * Resolve a declaration to its canonical identity. A same-name re-export of
+ * an intermediate rename produces an alias pointing at another alias, so a
+ * single hop isn't enough — follow the chain through declarations present in
+ * the index. The terminal is the declaration *object* when it's in the set
+ * (object identity keeps two same-`(module, name)` declarations distinct in
+ * pathological inputs), else the dangling `(module, name)` key (two aliases
+ * of the same absent canonical still resolve to one identity). The visited
+ * set guards malformed cyclic input.
+ */
+const resolveCanonicalIdentity = (byIdentity, modulePath, declaration) => {
+    let current = declaration;
+    const visited = new Set([`${modulePath}\n${declaration.name}`]);
+    while (current.aliasOf) {
+        const nextKey = `${current.aliasOf.module}\n${current.aliasOf.name}`;
+        if (visited.has(nextKey))
+            return nextKey;
+        visited.add(nextKey);
+        const next = byIdentity.get(nextKey);
+        if (!next)
+            return nextKey;
+        current = next;
+    }
+    return current;
+};
 /**
  * Find duplicate declaration names across modules.
  *
+ * A duplicate is two *different things* sharing a name in the flat namespace.
+ * Occurrences are compared by canonical identity — `aliasOf` chains are
+ * resolved first, so an alias and its canonical (or two aliases of the same
+ * canonical) are one thing, not a collision. Documenting a same-name re-export
+ * (which synthesizes an alias) or re-exporting a component under its own name
+ * (`export {default as Foo} from './Foo.svelte'`) therefore doesn't flag.
+ * When a name does flag, all occurrences are reported, aliases included.
+ *
  * Callers can decide how to handle duplicates (throw, warn, ignore).
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
@@ -54,10 +101,13 @@ const posixifyArray = (arr) => {
  * ```
  */
 export const findDuplicates = (modules) => {
+    const byIdentity = buildDeclarationIndex(modules);
+    const resolveCanonical = (modulePath, declaration) => resolveCanonicalIdentity(byIdentity, modulePath, declaration);
+    // Collect declaration names with their canonical identities. The default
+    // slot is module-scoped per the JS spec — every module can have its own
+    // `'default'` and they don't collide — so skip `name === 'default'`
+    // entries from this flat-namespace check.
     const allOccurrences = new Map();
-    // Collect declaration names. The default slot is module-scoped per the JS
-    // spec — every module can have its own `'default'` and they don't collide
-    // — so skip `name === 'default'` entries from this flat-namespace check.
     for (const mod of modules) {
         for (const declaration of mod.declarations) {
             if (declaration.name === 'default')
@@ -68,74 +118,90 @@ export const findDuplicates = (modules) => {
             allOccurrences.get(declaration.name).push({
                 declaration,
                 module: mod.path,
+                canonical: resolveCanonical(mod.path, declaration),
             });
         }
     }
-    // Filter to only duplicates
+    // A name is duplicated only when its occurrences span >1 canonical identity
     const duplicates = new Map();
     for (const [name, occurrences] of allOccurrences) {
-        if (occurrences.length > 1) {
-            duplicates.set(name, occurrences);
+        const identities = new Set(occurrences.map((o) => o.canonical));
+        if (identities.size > 1) {
+            duplicates.set(name, occurrences.map(({ declaration, module }) => ({ declaration, module })));
         }
     }
     return duplicates;
 };
+/**
+ * Code-unit string comparator for deterministic output ordering.
+ *
+ * Unlike `localeCompare` (host-locale/ICU-dependent, so byte-identical input
+ * can serialize in different orders on different machines), code-unit order is
+ * environment-independent — and it matches the default `Array.prototype.sort`
+ * used for `alsoExportedFrom`, `dependencies`, and `dependents`.
+ */
+export const compareStrings = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 /**
  * Sort modules alphabetically by path for deterministic output and cleaner diffs.
  *
+ * Code-unit order (`compareStrings`) so the output is environment-independent.
+ *
  * @param modules - the modules to sort
  * @returns a new sorted array (does not mutate input)
  */
 export const sortModules = (modules) => {
-    return modules.slice().sort((a, b) => a.path.localeCompare(b.path));
+    return modules.slice().sort((a, b) => compareStrings(a.path, b.path));
 };
 /**
- * Build `alsoExportedFrom` arrays from collected re-export data.
- *
- * This function resolves the two-phase re-export problem:
- *
- * **Problem**: When module A re-exports from module B, we discover this while
- * analyzing A, but need to update B's declarations. However, B may already be
- * processed or may be processed later.
+ * Build `alsoExportedFrom` arrays from the modules' forward re-export edges.
  *
- * **Solution**: Collect all re-exports in phase 1, then merge them in phase 2
- * after all modules are analyzed.
+ * Each module carries its same-name re-export edges as `ModuleJson.reExports`
+ * (collected in phase 1); this phase-2 pass inverts them onto the canonical
+ * declarations so both directions of the same fact are queryable. Edges whose
+ * canonical module or declaration is absent from `modules` are skipped — the
+ * forward entry remains without a back-link (see `ReExportJson` for the
+ * presence caveats).
  *
  * Component-only fields on renamed component aliases (`props`,
  * `acceptsChildren`, etc.) are populated separately by `resolveComponentAliases`
  * — call it after this function. They split because they touch disjoint fields
  * and have different inputs.
  *
- * @param modules - the modules array with all modules (will be mutated)
- * @param collectedReExports - array of re-exports collected during phase 1
- * @mutates modules - unions new re-exporters into `declaration.alsoExportedFrom`
+ * @param modules - the modules array with all modules (will be mutated).
+ *   Must be parsed `ModuleJson`s — wire JSON strips empty arrays, so run
+ *   raw JSON through `AnalyzeResultJson.parse` first or `reExports` may be
+ *   `undefined`
+ * @mutates modules - unions re-exporters into `declaration.alsoExportedFrom`
  *   (deduped + sorted), so a second call with the same inputs is a no-op
  *
  * @example
  * ```ts
  * // helpers.ts exports: foo, bar
- * // index.ts does: export {foo, bar} from './files.js'
+ * // index.ts does: export {foo, bar} from './helpers.js'
+ * // (so index.ts's ModuleJson carries reExports:
+ * //   [{name: 'foo', module: 'helpers.ts'}, {name: 'bar', module: 'helpers.ts'}])
  * //
  * // After processing:
  * // - helpers.ts foo declaration gets: alsoExportedFrom: ['index.ts']
  * // - helpers.ts bar declaration gets: alsoExportedFrom: ['index.ts']
  * ```
  */
-export const mergeReExports = (modules, collectedReExports) => {
-    // Group re-exports by `(originalModule, name)`. The default slot keys as
+export const mergeReExports = (modules) => {
+    // Group edges by `(canonical module, name)`. The default slot keys as
     // `'default'` like any other name — each module owns its own default slot,
     // so the per-module map prevents cross-module collisions naturally.
     const reExportMap = new Map();
-    for (const { reExportingModule, reExport } of collectedReExports) {
-        const { name, originalModule } = reExport;
-        if (!reExportMap.has(originalModule)) {
-            reExportMap.set(originalModule, new Map());
-        }
-        const moduleMap = reExportMap.get(originalModule);
-        if (!moduleMap.has(name)) {
-            moduleMap.set(name, []);
+    for (const mod of modules) {
+        for (const { name, module: originalModule } of mod.reExports) {
+            if (!reExportMap.has(originalModule)) {
+                reExportMap.set(originalModule, new Map());
+            }
+            const moduleMap = reExportMap.get(originalModule);
+            if (!moduleMap.has(name)) {
+                moduleMap.set(name, []);
+            }
+            moduleMap.get(name).push(mod.path);
         }
-        moduleMap.get(name).push(reExportingModule);
     }
     // Merge into original declarations
     for (const mod of modules) {
@@ -303,3 +369,185 @@ export const computeDependents = (files) => {
         };
     });
 };
+/**
+ * Resolve a module's full export surface from the analyzed model, applying
+ * ES module semantics to star exports.
+ *
+ * Combines the module's own `declarations` (including synthesized aliases),
+ * `reExports` edges, `externalReExports`, and transitively-resolved
+ * `starExports` into one deduped, name-sorted list. The ES rules applied to
+ * star projection:
+ *
+ * - explicit exports (declarations, edges, externals) shadow star-projected
+ *   names
+ * - a name projected by two stars that resolve to *different* canonicals is
+ *   ambiguous and excluded (same canonical through a diamond is included
+ *   once)
+ * - `default` is never star-projected — including canonical Svelte component
+ *   declarations, which represent their file's default export. (Caveat: a
+ *   star-projected re-export edge whose canonical is a component is treated
+ *   as a default-slot re-export and skipped; a `<script module>` const
+ *   sharing the component's exact name would be skipped with it.)
+ *
+ * A Position-3 alias and its `reExports` edge are the same fact — the
+ * declaration entry wins, inheriting the edge's `typeOnly`.
+ *
+ * Cyclic star graphs terminate by contributing nothing along the back-edge
+ * (an approximation of ES fixpoint resolution — fine in practice). Surfaces
+ * resolved inside a cycle are path-relative and not memoized, so sibling
+ * star paths resolve independently rather than inheriting them. Star
+ * targets missing from `modules` are reported in `unresolvedStarExports`
+ * rather than guessed at; `externalStarExports` aggregates external star
+ * specifiers reachable from the module, whose names are unknowable.
+ *
+ * @param modules - the analyzed modules (parsed `ModuleJson`s — run wire
+ *   JSON through `AnalyzeResultJson.parse` first)
+ * @param path - the module to resolve, as a `ModuleJson.path` value
+ * @returns the resolved surface, or `null` when `path` isn't in `modules`
+ */
+export const resolveExportSurface = (modules, path) => {
+    const byPath = new Map(modules.map((m) => [m.path, m]));
+    if (!byPath.has(path))
+        return null;
+    const byIdentity = buildDeclarationIndex(modules);
+    const cache = new Map();
+    const visiting = new Set();
+    const emptySurface = () => ({
+        entries: new Map(),
+        unresolvedStars: new Set(),
+        externalStars: new Set(),
+    });
+    // Only surfaces resolved without hitting a cycle back-edge are memoized.
+    // A surface computed while one of its star ancestors is mid-resolution is
+    // relative to that path — it can carry names a full resolution would
+    // exclude as ambiguous (the back-edge contributed nothing to weigh them
+    // against). Caching it would leak the path-relative answer to sibling
+    // star paths; tainted surfaces are instead recomputed per consumer.
+    // Recomputation is bounded by `visiting` and only occurs inside cyclic
+    // clusters, which are pathological to begin with.
+    const resolveModule = (modulePath) => {
+        const cached = cache.get(modulePath);
+        if (cached)
+            return { surface: cached, tainted: false };
+        // Cycle break: a star back-edge contributes nothing
+        if (visiting.has(modulePath))
+            return { surface: emptySurface(), tainted: true };
+        visiting.add(modulePath);
+        const mod = byPath.get(modulePath);
+        const surface = emptySurface();
+        let tainted = false;
+        const { entries } = surface;
+        // 1. Own declarations — including synthesized aliases and `default`
+        const edgesByName = new Map(mod.reExports.map((e) => [e.name, e]));
+        for (const declaration of mod.declarations) {
+            // A Position-3 alias duplicates its edge; carry the edge's typeOnly
+            const matchingEdge = declaration.aliasOf &&
+                edgesByName.get(declaration.name)?.module === declaration.aliasOf.module
+                ? edgesByName.get(declaration.name)
+                : undefined;
+            entries.set(declaration.name, {
+                entry: {
+                    name: declaration.name,
+                    via: 'declaration',
+                    module: modulePath,
+                    declaration,
+                    ...(matchingEdge?.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: resolveCanonicalIdentity(byIdentity, modulePath, declaration),
+            });
+        }
+        // 2. Same-name re-export edges not already covered by a declaration.
+        // Edges can collide on `name` (Svelte default re-keying — see
+        // `ReExportJson`); the surface is keyed by name, so the first edge in
+        // sort order wins and the collider is dropped
+        for (const edge of mod.reExports) {
+            if (entries.has(edge.name))
+                continue;
+            const canonical = byIdentity.get(`${edge.module}\n${edge.name}`);
+            entries.set(edge.name, {
+                entry: {
+                    name: edge.name,
+                    via: 'reExport',
+                    module: edge.module,
+                    ...(canonical ? { declaration: canonical } : {}),
+                    ...(edge.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: canonical
+                    ? resolveCanonicalIdentity(byIdentity, edge.module, canonical)
+                    : `${edge.module}\n${edge.name}`,
+            });
+        }
+        // 3. Direct external re-exports
+        for (const external of mod.externalReExports) {
+            if (entries.has(external.name))
+                continue;
+            entries.set(external.name, {
+                entry: {
+                    name: external.name,
+                    via: 'external',
+                    specifier: external.specifier,
+                    ...(external.originalName !== undefined ? { originalName: external.originalName } : {}),
+                    ...(external.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: `ext\n${external.specifier}\n${external.originalName ?? external.name}`,
+            });
+        }
+        // 4. External stars — names unknowable, surface incompleteness recorded
+        for (const specifier of mod.externalStarExports) {
+            surface.externalStars.add(specifier);
+        }
+        // 5. Star projection, with ES shadowing and ambiguity rules
+        const excluded = new Set();
+        for (const target of mod.starExports) {
+            if (!byPath.has(target)) {
+                surface.unresolvedStars.add(target);
+                continue;
+            }
+            const resolved = resolveModule(target);
+            if (resolved.tainted)
+                tainted = true;
+            const sub = resolved.surface;
+            for (const star of sub.unresolvedStars)
+                surface.unresolvedStars.add(star);
+            for (const star of sub.externalStars)
+                surface.externalStars.add(star);
+            for (const { entry, identity } of sub.entries.values()) {
+                // `default` never projects — nor do canonical Svelte components,
+                // which represent their file's default export (whether reached
+                // as a declaration or through a re-export edge)
+                if (entry.name === 'default')
+                    continue;
+                if (entry.declaration?.kind === 'component' && !entry.declaration.aliasOf)
+                    continue;
+                if (excluded.has(entry.name))
+                    continue;
+                const existing = entries.get(entry.name);
+                if (existing) {
+                    // Explicit exports shadow; identical canonicals (diamond) merge
+                    if (existing.entry.via !== 'star' || existing.identity === identity)
+                        continue;
+                    // Ambiguous between two stars — excluded per ES semantics
+                    entries.delete(entry.name);
+                    excluded.add(entry.name);
+                    continue;
+                }
+                entries.set(entry.name, {
+                    entry: { ...entry, via: 'star', starFrom: target },
+                    identity,
+                });
+            }
+        }
+        visiting.delete(modulePath);
+        if (!tainted)
+            cache.set(modulePath, surface);
+        return { surface, tainted };
+    };
+    const resolved = resolveModule(path).surface;
+    return {
+        entries: Array.from(resolved.entries.values())
+            .map(({ entry }) => entry)
+            .sort((a, b) => compareStrings(a.name, b.name)),
+        unresolvedStarExports: Array.from(resolved.unresolvedStars).sort(),
+        externalStarExports: Array.from(resolved.externalStars).sort(),
+    };
+};

package/dist/svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAC,QAAQ,EAAsB,MAAM,2BAA2B,CAAC;AAGxE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAA2C,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAGX,cAAc,EACd,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAAC,KAAK,cAAc,EAA0C,MAAM,aAAa,CAAC;AACzF,OAAO,EAAC,KAAK,mBAAmB,EAAsB,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,0FAA0F;AAC1F,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,sGAAsG;IACtG,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,cAAc,KAAG,eAoDlE,CAAC;AAkHF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAcpE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SA0BxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,eAAe,MAAM,KAAG,MAAM,GAAG,SAU3E,CAAC;AA0PF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAExD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,EAAE,CAAC,IAAI,EACpB,SAAS,EAAE,CAAC,WAAW,KACrB,KAAK,CAAC,kBAAkB,CAqB1B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAKxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,YAAY,KAAK,CAAC,kBAAkB,CAAC,KAAG,MAGtF,CAAC;AA8NF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,EACjE,YAAY,MAAM,EAClB,SAAS,EAAE,CAAC,WAAW,EACvB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,CAAC,OAAO,EACnB,aAAa,iBAAiB,KAC5B,cAAc,GAAG,SAuNnB,CAAC"}
+{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAC,QAAQ,EAAsB,MAAM,2BAA2B,CAAC;AAGxE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAA2C,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAGX,cAAc,EACd,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAAC,KAAK,cAAc,EAA0C,MAAM,aAAa,CAAC;AACzF,OAAO,EAAC,KAAK,mBAAmB,EAAsB,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,0FAA0F;AAC1F,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,sGAAsG;IACtG,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,cAAc,KAAG,eAoDlE,CAAC;AAkHF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAcpE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SA0BxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,eAAe,MAAM,KAAG,MAAM,GAAG,SAU3E,CAAC;AA0PF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAExD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,EAAE,CAAC,IAAI,EACpB,SAAS,EAAE,CAAC,WAAW,KACrB,KAAK,CAAC,kBAAkB,CAqB1B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAKxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,YAAY,KAAK,CAAC,kBAAkB,CAAC,KAAG,MAGtF,CAAC;AA8NF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,EACjE,YAAY,MAAM,EAClB,SAAS,EAAE,CAAC,WAAW,EACvB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,CAAC,OAAO,EACnB,aAAa,iBAAiB,KAC5B,cAAc,GAAG,SAoQnB,CAAC"}

package/dist/svelte.js

@@ -728,7 +728,7 @@ export const analyzeSvelteModule = (sourceFile, modulePath, checker, options, di
         return undefined;
     }
     // 1. Use analyzeExports for full checker-backed analysis (same as .ts files)
-    const { declarations: rawDeclarations, reExports, starExports, moduleComment: scriptModuleComment, } = analyzeExports(virtualTsSource, checker, options, diagnostics);
+    const { declarations: rawDeclarations, reExports, starExports, externalReExports, externalStarExports, moduleComment: scriptModuleComment, } = analyzeExports(virtualTsSource, checker, options, diagnostics);
     // 2. Filter internal svelte2tsx symbols and the default export (generated component class),
     //    and reclassify exported snippets from 'function' to 'snippet'
     const moduleDeclarations = [];
@@ -761,9 +761,24 @@ export const analyzeSvelteModule = (sourceFile, modulePath, checker, options, di
     }
     // 2b. Remap source lines for module-level exports using source map.
     // analyzeExports extracts sourceLine from virtual file positions — remap to original .svelte.
-    if (virtualFile.sourceMap && moduleDeclarations.length > 0) {
+    if (virtualFile.sourceMap) {
         // Build name→node map from virtual source statements
         const nodesByName = new Map();
+        // Export-statement bindings (specifiers + `* as ns`), kept separate:
+        // `const foo = 1; export {foo}` would otherwise collide — the
+        // declaration's line should point at the const, the synthesized
+        // alias's at the specifier.
+        const exportNodesByName = new Map();
+        // Virtual line → export binding node, for re-export edges. Edges
+        // can't be matched by name (Svelte default-slot re-keying renames
+        // them), but every edge's virtual sourceLine is some binding's line.
+        const exportNodesByLine = new Map();
+        const addExportNode = (name, node) => {
+            exportNodesByName.set(name, node);
+            const line = virtualTsSource.getLineAndCharacterOfPosition(node.getStart(virtualTsSource)).line + 1;
+            if (!exportNodesByLine.has(line))
+                exportNodesByLine.set(line, node);
+        };
         for (const stmt of virtualTsSource.statements) {
             if (ts.isVariableStatement(stmt)) {
                 for (const decl of stmt.declarationList.declarations) {
@@ -787,11 +802,26 @@ export const analyzeSvelteModule = (sourceFile, modulePath, checker, options, di
             else if (ts.isEnumDeclaration(stmt)) {
                 nodesByName.set(stmt.name.text, stmt);
             }
+            else if (ts.isExportDeclaration(stmt)) {
+                if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+                    for (const spec of stmt.exportClause.elements) {
+                        addExportNode(spec.name.text, spec);
+                    }
+                }
+                else if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause)) {
+                    addExportNode(stmt.exportClause.name.text, stmt.exportClause);
+                }
+            }
         }
         for (const d of moduleDeclarations) {
             if (d.declaration.name === undefined)
                 continue;
-            const node = nodesByName.get(d.declaration.name);
+            // Synthesized aliases and namespace declarations point at their
+            // export statement; everything else at its value declaration
+            const fromExportStatement = d.declaration.aliasOf !== undefined || d.declaration.kind === 'namespace';
+            const node = fromExportStatement
+                ? exportNodesByName.get(d.declaration.name)
+                : nodesByName.get(d.declaration.name);
             if (node) {
                 const mapped = mapVirtualPosition(node, virtualTsSource, virtualFile.sourceMap);
                 if (mapped.line !== undefined) {
@@ -799,6 +829,18 @@ export const analyzeSvelteModule = (sourceFile, modulePath, checker, options, di
                 }
             }
         }
+        // Remap edge lines by virtual line (name-independent — see above)
+        for (const edge of [...reExports, ...externalReExports]) {
+            if (edge.sourceLine === undefined)
+                continue;
+            const node = exportNodesByLine.get(edge.sourceLine);
+            if (node) {
+                const mapped = mapVirtualPosition(node, virtualTsSource, virtualFile.sourceMap);
+                if (mapped.line !== undefined) {
+                    edge.sourceLine = mapped.line;
+                }
+            }
+        }
     }
     // 3. Synthesize component declaration
     const componentName = getComponentName(modulePath);
@@ -894,5 +936,7 @@ export const analyzeSvelteModule = (sourceFile, modulePath, checker, options, di
         dependents,
         starExports,
         reExports,
+        externalReExports,
+        externalStarExports,
     };
 };

package/dist/types.d.ts

@@ -2393,6 +2393,96 @@ export declare const DeclarationJson: z.ZodDiscriminatedUnion<[
 ], 'kind'>;
 export type DeclarationJson = z.infer<typeof DeclarationJson>;
 export type DeclarationJsonInput = z.input<typeof DeclarationJson>;
+/**
+ * A same-name re-export edge, from the re-exporting module's side.
+ *
+ * Each entry on `ModuleJson.reExports` records that the module's source
+ * contains `export {name} from ...` where the canonical declaration lives in
+ * `module`. This is the forward view of the same fact that
+ * `alsoExportedFrom` records on the canonical declaration — consumers
+ * resolve the canonical by `(module, name)`, the same lookup contract as
+ * `aliasOf`.
+ *
+ * Same-name re-exports of analyzed source only. Renamed re-exports appear as
+ * declarations with `aliasOf` in the re-exporting module; star exports live
+ * in `ModuleJson.starExports`; external re-exports in
+ * `ModuleJson.externalReExports` / `externalStarExports`. Use
+ * `resolveExportSurface` (in `postprocess.ts`) to combine all of these into
+ * a module's full export surface — it handles the name dedup (a documented
+ * same-name re-export appears both here and as a synthesized alias
+ * declaration) and the ES star semantics (explicit exports shadow
+ * star-projected ones, names ambiguous between stars are excluded,
+ * `default` doesn't project).
+ *
+ * `module` points at the *canonical* module (multi-hop chains are resolved),
+ * not the immediate specifier in the export statement. For Svelte default-slot
+ * re-exports (`export {default} from './X.svelte'`), `name` is the component
+ * name derived from the filename (`'X'`), matching the canonical declaration's
+ * name — the same exception documented on `aliasOf`. Because of that
+ * re-keying, two entries in one module can share a `name` (a re-keyed
+ * component colliding with a same-name re-export from another module);
+ * `(module, name)` pairs remain unique (exact duplicates are deduped at
+ * construction).
+ *
+ * `@nodocs` on the export statement suppresses the entry (and the
+ * `alsoExportedFrom` back-link). When the canonical declaration itself is
+ * `@nodocs`, or the canonical module isn't part of the analyzed set, the
+ * entry still exists but has no matching back-link — the same presence
+ * caveat as `aliasOf.module` and `starExports`.
+ */
+export declare const ReExportJson: z.ZodObject<{
+    /** Exported name — the canonical declaration's name in `module`. */
+    name: z.ZodString;
+    /** Module path (relative to `sourceRoot`) where the canonical declaration lives. */
+    module: z.ZodString;
+    /**
+     * Whether the statement (`export type {A} from ...`) or specifier
+     * (`export {type A} from ...`) is type-only — the name is erased at
+     * runtime and importable only via `import type`.
+     */
+    typeOnly: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * 1-based line of the export specifier in this module's source. When
+     * identical `(name, module)` edges are deduped (Svelte default-slot
+     * re-keying), the smallest line is kept.
+     */
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ReExportJson = z.infer<typeof ReExportJson>;
+export type ReExportJsonInput = z.input<typeof ReExportJson>;
+/**
+ * A re-export whose immediate target is outside the analyzed source set —
+ * `export {x} from 'pkg'`, `export {x as y} from 'pkg'`, or
+ * `export * as ns from 'pkg'`.
+ *
+ * `specifier` is the module specifier as written (usually a package name);
+ * there is no canonical declaration to resolve, so these entries are flat
+ * facts about the statement rather than edges into the module graph.
+ *
+ * Only statements that *directly* reference the external specifier are
+ * captured. Forms that stay silent: `import {x} from 'pkg'; export {x};`
+ * (import-then-export), re-export chains that reach a package through
+ * another source module (that module owns the entry), and specifiers the
+ * checker can't resolve. Statement-level `@nodocs` suppresses the entry.
+ */
+export declare const ExternalReExportJson: z.ZodObject<{
+    /** Public exported name from this module. */
+    name: z.ZodString;
+    /** Module specifier as written in the statement (e.g. `'pkg'`). */
+    specifier: z.ZodString;
+    /**
+     * The name inside the external module when renamed
+     * (`export {x as y} from 'pkg'` → `'x'`). Omitted for same-name
+     * re-exports and namespace form (`export * as ns`).
+     */
+    originalName: z.ZodOptional<z.ZodString>;
+    /** Whether the statement or specifier is type-only — see `ReExportJson.typeOnly`. */
+    typeOnly: z.ZodDefault<z.ZodBoolean>;
+    /** 1-based line of the export specifier in this module's source. */
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ExternalReExportJson = z.infer<typeof ExternalReExportJson>;
+export type ExternalReExportJsonInput = z.input<typeof ExternalReExportJson>;
 /**
  * Metadata for a source module — the top-level container in the data model.
  *
@@ -4114,9 +4204,63 @@ export declare const ModuleJson: z.ZodObject<{
     dependents: z.ZodDefault<z.ZodArray<z.ZodString>>;
     /**
      * Modules fully re-exported via `export * from './module'`.
-     * Paths are relative to `sourceRoot`.
+     * Paths are relative to `sourceRoot`. Statement-level `@nodocs`
+     * suppresses the entry, like the other re-export encodings.
      */
     starExports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Same-name re-exports in this module's source, sorted by `name` then
+     * `module` (names can collide — see `ReExportJson`). The forward view of
+     * `alsoExportedFrom` — see `ReExportJson` for the full contract (canonical
+     * resolution, Svelte default-slot naming, `@nodocs` suppression, presence
+     * caveats).
+     */
+    reExports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Exported name — the canonical declaration's name in `module`. */
+        name: z.ZodString;
+        /** Module path (relative to `sourceRoot`) where the canonical declaration lives. */
+        module: z.ZodString;
+        /**
+         * Whether the statement (`export type {A} from ...`) or specifier
+         * (`export {type A} from ...`) is type-only — the name is erased at
+         * runtime and importable only via `import type`.
+         */
+        typeOnly: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * 1-based line of the export specifier in this module's source. When
+         * identical `(name, module)` edges are deduped (Svelte default-slot
+         * re-keying), the smallest line is kept.
+         */
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    /**
+     * Re-exports whose immediate target is an external package, sorted by
+     * `name` then `specifier`. See `ExternalReExportJson` for which forms
+     * are captured.
+     */
+    externalReExports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Public exported name from this module. */
+        name: z.ZodString;
+        /** Module specifier as written in the statement (e.g. `'pkg'`). */
+        specifier: z.ZodString;
+        /**
+         * The name inside the external module when renamed
+         * (`export {x as y} from 'pkg'` → `'x'`). Omitted for same-name
+         * re-exports and namespace form (`export * as ns`).
+         */
+        originalName: z.ZodOptional<z.ZodString>;
+        /** Whether the statement or specifier is type-only — see `ReExportJson.typeOnly`. */
+        typeOnly: z.ZodDefault<z.ZodBoolean>;
+        /** 1-based line of the export specifier in this module's source. */
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    /**
+     * External modules fully re-exported via `export * from 'pkg'`, as
+     * written (statement order). The projected names are unknown — the
+     * package isn't analyzed. Statement-level `@nodocs` suppresses the
+     * entry; unresolvable specifiers are skipped.
+     */
+    externalStarExports: z.ZodDefault<z.ZodArray<z.ZodString>>;
     /**
      * Whether the module is a placeholder for a file that couldn't be analyzed.
      *