svelte-docinfo 0.9.0 → 0.10.1

package/README.md

@@ -226,12 +226,12 @@ Plugin options:
 | `projectRoot`         | Vite's resolved `config.root`                        | Absolute path to project root.                                                                                                                                                                                         |
 | `include`             | —                                                    | Glob patterns to include (relative to `projectRoot`; absolute inside it accepted). Collapses `discovery: 'auto'` to glob; combining with `discovery: 'exports'` throws. Widens the source scope — see the notes below. |
 | `exclude`             | `['**/*.test.ts', '**/*.spec.ts', '**/internal/**']` | Glob patterns to exclude. An array fully replaces the defaults; the callback form extends them (`(defaults) => [...defaults, '**/*.gen.ts']`). The always-on baseline below still applies.                             |
-| `discovery`           | `'auto'`                                             | Discovery strategy: `'auto'` \| `'exports'` \| `'glob'`. `'exports'` is strict and fails if `package.json` exports is missing or resolves to no files.                                                                                |
+| `discovery`           | `'auto'`                                             | Discovery strategy: `'auto'` \| `'exports'` \| `'glob'`. `'exports'` is strict and fails if `package.json` exports is missing or resolves to no files.                                                                 |
 | `distDir`             | `'dist'`                                             | Dist directory name for exports-based discovery.                                                                                                                                                                       |
 | `sourceOptions`       | `{sourcePaths: ['src/lib'], …}`                      | Partial overrides for default source options (SvelteKit `src/lib` layout).                                                                                                                                             |
 | `resolveDependencies` | `true`                                               | Resolve import dependencies. When `false`, `dependencies`/`dependents` stay empty.                                                                                                                                     |
-| `onDuplicates`        | —                                                    | Dispatch on duplicate declaration names: `'throw'` \| `'warn'` \| callback. Diagnostic emits regardless of dispatch.                                                                                                   |
 | `hmrDebounceMs`       | `100`                                                | Dev re-analysis debounce delay in milliseconds.                                                                                                                                                                        |
