@colbymchenry/codegraph 0.9.6 → 0.9.8

package/dist/sync/watcher.d.ts

@@ -0,0 +1,191 @@
+/**
+ * File Watcher
+ *
+ * Watches the project directory for file changes and triggers debounced sync
+ * operations to keep the code graph up-to-date.
+ *
+ * Uses chokidar, whose `ignored` callback filters directories BEFORE they are
+ * watched — so we never register inotify watches on excluded trees like
+ * node_modules/, dist/, .git/ (fixes #276: recursive fs.watch exhausted the
+ * kernel watch budget on large repos). The ignore decision reuses the indexer's
+ * `buildDefaultIgnore` (built-in default-ignore dirs + the project's .gitignore)
+ * so the watcher watches exactly the set the indexer indexes — in particular,
+ * node_modules/build/cache dirs are excluded even when the repo has no
+ * .gitignore (#407), which a .gitignore-only filter would miss.
+ */
+/**
+ * Options for the file watcher
+ */
+export interface WatchOptions {
+    /**
+     * Debounce delay in milliseconds.
+     * After the last file change, wait this long before triggering sync.
+     * Default: 2000ms
+     */
+    debounceMs?: number;
+    /**
+     * Callback when a sync completes (for logging/diagnostics).
+     */
+    onSyncComplete?: (result: {
+        filesChanged: number;
+        durationMs: number;
+    }) => void;
+    /**
+     * Callback when a sync errors (for logging/diagnostics).
+     */
+    onSyncError?: (error: Error) => void;
+}
+/**
+ * Thrown by a `syncFn` to signal that the underlying sync couldn't acquire
+ * the cross-process write lock (#449). The watcher treats this as "no
+ * progress" — preserves `pendingFiles`, skips `onSyncComplete`, and the
+ * `finally` block reschedules. Quiet (debug-only) because a long-running
+ * external indexer can hit this every debounce cycle.
+ */
+export declare class LockUnavailableError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Per-file pending entry — tracks a source file the watcher saw an event for
+ * but hasn't yet synced into the index. Exposed via {@link FileWatcher.getPendingFiles}
+ * so MCP tool responses can mark stale results without forcing a wait.
+ */
+export interface PendingFile {
+    /** Project-relative POSIX path (e.g. "src/foo.ts"). */
+    path: string;
+    /** Wall-clock ms at the first event we saw for this path since the last sync. */
+    firstSeenMs: number;
+    /** Wall-clock ms at the most recent event we saw for this path. */
+    lastSeenMs: number;
+    /**
+     * True when a sync is currently in flight that began AFTER this file's most
+     * recent event — i.e. the next successful sync will pick it up. False when
+     * the file is still in the debounce window (no sync running yet).
+     */
+    indexing: boolean;
+}
+/**
+ * FileWatcher monitors a project directory for changes and triggers
+ * debounced sync operations via a provided callback.
+ *
+ * Design goals:
+ * - Minimal resource usage (chokidar filters excluded directories before
+ *   registering an inotify watch — see module docs / #276)
+ * - Debounced to avoid thrashing on rapid saves
+ * - Filters to supported source files by extension
+ * - Ignores .codegraph/ and .git/ regardless of .gitignore
+ * - Tracks per-file pending state so MCP tools can flag stale results
+ *   without blocking on a sync (issue #403)
+ */
+export declare class FileWatcher {
+    private watcher;
+    private debounceTimer;
+    /**
+     * Files seen by the watcher since the last successful sync — populated on
+     * every chokidar event, cleared at the start of a sync, and re-populated by
+     * events that arrive mid-sync (or restored on sync failure). Keyed by the
+     * same project-relative POSIX path the rest of the codebase uses, so a
+     * caller can intersect tool-response file paths against this map cheaply.
+     */
+    private pendingFiles;
+    /**
+     * Wall-clock ms at which the in-flight sync began. Combined with
+     * {@link pendingFiles}'s `lastSeenMs`, this distinguishes "still in the
+     * debounce window" (lastSeen > syncStarted, sync hasn't started yet for
+     * this edit) from "currently being indexed" (lastSeen <= syncStarted).
+     */
+    private syncStartedMs;
+    private syncing;
+    private stopped;
+    /**
+     * False until chokidar fires its `ready` event. Gates `pendingFiles`
+     * insertion so the initial crawl's `add` events (one per pre-existing
+     * source file) don't pollute the per-file staleness signal. The events
+     * still flow into `scheduleSync()` to preserve the previous "initial
+     * scan triggers a reconciling sync" behavior.
+     */
+    private chokidarReady;
+    /**
+     * Callbacks that resolve when chokidar fires `ready`. Used by tests (and
+     * any production caller that cares about a clean baseline) to deterministically
+     * gate on the end of the initial scan instead of guessing at a sleep duration.
+     */
+    private readyWaiters;
+    private ignoreMatcher;
+    private readonly projectRoot;
+    private readonly debounceMs;
+    private readonly syncFn;
+    private readonly onSyncComplete?;
+    private readonly onSyncError?;
+    constructor(projectRoot: string, syncFn: () => Promise<{
+        filesChanged: number;
+        durationMs: number;
+    }>, options?: WatchOptions);
+    /**
+     * Start watching for file changes.
+     * Returns true if watching started successfully, false otherwise.
+     */
+    start(): boolean;
+    /** Our own dirs are always ignored, regardless of .gitignore. */
+    private isAlwaysIgnored;
+    /**
+     * chokidar `ignored` predicate — true for any path that should NOT be watched.
+     * Uses chokidar's provided `stats` to decide directory-vs-file so a dir-only
+     * rule like `build/` matches, without an extra `statSync` per path.
+     */
+    private shouldIgnore;
+    /**
+     * Stop watching for file changes.
+     */
+    stop(): void;
+    /**
+     * Whether the watcher is currently active.
+     */
+    isActive(): boolean;
+    /**
+     * Resolves once chokidar has fired its `ready` event (or immediately if
+     * it has already done so). Useful for tests that need a deterministic
+     * boundary before asserting on `pendingFiles` — guessing a sleep duration
+     * is flaky under load because chokidar can take longer than expected to
+     * finish its initial crawl on slow filesystems / parallel test runs.
+     *
+     * Production callers don't need this: `pendingFiles` is read continuously,
+     * the staleness banner is always correct (empty or populated), and the
+     * initial-scan window is a small one-time startup cost.
+     */
+    waitUntilReady(timeoutMs?: number): Promise<void>;
+    /**
+     * Schedule a debounced sync.
+     */
+    private scheduleSync;
+    /**
+     * Flush pending changes by running sync.
+     *
+     * pendingFiles is NOT cleared at the start of sync — entries are removed
+     * only after sync commits successfully, and only for entries whose
+     * lastSeenMs <= syncStartedMs. That way, a query that arrives mid-sync
+     * still sees the affected files marked stale (the DB hasn't been updated
+     * yet), and an event that lands mid-sync persists into the follow-up.
+     *
+     * On sync failure pendingFiles is left untouched — every edit is still
+     * unindexed, and the rescheduled sync will absorb the same set next time.
+     */
+    private flush;
+    /**
+     * Snapshot of files seen by the watcher since the last successful sync.
+     *
+     * Used by MCP tool responses to mark stale results without blocking on a
+     * sync: a tool that returns a hit in `src/foo.ts` while `src/foo.ts` is in
+     * this list tells the agent "Read this file directly, the index lags."
+     *
+     * `indexing` is true when a sync is currently in flight whose start time is
+     * AFTER this file's most recent event — i.e. that sync will absorb the
+     * edit. False means the file is still inside the debounce window and no
+     * sync has started yet (a follow-up call a few hundred ms later may show
+     * `indexing: true` or the file may have left the list entirely).
+     *
+     * Cheap: O(pendingFiles.size), no I/O, no locks.
+     */
+    getPendingFiles(): PendingFile[];
+}
+//# sourceMappingURL=watcher.d.ts.map

