@zipbul/gildash 0.6.0 → 0.7.0

package/dist/src/errors.d.ts

@@ -3,13 +3,14 @@
  */
 export type GildashErrorType = 'watcher' | 'parse' | 'extract' | 'index' | 'store' | 'search' | 'closed' | 'validation' | 'close' | 'semantic';
 /**
- * Plain-object error value used throughout Gildash's Result-based error handling.
- * Produced by {@link gildashError} and carried as the `data` field of an `Err<GildashError>`.
+ * Error class used throughout Gildash.
+ * Extends `Error` so that `instanceof Error` checks work and stack traces are captured.
  */
-export interface GildashError {
-    type: GildashErrorType;
-    message: string;
-    cause?: unknown;
+export declare class GildashError extends Error {
+    readonly type: GildashErrorType;
+    constructor(type: GildashErrorType, message: string, options?: {
+        cause?: unknown;
+    });
 }
 /**
  * Factory function that creates a {@link GildashError} value.
@@ -18,5 +19,6 @@ export interface GildashError {
  * @param message - Human-readable description of the error.
  * @param cause   - Optional root cause (any value). When `undefined`, the `cause`
  *                  property is omitted from the returned object entirely.
+ * @deprecated Use `new GildashError(type, message, { cause })` instead.
  */
 export declare function gildashError(type: GildashErrorType, message: string, cause?: unknown): GildashError;

package/dist/src/gildash/extract-api.d.ts

@@ -1,9 +1,7 @@
-import { type Result } from '@zipbul/result';
 import type { ParsedFile } from '../parser/types';
 import type { ExtractedSymbol, CodeRelation } from '../extractor/types';
-import type { GildashError } from '../errors';
 import type { GildashContext } from './context';
 /** Extract all symbol declarations from a previously parsed file. */
-export declare function extractSymbols(ctx: GildashContext, parsed: ParsedFile): Result<ExtractedSymbol[], GildashError>;
+export declare function extractSymbols(ctx: GildashContext, parsed: ParsedFile): ExtractedSymbol[];
 /** Extract inter-file relationships from a previously parsed file. */
-export declare function extractRelations(ctx: GildashContext, parsed: ParsedFile): Result<CodeRelation[], GildashError>;
+export declare function extractRelations(ctx: GildashContext, parsed: ParsedFile): CodeRelation[];

package/dist/src/gildash/graph-api.d.ts

@@ -1,5 +1,3 @@
-import { type Result } from '@zipbul/result';
-import type { GildashError } from '../errors';
 import { DependencyGraph } from '../search/dependency-graph';
 import type { GildashContext } from './context';
 import type { FanMetrics } from './types';
@@ -11,20 +9,20 @@ export declare function invalidateGraphCache(ctx: GildashContext): void;
  */
 export declare function getOrBuildGraph(ctx: GildashContext, project?: string): DependencyGraph;
 /** List the files that a given file directly imports. */
-export declare function getDependencies(ctx: GildashContext, filePath: string, project?: string, limit?: number): Result<string[], GildashError>;
+export declare function getDependencies(ctx: GildashContext, filePath: string, project?: string, limit?: number): string[];
 /** List the files that directly import a given file. */
-export declare function getDependents(ctx: GildashContext, filePath: string, project?: string, limit?: number): Result<string[], GildashError>;
+export declare function getDependents(ctx: GildashContext, filePath: string, project?: string, limit?: number): string[];
 /** Compute the full set of files transitively affected by changes. */
-export declare function getAffected(ctx: GildashContext, changedFiles: string[], project?: string): Promise<Result<string[], GildashError>>;
+export declare function getAffected(ctx: GildashContext, changedFiles: string[], project?: string): Promise<string[]>;
 /** Check whether the import graph contains a circular dependency. */
-export declare function hasCycle(ctx: GildashContext, project?: string): Promise<Result<boolean, GildashError>>;
+export declare function hasCycle(ctx: GildashContext, project?: string): Promise<boolean>;
 /** Return the full import graph as an adjacency list. */
-export declare function getImportGraph(ctx: GildashContext, project?: string): Promise<Result<Map<string, string[]>, GildashError>>;
+export declare function getImportGraph(ctx: GildashContext, project?: string): Promise<Map<string, string[]>>;
 /** Return all files that `filePath` transitively imports (forward BFS). */
-export declare function getTransitiveDependencies(ctx: GildashContext, filePath: string, project?: string): Promise<Result<string[], GildashError>>;
+export declare function getTransitiveDependencies(ctx: GildashContext, filePath: string, project?: string): Promise<string[]>;
 /** Return all cycle paths in the import graph. */
 export declare function getCyclePaths(ctx: GildashContext, project?: string, options?: {
     maxCycles?: number;
-}): Promise<Result<string[][], GildashError>>;
+}): Promise<string[][]>;
 /** Compute import-graph fan metrics (fan-in / fan-out) for a single file. */
