library_load.ts

Cache filename inside a repo's .gro directory for library_load_from_repo.

Computes the cache key for a repo at repo_dir: the git HEAD commit hash.

Returns null (uncacheable — analysis still runs, caching is skipped) when the dir is not a git repo OR when the working tree is dirty. A dirty tree is deliberately uncacheable: the commit hash doesn't capture uncommitted edits, so a single -dirty key would serve a stale analysis across successive edits. Skipping the cache while dirty guarantees fresh metadata; clean commits cache.

Reads and validates the .gro/library.json cache at cache_path.

Returns the cached {library_json, package_json} only when the file exists, its stored hash matches key, and its version and svelte_docinfo_version stamps match the current LIBRARY_CACHE_VERSION and SVELTE_DOCINFO_VERSION. Returns null on every miss - absent, stale (different hash or stamps), or unreadable/corrupt - signalling the caller to re-analyze.

Format version for the .gro/library.json cache. The cache key is the git commit hash, which does NOT change when the cached *shape* changes — so bump this whenever LibraryCache's shape changes (e.g. the LibraryJson / PkgJson split, then slimming LibraryJson to the raw pkg_json/source_json pair) to self-invalidate stale caches across the ecosystem rather than serve old-shaped data at an unchanged commit. Upstream analyzer changes need no bump: each record also stamps SVELTE_DOCINFO_VERSION and self-invalidates when the installed svelte-docinfo moves.

Writes result to the .gro/library.json cache at cache_path, keyed by key and stamped with the current LIBRARY_CACHE_VERSION and SVELTE_DOCINFO_VERSION, creating the parent directory as needed.

Best effort: caching is optional, so write failures are logged as a warning and swallowed rather than thrown.

Loads a repo's library metadata via svelte-docinfo, with a .gro cache keyed by git hash.

Analyzes repo_dir with analyzeFromFiles and combines the result with the repo's package.json into a LibraryJson, returned alongside the full package.json. Results are cached at <repo_dir>/.gro/library.json keyed by the current git HEAD, so repeated loads at the same commit skip the (potentially slow) analysis. A dirty working tree (or a non-git dir) is uncacheable, so analysis re-runs on every load until the changes are committed - see library_cache_key.

Refuses to analyze a repo whose tsconfig.json extends $app/tsconfig but that hasn't been synced (see sveltekit_tsconfig_is_unsynced): its analysis would read external types as any. The check runs only on a cache miss - a cache hit is served as written. svelte-docinfo logs to a child of log labelled with the repo dir's name: its diagnostics as warnings and errors, its progress at debug level.

On-disk shape of the .gro/library.json cache file. The hash is the git-based cache key the result was computed at; version is the LIBRARY_CACHE_VERSION it was written under; svelte_docinfo_version is the SVELTE_DOCINFO_VERSION that analyzed it.

Result of loading a repo's library metadata: the curated LibraryJson (carrying the publish-safe pkg_json) plus the repo's full package.json.

The full package_json is kept alongside — not folded into LibraryJson — because tooling like fuz_gitops needs dependencies/devDependencies, which the curated LibraryJson.pkg_json deliberately omits.

The installed svelte-docinfo version — read from the same copy that analyzeFromFiles resolves to. Stamped into each cache record and compared on read, so caches analyzed by a different svelte-docinfo self-invalidate: source_json.modules is cached verbatim, and the cache key (the analyzed repo's commit hash) doesn't move when the *analyzer's* dependency changes its output shape.