svelte-docinfo 0.7.0 → 0.8.0

package/dist/postprocess.d.ts

@@ -5,14 +5,18 @@
  *
  * 1. **Validation** — `findDuplicates` checks flat namespace constraints
  * 2. **Transformation** — `mergeReExports` resolves re-export relationships,
+ *    `resolveComponentAliases` fills component aliases from their canonicals,
  *    `computeDependents` builds bidirectional dependency graphs
- * 3. **Output** — `sortModules` prepares deterministic output
+ * 3. **Output** — `sortModules` prepares deterministic output (`compareStrings`
+ *    is the one comparator for all output ordering)
+ * 4. **Queries** — `resolveExportSurface` combines a module's declarations and
+ *    re-export facts into its full export surface
  *
  * Every function here is pure — transformation passes return new arrays with
  * structural sharing (unchanged objects flow through `===`-equal) and never
  * mutate their input.
  *
- * @see `analyze.ts` for the main analysis entry point
+ * @see `analyze-core.ts` for the phase-2 pipeline that runs these
  *
  * @module
  */
@@ -137,6 +141,9 @@ export declare const mergeReExports: (modules: Array<ModuleJson>) => Array<Modul
  * are shared by reference, not cloned); everything else flows through
  * `===`-equal.
  *
+ * Doc-comment fields fill gaps only: local doc fields applied to the alias
+ * before phase 2 (from JSDoc on the re-export statement) stick.
+ *
  * @param modules - the analyzed modules (parsed `ModuleJson`s)
  * @param contextModules - canonical-lookup-only modules that never appear in
  *   output — gated component canonicals (the `internal/` convention) analyzed