-export declare function getFanMetrics(ctx: GildashContext, filePath: string, project?: string): Promise<Result<FanMetrics, GildashError>>;
+export declare function getFanMetrics(ctx: GildashContext, filePath: string, project?: string): Promise<FanMetrics>;

package/dist/src/gildash/index.d.ts

@@ -1,4 +1,3 @@
-import { type Result } from '@zipbul/result';
 import type { ParsedFile } from '../parser/types';
 import type { ParserOptions } from 'oxc-parser';
 import type { ExtractedSymbol, CodeRelation } from '../extractor/types';
@@ -9,7 +8,6 @@ import type { RelationSearchQuery } from '../search/relation-search';
 import type { SymbolStats } from '../store/repositories/symbol.repository';
 import type { FileRecord } from '../store/repositories/file.repository';
 import type { PatternMatch } from '../search/pattern-search';
-import type { GildashError } from '../errors';
 import type { ResolvedType, SemanticReference, Implementation, SemanticModuleInterface } from '../semantic/types';
 import type { GildashContext } from './context';
 import type { GildashOptions, SymbolDiff, ModuleInterface, HeritageNode, FullSymbol, FileStats, FanMetrics, ResolvedSymbol } from './types';
@@ -22,9 +20,9 @@ export type { GildashInternalOptions } from './lifecycle';
  * `Gildash` indexes TypeScript source code into a local SQLite database,
  * watches for file changes, and provides search / dependency-graph queries.
  *
- * Every public method returns a `Result<T, GildashError>` — either the
- * success value `T` directly, or an `Err<GildashError>` that can be checked
- * with `isErr()` from `@zipbul/result`.
+ * Every public method either returns a value directly or throws a
+ * `GildashError` on failure. Use `try/catch` with `instanceof GildashError`
+ * to handle errors.
  *
  * Create an instance with the static {@link Gildash.open} factory.
  * Always call {@link Gildash.close} when done to release resources.
@@ -41,52 +39,53 @@ export declare class Gildash {
     private constructor();
     /**
      * Create and initialise a new `Gildash` instance.
+     * @throws {GildashError} if initialization fails.
      */
-    static open(options: GildashOptions & GildashInternalOptions): Promise<Result<Gildash, GildashError>>;
+    static open(options: GildashOptions & GildashInternalOptions): Promise<Gildash>;
     /** Shut down the instance and release all resources. */
     close(opts?: {
         cleanup?: boolean;
-    }): Promise<Result<void, GildashError>>;
-    parseSource(filePath: string, sourceText: string, options?: ParserOptions): Result<ParsedFile, GildashError>;
-    batchParse(filePaths: string[], options?: ParserOptions): Promise<Result<Map<string, ParsedFile>, GildashError>>;
+    }): Promise<void>;
+    parseSource(filePath: string, sourceText: string, options?: ParserOptions): ParsedFile;
+    batchParse(filePaths: string[], options?: ParserOptions): Promise<Map<string, ParsedFile>>;
     getParsedAst(filePath: string): ParsedFile | undefined;
