@dtsx/dtsx 0.0.0-stage → 0.11.38

package/dist/src/bundle-linker.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Split generated declaration text into top-level statements, each with the
+ * comments that lead it. dtsx writes one top-level statement per line start;
+ * nested lines are indented, and a continuation at column 0 starts with a
+ * bracket or an operator, never an identifier.
+ */
+export declare function splitTopLevelStatements(text: string): DeclarationStatement[];
+/**
+ * Rename identifier references in declaration text. Strings, comments,
+ * qualified-name members (`a.b`) and property or parameter names (`{ b: T }`,
+ * `(b: T)`) are left alone.
+ */
+export declare function renameIdentifiers(text: string, renames: Map<string, string>): string;
+/**
+ * Link one entrypoint's reachable declarations into a single declaration
+ * file. `dtsContents` maps each source file to the declaration text dtsx
+ * generated for it.
+ */
+export declare function linkBundle(entry: string, files: string[], dtsContents: Map<string, string>, options: LinkBundleOptions): LinkBundleResult;
+export declare interface LinkBundleOptions {
+  cwd: string
+  keepComments?: boolean
+}
+export declare interface LinkBundleResult {
+  content: string
+  files: string[]
+  exportCount: number
+  warnings: string[]
+}
+export declare interface DeclarationStatement {
+  text: string
+  comments: string[]
+}
+declare type Binding = | { kind: 'local', name: string }
+| { kind: 'namespace', file: string }
+| { kind: 'external', source: string, imported: string }
+| { kind: 'external-namespace', source: string }
+export {};

package/dist/src/bundle-linker.js

@@ -0,0 +1,2 @@
+// @bun
+import{bo,Ue,hn}from"../chunk-wnqg6hem.js";import"../chunk-p9vfxn8g.js";import"../chunk-qzjzw9p2.js";import"../chunk-cpmqa8kd.js";import"../chunk-73dzve1s.js";import"../chunk-yay68832.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{hn as linkBundle,Ue as renameIdentifiers,bo as splitTopLevelStatements};

package/dist/src/bundler.d.ts

@@ -0,0 +1,55 @@
+import type { DtsGenerationConfig } from './types.js';
+/**
+ * Bundle multiple TypeScript files into a single .d.ts file
+ */
+export declare function bundleDeclarations(files: string[], sourceContents: Map<string, string>, config: DtsGenerationConfig): Promise<BundleResult>;
+/**
+ * Bundle multiple .d.ts files into a single file
+ */
+export declare function bundleDtsFiles(files: string[], config?: Partial<BundleConfig>): Promise<BundleResult>;
+/**
+ * Bundle and write to file
+ */
+export declare function bundleAndWrite(files: string[], outputPath: string, config?: Partial<BundleConfig>): Promise<BundleResult>;
+/**
+ * Create a bundler with preset configuration
+ */
+export declare function createBundler(config?: Partial<BundleConfig>): {
+  bundle: (files: string[]) => Promise<BundleResult>
+  bundleAndWrite: (files: string[], output: string) => Promise<BundleResult>
+};
+/**
+ * Resolve entry files from glob patterns
+ */
+export declare function resolveEntryFiles(patterns: string | string[], cwd?: string): Promise<string[]>;
+/**
+ * Bundle configuration options
+ */
+export declare interface BundleConfig {
+  entry: string | string[]
+  output: string
+  name?: string
+  includeSourceComments?: boolean
+  preserveFileSections?: boolean
+  externals?: string[]
+  banner?: string
+  footer?: string
+  sortDeclarations?: boolean
+  mergeDuplicates?: boolean
+  ambient?: boolean
+  moduleName?: string
+  includeReferences?: boolean
+  references?: string[]
+}
+/**
+ * Bundle result containing the combined declarations
+ */
+export declare interface BundleResult {
+  content: string
+  files: string[]
+  declarationCount: number
+  importCount: number
+  exportCount: number
+  size: number
+  warnings: string[]
+}

package/dist/src/bundler.js

