@zipbul/gildash 0.33.0 → 0.34.1

package/dist/src/common/hasher.d.ts

@@ -1,2 +1 @@
 export declare function hashString(input: string): string;
-export declare function hashFile(filePath: string): Promise<string>;

package/dist/src/common/path-utils.d.ts

@@ -1,3 +1,13 @@
+declare const RelBrand: unique symbol;
+declare const AbsBrand: unique symbol;
+/** A project-relative, forward-slash-normalized path (store/query domain). */
+export type RelPath = string & {
+    readonly [RelBrand]: never;
+};
+/** An absolute, forward-slash-normalized path (fs / tsc domain). */
+export type AbsPath = string & {
+    readonly [AbsBrand]: never;
+};
 /**
  * Normalize a file path to always use forward slashes.
  *
@@ -6,5 +16,21 @@
  * so every path that enters the system must pass through this function.
  */
 export declare function normalizePath(p: string): string;
-export declare function toRelativePath(projectRoot: string, absolutePath: string): string;
-export declare function toAbsolutePath(projectRoot: string, relativePath: string): string;
+/** Project-relative, normalized path from an absolute one. */
+export declare function toRelativePath(projectRoot: string, absolutePath: string): RelPath;
+/** Absolute, normalized path from a project-relative one. */
+export declare function toAbsolutePath(projectRoot: string, relativePath: string): AbsPath;
+/**
+ * Brand a string that is already a project-relative path (e.g. a value read
+ * back from the store, or a relative input from a caller) as {@link RelPath},
+ * normalizing separators. Use {@link toRelativePath} when the input may be
+ * absolute.
+ */
+export declare function relPath(p: string): RelPath;
+/**
+ * Normalize an inbound caller path (which may be absolute or relative) to the
+ * store's {@link RelPath} domain. This is the single entry-point every public
+ * facade method routes a `filePath` argument through.
+ */
+export declare function inboundRelPath(projectRoot: string, filePath: string): RelPath;
+export {};

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

