@skaile/workspaces 4.36.0 → 4.38.0

package/dist/{chunk-PKGI5QG7.js → chunk-QWWDDU5Z.js}

@@ -1,11 +1,13 @@
-import { getStoreManifestsDir } from './chunk-BSIHJZKN.js';
-import { deployAll, removeAsset, createScaffold } from './chunk-VCLN2IUM.js';
-import { resolveLibraryDir, writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-FJYOQMXT.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-VRFKCF3R.js';
-import { deployedBase, isDeployed, deployedDir } from './chunk-KIFJWSNC.js';
-import { loadMcpServerDeclarations, globalSkaileDir, resolveGlobalHarnesses, globalCacheRoot, migrateLegacyDir, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, coerceVersion, matchPin, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks, storeManifestSlug } from './chunk-QKXDRBLL.js';
-import { scanDirectory, parseRequires } from './chunk-SQ7IN7KR.js';
-import { parseAssetRef, slugifyAssetName, assetRefToStr } from './chunk-GEEW6SY2.js';
+import { getStoreManifestsDir } from './chunk-XU7JET5Z.js';
+import { readManifestSourceConfig, discoverAssetsInTree } from './chunk-OLMNDIAU.js';
+import { deployAll, removeAsset, createScaffold } from './chunk-YCMZHL4T.js';
+import { resolveLibraryDir, buildLibraryLockEntries, writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-YV3YI3TA.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-36ML6SFP.js';
+import { deployedBase, isDeployed, deployedDir } from './chunk-KAJH3XPW.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-JEPSP6XK.js';
+import { globalSkaileDir, globalCacheRoot, migrateLegacyDir } from './chunk-TLKM4M47.js';
+import { scanDirectory, parseRequires } from './chunk-5K2VT6E2.js';
+import { parseAssetRef, slugifyAssetName, assetRefToStr } from './chunk-A5EDMBFG.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
 import { spawnSync } from 'child_process';
@@ -239,18 +241,50 @@ function commonDirPrefix(paths) {
 }
 function indexLockByKindName(lock) {
   const lockByKindName = /* @__PURE__ */ new Map();
-  for (const [key] of Object.entries(lock?.assets ?? {})) {
+  for (const [key, entry] of Object.entries(lock?.assets ?? {})) {
     const parsed = parseCanonicalLockKey(key);
     if (parsed.kind && parsed.name && parsed.publisher && parsed.version) {
       lockByKindName.set(`${parsed.kind}:${parsed.name}`, {
         publisher: parsed.publisher,
         version: parsed.version,
-        url: lock.assets[key].source.url
+        url: entry.source?.url ?? "",
+        library: entry.library !== void 0
       });
     }
   }
   return lockByKindName;
 }
+function libraryDiskHashes(libPath, cache) {
+  let hashes = cache.get(libPath);
+  if (!hashes) {
+    const sourceConfig = readManifestSourceConfig(libPath) ?? {
+      version: 1,
+      publisher_default: "@library",
+      default_ref: "main",
+      publisher_overrides: [],
+      dev_paths: []
+    };
+    hashes = new Map(
+      discoverAssetsInTree(libPath, { sourceConfig }).assets.map((a) => [
+        `${a.kind}:${a.name}`,
+        a.sha256
+      ])
+    );
+    cache.set(libPath, hashes);
+  }
+  return hashes;
+}
+function newestLibraryDef(snap, libraryName, id) {
+  const lib = snap?.libraries.find((l) => l.name === libraryName);
+  if (!snap || !lib) return void 0;
+  let best;
+  for (const d of snap.defs) {
+    if (d.libraryId !== lib.id || d.kind !== id.kind || d.name !== id.name) continue;
+    if (d.publisher.replace(/^@/, "") !== id.publisher) continue;
+    if (!best || gt(coerceVersion(d.version), coerceVersion(best.version))) best = d;
+  }
+  return best;
+}
 function computeSyncStatus(repoStatus) {
   if (!repoStatus) return "unknown";
   if (repoStatus.kind === "local") return "local";
@@ -596,38 +630,46 @@ var AssetManager = class {
    * the consume side of `library create` — a freshly authored asset is
    * deployable with `skaile add <kind>:@<publisher>/<name>` without publishing.
    *
-   * Pure local read (no index, no network) and mirrors how `findSkills`
-   * discovers library content. Library assets are deliberately NOT written to
-   * the lock (a local authoring place is not a reproducible source); they are
-   * re-discovered on every `add`/`install`, so reconcile never treats them as
-   * stale.
+   * Local read (no network) and mirrors how `findSkills` discovers library
+   * content. The returned `libraryOf` map names the library each entry came from
+   * so callers can lock it as library-origin (see {@link libraryLockEntries}).
    *
-   * @returns the matched deploy entries plus the set of `missing` refs covered.
+   * @returns the matched deploy entries, the set of `missing` refs covered, and
+   *   each entry's originating library name.
    */
   async resolveLibraryEntries(missing) {
     const resolved = /* @__PURE__ */ new Set();
-    if (missing.length === 0) return { entries: [], resolved };
-    let librariesRoot;
+    const libraryOf = /* @__PURE__ */ new Map();
+    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 });
+    }
+    const registered = new Set(roots.map((r) => r.name));
     try {
-      librariesRoot = resolveLibraryDir();
+      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) });
+          }
+        }
+      }
     } catch {
-      return { entries: [], resolved };
     }
