@zipbul/gildash 0.6.0 → 0.8.0

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,12 +8,13 @@ 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';
+import type { FileChangeEvent } from '../watcher/types';
+import { GildashError } from '../errors';
+import type { GildashOptions, SymbolDiff, ModuleInterface, HeritageNode, FullSymbol, FileStats, FanMetrics, ResolvedSymbol, BatchParseResult } from './types';
 import type { GildashInternalOptions } from './lifecycle';
-export type { Logger, GildashOptions, SymbolDiff, ModuleInterface, HeritageNode, FullSymbol, FileStats, FanMetrics, ResolvedSymbol, } from './types';
+export type { Logger, GildashOptions, SymbolDiff, ModuleInterface, HeritageNode, FullSymbol, FileStats, FanMetrics, ResolvedSymbol, BatchParseResult, } from './types';
 export type { GildashInternalOptions } from './lifecycle';
 /**
  * Main entry point for gildash.
@@ -22,9 +22,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 +41,56 @@ 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<BatchParseResult>;
     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>;
+    onFileChanged(callback: (event: FileChangeEvent) => void): () => void;
+    onError(callback: (error: GildashError) => void): () => void;
+    onRoleChanged(callback: (newRole: 'owner' | 'reader') => void): () => void;
 }

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,11 +12,10 @@ 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;
-export declare const HEALTHCHECK_INTERVAL_MS = 60000;
+export declare const HEALTHCHECK_INTERVAL_MS = 15000;
 export declare const MAX_HEALTHCHECK_RETRIES = 10;
 export interface GildashInternalOptions {
     existsSyncFn?: (p: string) => boolean;
@@ -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,8 @@
-import { type Result } from '@zipbul/result';
 import type { SymbolSearchResult } from '../search/symbol-search';
 import type { IndexResult } from '../indexer/index-coordinator';
+import type { FileChangeEvent } from '../watcher/types';
 import type { PatternMatch } from '../search/pattern-search';
-import type { GildashError } from '../errors';
+import { 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 +10,19 @@ 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;
+/** Register a callback that fires whenever a watched file changes. */
+export declare function onFileChanged(ctx: GildashContext, callback: (event: FileChangeEvent) => void): () => void;
+/** Register a callback that fires on internal errors (e.g. healthcheck failures). */
+export declare function onError(ctx: GildashContext, callback: (error: GildashError) => void): () => void;
+/** Register a callback that fires when the watcher role changes (reader → owner). */
+export declare function onRoleChanged(ctx: GildashContext, callback: (newRole: 'owner' | 'reader') => void): () => void;
 /** 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,10 @@
-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';
+import type { BatchParseResult } from './types';
 /** 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>;
-/** 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 parseSource(ctx: GildashContext, filePath: string, sourceText: string, options?: ParserOptions): ParsedFile;
+/** Parse multiple files concurrently and return results with failure details. */
+export declare function batchParse(ctx: GildashContext, filePaths: string[], options?: ParserOptions): Promise<BatchParseResult>;
 /** 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

@@ -1,3 +1,4 @@
+import type { ParsedFile } from '../parser/types';
 import type { SymbolSearchResult } from '../search/symbol-search';
 import type { SymbolKind } from '../extractor/types';
 import type { ResolvedType } from '../semantic/types';
@@ -123,6 +124,21 @@ export interface ResolvedSymbol {
         filePath: string;
         exportedAs: string;
     }>;
+    /** Whether a circular re-export chain was detected. */
+    circular: boolean;
+}
+/**
+ * Result of a batch parse operation.
+ * Contains both successful parses and failure details.
+ */
+export interface BatchParseResult {
+    /** Successfully parsed files. */
+    parsed: Map<string, ParsedFile>;
+    /** Files that failed to parse, with error details. */
+    failures: Array<{
+        filePath: string;
+        error: Error;
+    }>;
 }
 /**
  * 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/dist/src/indexer/index-coordinator.d.ts

@@ -9,6 +9,7 @@ import type { SymbolRecord } from '../store/repositories/symbol.repository';
 import type { RelationRecord } from '../store/repositories/relation.repository';
 import type { Logger } from '../gildash';
 export declare const WATCHER_DEBOUNCE_MS = 100;
+export declare const FILE_READ_BATCH_SIZE = 50;
 /**
  * Summary returned after an indexing run completes.
  *

package/dist/src/search/dependency-graph.d.ts

@@ -32,6 +32,19 @@ export declare class DependencyGraph {
      * Must be called before any query method.
      */
     build(): void;
