@skaile/workspaces 5.2.0 → 5.4.0

package/dist/{chunk-L257BENF.js → chunk-BATL2CWI.js}

@@ -1,13 +1,13 @@
-import { getStoreManifestsDir } from './chunk-B4J4RGNY.js';
-import { readManifestSourceConfig, discoverAssetsInTree } from './chunk-LZ5RH6LD.js';
-import { deployAll, removeAsset, createScaffold } from './chunk-KGGT6MUM.js';
-import { resolveConfiguredDriverTarget, resolveLibraryDir, buildLibraryLockEntries, writeLock, buildLockFile, readLock, verifyLock, mergeLockFile, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-BIMEKYOE.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-PU5VY7KF.js';
-import { deployedBase, deployedDir, isDeployed } from './chunk-U6K3I3AX.js';
-import { loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, coerceVersion, matchPin, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks, storeManifestSlug } from './chunk-P2EM6FNQ.js';
-import { globalSkaileDir, globalCacheRoot, migrateLegacyDir } from './chunk-TLKM4M47.js';
-import { scanDirectory, parseRequires } from './chunk-YANDJSMN.js';
-import { parseAssetRef, parseAssetRefLoose, slugifyAssetName, assetRefToStr } from './chunk-OABIGSUY.js';
+import { getStoreManifestsDir } from './chunk-Y5OCUOXF.js';
+import { readManifestSourceConfig, discoverAssetsInTree } from './chunk-Y7UBRRKG.js';
+import { deployAll, removeAsset, canonicalEntryRef, createScaffold } from './chunk-37DN45RR.js';
+import { resolveConfiguredDriverTarget, GLOBAL_INSTALL_DIR_NAME, resolveLibraryDir, buildLibraryLockEntries, writeLock, buildLockFile, readLock, verifyLock, mergeLockFile, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-QEXEHXX5.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-JCATNLY3.js';
+import { deployedBase, deployedDir, isDeployed } from './chunk-XGIS325V.js';
+import { loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, matchPin, coerceVersion, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks, storeManifestSlug } from './chunk-6IGFSUTE.js';
+import { globalSkaileDir, globalCacheRoot, migrateLegacyDir } from './chunk-MFHKHXDE.js';
+import { scanDirectory, parseRequires } from './chunk-LFMX2UEF.js';
+import { parseAssetRef, parseAssetRefLoose, assetRefToStr, slugifyAssetName } from './chunk-WX74MVNA.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
 import { spawnSync } from 'child_process';
@@ -597,6 +597,13 @@ var AssetManager = class {
       source,
       publisher: slug,
       version: c.version,
+      // `publisher` above is the clone key; the printed ref carries the real publisher.
+      canonicalRef: assetRefToStr({
+        kind: c.kind,
+        name: c.name,
+        publisher: c.publisher,
+        pin: c.version || void 0
+      }),
       requires: [],
       // Manifest-declared deps are authoritative for the candidate's deps.
       dependencies: c.deps ?? [],
@@ -630,15 +637,20 @@ var AssetManager = class {
     if (missing.length === 0) return { entries: [], resolved, libraryOf };
     const roots = [];
     for (const l of (await this.loadLibraryIndex())?.libraries ?? []) {
-      if (existsSync(l.path)) roots.push({ name: l.name, dir: l.path });
+      if (l.name === GLOBAL_INSTALL_DIR_NAME) continue;
+      if (existsSync(l.path)) roots.push({ name: l.name, dir: l.path, isDefault: l.isDefault });
     }
     const registered = new Set(roots.map((r) => r.name));
     try {
       const librariesRoot = resolveLibraryDir();
       if (existsSync(librariesRoot)) {
         for (const dirent of readdirSync(librariesRoot, { withFileTypes: true })) {
-          if (dirent.isDirectory() && !registered.has(dirent.name)) {
-            roots.push({ name: dirent.name, dir: join(librariesRoot, dirent.name) });
+          if (dirent.isDirectory() && dirent.name !== GLOBAL_INSTALL_DIR_NAME && !registered.has(dirent.name)) {
+            roots.push({
+              name: dirent.name,
+              dir: join(librariesRoot, dirent.name),
+              isDefault: false
+            });
           }
         }
       }
@@ -646,14 +658,14 @@ var AssetManager = class {
     }
     if (roots.length === 0) return { entries: [], resolved, libraryOf };
     const byKey = /* @__PURE__ */ new Map();
+    const isDefaultLib = new Map(roots.map((r) => [r.name, r.isDefault]));
     for (const { name, dir } of roots) {
       const publisher = readDeclaredPublisher(dir) ?? slugifyAssetName(name);
       for (const entry of await scanDirectory(dir, publisher)) {
         const key = `${entry.kind}:@${entry.publisher}/${entry.name}`;
-        const prev = byKey.get(key);
-        if (!prev || gt(coerceVersion(entry.version ?? ""), coerceVersion(prev.entry.version ?? ""))) {
-          byKey.set(key, { entry, library: name });
-        }
+        const list = byKey.get(key);
+        if (list) list.push({ entry, library: name });
+        else byKey.set(key, [{ entry, library: name }]);
       }
     }
     if (byKey.size === 0) return { entries: [], resolved, libraryOf };
@@ -666,15 +678,43 @@ var AssetManager = class {
         continue;
       }
       if (!parsed.publisher) continue;
-      const hit = byKey.get(`${parsed.kind}:@${parsed.publisher}/${parsed.name}`);
-      if (!hit) continue;
-      if (parsed.pin && !matchPin(parsed.pin, hit.entry.version ?? "")) continue;
+      const key = `${parsed.kind}:@${parsed.publisher}/${parsed.name}`;
+      const candidates = (byKey.get(key) ?? []).filter(
+        (c) => !parsed.pin || matchPin(parsed.pin, c.entry.version ?? "")
+      );
+      if (candidates.length === 0) continue;
+      candidates.sort((a, b) => {
+        const va = coerceVersion(a.entry.version ?? "");
+        const vb = coerceVersion(b.entry.version ?? "");
+        if (gt(va, vb)) return -1;
+        if (gt(vb, va)) return 1;
+        const da = isDefaultLib.get(a.library) ? 0 : 1;
+        const db = isDefaultLib.get(b.library) ? 0 : 1;
+        return da - db || a.library.localeCompare(b.library);
+      });
+      const hit = candidates[0];
+      this.warnLibraryCollision(key, candidates, hit);
       entries.push(hit.entry);
       libraryOf.set(hit.entry, hit.library);
       resolved.add(ref);
     }
     return { entries, resolved, libraryOf };
   }
+  /** Collision messages already printed by this instance (one warning per ref + library set). */
+  warnedLibraryCollisions = /* @__PURE__ */ new Set();
+  /**
+   * Warn once when `key` is held by more than one library: names every library
+   * with its version and the one chosen, so a silent pick can't surprise.
+   */
+  warnLibraryCollision(key, candidates, chosen) {
+    const libraries = new Set(candidates.map((c) => c.library));
+    if (libraries.size < 2) return;
+    const held = candidates.map((c) => `${c.library} (${c.entry.version || "unversioned"})`);
+    const msg = `skaile: ${key} exists in ${libraries.size} libraries: ${held.join(", ")} \u2014 using ${chosen.library} (${chosen.entry.version || "unversioned"}). Highest version wins; an equal version goes to the default library, then by name. Pin a version (${key}#<version>) to choose another.`;
+    if (this.warnedLibraryCollisions.has(msg)) return;
+    this.warnedLibraryCollisions.add(msg);
+    console.warn(msg);
+  }
   /**
    * Open the local index and snapshot its libraries + asset definitions.
    * Best-effort: no index file (never indexed), or any open/guard failure,
@@ -746,7 +786,9 @@ var AssetManager = class {
       }
       const libPath = this.libraryPath(origin.name, snap);
       if (!libPath) {
-        missing.push(`${ref} (library "${origin.name}" not found)`);
+        missing.push(
+          `${ref} (library "${origin.name}" is not registered \u2014 renamed or removed? re-lock with \`skaile install\`)`
+        );
         continue;
       }
       const found = (await scanDirectory(libPath, publisher)).find(
@@ -767,7 +809,9 @@ var AssetManager = class {
       if (origin.sha256) {
         const onDisk = libraryDiskHashes(libPath, diskHashes).get(`${kind}:${name}`);
         if (onDisk !== void 0 && onDisk !== origin.sha256) {
-          missing.push(`${ref} (library "${origin.name}" content changed since lock)`);
+          missing.push(
+            `${ref} (library "${origin.name}" content changed since lock \u2014 or the lock predates the one shared asset hash; re-lock with \`skaile install\`)`
+          );
           continue;
         }
       }
@@ -780,6 +824,7 @@ var AssetManager = class {
    * when it exists, else `<libraries dir>/<name>`; `null` when neither is a directory.
    */
   libraryPath(name, snap) {
+    if (name === GLOBAL_INSTALL_DIR_NAME) return null;
     const registered = snap?.libraries.find((l) => l.name === name)?.path;
     if (registered && existsSync(registered)) return registered;
     try {
@@ -1235,6 +1280,8 @@ var AssetManager = class {
         // Keep the publisher label slash-free (repo name), not the full cache key.
         publisher: sourceShortName(entry.source.url),
         version: entry.source.commit,
+        // The lock key is the canonical ref; `publisher` above is only a clone label.
+        canonicalRef: ref,
         requires: [],
         dependencies: []
       });
@@ -1267,6 +1314,8 @@ var AssetManager = class {
    * @param opts.link - When `true`, symlink local-path assets instead of copying them
    *   (the author dev-loop). Machine-local / not for committing; a no-op for
    *   store/factory sources. Defaults to copy.
+   * @param opts.onLibraryOrigin - Called once per deployed library-origin asset with its
+   *   canonical ref and the name of the library it was resolved from.
    * @returns Array of asset refs that were deployed in this call.
    * @throws When the asset cannot be found in any configured repository.
    */
@@ -1296,6 +1345,13 @@ var AssetManager = class {
         )
       )
     ];
+    if (opts?.onLibraryOrigin) {
+      for (const e of lib.entries) {
+        const origin = lib.libraryOf.get(e);
+        const deployedRef = canonicalEntryRef(e);
+        if (origin && deployed.includes(deployedRef)) opts.onLibraryOrigin(deployedRef, origin);
+      }
+    }
     this.addDependencyToConfig(ref);
     await this.renderDriverMcpConfig();
     if (resolved.length > 0 || lib.entries.length > 0) {
@@ -1974,10 +2030,11 @@ var AssetManager = class {
     const lock = this.tryReadLock();
     if (!lock) return [];
     const result = [];
+    const reported = /* @__PURE__ */ new Set();
     for (const src of lock.sources) {
       const slug = sourceCacheKey(src.url);
       const decl = repositories[slug];
-      if (!decl || decl.path) continue;
+      if (!decl) continue;
       const status = checkRepoStatus(decl, slug, this.reposDir);
       if (status.behind <= 0) continue;
       for (const [ref, entry] of Object.entries(lock.assets)) {
@@ -1991,15 +2048,31 @@ var AssetManager = class {
           currentVersion: version ?? "",
           behind: status.behind
         });
+        reported.add(ref);
       }
     }
-    const libraryAssets = Object.entries(lock.assets).filter(([, e]) => e.library);
+    const libraryAssets = Object.entries(lock.assets).filter(
+      ([, e]) => e.library && !e.library.installed
+    );
     if (libraryAssets.length > 0) {
       const snap = await this.loadLibraryIndex();
       for (const [ref, entry] of libraryAssets) {
         const origin = entry.library;
         const { publisher, kind, name } = parseCanonicalLockKey(ref);
         if (!publisher || !kind || !name) continue;
+        if (!this.libraryPath(origin.name, snap)) {
+          result.push({
+            kind,
+            name,
+            publisher,
+            currentVersion: origin.version,
+            behind: 0,
+            library: origin.name,
+            problem: `library "${origin.name}" is not registered (renamed or removed?)`
+          });
+          reported.add(ref);
+          continue;
+        }
         const def = newestLibraryDef(snap, origin.name, { kind, publisher, name });
         if (!def || !gt(coerceVersion(def.version), coerceVersion(origin.version))) continue;
         result.push({
@@ -2011,14 +2084,35 @@ var AssetManager = class {
           latestVersion: def.version,
           library: origin.name
         });
+        reported.add(ref);
+      }
+    }
+    for (const [ref, entry] of Object.entries(lock.assets)) {
+      if (reported.has(ref) || entry.library?.installed) continue;
+      const { publisher, kind, name, version } = parseCanonicalLockKey(ref);
+      if (!kind || !name || NON_DEPLOYABLE_KINDS.has(kind)) continue;
+      if (isDeployed(kind, name, this.driverTarget, this.global, this.projectDir)) {
+        continue;
       }
+      result.push({
+        kind,
+        name,
+        publisher: publisher ?? "",
+        currentVersion: entry.library?.version ?? version ?? "",
+        behind: 0,
+        ...entry.library ? { library: entry.library.name } : {},
+        problem: "deployed copy missing"
+      });
     }
     return result;
   }
   /**
-   * Produce a unified diff between the deployed asset and its catalog source.
+   * Produce a unified diff from the deployed asset to its catalog source: `-` lines
+   * are in the deployed copy only (local edits `update` would overwrite), `+` lines
+   * are in the source only (what `update` would add).
    *
-   * Useful for detecting manual edits to deployed files or verifying that a patch
+   * Useful for detecting manual edits to deployed files or seeing what an upstream
+   * change would bring in; also for verifying that a patch
    * was applied correctly.
    *
    * @param ref - Asset ref in `kind:name` form.
@@ -2035,7 +2129,7 @@ var AssetManager = class {
       parsed.name
     );
     if (!existsSync(deployedPath)) return { status: "not-deployed" };
-    const r = spawnSync("diff", ["-ruN", entry.source, deployedPath], { encoding: "utf8" });
+    const r = spawnSync("diff", ["-ruN", deployedPath, entry.source], { encoding: "utf8" });
     if (r.status === 1) return { status: "differs", diff: r.stdout };
     if (r.status === 0) return { status: "identical" };
     throw new Error(`diff failed for ${ref}: ${r.stderr || r.error?.message || "unknown error"}`);
@@ -2166,15 +2260,17 @@ var AssetManager = class {
       const full = await this.info(`${entry.kind}:${entry.name}`);
       if (!full) continue;
       for (const req of full.requires) {
+        const dep = memberIdentity(`${req.kind}:${req.name}`);
+        if (!dep) continue;
         if (!isDeployed(
-          req.kind,
-          req.name,
+          dep.kind,
+          dep.name,
           this.driverTarget,
           this.global,
           this.projectDir
         )) {
           const inRepos = await resolveAsset(
-            { kind: req.kind, name: req.name },
+            { kind: dep.kind, name: dep.name },
             repositories,
             this.reposDir
           ) !== null;
@@ -2378,5 +2474,5 @@ var AssetManager = class {
 };
 
 export { AssetManager, FACTORY_SOURCE_URL, MissingManifestError, NON_DEPLOYABLE_KINDS, normalizeRepoUrl, parseCanonicalLockKey, parseRefTolerant, renderMcpServerConfig, softDepName };
-//# sourceMappingURL=chunk-L257BENF.js.map
-//# sourceMappingURL=chunk-L257BENF.js.map
+//# sourceMappingURL=chunk-BATL2CWI.js.map
+//# sourceMappingURL=chunk-BATL2CWI.js.map