-    extractSymbols(parsed: ParsedFile): Result<ExtractedSymbol[], GildashError>;
-    extractRelations(parsed: ParsedFile): Result<CodeRelation[], GildashError>;
-    getStats(project?: string): Result<SymbolStats, GildashError>;
-    searchSymbols(query: SymbolSearchQuery): Result<SymbolSearchResult[], GildashError>;
-    searchRelations(query: RelationSearchQuery): Result<CodeRelation[], GildashError>;
+    extractSymbols(parsed: ParsedFile): ExtractedSymbol[];
+    extractRelations(parsed: ParsedFile): CodeRelation[];
+    getStats(project?: string): SymbolStats;
+    searchSymbols(query: SymbolSearchQuery): SymbolSearchResult[];
+    searchRelations(query: RelationSearchQuery): CodeRelation[];
     searchAllSymbols(query: Omit<SymbolSearchQuery, 'project'> & {
         project?: string;
-    }): Result<SymbolSearchResult[], GildashError>;
-    searchAllRelations(query: RelationSearchQuery): Result<CodeRelation[], GildashError>;
-    listIndexedFiles(project?: string): Result<FileRecord[], GildashError>;
-    getInternalRelations(filePath: string, project?: string): Result<CodeRelation[], GildashError>;
-    getFullSymbol(symbolName: string, filePath: string, project?: string): Result<FullSymbol, GildashError>;
-    getFileStats(filePath: string, project?: string): Result<FileStats, GildashError>;
-    getFileInfo(filePath: string, project?: string): Result<FileRecord | null, GildashError>;
-    getSymbolsByFile(filePath: string, project?: string): Result<SymbolSearchResult[], GildashError>;
-    getModuleInterface(filePath: string, project?: string): Result<ModuleInterface, GildashError>;
-    getDependencies(filePath: string, project?: string, limit?: number): Result<string[], GildashError>;
-    getDependents(filePath: string, project?: string, limit?: number): Result<string[], GildashError>;
-    getAffected(changedFiles: string[], project?: string): Promise<Result<string[], GildashError>>;
-    hasCycle(project?: string): Promise<Result<boolean, GildashError>>;
-    getImportGraph(project?: string): Promise<Result<Map<string, string[]>, GildashError>>;
-    getTransitiveDependencies(filePath: string, project?: string): Promise<Result<string[], GildashError>>;
+    }): SymbolSearchResult[];
+    searchAllRelations(query: RelationSearchQuery): CodeRelation[];
+    listIndexedFiles(project?: string): FileRecord[];
+    getInternalRelations(filePath: string, project?: string): CodeRelation[];
+    getFullSymbol(symbolName: string, filePath: string, project?: string): FullSymbol | null;
+    getFileStats(filePath: string, project?: string): FileStats;
+    getFileInfo(filePath: string, project?: string): FileRecord | null;
+    getSymbolsByFile(filePath: string, project?: string): SymbolSearchResult[];
+    getModuleInterface(filePath: string, project?: string): ModuleInterface;
+    getDependencies(filePath: string, project?: string, limit?: number): string[];
+    getDependents(filePath: string, project?: string, limit?: number): string[];
+    getAffected(changedFiles: string[], project?: string): Promise<string[]>;
+    hasCycle(project?: string): Promise<boolean>;
+    getImportGraph(project?: string): Promise<Map<string, string[]>>;
+    getTransitiveDependencies(filePath: string, project?: string): Promise<string[]>;
     getCyclePaths(project?: string, options?: {
         maxCycles?: number;
-    }): Promise<Result<string[][], GildashError>>;
-    getFanMetrics(filePath: string, project?: string): Promise<Result<FanMetrics, GildashError>>;
-    getResolvedType(symbolName: string, filePath: string, project?: string): Result<ResolvedType | null, GildashError>;
-    getSemanticReferences(symbolName: string, filePath: string, project?: string): Result<SemanticReference[], GildashError>;
-    getImplementations(symbolName: string, filePath: string, project?: string): Result<Implementation[], GildashError>;
-    getSemanticModuleInterface(filePath: string): Result<SemanticModuleInterface, GildashError>;
+    }): Promise<string[][]>;
+    getFanMetrics(filePath: string, project?: string): Promise<FanMetrics>;
+    getResolvedType(symbolName: string, filePath: string, project?: string): ResolvedType | null;
+    getSemanticReferences(symbolName: string, filePath: string, project?: string): SemanticReference[];
+    getImplementations(symbolName: string, filePath: string, project?: string): Implementation[];
+    getSemanticModuleInterface(filePath: string): SemanticModuleInterface;
     diffSymbols(before: SymbolSearchResult[], after: SymbolSearchResult[]): SymbolDiff;
     onIndexed(callback: (result: IndexResult) => void): () => void;
-    reindex(): Promise<Result<IndexResult, GildashError>>;
-    resolveSymbol(symbolName: string, filePath: string, project?: string): Result<ResolvedSymbol, GildashError>;
+    reindex(): Promise<IndexResult>;
+    resolveSymbol(symbolName: string, filePath: string, project?: string): ResolvedSymbol;
     findPattern(pattern: string, opts?: {
         filePaths?: string[];
         project?: string;
-    }): Promise<Result<PatternMatch[], GildashError>>;
-    getHeritageChain(symbolName: string, filePath: string, project?: string): Promise<Result<HeritageNode, GildashError>>;
+    }): Promise<PatternMatch[]>;
+    getHeritageChain(symbolName: string, filePath: string, project?: string): Promise<HeritageNode>;
 }

