@skaile/workspaces 0.25.0 → 0.26.0

package/dist/{chunk-DCAWIRD6.js → chunk-RTAIGPTF.js}

@@ -1,10 +1,10 @@
-import { discoverAssetsInTree, loadSourceConfig } from './chunk-KT3CK26V.js';
-import { parseAssetRef } from './chunk-WIAHJOMG.js';
-import { PresetManifestSchema } from './chunk-NELZIQ2E.js';
+import { readManifestSourceConfig, discoverAssetsInTree } from './chunk-JIQLLZ65.js';
+import { parseAssetRef } from './chunk-IEJ5IOC3.js';
+import { PresetManifestSchema } from './chunk-QDJKE557.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
-import * as fs12 from 'fs';
+import * as fs11 from 'fs';
 import * as path4 from 'path';
 import { resolve, join, sep, dirname, isAbsolute } from 'path';
 import { eq, like, and } from 'drizzle-orm';
@@ -139,9 +139,9 @@ function projectConfigPath(projectDir) {
   return path4.join(projectDir, ".skaile", CONFIG_FILENAME);
 }
 function loadConfigFile(filePath) {
-  if (!fs12.existsSync(filePath)) return null;
+  if (!fs11.existsSync(filePath)) return null;
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     const raw = parse(content);
     if (!raw || typeof raw !== "object") return null;
     return SkaileConfigSchema.partial().parse(raw);
@@ -190,10 +190,10 @@ function resolveConfig(opts) {
 }
 function saveConfig(filePath, config) {
   const dir = path4.dirname(filePath);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
+  fs11.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
 }
 
 // library/src/local/schema.ts
@@ -276,9 +276,9 @@ function resolveSidecarPaths(slug) {
   return {
     rootDir,
     sidecarDir,
-    manifestFile: path4.join(sidecarDir, ".skaile-source.yaml"),
+    manifestFile: path4.join(sidecarDir, "skaile.manifest.yaml"),
     readmeFile: path4.join(sidecarDir, "README.md"),
-    lockFile: path4.join(sidecarDir, ".skaile-source.lock.json")
+    lockFile: path4.join(sidecarDir, "skaile.manifest.lock.json")
   };
 }
 function deriveSlug(sourceConfig, sourcePath, existingSlugs) {
@@ -294,9 +294,9 @@ function deriveSlug(sourceConfig, sourcePath, existingSlugs) {
 }
 function listSidecarSlugsOnDisk() {
   const root = getSidecarRoot();
-  if (!fs12.existsSync(root)) return [];
+  if (!fs11.existsSync(root)) return [];
   const out = [];
-  for (const entry of fs12.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs11.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     out.push(entry.name);
@@ -321,25 +321,28 @@ function migratedMarkerPath() {
 function migrateSidecarsToStoreIfNeeded() {
   const storeRoot = getStoreRoot();
   const marker = migratedMarkerPath();
-  if (fs12.existsSync(marker)) return { migrated: 0, storeRoot };
+  if (fs11.existsSync(marker)) return { migrated: 0, storeRoot };
   const sidecarRoot = getSidecarRoot();
   const manifestsDir = getStoreManifestsDir();
   const candidates = [];
-  if (fs12.existsSync(sidecarRoot)) {
-    for (const entry of fs12.readdirSync(sidecarRoot, { withFileTypes: true })) {
+  if (fs11.existsSync(sidecarRoot)) {
+    for (const entry of fs11.readdirSync(sidecarRoot, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const src = path4.join(sidecarRoot, entry.name, ".skaile-source.yaml");
-      if (fs12.existsSync(src)) candidates.push({ src, slug: entry.name });
+      const sidecarDir = path4.join(sidecarRoot, entry.name);
+      const current = path4.join(sidecarDir, "skaile.manifest.yaml");
+      const legacy = path4.join(sidecarDir, ".skaile-source.yaml");
+      const src = fs11.existsSync(current) ? current : fs11.existsSync(legacy) ? legacy : void 0;
+      if (src) candidates.push({ src, slug: entry.name });
     }
   }
-  fs12.mkdirSync(manifestsDir, { recursive: true });
+  fs11.mkdirSync(manifestsDir, { recursive: true });
   let migrated = 0;
   for (const { src, slug } of candidates) {
     const dest = path4.join(manifestsDir, `${slug}.yaml`);
-    if (fs12.existsSync(dest)) continue;
+    if (fs11.existsSync(dest)) continue;
     try {
-      fs12.renameSync(src, dest);
+      fs11.renameSync(src, dest);
       migrated++;
     } catch (err) {
       process.stderr.write(
@@ -348,10 +351,10 @@ function migrateSidecarsToStoreIfNeeded() {
       );
     }
   }
-  if (!fs12.existsSync(path4.join(storeRoot, ".git"))) {
+  if (!fs11.existsSync(path4.join(storeRoot, ".git"))) {
     try {
       spawnSync("git", ["init", "--quiet"], { cwd: storeRoot, stdio: "ignore" });
-      fs12.writeFileSync(
+      fs11.writeFileSync(
         path4.join(storeRoot, ".gitignore"),
         "# Remote-store cache \u2014 local to this machine.\nremote-cache/\n",
         "utf8"
@@ -359,7 +362,7 @@ function migrateSidecarsToStoreIfNeeded() {
     } catch {
     }
   }
-  fs12.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+  fs11.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
   return { migrated, storeRoot };
 }
 
@@ -506,7 +509,7 @@ async function runLibrariesMigration(client) {
   await client.batch(stmts);
 }
 function assertNoLegacyLibDb(newDbPath) {
-  if (fs12.existsSync(newDbPath)) return;
+  if (fs11.existsSync(newDbPath)) return;
   const parent = path4.dirname(newDbPath);
   const skaileHome = path4.join(os.homedir(), ".skaile");
   const defaultIndexPath2 = path4.join(skaileHome, "index.db");
@@ -522,7 +525,7 @@ function assertNoLegacyLibDb(newDbPath) {
     candidates.push(path4.join(path4.dirname(parent), "library", "lib.db"));
   }
   for (const legacy of candidates) {
-    if (!fs12.existsSync(legacy)) continue;
+    if (!fs11.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.`
     );
@@ -652,6 +655,10 @@ async function installFromManifest(opts) {
 function escapeLikePrefix(prefix) {
   return prefix.replace(/[%_]/g, "\\$&");
 }
+function stripRefVersion(ref) {
+  const at = ref.lastIndexOf("@");
+  return at > 0 ? ref.slice(0, at) : ref;
+}
 function rowToLibrary(row) {
   const cfg = (() => {
     try {
@@ -748,12 +755,12 @@ var LocalIndex = class {
       dbPath = resolveIndexPath();
       this._kindRegistry = optionsOrDir?.kindRegistry;
     }
-    if (!fs12.existsSync(dir)) {
-      fs12.mkdirSync(dir, { recursive: true });
+    if (!fs11.existsSync(dir)) {
+      fs11.mkdirSync(dir, { recursive: true });
     }
     const dbParent = path4.dirname(dbPath);
-    if (!fs12.existsSync(dbParent)) {
-      fs12.mkdirSync(dbParent, { recursive: true });
+    if (!fs11.existsSync(dbParent)) {
+      fs11.mkdirSync(dbParent, { recursive: true });
     }
     this.libraryDir = dir;
     this.dbPath = dbPath;
@@ -1002,10 +1009,21 @@ var LocalIndex = class {
     if (filter.defPin) conditions.push(eq(instances.defPin, filter.defPin));
     const where = conditions.length > 0 ? and(...conditions) : void 0;
     let rows = where ? await db.select().from(instances).where(where).all() : await db.select().from(instances).all();
+    if (filter.kind) {
+      const kindByBase = await this.buildInstanceKindMap(db);
+      rows = rows.filter((r) => kindByBase.get(stripRefVersion(r.defRef)) === filter.kind);
+    }
     if (filter.offset) rows = rows.slice(filter.offset);
     if (filter.limit) rows = rows.slice(0, filter.limit);
     return rows.map(rowToInstance);
   }
+  /** Map every cached asset def's version-stripped ref base to its kind. */
+  async buildInstanceKindMap(db) {
+    const defs = await db.select().from(assetDefinitions).all();
+    const map = /* @__PURE__ */ new Map();
+    for (const d of defs) map.set(stripRefVersion(d.id), d.kind);
+    return map;
+  }
   async updateInstance(id, patch) {
     const db = await this.ensureDb();
     const existing = await db.select().from(instances).where(eq(instances.id, id)).get();
@@ -1369,8 +1387,8 @@ var LibraryManager = class {
     const lib = await this.requireLibrary(nameOrId);
     const db = await this.lib.dbHandle();
     await db.delete(libraries).where(eq(libraries.id, lib.id)).run();
-    if (opts.purge && fs12.existsSync(lib.path)) {
-      fs12.rmSync(lib.path, { recursive: true, force: true });
+    if (opts.purge && fs11.existsSync(lib.path)) {
+      fs11.rmSync(lib.path, { recursive: true, force: true });
     }
   }
   /**
@@ -1387,7 +1405,7 @@ var LibraryManager = class {
     );
     if (writableDefault) return { library: writableDefault, created: false };
     const personalPath = path4.join(librariesDir, "personal");
-    fs12.mkdirSync(personalPath, { recursive: true });
+    fs11.mkdirSync(personalPath, { recursive: true });
     const lib = await this.addLibrary({
       name: "personal",
       path: personalPath,
@@ -1449,11 +1467,11 @@ var SidecarGit = class {
    * @docLink packages/library/concepts#sidecar-git
    */
   async ensureInitialized() {
-    if (!fs12.existsSync(this.rootDir)) {
-      fs12.mkdirSync(this.rootDir, { recursive: true });
+    if (!fs11.existsSync(this.rootDir)) {
+      fs11.mkdirSync(this.rootDir, { recursive: true });
     }
     const gitDir = path4.join(this.rootDir, ".git");
-    const freshRepo = !fs12.existsSync(gitDir);
+    const freshRepo = !fs11.existsSync(gitDir);
     if (freshRepo) {
       const init = this.spawn(["init", "-b", "main"]);
       if (init.exitCode !== 0) {
@@ -1461,9 +1479,9 @@ var SidecarGit = class {
       }
     }
     const attrsPath = path4.join(this.rootDir, ".gitattributes");
-    if (!fs12.existsSync(attrsPath)) fs12.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
+    if (!fs11.existsSync(attrsPath)) fs11.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
     const readmePath = path4.join(this.rootDir, "README.md");
-    if (!fs12.existsSync(readmePath)) fs12.writeFileSync(readmePath, ROOT_README, "utf-8");
+    if (!fs11.existsSync(readmePath)) fs11.writeFileSync(readmePath, ROOT_README, "utf-8");
     if (!this.hasGlobalGitConfig("user.name")) {
       this.spawn(["config", "user.name", FALLBACK_USER_NAME]);
     }
@@ -1489,7 +1507,7 @@ var SidecarGit = class {
   async commit(slug, message, opts) {
     if (opts?.skip) return;
     const slugDir = path4.join(this.rootDir, slug);
-    if (fs12.existsSync(slugDir)) {
+    if (fs11.existsSync(slugDir)) {
       this.spawn(["add", "--", slug]);
     } else {
       this.spawn(["add", "-A"]);
@@ -1600,8 +1618,8 @@ function parseWorkspaceV2(raw) {
 }
 function loadWorkspaceV2(dir, filename = "skaile.yaml") {
   const filePath = path4.join(dir, filename);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return parseWorkspaceV2(raw);
@@ -1609,32 +1627,32 @@ function loadWorkspaceV2(dir, filename = "skaile.yaml") {
 function saveWorkspaceV2(dir, v2, filename = "skaile.yaml") {
   const filePath = path4.join(dir, filename);
   let existing = {};
-  if (fs12.existsSync(filePath)) {
-    const content = fs12.readFileSync(filePath, "utf-8");
+  if (fs11.existsSync(filePath)) {
+    const content = fs11.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 (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
+  fs11.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
 }
 var LOCK_FILENAME = "skaile.lock.yaml";
 function loadLockFile(dir) {
   const filePath = path4.join(dir, LOCK_FILENAME);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   return LockFileSchema.parse(raw);
 }
 function saveLockFile(dir, lock) {
   const filePath = path4.join(dir, LOCK_FILENAME);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(
+  fs11.writeFileSync(
     filePath,
     `# Auto-generated by skaile. Do not edit manually.
 ${stringify(lock, { indent: 2 })}`,
@@ -1652,31 +1670,29 @@ function createEmptyLockFile() {
 }
 function detectWorkspaceVersion(dir, filename = "skaile.yaml") {
   const filePath = path4.join(dir, filename);
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return raw.version === 2 ? 2 : 1;
 }
-var MANIFEST_FILENAME = ".skaile-source.yaml";
+var MANIFEST_FILENAME = "skaile.manifest.yaml";
 async function writeManifestIfMissing(input) {
   const manifestPath = path4.join(input.libraryPath, MANIFEST_FILENAME);
-  if (fs12.existsSync(manifestPath)) return { wrote: false, manifestPath };
+  if (fs11.existsSync(manifestPath)) return { wrote: false, manifestPath };
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const yaml = `# Generated by skaile library add on ${now}
+  const yaml = `# Generated by skaile library add on ${now} (structure: ${input.structure})
 # Edit by hand to inline discovered assets; or run \`skaile library refresh-manifest\`.
-version: 2
-structure: ${input.structure}
 publisher: ""
 assets: []
 `;
-  fs12.writeFileSync(manifestPath, yaml, "utf-8");
+  fs11.writeFileSync(manifestPath, yaml, "utf-8");
   if (input.ownership !== "owner") {
     const excludePath = path4.join(input.libraryPath, ".git", "info", "exclude");
-    if (fs12.existsSync(path4.dirname(excludePath))) {
-      const current = fs12.existsSync(excludePath) ? fs12.readFileSync(excludePath, "utf-8") : "";
+    if (fs11.existsSync(path4.dirname(excludePath))) {
+      const current = fs11.existsSync(excludePath) ? fs11.readFileSync(excludePath, "utf-8") : "";
       if (!current.includes(MANIFEST_FILENAME)) {
-        fs12.writeFileSync(
+        fs11.writeFileSync(
           excludePath,
           (current.endsWith("\n") || current === "" ? current : `${current}
 `) + `# skaile-managed local-overlay manifest
@@ -1692,10 +1708,10 @@ ${MANIFEST_FILENAME}
 function migrateWorkspaceConfig(dir, opts) {
   const filename = opts?.filename ?? "skaile.yaml";
   const filePath = path4.join(dir, filename);
-  if (!fs12.existsSync(filePath)) {
+  if (!fs11.existsSync(filePath)) {
     return { migrated: false, version: 1, warnings: ["No skaile.yaml found"] };
   }
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") {
     return { migrated: false, version: 1, warnings: ["Invalid YAML content"] };
@@ -1727,7 +1743,7 @@ function migrateWorkspaceConfig(dir, opts) {
     } else {
       doc.set("version", 2);
     }
-    fs12.writeFileSync(filePath, doc.toString(), "utf-8");
+    fs11.writeFileSync(filePath, doc.toString(), "utf-8");
   }
   return {
     migrated: !opts?.dryRun,
@@ -1769,10 +1785,10 @@ function resolvePin(pin, availableVersions) {
     const base = pin.slice(0, -2);
     const parts = base.split(".");
     const major = Number.parseInt(parts[0], 10);
-    const minor = parts.length > 1 ? Number.parseInt(parts[1], 10) : 0;
+    const minor = parts.length > 1 ? Number.parseInt(parts[1], 10) : void 0;
     if (Number.isNaN(major)) return null;
     const match = parsed.find(
-      (v) => v.major === major && (Number.isNaN(minor) || v.minor === minor)
+      (v) => v.major === major && (minor === void 0 || v.minor === minor)
     );
     return match ? { version: match.raw, match: "range" } : null;
   }
@@ -1810,6 +1826,8 @@ function parseRangeTarget(range) {
     patch: Number.isNaN(patch) ? 0 : patch
   };
 }
+
+// library/src/local/local-catalog-source.ts
 var LocalCatalogSource = class {
   constructor(library, sourceId, rootPath, registry, options) {
     this.library = library;
@@ -1838,6 +1856,17 @@ var LocalCatalogSource = class {
     const defs = await this.library.listAssetDefs(libraryFilter);
     return defs.map(defToCatalogAsset);
   }
+  async listVersions(ref) {
+    const parsed = parseAssetRef(ref);
+    const defs = await this.library.listAssetDefs({
+      libraryId: this.sourceId,
+      kind: parsed.kind
+    });
+    const wantPublisher = parsed.publisher?.replace(/^@/, "");
+    return defs.filter(
+      (d) => d.name === parsed.name && (wantPublisher === void 0 || d.publisher.replace(/^@/, "") === wantPublisher)
+    ).map((d) => d.version);
+  }
   async fetchTarball(_ref, _sha256) {
     throw new Error(
       "LocalCatalogSource does not support tarball delivery. Assets are available on disk."
@@ -1864,7 +1893,7 @@ var LocalCatalogSource = class {
       includeDev: syncOpts?.includeDev ?? false
     };
     if (!this.sidecarPath) {
-      opts.sourceConfig = loadSourceConfigIfPresent(this.rootPath);
+      opts.sourceConfig = readManifestSourceConfig(this.rootPath);
     }
     const result = discoverAssetsInTree(this.rootPath, opts);
     let assetsUpdated = 0;
@@ -1912,18 +1941,6 @@ function defToCatalogAsset(def) {
     manifest: def.manifest
   };
 }
-function loadSourceConfigIfPresent(rootPath) {
-  const configPath = path4.join(rootPath, ".skaile-source.yaml");
-  if (!fs12.existsSync(configPath)) return void 0;
-  try {
-    const content = fs12.readFileSync(configPath, "utf-8");
-    const result = loadSourceConfig(content);
-    if (!result.ok) return void 0;
-    return result.config;
-  } catch {
-    return void 0;
-  }
-}
 function defaultCacheDir() {
   return path4.join(os.homedir(), ".skaile", "catalog-cache");
 }
@@ -2002,17 +2019,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 (!fs11.existsSync(p)) return null;
+    return fs11.readFileSync(p);
   }
   /** Persist a tarball blob to disk (atomic write). */
   writeTarball(sha256, bytes) {
     const dir = path4.join(this.dir, TARBALL_DIR);
-    if (!fs12.existsSync(dir)) fs12.mkdirSync(dir, { recursive: true });
+    if (!fs11.existsSync(dir)) fs11.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);
+    fs11.writeFileSync(tmpPath, bytes);
+    fs11.renameSync(tmpPath, finalPath);
   }
   // ── public: invalidation ────────────────────────────────────────────────
   /**
@@ -2032,8 +2049,8 @@ var CatalogCache = class {
   invalidateEverything() {
     this.invalidateAll();
     const tarballDir = path4.join(this.dir, TARBALL_DIR);
-    if (fs12.existsSync(tarballDir)) {
-      fs12.rmSync(tarballDir, { recursive: true, force: true });
+    if (fs11.existsSync(tarballDir)) {
+      fs11.rmSync(tarballDir, { recursive: true, force: true });
     }
   }
   /** Return whether `ttlMs` is zero (air-gapped mode). */
@@ -2042,9 +2059,9 @@ var CatalogCache = class {
   }
   // ── private ─────────────────────────────────────────────────────────────
   ensureDir() {
-    if (!fs12.existsSync(this.dir)) fs12.mkdirSync(this.dir, { recursive: true });
+    if (!fs11.existsSync(this.dir)) fs11.mkdirSync(this.dir, { recursive: true });
     const tarballDir = path4.join(this.dir, TARBALL_DIR);
-    if (!fs12.existsSync(tarballDir)) fs12.mkdirSync(tarballDir, { recursive: true });
+    if (!fs11.existsSync(tarballDir)) fs11.mkdirSync(tarballDir, { recursive: true });
   }
   indexPath() {
     return path4.join(this.dir, INDEX_FILE);
@@ -2052,12 +2069,12 @@ var CatalogCache = class {
   loadIndex() {
     if (this.index) return this.index;
     const p = this.indexPath();
-    if (!fs12.existsSync(p)) {
+    if (!fs11.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(fs11.readFileSync(p, "utf-8"));
       if (raw && typeof raw === "object" && raw.version === 1) {
         this.index = {
           version: 1,
@@ -2075,8 +2092,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);
+    fs11.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf-8");
+    fs11.renameSync(tmp, p);
   }
 };
 function filterKey(filter) {
@@ -2232,6 +2249,20 @@ var RemoteCatalogSource = class {
     this.cache.writeTarball(sha256, buf);
     return buf;
   }
+  /**
+   * Enumerate available versions for a version-less ref. The Catalog has no
+   * dedicated version-list route, so this derives versions from `listAssets`
+   * (filtered to the publisher) and keeps only the matching kind+name. Reuses
+   * the cached list path, so repeated calls are cheap.
+   */
+  async listVersions(ref) {
+    const parsed = parseAssetRef(ref);
+    const wantPublisher = parsed.publisher?.replace(/^@/, "");
+    const assets = await this.listAssets(wantPublisher ? { publisher: wantPublisher } : void 0);
+    return assets.filter(
+      (a) => a.kind === parsed.kind && a.name === parsed.name && (wantPublisher === void 0 || a.publisher.replace(/^@/, "") === wantPublisher)
+    ).map((a) => a.version);
+  }
   /**
    * Single synthetic Source pointing at the configured Catalog URL. Phase 2
    * is single-Source per spec; multi-source federation is Phase 4.8.
@@ -2655,6 +2686,20 @@ var RestCatalogSource = class {
     this.cache.writeTarball(sha256, buf);
     return buf;
   }
+  /**
+   * Enumerate available versions for a version-less ref. The forge-store REST
+   * API has no version-list route, so this derives versions from `listAssets`
+   * (filtered to the publisher) and keeps only the matching kind+name. Reuses
+   * the cached list path, so repeated calls are cheap.
+   */
+  async listVersions(ref) {
+    const parsed = parseAssetRef(ref);
+    const wantPublisher = parsed.publisher?.replace(/^@/, "");
+    const assets = await this.listAssets(wantPublisher ? { publisher: wantPublisher } : void 0);
+    return assets.filter(
+      (a) => a.kind === parsed.kind && a.name === parsed.name && (wantPublisher === void 0 || a.publisher.replace(/^@/, "") === wantPublisher)
+    ).map((a) => a.version);
+  }
   /**
    * Single synthetic Source pointing at the configured forge-store URL.
    */
@@ -2857,9 +2902,9 @@ function validateKnowledge(data) {
 }
 function collectDirRecursive(baseDir, relativeDir) {
   const full = path4.join(baseDir, relativeDir);
-  if (!fs12.existsSync(full) || !fs12.statSync(full).isDirectory()) return [];
+  if (!fs11.existsSync(full) || !fs11.statSync(full).isDirectory()) return [];
   const results = [];
-  for (const entry of fs12.readdirSync(full, { withFileTypes: true })) {
+  for (const entry of fs11.readdirSync(full, { withFileTypes: true })) {
     const rel = path4.posix.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectDirRecursive(baseDir, rel));
@@ -3067,6 +3112,9 @@ function validateAllPlaceholders(placeholders, inputs) {
 }
 async function queryInstancePickerChoices(library, options) {
   const filter = {};
+  if (options?.kind) {
+    filter.kind = options.kind;
+  }
   if (options?.defRefPrefix) {
     filter.defRef = options.defRefPrefix;
   }
@@ -3266,8 +3314,8 @@ function resolveTemplate(template, context) {
   });
   return { value: result, hasSecret: false };
 }
-function setNestedValue(obj, path14, value) {
-  const parts = path14.split(".");
+function setNestedValue(obj, path13, value) {
+  const parts = path13.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const key = parts[i];
@@ -3300,11 +3348,9 @@ async function applyPreset(presetRef, manifest, inputs, opts) {
       itemResults
     );
     result.errors.push(...itemResult.errors);
-    for (const inst of itemResult.instances) {
-      result.instances.push(inst);
-      if (item.id && itemResult.instances.length > 0) {
-        itemResults.set(item.id, itemResult.instances[0]);
-      }
+    result.instances.push(...itemResult.instances);
+    if (item.id && itemResult.instances.length > 0) {
+      itemResults.set(item.id, itemResult.instances[0]);
     }
     result.subscriptions.push(...itemResult.subscriptions);
   }
@@ -3569,5 +3615,5 @@ function deepEqual(a, b) {
 }
 
 export { CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateLibraryNameError, DuplicateSubscriptionError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KNOWN_ASSET_KINDS, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LIBRARY_STRUCTURES, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockFileSchema, LockSubscriptionSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, SubscriptionNotFoundError, TarballHashMismatchError, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, classifyRef, createEmptyLockFile, deriveSlug, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, installFromManifest, interpolate, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, queryInstancePickerChoices, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolveLibraryDir, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, sha256Hex, skaileHomeDir, storeSecrets, trpcGetUrl, userConfigPath, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeManifestIfMissing };
-//# sourceMappingURL=chunk-DCAWIRD6.js.map
-//# sourceMappingURL=chunk-DCAWIRD6.js.map
+//# sourceMappingURL=chunk-RTAIGPTF.js.map
+//# sourceMappingURL=chunk-RTAIGPTF.js.map