@skaile/workspaces 6.3.0 → 6.5.0

package/dist/{chunk-Y3I4KGLX.js → chunk-TGUMN5G7.js}

@@ -1,26 +1,28 @@
-import { readManifestSourceConfig, discoverAssetsInTree, barePublisher, createDefaultKindRegistry, sharesItsFolder, SEMVER_RE, invalidSemverMessage, parseManifestFile } from './chunk-XEVFSDIF.js';
-import { installFromManifest, assertSafeManifestPath } from './chunk-E5NQRHEB.js';
-import { PresetManifestSchema } from './chunk-76FLBODK.js';
-import { defaultLibraryDir, resolveLibraryDir, GLOBAL_INSTALL_DIR_NAME, readLock, buildLibraryLockEntries, writeLock, mergeLockFile, buildLockFile, ManifestYamlEditor } from './chunk-J5JRGBKK.js';
-import { getGlobalCacheDir, storeManifestSlug, priorStoreManifestSlugs, resolveSourcePublisher } from './chunk-XBQTXGY4.js';
+import { readManifestSourceConfig, discoverAssetsInTree, barePublisher, createDefaultKindRegistry, sharesItsFolder, SEMVER_RE, invalidSemverMessage, parseManifestFile } from './chunk-22ZX33H6.js';
+import { installFromManifest, assertSafeManifestPath } from './chunk-U6KRTCNA.js';
+import { PresetManifestSchema } from './chunk-VT6G5AJV.js';
+import { defaultLibraryDir, resolveLibraryDir, GLOBAL_INSTALL_DIR_NAME, readLock, buildLibraryLockEntries, writeLock, mergeLockFile, buildLockFile, ManifestYamlEditor } from './chunk-UMLCKKIA.js';
+import { getGlobalCacheDir, storeManifestSlug, priorStoreManifestSlugs, resolveSourcePublisher } from './chunk-IWKKTCXY.js';
 import { userConfigPath, globalSkaileDir, mergeLegacyEntriesInto, migrateLegacyDir, globalCacheRoot } from './chunk-L5VSIPQD.js';
-import { encodeSkaileManifest, expandManifestFiles, SKAILE_MANIFEST_FILENAME, librarySymlinkMessage, loadSkPublishManifest } from './chunk-KPKGWXUJ.js';
-import { scanDirectory } from './chunk-JMIKGAUA.js';
-import { parseAssetRef, assetRefToStr, isValidAssetName } from './chunk-IZQOO6MN.js';
+import { encodeSkaileManifest, expandManifestFiles, SKAILE_MANIFEST_FILENAME, librarySymlinkMessage, loadSkPublishManifest } from './chunk-23SG4JRV.js';
+import { scanDirectory } from './chunk-AVFRFGM2.js';
+import { parseAssetRef, assetRefToStr, isValidAssetName } from './chunk-V5KG6CCV.js';
 import { __export } from './chunk-NSBPE2FW.js';
-import * as fs12 from 'fs';
+import * as fs14 from 'fs';
 import { existsSync, mkdirSync, symlinkSync, copyFileSync, cpSync } from 'fs';
 import * as path16 from 'path';
 import { resolve, relative, sep, join, dirname } from 'path';
 import { stringify, parse, parseDocument } from 'yaml';
 import * as z3 from 'zod';
 import * as crypto from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { eq, and, like } from 'drizzle-orm';
 import { createClient } from '@libsql/client';
 import { drizzle } from 'drizzle-orm/libsql';
 import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
 import { spawnSync } from 'child_process';
 import { valid, gt } from 'semver';
+import * as os from 'os';
 import { isDeepStrictEqual } from 'util';
 
 // library/src/library.ts