package/dist/src/gildash/lifecycle.d.ts

@@ -1,4 +1,3 @@
-import { type Result } from '@zipbul/result';
 import { FileRepository } from '../store/repositories/file.repository';
 import { SymbolRepository } from '../store/repositories/symbol.repository';
 import { RelationRepository } from '../store/repositories/relation.repository';
@@ -13,7 +12,6 @@ import { symbolSearch as defaultSymbolSearch } from '../search/symbol-search';
 import { relationSearch as defaultRelationSearch } from '../search/relation-search';
 import type { PatternMatch } from '../search/pattern-search';
 import { SemanticLayer } from '../semantic/index';
-import type { GildashError } from '../errors';
 import type { GildashContext, CoordinatorLike, WatcherLike, DbStore } from './context';
 import type { GildashOptions } from './types';
 export declare const HEARTBEAT_INTERVAL_MS = 30000;
@@ -46,17 +44,17 @@ export interface GildashInternalOptions {
     loadTsconfigPathsFn?: typeof loadTsconfigPaths;
     readFileFn?: (filePath: string) => Promise<string>;
     unlinkFn?: (filePath: string) => Promise<void>;
-    semanticLayerFactory?: (tsconfigPath: string) => Result<SemanticLayer, GildashError>;
+    semanticLayerFactory?: (tsconfigPath: string) => SemanticLayer;
 }
 /** Create coordinator + watcher, start watcher, heartbeat timer, run fullIndex. */
 export declare function setupOwnerInfrastructure(ctx: GildashContext, opts: {
     isWatchMode: boolean;
 }): Promise<void>;
 /** Register SIGTERM / SIGINT / beforeExit handlers. */
-export declare function registerSignalHandlers(ctx: GildashContext, closeFn: () => Promise<Result<void, GildashError> | undefined>): void;
+export declare function registerSignalHandlers(ctx: GildashContext, closeFn: () => Promise<void>): void;
 /** Initialize a GildashContext (replaces the old `Gildash.open()` body). */
-export declare function initializeContext(options: GildashOptions & GildashInternalOptions): Promise<Result<GildashContext, GildashError>>;
+export declare function initializeContext(options: GildashOptions & GildashInternalOptions): Promise<GildashContext>;
 /** Shut down the context and release all resources. */
 export declare function closeContext(ctx: GildashContext, opts?: {
     cleanup?: boolean;
-}): Promise<Result<void, GildashError>>;
+}): Promise<void>;

package/dist/src/gildash/misc-api.d.ts

@@ -1,8 +1,6 @@
-import { type Result } from '@zipbul/result';
 import type { SymbolSearchResult } from '../search/symbol-search';
 import type { IndexResult } from '../indexer/index-coordinator';
 import type { PatternMatch } from '../search/pattern-search';
-import type { GildashError } from '../errors';
 import type { GildashContext } from './context';
 import type { SymbolDiff, ResolvedSymbol, HeritageNode } from './types';
 /** Compare two snapshots of symbol search results and return a structured diff. */
@@ -10,13 +8,13 @@ export declare function diffSymbols(before: SymbolSearchResult[], after: SymbolS
 /** Register a callback that fires after each indexing run completes. */
 export declare function onIndexed(ctx: GildashContext, callback: (result: IndexResult) => void): () => void;
 /** Trigger a full re-index of all tracked files. */
-export declare function reindex(ctx: GildashContext): Promise<Result<IndexResult, GildashError>>;
+export declare function reindex(ctx: GildashContext): Promise<IndexResult>;
 /** Resolve the original definition location of a symbol by following its re-export chain. */
-export declare function resolveSymbol(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Result<ResolvedSymbol, GildashError>;
+export declare function resolveSymbol(ctx: GildashContext, symbolName: string, filePath: string, project?: string): ResolvedSymbol;
 /** Search for an AST structural pattern across indexed TypeScript files. */
 export declare function findPattern(ctx: GildashContext, pattern: string, opts?: {
     filePaths?: string[];
     project?: string;
-}): Promise<Result<PatternMatch[], GildashError>>;
+}): Promise<PatternMatch[]>;
 /** Recursively traverse extends/implements relations to build a heritage tree. */