+| `onDuplicates`        | —                                                    | Opt-in check that names are unique across modules, for packages with a flat export namespace: `'diagnostic'` \| `'warn'` \| `'throw'`. Off by default.                                                                |
 
 Source-scope notes (shared with the [CLI](#cli) and `analyzeFromFiles`):
 
@@ -274,21 +274,21 @@ All CLI options:
 | `-i, --include <pattern>`   | Include pattern (repeatable, replaces exports discovery, widens the source scope; incompatible with `--discovery exports`)                                                                    |
 | `-e, --exclude <pattern>`   | Exclude glob, applied at discovery and analysis (repeatable; fully replaces the defaults `**/*.test.ts`, `**/*.spec.ts`, `**/internal/**` — no merge; the always-on baseline applies beneath) |
 | `-o, --output <file>`       | Output file (default: stdout; pass `-` for explicit stdout, so `-o "$OUT"` works when `$OUT=-`)                                                                                               |
-| `--discovery <mode>`        | `auto` \| `exports` \| `glob` (default: `auto` — exports first, glob fallback). `exports` is strict and fails if package.json exports is missing or resolves to no files                                     |
+| `--discovery <mode>`        | `auto` \| `exports` \| `glob` (default: `auto` — exports first, glob fallback). `exports` is strict and fails if package.json exports is missing or resolves to no files                      |
 | `--dist-dir <dir>`          | Dist directory for exports discovery (default: dist)                                                                                                                                          |
 | `--source-dir <dir>`        | Source directory, relative to project root or absolute inside it (default: src/lib). Repeatable for monorepos; drives the implicit include glob when no `--include` is provided               |
 | `--source-root <dir>`       | Source root for module-path stripping (default: single source-dir or longest common prefix; pass `.` for project-relative paths)                                                              |
-| `--on-duplicates <mode>`    | Dispatch on duplicate declaration names: `throw` \| `warn` (default: emit `duplicate_declaration` diagnostic, no dispatch)                                                                    |
 | `--only <pattern>`          | Glob filter applied to module paths in output (repeatable). Full project is still analyzed (re-exports/dependents stay correct); diagnostics aren't filtered                                  |
 | `--no-resolve-dependencies` | Disable dependency resolution                                                                                                                                                                 |
 | `--pretty`                  | Pretty-print JSON output (default: compact)                                                                                                                                                   |
 | `-q, --quiet`               | Suppress info messages on stderr (warnings and errors still print)                                                                                                                            |
+| `--on-duplicates <mode>`    | Opt-in check that names are unique across modules, for packages with a flat export namespace: `diagnostic` \| `warn` \| `throw` (default: off)                                                |
 | `-V, --version`             | Show version number                                                                                                                                                                           |
 
 The [Vite plugin](#vite-plugin)'s source-scope notes apply here too: explicit `--include` patterns widen the source scope (module paths become relative to the widened root, and a pattern with no base scopes the whole project root and logs an info line); `node_modules` and dot-directories below a source dir are always excluded regardless of `--exclude`; absolute paths and patterns inside the project root are accepted, and out-of-root ones fail loudly.
 
 Exit codes: 0 (success), 1 (analysis errors), 2 (CLI errors or a thrown analysis error, like a
-missing or unloadable `tsconfig.json` or an `--on-duplicates throw` collision).
+missing or unloadable `tsconfig.json`).
 
 See [examples/cli/](examples/cli/README.md) for more usage patterns.
 

package/dist/analyze-core.d.ts

@@ -13,10 +13,8 @@
  * - `analyzeModule` — the per-module dispatcher for non-Svelte files (TS / CSS /
  *   JSON; Svelte needs `analyzeSvelteModule`). `@internal`; exposed for tests
  *   and power users via the subpath.
- * - `AnalyzeResultJson` / `AnalyzeResultJsonWire` / `OnDuplicates` /
- *   `OnDuplicatesCallback` — shared types surfaced through the main barrel
- *   directly from this module.
- * - `throwOnDuplicates` — convenience callback paired with `OnDuplicates`.
+ * - `AnalyzeResultJson` / `AnalyzeResultJsonWire` / `OnDuplicates` — shared
+ *   types surfaced through the main barrel directly from this module.
  * - `finalizeDiagnostics` — the diagnostic boundary passes (virtual position
  *   remap, then path normalization) in their required order; the one call for
  *   callers assembling modules themselves.
@@ -28,7 +26,7 @@
  *   assembling modules itself through `analyzeModule` can meet the same
  *   output contract.
  *
- * The barrel-surfaced schemas, types, and `throwOnDuplicates` are stable API.
+ * The barrel-surfaced schemas and types are stable API.
  * Everything else is subpath-only; `analyzeCore` and `analyzeModule` are
  * `@internal`.
  *
@@ -43,47 +41,25 @@ import { type SvelteVirtualFile } from './svelte.js';
 import { type SourceFileInfo } from './source.js';
 import { type ModuleSourceOptions } from './source-config.js';
 import type { AliasRegistry } from './typescript-extract-type-json.js';
-import { type DuplicateDeclaration } from './postprocess.js';
 /**
- * Custom callback for handling duplicate declaration names.
+ * Opt-in check that declaration names are unique across modules.
  *
- * Use the `'throw'` or `'warn'` shortcuts on `onDuplicates` for the common
- * cases. Pass a function to fully control reporting.
+ * For packages that keep a flat export namespace, where every exported name
+ * is unique across the whole package. Most packages don't, and two modules
+ * exporting the same name is ordinary, so the check is off by default:
+ * omitted, duplicate detection doesn't run and nothing is reported.
  *
- * @param duplicates - map of declaration names to their `DuplicateDeclaration` occurrences across modules
- * @param log - logger for reporting (only `error` method required)
- */
-export type OnDuplicatesCallback = (duplicates: Map<string, Array<DuplicateDeclaration>>, log: Pick<AnalysisLog, 'error'>) => void;
-/**
- * Behavior selector for duplicate declaration names across modules.
- *
- * - `'throw'` — throw an `Error` listing every duplicate (strict flat-namespace enforcement)
- * - `'warn'` — log to `log.error` and continue
- * - `OnDuplicatesCallback` — custom handler
- *
- * Omitted entirely: no dispatch runs, but a `duplicate_declaration` diagnostic
- * is still emitted into the diagnostics array for every collision (the diagnostic
- * is the data; this option is the action).
+ * Every mode emits a `duplicate_declaration` diagnostic per colliding name:
  *
- * **`'throw'` trade-off**: the throw fires after diagnostics are emitted but
- * before the result is returned, so `'throw'` callers never reach the
- * diagnostics array. Callers that want fail-fast *and* diagnostic access
- * should omit `onDuplicates` and inspect themselves:
- *
- * ```ts
- * const result = await analyze({...});
- * if (hasErrors(result.diagnostics)) throw new Error('analysis errors');
- * ```
- *
- * Or use an `OnDuplicatesCallback` and stash the data before throwing.
- */
-export type OnDuplicates = 'throw' | 'warn' | OnDuplicatesCallback;
-/**
- * Convenience `OnDuplicatesCallback` that throws on any duplicate.
+ * - `'diagnostic'` — the diagnostics only
+ * - `'warn'` — also log the collisions to `log.warn` and continue
+ * - `'throw'` — also throw an `Error` listing every duplicate
  *
- * @throws Error listing every duplicate name and module location
+ * The throw fires before the result is returned, so `'throw'` callers never
+ * reach the diagnostics array. For custom handling, use `'diagnostic'` and
+ * read the records with `byKind(diagnostics, 'duplicate_declaration')`.
  */
-export declare const throwOnDuplicates: OnDuplicatesCallback;
+export type OnDuplicates = 'diagnostic' | 'warn' | 'throw';
 /**
  * Result of `analyze`, `analyzeFromFiles`, and `AnalysisSession.query`.
  *
@@ -1576,8 +1552,7 @@ export declare const finalizeDiagnostics: (diagnostics: Array<Diagnostic>, optio
  *
  * `message` gets the same treatment as `file`, by textual substitution. A
  * message is free-form, and not every path in one comes from a field this
- * pass can see — `import_parse_failed` wraps an es-module-lexer error that
- * embeds the file name itself. Scrubbing here means the contract holds for
+ * pass can see — a wrapped error message can embed the file name itself. Scrubbing here means the contract holds for
  * the whole record rather than one field, so a producer can't reintroduce an
  * absolute path through prose.
  *

package/dist/analyze-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze-core.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze-core.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"analyze-core.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze-core.ts"],"names":[],"mappings":"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"}

package/dist/analyze-core.js

@@ -13,10 +13,8 @@
  * - `analyzeModule` — the per-module dispatcher for non-Svelte files (TS / CSS /
  *   JSON; Svelte needs `analyzeSvelteModule`). `@internal`; exposed for tests
  *   and power users via the subpath.
- * - `AnalyzeResultJson` / `AnalyzeResultJsonWire` / `OnDuplicates` /
- *   `OnDuplicatesCallback` — shared types surfaced through the main barrel
- *   directly from this module.
- * - `throwOnDuplicates` — convenience callback paired with `OnDuplicates`.
+ * - `AnalyzeResultJson` / `AnalyzeResultJsonWire` / `OnDuplicates` — shared
+ *   types surfaced through the main barrel directly from this module.
  * - `finalizeDiagnostics` — the diagnostic boundary passes (virtual position
  *   remap, then path normalization) in their required order; the one call for
  *   callers assembling modules themselves.
@@ -28,7 +26,7 @@
  *   assembling modules itself through `analyzeModule` can meet the same
  *   output contract.
  *
- * The barrel-surfaced schemas, types, and `throwOnDuplicates` are stable API.
+ * The barrel-surfaced schemas and types are stable API.
  * Everything else is subpath-only; `analyzeCore` and `analyzeModule` are
  * `@internal`.
  *
@@ -47,16 +45,6 @@ import { toPosixPath, isAbsolutePosixPath } from './paths.js';
 import { buildAliasRegistry } from './typescript-alias-registry.js';
 import { createExtractContext } from './typescript-extract-shared.js';
 import { sortModules, findDuplicates, mergeReExports, resolveComponentAliases, compareStrings } from './postprocess.js';
-/**
- * Convenience `OnDuplicatesCallback` that throws on any duplicate.
- *
- * @throws Error listing every duplicate name and module location
- */
-export const throwOnDuplicates = (duplicates) => {
-    if (duplicates.size === 0)
-        return;
-    throw new Error(formatDuplicates(duplicates));
-};
 const formatDuplicates = (duplicates) => {
     const details = Array.from(duplicates)
         .map(([name, occurrences]) => {
@@ -70,9 +58,8 @@ const formatDuplicates = (duplicates) => {
     })
         .join('\n');
     return (`Found ${duplicates.size} duplicate declaration name${duplicates.size === 1 ? '' : 's'} across modules. ` +
-        'The flat namespace requires unique names. To resolve: ' +
-        '(1) rename one of the conflicting declarations, or ' +
-        '(2) add /** @nodocs */ to exclude from documentation.\n' +
+        'To resolve, rename one of the conflicting declarations, ' +
+        'or mark one /** @nodocs */ if it is not public API.\n' +
         details);
 };
 /**
@@ -103,17 +90,12 @@ const emitDuplicateDiagnostics = (diagnostics, duplicates, sourceIdsByModulePath
     }
 };
 const dispatchOnDuplicates = (mode, duplicates, log) => {
-    if (duplicates.size === 0)
-        return;
-    if (mode === 'throw') {
-        throw new Error(formatDuplicates(duplicates));
-    }
-    const errorLog = log ?? { error: (msg) => console.error(msg) };
-    if (mode === 'warn') {
-        errorLog.error(formatDuplicates(duplicates));
+    if (duplicates.size === 0 || mode === 'diagnostic')
         return;
-    }
-    mode(duplicates, errorLog);
+    const message = formatDuplicates(duplicates);
+    if (mode === 'throw')
+        throw new Error(message);
+    (log?.warn ?? console.warn)(message);
 };
 // Result types
 /**
@@ -418,13 +400,10 @@ export const analyzeCore = (inputs) => {
     // Gated canonicals extend the lookup without joining the output.
     const resolvedModules = resolveComponentAliases(mergedModules, contextModules);
     const sortedModules = sortModules(resolvedModules);
-    // Always run duplicate detection so a `duplicate_declaration` diagnostic
-    // reaches consumers regardless of `onDuplicates`. The `onDuplicates`
-    // callback/shortcut still fires for callers that want fail-fast or custom
-    // handling — diagnostics is the data, `onDuplicates` is the action.
-    const duplicates = findDuplicates(sortedModules);
-    emitDuplicateDiagnostics(diagnostics, duplicates, sourceIdsByModulePath);
+    // opt-in flat-namespace check, see `OnDuplicates`
     if (onDuplicates) {
+        const duplicates = findDuplicates(sortedModules);
+        emitDuplicateDiagnostics(diagnostics, duplicates, sourceIdsByModulePath);
         dispatchOnDuplicates(onDuplicates, duplicates, log);
     }
     normalizeModulePathsInTypes(sortedModules, sourceOptions, program);
@@ -468,8 +447,7 @@ export const finalizeDiagnostics = (diagnostics, options) => {
  *
  * `message` gets the same treatment as `file`, by textual substitution. A
  * message is free-form, and not every path in one comes from a field this
- * pass can see — `import_parse_failed` wraps an es-module-lexer error that
- * embeds the file name itself. Scrubbing here means the contract holds for
+ * pass can see — a wrapped error message can embed the file name itself. Scrubbing here means the contract holds for
  * the whole record rather than one field, so a producer can't reintroduce an
  * absolute path through prose.
  *

package/dist/analyze.d.ts

@@ -40,7 +40,7 @@ export interface AnalyzeOptions {
     sourceFiles: ReadonlyArray<SourceFileInfo>;
     /** Module source options for path extraction and source filtering. */
     sourceOptions: ModuleSourceOptions;
-    /** Behavior when duplicate declaration names are found across modules. */
+    /** Opt-in check that declaration names are unique across modules (see `OnDuplicates`). */
     onDuplicates?: OnDuplicates;
     /** Optional logger for status and diagnostic messages. */
     log?: AnalysisLog;
@@ -78,7 +78,7 @@ export interface AnalyzeFromFilesOptions {
     projectRoot: string;
     /** Partial overrides for default source options (SvelteKit `src/lib` layout). */
     sourceOptions?: SourceOptionsOverrides;
-    /** Behavior when duplicate declaration names are found across modules. */
+    /** Opt-in check that declaration names are unique across modules (see `OnDuplicates`). */
     onDuplicates?: OnDuplicates;
     /** Optional logger for status and diagnostic messages. */
     log?: AnalysisLog;

package/dist/analyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAEN,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC9B;;;;;;OAMG;IACH,WAAW,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC3C,sEAAsE;IACtE,aAAa,EAAE,mBAAmB,CAAC;IACnC,0EAA0E;IAC1E,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAU,SAAS,cAAc,KAAG,OAAO,CAAC,iBAAiB,CAwBhF,CAAC;AAIF;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACvC,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,0EAA0E;IAC1E,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC5B,SAAS,uBAAuB,KAC9B,OAAO,CAAC,iBAAiB,CAwH3B,CAAC"}
+{"version":3,"file":"analyze.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAEN,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC9B;;;;;;OAMG;IACH,WAAW,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC3C,sEAAsE;IACtE,aAAa,EAAE,mBAAmB,CAAC;IACnC,0FAA0F;IAC1F,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAU,SAAS,cAAc,KAAG,OAAO,CAAC,iBAAiB,CAwBhF,CAAC;AAIF;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACvC,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,0FAA0F;IAC1F,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC5B,SAAS,uBAAuB,KAC9B,OAAO,CAAC,iBAAiB,CAwH3B,CAAC"}

package/dist/cli.d.ts

@@ -17,10 +17,8 @@
  *
  * @module
  */
+import type { OnDuplicates } from './analyze-core.js';
 import type { Discovery } from './discovery.js';
-/** Allowed values for `--on-duplicates`. */
-declare const ON_DUPLICATES_VALUES: readonly ["throw", "warn"];
-type OnDuplicatesFlag = (typeof ON_DUPLICATES_VALUES)[number];
 /**
  * CLI options parsed from command line arguments.
  */
@@ -76,13 +74,10 @@ export interface CliOptions {
      */
     sourceRoot?: string;
     /**
-     * Behavior when duplicate declaration names are found across modules
-     * (undefined = emit `duplicate_declaration` diagnostic, no dispatch).
-     *
-     * Duplicate detection always runs regardless of this option — the diagnostic
-     * is the data, this option is the dispatch action.
+     * Opt-in check that declaration names are unique across modules (see
+     * `OnDuplicates`). Undefined skips the check.
      */
-    onDuplicates?: OnDuplicatesFlag;
+    onDuplicates?: OnDuplicates;
     /**
      * Glob patterns to filter the emitted `modules` array against `ModuleJson.path`
      * (undefined = emit all analyzed modules).
@@ -105,5 +100,4 @@ export interface CliOptions {
  *   thrown analysis error (including an `--on-duplicates throw` collision)
  */
 export declare const runCli: (argv?: Array<string>) => Promise<number>;
-export {};
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAUhD,4CAA4C;AAC5C,QAAA,MAAM,oBAAoB,4BAA6B,CAAC;AACxD,KAAK,gBAAgB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAS9D;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,sFAAsF;IACtF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAU,OAAM,KAAK,CAAC,MAAM,CAAgB,KAAG,OAAO,CAAC,MAAM,CA6N/E,CAAC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAwBhD;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,sFAAsF;IACtF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAU,OAAM,KAAK,CAAC,MAAM,CAAgB,KAAG,OAAO,CAAC,MAAM,CA4N/E,CAAC"}

package/dist/cli.js

@@ -29,7 +29,11 @@ import { compactReplacer } from './declaration-helpers.js';
 /** Collect repeatable option values into an array. */
 const collect = (value, previous) => previous ? [...previous, value] : [value];
 /** Allowed values for `--on-duplicates`. */
-const ON_DUPLICATES_VALUES = ['throw', 'warn'];
+const ON_DUPLICATES_VALUES = [
+    'diagnostic',
+    'warn',
+    'throw'
+];
 const isOnDuplicatesFlag = (value) => ON_DUPLICATES_VALUES.includes(value);
 /** Allowed values for `--discovery`. */
 const DISCOVERY_VALUES = ['auto', 'exports', 'glob'];
@@ -87,14 +91,16 @@ export const runCli = async (argv = process.argv) => {
         'glob for the glob-discovery fallback when no --include is provided.', collect)
         .option('--source-root <dir>', 'Prefix stripped from module paths in output (default: the source-dir, ' +
         'or longest common prefix when multiple). Pass `.` to keep paths project-relative.')
-        .option('--on-duplicates <mode>', `Dispatch on duplicate declaration names across modules: ${ON_DUPLICATES_VALUES.join('|')} ` +
-        '(default: emit duplicate_declaration diagnostic, no dispatch)')
         .option('--only <pattern>', 'Glob filter applied to module paths in output (repeatable). ' +
         'Full project is still analyzed — re-exports/dependents stay correct — ' +
         'but only matching modules are emitted. Diagnostics are not filtered ' +
         'and may reference modules dropped from output.', collect)
         .option('--pretty', 'Pretty-print JSON output', false)
         .option('-q, --quiet', 'Suppress info messages on stderr (warnings and errors still print)', false)
+        .option('--on-duplicates <mode>', 'Opt-in check that declaration names are unique across modules, ' +
+        `for packages with a flat export namespace: ${ON_DUPLICATES_VALUES.join('|')} ` +
+        '(default: off). Every mode emits duplicate_declaration diagnostics; ' +
+        'warn also logs them and throw fails the run.')
         .addHelpText('after', `
 Examples:
   $ svelte-docinfo                                Analyze current project
@@ -107,7 +113,6 @@ Examples:
                                                   No common prefix — module paths stay project-relative
   $ svelte-docinfo --discovery glob               Skip package.json exports
   $ svelte-docinfo --discovery exports            Strict — fail if exports missing
-  $ svelte-docinfo --on-duplicates throw          Enforce flat namespace
   $ svelte-docinfo --only 'components/**'         Emit only modules under components/
   $ svelte-docinfo --only '*.svelte'              Emit only Svelte modules (top-level)
   $ svelte-docinfo | jq .                         Pipe to jq for readable output`)
@@ -156,7 +161,6 @@ Examples:
                     ...(options.sourceRoot !== undefined ? { sourceRoot: options.sourceRoot } : {})
                 }
                 : undefined;
-            const onDuplicates = options.onDuplicates;
             const { modules, diagnostics } = await analyzeFromFiles({
                 projectRoot: resolvedRoot,
                 include: options.include,
@@ -165,7 +169,7 @@ Examples:
                 discovery: options.discovery,
                 distDir: options.distDir,
                 ...(sourceOptions !== undefined ? { sourceOptions } : {}),
-                ...(onDuplicates !== undefined ? { onDuplicates } : {}),
+                ...(options.onDuplicates !== undefined ? { onDuplicates: options.onDuplicates } : {}),
                 log
             });
             // `--only` is an output-only filter: analysis ran against the full

package/dist/dep-resolver.d.ts

@@ -4,8 +4,6 @@
  * Exposes the `ImportResolver` token contract (`{resolve, identity, invalidate?}`) plus
  * building blocks the session uses inside its three-phase setFiles pipeline:
  *
- * - `ensureLexerReady` — one-time wasm init for `es-module-lexer`. Phase 1 is
- *   sync per-file; the session awaits this once before the loop starts.
  * - `lexImports` — sync specifier extraction from already-prepared content
  *   (raw TS/JS, or svelte2tsx virtual content for `.svelte` files).
  * - `createDefaultResolver` — the TS + tsconfig fallback used when neither
@@ -108,32 +106,29 @@ export type ResolveImport = ResolveImportFn | ImportResolver;
  * override.
  */
 export declare const normalizeResolveImport: (value: ResolveImport | undefined) => ImportResolver | undefined;
-/**
- * Ensure `es-module-lexer`'s wasm runtime is initialized.
- *
- * Idempotent and cheap after the first call. The session awaits this once at
- * the top of `setFiles` so phase 1's per-file lex is purely synchronous.
- */
-export declare const ensureLexerReady: () => Promise<void>;
 /**
  * Lex import specifiers from prepared content.
  *
- * Sync — caller must have awaited `ensureLexerReady` at least once before
- * invoking. For `.svelte` files, pass the svelte2tsx-transformed virtual
- * content, not the raw `.svelte` source (which isn't lex-able as JS/TS).
+ * Parses with TypeScript (`ts.createSourceFile`, no binding or checking)
+ * rather than lexing as JS, so TypeScript syntax a JS lexer misreads as a
+ * regex or comparison (`a! / b`, `Promise<Result<A, B>> => {}`) can't derail
+ * it, and every ES form is seen, including `export * as ns from` (which
+ * TypeScript's lighter `preProcessFile` scanner misses).
  *
- * Dynamic imports (`import(specifier)` with non-literal arg) are omitted.
- * `import type` and inline `type` specifiers are kept, but the lexer drops
- * type-only re-exports (`export type {...} from`, `export type * from`).
+ * Collects, in source order: static imports and re-exports (type-only ones
+ * included: `import type`, inline `type` specifiers, `export type {...}
+ * from`, `export type * from`), `import x = require()`, module augmentations
+ * (`declare module '…'` in a module), and anywhere in the file, dynamic
+ * `import()` with a string literal and `import('…')` types. CommonJS
+ * `require()` calls and non-literal `import()` are omitted.
  *
- * @throws Error if lexing fails (malformed source). Callers should catch and
- *   emit `import_parse_failed`.
+ * For `.svelte` files, pass the svelte2tsx-transformed virtual content, not
+ * the raw `.svelte` source.
  *
  * @param content - prepared file content (TS/JS, or svelte2tsx virtual)
- * @param fileId - absolute file path (used for error messages)
- * @returns specifiers in declaration order
+ * @returns specifiers in source order
  */
-export declare const lexImports: (content: string, fileId: string) => Array<string>;
+export declare const lexImports: (content: string) => Array<string>;
 /**
  * Whether a lexed specifier names a Node builtin (`fs`, `node:fs/promises`, …).
  *

package/dist/dep-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dep-resolver.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/dep-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAAE,MAAM,YAAY,CAAC;AAK5B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACZ,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC9B,uEAAuE;IACvE,OAAO,EAAE,eAAe,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,cAAc,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAClC,OAAO,aAAa,GAAG,SAAS,KAC9B,cAAc,GAAG,SAC6E,CAAC;AAElG;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,IAAI,CAErD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,KAAK,CAAC,MAAM,CAOxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,WAAW,MAAM,KAAG,OAA+B,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,GACjC,iBAAiB,EAAE,CAAC,eAAe,EACnC,aAAa,MAAM,EACnB,OAAM,EAAE,CAAC,oBAA6B,KACpC,cAgCF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC7B,eAAe,eAAe,EAC9B,WAAU,MAAM,GAAG,MAA0B,KAC3C,cAGD,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAG5B,CAAC"}
+{"version":3,"file":"dep-resolver.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/dep-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACZ,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC9B,uEAAuE;IACvE,OAAO,EAAE,eAAe,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,cAAc,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAClC,OAAO,aAAa,GAAG,SAAS,KAC9B,cAAc,GAAG,SAC6E,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,KAAG,KAAK,CAAC,MAAM,CAwCxD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,WAAW,MAAM,KAAG,OAA+B,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,GACjC,iBAAiB,EAAE,CAAC,eAAe,EACnC,aAAa,MAAM,EACnB,OAAM,EAAE,CAAC,oBAA6B,KACpC,cAgCF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC7B,eAAe,eAAe,EAC9B,WAAU,MAAM,GAAG,MAA0B,KAC3C,cAGD,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAG5B,CAAC"}

package/dist/dep-resolver.js

@@ -4,8 +4,6 @@
  * Exposes the `ImportResolver` token contract (`{resolve, identity, invalidate?}`) plus
  * building blocks the session uses inside its three-phase setFiles pipeline:
  *
- * - `ensureLexerReady` — one-time wasm init for `es-module-lexer`. Phase 1 is
- *   sync per-file; the session awaits this once before the loop starts.
  * - `lexImports` — sync specifier extraction from already-prepared content
  *   (raw TS/JS, or svelte2tsx virtual content for `.svelte` files).
  * - `createDefaultResolver` — the TS + tsconfig fallback used when neither
@@ -32,7 +30,6 @@
 import { isBuiltin } from 'node:module';
 import { dirname, isAbsolute, resolve as resolvePath } from 'node:path';
 import ts from 'typescript';
-import { init as esModuleLexerInit, parse as esModuleLexerParse } from 'es-module-lexer';
 import { toPosixPath } from './paths.js';
 /**
  * Normalize the public `ResolveImport` union to an `ImportResolver`.
@@ -44,41 +41,64 @@ import { toPosixPath } from './paths.js';
  * override.
  */
 export const normalizeResolveImport = (value) => value === undefined ? undefined : typeof value === 'function' ? wrapResolveImport(value) : value;
-/**
- * Ensure `es-module-lexer`'s wasm runtime is initialized.
- *
- * Idempotent and cheap after the first call. The session awaits this once at
- * the top of `setFiles` so phase 1's per-file lex is purely synchronous.
- */
-export const ensureLexerReady = async () => {
-    await esModuleLexerInit;
-};
 /**
  * Lex import specifiers from prepared content.
  *
- * Sync — caller must have awaited `ensureLexerReady` at least once before
- * invoking. For `.svelte` files, pass the svelte2tsx-transformed virtual
- * content, not the raw `.svelte` source (which isn't lex-able as JS/TS).
+ * Parses with TypeScript (`ts.createSourceFile`, no binding or checking)
+ * rather than lexing as JS, so TypeScript syntax a JS lexer misreads as a
+ * regex or comparison (`a! / b`, `Promise<Result<A, B>> => {}`) can't derail
+ * it, and every ES form is seen, including `export * as ns from` (which
+ * TypeScript's lighter `preProcessFile` scanner misses).
  *
- * Dynamic imports (`import(specifier)` with non-literal arg) are omitted.
- * `import type` and inline `type` specifiers are kept, but the lexer drops
- * type-only re-exports (`export type {...} from`, `export type * from`).
+ * Collects, in source order: static imports and re-exports (type-only ones
+ * included: `import type`, inline `type` specifiers, `export type {...}
+ * from`, `export type * from`), `import x = require()`, module augmentations
+ * (`declare module '…'` in a module), and anywhere in the file, dynamic
+ * `import()` with a string literal and `import('…')` types. CommonJS
+ * `require()` calls and non-literal `import()` are omitted.
  *
- * @throws Error if lexing fails (malformed source). Callers should catch and
- *   emit `import_parse_failed`.
+ * For `.svelte` files, pass the svelte2tsx-transformed virtual content, not
+ * the raw `.svelte` source.
  *
  * @param content - prepared file content (TS/JS, or svelte2tsx virtual)
- * @param fileId - absolute file path (used for error messages)
- * @returns specifiers in declaration order
+ * @returns specifiers in source order
  */
-export const lexImports = (content, fileId) => {
-    const [imports] = esModuleLexerParse(content, fileId);
-    const specifiers = [];
-    for (const imp of imports) {
-        if (imp.n)
-            specifiers.push(imp.n);
+export const lexImports = (content) => {
+    const sourceFile = ts.createSourceFile('lex.ts', content, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    const found = [];
+    const add = (node) => {
+        if (node && ts.isStringLiteralLike(node))
+            found.push({ pos: node.pos, text: node.text });
+    };
+    const isModule = ts.isExternalModule(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) {
+            add(statement.moduleSpecifier);
+        }
+        else if (ts.isImportEqualsDeclaration(statement) &&
+            ts.isExternalModuleReference(statement.moduleReference)) {
+            add(statement.moduleReference.expression);
+        }
+        else if (isModule && ts.isModuleDeclaration(statement)) {
+            add(statement.name);
+        }
+    }
+    // dynamic imports and import types can sit at any depth, so the full walk
+    // runs only when the text could contain one
+    if (content.includes('import(') || content.includes('import (')) {
+        const visit = (node) => {
+            if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+                add(node.arguments[0]);
+            }
+            else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+                add(node.argument.literal);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        found.sort((a, b) => a.pos - b.pos);
     }
-    return specifiers;
+    return found.map((f) => f.text);
 };
 /**
  * Whether a lexed specifier names a Node builtin (`fs`, `node:fs/promises`, …).

package/dist/diagnostics.d.ts

@@ -455,7 +455,10 @@ export declare const ModuleUnreadableDiagnostic: z.ZodObject<{
 }, z.core.$strict>;
 export type ModuleUnreadableDiagnostic = z.infer<typeof ModuleUnreadableDiagnostic>;
 /**
- * Import parsing failed during dependency resolution.
+ * Import scanning threw during dependency resolution.
+ *
+ * Not expected in practice: the parse in `lexImports` tolerates malformed
+ * source rather than rejecting it, so this guards an unexpected throw.
  */
 export declare const ImportParseDiagnostic: z.ZodObject<{
     /**
@@ -677,11 +680,11 @@ export type UnknownParamDiagnostic = z.infer<typeof UnknownParamDiagnostic>;
 /**
  * A declaration `name` appears in more than one module.
  *
- * Library docs assume a flat namespace — two modules exporting the same name
- * collide when consumers `import {name}`. Emitted at `warning` severity so
- * the analysis result remains usable; consumers who want it fatal can promote
- * via `onDuplicates: 'throw'` or by inspecting the diagnostic. The default
- * slot (`name === 'default'`) is excluded — every module owns its own.
+ * Opt-in: emitted only when `onDuplicates` is set, for packages that keep a
+ * flat export namespace (see `OnDuplicates`). Emitted at `warning` severity
+ * so the analysis result remains usable; `onDuplicates: 'throw'` makes it
+ * fatal. The default slot (`name === 'default'`) is excluded — every module
+ * owns its own.
  */
 export declare const DuplicateDeclarationDiagnostic: z.ZodObject<{
     /** The duplicated declaration name. */

package/dist/diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostics.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/diagnostics.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/diagnostics.ts"],"names":[],"mappings":"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"}

package/dist/diagnostics.js

@@ -240,7 +240,10 @@ export const ModuleUnreadableDiagnostic = z.strictObject({
     ...baseDiagnosticFields
 });
 /**
- * Import parsing failed during dependency resolution.
+ * Import scanning threw during dependency resolution.
+ *
+ * Not expected in practice: the parse in `lexImports` tolerates malformed
+ * source rather than rejecting it, so this guards an unexpected throw.
  */
 export const ImportParseDiagnostic = z.strictObject({
     kind: z.literal('import_parse_failed'),
@@ -315,11 +318,11 @@ export const UnknownParamDiagnostic = z.strictObject({
 /**
  * A declaration `name` appears in more than one module.
  *
- * Library docs assume a flat namespace — two modules exporting the same name
- * collide when consumers `import {name}`. Emitted at `warning` severity so
- * the analysis result remains usable; consumers who want it fatal can promote
- * via `onDuplicates: 'throw'` or by inspecting the diagnostic. The default
- * slot (`name === 'default'`) is excluded — every module owns its own.
+ * Opt-in: emitted only when `onDuplicates` is set, for packages that keep a
+ * flat export namespace (see `OnDuplicates`). Emitted at `warning` severity
+ * so the analysis result remains usable; `onDuplicates: 'throw'` makes it
+ * fatal. The default slot (`name === 'default'`) is excluded — every module
+ * owns its own.
  */
 export const DuplicateDeclarationDiagnostic = z.strictObject({
     kind: z.literal('duplicate_declaration'),

package/dist/index.d.ts

@@ -10,8 +10,8 @@
  */
 export { analyze, analyzeFromFiles } from './analyze.js';
 export type { AnalyzeOptions, AnalyzeFromFilesOptions } from './analyze.js';
-export { throwOnDuplicates, AnalyzeResultJson } from './analyze-core.js';
-export type { AnalyzeResultJsonWire, OnDuplicates, OnDuplicatesCallback } from './analyze-core.js';
+export { AnalyzeResultJson } from './analyze-core.js';
+export type { AnalyzeResultJsonWire, OnDuplicates } from './analyze-core.js';
 export { createAnalysisSession } from './session.js';
 export type { AnalysisSession, AnalysisSessionOptions, SetFileOptions, SetFileResult, SetFilesResult, QueryOptions } from './session.js';
 export { normalizeResolveImport } from './dep-resolver.js';
@@ -23,8 +23,8 @@ export { getDefaultAnalyzer } from './source.js';
 export type { SourceFileInfo, AnalyzerType } from './source.js';
 export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
 export type { ExcludeOption, ModuleSourceOptions, SourceOptionsDefaults, SourceOptionsOverrides } from './source-config.js';
-export { findDuplicates, mergeReExports, resolveComponentAliases, resolveExportSurface } from './postprocess.js';
-export type { DuplicateDeclaration, ExportSurface, ExportSurfaceEntry } from './postprocess.js';
+export { mergeReExports, resolveComponentAliases, resolveExportSurface } from './postprocess.js';
+export type { ExportSurface, ExportSurfaceEntry } from './postprocess.js';
 export { deriveIncludePatterns } from './files.js';
 export { discoverSourceFiles } from './discovery.js';
 export type { Discovery, DiscoverSourceFilesOptions, DiscoverSourceFilesResult } from './discovery.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzD,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EAAE,qBAAqB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EACX,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIxF,OAAO,EACN,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,UAAU,EACV,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,cAAc,EACd,cAAc,EACd,eAAe,EACf,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAI9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjF,YAAY,EACX,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EACN,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAIhG,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAInD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,YAAY,EACX,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,EACzB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzD,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EACX,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIxF,OAAO,EACN,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,UAAU,EACV,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,cAAc,EACd,cAAc,EACd,eAAe,EACf,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAI9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjF,YAAY,EACX,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACjG,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAInD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,YAAY,EACX,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,EACzB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -10,7 +10,7 @@
  */
 // Core entry points
 export { analyze, analyzeFromFiles } from './analyze.js';
-export { throwOnDuplicates, AnalyzeResultJson } from './analyze-core.js';
+export { AnalyzeResultJson } from './analyze-core.js';
 export { createAnalysisSession } from './session.js';
 export { normalizeResolveImport } from './dep-resolver.js';
 // Types (Zod schemas + TypeScript interfaces)
@@ -22,7 +22,7 @@ export { getDefaultAnalyzer } from './source.js';
 // Source options
 export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
 // Post-processing
-export { findDuplicates, mergeReExports, resolveComponentAliases, resolveExportSurface } from './postprocess.js';
+export { mergeReExports, resolveComponentAliases, resolveExportSurface } from './postprocess.js';
 // File system helpers
 export { deriveIncludePatterns } from './files.js';
 // File discovery

package/dist/postprocess.d.ts

@@ -3,7 +3,7 @@
  *
  * These functions transform analysis results after module-level analysis is complete:
  *
- * 1. **Validation** — `findDuplicates` checks flat namespace constraints
+ * 1. **Validation** — `findDuplicates` checks the opt-in flat-namespace constraint
  * 2. **Transformation** — `mergeReExports` resolves re-export relationships,
  *    `resolveComponentAliases` fills component aliases from their canonicals,
  *    `computeDependents` builds bidirectional dependency graphs
@@ -42,22 +42,14 @@ export interface DuplicateDeclaration {
  * (`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).
+ * The analysis entry points run this only under the opt-in `onDuplicates`.
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
  *
  * @example
  * ```ts
  * const duplicates = findDuplicates(modules);
- * if (duplicates.size > 0) {
- *   for (const [name, occurrences] of duplicates) {
- *     console.error(`"${name}" found in:`);
- *     for (const {declaration, module} of occurrences) {
- *       console.error(`  - ${module}:${declaration.sourceLine} (${declaration.kind})`);
- *     }
- *   }
- *   throw new Error(`Found ${duplicates.size} duplicate declaration names`);
- * }
+ * duplicates.get('parse'); // [{declaration, module: 'a.ts'}, {declaration, module: 'b.ts'}]
  * ```
  */
 export declare const findDuplicates: (modules: Array<ModuleJson>) => Map<string, Array<DuplicateDeclaration>>;

package/dist/postprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAA4B,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA0ClD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAwCzC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAMrD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAsC3E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,uBAAuB,GACnC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,iBAAgB,aAAa,CAAC,UAAU,CAAM,KAC5C,KAAK,CAAC,UAAU,CA4DlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,CAwD/D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,GAAG,EAAE,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IACtD,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,oFAAoF;IACpF,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,qBAAqB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,MAAM,MAAM,KACV,aAAa,GAAG,IA+IlB,CAAC"}
+{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAA4B,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA0ClD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AA6CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAwCzC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAMrD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAsC3E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,uBAAuB,GACnC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,iBAAgB,aAAa,CAAC,UAAU,CAAM,KAC5C,KAAK,CAAC,UAAU,CA4DlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,CAwD/D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,GAAG,EAAE,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IACtD,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,oFAAoF;IACpF,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,qBAAqB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,MAAM,MAAM,KACV,aAAa,GAAG,IA+IlB,CAAC"}

package/dist/postprocess.js

@@ -3,7 +3,7 @@
  *
  * These functions transform analysis results after module-level analysis is complete:
  *
- * 1. **Validation** — `findDuplicates` checks flat namespace constraints
+ * 1. **Validation** — `findDuplicates` checks the opt-in flat-namespace constraint
  * 2. **Transformation** — `mergeReExports` resolves re-export relationships,
  *    `resolveComponentAliases` fills component aliases from their canonicals,
  *    `computeDependents` builds bidirectional dependency graphs
@@ -106,22 +106,14 @@ const resolveCanonicalIdentity = (byIdentity, modulePath, declaration) => {
  * (`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).
+ * The analysis entry points run this only under the opt-in `onDuplicates`.
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
  *
  * @example
  * ```ts
  * const duplicates = findDuplicates(modules);
- * if (duplicates.size > 0) {
- *   for (const [name, occurrences] of duplicates) {
- *     console.error(`"${name}" found in:`);
- *     for (const {declaration, module} of occurrences) {
- *       console.error(`  - ${module}:${declaration.sourceLine} (${declaration.kind})`);
- *     }
- *   }
- *   throw new Error(`Found ${duplicates.size} duplicate declaration names`);
- * }
+ * duplicates.get('parse'); // [{declaration, module: 'a.ts'}, {declaration, module: 'b.ts'}]
  * ```
  */
 export const findDuplicates = (modules) => {

package/dist/session.d.ts

@@ -114,7 +114,7 @@ export interface SetFilesResult {
  * Per-call input to `query`.
  */
 export interface QueryOptions {
-    /** Behavior when duplicate declaration names are found across modules. */
+    /** Opt-in check that declaration names are unique across modules (see `OnDuplicates`). */
     onDuplicates?: OnDuplicates;
     /** Per-call logger override (defaults to the session-level logger). */
     log?: AnalysisLog;
@@ -352,7 +352,7 @@ export interface AnalysisSessionOptions extends Omit<AnalysisLanguageServiceOpti
  * const session = createAnalysisSession({sourceOptions, contextClosure: false});
  * try {
  *   await session.setFiles(sourceFiles);
- *   return session.query({onDuplicates: 'throw'});
+ *   return session.query();
  * } finally {
  *   session.dispose();
  * }

package/dist/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/session.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/session.ts"],"names":[],"mappings":"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"}

package/dist/session.js

@@ -40,7 +40,7 @@ import ts from 'typescript';
 import { createAnalysisLanguageService, createOwnedDirIndex } from './typescript-program.js';
 import { toErrorMessage } from './error.js';
 import { transformSvelteSource } from './svelte.js';
-import { createDefaultResolver, ensureLexerReady, isNodeBuiltin, lexImports, normalizeResolveImport } from './dep-resolver.js';
+import { createDefaultResolver, isNodeBuiltin, lexImports, normalizeResolveImport } from './dep-resolver.js';
 import { hasBaselineExcludedSegment, isSource, normalizeSourceOptions } from './source-config.js';
 import { toPosixPath } from './paths.js';
 import { MAX_FILE_CONCURRENCY, MAX_RESOLVE_CONCURRENCY, mapConcurrent } from './concurrency.js';
@@ -89,7 +89,7 @@ const arraysShallowEqual = (a, b) => {
  * const session = createAnalysisSession({sourceOptions, contextClosure: false});
  * try {
  *   await session.setFiles(sourceFiles);
- *   return session.query({onDuplicates: 'throw'});
+ *   return session.query();
  * } finally {
  *   session.dispose();
  * }
@@ -247,15 +247,16 @@ export const createAnalysisSession = (options) => {
             }
         }
         // Lex import specifiers — skipped when caller supplied pre-resolved deps.
-        // Sync — caller awaited ensureLexerReady. CSS/JSON files have nothing to
-        // lex; transform_failed Svelte has no virtual content to lex.
+        // CSS/JSON files have nothing to lex; transform_failed Svelte has no
+        // virtual content to lex. The parse tolerates malformed source, so the
+        // catch only guards an unexpected throw.
         let specifiers = [];
         if (!usePreResolved &&
             !transformFailed &&
             (analyzer === 'typescript' || analyzer === 'svelte')) {
             try {
                 const contentToLex = virtual ? virtual.content : file.content;
-                specifiers = lexImports(contentToLex, file.id);
+                specifiers = lexImports(contentToLex);
             }
             catch (err) {
                 ingestDiagnostics.push({
@@ -393,7 +394,6 @@ export const createAnalysisSession = (options) => {
     // batch's posixified resolved import targets before any `isSource`
     // filtering — the context-closure seed; never stored on entries.
     const runBatch = async (files, opts) => {
-        await ensureLexerReady();
         // Resolver gating: pick one only if any file in the batch lacks
         // `dependencies` (i.e., needs lex+resolve). For fully pre-resolved
         // batches the resolver is never consulted, so we skip `pickResolver`

package/dist/source.d.ts

@@ -59,12 +59,10 @@ export interface SourceFileInfo {
      * supply this field own the correctness of the graph they hand over.
      *
      * Type-only imports (`import type {...}`) are the most common asymmetry
-     * versus the lex+resolve path: the default lex (`es-module-lexer`) keeps
-     * `import type` and inline `type` specifiers; pre-resolved callers backed
-     * by a Gro-style filer typically drop them. Both are intentional within
-     * their respective contracts. The default lex does drop type-only
-     * re-exports (see `lexImports`), so such a re-export has a `reExports`
-     * edge with no `dependencies` entry and seeds no context closure.
+     * versus the lex+resolve path: the default lex (`lexImports`) keeps
+     * type-only imports and re-exports; pre-resolved callers backed by a
+     * Gro-style filer typically drop them. Both are intentional within their
+     * respective contracts.
      *
      * Cache semantics: the session compares this array element-wise (shallow
      * equality) against the snapshot stored from the prior call — a fresh

package/dist/source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC9B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,YAAY,GAAG,IAMhE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,KAAG,MACG,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,OAC8B,CAAC;AAE3E,kDAAkD;AAClD,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,OAAmC,CAAC;AAE5E,qCAAqC;AACrC,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,OAAgC,CAAC;AAEtE,sCAAsC;AACtC,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,OAAiC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,uBAAuB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MACyC,CAAC;AAE5F,wFAAwF;AACxF,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,OAA+C,CAAC;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MACqC,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,uBAAuB,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,OAGP,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,MAAM,KAAG,OACV,CAAC"}
+{"version":3,"file":"source.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC9B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,YAAY,GAAG,IAMhE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,KAAG,MACG,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,OAC8B,CAAC;AAE3E,kDAAkD;AAClD,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,OAAmC,CAAC;AAE5E,qCAAqC;AACrC,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,OAAgC,CAAC;AAEtE,sCAAsC;AACtC,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,OAAiC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,uBAAuB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MACyC,CAAC;AAE5F,wFAAwF;AACxF,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,OAA+C,CAAC;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MACqC,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,uBAAuB,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,OAGP,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,MAAM,KAAG,OACV,CAAC"}

package/dist/vite.d.ts

@@ -89,7 +89,7 @@ export interface VitePluginSvelteDocinfoOptions {
      * Partial overrides for default source options (SvelteKit `src/lib` layout).
      */
     sourceOptions?: SourceOptionsOverrides;
-    /** Behavior when duplicate declaration names are found across modules. */
+    /** Opt-in check that declaration names are unique across modules (see `OnDuplicates`). */
     onDuplicates?: OnDuplicates;
     /**
      * Dev re-analysis debounce delay in milliseconds. Coalesces rapid file changes.

package/dist/vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAqC,MAAM,EAAiB,MAAM,MAAM,CAAC;AAGrF,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKrE,OAAO,EAGN,KAAK,aAAa,EAElB,KAAK,sBAAsB,EAC3B,MAAM,oBAAoB,CAAC;AAU5B,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC9C;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,0EAA0E;IAC1E,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,UAAS,8BAAmC,KAAG,MAodrE,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAqC,MAAM,EAAiB,MAAM,MAAM,CAAC;AAGrF,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKrE,OAAO,EAGN,KAAK,aAAa,EAElB,KAAK,sBAAsB,EAC3B,MAAM,oBAAoB,CAAC;AAU5B,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC9C;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,0FAA0F;IAC1F,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,UAAS,8BAAmC,KAAG,MAodrE,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-docinfo",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "static analysis for TypeScript and Svelte",
   "glyph": "📜",
   "logo": "logo.svg",
@@ -43,7 +43,6 @@
   "dependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",
     "commander": "^14.0.3",
-    "es-module-lexer": "^2.0.0",
     "picomatch": "^4.0.4",
     "tinyglobby": "^0.2.15"
   },
@@ -61,11 +60,11 @@
   },
   "devDependencies": {
     "@fuzdev/blake3-wasm": "^0.2.0",
-    "@fuzdev/fuz_code": "^0.50.0",
+    "@fuzdev/fuz_code": "^0.52.1",
     "@fuzdev/fuz_css": "^0.66.1",
     "@fuzdev/fuz_ui": "^0.213.0",
     "@fuzdev/fuz_util": "^0.72.0",
-    "@fuzdev/gro": "^0.215.1",
+    "@fuzdev/gro": "^0.216.0",
     "@fuzdev/mdz": "^0.4.0",
     "@ryanatkn/eslint-config": "^0.13.0",
     "@sveltejs/acorn-typescript": "^1.0.9",