@@ -150,10 +157,10 @@ export declare const resolveComponentAliases: (modules: Array<ModuleJson>, conte
 /**
  * Compute bidirectional dependencies from source files.
  *
- * This function ensures that if file A has file B in its `dependencies`,
- * then file B will have file A in its `dependents`. This provides consistent
- * output regardless of whether callers provide one-directional or bidirectional
- * dependency information.
+ * If file A has file B in its `dependencies`, file B gets file A in its
+ * `dependents`. Dependents are derived solely from the forward `dependencies`
+ * edges within `files` (`SourceFileInfo` carries no `dependents` field);
+ * edges to files outside the set are ignored.
  *
  * Returns new `SourceFileInfo` objects when computed dependents exist or when
  * paths needed posixification; otherwise the original input objects flow

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;;;;;;;;;;;;;;;;;GAiBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/postprocess.js

@@ -5,14 +5,18 @@
  *
  * 1. **Validation** — `findDuplicates` checks flat namespace constraints
  * 2. **Transformation** — `mergeReExports` resolves re-export relationships,
+ *    `resolveComponentAliases` fills component aliases from their canonicals,
  *    `computeDependents` builds bidirectional dependency graphs
- * 3. **Output** — `sortModules` prepares deterministic output
+ * 3. **Output** — `sortModules` prepares deterministic output (`compareStrings`
+ *    is the one comparator for all output ordering)
+ * 4. **Queries** — `resolveExportSurface` combines a module's declarations and
+ *    re-export facts into its full export surface
  *
  * Every function here is pure — transformation passes return new arrays with
  * structural sharing (unchanged objects flow through `===`-equal) and never
  * mutate their input.
  *
- * @see `analyze.ts` for the main analysis entry point
+ * @see `analyze-core.ts` for the phase-2 pipeline that runs these
  *
  * @module
  */
@@ -281,6 +285,9 @@ export const mergeReExports = (modules) => {
  * are shared by reference, not cloned); everything else flows through
  * `===`-equal.
  *
+ * Doc-comment fields fill gaps only: local doc fields applied to the alias
+ * before phase 2 (from JSDoc on the re-export statement) stick.
+ *
  * @param modules - the analyzed modules (parsed `ModuleJson`s)
  * @param contextModules - canonical-lookup-only modules that never appear in
  *   output — gated component canonicals (the `internal/` convention) analyzed
@@ -356,10 +363,10 @@ export const resolveComponentAliases = (modules, contextModules = []) => {
 /**
  * Compute bidirectional dependencies from source files.
  *
- * This function ensures that if file A has file B in its `dependencies`,
- * then file B will have file A in its `dependents`. This provides consistent
- * output regardless of whether callers provide one-directional or bidirectional
- * dependency information.
+ * If file A has file B in its `dependencies`, file B gets file A in its
+ * `dependents`. Dependents are derived solely from the forward `dependencies`
+ * edges within `files` (`SourceFileInfo` carries no `dependents` field);
+ * edges to files outside the set are ignored.
  *
  * Returns new `SourceFileInfo` objects when computed dependents exist or when
  * paths needed posixification; otherwise the original input objects flow

package/dist/session.d.ts

@@ -9,11 +9,14 @@
  *   when content matches AND the mode-specific cache key matches (resolver
  *   identity for lex+resolve, dependency-snapshot equality for pre-resolved).
  * - `deleteFile` — drop owned entry, evict from LS.
- * - `has` / `list` — owned-set introspection (covers what consumers used to
- *   get from their own mirror caches).
- * - `query` — sync analysis pass against the current owned set; returns
- *   analysis-pass diagnostics only (ingest diagnostics surface via the
- *   `setFile`/`setFiles` returns).
+ * - `has` / `list` — owned-set introspection, so consumers need no mirror
+ *   cache of their own.
+ * - `query` — sync analysis pass against the source-gated owned set; returns
+ *   analysis-pass diagnostics only (ingest diagnostics come from the
+ *   `setFile`/`setFiles` returns, and cumulatively, context-closure ingest
+ *   included, from `allIngestDiagnostics`).
+ * - `getProgram` — the LS-backed `ts.Program`, for consumers doing their own
+ *   checker work.
  * - `dispose` — release LS resources.
  *
  * The session owns a single `Map<id, OwnedEntry>` covering content, svelte
@@ -21,7 +24,8 @@
  * or pre-resolved snapshot), and ingest-time diagnostics. svelte2tsx runs
  * at most once per content change. Resolver work parallelizes across the
  * batch in phase 2 of the three-phase setFiles pipeline; fully pre-resolved
- * batches skip phase 2 (and the default-resolver construction) entirely.
+ * batches skip phase 2 and the default-resolver construction (see
+ * `AnalysisSessionOptions.contextClosure` for the exception).
  * A batch that adds paths then retries the import specifiers earlier batches
  * couldn't resolve, since the file that settles one is the dep rather than
  * the importer (see `AnalysisSession` → Deferred resolutions).
@@ -41,10 +45,6 @@ import { type ModuleSourceOptions } from './source-config.js';
 import { AnalyzeResultJson, type OnDuplicates } from './analyze-core.js';
 /**
  * Options for a per-file or per-batch resolver override.
- *
- * Identity is required (not optional) — silently coalescing missing identities
- * to a function reference would destroy cache reuse when the same logical
- * resolver is wrapped in fresh closures across calls.
  */
 export interface SetFileOptions {
     /**
@@ -166,6 +166,20 @@ export interface QueryOptions {
  * in-root non-source dependency closure (e.g. `internal/` modules public
  * files import) so those files are version-tracked rather than pinned at
  * their first disk read.
+ *
+ * **Input order**: `query()` analyzes the owned set in `compareStrings` order
+ * of file ID, and the language-service host returns owned program roots in
+ * that order too, so the same files ingested in any order, in one batch or
+ * across many `setFile` calls, give identical output from a fresh session.
+ * Analysis order matters because TypeScript prints a union with no alias
+ * origin (`z.enum` members, literal unions) in type-creation order, which
+ * follows the order the checker first visits files; root order matters
+ * because it sets the merge order of `declare global`, module augmentations,
+ * and interface merging. Two limits remain, both from type-creation order:
+ * an edit to an unrelated file can still reorder such a union's members,
+ * since it can change which file first creates a member type, and checker
+ * work done through `getProgram()` before the first `query()` on a fresh
+ * program can reorder them in that query's output.
  */
 export interface AnalysisSession {
     /**
@@ -219,6 +233,10 @@ export interface AnalysisSession {
      * retained reference goes stale after any `setFile` / `setFiles` /
      * `deleteFile`; re-call after mutating. Subject to the session's
      * concurrency contract above; invalid after `dispose()`.
+     *
+     * Checker work done before `query()` on a fresh program can reorder
+     * origin-less unions in that query's output (see "Input order" above);
+     * call `query()` first.
      */
     getProgram(): ts.Program;
     /**
@@ -295,6 +313,11 @@ export interface AnalysisSessionOptions extends Omit<AnalysisLanguageServiceOpti
      * the Vite plugin, watched) for the session's lifetime, even when no
      * importer remains.
      *
+     * A context file created after its importer's last ingest becomes owned on
+     * the importer's next change only if its specifier re-resolves — with the
+     * default resolver a cached miss sticks until owned-set membership changes
+     * (the Vite dev resolver doesn't cache).
+     *
      * Set `false` only when the caller supplies every file the checker needs
      * (the internal `analyze()` wrapper does): TS/JS context is covered by the
      * LS disk fallback either way, but a gated `.svelte` dependency resolves
@@ -324,8 +347,9 @@ export interface AnalysisSessionOptions extends Omit<AnalysisLanguageServiceOpti
  *
  * @example One-shot via the public wrapper
  * ```ts
- * // Equivalent to `analyze(...)` — the wrapper goes through a session internally.
- * const session = createAnalysisSession({sourceOptions});
+ * // Equivalent to `analyze(...)` — the wrapper goes through a session internally
+ * // (and opts out of the context closure, since its callers supply the inputs).
+ * const session = createAnalysisSession({sourceOptions, contextClosure: false});
  * try {
  *   await session.setFiles(sourceFiles);
  *   return session.query({onDuplicates: 'throw'});

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

@@ -9,11 +9,14 @@
  *   when content matches AND the mode-specific cache key matches (resolver
  *   identity for lex+resolve, dependency-snapshot equality for pre-resolved).
  * - `deleteFile` — drop owned entry, evict from LS.
- * - `has` / `list` — owned-set introspection (covers what consumers used to
- *   get from their own mirror caches).
- * - `query` — sync analysis pass against the current owned set; returns
- *   analysis-pass diagnostics only (ingest diagnostics surface via the
- *   `setFile`/`setFiles` returns).
+ * - `has` / `list` — owned-set introspection, so consumers need no mirror
+ *   cache of their own.
+ * - `query` — sync analysis pass against the source-gated owned set; returns
+ *   analysis-pass diagnostics only (ingest diagnostics come from the
+ *   `setFile`/`setFiles` returns, and cumulatively, context-closure ingest
+ *   included, from `allIngestDiagnostics`).
+ * - `getProgram` — the LS-backed `ts.Program`, for consumers doing their own
+ *   checker work.
  * - `dispose` — release LS resources.
  *
  * The session owns a single `Map<id, OwnedEntry>` covering content, svelte
@@ -21,7 +24,8 @@
  * or pre-resolved snapshot), and ingest-time diagnostics. svelte2tsx runs
  * at most once per content change. Resolver work parallelizes across the
  * batch in phase 2 of the three-phase setFiles pipeline; fully pre-resolved
- * batches skip phase 2 (and the default-resolver construction) entirely.
+ * batches skip phase 2 and the default-resolver construction (see
+ * `AnalysisSessionOptions.contextClosure` for the exception).
  * A batch that adds paths then retries the import specifiers earlier batches
  * couldn't resolve, since the file that settles one is the dep rather than
  * the importer (see `AnalysisSession` → Deferred resolutions).
@@ -34,14 +38,14 @@
 import { readFile } from 'node:fs/promises';
 import ts from 'typescript';
 import { createAnalysisLanguageService, createOwnedDirIndex } from './typescript-program.js';
-import { to_error_message } from './error.js';
+import { toErrorMessage } from './error.js';
 import { transformSvelteSource } from './svelte.js';
 import { createDefaultResolver, ensureLexerReady, 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, map_concurrent } from './concurrency.js';
+import { MAX_FILE_CONCURRENCY, MAX_RESOLVE_CONCURRENCY, mapConcurrent } from './concurrency.js';
 import { analyzeCore, normalizeDiagnosticPaths, AnalyzeResultJson } from './analyze-core.js';
-import { computeDependents } from './postprocess.js';
+import { compareStrings, computeDependents } from './postprocess.js';
 /**
  * Element-wise equality on two readonly string arrays. Used for the
  * pre-resolved-deps cache key: a fresh array with identical contents
@@ -80,8 +84,9 @@ const arraysShallowEqual = (a, b) => {
  *
  * @example One-shot via the public wrapper
  * ```ts
- * // Equivalent to `analyze(...)` — the wrapper goes through a session internally.
- * const session = createAnalysisSession({sourceOptions});
+ * // Equivalent to `analyze(...)` — the wrapper goes through a session internally
+ * // (and opts out of the context closure, since its callers supply the inputs).
+ * const session = createAnalysisSession({sourceOptions, contextClosure: false});
  * try {
  *   await session.setFiles(sourceFiles);
  *   return session.query({onDuplicates: 'throw'});
@@ -153,8 +158,9 @@ export const createAnalysisSession = (options) => {
     // Lazy default resolver — only constructed when needed: a `setFiles` batch
     // has at least one file lacking `dependencies`, the call doesn't supply a
     // per-call override, and no session-default resolver was configured. Fully
-    // pre-resolved batches skip the construction entirely (see `needsResolver`
-    // gating below). Compiler options come from the LS handle — the session's
+    // pre-resolved batches skip the construction (see `needsResolver` gating
+    // below), though a context-closure batch can still trigger it, since
+    // context files always lex+resolve. Compiler options come from the LS handle — the session's
     // one tsconfig parse, at LS construction — so the resolver and the checker
     // see the same merged config. The TS module-resolution cache is kept on
     // the resolver so consecutive resolves share state.
@@ -255,7 +261,7 @@ export const createAnalysisSession = (options) => {
                 ingestDiagnostics.push({
                     kind: 'import_parse_failed',
                     file: file.id,
-                    message: `Failed to parse imports: ${to_error_message(err)}`,
+                    message: `Failed to parse imports: ${toErrorMessage(err)}`,
                     severity: 'warning'
                 });
             }
@@ -459,7 +465,7 @@ export const createAnalysisSession = (options) => {
             if (tasks.length > 0 && resolver === null) {
                 throw new Error('svelte-docinfo: phase-2 invariant violated — tasks pending without a resolver');
             }
-            const taskResults = await map_concurrent(tasks, MAX_RESOLVE_CONCURRENCY, async (t) => {
+            const taskResults = await mapConcurrent(tasks, MAX_RESOLVE_CONCURRENCY, async (t) => {
                 const pending = pendings[t.pendingIdx];
                 try {
                     const resolved = await resolver.resolve(t.specifier, pending.file.id);
@@ -478,7 +484,7 @@ export const createAnalysisSession = (options) => {
                     return {
                         ...t,
                         resolved: null,
-                        error: to_error_message(err)
+                        error: toErrorMessage(err)
                     };
                 }
             });
@@ -585,7 +591,7 @@ export const createAnalysisSession = (options) => {
         while (candidates.length > 0) {
             for (const c of candidates)
                 attempted.add(c);
-            const loaded = await map_concurrent(candidates, MAX_FILE_CONCURRENCY, async (id) => {
+            const loaded = await mapConcurrent(candidates, MAX_FILE_CONCURRENCY, async (id) => {
                 try {
                     return { id, content: await readFile(id, 'utf-8') };
                 }
@@ -627,11 +633,13 @@ export const createAnalysisSession = (options) => {
     // `runBatch` cleared those at the top.
     //
     // A settled slot also retires the `resolver_failed` its ingest emitted, if
-    // any — the claim was true then and isn't now. Two margins remain, both
-    // self-healing on the importer's next ingest: a resolver that throws *here*
-    // leaves the slot deferred and its original diagnostic standing, and a
-    // newly-resolved edge pointing at an in-root non-source file doesn't itself
-    // seed a context-closure round.
+    // any — the claim was true then and isn't now. Gaps, each corrected only on
+    // the importer's next content change: a resolver that throws *here* leaves
+    // the slot deferred with its original diagnostic standing; a newly resolved
+    // edge to an in-root non-source file doesn't seed a context-closure round;
+    // and an owned file *shadowing* a target that already resolved from disk
+    // (`dep.ts` displacing `dep.js`) is outside this pass entirely, since the
+    // entry has no deferred slot to retry.
     const healUnresolvedEdges = async (opts) => {
         // A scan of the owned set rather than a side index of deferred entries:
         // it can't desync, and it only runs on a batch that added paths.
@@ -657,7 +665,7 @@ export const createAnalysisSession = (options) => {
         }
         if (retries.length === 0)
             return;
-        const results = await map_concurrent(retries, MAX_RESOLVE_CONCURRENCY, async (r) => {
+        const results = await mapConcurrent(retries, MAX_RESOLVE_CONCURRENCY, async (r) => {
             try {
                 const resolved = await resolver.resolve(r.entry.unresolved.specifiers[r.slot], r.id);
                 return { ...r, resolved: resolved === null ? null : toPosixPath(resolved) };
@@ -781,7 +789,14 @@ export const createAnalysisSession = (options) => {
         const contextSvelteFiles = [];
         const svelteVirtualFiles = new Map();
         const transformFailedIds = new Set();
-        for (const [id, entry] of owned) {
+        // Analysis order is sorted, not ingest order, so output is a function of
+        // the owned file set. TypeScript prints a union with no alias origin
+        // (`z.enum` members, literal unions) in type-creation order, so the
+        // order the checker first visits files in reorders those members;
+        // ingest order varies with the filesystem crawl and with which files
+        // an incremental session received first.
+        const ownedSorted = [...owned].sort((a, b) => compareStrings(a[0], b[0]));
+        for (const [id, entry] of ownedSorted) {
             if (!emittedIds.has(id)) {
                 // Gated Svelte file with a good virtual (context closure, or a
                 // caller-pushed input): offered to `analyzeCore` as canonical-fill

package/dist/source-config.d.ts

@@ -3,10 +3,10 @@
  *
  * Provides `ModuleSourceOptions` configuration management and functions
  * that operate on source files using those options: path extraction,
- * source detection, dependency filtering, and file collection.
+ * source detection, dependency filtering, include-pattern widening, and
+ * glob-pattern normalization.
  *
  * @see `source.ts` for pure file type predicates (`isTypescript`, `isSvelte`, etc.)
- * @see `analyze.ts` for consumers (`analyze`, `analyzeFromFiles`)
  *
  * @module
  */
@@ -100,8 +100,7 @@ export interface ModuleSourceOptions {
      * Applied at both stages of the pipeline:
      * - **Discovery time** by `globFiles`/`discoverFromExports`, preventing matched files from being loaded.
      * - **Analysis time** by `isSource()` against `relative(projectRoot, absolutePath)`,
-     *   catching files that enter through TypeScript import resolution
-     *   (e.g., a source file imports a test helper).
+     *   which gates both the emitted module set (`query()`) and dependency edges.
      *
      * Beneath it, the always-on baseline (`node_modules` + dot-directories
      * below a matched source path — see `hasBaselineExcludedSegment`) applies
@@ -116,7 +115,8 @@ export interface ModuleSourceOptions {
      * defaults doesn't require restating them; this normalized field is always
      * a plain array.
      *
-     * `analyzeFromFiles` accepts a top-level `exclude` shortcut that merges into this field.
+     * `analyzeFromFiles` and the Vite plugin accept a top-level `exclude` that
+     * replaces this field (no merge).
      *
      * Compiled to a matcher once per options object via picomatch and cached by reference;
      * mutating this array post-`isSource`-call has no effect — pass through
@@ -129,14 +129,9 @@ export interface ModuleSourceOptions {
     /**
      * Determine which analyzer to use for a file path.
      *
-     * Called for files in source directories. Return an `AnalyzerType` or `null` to skip:
-     * - `'typescript'` — TypeScript/JS files analyzed via TypeScript compiler API
-     * - `'svelte'` — Svelte components analyzed via svelte2tsx + TypeScript compiler API
-     * - `'css'` — CSS files included as modules with no declarations
-     * - `'json'` — JSON files included as modules with no declarations
-     * - `null` — skip the file
-     *
-     * @default Uses file extension: `.svelte` → svelte, `.ts`/`.js` → typescript, `.css` → css, `.json` → json
+     * Called wherever the pipeline classifies a path (ingest, every `isSource`
+     * check, context-closure candidates), so keep it cheap and pure. Return an
+     * `AnalyzerType` (see there for what each analyzes) or `null` to skip.
      *
      * Extend the default table by delegating to `getDefaultAnalyzer` (exported
      * from the main barrel) for everything but the added case — restating the
@@ -153,6 +148,8 @@ export interface ModuleSourceOptions {
      * // Include .d.ts files (the default excludes them)
      * getAnalyzerType: (path) => (path.endsWith('.d.ts') ? 'typescript' : getDefaultAnalyzer(path))
      * ```
+     *
+     * @default `getDefaultAnalyzer` (by file extension)
      */
     getAnalyzerType: (path: string) => AnalyzerType | null;
 }
@@ -169,9 +166,10 @@ export type SourceOptionsDefaults = Omit<ModuleSourceOptions, 'projectRoot'>;
  * `analyzeFromFiles`, the Vite plugin — not the CLI, whose `--exclude` is
  * array-only).
  *
- * An array **replaces** `DEFAULT_SOURCE_OPTIONS.exclude` wholesale; the
- * callback form receives a fresh copy of those defaults and returns the list
- * to use, so extending them doesn't require restating them:
+ * An array **replaces** `DEFAULT_SOURCE_OPTIONS.exclude` wholesale (the test,
+ * spec, and `internal/` filters are dropped unless restated); the callback
+ * form receives a fresh copy of those defaults and returns the list to use,
+ * so extending them doesn't require restating them:
  *
  * ```ts
  * exclude: (defaults) => [...defaults, '**\/*.gen.ts']         // add a pattern
@@ -181,7 +179,9 @@ export type SourceOptionsDefaults = Omit<ModuleSourceOptions, 'projectRoot'>;
  * The callback runs at most once per built options object (include-pattern
  * widening rebuilds options from the already-resolved array). Resolved to a
  * plain array before normalization; `ModuleSourceOptions.exclude` never
- * carries the function form.
+ * carries the function form. The always-on baseline (`node_modules` +
+ * dot-directories below a matched source path, `hasBaselineExcludedSegment`)
+ * applies beneath either form and is unaffected by overrides.
  */
 export type ExcludeOption = Array<string> | ((defaults: Array<string>) => Array<string>);
 /**
@@ -218,7 +218,9 @@ export declare const DEFAULT_SOURCE_OPTIONS: SourceOptionsDefaults;
  *
  * @param projectRoot - path to project root (typically `process.cwd()`); resolved to absolute
  * @param overrides - optional overrides for default options
- * @throws Error if validation fails (empty `sourcePaths`, or `sourceRoot` not a prefix of all `sourcePaths`)
+ * @throws Error if validation fails (empty `sourcePaths`; a `sourcePaths` entry, `sourceRoot`,
+ *   or absolute `exclude` glob escaping `projectRoot`; or `sourceRoot` not a prefix of all
+ *   `sourcePaths`)
  *
  * @example
  * ```ts
@@ -430,7 +432,8 @@ export declare const extractPath: (sourceId: string, options: ModuleSourceOption
  *
  * Deliberately NOT part of `DEFAULT_SOURCE_OPTIONS.exclude`: user `exclude`
  * replaces the defaults wholesale and would silently strip the baseline.
- * `baselineExcludesForBase` is the discovery-time glob form.
+ * `baselineExcludesForBase` is the discovery-time glob form; at analysis it
+ * applies wherever `isSource` does.
  *
  * @param relPath - POSIX path relative to a matched source path / discovery base
  */

package/dist/source-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/source-config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"source-config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/source-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,cAAc,EAAsB,MAAM,aAAa,CAAC;AAGzF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;;;;;;;;;;;;OAeG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC;CACvD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzF;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,EAAE,SAAS,CAAC,GAAG;IACtF,OAAO,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,EAAE,qBAIpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,mBAAmB,GAC/B,aAAa,MAAM,EACnB,YAAY,sBAAsB,KAChC,mBAMA,CAAC;AAcJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,mBAAmB,KAAG,mBAqFrE,CAAC;AAwCF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,IAQ7D,CAAC;AAqCF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACpC,SAAS,aAAa,CAAC,MAAM,CAAC,EAC9B,aAAa,MAAM,KACjB,aAAa,CAAC,MAAM,CACqD,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,0BAA0B,GACtC,aAAa,aAAa,CAAC,MAAM,CAAC,EAClC,SAAS,aAAa,CAAC,MAAM,CAAC,KAC5B,aAAa,CAAC,MAAM,CAUtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,8BAA8B,GAC1C,aAAa,MAAM,EACnB,WAAW,sBAAsB,GAAG,SAAS,EAC7C,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,EAC1C,MAAM,WAAW,KACf,mBA0BF,CAAC;AAuBF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,mBAAmB,KAAG,MAQ5D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,MAAM,EAAE,SAAS,mBAAmB,KAAG,MAgB5E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,MAAM,KAAG,OAS5D,CAAC;AAKF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,KAAK,CAAC,MAAM,CACJ,CAAC;AAwBhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,EAAE,SAAS,mBAAmB,KAAG,OAgCrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,EACnE,SAAS,mBAAmB,KAC1B;IAAE,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CA2B1D,CAAC"}

package/dist/source-config.js

@@ -3,10 +3,10 @@
  *
  * Provides `ModuleSourceOptions` configuration management and functions
  * that operate on source files using those options: path extraction,
- * source detection, dependency filtering, and file collection.
+ * source detection, dependency filtering, include-pattern widening, and
+ * glob-pattern normalization.
  *
  * @see `source.ts` for pure file type predicates (`isTypescript`, `isSvelte`, etc.)
- * @see `analyze.ts` for consumers (`analyze`, `analyzeFromFiles`)
  *
  * @module
  */
@@ -42,7 +42,9 @@ export const DEFAULT_SOURCE_OPTIONS = {
  *
  * @param projectRoot - path to project root (typically `process.cwd()`); resolved to absolute
  * @param overrides - optional overrides for default options
- * @throws Error if validation fails (empty `sourcePaths`, or `sourceRoot` not a prefix of all `sourcePaths`)
+ * @throws Error if validation fails (empty `sourcePaths`; a `sourcePaths` entry, `sourceRoot`,
+ *   or absolute `exclude` glob escaping `projectRoot`; or `sourceRoot` not a prefix of all
+ *   `sourcePaths`)
  *
  * @example
  * ```ts
@@ -151,11 +153,10 @@ export const normalizeSourceOptions = (options) => {
     // resolve inside the project root by storing them root-relative (matching
     // `loadFile`'s treatment of path inputs). An entry that resolves outside
     // the project root throws: out-of-root modules are unrepresentable
-    // (`ModuleJson.path` is relative to `sourceRoot` and `Diagnostic.file` to
-    // the project root — different bases, neither able to reach outside the
-    // root), so the config would be silently dead — discovery finds the
-    // files, ingest accepts them, the query-time source gate drops every one
-    // with no trace beyond its info log. Include-pattern widening re-runs
+    // (`ModuleJson.path` is relative to `sourceRoot` and cannot name a file
+    // outside the root), so the config would be silently dead — discovery finds
+    // the files, ingest accepts them, and the query-time source gate drops every
+    // one with no trace beyond its info log. Include-pattern widening re-runs
     // `createSourceOptions`, so an out-of-root include base fails here too.
     const sourcePaths = options.sourcePaths.map((p) => toRootRelativePath(p, projectRoot, 'sourcePaths entry', 'Out-of-root files cannot be analyzed — module paths and diagnostics are ' +
         'project-root-relative. Point projectRoot at a common ancestor of all source ' +
@@ -193,9 +194,9 @@ export const normalizeSourceOptions = (options) => {
     // Normalize exclude globs the same way include patterns normalize at the
     // discovery seams: an in-root absolute pattern relativizes (textual prefix
     // strip — glob metacharacters aren't path segments), an out-of-root one
-    // throws. Closes a stage disagreement: tinyglobby's glob `ignore` honored
-    // absolute excludes at discovery while `isSource` and the concrete-export
-    // check match against root-relative paths and silently never excluded.
+    // throws. Keeps the stages agreeing: tinyglobby's glob `ignore` honors
+    // absolute excludes at discovery, while `isSource` and the concrete-export
+    // check match root-relative paths and would silently never exclude.
     const exclude = options.exclude.map((p) => normalizeGlobPattern(p, projectRoot, 'exclude glob'));
     return { ...options, projectRoot, sourcePaths, sourceRoot, exclude };
 };
@@ -487,7 +488,8 @@ export const extractPath = (sourceId, options) => {
  *
  * Deliberately NOT part of `DEFAULT_SOURCE_OPTIONS.exclude`: user `exclude`
  * replaces the defaults wholesale and would silently strip the baseline.
- * `baselineExcludesForBase` is the discovery-time glob form.
+ * `baselineExcludesForBase` is the discovery-time glob form; at analysis it
+ * applies wherever `isSource` does.
  *
  * @param relPath - POSIX path relative to a matched source path / discovery base
  */

package/dist/source.d.ts

@@ -1,12 +1,9 @@
 /**
- * Source file type predicates and path helpers.
- *
- * Pure functions for detecting file types by extension and extracting
- * component names from paths. No configuration dependency — these are
- * the building blocks used by `source-config.ts`.
+ * Source file shapes (`SourceFileInfo`, `AnalyzerType`), extension predicates,
+ * and svelte2tsx virtual-path and generated-name helpers. No configuration
+ * dependency; the building blocks under `source-config.ts`.
  *
  * @see `source-config.ts` for configuration-aware functions (`isSource`, `extractPath`, etc.)
- * @see `analyze.ts` for consumers (`analyze`, `analyzeFromFiles`)
  *
  * @module
  */
@@ -25,13 +22,17 @@ export type AnalyzerType = 'typescript' | 'svelte' | 'css' | 'json';
  * Provides file content to analysis functions from any source:
  * file system, build pipeline, or in-memory.
  *
- * Note: `content` is required to keep analysis functions pure (no hidden I/O).
- * Callers are responsible for reading file content before analysis.
+ * Note: `content` is required so callers control what the checker sees for
+ * the files they supply. Files they don't (context-closure files,
+ * `node_modules`, other unowned imports) are read from disk.
  */
 export interface SourceFileInfo {
-    /** Absolute path to the file. */
+    /**
+     * Absolute path to the file. Native paths are fine at the boundary — ids
+     * are posixified at ingest (see `paths.ts`).
+     */
     id: string;
-    /** File content (required - analysis functions don't read from disk). */
+    /** File content (required — the checker sees this, not the disk, for ingested files). */
     content: string;
     /**
      * Pre-resolved absolute file paths of modules this file imports.
@@ -59,8 +60,11 @@ export interface SourceFileInfo {
      *
      * Type-only imports (`import type {...}`) are the most common asymmetry
      * versus the lex+resolve path: the default lex (`es-module-lexer`) keeps
-     * them; pre-resolved callers backed by a Gro-style filer typically drop
-     * them. Both are intentional within their respective contracts.
+     * `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.
      *
      * Cache semantics: the session compares this array element-wise (shallow
      * equality) against the snapshot stored from the prior call — a fresh
@@ -81,7 +85,7 @@ export interface SourceFileInfo {
  * Default analyzer resolver based on file extension.
  *
  * - `.svelte` → `'svelte'`
- * - `.ts`, `.js` → `'typescript'`
+ * - `.ts` (not `.d.ts`), `.js` → `'typescript'`
  * - `.css` → `'css'`
  * - `.json` → `'json'`
  * - Other extensions → `null` (skip)

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;;;;;;;;;;;GAWG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpE;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC9B,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}