-export declare function getHeritageChain(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Promise<Result<HeritageNode, GildashError>>;
+export declare function getHeritageChain(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Promise<HeritageNode>;

package/dist/src/gildash/parse-api.d.ts

@@ -1,11 +1,9 @@
-import { type Result } from '@zipbul/result';
 import type { ParsedFile } from '../parser/types';
 import type { ParserOptions } from 'oxc-parser';
-import type { GildashError } from '../errors';
 import type { GildashContext } from './context';
 /** Parse a TypeScript source string into an AST and cache the result. */
-export declare function parseSource(ctx: GildashContext, filePath: string, sourceText: string, options?: ParserOptions): Result<ParsedFile, GildashError>;
+export declare function parseSource(ctx: GildashContext, filePath: string, sourceText: string, options?: ParserOptions): ParsedFile;
 /** Parse multiple files concurrently and return a map of results. */
-export declare function batchParse(ctx: GildashContext, filePaths: string[], options?: ParserOptions): Promise<Result<Map<string, ParsedFile>, GildashError>>;
+export declare function batchParse(ctx: GildashContext, filePaths: string[], options?: ParserOptions): Promise<Map<string, ParsedFile>>;
 /** Retrieve a previously-parsed AST from the internal LRU cache. */
 export declare function getParsedAst(ctx: GildashContext, filePath: string): ParsedFile | undefined;

package/dist/src/gildash/query-api.d.ts

@@ -1,35 +1,33 @@
-import { type Result } from '@zipbul/result';
 import type { SymbolSearchQuery, SymbolSearchResult } from '../search/symbol-search';
 import type { RelationSearchQuery } from '../search/relation-search';
 import type { CodeRelation } from '../extractor/types';
 import type { FileRecord } from '../store/repositories/file.repository';
 import type { SymbolStats } from '../store/repositories/symbol.repository';
-import type { GildashError } from '../errors';
 import type { GildashContext } from './context';
 import type { FullSymbol, FileStats, ModuleInterface } from './types';
 /** Return aggregate symbol statistics for the given project. */
-export declare function getStats(ctx: GildashContext, project?: string): Result<SymbolStats, GildashError>;
+export declare function getStats(ctx: GildashContext, project?: string): SymbolStats;
 /** Search indexed symbols by name, kind, file path, or export status. */
-export declare function searchSymbols(ctx: GildashContext, query: SymbolSearchQuery): Result<SymbolSearchResult[], GildashError>;
+export declare function searchSymbols(ctx: GildashContext, query: SymbolSearchQuery): SymbolSearchResult[];
 /** Search indexed code relationships (imports, calls, extends, implements). */
-export declare function searchRelations(ctx: GildashContext, query: RelationSearchQuery): Result<CodeRelation[], GildashError>;
+export declare function searchRelations(ctx: GildashContext, query: RelationSearchQuery): CodeRelation[];
 /** Search symbols across all projects (no project filter). */
 export declare function searchAllSymbols(ctx: GildashContext, query: Omit<SymbolSearchQuery, 'project'> & {
     project?: string;
-}): Result<SymbolSearchResult[], GildashError>;
+}): SymbolSearchResult[];
 /** Search relations across all projects (no project filter). */
-export declare function searchAllRelations(ctx: GildashContext, query: RelationSearchQuery): Result<CodeRelation[], GildashError>;
+export declare function searchAllRelations(ctx: GildashContext, query: RelationSearchQuery): CodeRelation[];
 /** List all files indexed for a given project. */
-export declare function listIndexedFiles(ctx: GildashContext, project?: string): Result<FileRecord[], GildashError>;
+export declare function listIndexedFiles(ctx: GildashContext, project?: string): FileRecord[];
 /** Get all intra-file relations for a given file. */
-export declare function getInternalRelations(ctx: GildashContext, filePath: string, project?: string): Result<CodeRelation[], GildashError>;
+export declare function getInternalRelations(ctx: GildashContext, filePath: string, project?: string): CodeRelation[];
 /** Retrieve full details for a named symbol in a specific file. */