package/dist/sync/worktree.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Git Worktree Awareness
+ *
+ * A CodeGraph index lives in a `.codegraph/` directory and is resolved by
+ * walking up parent directories to the nearest one (see
+ * `findNearestCodeGraphRoot`). That walk is unaware of git worktrees: when a
+ * worktree is created *inside* the main checkout (e.g. some tools place them
+ * under `.gitignore`d paths like `.claude/worktrees/<name>/`), a command run
+ * from the worktree walks up and silently resolves the MAIN checkout's index.
+ *
+ * Every query then returns results from the main tree's code — usually a
+ * different branch — rather than the worktree the user is actually editing.
+ * Symbols added or changed only in the worktree are invisible. This module
+ * detects that "borrowed index" situation so callers can warn about it.
+ *
+ * Detection is best-effort: when git is unavailable or the path isn't a repo,
+ * it reports "no mismatch" and callers carry on unchanged.
+ */
+/**
+ * Absolute, symlink-resolved toplevel of the git working tree that `dir`
+ * belongs to, or null when `dir` isn't inside a git repo (or git is missing).
+ *
+ * `git rev-parse --show-toplevel` returns the per-worktree root: the main
+ * checkout and each linked worktree report their own distinct directory, which
+ * is exactly the distinction this module relies on.
+ */
+export declare function gitWorktreeRoot(dir: string): string | null;
+export interface WorktreeIndexMismatch {
+    /** The git working tree the command was run from. */
+    worktreeRoot: string;
+    /** The (different) working tree whose `.codegraph` index is being used. */
+    indexRoot: string;
+}
+/**
+ * Detect when `startPath` lives in one git working tree but the resolved
+ * CodeGraph index (`indexRoot`) belongs to a *different* working tree.
+ *
+ * Returns null — meaning "nothing to warn about" — when:
+ *   - `startPath` isn't in a git repo (or git is unavailable),
+ *   - the index already lives in `startPath`'s own working tree, or
+ *   - `indexRoot` isn't itself a working-tree root (an unrelated parent dir
+ *     that merely happens to contain a `.codegraph/`), which keeps non-git
+ *     and monorepo-subdir layouts from producing false warnings.
+ */
+export declare function detectWorktreeIndexMismatch(startPath: string, indexRoot: string): WorktreeIndexMismatch | null;
+/** One-line-per-fact warning describing a detected mismatch. */
+export declare function worktreeMismatchWarning(m: WorktreeIndexMismatch): string;
+/**
+ * Compact, single-line variant for prefixing a tool's result. Read tools
+ * return their answer inline, so the heads-up has to ride on the same payload
+ * the agent is already reading — a multi-line block would bury the result.
+ */
+export declare function worktreeMismatchNotice(m: WorktreeIndexMismatch): string;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,369 @@
+/**
+ * CodeGraph Type Definitions
+ *
+ * Core types for the semantic knowledge graph system.
+ */
+/**
+ * Types of nodes in the knowledge graph.
+ *
+ * Defined as a runtime-iterable `as const` array so the same source
+ * of truth backs both the TS type and any runtime validation
+ * (e.g. the search query parser).
+ */
+export declare const NODE_KINDS: readonly ["file", "module", "class", "struct", "interface", "trait", "protocol", "function", "method", "property", "field", "variable", "constant", "enum", "enum_member", "type_alias", "namespace", "parameter", "import", "export", "route", "component"];
+export type NodeKind = (typeof NODE_KINDS)[number];
+/**
+ * Types of edges (relationships) between nodes
+ */
+export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends' | 'implements' | 'references' | 'type_of' | 'returns' | 'instantiates' | 'overrides' | 'decorates';
+/**
+ * Supported programming languages. See NODE_KINDS for why this is a
+ * runtime-iterable const array.
+ */
+export declare const LANGUAGES: readonly ["typescript", "javascript", "tsx", "jsx", "python", "go", "rust", "java", "c", "cpp", "csharp", "php", "ruby", "swift", "kotlin", "dart", "svelte", "vue", "liquid", "pascal", "scala", "lua", "luau", "objc", "yaml", "twig", "xml", "properties", "unknown"];
+export type Language = (typeof LANGUAGES)[number];
+/**
+ * A node in the knowledge graph representing a code symbol
+ */
+export interface Node {
+    /** Unique identifier (hash of file path + qualified name) */
+    id: string;
+    /** Type of code element */
+    kind: NodeKind;
+    /** Simple name (e.g., "calculateTotal") */
+    name: string;
+    /** Fully qualified name (e.g., "src/utils.ts::MathHelper.calculateTotal") */
+    qualifiedName: string;
+    /** File path relative to project root */
+    filePath: string;
+    /** Programming language */
+    language: Language;
+    /** Starting line number (1-indexed) */
+    startLine: number;
+    /** Ending line number (1-indexed) */
+    endLine: number;
+    /** Starting column (0-indexed) */
+    startColumn: number;
+    /** Ending column (0-indexed) */
+    endColumn: number;
+    /** Documentation string if present */
+    docstring?: string;
+    /** Function/method signature */
+    signature?: string;
+    /** Visibility modifier */
+    visibility?: 'public' | 'private' | 'protected' | 'internal';
+    /** Whether symbol is exported */
+    isExported?: boolean;
+    /** Whether symbol is async */
+    isAsync?: boolean;
+    /** Whether symbol is static */
+    isStatic?: boolean;
+    /** Whether symbol is abstract */
+    isAbstract?: boolean;
+    /** Decorators/annotations applied */
+    decorators?: string[];
+    /** Generic type parameters */
+    typeParameters?: string[];
+    /** When the node was last updated */
+    updatedAt: number;
+}
+/**
+ * An edge representing a relationship between two nodes
+ */
+export interface Edge {
+    /** Source node ID */
+    source: string;
+    /** Target node ID */
+    target: string;
+    /** Type of relationship */
+    kind: EdgeKind;
+    /** Additional context about the relationship */
+    metadata?: Record<string, unknown>;
+    /** Line number where relationship occurs (e.g., call site) */
+    line?: number;
+    /** Column number where relationship occurs */
+    column?: number;
+    /** How this edge was created */
+    provenance?: 'tree-sitter' | 'scip' | 'heuristic';
+}
+/**
+ * Metadata about a tracked file
+ */
+export interface FileRecord {
+    /** File path relative to project root */
+    path: string;
+    /** Content hash for change detection */
+    contentHash: string;
+    /** Detected language */
+    language: Language;
+    /** File size in bytes */
+    size: number;
+    /** Last modification timestamp */
+    modifiedAt: number;
+    /** When last indexed */
+    indexedAt: number;
+    /** Number of nodes extracted */
+    nodeCount: number;
+    /** Any extraction errors */
+    errors?: ExtractionError[];
+}
+/**
+ * Result from parsing a source file
+ */
+export interface ExtractionResult {
+    /** Extracted nodes */
+    nodes: Node[];
+    /** Extracted edges */
+    edges: Edge[];
+    /** References that couldn't be resolved yet */
+    unresolvedReferences: UnresolvedReference[];
+    /** Any errors during extraction */
+    errors: ExtractionError[];
+    /** Extraction duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Error during code extraction
+ */
+export interface ExtractionError {
+    /** Error message */
+    message: string;
+    /** File path where the error occurred */
+    filePath?: string;
+    /** Line number if available */
+    line?: number;
+    /** Column number if available */
+    column?: number;
+    /** Error severity */
+    severity: 'error' | 'warning';
+    /** Error code for categorization */
+    code?: string;
+}
+/**
+ * A reference that couldn't be resolved during extraction
+ */
+export interface UnresolvedReference {
+    /** ID of the node containing the reference */
+    fromNodeId: string;
+    /** Name being referenced */
+    referenceName: string;
+    /** Type of reference (call, type, import, etc.) */
+    referenceKind: EdgeKind;
+    /** Location of the reference */
+    line: number;
+    column: number;
+    /** File path where reference occurs (denormalized for performance) */
+    filePath?: string;
+    /** Language of the source file (denormalized for performance) */
+    language?: Language;
+    /** Possible qualified names it might resolve to */
+    candidates?: string[];
+}
+/**
+ * A subgraph containing a subset of the knowledge graph
+ */
+export interface Subgraph {
+    /** Nodes in this subgraph */
+    nodes: Map<string, Node>;
+    /** Edges in this subgraph */
+    edges: Edge[];
+    /** Root node IDs (entry points) */
+    roots: string[];
+}
+/**
+ * Options for graph traversal
+ */
+export interface TraversalOptions {
+    /** Maximum depth to traverse (default: Infinity) */
+    maxDepth?: number;
+    /** Edge types to follow (default: all) */
+    edgeKinds?: EdgeKind[];
+    /** Node types to include (default: all) */
+    nodeKinds?: NodeKind[];
+    /** Direction of traversal */
+    direction?: 'outgoing' | 'incoming' | 'both';
+    /** Maximum nodes to return */
+    limit?: number;
+    /** Whether to include the starting node */
+    includeStart?: boolean;
+}
+/**
+ * Options for searching the graph
+ */
+export interface SearchOptions {
+    /** Node types to search */
+    kinds?: NodeKind[];
+    /** Languages to include */
+    languages?: Language[];
+    /** File path patterns to include */
+    includePatterns?: string[];
+    /** File path patterns to exclude */
+    excludePatterns?: string[];
+    /** Maximum results to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Whether search is case-sensitive */
+    caseSensitive?: boolean;
+}
+/**
+ * A search result with relevance scoring
+ */
+export interface SearchResult {
+    /** Matching node */
+    node: Node;
+    /** Relevance score (0-1) */
+    score: number;
+    /** Matched text snippets for highlighting */
+    highlights?: string[];
+}
+/**
+ * Context information for code understanding
+ */
+export interface Context {
+    /** Primary node being examined */
+    focal: Node;
+    /** Nodes containing the focal node (file, class, etc.) */
+    ancestors: Node[];
+    /** Nodes directly contained by focal node */
+    children: Node[];
+    /** Incoming references (who calls/uses this) */
+    incomingRefs: Array<{
+        node: Node;
+        edge: Edge;
+    }>;
+    /** Outgoing references (what this calls/uses) */
+    outgoingRefs: Array<{
+        node: Node;
+        edge: Edge;
+    }>;
+    /** Related type information */
+    types: Node[];
+    /** Relevant imports */
+    imports: Node[];
+}
+/**
+ * A block of code with context
+ */
+export interface CodeBlock {
+    /** The code content */
+    content: string;
+    /** File path */
+    filePath: string;
+    /** Starting line */
+    startLine: number;
+    /** Ending line */
+    endLine: number;
+    /** Language for syntax highlighting */
+    language: Language;
+    /** Associated node if extracted */
+    node?: Node;
+}
+/**
+ * Database schema version info
+ */
+export interface SchemaVersion {
+    /** Current schema version */
+    version: number;
+    /** When schema was created/updated */
+    appliedAt: number;
+    /** Description of this version */
+    description?: string;
+}
+/**
+ * Statistics about the knowledge graph
+ */
+export interface GraphStats {
+    /** Total number of nodes */
+    nodeCount: number;
+    /** Total number of edges */
+    edgeCount: number;
+    /** Number of tracked files */
+    fileCount: number;
+    /** Node counts by kind */
+    nodesByKind: Record<NodeKind, number>;
+    /** Edge counts by kind */
+    edgesByKind: Record<EdgeKind, number>;
+    /** File counts by language */
+    filesByLanguage: Record<Language, number>;
+    /** Database size in bytes */
+    dbSizeBytes: number;
+    /** Last update timestamp */
+    lastUpdated: number;
+}
+/**
+ * Input for building task context
+ */
+export type TaskInput = string | {
+    title: string;
+    description?: string;
+};
+/**
+ * Options for building task context
+ */
+export interface BuildContextOptions {
+    /** Maximum number of nodes to include (default: 50) */
+    maxNodes?: number;
+    /** Maximum number of code blocks to include (default: 10) */
+    maxCodeBlocks?: number;
+    /** Maximum characters per code block (default: 2000) */
+    maxCodeBlockSize?: number;
+    /** Whether to include code blocks (default: true) */
+    includeCode?: boolean;
+    /** Output format (default: 'markdown') */
+    format?: 'markdown' | 'json';
+    /** Number of semantic search results (default: 5) */
+    searchLimit?: number;
+    /** Graph traversal depth from entry points (default: 2) */
+    traversalDepth?: number;
+    /** Minimum semantic similarity score (default: 0.3) */
+    minScore?: number;
+}
+/**
+ * Full context for a task, ready for Claude
+ */
+export interface TaskContext {
+    /** The original query/task */
+    query: string;
+    /** Subgraph of relevant nodes and edges */
+    subgraph: Subgraph;
+    /** Entry point nodes (from semantic search) */
+    entryPoints: Node[];
+    /** Code blocks extracted from key nodes */
+    codeBlocks: CodeBlock[];
+    /** Files involved in this context */
+    relatedFiles: string[];
+    /** Brief summary of the context */
+    summary: string;
+    /** Statistics about the context */
+    stats: {
+        /** Number of nodes included */
+        nodeCount: number;
+        /** Number of edges included */
+        edgeCount: number;
+        /** Number of files touched */
+        fileCount: number;
+        /** Number of code blocks included */
+        codeBlockCount: number;
+        /** Total characters in code blocks */
+        totalCodeSize: number;
+    };
+}
+/**
+ * Options for finding relevant context
+ */
+export interface FindRelevantContextOptions {
+    /** Number of semantic search results (default: 5) */
+    searchLimit?: number;
+    /** Graph traversal depth (default: 2) */
+    traversalDepth?: number;
+    /** Maximum nodes in result (default: 50) */
+    maxNodes?: number;
+    /** Minimum semantic similarity score (default: 0.3) */
+    minScore?: number;
+    /** Edge types to follow in traversal */
+    edgeKinds?: EdgeKind[];
+    /** Node types to include */
+    nodeKinds?: NodeKind[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ui/glyphs.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Glyph selection for CLI output.
+ *
+ * On Windows, console output is interpreted via the active output
+ * codepage. PowerShell 5.1 and cmd.exe default to OEM codepages
+ * (CP437, CP936, ...), so UTF-8 bytes written to the console render
+ * as mojibake (see #168). The shimmer worker is hit hardest because
+ * it uses `fs.writeSync(1, ...)` (raw bytes, no TTY-aware encoding
+ * conversion) to keep animation smooth while the main thread is
+ * blocked in SQLite. To stay readable everywhere, we fall back to
+ * ASCII glyphs whenever the terminal is not known to handle UTF-8.
+ *
+ * Detection is intentionally simple:
+ *   - `CODEGRAPH_ASCII=1`  -> ASCII (escape hatch for any terminal)
+ *   - `CODEGRAPH_UNICODE=1` -> Unicode (opt-in on Windows)
+ *   - Windows              -> ASCII by default
+ *   - Linux kernel console (`TERM=linux`) -> ASCII
+ *   - Everything else      -> Unicode
+ */
+export declare function supportsUnicode(): boolean;
+export interface Glyphs {
+    ok: string;
+    err: string;
+    info: string;
+    warn: string;
+    spinner: string[];
+    barFilled: string;
+    barEmpty: string;
+    rail: string;
+    phaseDone: string;
+    dash: string;
+    hLine: string;
+    treeBranch: string;
+    treeLast: string;
+    treePipe: string;
+}
+export declare const UNICODE_GLYPHS: Glyphs;
+export declare const ASCII_GLYPHS: Glyphs;
+export declare function getGlyphs(): Glyphs;
+/** Reset the cached glyph set. Test-only; production code should call `getGlyphs()`. */
+export declare function _resetGlyphsCache(): void;
+//# sourceMappingURL=glyphs.d.ts.map

package/dist/ui/shimmer-progress.d.ts

@@ -0,0 +1,11 @@
+export interface IndexProgress {
+    phase: string;
+    current: number;
+    total: number;
+}
+export interface ShimmerProgress {
+    onProgress: (progress: IndexProgress) => void;
+    stop: () => Promise<void>;
+}
+export declare function createShimmerProgress(): ShimmerProgress;
+//# sourceMappingURL=shimmer-progress.d.ts.map

package/dist/ui/shimmer-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shimmer-worker.d.ts.map

package/dist/ui/types.d.ts

@@ -0,0 +1,17 @@
+/** Messages from main thread to worker */
+export type ShimmerWorkerMessage = {
+    type: 'update';
+    phase: string;
+    phaseName: string;
+    percent: number;
+    count: number;
+} | {
+    type: 'finish-phase';
+} | {
+    type: 'stop';
+};
+/** Messages from worker to main thread */
+export type ShimmerMainMessage = {
+    type: 'stopped';
+};
+//# sourceMappingURL=types.d.ts.map