@dtsx/dtsx 0.0.0-stage → 0.11.37

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{b,oa,aa,ae,tt,Ot,f,ca,la,ua}from"../chunk-dfye109x.js";export{ae as file,ca as fileExists,ua as getRuntimeInfo,b as isBun,oa as isNode,f as readTextFile,aa as runtime,Ot as spawnProcess,tt as write,la 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,Wn,jn,_n,Gn}from"../chunk-n2nyd0ck.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Wn as attachComputedKeyConstants,w as evaluateKeyConstant,Gn as hasTemplateSubstitution,_n as isSymbolKey,jn 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,To,Ao,Po,Do,S}from"../chunk-v44crx69.js";import"../chunk-km8t8gqg.js";export{S as config,N as defaultConfig,Po as defineConfig,Do as defineConfigAsync,To as getConfig,Ao 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{pn}from"../chunk-n37yj3xv.js";import"../chunk-aw48mk3t.js";export{pn 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{me,J,v,G,Eo,ge}from"../chunk-853ftm92.js";import"../chunk-xb92nrsm.js";import"../chunk-vtskg4r2.js";import"../chunk-qnf4byak.js";import"../chunk-1pz7zxhc.js";import"../chunk-pga5m4wm.js";import"../chunk-25vyhfzh.js";import"../chunk-mt9219xc.js";import"../chunk-v6fwy63g.js";import"../chunk-ttc5pr8y.js";import"../chunk-xr1h3tv2.js";import"../chunk-gsb3ty07.js";import"../chunk-s6c98nad.js";import"../chunk-z4mvkazp.js";import"../chunk-g9d5r6a8.js";import"../chunk-wnk9yjw2.js";import"../chunk-gpq2kggq.js";import"../chunk-90aptjh6.js";import"../chunk-rdzfdjkb.js";import"../chunk-n2nyd0ck.js";import"../chunk-j6pfxvy8.js";import"../chunk-2kwjbk55.js";import"../chunk-69dbf6de.js";import"../chunk-cen2t56g.js";import"../chunk-d43bpfk6.js";import"../chunk-rmdwvzgn.js";import"../chunk-pzedkn7z.js";import"../chunk-km8t8gqg.js";import"../chunk-dfye109x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{ge as createDeclarationReferenceResolver,G as getDeclarationOutputPath,Eo as getDeclarationSpecifier,J as isExcluded,v as isWithinRoot,me 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{K,pe}from"../chunk-s0mvstt0.js";import"../chunk-79nv7twc.js";import"../chunk-n37yj3xv.js";import"../chunk-aw48mk3t.js";import"../chunk-853ftm92.js";import"../chunk-xb92nrsm.js";import"../chunk-v44crx69.js";import"../chunk-vae5wxar.js";import"../chunk-vtskg4r2.js";import"../chunk-qnf4byak.js";import"../chunk-1pz7zxhc.js";import"../chunk-pga5m4wm.js";import"../chunk-25vyhfzh.js";import"../chunk-mt9219xc.js";import"../chunk-v6fwy63g.js";import"../chunk-ttc5pr8y.js";import"../chunk-xr1h3tv2.js";import"../chunk-gsb3ty07.js";import"../chunk-s6c98nad.js";import"../chunk-z4mvkazp.js";import"../chunk-g9d5r6a8.js";import"../chunk-wnk9yjw2.js";import"../chunk-gpq2kggq.js";import"../chunk-90aptjh6.js";import"../chunk-rdzfdjkb.js";import"../chunk-n2nyd0ck.js";import"../chunk-j6pfxvy8.js";import"../chunk-2kwjbk55.js";import"../chunk-69dbf6de.js";import"../chunk-cen2t56g.js";import"../chunk-d43bpfk6.js";import"../chunk-rmdwvzgn.js";import"../chunk-pzedkn7z.js";import"../chunk-km8t8gqg.js";import"../chunk-dfye109x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{K as assertSafeOutputConfiguration,pe 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{et,Mt,j,Vn,Un,zn}from"../chunk-j6pfxvy8.js";import"../chunk-2kwjbk55.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{zn as collectDeclarationValueReferences,et as directConstValueAlias,j as isExternalModuleSource,Vn as isExternalModuleText,Un as isPrivateImportableDeclaration,Mt as returnTypeExpectsObject};

package/dist/src/diff.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Compute diff between two strings
+ */
+export declare function computeDiff(oldContent: string, newContent: string, filePath: string, options?: DiffOptions): DiffResult;
+/**
+ * Format diff result as unified diff string
+ */
+export declare function formatUnifiedDiff(result: DiffResult): string;
+/**
+ * Format diff with colors for terminal output
+ */
+export declare function formatColoredDiff(result: DiffResult): string;
+/**
+ * Format diff as simple summary
+ */
+export declare function formatDiffSummary(result: DiffResult): string;
+/**
+ * Compare a file against new content
+ */
+export declare function diffFile(filePath: string, newContent: string, options?: DiffOptions): Promise<DiffResult>;
+/**
+ * Compare multiple files
+ */
+export declare function diffFiles(files: Map<string, string>, options?: DiffOptions): Promise<Map<string, DiffResult>>;
+/**
+ * Generate a summary of all diffs
+ */
+export declare function summarizeDiffs(results: Map<string, DiffResult>): {
+  totalFiles: number
+  changedFiles: number
+  unchangedFiles: number
+  totalAdditions: number
+  totalDeletions: number
+  newFiles: number
+};
+/**
+ * Print colored diff to console
+ */
+export declare function printDiff(result: DiffResult): void;
+/**
+ * Print all diffs to console
+ */
+export declare function printDiffs(results: Map<string, DiffResult>, showUnchanged?: boolean): void;
+/**
+ * A single diff hunk (change)
+ */
+export declare interface DiffHunk {
+  operation: DiffOperation
+  lines: string[]
+  oldStart: number
+  oldCount: number
+  newStart: number
+  newCount: number
+}
+/**
+ * Complete diff result
+ */
+export declare interface DiffResult {
+  filePath: string
+  identical: boolean
+  hunks: DiffHunk[]
+  stats: {
+    additions: number
+    deletions: number
+    unchanged: number
+  }
+  oldContent?: string
+  newContent: string
+}
+/**
+ * Options for diff generation
+ */
+export declare interface DiffOptions {
+  context?: number
+  ignoreWhitespace?: boolean
+  ignoreBlankLines?: boolean
+  treatMissingAsEmpty?: boolean
+}
+/**
+ * Diff operation type
+ */
+export type DiffOperation = 'add' | 'remove' | 'equal';

package/dist/src/diff.js

@@ -0,0 +1,2 @@
+// @bun
+import{ut,Ps,Mr,Ds,Or,Rs,Ir,Fr,Ms}from"../chunk-n6nw7sn2.js";import"../chunk-dfye109x.js";export{ut as computeDiff,Or as diffFile,Rs as diffFiles,Mr as formatColoredDiff,Ds as formatDiffSummary,Ps as formatUnifiedDiff,Fr as printDiff,Ms as printDiffs,Ir as summarizeDiffs};

package/dist/src/docs.d.ts

@@ -0,0 +1,97 @@
+import type { Declaration } from './types.js';
+/**
+ * Parse JSDoc comments from a declaration
+ */
+export declare function parseJSDoc(comments: string[] | undefined): JSDocInfo;
+/**
+ * Extract documentation from source files
+ */
+export declare function extractDocumentation(files: string[], config?: Partial<DocsConfig>): Promise<Documentation>;
+/**
+ * Generate markdown documentation
+ */
+export declare function generateMarkdown(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate HTML documentation
+ */
+export declare function generateHTML(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate JSON documentation
+ */
+export declare function generateJSON(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate documentation in TypeDoc-compatible JSON format
+ */
+export declare function generateTypeDocJSON(docs: Documentation): string;
+/**
+ * Generate and write documentation files
+ */
+export declare function generateDocs(files: string[], config: DocsConfig): Promise<void>;
+/**
+ * Create a documentation generator with preset configuration
+ */
+export declare function createDocsGenerator(config?: Partial<DocsConfig>): {
+  extract: (files: string[]) => Promise<Documentation>
+  generateMarkdown: (docs: Documentation) => string
+  generateHTML: (docs: Documentation) => string
+  generateJSON: (docs: Documentation) => string
+  parseJSDoc: typeof parseJSDoc
+};
+/**
+ * Documentation configuration
+ */
+export declare interface DocsConfig {
+  format: 'markdown' | 'html' | 'json'
+  outdir: string
+  includePrivate?: boolean
+  includeInternal?: boolean
+  groupByCategory?: boolean
+  title?: string
+  description?: string
+  includeSourceLinks?: boolean
+  sourceBaseUrl?: string
+  includeTypes?: boolean
+  splitByModule?: boolean
+  template?: 'default' | 'minimal' | 'detailed'
+  customCss?: string
+  includeSidebar?: boolean
+}
+/**
+ * Parsed JSDoc information
+ */
+export declare interface JSDocInfo {
+  description: string
+  params: Array<{ name: string, type?: string, description: string, optional?: boolean }>
+  returns?: { type?: string, description: string }
+  examples: string[]
+  tags: Record<string, string[]>
+  deprecated?: string
+  since?: string
+  see: string[]
+  throws: Array<{ type?: string, description: string }>
+  category?: string
+}
+/**
+ * Documentation entry for a declaration
+ */
+export declare interface DocEntry {
+  name: string
+  kind: Declaration['kind']
+  signature: string
+  jsdoc: JSDocInfo
+  isExported: boolean
+  isDefault?: boolean
+  sourceFile?: string
+  sourceLine?: number
+  members?: DocEntry[]
+}
+/**
+ * Documentation output structure
+ */
+export declare interface Documentation {
+  title: string
+  description?: string
+  entries: DocEntry[]
+  categories: Map<string, DocEntry[]>
+  generatedAt: Date
+}

package/dist/src/docs.js

@@ -0,0 +1,2 @@
+// @bun
+import{Wt,jt,Be,_t,Gt,gr,Yi,Xi}from"../chunk-knrtwppp.js";import"../chunk-qnf4byak.js";import"../chunk-1pz7zxhc.js";import"../chunk-pga5m4wm.js";import"../chunk-25vyhfzh.js";import"../chunk-mt9219xc.js";import"../chunk-v6fwy63g.js";import"../chunk-ttc5pr8y.js";import"../chunk-xr1h3tv2.js";import"../chunk-gsb3ty07.js";import"../chunk-s6c98nad.js";import"../chunk-z4mvkazp.js";import"../chunk-g9d5r6a8.js";import"../chunk-wnk9yjw2.js";import"../chunk-gpq2kggq.js";import"../chunk-90aptjh6.js";import"../chunk-rdzfdjkb.js";import"../chunk-n2nyd0ck.js";import"../chunk-j6pfxvy8.js";import"../chunk-2kwjbk55.js";import"../chunk-69dbf6de.js";import"../chunk-cen2t56g.js";import"../chunk-km8t8gqg.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Xi as createDocsGenerator,jt as extractDocumentation,Yi as generateDocs,_t as generateHTML,Gt as generateJSON,Be as generateMarkdown,gr as generateTypeDocJSON,Wt as parseJSDoc};

package/dist/src/enum-declarations.d.ts

@@ -0,0 +1,6 @@
+import type { Declaration } from './types.js';
+import type { KeyBinding, KeyConstants } from './computed-keys.js';
+/** Runtime enum values become uninitialized numeric ambient members. */
+export declare function lowerEnumBody(body: string, name: string, outer?: KeyConstants): { body: string, members: Map<string, KeyBinding> };
+/** Preserve source constants before pruning implementation-only declarations. */
+export declare function attachEnumBodies(declarations: Declaration[], privateDeclarations: ReadonlyMap<string, Declaration>): void;

package/dist/src/enum-declarations.js

@@ -0,0 +1,2 @@
+// @bun
+import{Jo,Pn}from"../chunk-gsb3ty07.js";import"../chunk-n2nyd0ck.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Pn as attachEnumBodies,Jo as lowerEnumBody};

package/dist/src/errors.d.ts

@@ -0,0 +1,113 @@
+import type { DtsError, SourceLocation } from './types.js';
+/**
+ * Type guards for error types
+ */
+export declare function isDtsxError(error: unknown): error is DtsxError;
+export declare function isParseError(error: unknown): error is ParseError;
+export declare function isFileError(error: unknown): error is FileError;
+export declare function isConfigError(error: unknown): error is ConfigError;
+/**
+ * Wrap an unknown error in a DtsxError
+ */
+export declare function wrapError(error: unknown, code?: ErrorCode, message?: string): DtsxError;
+/**
+ * Calculate line and column from source code offset
+ */
+export declare function getLocationFromOffset(sourceCode: string, offset: number): SourceLocation;
+/**
+ * Create a formatted error message with source location context
+ */
+export declare function formatErrorWithContext(sourceCode: string, location: SourceLocation, message: string, filePath?: string): string;
+/**
+ * Create a DtsError from an exception
+ */
+export declare function createDtsError(error: unknown, file: string, _sourceCode?: string): DtsError;
+/**
+ * Format a DtsError for display
+ */
+export declare function formatDtsError(error: DtsError, sourceCode?: string): string;
+/**
+ * Aggregate multiple errors into a summary
+ */
+export declare function summarizeErrors(errors: DtsError[]): string;
+/**
+ * Error codes for categorizing errors
+ */
+export declare const ErrorCodes: {
+  readonly PARSE_ERROR: 'PARSE_ERROR';
+  readonly SYNTAX_ERROR: 'SYNTAX_ERROR';
+  readonly FILE_NOT_FOUND: 'FILE_NOT_FOUND';
+  readonly FILE_READ_ERROR: 'FILE_READ_ERROR';
+  readonly FILE_WRITE_ERROR: 'FILE_WRITE_ERROR';
+  readonly TYPE_INFERENCE_ERROR: 'TYPE_INFERENCE_ERROR';
+  readonly UNRESOLVED_TYPE: 'UNRESOLVED_TYPE';
+  readonly EXTRACTION_ERROR: 'EXTRACTION_ERROR';
+  readonly PROCESSING_ERROR: 'PROCESSING_ERROR';
+  readonly VALIDATION_ERROR: 'VALIDATION_ERROR';
+  readonly INVALID_DECLARATION: 'INVALID_DECLARATION';
+  readonly CONFIG_ERROR: 'CONFIG_ERROR';
+  readonly INVALID_ENTRYPOINT: 'INVALID_ENTRYPOINT';
+  readonly CIRCULAR_DEPENDENCY: 'CIRCULAR_DEPENDENCY';
+  readonly TIMEOUT_ERROR: 'TIMEOUT_ERROR';
+  readonly NOT_SUPPORTED: 'NOT_SUPPORTED';
+  readonly UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * Base error class for dtsx errors
+ */
+export declare class DtsxError extends Error {
+  readonly code: ErrorCode;
+  readonly context?: Record<string, unknown>;
+  constructor(message: string, code?: ErrorCode, context?: Record<string, unknown>);
+  toString(): string;
+  toJSON(): Record<string, unknown>;
+}
+/**
+ * Error during file parsing
+ */
+export declare class ParseError extends DtsxError {
+  readonly filePath: string;
+  readonly line?: number;
+  readonly column?: number;
+  constructor(message: string, filePath: string, options?: { line?: number, column?: number, cause?: Error });
+  get locationString(): string;
+}
+/**
+ * Error during declaration extraction
+ */
+export declare class ExtractionError extends DtsxError {
+  readonly filePath: string;
+  readonly declarationKind?: string;
+  constructor(message: string, filePath: string, declarationKind?: string, cause?: Error);
+}
+/**
+ * Error during type processing
+ */
+export declare class ProcessingError extends DtsxError {
+  readonly declarationName?: string;
+  constructor(message: string, declarationName?: string, cause?: Error);
+}
+/**
+ * Error during file I/O operations
+ */
+export declare class FileError extends DtsxError {
+  readonly filePath: string;
+  readonly operation: 'read' | 'write' | 'delete' | 'stat' | 'glob';
+  constructor(message: string, filePath: string, operation: 'read' | 'write' | 'delete' | 'stat' | 'glob', cause?: Error);
+}
+/**
+ * Error during configuration loading or validation
+ */
+export declare class ConfigError extends DtsxError {
+  readonly configPath?: string;
+  readonly invalidKey?: string;
+  constructor(message: string, options?: { configPath?: string, invalidKey?: string, cause?: Error });
+}
+/**
+ * Error when circular dependency is detected
+ */
+export declare class CircularDependencyError extends DtsxError {
+  readonly cycle: string[];
+  constructor(cycle: string[]);
+}

package/dist/src/errors.js

@@ -0,0 +1,2 @@
+// @bun
+import{Ce,E,$n,mi,gi,En,kn,hi,Io,Fo,Lo,No,Bo,Wo,jo,ze,xt,_o}from"../chunk-ezbp8tss.js";export{hi as CircularDependencyError,kn as ConfigError,E as DtsxError,Ce as ErrorCodes,mi as ExtractionError,En as FileError,$n as ParseError,gi as ProcessingError,ze as createDtsError,xt as formatDtsError,jo as formatErrorWithContext,Wo as getLocationFromOffset,No as isConfigError,Io as isDtsxError,Lo as isFileError,Fo as isParseError,_o as summarizeErrors,Bo as wrapError};

package/dist/src/extractor/directives.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extract triple-slash directives from source code.
+ * These are special comments like /// <reference types="..." />
+ */
+export declare function extractTripleSlashDirectives(sourceCode: string): string[];

package/dist/src/extractor/directives.js

@@ -0,0 +1,2 @@
+// @bun
+import{hn}from"../../chunk-60ssvwc8.js";export{hn as extractTripleSlashDirectives};

package/dist/src/extractor/extract.d.ts

@@ -0,0 +1,10 @@
+import type { Declaration } from '../types.js';
+/**
+ * Extract declarations using the fast string scanner (no TS parser).
+ * Results are cached by file path + keepComments flag.
+ */
+export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean, isolatedDeclarations?: boolean, importedFunctions?: ReadonlySet<string>): Declaration[];
+/**
+ * Clear the declaration cache (for benchmarks and testing)
+ */
+export declare function clearDeclarationCache(): void;

package/dist/src/extractor/extract.js

@@ -0,0 +1,2 @@
+// @bun
+import{xe,Sn}from"../../chunk-25vyhfzh.js";import"../../chunk-mt9219xc.js";import"../../chunk-v6fwy63g.js";import"../../chunk-ttc5pr8y.js";import"../../chunk-xr1h3tv2.js";import"../../chunk-gsb3ty07.js";import"../../chunk-s6c98nad.js";import"../../chunk-z4mvkazp.js";import"../../chunk-g9d5r6a8.js";import"../../chunk-wnk9yjw2.js";import"../../chunk-gpq2kggq.js";import"../../chunk-90aptjh6.js";import"../../chunk-rdzfdjkb.js";import"../../chunk-n2nyd0ck.js";import"../../chunk-j6pfxvy8.js";import"../../chunk-2kwjbk55.js";import"../../chunk-69dbf6de.js";import"../../chunk-cen2t56g.js";import"../../chunk-1j6092xz.js";import"../../chunk-zq93f8ca.js";export{Sn as clearDeclarationCache,xe as extractDeclarations};

package/dist/src/extractor/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashContent(content: string): number | bigint;

package/dist/src/extractor/hash.js

@@ -0,0 +1,2 @@
+// @bun
+import{p}from"../../chunk-v6fwy63g.js";export{p as hashContent};