-export declare function getFullSymbol(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Result<FullSymbol, GildashError>;
+export declare function getFullSymbol(ctx: GildashContext, symbolName: string, filePath: string, project?: string): FullSymbol | null;
 /** Retrieve statistics for an indexed file. */
-export declare function getFileStats(ctx: GildashContext, filePath: string, project?: string): Result<FileStats, GildashError>;
+export declare function getFileStats(ctx: GildashContext, filePath: string, project?: string): FileStats;
 /** Retrieve metadata for an indexed file. */
-export declare function getFileInfo(ctx: GildashContext, filePath: string, project?: string): Result<FileRecord | null, GildashError>;
+export declare function getFileInfo(ctx: GildashContext, filePath: string, project?: string): FileRecord | null;
 /** List all symbols declared in a specific file. */
-export declare function getSymbolsByFile(ctx: GildashContext, filePath: string, project?: string): Result<SymbolSearchResult[], GildashError>;
+export declare function getSymbolsByFile(ctx: GildashContext, filePath: string, project?: string): SymbolSearchResult[];
 /** Return the public interface of a module. */
-export declare function getModuleInterface(ctx: GildashContext, filePath: string, project?: string): Result<ModuleInterface, GildashError>;
+export declare function getModuleInterface(ctx: GildashContext, filePath: string, project?: string): ModuleInterface;

package/dist/src/gildash/semantic-api.d.ts

@@ -1,6 +1,4 @@
-import { type Result } from '@zipbul/result';
 import type { SymbolSearchResult } from '../search/symbol-search';
-import type { GildashError } from '../errors';
 import type { ResolvedType, SemanticReference, Implementation, SemanticModuleInterface } from '../semantic/types';
 import type { GildashContext } from './context';
 /**
@@ -13,10 +11,10 @@ export declare function resolveSymbolPosition(ctx: GildashContext, symbolName: s
     absPath: string;
 } | null;
 /** Retrieve the resolved type of a symbol using the Semantic Layer. */
-export declare function getResolvedType(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Result<ResolvedType | null, GildashError>;
+export declare function getResolvedType(ctx: GildashContext, symbolName: string, filePath: string, project?: string): ResolvedType | null;
 /** Find all semantic references to a symbol. */
-export declare function getSemanticReferences(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Result<SemanticReference[], GildashError>;
+export declare function getSemanticReferences(ctx: GildashContext, symbolName: string, filePath: string, project?: string): SemanticReference[];
 /** Find implementations of an interface/abstract class. */
-export declare function getImplementations(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Result<Implementation[], GildashError>;
+export declare function getImplementations(ctx: GildashContext, symbolName: string, filePath: string, project?: string): Implementation[];
 /** Retrieve the semantic module interface — exported symbols with resolved types. */
-export declare function getSemanticModuleInterface(ctx: GildashContext, filePath: string): Result<SemanticModuleInterface, GildashError>;
+export declare function getSemanticModuleInterface(ctx: GildashContext, filePath: string): SemanticModuleInterface;

package/dist/src/gildash/types.d.ts

@@ -123,6 +123,8 @@ export interface ResolvedSymbol {
         filePath: string;
         exportedAs: string;
     }>;
+    /** Whether a circular re-export chain was detected. */
+    circular: boolean;
 }
 /**
  * Options for creating a {@link Gildash} instance via {@link Gildash.open}.

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 export { Gildash } from "./gildash";
 export type { GildashOptions, Logger, SymbolDiff, ModuleInterface, HeritageNode, FullSymbol, FileStats, FanMetrics, ResolvedSymbol } from "./gildash";
-export { gildashError } from "./errors";
-export type { GildashError, GildashErrorType } from "./errors";
+export { GildashError, gildashError } from "./errors";
+export type { GildashErrorType } from "./errors";
 export { symbolSearch } from "./search/symbol-search";
 export type { SymbolSearchQuery, SymbolSearchResult } from "./search/symbol-search";
 export { relationSearch } from "./search/relation-search";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/gildash",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "TypeScript code indexing and dependency graph engine for Bun",
   "license": "MIT",
   "repository": {
@@ -44,6 +44,7 @@
   "dependencies": {
     "@ast-grep/napi": "^0.41.0",
     "@parcel/watcher": "^2.5.6",
+    "@zipbul/result": "^0.1.4",
     "comment-parser": "1.4.5",
     "drizzle-orm": "^0.45.1",
     "oxc-parser": "0.115.0"
@@ -59,7 +60,11 @@
     "typescript": "^5.8.0"
   },
   "peerDependencies": {
-    "@zipbul/result": "^0.0.3",
-    "oxc-parser": ">=0.114.0"
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   }
 }