+    /**
+     * Incrementally patch the graph after a set of files changed or were deleted.
+     *
+     * For small change-sets this is much cheaper than a full {@link build}.
+     *
+     * @param changedFiles  - Files whose edges may have changed.
+     * @param deletedFiles  - Files that were removed from the project.
+     * @param getRelationsForFile - Callback to query current relations for a file.
+     */
+    patchFiles(changedFiles: string[], deletedFiles: string[], getRelationsForFile: (filePath: string) => Array<{
+        srcFilePath: string;
+        dstFilePath: string;
+    }>): void;
     /**
      * Return the files that `filePath` directly imports.
      *

package/dist/src/store/connection.d.ts

@@ -21,9 +21,10 @@ export declare class DbConnection {
     selectOwner(): {
         pid: number;
         heartbeat_at: string;
+        instance_id: string | null;
     } | undefined;
-    insertOwner(pid: number): void;
-    replaceOwner(pid: number): void;
+    insertOwner(pid: number, instanceId?: string): void;
+    replaceOwner(pid: number, instanceId?: string): void;
     touchOwner(pid: number): void;
     deleteOwner(pid: number): void;
     private requireClient;

package/dist/src/store/schema.d.ts

@@ -683,6 +683,25 @@ export declare const watcherOwner: import("drizzle-orm/sqlite-core").SQLiteTable
         }, {}, {
             length: number | undefined;
         }>;
+        instanceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "instance_id";
+            tableName: "watcher_owner";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "sqlite";
 }>;

package/dist/src/watcher/ownership.d.ts

@@ -2,12 +2,13 @@ import type { WatcherRole } from "./types";
 interface WatcherOwnerRow {
     pid: number;
     heartbeat_at: string;
+    instance_id: string | null;
 }
 export interface WatcherOwnerStore {
     immediateTransaction<T>(fn: () => T): T;
     selectOwner(): WatcherOwnerRow | undefined;
-    insertOwner(pid: number): void;
-    replaceOwner(pid: number): void;
+    insertOwner(pid: number, instanceId?: string): void;
+    replaceOwner(pid: number, instanceId?: string): void;
     touchOwner(pid: number): void;
     deleteOwner(pid: number): void;
 }
@@ -15,6 +16,7 @@ interface AcquireOptions {
     now?: () => number;
     isAlive?: (pid: number) => boolean;
     staleAfterSeconds?: number;
+    instanceId?: string;
 }
 export declare function acquireWatcherRole(db: WatcherOwnerStore, pid: number, options?: AcquireOptions): WatcherRole;
 export declare function releaseWatcherRole(db: WatcherOwnerStore, pid: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/gildash",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "TypeScript code indexing and dependency graph engine for Bun",
   "license": "MIT",
   "repository": {
@@ -39,11 +39,14 @@
     "changeset": "changeset",
     "version-packages": "changeset version",
     "release": "changeset publish",
+    "bench": "bun run bench/index-benchmark.ts && bun run bench/search-benchmark.ts && bun run bench/graph-benchmark.ts",
+    "bench:oss": "bun run bench/oss-benchmark.ts",
     "prepare": "husky"
   },
   "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"
@@ -55,11 +58,16 @@
     "@commitlint/config-conventional": "^20.4.2",
     "@types/bun": "latest",
     "drizzle-kit": "^0.31.9",
+    "fast-check": "^4.5.3",
     "husky": "^9.1.7",
     "typescript": "^5.8.0"
   },
   "peerDependencies": {
-    "@zipbul/result": "^0.0.3",
-    "oxc-parser": ">=0.114.0"
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   }
 }