-    if (!existsSync(librariesRoot)) return { entries: [], resolved };
+    if (roots.length === 0) return { entries: [], resolved, libraryOf };
     const byKey = /* @__PURE__ */ new Map();
-    for (const dirent of readdirSync(librariesRoot, { withFileTypes: true })) {
-      if (!dirent.isDirectory()) continue;
-      const libPath = join(librariesRoot, dirent.name);
-      const publisher = readDeclaredPublisher(libPath) ?? slugifyAssetName(dirent.name);
-      for (const entry of await scanDirectory(libPath, publisher)) {
+    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.version ?? ""))) {
-          byKey.set(key, entry);
+        if (!prev || gt(coerceVersion(entry.version ?? ""), coerceVersion(prev.entry.version ?? ""))) {
+          byKey.set(key, { entry, library: name });
         }
       }
     }
-    if (byKey.size === 0) return { entries: [], resolved };
+    if (byKey.size === 0) return { entries: [], resolved, libraryOf };
     const entries = [];
     for (const ref of missing) {
       let parsed;
@@ -637,13 +679,126 @@ var AssetManager = class {
         continue;
       }
       if (!parsed.publisher) continue;
-      const entry = byKey.get(`${parsed.kind}:@${parsed.publisher}/${parsed.name}`);
-      if (!entry) continue;
-      if (parsed.pin && !matchPin(parsed.pin, entry.version ?? "")) continue;
-      entries.push(entry);
+      const hit = byKey.get(`${parsed.kind}:@${parsed.publisher}/${parsed.name}`);
+      if (!hit) continue;
+      if (parsed.pin && !matchPin(parsed.pin, hit.entry.version ?? "")) continue;
+      entries.push(hit.entry);
+      libraryOf.set(hit.entry, hit.library);
       resolved.add(ref);
     }
