svelte-docinfo 0.5.4 → 0.6.0

package/dist/diagnostics.d.ts

@@ -51,9 +51,14 @@
  * ## File Path Contract
  *
  * `Diagnostic.file` is always project-root-relative — no leading slash,
- * no `./` prefix. `analyze` / `analyzeFromFiles` normalize paths from all
- * sources (extraction, discovery, dependency resolution) before returning.
- * Consumers that need an absolute path can rejoin with `projectRoot`.
+ * no `./` prefix. `analyze` / `analyzeFromFiles` and the session
+ * (`setFile`/`setFiles` at ingest, `query` at analysis) normalize paths from
+ * all sources (extraction, discovery, dependency resolution) before
+ * returning. Consumers that need an absolute path can rejoin with
+ * `projectRoot`.
+ *
+ * It names a *file*, not a module: `ModuleJson.path` is relative to
+ * `sourceRoot`, so `file` is not a lookup key into `modules`.
  *
  * @module
  */
@@ -77,6 +82,7 @@ export declare const DiagnosticKind: z.ZodEnum<{
     signature_analysis_failed: "signature_analysis_failed";
     class_member_failed: "class_member_failed";
     svelte_prop_failed: "svelte_prop_failed";
+    legacy_props: "legacy_props";
     module_skipped: "module_skipped";
     module_unreadable: "module_unreadable";
     import_parse_failed: "import_parse_failed";
@@ -87,6 +93,7 @@ export declare const DiagnosticKind: z.ZodEnum<{
     duplicate_declaration: "duplicate_declaration";
     transform_failed: "transform_failed";
     resolver_failed: "resolver_failed";
+    alias_lost: "alias_lost";
 }>;
 export type DiagnosticKind = z.infer<typeof DiagnosticKind>;
 /**
@@ -104,6 +111,21 @@ export declare const TypeExtractionDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -134,6 +156,21 @@ export declare const SignatureAnalysisDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -166,6 +203,21 @@ export declare const ClassMemberDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -183,6 +235,13 @@ export declare const ClassMemberDiagnostic: z.ZodObject<{
 export type ClassMemberDiagnostic = z.infer<typeof ClassMemberDiagnostic>;
 /**
  * Svelte prop type resolution failed.
+ *
+ * `file` is the original `.svelte` path, so `line`/`column` are present only
+ * when the prop's declaration lives in the component's own virtual *and* maps
+ * back to the original source — an imported props type or a node svelte2tsx
+ * synthesized leaves the position absent rather than publishing a virtual
+ * line, the rule `remapVirtualDiagnosticPositions` applies to extractor
+ * diagnostics.
  */
 export declare const SveltePropDiagnostic: z.ZodObject<{
     /** Name of the component. */
@@ -198,6 +257,21 @@ export declare const SveltePropDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -213,6 +287,60 @@ export declare const SveltePropDiagnostic: z.ZodObject<{
     kind: z.ZodLiteral<"svelte_prop_failed">;
 }, z.core.$strict>;
 export type SveltePropDiagnostic = z.infer<typeof SveltePropDiagnostic>;
+/**
+ * Legacy (runes-less) component props detected — not extracted.
+ *
+ * `export let` components are still-legal Svelte 5 syntax, but prop extraction
+ * anchors on the `$props()` declaration, so their props yield no
+ * `ComponentPropJson` entries. Emitted once per component, listing the
+ * detected prop names — exported `let`/`var` statements plus export-clause
+ * renames of mutable bindings (`export {a as b}`) — with `line` pointing at
+ * the first legacy prop export in the original `.svelte` source.
+ */
+export declare const LegacyPropsDiagnostic: z.ZodObject<{
+    /** Name of the component. */
+    componentName: z.ZodString;
+    /** Exported prop names, in source order. */
+    propNames: z.ZodArray<z.ZodString>;
+    /**
+     * File path relative to project root (no leading slash, no `./` prefix).
+     *
+     * Normalized at every public API boundary — `session.setFile`/`setFiles`
+     * (ingest-time), `session.query` (query-time, via `analyzeCore`), and the
+     * one-shot wrappers `analyze` / `analyzeFromFiles`. Producers inside the
+     * pipeline may write absolute or virtual paths (e.g.,
+     * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
+     * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
+     */
+    file: z.ZodString;
+    /** Line number (1-based), absent if location unavailable. */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Column number (1-based), absent if location unavailable. */
+    column: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable description of the issue. */
+    message: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    kind: z.ZodLiteral<"legacy_props">;
+}, z.core.$strict>;
+export type LegacyPropsDiagnostic = z.infer<typeof LegacyPropsDiagnostic>;
 /**
  * Module was skipped during the analysis pass.
  *
@@ -243,6 +371,21 @@ export declare const ModuleSkippedDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -276,6 +419,21 @@ export declare const ModuleUnreadableDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -304,6 +462,21 @@ export declare const ImportParseDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -338,6 +511,21 @@ export declare const DuplicateCommentDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -359,8 +547,9 @@ export type DuplicateCommentDiagnostic = z.infer<typeof DuplicateCommentDiagnost
  * Two contexts emit this:
  *
  * - **Non-primary overload signature** — symbol-scope tags (`@example`,
- *   `@deprecated`, `@since`, `@see`, `@throws`, `@mutates`, `@default`,
- *   `@nodocs`) describe the function as a whole, not individual signatures.
+ *   `@deprecated`, `@internal`, `@since`, `@see`, `@throws`, `@mutates`,
+ *   `@default`, `@nodocs`) describe the function as a whole, not individual
+ *   signatures.
  *   The primary signature's JSDoc feeds the parent declaration's symbol-level
  *   extraction; tags on non-primary overload signatures are silently dropped
  *   from output. This diagnostic surfaces them so authors can move them to
@@ -376,17 +565,19 @@ export declare const MisplacedTagDiagnostic: z.ZodObject<{
     /** The tag name without the `@` prefix (e.g., `'example'`, `'deprecated'`). */
     tagName: z.ZodEnum<{
         default: "default";
+        deprecated: "deprecated";
         throws: "throws";
         since: "since";
         mutates: "mutates";
-        deprecated: "deprecated";
         example: "example";
+        internal: "internal";
         see: "see";
         nodocs: "nodocs";
     }>;
     /**
-     * Name of the function or method whose overload carries the misplaced tag.
-     * Absent for module-comment misplacements (no enclosing symbol).
+     * Name of the enclosing symbol: the function or method whose overload
+     * carries the misplaced tag. Absent for module-comment misplacements (no
+     * enclosing symbol).
      */
     functionName: z.ZodOptional<z.ZodString>;
     /**
@@ -398,6 +589,21 @@ export declare const MisplacedTagDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -433,6 +639,21 @@ export declare const UnknownParamDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -460,7 +681,14 @@ export type UnknownParamDiagnostic = z.infer<typeof UnknownParamDiagnostic>;
 export declare const DuplicateDeclarationDiagnostic: z.ZodObject<{
     /** The duplicated declaration name. */
     declarationName: z.ZodString;
-    /** Module paths where the name was defined (>= 2). */
+    /**
+     * Module paths where the name was defined (>= 2).
+     *
+     * `ModuleJson.path` values — relative to `sourceRoot`, so a different base
+     * than the record's `file` (project-root-relative, like every diagnostic).
+     * The two disagree textually whenever `sourceRoot` is non-empty; each names
+     * what it says it names, a module vs. a file.
+     */
     modules: z.ZodArray<z.ZodString>;
     /**
      * File path relative to project root (no leading slash, no `./` prefix).
@@ -471,6 +699,21 @@ export declare const DuplicateDeclarationDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -489,10 +732,12 @@ export type DuplicateDeclarationDiagnostic = z.infer<typeof DuplicateDeclaration
 /**
  * Source map parsing failed for a Svelte virtual file.
  *
- * Analysis continues using virtual-file positions, so downstream `line`/`column`
- * fields on other diagnostics may point into the svelte2tsx-generated TS rather
- * than the original `.svelte` source. Rare; usually signals a malformed or
- * incompatible svelte2tsx output.
+ * Analysis continues without position mapping: query-time diagnostics drop
+ * `line`/`column` rather than point into svelte2tsx-generated TS — those
+ * emitted against the virtual via `remapVirtualDiagnosticPositions`,
+ * `svelte_prop_failed` at its own emission site — while declaration
+ * `sourceLine`s fall back to virtual positions. Rare; usually signals a
+ * malformed or incompatible svelte2tsx output.
  *
  * Emitted at ingest time by `transformSvelteSource` (in `svelte.ts`); flows
  * through `setFile`/`setFiles` ingest diagnostics rather than the analysis
@@ -508,6 +753,21 @@ export declare const SourceMapFailedDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -542,6 +802,21 @@ export declare const TransformFailedDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -580,6 +855,21 @@ export declare const ResolverFailedDiagnostic: z.ZodObject<{
      * pipeline may write absolute or virtual paths (e.g.,
      * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
      * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
      */
     file: z.ZodString;
     /** Line number (1-based), absent if location unavailable. */
@@ -595,6 +885,65 @@ export declare const ResolverFailedDiagnostic: z.ZodObject<{
     kind: z.ZodLiteral<"resolver_failed">;
 }, z.core.$strict>;
 export type ResolverFailedDiagnostic = z.infer<typeof ResolverFailedDiagnostic>;
+/**
+ * An exported type alias loses its name at use sites.
+ *
+ * The alias's right-hand side (an indexed access or conditional —
+ * `z.infer<typeof S>`, valibot's `InferOutput`) resolves to a pre-existing
+ * interned type that TypeScript never retroactively stamps an alias symbol
+ * on, so unannotated positions document the expansion instead of the name.
+ * Fires only where nothing self-heals: a loss the alias registry recovers
+ * (`typeInfo` emits `{kind: 'reference', name}` at use sites) is suppressed,
+ * as are literal-only unions (`z.enum` outputs) and brand-like intersections
+ * (`.brand()`) — readable degradations with no author-side fix worth
+ * demanding. `@nodocs` on the declaration suppresses. The author-side escape
+ * for a flagged alias is a nominal symbol, e.g.
+ * `interface Foo extends z.infer<typeof S> {}` where applicable.
+ *
+ * Always `warning`, query-time category (recomputed each `query()`).
+ */
+export declare const AliasLostDiagnostic: z.ZodObject<{
+    /** Name of the alias whose right-hand side resolves to a nameless type. */
+    aliasName: z.ZodString;
+    /**
+     * File path relative to project root (no leading slash, no `./` prefix).
+     *
+     * Normalized at every public API boundary — `session.setFile`/`setFiles`
+     * (ingest-time), `session.query` (query-time, via `analyzeCore`), and the
+     * one-shot wrappers `analyze` / `analyzeFromFiles`. Producers inside the
+     * pipeline may write absolute or virtual paths (e.g.,
+     * `Foo.svelte.__svelte2tsx__.ts`); normalization rewrites them to
+     * project-relative form before they reach consumers.
+     *
+     * The exception is **discovery** — `discoverSourceFiles` /
+     * `discoverFromExports` return their diagnostics unnormalized, since they
+     * run before any session exists. Their `file` is already
+     * project-root-relative, but `message` can embed an absolute path (an fs
+     * error names the file it failed on), so a consumer wiring discovery up
+     * itself owns the `normalizeDiagnosticPaths` call — `analyzeFromFiles` and
+     * the Vite plugin both make it before merging.
+     *
+     * **The absolute form is the one to write.** Normalization deliberately
+     * leaves an already-relative path alone (relativizing it would resolve
+     * against `cwd`), so a producer writing a `ModuleJson.path` — relative to
+     * `sourceRoot`, a different base — passes through untouched and publishes
+     * the same file under a second name. Absolute is what the pass can
+     * actually correct.
+     */
+    file: z.ZodString;
+    /** Line number (1-based), absent if location unavailable. */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Column number (1-based), absent if location unavailable. */
+    column: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable description of the issue. */
+    message: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    kind: z.ZodLiteral<"alias_lost">;
+}, z.core.$strict>;
+export type AliasLostDiagnostic = z.infer<typeof AliasLostDiagnostic>;
 /**
  * Discriminated union of all diagnostic variants.
  */
@@ -603,6 +952,7 @@ export declare const Diagnostic: z.ZodDiscriminatedUnion<[
     typeof SignatureAnalysisDiagnostic,
     typeof ClassMemberDiagnostic,
     typeof SveltePropDiagnostic,
+    typeof LegacyPropsDiagnostic,
     typeof ModuleSkippedDiagnostic,
     typeof ModuleUnreadableDiagnostic,
     typeof ImportParseDiagnostic,
@@ -612,7 +962,8 @@ export declare const Diagnostic: z.ZodDiscriminatedUnion<[
     typeof SourceMapFailedDiagnostic,
     typeof DuplicateDeclarationDiagnostic,
     typeof TransformFailedDiagnostic,
-    typeof ResolverFailedDiagnostic
+    typeof ResolverFailedDiagnostic,
+    typeof AliasLostDiagnostic
 ], 'kind'>;
 export type Diagnostic = z.infer<typeof Diagnostic>;
 /**

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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"}