@@ -146,7 +146,8 @@ export interface ExpressionUnresolvable {
  * - `'namespace'` — `namespace`, `declare namespace`, and `declare module` declarations
  * - `'property'` — class properties and interface/type members
  */
-export type SymbolKind = 'function' | 'method' | 'class' | 'variable' | 'type' | 'interface' | 'enum' | 'namespace' | 'property';
+export declare const SYMBOL_KINDS: readonly ["function", "method", "class", "variable", "type", "interface", "enum", "namespace", "property"];
+export type SymbolKind = (typeof SYMBOL_KINDS)[number];
 /**
  * TypeScript declaration modifiers attached to a symbol.
  */
@@ -304,9 +305,11 @@ export interface ImportReference {
  * - `'extends'` — class/interface in file A extends one in file B
  * - `'implements'` — class in file A implements an interface in file B
  */
+export declare const RELATION_TYPES: readonly ["imports", "type-references", "re-exports", "calls", "extends", "implements"];
+export type RelationType = (typeof RELATION_TYPES)[number];
 export interface CodeRelation {
     /** The kind of relationship. */
-    type: 'imports' | 'type-references' | 're-exports' | 'calls' | 'extends' | 'implements';
+    type: RelationType;
     /** File path where the relationship originates. */
     srcFilePath: string;
     /** Source symbol name, or `null` for module-level relationships. */
@@ -341,7 +344,8 @@ export interface CodeRelation {
      */
     specifier?: string;
 }
-export type AnnotationSource = 'jsdoc' | 'line' | 'block';
+export declare const ANNOTATION_SOURCES: readonly ["jsdoc", "line", "block"];
+export type AnnotationSource = (typeof ANNOTATION_SOURCES)[number];
 export interface ExtractedAnnotation {
     tag: string;
     value: string;

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

@@ -14,12 +14,13 @@ import type { WatcherOwnerStore } from '../watcher/ownership';
 import type { WatcherRole } from '../watcher/types';
 import type { ProjectBoundary } from '../common/project-discovery';
 import type { TsconfigPaths } from '../common/tsconfig-resolver';
-import type { SymbolSearchQuery, SymbolSearchResult, ISymbolRepo } from '../search/symbol-search';
-import type { RelationSearchQuery, IRelationRepo } from '../search/relation-search';
+import type { SymbolSearchQuery, SymbolSearchResult, SymbolRepositoryReader } from '../search/symbol-search';
+import type { RelationSearchQuery, RelationRepositoryReader } from '../search/relation-search';
 import type { PatternMatch } from '../search/pattern-search';
-import type { AnnotationSearchQuery, AnnotationSearchResult, IAnnotationRepo } from '../search/annotation-search';
+import type { AnnotationSearchQuery, AnnotationSearchResult, AnnotationRepositoryReader } from '../search/annotation-search';
 import type { DependencyGraph } from '../search/dependency-graph';
 import type { ChangelogRepository } from '../store/repositories/changelog.repository';
+import type { AnnotationRepository } from '../store/repositories/annotation.repository';
 import type { SemanticLayer } from '../semantic/index';
 import type { ParseCache } from '../parser/parse-cache';
 import type { GildashError } from '../errors';
@@ -28,12 +29,14 @@ export type ParseSourceFn = (filePath: string, sourceText: string, options?: Par
 export type ExtractSymbolsFn = (parsed: ParsedFile) => ExtractedSymbol[];
 export type ExtractRelationsFn = (ast: Program, filePath: string, tsconfigPaths?: TsconfigPaths) => CodeRelation[];
 export type SymbolSearchFn = (options: {
-    symbolRepo: ISymbolRepo;
+    symbolRepo: SymbolRepositoryReader;
+    projectRoot: string;
     project?: string;
     query: SymbolSearchQuery;
 }) => SymbolSearchResult[];
 export type RelationSearchFn = (options: {
-    relationRepo: IRelationRepo;
+    relationRepo: RelationRepositoryReader;
+    projectRoot: string;
     project?: string;
     query: RelationSearchQuery;
 }) => StoredCodeRelation[];
@@ -42,7 +45,7 @@ export type PatternSearchFn = (opts: {
     filePaths: string[];
 }) => Promise<PatternMatch[]>;
 export type AnnotationSearchFn = (options: {
-    annotationRepo: IAnnotationRepo;
+    annotationRepo: AnnotationRepositoryReader;
     project?: string;
     query: AnnotationSearchQuery;
 }) => AnnotationSearchResult[];
@@ -57,7 +60,7 @@ export type CoordinatorLike = Pick<IndexCoordinator, 'fullIndex' | 'shutdown' |
     handleWatcherEvent?(event: FileChangeEvent): void;
 };
 export type WatcherLike = Pick<ProjectWatcher, 'start' | 'close'>;
-export type SemanticLayerLike = Pick<SemanticLayer, 'collectTypeAt' | 'collectFileTypes' | 'collectTypesAtPositions' | 'collectAtSpan' | 'isThenableAtSpan' | 'contextualCallReturnsAtSpan' | 'findReferences' | 'findEnrichedReferences' | 'getFileBindings' | 'getFileBindingsBatch' | 'getStandaloneFileBindings' | 'findImplementations' | 'isTypeAssignableTo' | 'isTypeAssignableToType' | 'isTypeAssignableToTypeAtPositions' | 'getModuleInterface' | 'getSymbolNode' | 'getBaseTypes' | 'getDiagnostics' | 'notifyFileChanged' | 'notifyFileDeleted' | 'dispose' | 'isDisposed' | 'lineColumnToPosition' | 'findNamePosition'>;
+export type SemanticLayerLike = Pick<SemanticLayer, 'collectTypeAt' | 'collectFileTypes' | 'collectTypesAtPositions' | 'collectAtSpan' | 'isThenableAtSpan' | 'contextualCallReturnsAtSpan' | 'isTypeAssignableToTypeAtSpan' | 'findReferences' | 'findEnrichedReferences' | 'getFileBindings' | 'getFileBindingsBatch' | 'getStandaloneFileBindings' | 'findImplementations' | 'isTypeAssignableTo' | 'isTypeAssignableToType' | 'isTypeAssignableToTypeAtPositions' | 'getModuleInterface' | 'getSymbolNode' | 'getBaseTypes' | 'getDiagnostics' | 'notifyFileChanged' | 'notifyFileDeleted' | 'dispose' | 'isDisposed' | 'lineColumnToPosition' | 'findNamePosition'>;
 /** Internal shared state for all Gildash API modules. */
 export interface GildashContext {
     readonly projectRoot: string;
@@ -71,7 +74,7 @@ export interface GildashContext {
     readonly relationRepo: RelationRepository;
     readonly fileRepo: FileRepoLike;
     readonly parseCache: ParseCacheLike;
-    readonly annotationRepo: IAnnotationRepo | null;
+    readonly annotationRepo: AnnotationRepository | null;
     readonly changelogRepo: ChangelogRepository | null;
     readonly annotationSearchFn: AnnotationSearchFn | null;
     readonly releaseWatcherRoleFn: ReleaseWatcherRoleFn;
@@ -93,7 +96,7 @@ export interface GildashContext {
     coordinator: CoordinatorLike | null;
     watcher: WatcherLike | null;
     timer: ReturnType<typeof setInterval> | null;
-    signalHandlers: Array<[string, () => void]>;
+    signalHandlers: Array<[NodeJS.Signals | 'beforeExit', () => void]>;
     tsconfigPaths: TsconfigPaths | null;
     boundaries: ProjectBoundary[];
     onIndexedCallbacks: Set<(result: IndexResult) => void>;

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

@@ -0,0 +1,23 @@
+import { type GildashErrorType } from '../errors';
+import type { GildashContext } from './context';
+/**
+ * Shared open-state precondition for every facade operation.
+ * Throws `GildashError('closed')` if the instance has been closed.
+ *
+ * Use this directly for operations that have no failure mode to wrap
+ * (e.g. callback subscriptions); use {@link guard} / {@link guardAsync}
+ * when the operation can throw and its errors must be normalized.
+ */
+export declare function assertOpen(ctx: GildashContext): void;
+/**
+ * Run a synchronous facade operation under the uniform guard:
+ * reject use after close, pass any {@link GildashError} through untouched,
+ * and wrap every other thrown error as a `GildashError` of `errorType`
+ * with the message `Gildash: <op> failed`.
+ *
+ * This is the single definition of the facade's closed-check + error-wrap
+ * contract — individual API functions must not re-implement it by hand.
+ */
+export declare function guard<T>(ctx: GildashContext, errorType: GildashErrorType, op: string, fn: () => T): T;
+/** Async counterpart of {@link guard}. Awaits `fn` so rejections are normalized too. */
+export declare function guardAsync<T>(ctx: GildashContext, errorType: GildashErrorType, op: string, fn: () => Promise<T>): Promise<T>;

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

@@ -479,6 +479,22 @@ export declare class Gildash {
      * @throws {GildashError} `'semantic'` if the semantic layer is not enabled.
      */
     getContextualCallReturnsAtSpan(filePath: string, span: ByteSpan): ResolvedType[] | null;
+    /**
+     * Whether the type of the **expression exactly spanning `span`** is assignable
+     * to the type described by `targetTypeExpression` (e.g. `'Error'`,
+     * `'PromiseLike<any>'`). The span-based counterpart of {@link isTypeAssignableToTypeAtPositions}'s
+     * single check — resolves any expression node, so `new CustomError()` / `f()`
+     * work where the identifier-only position resolver returns `null`.
+     *
+     * @param options.anyConstituent - for a union source type, `true` if **some**
+     *   member is assignable.
+     * @returns `true`/`false`, or `null` if the span resolves no node or the
+     *   source/target type cannot be resolved.
+     * @throws {GildashError} `'semantic'` if the semantic layer is not enabled.
+     */
+    isTypeAssignableToTypeAtSpan(filePath: string, span: ByteSpan, targetTypeExpression: string, options?: {
+        anyConstituent?: boolean;
+    }): boolean | null;
     /**
      * Find all semantic references to the symbol at a specific byte position.
      *

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

@@ -1,3 +1,4 @@
+import { DbConnection } from '../store/connection';
 import { FileRepository } from '../store/repositories/file.repository';
 import { SymbolRepository } from '../store/repositories/symbol.repository';
 import { RelationRepository } from '../store/repositories/relation.repository';
@@ -13,7 +14,7 @@ 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 { GildashContext, CoordinatorLike, WatcherLike, DbStore } from './context';
+import type { GildashContext, CoordinatorLike, WatcherLike } from './context';
 import type { GildashOptions } from './types';
 export declare const HEARTBEAT_INTERVAL_MS = 30000;
 export declare const HEALTHCHECK_INTERVAL_MS = 15000;
@@ -22,7 +23,7 @@ export declare const MAX_HEALTHCHECK_RETRIES = 10;
 export declare function applyBoundariesChange(ctx: GildashContext, boundaries: ProjectBoundary[]): void;
 export interface GildashInternalOptions {
     existsSyncFn?: (p: string) => boolean;
-    dbConnectionFactory?: () => DbStore;
+    dbConnectionFactory?: () => DbConnection;
     watcherFactory?: () => WatcherLike;
     coordinatorFactory?: () => CoordinatorLike;
     repositoryFactory?: () => {

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

@@ -52,6 +52,10 @@ export declare function isThenableAtSpan(ctx: GildashContext, filePath: string,
 }): boolean | null;
 /** Return types of the contextual call signatures at the argument expression spanning `span`. */
 export declare function getContextualCallReturnsAtSpan(ctx: GildashContext, filePath: string, span: ByteSpan): ResolvedType[] | null;
+/** Whether the type of the expression spanning `span` is assignable to a type expression string. */
+export declare function isTypeAssignableToTypeAtSpan(ctx: GildashContext, filePath: string, span: ByteSpan, targetTypeExpression: string, options?: {
+    anyConstituent?: boolean;
+}): boolean | null;
 /** Retrieve the resolved type at a byte offset without line/column conversion. */
 export declare function getResolvedTypeAtPosition(ctx: GildashContext, filePath: string, position: number): ResolvedType | null;
 /** Find all semantic references at a byte offset. */

package/dist/src/indexer/annotation-indexer.d.ts

@@ -1,4 +1,5 @@
 import type { ParsedFile } from '../parser/types';
+import type { AnnotationSource } from '../extractor/types';
 interface AnnotationRepoPart {
     deleteFileAnnotations(project: string, filePath: string): void;
     insertBatch(project: string, filePath: string, rows: ReadonlyArray<{
@@ -6,7 +7,7 @@ interface AnnotationRepoPart {
         filePath: string;
         tag: string;
         value: string;
-        source: string;
+        source: AnnotationSource;
         symbolName: string | null;
         startLine: number;
         startColumn: number;

package/dist/src/indexer/relation-indexer.d.ts

@@ -1,9 +1,10 @@
 import type { Program } from 'oxc-parser';
+import type { RelationType } from '../extractor/types';
 import type { ProjectBoundary } from '../common/project-discovery';
 import type { TsconfigPaths } from '../common/tsconfig-resolver';
 export interface RelationDbRow {
     project: string;
-    type: string;
+    type: RelationType;
     srcFilePath: string;
     srcSymbolName: string | null;
     dstProject: string | null;

package/dist/src/indexer/symbol-indexer.d.ts

@@ -1,9 +1,9 @@
 import type { ParsedFile } from '../parser/types';
-import type { ExtractedSymbol } from '../extractor/types';
+import type { ExtractedSymbol, SymbolKind } from '../extractor/types';
 export interface SymbolDbRow {
     project: string;
     filePath: string;
-    kind: string;
+    kind: SymbolKind;
     name: string;
     startLine: number;
     startColumn: number;

package/dist/src/parser/ast-utils.d.ts

@@ -1,6 +1,5 @@
-import type { Node } from 'oxc-parser';
+import type { Node, Expression } from 'oxc-parser';
 import type { QualifiedName } from '../extractor/types';
-export declare function getNodeHeader(node: Record<string, unknown>, parent?: Record<string, unknown> | null): string;
 /**
  * Type predicate for the union of FunctionDeclaration / FunctionExpression /
  * ArrowFunctionExpression discriminators.
@@ -135,6 +134,4 @@ export type IsNamespace = {
  * `undefined` returns `false`.
  */
 export declare const is: IsNamespace;
-export declare function getNodeName(node: unknown): string | null;
-export declare function getStringLiteralValue(node: unknown): string | null;
-export declare function getQualifiedName(expr: unknown): QualifiedName | null;
+export declare function getQualifiedName(expr: Expression | null | undefined): QualifiedName | null;

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

@@ -1,7 +1,7 @@
 export { parseSource } from './parse-source';
 export { ParseCache } from './parse-cache';
 export { buildLineOffsets, getLineColumn, } from './source-position';
-export { getNodeHeader, isArrowFunctionExpression, isAssignmentExpression, isCallExpression, isFunctionDeclaration, isFunctionExpression, isFunctionNode, isIdentifier, isMemberExpression, isTSQualifiedName, isVariableDeclaration, getNodeName, getStringLiteralValue, getQualifiedName, is, } from './ast-utils';
+export { isArrowFunctionExpression, isAssignmentExpression, isCallExpression, isFunctionDeclaration, isFunctionExpression, isFunctionNode, isIdentifier, isMemberExpression, isTSQualifiedName, isVariableDeclaration, getQualifiedName, is, } from './ast-utils';
 export type { IsNamespace, NodeTypePredicate } from './ast-utils';
 export { parseJsDoc } from './jsdoc-parser';
 export type { ParsedFile, SourcePosition, SourceSpan } from './types';

package/dist/src/search/annotation-search.d.ts

@@ -26,19 +26,19 @@ export interface AnnotationSearchResult {
         };
     };
 }
-export interface IAnnotationRepo {
+export interface AnnotationRepositoryReader {
     search(opts: {
         project?: string;
         tag?: string;
         filePath?: string;
         symbolName?: string;
-        source?: string;
+        source?: AnnotationSource;
         ftsQuery?: string;
         limit?: number;
     }): AnnotationRecord[];
 }
 export declare function annotationSearch(options: {
-    annotationRepo: IAnnotationRepo;
+    annotationRepo: AnnotationRepositoryReader;
     project?: string;
     query: AnnotationSearchQuery;
 }): AnnotationSearchResult[];

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

@@ -1,5 +1,6 @@
 import type { RelationRecord } from '../store/repositories/relation.repository';
-export interface IDependencyGraphRepo {
+import type { RelPath } from '../common/path-utils';
+export interface DependencyGraphRelationReader {
     getByType(project: string, type: string): RelationRecord[];
 }
 /**
@@ -22,7 +23,7 @@ export declare class DependencyGraph {
     private adjacencyList;
     private reverseAdjacencyList;
     constructor(options: {
-        relationRepo: IDependencyGraphRepo;
+        relationRepo: DependencyGraphRelationReader;
         project: string;
         additionalProjects?: string[];
     });
@@ -48,22 +49,23 @@ export declare class DependencyGraph {
     /**
      * Return the files that `filePath` directly imports.
      *
-     * @param filePath - Absolute file path.
+     * @param filePath - Project-relative file path (the graph keys on the
+     *   store's relative-path domain; callers normalize via `inboundRelPath`).
      */
-    getDependencies(filePath: string): string[];
+    getDependencies(filePath: RelPath): string[];
     /**
      * Return the files that directly import `filePath`.
      *
-     * @param filePath - Absolute file path.
+     * @param filePath - Project-relative file path.
      */
-    getDependents(filePath: string): string[];
+    getDependents(filePath: RelPath): string[];
     /**
      * Return all files that transitively depend on `filePath`
      * (breadth-first reverse walk).
      *
-     * @param filePath - Absolute file path.
+     * @param filePath - Project-relative file path.
      */
-    getTransitiveDependents(filePath: string): string[];
+    getTransitiveDependents(filePath: RelPath): string[];
     /**
      * Detect whether the import graph contains at least one cycle.
      *
@@ -78,10 +80,10 @@ export declare class DependencyGraph {
      * Combines {@link getTransitiveDependents} for every changed file
      * and de-duplicates the result.
      *
-     * @param changedFiles - Absolute paths of files that changed.
+     * @param changedFiles - Project-relative paths of files that changed.
      * @returns Paths of all transitively-dependent files.
      */
-    getAffectedByChange(changedFiles: string[]): string[];
+    getAffectedByChange(changedFiles: RelPath[]): string[];
     /**
      * Return the full import graph as an adjacency list.
      *
@@ -99,7 +101,7 @@ export declare class DependencyGraph {
      * @returns Paths of all transitively-imported files. Does not include `filePath` itself
      *   unless a cycle exists.
      */
-    getTransitiveDependencies(filePath: string): string[];
+    getTransitiveDependencies(filePath: RelPath): string[];
     /**
      * Return the distinct cycle paths in the import graph.
      *

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

@@ -1,10 +1,10 @@
 export { symbolSearch } from './symbol-search';
-export type { SymbolSearchQuery, SymbolSearchResult, ISymbolRepo } from './symbol-search';
+export type { SymbolSearchQuery, SymbolSearchResult, SymbolRepositoryReader } from './symbol-search';
 export { relationSearch } from './relation-search';
-export type { RelationSearchQuery, IRelationRepo } from './relation-search';
+export type { RelationSearchQuery, RelationRepositoryReader } from './relation-search';
 export { DependencyGraph } from './dependency-graph';
-export type { IDependencyGraphRepo } from './dependency-graph';
+export type { DependencyGraphRelationReader } from './dependency-graph';
 export { patternSearch } from './pattern-search';
 export type { PatternMatch, PatternCapture, PatternSearchOptions } from './pattern-search';
 export { annotationSearch } from './annotation-search';
-export type { AnnotationSearchQuery, AnnotationSearchResult, IAnnotationRepo } from './annotation-search';
+export type { AnnotationSearchQuery, AnnotationSearchResult, AnnotationRepositoryReader } from './annotation-search';

package/dist/src/search/relation-search.d.ts

@@ -1,5 +1,7 @@
 import type { CodeRelation } from '../extractor/types';
 import type { RelationRecord } from '../store/repositories/relation.repository';
+import { type RelPath } from '../common/path-utils';
+import type { RelationType } from '../extractor/types';
 /**
  * A {@link CodeRelation} enriched with the destination project identifier
  * as stored in the relation index.
@@ -49,14 +51,14 @@ export interface RelationSearchQuery {
     /** Filter by external package flag. */
     isExternal?: boolean;
 }
-export interface IRelationRepo {
+export interface RelationRepositoryReader {
     searchRelations(opts: {
-        srcFilePath?: string;
+        srcFilePath?: RelPath;
         srcSymbolName?: string;
-        dstFilePath?: string;
+        dstFilePath?: RelPath;
         dstSymbolName?: string;
         dstProject?: string;
-        type?: string;
+        type?: RelationType;
         project?: string;
         specifier?: string;
         isExternal?: boolean;
@@ -70,7 +72,8 @@ export interface IRelationRepo {
  * @returns An array of {@link CodeRelation} entries matching the query.
  */
 export declare function relationSearch(options: {
-    relationRepo: IRelationRepo;
+    relationRepo: RelationRepositoryReader;
+    projectRoot: string;
     project?: string;
     query: RelationSearchQuery;
 }): StoredCodeRelation[];

package/dist/src/search/symbol-search.d.ts

@@ -1,5 +1,6 @@
 import type { SymbolKind, Modifier, Decorator, JsDocBlock, ExpressionValue } from '../extractor/types';
 import type { SymbolRecord } from '../store/repositories/symbol.repository';
+import { type RelPath } from '../common/path-utils';
 /**
  * Filters for {@link symbolSearch}.
  *
@@ -118,12 +119,12 @@ export interface SymbolSearchResult {
     /** Typed detail fields parsed from the stored JSON. */
     detail: SymbolDetail;
 }
-export interface ISymbolRepo {
+export interface SymbolRepositoryReader {
     searchByQuery(opts: {
         ftsQuery?: string;
         exactName?: string;
-        kind?: string;
-        filePath?: string;
+        kind?: SymbolKind;
+        filePath?: RelPath;
         isExported?: boolean;
         project?: string;
         limit?: number;
@@ -141,7 +142,8 @@ export interface ISymbolRepo {
  * @returns An array of {@link SymbolSearchResult} entries matching the query.
  */
 export declare function symbolSearch(options: {
-    symbolRepo: ISymbolRepo;
+    symbolRepo: SymbolRepositoryReader;
+    projectRoot: string;
     project?: string;
     query: SymbolSearchQuery;
 }): SymbolSearchResult[];

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

@@ -41,6 +41,9 @@ export declare class SemanticLayer {
         anyConstituent?: boolean;
     }): boolean | null;
     contextualCallReturnsAtSpan(filePath: string, span: ByteSpan): ResolvedType[] | null;
+    isTypeAssignableToTypeAtSpan(filePath: string, span: ByteSpan, targetTypeExpression: string, options?: {
+        anyConstituent?: boolean;
+    }): boolean | null;
     findReferences(filePath: string, position: number): SemanticReference[];
     findEnrichedReferences(filePath: string, position: number): EnrichedReference[];
     getFileBindings(filePath: string): FileBinding[];

package/dist/src/semantic/tsc-program.d.ts

@@ -42,7 +42,6 @@ export declare class TscProgram {
     static create(tsconfigPath: string, options?: TscProgramOptions): Result<TscProgram, GildashError>;
     get isDisposed(): boolean;
     getProgram(): ts.Program;
-    getChecker(): ts.TypeChecker;
     /**
      * The project's compiler options, read from the host without forcing a
      * Program sync (so callers that don't need the Program stay cheap).

package/dist/src/semantic/type-collector.d.ts

@@ -68,6 +68,19 @@ export declare class TypeCollector {
      *
      */
     contextualCallReturnsAtSpan(filePath: string, span: ByteSpan): ResolvedType[] | null;
+    /**
+     * Whether the type of the expression exactly spanning `span` is assignable to
+     * the type described by `targetTypeExpression` (e.g. `'Error'`,
+     * `'PromiseLike<any>'`). The span-based counterpart of {@link isAssignableToType}
+     * — resolves any expression node (so `new CustomError()` / `f()` work, unlike
+     * the identifier-only position resolver) via the same probe-injection target
+     * resolution. `null` when the span resolves no node, or the target/source type
+     * cannot be resolved. `options.anyConstituent`: for a union source, true if
+     * **some** member is assignable.
+     */
+    isAssignableToTypeAtSpan(filePath: string, span: ByteSpan, targetTypeExpression: string, options?: {
+        anyConstituent?: boolean;
+    }): boolean | null;
     /**
      * 두 위치의 타입 호환성을 검사한다.
      *

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

@@ -3,7 +3,7 @@ export type { DbConnectionOptions } from './connection';
 export { FileRepository } from './repositories/file.repository';
 export type { FileRecord } from './repositories/file.repository';
 export { SymbolRepository } from './repositories/symbol.repository';
-export type { SymbolRecord, SearchOptions, SymbolStats } from './repositories/symbol.repository';
+export type { SymbolRecord, SymbolStats } from './repositories/symbol.repository';
 export { RelationRepository } from './repositories/relation.repository';
 export type { RelationRecord } from './repositories/relation.repository';
 export { AnnotationRepository } from './repositories/annotation.repository';

package/dist/src/store/repositories/annotation.repository.d.ts

@@ -1,11 +1,12 @@
 import type { DbConnection } from '../connection';
+import type { AnnotationSource } from '../../extractor/types';
 export interface AnnotationRecord {
     id: number;
     project: string;
     filePath: string;
     tag: string;
     value: string;
-    source: string;
+    source: AnnotationSource;
     symbolName: string | null;
     startLine: number;
     startColumn: number;
@@ -23,7 +24,7 @@ export declare class AnnotationRepository {
         tag?: string;
         filePath?: string;
         symbolName?: string;
-        source?: string;
+        source?: AnnotationSource;
         ftsQuery?: string;
         limit?: number;
     }): AnnotationRecord[];

package/dist/src/store/repositories/file.repository.d.ts

@@ -1,4 +1,5 @@
 import type { DbConnection } from '../connection';
+import type { RelPath } from '../../common/path-utils';
 /**
  * Metadata record for an indexed source file.
  *
@@ -24,9 +25,9 @@ export interface FileRecord {
 export declare class FileRepository {
     private readonly db;
     constructor(db: DbConnection);
-    getFile(project: string, filePath: string): FileRecord | null;
+    getFile(project: string, filePath: RelPath): FileRecord | null;
     upsertFile(record: FileRecord): void;
     getAllFiles(project: string): FileRecord[];
     getFilesMap(project: string): Map<string, FileRecord>;
-    deleteFile(project: string, filePath: string): void;
+    deleteFile(project: string, filePath: RelPath): void;
 }

package/dist/src/store/repositories/relation.repository.d.ts

@@ -1,7 +1,9 @@
 import type { DbConnection } from '../connection';
+import type { RelPath } from '../../common/path-utils';
+import type { RelationType } from '../../extractor/types';
 export interface RelationRecord {
     project: string;
-    type: string;
+    type: RelationType;
     srcFilePath: string;
     srcSymbolName: string | null;
     dstProject: string | null;
@@ -14,22 +16,24 @@ export interface RelationRecord {
 export declare class RelationRepository {
     private readonly db;
     constructor(db: DbConnection);
-    replaceFileRelations(project: string, srcFilePath: string, rels: ReadonlyArray<Partial<RelationRecord>>): void;
-    getOutgoing(project: string, srcFilePath: string, srcSymbolName?: string): RelationRecord[];
+    replaceFileRelations(project: string, srcFilePath: string, rels: ReadonlyArray<Partial<RelationRecord> & {
+        type: RelationType;
+    }>): void;
+    getOutgoing(project: string, srcFilePath: RelPath, srcSymbolName?: string): RelationRecord[];
     getIncoming(opts: {
         dstProject: string;
-        dstFilePath: string;
+        dstFilePath: RelPath;
     }): RelationRecord[];
-    getByType(project: string, type: string): RelationRecord[];
-    deleteFileRelations(project: string, srcFilePath: string): void;
-    deleteIncomingRelations(dstProject: string, dstFilePath: string): void;
+    getByType(project: string, type: RelationType): RelationRecord[];
+    deleteFileRelations(project: string, srcFilePath: RelPath): void;
+    deleteIncomingRelations(dstProject: string, dstFilePath: RelPath): void;
     searchRelations(opts: {
-        srcFilePath?: string;
+        srcFilePath?: RelPath;
         srcSymbolName?: string;
         dstProject?: string;
-        dstFilePath?: string;
+        dstFilePath?: RelPath;
         dstSymbolName?: string;
-        type?: string;
+        type?: RelationType;
         project?: string;
         specifier?: string;
         isExternal?: boolean;