-    return { entries, resolved };
+    return { entries, resolved, libraryOf };
+  }
+  /**
+   * Open the local index and snapshot its libraries + asset definitions.
+   * Best-effort: no index file (never indexed), or any open/guard failure,
+   * yields `null` — a lock/outdated read must never create `index.db` or throw.
+   */
+  async loadLibraryIndex() {
+    try {
+      const { LocalIndex, resolveIndexPath } = await import('./library/index.js');
+      const indexPath = this.indexPathOverride ?? resolveIndexPath();
+      if (!existsSync(indexPath)) return null;
+      const index = new LocalIndex({ indexPath });
+      try {
+        return { libraries: await index.listSources(), defs: await index.listAssetDefs() };
+      } finally {
+        index.close();
+      }
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Library-origin lock entries for the assets {@link resolveLibraryEntries}
+   * matched. The locked version comes from the library index when it knows the
+   * asset (its manifest-declared version is authoritative), else from the
+   * on-disk asset. The hash is computed from the files on disk, so it matches
+   * what `install --locked` re-hashes.
+   */
+  async libraryLockEntries(lib) {
+    if (lib.entries.length === 0) return {};
+    const snap = await this.loadLibraryIndex();
+    const diskHashes = /* @__PURE__ */ new Map();
+    return buildLibraryLockEntries(
+      lib.entries.map((e) => {
+        const name = lib.libraryOf.get(e) ?? "";
+        const publisher = e.publisher ?? "";
+        const def = newestLibraryDef(snap, name, { kind: e.kind, publisher, name: e.name });
+        const libPath = this.libraryPath(name, snap);
+        const sha256 = (libPath ? libraryDiskHashes(libPath, diskHashes).get(`${e.kind}:${e.name}`) : void 0) ?? def?.sha256;
+        return {
+          kind: e.kind,
+          publisher,
+          name: e.name,
+          library: { name, version: def?.version || e.version || "0.0.0", sha256 }
+        };
+      })
+    );
+  }
+  /**
+   * Re-resolve every library-origin lock entry from its named library, for
+   * `install --locked`. An entry is restored only when its library is still
+   * registered/on disk, still holds the asset, and still offers the locked
+   * version; anything else is reported in `missing` with the reason.
+   */
+  async restoreLibraryLockEntries(lock) {
+    const entries = [];
+    const missing = [];
+    const locked = Object.entries(lock.assets).filter(([, e]) => e.library !== void 0);
+    if (locked.length === 0) return { entries, missing };
+    const snap = await this.loadLibraryIndex();
+    const diskHashes = /* @__PURE__ */ new Map();
+    for (const [ref, e] of locked) {
+      const origin = e.library;
+      const { publisher, kind, name } = parseCanonicalLockKey(ref);
+      if (!publisher || !kind || !name) {
+        missing.push(`${ref} (unparseable lock key)`);
+        continue;
+      }
+      const libPath = this.libraryPath(origin.name, snap);
+      if (!libPath) {
+        missing.push(`${ref} (library "${origin.name}" not found)`);
+        continue;
+      }
+      const found = (await scanDirectory(libPath, publisher)).find(
+        (x) => x.kind === kind && x.name === name
+      );
+      if (!found) {
+        missing.push(`${ref} (not found in library "${origin.name}")`);
+        continue;
+      }
+      const def = newestLibraryDef(snap, origin.name, { kind, publisher, name });
+      const current = def?.version || found.version || "0.0.0";
+      if (current !== origin.version) {
+        missing.push(
+          `${ref} (library "${origin.name}" is at ${current}, locked ${origin.version})`
+        );
+        continue;
+      }
+      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)`);
+          continue;
+        }
+      }
+      entries.push(found);
+    }
+    return { entries, missing };
+  }
+  /**
+   * On-disk root of the library named `name`: the registered path from the index
+   * when it exists, else `<libraries dir>/<name>`; `null` when neither is a directory.
+   */
+  libraryPath(name, snap) {
+    const registered = snap?.libraries.find((l) => l.name === name)?.path;
+    if (registered && existsSync(registered)) return registered;
+    try {
+      const guess = join(resolveLibraryDir(), name);
+      return existsSync(guess) ? guess : null;
+    } catch {
+      return null;
+    }
   }
   // ── Store fetch-then-deploy ────────────────────────────────────────────
   /** A candidate's stable identity key (`<publisher>/<kind>:<name>@<version>`). */
@@ -855,7 +1010,8 @@ var AssetManager = class {
       stores
     });
     const lib = await this.resolveLibraryEntries(missing);
-    const removed = this.reconcileRemovedAssets(resolved);
+    const libraryLock = await this.libraryLockEntries(lib);
+    const removed = this.reconcileRemovedAssets(resolved, new Set(Object.keys(libraryLock)));
     const entries = [...await this.buildCatalogEntries(resolved, repositories), ...lib.entries];
     const deployed = [
       ...new Set(
@@ -865,9 +1021,9 @@ var AssetManager = class {
       )
     ];
     await this.renderDriverMcpConfig();
-    const lockWritten = resolved.length > 0 || existsSync(this.lockPath);
+    const lockWritten = resolved.length > 0 || lib.entries.length > 0 || existsSync(this.lockPath);
     if (lockWritten) {
-      writeLock(this.lockPath, buildLockFile(resolved, overridesApplied));
+      writeLock(this.lockPath, buildLockFile(resolved, overridesApplied, libraryLock));
     }
     this.recordInstallHistory(deployed, removed);
     const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
@@ -918,13 +1074,16 @@ var AssetManager = class {
   }
   /**
    * Remove stale assets — those recorded in the old lock but absent from the
-   * newly resolved set. Returns the list of removed refs.
+   * newly resolved set (`resolved` source candidates plus `keep`, the canonical
+   * refs of library-origin assets locked in this run). Returns the list of
+   * removed refs.
    */
-  reconcileRemovedAssets(resolved) {
+  reconcileRemovedAssets(resolved, keep = /* @__PURE__ */ new Set()) {
     const oldLock = this.tryReadLock();
-    const resolvedRefs = new Set(
-      resolved.map((c) => `${c.kind}:@${c.publisher}/${c.name}#${c.version}`)
-    );
+    const resolvedRefs = /* @__PURE__ */ new Set([
+      ...resolved.map((c) => `${c.kind}:@${c.publisher}/${c.name}#${c.version}`),
+      ...keep
+    ]);
     const removed = [];
     if (oldLock) {
       for (const ref of Object.keys(oldLock.assets)) {
@@ -1067,6 +1226,7 @@ var AssetManager = class {
     }
     const resolved = [];
     for (const [ref, entry] of Object.entries(lock.assets)) {
+      if (!entry.source) continue;
       const { publisher, kind, name } = parseCanonicalLockKey(ref);
       if (!publisher || !kind || !name) continue;
       const slug = sourceCacheKey(entry.source.url);
@@ -1085,15 +1245,21 @@ var AssetManager = class {
       });
       if (!repositories[slug]) repositories[slug] = { url: entry.source.url, path: cloneDir };
     }
+    const library = await this.restoreLibraryLockEntries(lock);
     const deployed = [
       ...new Set(
         this.targetHarnesses().flatMap(
-          (t) => deployAll(resolved, repositories, patches, this.deployOptsFor(t))
+          (t) => deployAll(
+            [...resolved, ...library.entries],
+            repositories,
+            patches,
+            this.deployOptsFor(t)
+          )
         )
       )
     ];
     await this.renderDriverMcpConfig();
-    return { deployed, removed: [], missing: [], lockWritten: false };
+    return { deployed, removed: [], missing: library.missing, lockWritten: false };
   }
   /**
    * Add a single asset (and its transitive dependencies) to the workspace.
@@ -1137,15 +1303,26 @@ var AssetManager = class {
     ];
     this.addDependencyToConfig(ref);
     await this.renderDriverMcpConfig();
-    if (resolved.length > 0) {
-      const fresh = buildLockFile(resolved, overridesApplied);
+    if (resolved.length > 0 || lib.entries.length > 0) {
+      const fresh = buildLockFile(resolved, overridesApplied, await this.libraryLockEntries(lib));
       const prev = this.tryReadLock();
       if (prev) {
         const sources2 = new Map(prev.sources.map((s) => [s.url, s]));
         for (const s of fresh.sources) sources2.set(s.url, s);
+        const assets = { ...prev.assets };
+        for (const key of Object.keys(fresh.assets)) {
+          if (!fresh.assets[key]?.library) continue;
+          const freshId = parseCanonicalLockKey(key);
+          for (const old of Object.keys(assets)) {
+            const id = parseCanonicalLockKey(old);
+            if (id.kind === freshId.kind && id.publisher === freshId.publisher && id.name === freshId.name) {
+              delete assets[old];
+            }
+          }
+        }
         writeLock(this.lockPath, {
           ...fresh,
-          assets: { ...prev.assets, ...fresh.assets },
+          assets: { ...assets, ...fresh.assets },
           sources: [...sources2.values()].sort((a, b) => a.url.localeCompare(b.url)),
           // buildLockFile never emits a plugins slice — preserve the reconciler's.
           plugins: prev.plugins
@@ -1509,7 +1686,8 @@ var AssetManager = class {
       );
       if (match) return match;
     }
-    return null;
+    const lib = await this.resolveLibraryEntries([ref]);
+    return lib.entries[0] ?? null;
   }
   /**
    * List all assets currently deployed in the workspace (or global cache).
@@ -1705,8 +1883,8 @@ var AssetManager = class {
       const lockEntry = lockByKindName.get(`${d.kind}:${d.name}`);
       const publisher = lockEntry?.publisher ?? "";
       const version = lockEntry?.version ?? "";
-      const slug = lockEntry ? sourceCacheKey(lockEntry.url) : "";
-      const syncStatus = slug ? computeSyncStatus(repoStatuses.get(slug)) : "unknown";
+      const slug = lockEntry && !lockEntry.library ? sourceCacheKey(lockEntry.url) : "";
+      const syncStatus = lockEntry?.library ? "local" : slug ? computeSyncStatus(repoStatuses.get(slug)) : "unknown";
       const domain = publisher || "unknown";
       entries.push({ kind: d.kind, name: d.name, domain, publisher, version, syncStatus });
     }
@@ -1762,14 +1940,18 @@ var AssetManager = class {
     return [key, "direct (skaile.yaml)"];
   }
   /**
-   * List installed assets whose source repository is behind the remote.
+   * List installed assets that have a newer upstream available.
    *
-   * Only remote repositories (not local paths) are checked for staleness.
+   * Two kinds of staleness are reported:
+   * - **Source assets** — only remote repositories (not local paths) are checked;
+   *   `behind` is the number of commits the local clone is missing.
+   * - **Library assets** — a library-origin lock entry whose library index now
+   *   offers a newer version than the locked one; `behind` is 0, `latestVersion`
+   *   and `library` are set. A library not indexed (or removed) is not reported.
    *
-   * @returns Array of {@link OutdatedEntry} objects, one per asset in a repository
-   *   that has commits not yet pulled locally.
+   * @returns Array of {@link OutdatedEntry} objects.
    */
-  outdated() {
+  async outdated() {
     const { repositories } = this.loadConfig();
     const lock = this.tryReadLock();
     if (!lock) return [];
@@ -1781,7 +1963,7 @@ var AssetManager = class {
       const status = checkRepoStatus(decl, slug, this.reposDir);
       if (status.behind <= 0) continue;
       for (const [ref, entry] of Object.entries(lock.assets)) {
-        if (entry.source.url !== src.url) continue;
+        if (entry.source?.url !== src.url) continue;
         const { publisher, kind, name, version } = parseCanonicalLockKey(ref);
         if (!kind || !name) continue;
         result.push({
@@ -1793,6 +1975,26 @@ var AssetManager = class {
         });
       }
     }
+    const libraryAssets = Object.entries(lock.assets).filter(([, e]) => e.library);
+    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;
+        const def = newestLibraryDef(snap, origin.name, { kind, publisher, name });
+        if (!def || !gt(coerceVersion(def.version), coerceVersion(origin.version))) continue;
+        result.push({
+          kind,
+          name,
+          publisher,
+          currentVersion: origin.version,
+          behind: 0,
+          latestVersion: def.version,
+          library: origin.name
+        });
+      }
+    }
     return result;
   }
   /**
@@ -1802,20 +2004,23 @@ var AssetManager = class {
    * was applied correctly.
    *
    * @param ref - Asset ref in `kind:name` form.
-   * @returns Unified diff string, or `null` when there are no differences or the
-   *   asset is not deployed/resolvable.
+   * @returns A {@link DiffResult}: `not-found` (unknown ref), `not-deployed`,
+   *   `identical`, or `differs` with the unified diff.
+   * @throws When `diff(1)` itself fails (exit status other than 0/1).
    */
   async diff(ref) {
     const parsed = parseAssetRef(ref);
     const entry = await this.info(ref);
-    if (!entry) return null;
+    if (!entry || !existsSync(entry.source)) return { status: "not-found" };
     const deployedPath = join(
       deployedBase(parsed.kind, this.driverTarget, this.global, this.projectDir),
       parsed.name
     );
-    if (!existsSync(deployedPath) || !existsSync(entry.source)) return null;
+    if (!existsSync(deployedPath)) return { status: "not-deployed" };
     const r = spawnSync("diff", ["-ruN", entry.source, deployedPath], { encoding: "utf8" });
-    return r.status === 1 ? r.stdout : null;
+    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"}`);
   }
   // ── Lock ───────────────────────────────────────────────────────────────
   /**
@@ -1832,12 +2037,13 @@ var AssetManager = class {
     const provenanceIndex = await buildProvenanceIndex(this.buildClones(repositories), {
       projectDir: this.projectDir
     });
-    const { resolved, overridesApplied } = await this.resolveWithStores(dependencies, {
+    const { resolved, missing, overridesApplied } = await this.resolveWithStores(dependencies, {
       provenanceIndex,
       overrides,
       stores
     });
-    const lockData = buildLockFile(resolved, overridesApplied);
+    const libraryLock = await this.libraryLockEntries(await this.resolveLibraryEntries(missing));
+    const lockData = buildLockFile(resolved, overridesApplied, libraryLock);
     writeLock(this.lockPath, lockData);
     return lockData;
   }
@@ -1973,11 +2179,12 @@ var AssetManager = class {
    * @param name - Asset name (also used as the directory name).
    * @param kind - Asset kind: `skill` | `agent` | `bundle` | `flow` | `prompt` | `contract`.
    * @param destDir - Parent directory to create the asset in.
+   * @param opts - Optional scaffold content (`description`).
    * @returns `{ ok: true, path }` on success, `{ ok: false, path: errorMessage }` if the
    *   directory already exists.
    */
-  create(name, kind, destDir) {
-    return createScaffold(name, kind, destDir);
+  create(name, kind, destDir, opts) {
+    return createScaffold(name, kind, destDir, opts);
   }
   // ── Contrib (REMOVED 2026-05-12) ───────────────────────────────────────
   //
@@ -2153,5 +2360,5 @@ var AssetManager = class {
 };
 
 export { AssetManager, FACTORY_SOURCE_URL, MissingManifestError, NON_DEPLOYABLE_KINDS, normalizeRepoUrl, parseCanonicalLockKey, parseRefTolerant, renderMcpServerConfig, softDepName };
-//# sourceMappingURL=chunk-PKGI5QG7.js.map
-//# sourceMappingURL=chunk-PKGI5QG7.js.map
+//# sourceMappingURL=chunk-QWWDDU5Z.js.map
+//# sourceMappingURL=chunk-QWWDDU5Z.js.map