@@ -121,9 +123,9 @@ function projectConfigPath(projectDir) {
   return path16.join(projectDir, ".skaile", CONFIG_FILENAME);
 }
 function loadConfigFile(filePath) {
-  if (!fs12.existsSync(filePath)) return null;
+  if (!fs14.existsSync(filePath)) return null;
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs14.readFileSync(filePath, "utf-8");
     const raw = parse(content);
     if (!raw || typeof raw !== "object") return null;
     return SkaileConfigSchema.partial().parse(raw);
@@ -172,10 +174,10 @@ function resolveConfig(opts) {
 }
 function saveConfig(filePath, config) {
   const dir = path16.dirname(filePath);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
+  fs14.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
 }
 var KnowledgeManifestSchema = z3.looseObject({
   name: z3.string().optional(),
@@ -202,9 +204,9 @@ function validateKnowledge(data) {
 // library/src/knowledge/knowledge-kind-provider.ts
 function collectDirRecursive(baseDir, relativeDir) {
   const full = path16.join(baseDir, relativeDir);
-  if (!fs12.existsSync(full) || !fs12.statSync(full).isDirectory()) return [];
+  if (!fs14.existsSync(full) || !fs14.statSync(full).isDirectory()) return [];
   const results = [];
-  for (const entry of fs12.readdirSync(full, { withFileTypes: true })) {
+  for (const entry of fs14.readdirSync(full, { withFileTypes: true })) {
     const rel = path16.posix.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectDirRecursive(baseDir, rel));
@@ -312,7 +314,7 @@ var assignments = sqliteTable("assignments", {
   assignedAt: text("assigned_at").notNull()
 });
 function isClone(dir) {
-  return fs12.existsSync(path16.join(dir, ".git"));
+  return fs14.existsSync(path16.join(dir, ".git"));
 }
 function getSidecarRoot() {
   const home = globalSkaileDir();
@@ -346,9 +348,9 @@ function deriveSlug(sourceConfig, sourcePath, existingSlugs) {
 }
 function listSidecarSlugsOnDisk() {
   const root = getSidecarRoot();
-  if (!fs12.existsSync(root)) return [];
+  if (!fs14.existsSync(root)) return [];
   const out = [];
-  for (const entry of fs12.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs14.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     out.push(entry.name);
@@ -369,16 +371,16 @@ function getStoreManifestsDir() {
 function storeManifestFile(sourceUrl) {
   const dir = getStoreManifestsDir();
   const current = path16.join(dir, `${storeManifestSlug(sourceUrl)}.yaml`);
-  if (fs12.existsSync(current)) return current;
+  if (fs14.existsSync(current)) return current;
   for (const slug of priorStoreManifestSlugs(sourceUrl)) {
     const old = path16.join(dir, `${slug}.yaml`);
-    if (fs12.existsSync(old)) return old;
+    if (fs14.existsSync(old)) return old;
   }
   return current;
 }
 function curatedManifestOverlay(sourceUrl) {
   const file = storeManifestFile(sourceUrl);
-  return fs12.existsSync(file) ? file : void 0;
+  return fs14.existsSync(file) ? file : void 0;
 }
 function commitStoreManifest(file, message) {
   const root = getStoreRoot();
@@ -410,14 +412,14 @@ function migratedMarkerPath() {
 }
 function collectSidecarMigrationCandidates(sidecarRoot) {
   const candidates = [];
-  if (fs12.existsSync(sidecarRoot)) {
-    for (const entry of fs12.readdirSync(sidecarRoot, { withFileTypes: true })) {
+  if (fs14.existsSync(sidecarRoot)) {
+    for (const entry of fs14.readdirSync(sidecarRoot, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       const sidecarDir = path16.join(sidecarRoot, entry.name);
       const current = path16.join(sidecarDir, "skaile.manifest.yaml");
       const legacy = path16.join(sidecarDir, ".skaile-source.yaml");
-      const src = fs12.existsSync(current) ? current : fs12.existsSync(legacy) ? legacy : void 0;
+      const src = fs14.existsSync(current) ? current : fs14.existsSync(legacy) ? legacy : void 0;
       if (src) candidates.push({ src, slug: entry.name });
     }
   }
@@ -427,9 +429,9 @@ function moveSidecarManifests(candidates, manifestsDir) {
   let migrated = 0;
   for (const { src, slug } of candidates) {
     const dest = path16.join(manifestsDir, `${slug}.yaml`);
-    if (fs12.existsSync(dest)) continue;
+    if (fs14.existsSync(dest)) continue;
     try {
-      fs12.renameSync(src, dest);
+      fs14.renameSync(src, dest);
       migrated++;
     } catch (err) {
       process.stderr.write(
@@ -441,10 +443,10 @@ function moveSidecarManifests(candidates, manifestsDir) {
   return migrated;
 }
 function initStoreGitRepo(storeRoot) {
-  if (fs12.existsSync(path16.join(storeRoot, ".git"))) return;
+  if (fs14.existsSync(path16.join(storeRoot, ".git"))) return;
   try {
     spawnSync("git", ["init", "--quiet"], { cwd: storeRoot, stdio: "ignore" });
-    fs12.writeFileSync(
+    fs14.writeFileSync(
       path16.join(storeRoot, ".gitignore"),
       "# Remote-store cache \u2014 local to this machine.\nremote-cache/\n",
       "utf8"
@@ -455,14 +457,14 @@ function initStoreGitRepo(storeRoot) {
 function migrateSidecarsToStoreIfNeeded() {
   const storeRoot = getStoreRoot();
   const marker = migratedMarkerPath();
-  if (fs12.existsSync(marker)) return { migrated: 0, storeRoot };
+  if (fs14.existsSync(marker)) return { migrated: 0, storeRoot };
   const sidecarRoot = getSidecarRoot();
   const manifestsDir = getStoreManifestsDir();
   const candidates = collectSidecarMigrationCandidates(sidecarRoot);
-  fs12.mkdirSync(manifestsDir, { recursive: true });
+  fs14.mkdirSync(manifestsDir, { recursive: true });
   const migrated = moveSidecarManifests(candidates, manifestsDir);
   initStoreGitRepo(storeRoot);
-  fs12.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+  fs14.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
   return { migrated, storeRoot };
 }
 
@@ -707,7 +709,7 @@ async function purgeOrphanedAssetDefinitions(client) {
   await client.execute(`PRAGMA user_version = ${ORPHAN_PURGE_VERSION}`);
 }
 function assertNoLegacyLibDb(newDbPath) {
-  if (fs12.existsSync(newDbPath)) return;
+  if (fs14.existsSync(newDbPath)) return;
   const parent = path16.dirname(newDbPath);
   const skaileHome = globalSkaileDir();
   const defaultIndexPath2 = path16.join(skaileHome, "index.db");
@@ -723,7 +725,7 @@ function assertNoLegacyLibDb(newDbPath) {
     candidates.push(path16.join(path16.dirname(parent), "library", "lib.db"));
   }
   for (const legacy of candidates) {
-    if (!fs12.existsSync(legacy)) continue;
+    if (!fs14.existsSync(legacy)) continue;
     throw new Error(
       `Found legacy index database at ${legacy}. The lib.db \u2192 index.db relocation ran for one release and has been removed. Move the file manually to ${newDbPath} (and any -wal / -shm siblings), then retry.`
     );
@@ -898,12 +900,12 @@ var LocalIndex = class {
       dbPath = resolveIndexPath();
       this._kindRegistry = optionsOrDir?.kindRegistry;
     }
-    if (!fs12.existsSync(dir)) {
-      fs12.mkdirSync(dir, { recursive: true });
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
     const dbParent = path16.dirname(dbPath);
-    if (!fs12.existsSync(dbParent)) {
-      fs12.mkdirSync(dbParent, { recursive: true });
+    if (!fs14.existsSync(dbParent)) {
+      fs14.mkdirSync(dbParent, { recursive: true });
     }
     this.libraryDir = dir;
     this.dbPath = dbPath;
@@ -1250,7 +1252,7 @@ var LocalIndex = class {
 var UNREGISTERED_FILE = ".unregistered-libraries";
 function libraryDirMissing(lib) {
   try {
-    return !fs12.statSync(lib.path).isDirectory();
+    return !fs14.statSync(lib.path).isDirectory();
   } catch {
     return true;
   }
@@ -1263,7 +1265,7 @@ function missingLibraryDirMessage(lib) {
 }
 function realDir(dir) {
   try {
-    return fs12.realpathSync(dir);
+    return fs14.realpathSync(dir);
   } catch {
     return path16.resolve(dir);
   }
@@ -1271,7 +1273,7 @@ function realDir(dir) {
 function unregisteredLibraryNames() {
   try {
     return new Set(
-      fs12.readFileSync(path16.join(resolveLibraryDir(), UNREGISTERED_FILE), "utf8").split("\n").map((l) => l.trim()).filter(Boolean)
+      fs14.readFileSync(path16.join(resolveLibraryDir(), UNREGISTERED_FILE), "utf8").split("\n").map((l) => l.trim()).filter(Boolean)
     );
   } catch {
     return /* @__PURE__ */ new Set();
@@ -1282,8 +1284,8 @@ function markLibraryUnregistered(lib) {
   const known = unregisteredLibraryNames();
   const add = [.../* @__PURE__ */ new Set([lib.name, path16.basename(lib.path)])].filter((n) => !known.has(n));
   if (add.length === 0) return;
-  fs12.mkdirSync(resolveLibraryDir(), { recursive: true });
-  fs12.appendFileSync(
+  fs14.mkdirSync(resolveLibraryDir(), { recursive: true });
+  fs14.appendFileSync(
     path16.join(resolveLibraryDir(), UNREGISTERED_FILE),
     `${add.join("\n")}
 `,
@@ -1300,15 +1302,15 @@ function clearLibraryUnregistered(lib) {
   const keep = [...known].filter((n) => !drop.has(n));
   if (keep.length === known.size) return;
   const file = path16.join(resolveLibraryDir(), UNREGISTERED_FILE);
-  if (keep.length === 0) fs12.rmSync(file, { force: true });
-  else fs12.writeFileSync(file, `${keep.join("\n")}
+  if (keep.length === 0) fs14.rmSync(file, { force: true });
+  else fs14.writeFileSync(file, `${keep.join("\n")}
 `, "utf8");
 }
 var RENAMED_FILE = ".renamed-libraries";
 function readAllRenames() {
   const out = /* @__PURE__ */ new Map();
   try {
-    for (const line of fs12.readFileSync(path16.join(resolveLibraryDir(), RENAMED_FILE), "utf8").split("\n")) {
+    for (const line of fs14.readFileSync(path16.join(resolveLibraryDir(), RENAMED_FILE), "utf8").split("\n")) {
       const [from, to, flag] = line.split("	").map((s) => s.trim());
       if (from && to && from !== to) out.set(from, { to, gone: flag === "gone" });
     }
@@ -1319,11 +1321,11 @@ function readAllRenames() {
 function writeAllRenames(renames) {
   const file = path16.join(resolveLibraryDir(), RENAMED_FILE);
   if (renames.size === 0) {
-    fs12.rmSync(file, { force: true });
+    fs14.rmSync(file, { force: true });
     return;
   }
-  fs12.mkdirSync(resolveLibraryDir(), { recursive: true });
-  fs12.writeFileSync(
+  fs14.mkdirSync(resolveLibraryDir(), { recursive: true });
+  fs14.writeFileSync(
     file,
     `${[...renames].map(([from, r]) => `${from}	${r.to}${r.gone ? "	gone" : ""}`).join("\n")}
 `,
@@ -1907,8 +1909,8 @@ var LibraryManager = class {
   async removeLibrary(nameOrId, opts = {}) {
     const lib = await this.requireLibrary(nameOrId);
     await this.lib.removeSource(lib.id);
-    if (opts.purge && fs12.existsSync(lib.path)) {
-      fs12.rmSync(lib.path, { recursive: true, force: true });
+    if (opts.purge && fs14.existsSync(lib.path)) {
+      fs14.rmSync(lib.path, { recursive: true, force: true });
     }
     dropLibraryRenamesTo(lib.name);
     if (!opts.purge) markLibraryUnregistered(lib);
@@ -1927,7 +1929,7 @@ var LibraryManager = class {
     );
     if (writableDefault) return { library: writableDefault, created: false };
     const personalPath = path16.join(librariesDir, "personal");
-    fs12.mkdirSync(personalPath, { recursive: true });
+    fs14.mkdirSync(personalPath, { recursive: true });
     const lib = await this.addLibrary({
       name: "personal",
       path: personalPath,
@@ -2118,7 +2120,7 @@ var LocalCatalogSource = class {
 };
 function isReadableDirectory(dir) {
   try {
-    fs12.readdirSync(dir);
+    fs14.readdirSync(dir);
     return true;
   } catch {
     return false;
@@ -2260,11 +2262,11 @@ var SidecarGit = class {
    * @docLink packages/library/concepts#sidecar-git
    */
   async ensureInitialized() {
-    if (!fs12.existsSync(this.rootDir)) {
-      fs12.mkdirSync(this.rootDir, { recursive: true });
+    if (!fs14.existsSync(this.rootDir)) {
+      fs14.mkdirSync(this.rootDir, { recursive: true });
     }
     const gitDir = path16.join(this.rootDir, ".git");
-    const freshRepo = !fs12.existsSync(gitDir);
+    const freshRepo = !fs14.existsSync(gitDir);
     if (freshRepo) {
       const init = this.spawn(["init", "-b", "main"]);
       if (init.exitCode !== 0) {
@@ -2272,9 +2274,9 @@ var SidecarGit = class {
       }
     }
     const attrsPath = path16.join(this.rootDir, ".gitattributes");
-    if (!fs12.existsSync(attrsPath)) fs12.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
+    if (!fs14.existsSync(attrsPath)) fs14.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
     const readmePath = path16.join(this.rootDir, "README.md");
-    if (!fs12.existsSync(readmePath)) fs12.writeFileSync(readmePath, ROOT_README, "utf-8");
+    if (!fs14.existsSync(readmePath)) fs14.writeFileSync(readmePath, ROOT_README, "utf-8");
     if (!this.hasGlobalGitConfig("user.name")) {
       this.spawn(["config", "user.name", FALLBACK_USER_NAME]);
     }
@@ -2300,7 +2302,7 @@ var SidecarGit = class {
   async commit(slug, message, opts) {
     if (opts?.skip) return;
     const slugDir = path16.join(this.rootDir, slug);
-    if (fs12.existsSync(slugDir)) {
+    if (fs14.existsSync(slugDir)) {
       this.spawn(["add", "--", slug]);
     } else {
       this.spawn(["add", "-A"]);
@@ -2361,10 +2363,10 @@ ${result.stderr}`;
 function migrateWorkspaceConfig(dir, opts) {
   const filename = opts?.filename ?? "skaile.yaml";
   const filePath = path16.join(dir, filename);
-  if (!fs12.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     return { migrated: false, version: 1, warnings: ["No skaile.yaml found"] };
   }
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs14.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") {
     return { migrated: false, version: 1, warnings: ["Invalid YAML content"] };
@@ -2396,7 +2398,7 @@ function migrateWorkspaceConfig(dir, opts) {
     } else {
       doc.set("version", 2);
     }
-    fs12.writeFileSync(filePath, doc.toString(), "utf-8");
+    fs14.writeFileSync(filePath, doc.toString(), "utf-8");
   }
   return {
     migrated: !opts?.dryRun,
@@ -3290,17 +3292,17 @@ var CatalogCache = class {
   /** Read a cached tarball from disk if present, otherwise `null`. */
   readTarball(sha256) {
     const p = this.tarballPath(sha256);
-    if (!fs12.existsSync(p)) return null;
-    return fs12.readFileSync(p);
+    if (!fs14.existsSync(p)) return null;
+    return fs14.readFileSync(p);
   }
   /** Persist a tarball blob to disk (atomic write). */
   writeTarball(sha256, bytes) {
     const dir = path16.join(this.dir, TARBALL_DIR);
-    if (!fs12.existsSync(dir)) fs12.mkdirSync(dir, { recursive: true });
+    if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
     const finalPath = this.tarballPath(sha256);
     const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    fs12.writeFileSync(tmpPath, bytes);
-    fs12.renameSync(tmpPath, finalPath);
+    fs14.writeFileSync(tmpPath, bytes);
+    fs14.renameSync(tmpPath, finalPath);
   }
   // ── public: invalidation ────────────────────────────────────────────────
   /**
@@ -3320,8 +3322,8 @@ var CatalogCache = class {
   invalidateEverything() {
     this.invalidateAll();
     const tarballDir = path16.join(this.dir, TARBALL_DIR);
-    if (fs12.existsSync(tarballDir)) {
-      fs12.rmSync(tarballDir, { recursive: true, force: true });
+    if (fs14.existsSync(tarballDir)) {
+      fs14.rmSync(tarballDir, { recursive: true, force: true });
     }
   }
   /** Return whether `ttlMs` is zero (air-gapped mode). */
@@ -3330,9 +3332,9 @@ var CatalogCache = class {
   }
   // ── private ─────────────────────────────────────────────────────────────
   ensureDir() {
-    if (!fs12.existsSync(this.dir)) fs12.mkdirSync(this.dir, { recursive: true });
+    if (!fs14.existsSync(this.dir)) fs14.mkdirSync(this.dir, { recursive: true });
     const tarballDir = path16.join(this.dir, TARBALL_DIR);
-    if (!fs12.existsSync(tarballDir)) fs12.mkdirSync(tarballDir, { recursive: true });
+    if (!fs14.existsSync(tarballDir)) fs14.mkdirSync(tarballDir, { recursive: true });
   }
   indexPath() {
     return path16.join(this.dir, INDEX_FILE);
@@ -3340,12 +3342,12 @@ var CatalogCache = class {
   loadIndex() {
     if (this.index) return this.index;
     const p = this.indexPath();
-    if (!fs12.existsSync(p)) {
+    if (!fs14.existsSync(p)) {
       this.index = { version: 1, resolve: {}, list: {} };
       return this.index;
     }
     try {
-      const raw = JSON.parse(fs12.readFileSync(p, "utf-8"));
+      const raw = JSON.parse(fs14.readFileSync(p, "utf-8"));
       if (raw && typeof raw === "object" && raw.version === 1) {
         this.index = {
           version: 1,
@@ -3363,8 +3365,8 @@ var CatalogCache = class {
     this.index = idx;
     const p = this.indexPath();
     const tmp = `${p}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    fs12.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf-8");
-    fs12.renameSync(tmp, p);
+    fs14.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf-8");
+    fs14.renameSync(tmp, p);
   }
 };
 function filterKey(filter) {
@@ -3424,6 +3426,14 @@ function describeCatalogError(err, baseUrl) {
   const why = cause?.code ?? cause?.message ?? e?.message ?? String(err);
   return `cannot reach ${baseUrl} (${why})`;
 }
+var staleNoticed = /* @__PURE__ */ new Set();
+function staleCatalogNotice(baseUrl, err, ageMs) {
+  if (staleNoticed.has(baseUrl)) return null;
+  staleNoticed.add(baseUrl);
+  const s = Math.max(0, Math.round(ageMs / 1e3));
+  const age = s < 60 ? `${s} s` : s < 3600 ? `${Math.round(s / 60)} min` : s < 86400 ? `${Math.round(s / 3600)} h` : `${Math.round(s / 86400)} d`;
+  return `The store is not reachable (${describeCatalogError(err, baseUrl)}). This answer comes from the cache and is ${age} old.`;
+}
 var DEFAULT_TTL_MS = 864e5;
 var RemoteCatalogSource = class {
   id;
@@ -3432,6 +3442,7 @@ var RemoteCatalogSource = class {
   cacheTtlMs;
   httpClient;
   silentBackgroundErrors;
+  now;
   /** Tracks in-flight background revalidations so callers can `await` them in tests. */
   inFlight = /* @__PURE__ */ new Map();
   constructor(opts) {
@@ -3440,6 +3451,7 @@ var RemoteCatalogSource = class {
     this.cacheTtlMs = opts.cacheTtlMs ?? DEFAULT_TTL_MS;
     this.httpClient = opts.httpClient ?? defaultFetch;
     this.silentBackgroundErrors = opts.silentBackgroundErrors ?? false;
+    this.now = opts.now ?? Date.now;
     this.cache = opts.cache ?? new CatalogCache({
       dir: opts.cacheDir,
       ttlMs: this.cacheTtlMs,
@@ -3473,7 +3485,11 @@ var RemoteCatalogSource = class {
     }
     const stale = this.cache.getResolveStale(ref);
     if (stale && (stale.value === null || stale.value.requires !== void 0)) {
-      this.scheduleBackground(`resolve:${ref}`, () => this.fetchAndStoreResolve(ref));
+      this.scheduleBackground(
+        `resolve:${ref}`,
+        () => this.fetchAndStoreResolve(ref),
+        stale.fetchedAt
+      );
       return cachedAsset(stale.value);
     }
     try {
@@ -3565,7 +3581,11 @@ var RemoteCatalogSource = class {
     const stale = this.cache.getListStale(filter);
     if (stale) {
       const filterKey2 = JSON.stringify(filter ?? null);
-      this.scheduleBackground(`list:${filterKey2}`, () => this.fetchAndStoreList(filter));
+      this.scheduleBackground(
+        `list:${filterKey2}`,
+        () => this.fetchAndStoreList(filter),
+        stale.fetchedAt
+      );
       return stale.items.map(cachedAsset);
     }
     try {
@@ -3774,17 +3794,16 @@ var RemoteCatalogSource = class {
     await Promise.allSettled(promises);
   }
   // ── private ─────────────────────────────────────────────────────────────
-  scheduleBackground(key, fn) {
+  scheduleBackground(key, fn, servedFetchedAt) {
     if (this.inFlight.has(key)) return;
     const p = (async () => {
       try {
         await fn();
       } catch (err) {
         if (!this.silentBackgroundErrors) {
-          process.stderr.write(
-            `[skaile/catalog] Background refresh failed for ${key}: ${err instanceof Error ? err.message : String(err)}
-`
-          );
+          const line = staleCatalogNotice(this.baseUrl, err, this.now() - servedFetchedAt);
+          if (line) process.stderr.write(`${line}
+`);
         }
       } finally {
         this.inFlight.delete(key);
@@ -3986,6 +4005,7 @@ var RestCatalogSource = class {
   cacheTtlMs;
   httpClient;
   silentBackgroundErrors;
+  now;
   /** Tracks in-flight background revalidations so callers can `await` them in tests. */
   inFlight = /* @__PURE__ */ new Map();
   constructor(opts) {
@@ -3994,6 +4014,7 @@ var RestCatalogSource = class {
     this.cacheTtlMs = opts.cacheTtlMs ?? DEFAULT_TTL_MS2;
     this.httpClient = opts.httpClient ?? defaultFetch2;
     this.silentBackgroundErrors = opts.silentBackgroundErrors ?? false;
+    this.now = opts.now ?? Date.now;
     this.cache = opts.cache ?? new CatalogCache({
       dir: opts.cacheDir,
       ttlMs: this.cacheTtlMs,
@@ -4020,7 +4041,11 @@ var RestCatalogSource = class {
     }
     const stale = this.cache.getResolveStale(ref);
     if (stale) {
-      this.scheduleBackground(`resolve:${ref}`, () => this.fetchAndStoreResolve(ref));
+      this.scheduleBackground(
+        `resolve:${ref}`,
+        () => this.fetchAndStoreResolve(ref),
+        stale.fetchedAt
+      );
       return stale.value;
     }
     return this.fetchAndStoreResolve(ref);
@@ -4046,7 +4071,11 @@ var RestCatalogSource = class {
     const stale = this.cache.getListStale(filter);
     if (stale) {
       const filterKey2 = JSON.stringify(filter ?? null);
-      this.scheduleBackground(`list:${filterKey2}`, () => this.fetchAndStoreList(filter));
+      this.scheduleBackground(
+        `list:${filterKey2}`,
+        () => this.fetchAndStoreList(filter),
+        stale.fetchedAt
+      );
       return stale.items;
     }
     return this.fetchAndStoreList(filter);
@@ -4186,17 +4215,16 @@ var RestCatalogSource = class {
     await Promise.allSettled(promises);
   }
   // ── private ─────────────────────────────────────────────────────────────
-  scheduleBackground(key, fn) {
+  scheduleBackground(key, fn, servedFetchedAt) {
     if (this.inFlight.has(key)) return;
     const p = (async () => {
       try {
         await fn();
       } catch (err) {
         if (!this.silentBackgroundErrors) {
-          process.stderr.write(
-            `[skaile/catalog] Background refresh failed for ${key}: ${err instanceof Error ? err.message : String(err)}
-`
-          );
+          const line = staleCatalogNotice(this.baseUrl, err, this.now() - servedFetchedAt);
+          if (line) process.stderr.write(`${line}
+`);
         }
       } finally {
         this.inFlight.delete(key);
@@ -4359,15 +4387,15 @@ function discoveredToAssetEntry(asset, repoPublisher, inheritPublisher) {
 }
 function writeCuratedManifest(input) {
   const manifestPath = input.manifestFile;
-  if (fs12.existsSync(manifestPath) && !input.force) {
+  if (fs14.existsSync(manifestPath) && !input.force) {
     return { wrote: false, manifestPath, assetCount: 0 };
   }
   const publisher = input.publisher.startsWith("@") ? input.publisher.slice(1) : input.publisher;
   const inheritPublisher = input.inheritPublisher ?? false;
   const assets = input.assets.map((a) => discoveredToAssetEntry(a, publisher, inheritPublisher)).sort((a, b) => `${a.kind}:${a.name}`.localeCompare(`${b.kind}:${b.name}`));
   const manifest = { publisher, assets };
-  fs12.mkdirSync(path16.dirname(manifestPath), { recursive: true });
-  fs12.writeFileSync(manifestPath, encodeSkaileManifest(manifest), "utf-8");
+  fs14.mkdirSync(path16.dirname(manifestPath), { recursive: true });
+  fs14.writeFileSync(manifestPath, encodeSkaileManifest(manifest), "utf-8");
   return { wrote: true, manifestPath, assetCount: assets.length };
 }
 function filesEntryPaths(libraryPath, entry) {
@@ -4378,11 +4406,104 @@ function filesEntryPaths(libraryPath, entry) {
   return expandManifestFiles(libraryPath, patterns).files;
 }
 var DEFAULT_ASSET_VERSION = "0.1.0";
+var MANIFEST_LOCK_WAIT_MS = 2e4;
+var MANIFEST_LOCK_STALE_MS = 1e4;
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function manifestLockFile(libraryPath) {
+  const dir = path16.resolve(libraryPath);
+  fs14.mkdirSync(dir, { recursive: true });
+  const id = createHash("sha256").update(fs14.realpathSync(dir)).digest("hex").slice(0, 24);
+  const lockDir = path16.join(os.tmpdir(), "skaile-manifest-locks");
+  fs14.mkdirSync(lockDir, { recursive: true });
+  return path16.join(lockDir, `${id}.lock`);
+}
+function manifestLockIsStale(lockFile) {
+  try {
+    const stat = fs14.statSync(lockFile);
+    if (Date.now() - stat.mtimeMs > MANIFEST_LOCK_STALE_MS) return true;
+    const pid = Number.parseInt(fs14.readFileSync(lockFile, "utf8"), 10);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      return err.code === "ESRCH";
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function takeOverStaleLock(lockFile) {
+  let seen;
+  try {
+    seen = fs14.readFileSync(lockFile, "utf8");
+  } catch {
+    return false;
+  }
+  if (!manifestLockIsStale(lockFile)) return false;
+  const moved = `${lockFile}.stale.${process.pid}.${randomBytes(6).toString("hex")}`;
+  try {
+    fs14.renameSync(lockFile, moved);
+  } catch {
+    return false;
+  }
+  let held;
+  try {
+    held = fs14.readFileSync(moved, "utf8");
+  } catch {
+    return false;
+  }
+  if (held === seen) {
+    fs14.rmSync(moved, { force: true });
+    return true;
+  }
+  try {
+    fs14.linkSync(moved, lockFile);
+  } catch {
+  }
+  fs14.rmSync(moved, { force: true });
+  return false;
+}
+function withManifestLock(libraryPath, fn) {
+  const lockFile = manifestLockFile(libraryPath);
+  const token = `${process.pid}:${randomBytes(8).toString("hex")}`;
+  const deadline = Date.now() + MANIFEST_LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      const fd = fs14.openSync(lockFile, "wx");
+      try {
+        fs14.writeSync(fd, token);
+      } finally {
+        fs14.closeSync(fd);
+      }
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      if (takeOverStaleLock(lockFile)) continue;
+      if (Date.now() > deadline) {
+        throw new Error(
+          `${SKAILE_MANIFEST_FILENAME} of ${path16.resolve(libraryPath)} is being written by another skaile process; retry in a moment.`
+        );
+      }
+      sleepSync(5 + Math.floor(Math.random() * 20));
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      if (fs14.readFileSync(lockFile, "utf8") === token) fs14.rmSync(lockFile, { force: true });
+    } catch {
+    }
+  }
+}
 function openManifest(libraryPath) {
   const dir = path16.resolve(libraryPath);
   const file = path16.join(dir, SKAILE_MANIFEST_FILENAME);
-  if (!fs12.existsSync(file)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(file)) {
+    fs14.mkdirSync(dir, { recursive: true });
     return { editor: ManifestYamlEditor.create(file), created: true };
   }
   const editor = ManifestYamlEditor.load(file);
@@ -4392,14 +4513,14 @@ function openManifest(libraryPath) {
 }
 function assertManifestEditable(libraryPath) {
   const file = path16.join(path16.resolve(libraryPath), SKAILE_MANIFEST_FILENAME);
-  if (!fs12.existsSync(file)) return;
+  if (!fs14.existsSync(file)) return;
   openManifest(libraryPath);
 }
 function assetRootProblem(libraryPath, root) {
   const libDir = path16.resolve(libraryPath);
   let realLib;
   try {
-    realLib = fs12.realpathSync(libDir);
+    realLib = fs14.realpathSync(libDir);
   } catch {
     return void 0;
   }
@@ -4418,12 +4539,12 @@ function assetRootProblem(libraryPath, root) {
     walked.push(part);
     let stat;
     try {
-      stat = fs12.lstatSync(current);
+      stat = fs14.lstatSync(current);
     } catch {
       return void 0;
     }
     if (stat.isSymbolicLink()) {
-      return librarySymlinkMessage({ path: walked.join("/"), target: fs12.readlinkSync(current) });
+      return librarySymlinkMessage({ path: walked.join("/"), target: fs14.readlinkSync(current) });
     }
   }
   return void 0;
@@ -4438,80 +4559,92 @@ function existingRootConflict(libraryPath, existing, root) {
   if (!existing?.root || existing.source) return void 0;
   const existingAbs = path16.resolve(libraryPath, existing.root);
   if (existingAbs === path16.resolve(libraryPath, root)) return void 0;
-  const stat = fs12.statSync(existingAbs, { throwIfNoEntry: false });
+  const stat = fs14.statSync(existingAbs, { throwIfNoEntry: false });
   return stat?.isDirectory() ? existing.root : void 0;
 }
 function upsertManifestAsset(libraryPath, input) {
   if (input.root.split(/[\\/]+/).includes("..")) {
     throw new Error(`Asset root "${input.root}" must stay inside the library (no "..").`);
   }
-  const { editor } = openManifest(libraryPath);
-  const declared = editor.getPublisher();
-  const topLevel = declared === void 0 ? void 0 : barePublisher(declared);
-  const overridesTopLevel = !!input.publisher && input.publisher !== topLevel;
-  const entry = { kind: input.kind, name: input.name, root: input.root };
-  if (input.version) entry.version = input.version;
-  if (overridesTopLevel) entry.publisher = input.publisher;
-  if (input.description) entry.description = input.description;
-  if (input.keywords && input.keywords.length > 0) entry.keywords = input.keywords;
-  const existing = editor.getAssets().find((a) => a.kind === input.kind && a.name === input.name);
-  const conflict = existingRootConflict(libraryPath, existing, input.root);
-  if (conflict) {
-    throw new Error(
-      `${input.kind}:${input.name} is already registered at "${conflict}" \u2014 "${input.root}" would re-point it and orphan the first asset. Remove or rename one of them.`
-    );
-  }
-  const next = existing ? { ...existing, ...entry } : entry;
-  if (existing?.files && !existing.root && !existing.source) delete next.root;
-  if (existing && input.publisher && !overridesTopLevel) delete next.publisher;
-  if (!existing || !isDeepStrictEqual(existing, next)) {
-    editor.setAsset(next);
-    editor.save();
-  }
-  return { manifestPath: editor.path, added: !existing };
+  return withManifestLock(libraryPath, () => {
+    const { editor } = openManifest(libraryPath);
+    const declared = editor.getPublisher();
+    const topLevel = declared === void 0 ? void 0 : barePublisher(declared);
+    const overridesTopLevel = !!input.publisher && input.publisher !== topLevel;
+    const entry = { kind: input.kind, name: input.name, root: input.root };
+    if (input.version) entry.version = input.version;
+    if (overridesTopLevel) entry.publisher = input.publisher;
+    if (input.description) entry.description = input.description;
+    if (input.keywords && input.keywords.length > 0) entry.keywords = input.keywords;
+    const existing = editor.getAssets().find((a) => a.kind === input.kind && a.name === input.name);
+    const conflict = existingRootConflict(libraryPath, existing, input.root);
+    if (conflict) {
+      throw new Error(
+        `${input.kind}:${input.name} is already registered at "${conflict}" \u2014 "${input.root}" would re-point it and orphan the first asset. Remove or rename one of them.`
+      );
+    }
+    const next = existing ? { ...existing, ...entry } : entry;
+    if (existing?.files && !existing.root && !existing.source) delete next.root;
+    if (existing && input.publisher && !overridesTopLevel) delete next.publisher;
+    if (!existing || !isDeepStrictEqual(existing, next)) {
+      editor.setAsset(next);
+      editor.save();
+    }
+    return { manifestPath: editor.path, added: !existing };
+  });
 }
 function missingRootAssets(libraryPath, manifest) {
   return (manifest.assets ?? []).filter((a) => {
     if (a.source || manifest.source || !a.root) return false;
     const dir = path16.resolve(libraryPath, a.root);
-    return !(fs12.existsSync(dir) && fs12.statSync(dir).isDirectory());
+    return !(fs14.existsSync(dir) && fs14.statSync(dir).isDirectory());
   });
 }
 function pruneMissingRootAssets(libraryPath) {
   const manifest = loadSkPublishManifest(libraryPath);
-  if (!manifest) return [];
-  const missing = missingRootAssets(libraryPath, manifest);
-  if (missing.length === 0) return [];
-  const { editor } = openManifest(libraryPath);
-  const removed = missing.filter((a) => editor.removeAsset(a.kind, a.name));
-  if (removed.length > 0) editor.save();
-  return removed;
+  if (!manifest || missingRootAssets(libraryPath, manifest).length === 0) return [];
+  return withManifestLock(libraryPath, () => {
+    const current = loadSkPublishManifest(libraryPath);
+    const missing = current ? missingRootAssets(libraryPath, current) : [];
+    if (missing.length === 0) return [];
+    const { editor } = openManifest(libraryPath);
+    const removed = missing.filter((a) => editor.removeAsset(a.kind, a.name));
+    if (removed.length > 0) editor.save();
+    return removed;
+  });
 }
 function pruneUnknownKindAssets(libraryPath, knownKinds) {
+  const unknownOf = (manifest2) => (manifest2.assets ?? []).filter((a) => !knownKinds.has(a.kind));
   const manifest = loadSkPublishManifest(libraryPath);
-  if (!manifest) return [];
-  const unknown = (manifest.assets ?? []).filter((a) => !knownKinds.has(a.kind));
-  if (unknown.length === 0) return [];
-  const { editor } = openManifest(libraryPath);
-  const removed = unknown.filter((a) => editor.removeAsset(a.kind, a.name));
-  if (removed.length > 0) editor.save();
-  return removed;
+  if (!manifest || unknownOf(manifest).length === 0) return [];
+  return withManifestLock(libraryPath, () => {
+    const unknown = unknownOf(loadSkPublishManifest(libraryPath) ?? {});
+    if (unknown.length === 0) return [];
+    const { editor } = openManifest(libraryPath);
+    const removed = unknown.filter((a) => editor.removeAsset(a.kind, a.name));
+    if (removed.length > 0) editor.save();
+    return removed;
+  });
 }
 function stampManifestPublisher(libraryPath, publisher) {
-  const { editor, created } = openManifest(libraryPath);
-  if (editor.getPublisher()) return false;
-  editor.setPublisher(publisher);
-  if (created) editor.ensureAssets();
-  editor.save();
-  return true;
+  return withManifestLock(libraryPath, () => {
+    const { editor, created } = openManifest(libraryPath);
+    if (editor.getPublisher()) return false;
+    editor.setPublisher(publisher);
+    if (created) editor.ensureAssets();
+    editor.save();
+    return true;
+  });
 }
 function setManifestPublisher(libraryPath, publisher) {
-  const { editor, created } = openManifest(libraryPath);
-  if (editor.getPublisher() === publisher) return false;
-  editor.setPublisher(publisher);
-  if (created) editor.ensureAssets();
-  editor.save();
-  return true;
+  return withManifestLock(libraryPath, () => {
+    const { editor, created } = openManifest(libraryPath);
+    if (editor.getPublisher() === publisher) return false;
+    editor.setPublisher(publisher);
+    if (created) editor.ensureAssets();
+    editor.save();
+    return true;
+  });
 }
 function reconcileEntryNames(libraryPath, scanned, refused) {
   const renamed = [];
@@ -4536,7 +4669,7 @@ function reconcileEntryNames(libraryPath, scanned, refused) {
       );
       if (renamedAway) {
         superseded.push(entry);
-        edits.push((editor2) => editor2.removeAsset(entry.kind, entry.name));
+        edits.push((editor) => editor.removeAsset(entry.kind, entry.name));
       }
       continue;
     }
@@ -4545,16 +4678,18 @@ function reconcileEntryNames(libraryPath, scanned, refused) {
     if (target) {
       listed.add(`${target.kind}:${target.name}`);
       renamed.push({ from: entry, to: target.name });
-      edits.push((editor2) => editor2.renameAsset(entry.kind, entry.name, target.name));
+      edits.push((editor) => editor.renameAsset(entry.kind, entry.name, target.name));
     } else if (free.length === 0) {
       superseded.push(entry);
-      edits.push((editor2) => editor2.removeAsset(entry.kind, entry.name));
+      edits.push((editor) => editor.removeAsset(entry.kind, entry.name));
     }
   }
   if (edits.length === 0) return { renamed, superseded };
-  const { editor } = openManifest(libraryPath);
-  for (const edit of edits) edit(editor);
-  editor.save();
+  withManifestLock(libraryPath, () => {
+    const { editor } = openManifest(libraryPath);
+    for (const edit of edits) edit(editor);
+    editor.save();
+  });
   return { renamed, superseded };
 }
 async function syncManifestWithDisk(libraryPath, defaultPublisher, registry, opts = {}) {
@@ -4719,14 +4854,14 @@ async function unparsableAssetFiles(libraryPath, registry) {
 }
 function isParsable(file) {
   try {
-    return parseManifestFile(file, fs12.readFileSync(file, "utf-8")).ok;
+    return parseManifestFile(file, fs14.readFileSync(file, "utf-8")).ok;
   } catch {
     return false;
   }
 }
 function parseFailureOf(file) {
   try {
-    const res = parseManifestFile(file, fs12.readFileSync(file, "utf-8"));
+    const res = parseManifestFile(file, fs14.readFileSync(file, "utf-8"));
     return res.ok ? void 0 : res.reason;
   } catch (err) {
     return err instanceof Error ? err.message : String(err);
@@ -4734,7 +4869,7 @@ function parseFailureOf(file) {
 }
 function declaresInvalidName(file, kind) {
   try {
-    const res = parseManifestFile(file, fs12.readFileSync(file, "utf-8"));
+    const res = parseManifestFile(file, fs14.readFileSync(file, "utf-8"));
     if (!res.ok) return false;
     const declared = kind === "flow" ? res.data.id : res.data.name;
     if (declared === void 0 || declared === null || declared === "") return false;
@@ -4796,8 +4931,8 @@ function parseWorkspaceV2(raw) {
 }
 function loadWorkspaceV2(dir, filename = "skaile.yaml") {
   const filePath = path16.join(dir, filename);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs14.existsSync(filePath)) return null;
+  const content = fs14.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return parseWorkspaceV2(raw);
@@ -4805,23 +4940,23 @@ function loadWorkspaceV2(dir, filename = "skaile.yaml") {
 function saveWorkspaceV2(dir, v2, filename = "skaile.yaml") {
   const filePath = path16.join(dir, filename);
   let existing = {};
-  if (fs12.existsSync(filePath)) {
-    const content = fs12.readFileSync(filePath, "utf-8");
+  if (fs14.existsSync(filePath)) {
+    const content = fs14.readFileSync(filePath, "utf-8");
     existing = parse(content) ?? {};
   }
   existing.version = 2;
   if (v2.library !== void 0) existing.library = v2.library;
   if (v2.presets_applied !== void 0) existing.presets_applied = v2.presets_applied;
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
+  fs14.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
 }
 var LOCK_FILENAME = "skaile.lock.yaml";
 function loadLockFile(dir) {
   const filePath = path16.join(dir, LOCK_FILENAME);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs14.existsSync(filePath)) return null;
+  const content = fs14.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (raw !== null && !("assignments" in raw) && "subscriptions" in raw) {
     const legacySubs = raw.subscriptions;
@@ -4838,10 +4973,10 @@ function loadLockFile(dir) {
 }
 function saveLockFile(dir, lock) {
   const filePath = path16.join(dir, LOCK_FILENAME);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(
+  fs14.writeFileSync(
     filePath,
     `# Auto-generated by skaile. Do not edit manually.
 ${stringify(lock, { indent: 2 })}`,
@@ -4859,13 +4994,13 @@ function createEmptyLockFile() {
 }
 function detectWorkspaceVersion(dir, filename = "skaile.yaml") {
   const filePath = path16.join(dir, filename);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs14.existsSync(filePath)) return null;
+  const content = fs14.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return raw.version === 2 ? 2 : 1;
 }
 
 export { AssignmentNotFoundError, CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateAssignmentError, DuplicateLibraryNameError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockAssignmentSchema, LockFileSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, TarballHashMismatchError, UNLISTED_SCAN_SKIP_DIRS, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, assertManifestEditable, assertValidLibraryName, assetRootProblem, classifyRef, cloneOrInitGitRepo, commitStoreManifest, conflictingAssetRoot, createEmptyLockFile, curatedManifestOverlay, deriveSlug, describeCatalogError, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, ensureGitRepo, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filesEntryPaths, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, installLibraryAsset, interpolate, isGitRepo, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, lastLibraryName, libraryDirMissing, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, markLibraryUnregistered, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, missingLibraryDirMessage, missingRootAssets, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, pruneMissingRootAssets, queryInstancePickerChoices, recordLibraryRename, renamedLibraryName, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, scanAuthoringLibraries, scanLibraryRoot, scanUnlistedAssets, setManifestPublisher, setOriginUrl, sha256Hex, stampManifestPublisher, storeManifestFile, storeSecrets, syncManifestWithDisk, trackOriginBranch, trpcGetUrl, unparsableAssetFiles, unregisteredLibraryNames, upsertManifestAsset, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeCuratedManifest };
-//# sourceMappingURL=chunk-Y3I4KGLX.js.map
-//# sourceMappingURL=chunk-Y3I4KGLX.js.map
+//# sourceMappingURL=chunk-TGUMN5G7.js.map
+//# sourceMappingURL=chunk-TGUMN5G7.js.map