@@ -0,0 +1,2 @@
+// @bun
+import{ns,_t,pr,rs,is}from"../chunk-t4va49p3.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{pr as bundleAndWrite,ns as bundleDeclarations,_t as bundleDtsFiles,rs as createBundler,is as resolveEntryFiles};

package/dist/src/cache.d.ts

@@ -0,0 +1,53 @@
+import type { DtsGenerationConfig } from './types.js';
+/** Clear only the cache manifest, preserving other tools' files in the directory. */
+export declare function clearBuildCache(cacheDir: string): void;
+/**
+ * Add .dtsx-cache to .gitignore if not already present
+ */
+export declare function ensureGitignore(cwd: string): void;
+/**
+ * Cache entry for a single file
+ */
+export declare interface CacheEntry {
+  sourcePath: string
+  sourceHash: string
+  sourceMtime: number
+  sourceCtime: number
+  sourceSize: number
+  dtsContent: string
+  dtsHash: string
+  generatedAt: number
+  configHash: string
+}
+/**
+ * Cache manifest containing all cached entries
+ */
+export declare interface CacheManifest {
+  version: number
+  configHash: string
+  entries: Record<string, CacheEntry>
+  createdAt: number
+  updatedAt: number
+}
+/**
+ * Incremental build cache manager
+ */
+export declare class BuildCache {
+  private cacheDir;
+  private manifestPath;
+  private manifest;
+  private configHash;
+  constructor(config: DtsGenerationConfig, resolutionContext?: string);
+  private hashConfig;
+  private hashString;
+  load(): boolean;
+  save(): void;
+  needsRegeneration(filePath: string, cwd: string): boolean;
+  getCached(filePath: string, cwd: string): string | null;
+  getCachedIfValid(filePath: string, cwd: string): string | null;
+  update(filePath: string, sourceContent: string, dtsContent: string, cwd: string): void;
+  remove(filePath: string, cwd: string): void;
+  clear(): void;
+  getStats(): { entries: number, size: number };
+  prune(existingFiles: Set<string>, cwd: string): number;
+}

package/dist/src/cache.js

@@ -0,0 +1,2 @@
+// @bun
+import{Qr,Ge,mt}from"../chunk-tka2m4af.js";import"../chunk-v6fwy63g.js";export{Ge as BuildCache,Qr as clearBuildCache,mt as ensureGitignore};

package/dist/src/call-signatures.d.ts

@@ -0,0 +1 @@
+export declare function functionCount(source: string, name: string): number;

package/dist/src/call-signatures.js

@@ -0,0 +1,2 @@
+// @bun
+import{Re}from"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Re as functionCount};

package/dist/src/checker.d.ts

@@ -0,0 +1,107 @@
+import ts from 'typescript';
+import type { DtsGenerationConfig } from './types.js';
+/**
+ * Load TypeScript compiler options from tsconfig.json
+ */
+export declare function loadCompilerOptions(tsconfigPath: string, overrides?: Partial<ts.CompilerOptions>): ts.CompilerOptions;
+/**
+ * Type check TypeScript/declaration files
+ */
+export declare function typeCheck(files: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+/**
+ * Validate that generated .d.ts files are valid TypeScript
+ */
+export declare function validateDeclarations(dtsFiles: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+/**
+ * Check if source files are compatible with TypeScript's isolatedDeclarations mode
+ */
+export declare function checkIsolatedDeclarations(files: string[], tsconfigPath?: string): Promise<Map<string, IsolatedDeclarationsResult>>;
+/**
+ * Get type information for a specific position in a file
+ */
+export declare function getTypeAtPosition(filePath: string, line: number, column: number, tsconfigPath?: string): string | null;
+/**
+ * Get quick info (hover information) for a position
+ */
+export declare function getQuickInfo(filePath: string, line: number, column: number, tsconfigPath?: string): { type: string, documentation?: string } | null;
+/**
+ * Format type check results as a human-readable string
+ */
+export declare function formatTypeCheckResults(result: TypeCheckResult): string;
+/**
+ * Integrate type checking into DTS generation config
+ */
+export declare function typeCheckWithConfig(config: DtsGenerationConfig): Promise<TypeCheckResult>;
+/**
+ * Validate generated declarations match the source types
+ */
+export declare function validateGeneratedDeclarations(_sourceFiles: string[], _dtsFiles: string[], _tsconfigPath?: string): Promise<{
+  valid: boolean
+  mismatches: Array<{
+    sourceName: string
+    sourceType: string
+    dtsType: string
+  }>
+}>;
+/**
+ * A diagnostic message from type checking
+ */
+export declare interface TypeDiagnostic {
+  file: string
+  line: number
+  column: number
+  message: string
+  code: number
+  severity: DiagnosticSeverity
+  source?: string
+  suggestion?: string
+  category: string
+}
+/**
+ * Result of type checking
+ */
+export declare interface TypeCheckResult {
+  success: boolean
+  diagnostics: TypeDiagnostic[]
+  errorCount: number
+  warningCount: number
+  infoCount: number
+  filesChecked: string[]
+  durationMs: number
+}
+/**
+ * Type checking configuration
+ */
+export declare interface TypeCheckConfig {
+  tsconfigPath?: string
+  rootDir?: string
+  strict?: boolean
+  declarationsOnly?: boolean
+  skipLibCheck?: boolean
+  include?: string[]
+  exclude?: string[]
+  warningsAsErrors?: boolean
+  maxErrors?: number
+  compilerOptions?: Partial<ts.CompilerOptions>
+}
+/**
+ * Isolated declarations checking result
+ */
+export declare interface IsolatedDeclarationsResult {
+  compatible: boolean
+  issues: IsolatedDeclarationsIssue[]
+}
+/**
+ * An issue found during isolated declarations checking
+ */
+export declare interface IsolatedDeclarationsIssue {
+  line: number
+  column: number
+  message: string
+  declarationName?: string
+  missingAnnotation?: 'return' | 'parameter' | 'variable' | 'property'
+}
+/**
+ * Diagnostic severity levels
+ */
+export type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';

package/dist/src/circular.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Build a dependency graph from TypeScript source files
+ */
+export declare function buildDependencyGraph(files: string[], options?: CircularDetectionOptions): Promise<Map<string, DependencyNode>>;
+/**
+ * Detect circular dependencies in a dependency graph
+ */
+export declare function detectCircularDependencies(graph: Map<string, DependencyNode>, options?: CircularDetectionOptions): CircularDependency[];
+/**
+ * Analyze files for circular dependencies
+ */
+export declare function analyzeCircularDependencies(files: string[], options?: CircularDetectionOptions): Promise<CircularAnalysisResult>;
+/**
+ * Format circular dependency analysis as a string
+ */
+export declare function formatCircularAnalysis(result: CircularAnalysisResult, rootDir?: string): string;
+/**
+ * Get a summary of the dependency graph
+ */
+export declare function getGraphSummary(graph: Map<string, DependencyNode>): {
+  totalFiles: number
+  totalDependencies: number
+  avgDependencies: number
+  maxDependencies: { file: string, count: number }
+  isolatedFiles: string[]
+  mostDepended: { file: string, count: number }
+};
+/**
+ * Find all files that depend on a given file (transitive)
+ */
+export declare function findAllDependents(filePath: string, graph: Map<string, DependencyNode>): Set<string>;
+/**
+ * Find all dependencies of a given file (transitive)
+ */
+export declare function findAllDependencies(filePath: string, graph: Map<string, DependencyNode>): Set<string>;
+/**
+ * Export dependency graph as DOT format (for visualization with Graphviz)
+ */
+export declare function exportGraphAsDot(graph: Map<string, DependencyNode>, rootDir?: string): string;
+/**
+ * Export dependency graph as JSON
+ */
+export declare function exportGraphAsJson(graph: Map<string, DependencyNode>, rootDir?: string): string;
+/**
+ * A node in the dependency graph
+ */
+export declare interface DependencyNode {
+  path: string
+  exports: Set<string>
+  imports: Map<string, string>
+  dependencies: Set<string>
+  dependents: Set<string>
+}
+/**
+ * A circular dependency chain
+ */
+export declare interface CircularDependency {
+  chain: string[]
+  symbols: string[]
+  severity: 'error' | 'warning'
+  reason: string
+}
+/**
+ * Result of circular dependency analysis
+ */
+export declare interface CircularAnalysisResult {
+  hasCircular: boolean
+  cycles: CircularDependency[]
+  graph: Map<string, DependencyNode>
+  filesAnalyzed: string[]
+  durationMs: number
+}
+/**
+ * Options for circular dependency detection
+ */
+export declare interface CircularDetectionOptions {
+  rootDir?: string
+  ignore?: string[]
+  typesOnly?: boolean
+  maxDepth?: number
+  includeNodeModules?: boolean
+}

package/dist/src/circular.js

@@ -0,0 +1,2 @@
+// @bun
+import{mr,gr,ss,os,as,cs,ls,us,fs}from"../chunk-rkstz4w1.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{ss as analyzeCircularDependencies,mr as buildDependencyGraph,gr as detectCircularDependencies,us as exportGraphAsDot,fs as exportGraphAsJson,ls as findAllDependencies,cs as findAllDependents,os as formatCircularAnalysis,as as getGraphSummary};

package/dist/src/compat.d.ts

@@ -0,0 +1,114 @@
+import type { ChildProcess } from 'node:child_process';
+/**
+ * Cross-runtime file handle creator
+ * Compatible with Bun.file() API
+ */
+export declare function file(path: string): FileHandle;
+/**
+ * Cross-runtime file writer
+ * Compatible with Bun.write() API
+ */
+export declare function write(path: string, content: string | Uint8Array | ArrayBuffer): Promise<number>;
+/**
+ * Cross-runtime process spawner
+ * Compatible with Bun.spawn() API
+ */
+export declare function spawnProcess(command: string | string[], options?: CompatSpawnOptions): SpawnResult;
+/**
+ * Read a file as text with cross-runtime compatibility.
+ * On Node.js we skip the FileHandle wrapper allocation and call readFile directly.
+ */
+export declare function readTextFile(path: string): Promise<string>;
+/**
+ * Check if a file exists with cross-runtime compatibility.
+ * On Node.js we go straight to stat() — the FileHandle indirection only
+ * mattered for Bun's optimized exists() check.
+ */
+export declare function fileExists(path: string): Promise<boolean>;
+/**
+ * Write text to a file with cross-runtime compatibility
+ */
+export declare function writeTextFile(path: string, content: string): Promise<void>;
+/**
+ * Get runtime information
+ */
+export declare function getRuntimeInfo(): RuntimeInfo;
+/**
+ * Runtime detection
+ */
+export declare const isBun: boolean;
+export declare const isNode: boolean;
+/**
+ * Current runtime name
+ */
+export declare const runtime: 'bun' | 'node';
+/**
+ * File handle interface compatible with Bun.file()
+ */
+export declare interface FileHandle {
+  exists: () => Promise<boolean>
+  text: () => Promise<string>
+  arrayBuffer: () => Promise<ArrayBuffer>
+  size: number
+  name: string
+}
+/**
+ * Spawn result interface compatible with Bun.spawn()
+ */
+export declare interface SpawnResult {
+  pid: number
+  stdout: ReadableStream<Uint8Array> | NodeJS.ReadableStream
+  stderr: ReadableStream<Uint8Array> | NodeJS.ReadableStream
+  stdin: WritableStream<Uint8Array> | NodeJS.WritableStream | null
+  exited: Promise<number>
+  kill: (signal?: number) => void
+  ref: () => void
+  unref: () => void
+}
+/**
+ * Spawn options compatible with Bun.spawn()
+ */
+export declare interface CompatSpawnOptions {
+  cwd?: string
+  env?: Record<string, string | undefined>
+  stdin?: 'inherit' | 'pipe' | 'ignore' | null
+  stdout?: 'inherit' | 'pipe' | 'ignore' | null
+  stderr?: 'inherit' | 'pipe' | 'ignore' | null
+}
+/**
+ * Runtime information
+ */
+export declare interface RuntimeInfo {
+  name: 'bun' | 'node'
+  version: string
+  isBun: boolean
+  isNode: boolean
+}
+/**
+ * Node.js implementation of Bun-like file handle
+ */
+declare class NodeFileHandle implements FileHandle {
+  name: string;
+  private _size;
+  constructor(path: string);
+  exists(): Promise<boolean>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  get size(): number;
+}
+/**
+ * Node.js implementation of Bun-like spawn result
+ */
+declare class NodeSpawnResult implements SpawnResult {
+  pid: number;
+  stdout: NodeJS.ReadableStream;
+  stderr: NodeJS.ReadableStream;
+  stdin: NodeJS.WritableStream | null;
+  exited: Promise<number>;
+  private process;
+  constructor(proc: ChildProcess);
+  kill(signal?: number): void;
+  ref(): void;
+  unref(): void;
+}
+export {};

package/dist/src/compat.js

@@ -0,0 +1,2 @@
+// @bun
+import{g,Jo,Yo,Z,Ke,xt,u,Xo,Zo,Qo}from"../chunk-73dzve1s.js";export{Z as file,Xo as fileExists,Qo as getRuntimeInfo,g as isBun,Jo as isNode,u as readTextFile,Yo as runtime,xt as spawnProcess,Ke as write,Zo as writeTextFile};

package/dist/src/computed-keys.d.ts

@@ -0,0 +1,12 @@
+import type { Declaration } from './types.js';
+/** Evaluate the string/number constant grammar used by computed template keys. */
+export declare function evaluateKeyConstant(expression: string, constants: KeyConstants, depth?: number): KeyConstant | undefined;
+/** Snapshot eligible const syntax before private declaration pruning. */
+export declare function attachComputedKeyConstants(declarations: Declaration[], privateDeclarations: ReadonlyMap<string, Declaration>): void;
+export declare function resolveTemplateKey(key: string, constants?: KeyConstants): { name: string } | { index: true } | undefined;
+/** Symbol properties do not contribute to a string index's value union. */
+export declare function isSymbolKey(key: string, constants?: KeyConstants): boolean;
+export declare function hasTemplateSubstitution(key: string): boolean;
+export type KeyConstant = string | number;
+export type KeyBinding = KeyConstant | { kind: 'symbol' }
+export type KeyConstants = ReadonlyMap<string, KeyBinding> & { mutableBindingTypes?: ReadonlyMap<string, string> }

package/dist/src/computed-keys.js

@@ -0,0 +1,2 @@
+// @bun
+import{w,Vn,Un,zn,Hn}from"../chunk-32qexm3w.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Vn as attachComputedKeyConstants,w as evaluateKeyConstant,Hn as hasTemplateSubstitution,zn as isSymbolKey,Un as resolveTemplateKey};

package/dist/src/concurrency.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Normalize user-provided batch sizes so loops always make forward progress.
+ */
+export declare function normalizeConcurrency(value: number | undefined, fallback: number): number;

package/dist/src/concurrency.js

@@ -0,0 +1,2 @@
+// @bun
+import{B}from"../chunk-pga5m4wm.js";export{B as normalizeConcurrency};

package/dist/src/config.d.ts

@@ -0,0 +1,35 @@
+import type { DtsGenerationConfig } from './types.js';
+/**
+ * Get the configuration, loading from config file if available
+ */
+export declare function getConfig(cwd?: string): Promise<DtsGenerationConfig>;
+/**
+ * Reset the cached config (useful for testing)
+ */
+export declare function resetConfig(): void;
+/*.ts'],
+ *   keepComments: true,
+ * })
+ * ```
+ */
+export declare function defineConfig(config: Partial<DtsGenerationConfig>): DtsGenerationConfig;
+/**
+ * Define a dtsx configuration with async support
+ * Allows loading plugins or other async dependencies
+ *
+ * @example
+ * ```ts
+ * // dtsx.config.ts
+ * import { defineConfigAsync } from 'dtsx'
+ *
+ * export default defineConfigAsync(async () => ({
+ *   root: './src',
+ *   outdir: './dist',
+ *   plugins: [await loadPlugin()],
+ * }))
+ * ```
+ */
+export declare function defineConfigAsync(configFn: () => Promise<Partial<DtsGenerationConfig>>): () => Promise<DtsGenerationConfig>;
+export declare const defaultConfig: DtsGenerationConfig;
+// For backwards compatibility - synchronous access with default fallback
+export declare const config: DtsGenerationConfig;

package/dist/src/config.js

@@ -0,0 +1,2 @@
+// @bun
+import{N,zo,Ho,Ko,qo,E}from"../chunk-ebjafajx.js";import"../chunk-yay68832.js";export{E as config,N as defaultConfig,Ko as defineConfig,qo as defineConfigAsync,zo as getConfig,Ho as resetConfig};

package/dist/src/dangling-refs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type names the emitted declaration references but never resolves.
+ *
+ * Returns an empty array for a self-contained file, which is the normal case.
+ */
+export declare function findDanglingTypeReferences(dts: string): DanglingReference[];
+export declare interface DanglingReference {
+  name: string
+  line: number
+  context: string
+}

package/dist/src/dangling-refs.js

@@ -0,0 +1,2 @@
+// @bun
+import{bn}from"../chunk-p023fhce.js";import"../chunk-6yvk3q1e.js";export{bn as findDanglingTypeReferences};

package/dist/src/declaration-project.d.ts

@@ -0,0 +1,33 @@
+import type { DtsGenerationConfig } from './types.js';
+import type { ModuleResolver, ReachabilityResult } from './module-graph.js';
+/**
+ * Plan sources and intended declaration outputs from an effective config.
+ * The optional resolver provider lets the generator retain its config-scoped
+ * resolver lifecycle; it runs only after the existing entrypoint validation.
+ */
+export declare function planDeclarationProject(config: DtsGenerationConfig, provideResolver?: () => Promise<ModuleResolver>): Promise<DeclarationProjectPlan>;
+/**
+ * Check if a file matches any of the exclude patterns
+ */
+export declare function isExcluded(filePath: string, excludePatterns: string[], rootPath: string): boolean;
+export declare function isWithinRoot(filePath: string, rootPath: string): boolean;
+/** Get the declaration output path without accessing or changing the filesystem. */
+export declare function getDeclarationOutputPath(inputPath: string, config: DtsGenerationConfig): string;
+export declare function getDeclarationSpecifier(fromOutputPath: string, toOutputPath: string, runtimeExtension?: string): string;
+/**
+ * Resolve one reference encountered in declaration output. A supplied delivery
+ * set identifies the current project boundary; omitting it retains standalone
+ * transform behavior and does not establish package delivery.
+ */
+export declare function createDeclarationReferenceResolver(filePath: string, config: DtsGenerationConfig, resolveSpecifier: ModuleResolver, delivered?: ReadonlySet<string>): (specifier: string) => DeclarationReference;
+export declare interface DeclarationProjectPlan {
+  readonly entryFiles: readonly string[]
+  readonly files: readonly string[]
+  readonly outputBySource: ReadonlyMap<string, string>
+  readonly resolver: ModuleResolver
+  readonly reachability: ReachabilityResult | null
+  readonly augmentationImports: ReadonlyMap<string, ReadonlySet<string>>
+  getResolutionFingerprint: () => string | undefined
+}
+export type DeclarationReference = | { kind: 'unchanged', reason: 'external' | 'unresolved' | 'preserved-declaration', specifier: string, emittedSpecifier: string }
+| { kind: 'local', specifier: string, resolvedSource: string, declarationOutput: string, emittedSpecifier: string }

package/dist/src/declaration-project.js

@@ -0,0 +1,2 @@
+// @bun
+import{ye,J,S,G,Vo,be}from"../chunk-davy89dj.js";import"../chunk-g2120ysy.js";import"../chunk-4fygcxtb.js";import"../chunk-p9vfxn8g.js";import"../chunk-qzjzw9p2.js";import"../chunk-cpmqa8kd.js";import"../chunk-73dzve1s.js";import"../chunk-yay68832.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{be as createDeclarationReferenceResolver,G as getDeclarationOutputPath,Vo as getDeclarationSpecifier,J as isExcluded,S as isWithinRoot,ye as planDeclarationProject};

package/dist/src/declaration-publication.d.ts

@@ -0,0 +1,15 @@
+import type { DtsGenerationConfig } from './types.js';
+/** Keep the generator's existing early configuration checks in their owner. */
+export declare function assertSafeOutputConfiguration(config: DtsGenerationConfig): Promise<void>;
+/**
+ * Stage all normalized declaration/map bytes, then commit with reversible
+ * renames. This protects detected preparation/commit failures, not atomic
+ * visibility to concurrent readers or process/power-loss crash recovery.
+ * Callers prepare bundles before publication; cache saving and processFile
+ * remain separate caller operations.
+ */
+export declare function publishDeclarationOutputs(config: DtsGenerationConfig, pending: ReadonlyMap<string, DeclarationOutput>): Promise<void>;
+export declare interface DeclarationOutput {
+  content: string
+  lineEnding?: 'lf' | 'crlf' | 'auto'
+}

package/dist/src/declaration-publication.js

@@ -0,0 +1,2 @@
+// @bun
+import{z,de}from"../chunk-kfk554fj.js";import"../chunk-7tremqhs.js";import"../chunk-danfamyx.js";import"../chunk-p023fhce.js";import"../chunk-6yvk3q1e.js";import"../chunk-davy89dj.js";import"../chunk-g2120ysy.js";import"../chunk-4fygcxtb.js";import"../chunk-ebjafajx.js";import"../chunk-p9vfxn8g.js";import"../chunk-qzjzw9p2.js";import"../chunk-cpmqa8kd.js";import"../chunk-73dzve1s.js";import"../chunk-yay68832.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{z as assertSafeOutputConfiguration,de as publishDeclarationOutputs};

package/dist/src/declaration-references.d.ts

@@ -0,0 +1,19 @@
+import type { Declaration } from './types.js';
+/** A direct const alias preserves the referenced value's type identity. */
+export declare function directConstValueAlias(value: string): string | undefined;
+/** Whether a depth-zero brace starts a type operand instead of a function body. */
+export declare function returnTypeExpectsObject(prefix: string): boolean;
+/** Original top-level syntax, independent of imports or declarations pruned later. */
+export declare function isExternalModuleSource(source: string): boolean;
+/**
+ * The same check for generated text, whose tokens nobody reuses. Emitted
+ * declarations usually start with an import or export, and tokens ending
+ * strictly before a cut are the same with or without the rest of the text
+ * (lexing is left to right and never fails), so growing prefixes usually
+ * answer after a few hundred bytes.
+ */
+export declare function isExternalModuleText(text: string): boolean;
+/** Bindings in an ambient external module are implicitly exported without a clause. */
+export declare function isPrivateImportableDeclaration(declaration: Declaration): boolean;
+/** Functions have value bindings. Type names and labels cannot retain them. */
+export declare function collectDeclarationValueReferences(declaration: Declaration, references: Set<string>): void;

package/dist/src/declaration-references.js

@@ -0,0 +1,2 @@
+// @bun
+import{Qe,Dt,W,jn,_n,Gn}from"../chunk-ag1b6d30.js";import"../chunk-42j9cfte.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Gn as collectDeclarationValueReferences,Qe as directConstValueAlias,W as isExternalModuleSource,jn as isExternalModuleText,_n as isPrivateImportableDeclaration,Dt as returnTypeExpectsObject};