@skaile/workspaces 6.15.0 → 6.16.1

package/dist/asset-manager/src/resolve/scan.d.ts

@@ -0,0 +1,222 @@
+import { type CatalogEntry, type LockEntry, type OverrideEntry, type ProvenanceCandidate, type SkWorkspaceConfig, type SourceClone, type SourceDeclaration, type SourceEntry, type StoreEntry } from "@skaile/workspaces/core";
+import { type AssetDefinition, type Library } from "@skaile/workspaces/library";
+import { AmConfigEdit } from "../config/edit.js";
+import { type DeployableEntry } from "../installer.js";
+import type { LibraryIndexSnapshot, LibraryResolution, PreferLocked } from "../shared/types.js";
+/** One row of {@link AssetManager.libraryHolders}: a library holding a ref at one version. */
+export interface LibraryHolder {
+    library: string;
+    version: string;
+    description: string;
+    /** `true` for the holder `add <ref>` deploys. */
+    picked: boolean;
+}
+/**
+ * One origin that holds a ref, see {@link AssetManager.refOrigins}: the bundled factory
+ * source, a project source clone, or a registered library.
+ */
+export interface RefOrigin {
+    kind: "factory" | "source" | "library";
+    /** `factory`, the source's short name, or the library name. */
+    label: string;
+    version: string;
+    description: string;
+}
+/**
+ * A library asset that `add`, `install` and the status commands cannot use as it is (a version
+ * that is not semver, a flow file the engine does not load). The CLI prints its message as one
+ * `✗` line, never a stack trace (p874, p1082).
+ */
+export declare class LibraryEntryError extends Error {
+}
+/** LoadConfig, library scan, origins, library index scope. One layer of the `AssetManager` class chain (see `asset-manager/CLAUDE.md`). */
+export declare abstract class AmResolveScan extends AmConfigEdit {
+    protected abstract warnLibraryCollision(key: string, candidates: Array<{
+        entry: CatalogEntry;
+        library: string;
+    }>, chosen: {
+        entry: CatalogEntry;
+        library: string;
+    }, differing?: string[]): void;
+    protected abstract ensureSourceClonesQuiet(repositories: Record<string, SourceDeclaration>, sources: SourceEntry[]): void;
+    protected loadConfig(): {
+        repositories: Record<string, SourceDeclaration>;
+        sources: SourceEntry[];
+        stores: StoreEntry[];
+        dependencies: string[];
+        overrides: OverrideEntry[];
+        patches: Record<string, string>;
+        config: SkWorkspaceConfig;
+    };
+    /** Build provenance-index clones from the resolved source declarations; a clone folder with no git checkout goes to `onSourceError`. */
+    protected buildClones(repositories: Record<string, SourceDeclaration>, onSourceError?: (clone: SourceClone, err: unknown) => void): SourceClone[];
+    /**
+     * Bridge a resolved {@link ProvenanceCandidate} to a {@link CatalogEntry} for
+     * the deploy pipeline. `source` is the absolute path to the asset's primary
+     * manifest (or its directory) inside the clone; `publisher` is set to the
+     * clone slug so `deployAll`'s repositories lookup resolves local-vs-remote.
+     */
+    protected candidateToCatalogEntry(c: ProvenanceCandidate, repositories: Record<string, SourceDeclaration>): DeployableEntry | null;
+    /**
+     * The {@link ProvenanceCandidate} a source- or store-origin lock entry stands for: what a
+     * deploy needs to restore the asset from the commit the lock names (`files[]` is the asset's
+     * whole file set). `null` for a library-origin entry or a key that is not a canonical ref.
+     * The source URL is the declared source's own spelling (the bundled factory tree and a
+     * `sources:` entry match their declaration by it).
+     */
+    protected lockedCandidate(key: string, entry: LockEntry, repositories: Record<string, SourceDeclaration>): ProvenanceCandidate | null;
+    /**
+     * Resolve refs the source/store pass could not against the user's registered
+     * **libraries** (local authoring places). Each library dir is scanned on disk
+     * under its declared publisher (its root `skaile.manifest.yaml`, falling back
+     * to the kebab-cased library name); a matching asset becomes a deployable
+     * {@link CatalogEntry} whose `source` points at the on-disk manifest. This is
+     * the consume side of `library create` — a freshly authored asset is
+     * deployable with `skaile add <kind>:@<publisher>/<name>` without publishing.
+     *
+     * 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}).
+     *
+     * @param opts.quiet - Skip the cross-library collision warning (a lookup that only
+     *   builds an error hint must not warn).
+     * @param opts.library - Resolve only from this library (the one a lock entry names), not
+     *   from every registered one. Never warns: no choice is made between libraries.
+     * @param opts.lockedLibraries - `kind:publisher/name` → the library its lock entry names
+     *   ({@link AssetManager.lockedLibraryNames}). A ref listed here resolves from that library
+     *   when it holds a match, whatever the default library is.
+     * @returns the matched deploy entries, the set of `missing` refs covered, and
+     *   each entry's originating library name.
+     */
+    protected resolveLibraryEntries(missing: string[], opts?: {
+        quiet?: boolean;
+        library?: string;
+        lockedLibraries?: ReadonlyMap<string, string | null>;
+        /** `update`: a tie between equal versions goes to the default library, then to the locked library or the one holding the locked bytes. */
+        preferLocked?: PreferLocked;
+    }): Promise<LibraryResolution>;
+    /**
+     * Scan every candidate library (the set {@link resolveLibraryEntries} resolves from)
+     * into `kind:@publisher/name` → every holder, across all libraries and versions.
+     *
+     * @param minRoots - Return `null` without scanning when fewer candidate libraries
+     *   exist (a cross-library question needs at least two).
+     * @returns `null` when there is no candidate library or none holds an asset.
+     */
+    protected scanLibraries(minRoots?: number): Promise<{
+        byKey: Map<string, Array<{
+            entry: DeployableEntry;
+            library: string;
+        }>>;
+        isDefaultLib: Map<string, boolean>;
+        libraryDir: Map<string, string>;
+    } | null>;
+    /**
+     * Every ref that more than one registered library holds, with one row per holder
+     * (all libraries, all versions) in the order `add` prefers them: the first row is
+     * the one `add <ref>` deploys. `search` reads this to group the index rows of a ref
+     * (one per library) and mark the copy `add` deploys; the versions come from the files
+     * themselves, which the index follows only after the next `skaile library index`.
+     *
+     * @returns `kind:@publisher/name` → holders; refs held by one library are absent.
+     */
+    libraryHolders(): Promise<Map<string, LibraryHolder[]>>;
+    /**
+     * Every asset a registered library holds, read from the library directories themselves
+     * (not the local index, which lags behind them until the next `skaile library index`).
+     * One row per holder, all versions.
+     *
+     * @returns `[]` when no library holds an asset. Never warns.
+     */
+    libraryAssets(): Promise<Array<{
+        entry: CatalogEntry;
+        library: string;
+    }>>;
+    /**
+     * The version `add` deploys for each asset of a source clone registered as a `reader`
+     * library, when its file declares none: the repo commit pseudo-version (p855). `search`
+     * reads this where no project is in scope, so it lists what `add` locks, not the index
+     * default.
+     *
+     * @returns `<library>\0<kind>:@<publisher>/<name>` -> version; only assets that declare none.
+     */
+    sourceAssetVersions(): Promise<Map<string, string>>;
+    /**
+     * Every origin that holds `ref` (`kind:@publisher/name`) with the version it holds, in
+     * the order `add <ref>` prefers them, so the first row is the one `add` deploys: the
+     * project's source clones and the bundled factory source (highest version first), then
+     * the registered libraries. `add`, `info` and `search` all read this, so the three name
+     * one origin for one ref. Stores are not asked (no network).
+     *
+     * @returns one row per origin and version; `[]` for a ref without a publisher or one
+     *   nothing holds. Never warns.
+     */
+    refOrigins(ref: string): Promise<RefOrigin[]>;
+    /**
+     * Every ref (`kind:@publisher/name`) that several origins hold at different versions,
+     * with its origins in {@link refOrigins} order. A ref the origins hold at one version
+     * has nothing to choose between and is left out.
+     */
+    competingOrigins(): Promise<Map<string, RefOrigin[]>>;
+    /**
+     * The origins of {@link refOrigins} for every ref, keyed by `kind:@publisher/name`: the
+     * version in each row is the one `add` locks (a source asset whose file declares none is
+     * `0.0.0-sha.<commit>`), which `search` lists too (p855).
+     */
+    allOrigins(): Promise<Map<string, RefOrigin[]>>;
+    /**
+     * The origins of {@link refOrigins} for every ref, or for the one `only` names
+     * (`kind:@publisher/name`), keyed by `kind:@publisher/name`.
+     */
+    protected collectOrigins(only?: string): Promise<Map<string, RefOrigin[]>>;
+    /**
+     * Open the local index and snapshot its libraries + asset definitions, scoped to this
+     * project's `sources:` ({@link scopeLibraryIndex}).
+     * 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.
+     */
+    protected loadLibraryIndex(): Promise<LibraryIndexSnapshot | null>;
+    /**
+     * The `sources:` this project declares by repository identity ({@link repoIdentity}), or `undefined` outside a project (no
+     * `skaile.yaml` in `projectDir` or a parent) or when the file does not parse. Outside a
+     * project nothing declares sources, so the machine-wide search reads every clone.
+     */
+    protected declaredSourceEntries(): Map<string, SourceEntry> | undefined;
+    /**
+     * The repository identity ({@link repoIdentity} key) a source-clone reader row stands for, or
+     * `undefined` for any other library. A row is a source clone when its registry scope is
+     * `project`, or (a row an older CLI wrote has no scope) when its folder lies in a clone cache.
+     */
+    protected sourceCloneKey(l: Library): string | undefined;
+    /**
+     * Ids of the registered libraries that are the clone of a source this project does not
+     * declare. `source add` registers the clone as a machine-wide reader library so `search`
+     * and the indexer can read it, but a `sources:` clone belongs to the projects that declare
+     * it (OQ4, p321): another project neither resolves it, nor ties with it by name, nor has
+     * `update` re-pin its locked assets to it. A reader library the user registered by hand
+     * (`library init --reader --git`) lives outside the sources cache and is never hidden.
+     */
+    undeclaredSourceClones(libraries: readonly Library[]): Set<string>;
+    /**
+     * The registered libraries as `library list` shows them in this project. A source clone is
+     * cache: its row is read from the clone, so it is dropped when the clone is gone and
+     * when this project does not declare the source. `sources` holds the ids of the clone rows
+     * that stay, so the list can mark them `(source)`.
+     */
+    scopeLibraryList(libraries: readonly Library[]): {
+        libraries: Library[];
+        sources: Set<string>;
+    };
+    /**
+     * The index as this project sees it: the source clones of other projects are dropped
+     * ({@link undeclaredSourceClones}) and the assets of a declared source carry the publisher
+     * this project's `sources:` entry names. The clone and its index rows are shared by every
+     * project that declares the source, so a project that declares another `--publisher` is
+     * re-labelled here, at read time, and never changes what the others see (p1822).
+     */
+    scopeLibraryIndex(libraries: Library[], defs: AssetDefinition[]): {
+        libraries: Library[];
+        defs: AssetDefinition[];
+    };
+}
+//# sourceMappingURL=scan.d.ts.map

package/dist/asset-manager/src/resolve/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/resolve/scan.ts"],"names":[],"mappings":"AAEA,OAAO,EAwBL,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,OAAO,EACb,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAU1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAyBhG,8FAA8F;AAC9F,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;IACvC,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;CAG3C;AAmDD,2IAA2I;AAC3I,8BAAsB,aAAc,SAAQ,YAAY;IAEtD,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CACrC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EAC3D,MAAM,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAChD,SAAS,CAAC,EAAE,MAAM,EAAE,GACnB,IAAI;IACP,SAAS,CAAC,QAAQ,CAAC,uBAAuB,CACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC/C,OAAO,EAAE,WAAW,EAAE,GACrB,IAAI;IAEP,SAAS,CAAC,UAAU,IAAI;QACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;QAChD,OAAO,EAAE,WAAW,EAAE,CAAC;QACvB,MAAM,EAAE,UAAU,EAAE,CAAC;QACrB,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,SAAS,EAAE,aAAa,EAAE,CAAC;QAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,MAAM,EAAE,iBAAiB,CAAC;KAC3B;IA+CD,wIAAwI;IACxI,SAAS,CAAC,WAAW,CACnB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC/C,aAAa,GAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,KAAK,IAA6B,GACjF,WAAW,EAAE;IAkChB;;;;;OAKG;IACH,SAAS,CAAC,uBAAuB,CAC/B,CAAC,EAAE,mBAAmB,EACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC9C,eAAe,GAAG,IAAI;IAmEzB;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC9C,mBAAmB,GAAG,IAAI;IAwB7B;;;;;;;;;;;;;;;;;;;;;;OAsBG;cACa,qBAAqB,CACnC,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,GAAE;QACJ,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;QACrD,0IAA0I;QAC1I,YAAY,CAAC,EAAE,YAAY,CAAC;KACxB,GACL,OAAO,CAAC,iBAAiB,CAAC;IAkJ7B;;;;;;;OAOG;cACa,aAAa,CAAC,QAAQ,SAAI,GAAG,OAAO,CAAC;QACnD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,eAAe,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC,CAAC;QACvE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,GAAG,IAAI,CAAC;IAoET;;;;;;;;OAQG;IACG,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IAoB7D;;;;;;OAMG;IACG,aAAa,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAM/E;;;;;;;OAOG;IACG,mBAAmB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAqBzD;;;;;;;;;OASG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAOnD;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAQ3D;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAIrD;;;OAGG;cACa,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IA6DhF;;;;;OAKG;cACa,gBAAgB,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAgBxE;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,SAAS;IASvE;;;;OAIG;IACH,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IAcxD;;;;;;;OAOG;IACH,sBAAsB,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC;IAWlE;;;;;OAKG;IACH,gBAAgB,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,GAAG;QAC/C,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;KACtB;IAeD;;;;;;OAMG;IACH,iBAAiB,CACf,SAAS,EAAE,OAAO,EAAE,EACpB,IAAI,EAAE,eAAe,EAAE,GACtB;QAAE,SAAS,EAAE,OAAO,EAAE,CAAC;QAAC,IAAI,EAAE,eAAe,EAAE,CAAA;KAAE;CAqCrD"}

package/dist/asset-manager/src/resolve/stores.d.ts

@@ -0,0 +1,176 @@
+import { type buildProvenanceIndex, type OverrideEntry, type ProvenanceCandidate, type ProvenanceIndex, type ResolveResult, type SourceDeclaration, type StoreEntry, type StoreFetcher } from "@skaile/workspaces/core";
+import type { AssetFetcher } from "@skaile/workspaces/library";
+import { type DeployableEntry } from "../installer.js";
+import type { KeptLibraryEntry, LibraryFirstResolution, PreferLocked } from "../shared/types.js";
+import { AmResolveGuards } from "./guards.js";
+/** ResolveWithStores, resolveLibraryFirst, stageStoreAssets. One layer of the `AssetManager` class chain (see `asset-manager/CLAUDE.md`). */
+export declare abstract class AmResolveStores extends AmResolveGuards {
+    protected abstract lockedCopyDeployed(kind: string, name: string): boolean;
+    protected abstract buildStoreFetcher(stores: StoreEntry[]): StoreFetcher | undefined;
+    /**
+     * The lock entries that came from a source or the store (a `source:`, no `library:`), by
+     * identity `<publisher>/<kind>:<name>` -> locked version. The lock's origin
+     * wins: a library registered later that holds the same ref does not take such an asset
+     * (`update`, `install`, `add`; OQ15, p1490).
+     */
+    protected lockedOriginVersions(): Map<string, string>;
+    /**
+     * The locked assets whose entry says `origin: store`, by identity -> the store URL. A store
+     * origin is a pin: no source that holds the same ref takes the asset until `skaile remove`
+     * and `skaile add` move it (`update`, `install`, `add`). A declared ref whose `#pin` the
+     * locked version does not satisfy is the user asking for another version: it is not pinned.
+     *
+     * @param declared - The `dependencies:` refs of `skaile.yaml`.
+     * @param asked - Refs being resolved now.
+     */
+    protected storePinnedIdentities(declared: readonly string[], asked: readonly string[]): Map<string, string | undefined>;
+    /**
+     * Say which registered library holds a ref the lock keeps on its source or the store: the
+     * candidate that lost, with the way to switch (p1490). Printed once per `add`.
+     */
+    protected noteLosingLibraries(refs: readonly string[]): Promise<void>;
+    /** A candidate's stable identity key (`<publisher>/<kind>:<name>@<version>`). */
+    protected candidateKey(c: ProvenanceCandidate): string;
+    /**
+     * Resolve `deps`, falling back to the global `catalog.url` store when the
+     * project declares no store and the first pass leaves something missing.
+     *
+     * The first pass uses the project stores only, so locally-resolvable refs
+     * never trigger a network probe. The fallback retry is best-effort: any error
+     * (offline, store down) keeps the first pass's result rather than regressing.
+     */
+    protected resolveWithStores(deps: string[], opts: {
+        provenanceIndex: Awaited<ReturnType<typeof buildProvenanceIndex>>;
+        overrides: OverrideEntry[];
+        stores: StoreEntry[];
+        declaredRefs?: readonly string[];
+    }): Promise<ResolveResult>;
+    /**
+     * Resolve `deps` library-first, then walk the dependencies of every library
+     * asset it picks.
+     *
+     * A publisher-qualified ref that no project source declares is looked up in the
+     * registered **libraries** before any store is asked, so a locally authored
+     * asset resolves (and deploys) with the store unreachable and without a
+     * version-discovery round trip. Only refs the libraries did not satisfy go to
+     * {@link resolveWithStores}; its misses get one more library try (a ref a source
+     * knows only under another version). A `#version` pin still selects through
+     * `matchPin` inside {@link resolveLibraryEntries}.
+     *
+     * Library assets declare `dependencies` / `requires`. Those are fed back through
+     * the same resolution with a `seen` identity set (mirrors `resolveAll`), so deps
+     * deploy, get lock entries, and a dependency cycle terminates.
+     *
+     * @returns source/store candidates, still-unresolved refs, applied overrides,
+     *   expanded presets, and the library leg (entries + originating library per entry).
+     */
+    protected resolveLibraryFirst(deps: string[], opts: {
+        provenanceIndex: ProvenanceIndex;
+        overrides: OverrideEntry[];
+        stores: StoreEntry[];
+        /** Refs `skaile.yaml` declares; a dependency of a resolved asset with the same identity resolves at the declared ref/pin. */
+        declaredRefs?: readonly string[];
+        /** Print the "exists in N libraries" warning for a ref several libraries hold (`add` only; every other command is silent about a choice the lock or a pin already made). */
+        warnCollisions?: boolean;
+        /** Keep a locked asset on the library its lock entry names ({@link AssetManager.lockedLibraryNames}); `install` passes it, `update` and `add` do not. */
+        lockedLibraries?: ReadonlyMap<string, string | null>;
+        /** `update` and `update <name>`: a locked asset may move to another library (the highest version wins) but an equal-version tie goes to the default library, then to the library its lock entry names (renames followed), then to one holding the locked bytes. */
+        preferLocked?: PreferLocked;
+        /** Source/store-origin lock entries by identity (`<publisher>/<kind>:<name>`) -> locked version: such an asset stays on its origin, a library holding the same ref does not take it (OQ15, p1490). */
+        lockedOrigin?: ReadonlyMap<string, string>;
+        /** `install`: lock entries of library assets by identity (`<publisher>/<kind>:<name>`). A library holding another version of one keeps the locked version. */
+        keepLocked?: ReadonlyMap<string, KeptLibraryEntry>;
+        /** `add` and `install`: read the `requires` of each store candidate's own manifest (the staged bytes) too, so a requirement the catalog row does not list (a cross-kind one) is resolved, deployed and locked (p1221). */
+        readStoreRequires?: boolean;
+        /** `update`: name the source that holds a ref the lock keeps on its store (`add` always does). */
+        noteStorePinned?: boolean;
+    }): Promise<LibraryFirstResolution>;
+    /**
+     * A source asset without a declared version is keyed `0.0.0-sha.<repo commit>`, so every
+     * commit of its repo would re-key (and re-lock, and report as updated) every asset of
+     * that repo, changed or not. Keep the locked key and version of an asset whose files hash
+     * to what the lock holds: `update` then re-locks only what changed, as `outdated` lists.
+     * The commit stays the clone's, so the lock's `sources:` row still names the bytes' commit.
+     * A ref the user pinned (`#<version>`) keeps the version it names.
+     */
+    protected keepUnchangedSourceVersions(resolved: ProvenanceCandidate[], requested: readonly string[]): void;
+    /**
+     * The catalog fetcher to use: an injected one, else built from `stores`. `catalogUrl: ""`
+     * (`update --no-catalog`) asks no store at all, project `stores:` included.
+     */
+    protected storeFetcherFor(stores: StoreEntry[]): StoreFetcher | undefined;
+    /**
+     * The global `catalog.url` as a single-store fallback, or `[]` when no
+     * project store should be synthesized — `local` sentinel, already-declared,
+     * or no URL. Honours an explicit `catalogUrl` injection (`""` and `"local"` disable it).
+     */
+    protected globalStoreFallback(projectStores: StoreEntry[], honourOverride?: boolean): Promise<StoreEntry[]>;
+    /**
+     * Build deployable catalog entries from resolved candidates. Store-resolved
+     * candidates (no local clone bytes) are fetched + SHA-verified into the
+     * project store-cache first, then their entry points at the staged bytes so
+     * the existing copy-deploy path works. Source-backed candidates keep the
+     * clone-relative entry.
+     */
+    protected buildCatalogEntries(resolved: ProvenanceCandidate[], repositories: Record<string, SourceDeclaration>): Promise<DeployableEntry[]>;
+    /**
+     * The tail of a `hash mismatch for <file>: expected <lock>, got <fetched>` failure of a locked
+     * restore when the deployed copy already holds the fetched bytes: the lock records another
+     * hash for the file, and `install` (not `install --locked`) writes the right one. Empty for
+     * any other failure, and when the copy is missing or differs from the fetched bytes.
+     */
+    protected wrongLockHashHint(candidates: readonly ProvenanceCandidate[], reason: string): string;
+    /**
+     * Fetch + SHA-verify the bytes of every store-resolved candidate that needs
+     * bytes on disk into `.skaile/cache/store/`, reusing the same verified-fetch
+     * path the pointer-only `library.install` uses (`installFromManifest` flat
+     * mode). Every kind with bytes, composition-only kinds included.
+     *
+     * @returns Map of candidate key → staged primary-manifest path.
+     */
+    protected stageStoreAssets(resolved: ProvenanceCandidate[], repositories: Record<string, SourceDeclaration>): Promise<Map<string, string>>;
+    /**
+     * The requirements a store candidate's own manifest declares (`metadata.requires`, a manifest
+     * `dependencies:`) that its catalog row did not list, read from the staged bytes. The catalog
+     * row is the store's own summary and may hold only same-kind ones; the deployed copy is what
+     * `check` reads, so a requirement only the manifest names would be missing right after `add`
+     * (p1221). Each one is added to the candidate's `deps` and `storeRequires` (the lock records
+     * them) and returned so the caller resolves, deploys and locks it like any other dependency.
+     * A candidate whose bytes come from a source clone, or that has none, adds nothing.
+     */
+    protected readStoreCandidateRequires(c: ProvenanceCandidate, repositories: Record<string, SourceDeclaration>): Promise<string[]>;
+    /** Repo-relative path of a candidate's primary manifest (un-stripped). */
+    protected primaryManifestRel(c: ProvenanceCandidate): string | undefined;
+    /**
+     * The primary-manifest path relative to a staged asset dir. Takes the kind's
+     * manifest (e.g. `SKILL.md`), then strips the same common-dir prefix
+     * `installFromManifest` flat mode removed on write.
+     */
+    protected stagedManifestRel(c: ProvenanceCandidate): string;
+    /**
+     * `true` when a candidate's primary manifest is present on a local source
+     * clone — its `sourceUrl` matches a registered source AND the manifest file
+     * exists on disk at the expected path. A URL match alone is not enough: a
+     * store can pin a different commit (or a subtree not bundled) of a repo that
+     * is also a registered source, in which case the bytes must be fetched from
+     * the store rather than read from the clone. (Only the primary manifest is
+     * probed — a partially-cloned source is deployed as-is, matching the existing
+     * clone-deploy path.)
+     */
+    protected candidateHasLocalBytes(c: ProvenanceCandidate, repositories: Record<string, SourceDeclaration>): boolean;
+    /**
+     * `true` when `c` names a commit and the git clone at `dir` is checked out at another one.
+     * A local path without git, the bundled factory tree (all-zero commit) and a candidate
+     * without a commit never differ.
+     */
+    protected cloneIsOnOtherCommit(dir: string, c: ProvenanceCandidate): boolean;
+    /**
+     * The fetcher that stages `c`: the injected one, else (for a source-origin asset, which has no
+     * catalog to ask) one that reads the commit's files from the source clone's git objects.
+     * `undefined` leaves the default GitHub fetch for a store asset.
+     */
+    protected stageFetcherFor(c: ProvenanceCandidate, repositories: Record<string, SourceDeclaration>): AssetFetcher | undefined;
+    /** Build a copy-deploy catalog entry pointing at staged store bytes. */
+    protected stagedCandidateToEntry(c: ProvenanceCandidate, stagedManifestPath: string): DeployableEntry;
+}
+//# sourceMappingURL=stores.d.ts.map

package/dist/asset-manager/src/resolve/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/resolve/stores.ts"],"names":[],"mappings":"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"}

package/dist/asset-manager/src/shared/files.d.ts

@@ -0,0 +1,42 @@
+import { type AiComponent } from "@skaile/workspaces/core";
+/** Primary manifest filename for each asset kind (the deploy entry point). */
+export declare const MD_BY_KIND: Record<string, string>;
+/**
+ * Pick a candidate's primary manifest file from its `files[]`. Fixed-name kinds
+ * (skill/agent/contract/…) match their `MD_BY_KIND` basename; `prompt` and
+ * `flow` use their `<name>.prompt.md` / `<name>.flow.{yaml,json}` suffixes
+ * (these have no fixed basename, so an exact-name match alone would miss them).
+ */
+export declare function matchManifestPath(kind: string, paths: readonly string[]): string | undefined;
+/**
+ * An asset's `paths` relative to its primary manifest's directory, `manifestRel`
+ * (both in one coordinate space), dropping anything outside it. This is the file
+ * set a deploy copies: exactly what the lock records for the asset, so a deployed
+ * tree never differs from its lock (a `.gitignore` or a `resources/` dir the kind's
+ * convention filter would not pick is still the asset's).
+ */
+export declare function filesUnderManifestDir(paths: readonly string[], manifestRel: string): string[];
+/**
+ * The files a source- or store-origin lock entry lists, relative to the deployed asset directory
+ * (the primary manifest's directory): the file set a restore writes and `check` compares. Files
+ * the lock lists outside the manifest's directory are not part of the deployed copy.
+ */
+export declare function lockedAssetFiles(kind: string, files: ReadonlyArray<{
+    path: string;
+    sha256: string;
+}>): Array<{
+    rel: string;
+    path: string;
+    sha256: string;
+}>;
+/** A GitHub repository URL: the origin of a store asset (no `sources:` entry declares it). */
+export declare const GITHUB_REPO_URL: RegExp;
+/** Whether something sits at `p`, a dangling symlink included (`existsSync` follows the link and says no). */
+export declare function pathEntryExists(p: string): boolean;
+/** Whether `p` is a symlink, dangling or not. */
+export declare function isSymlink(p: string): boolean;
+/** The 5.12.0 omp deploy paths of `name` (`~/.omp/<dir>/<name>`) that exist on disk. */
+export declare function legacyOmpPaths(component: AiComponent, name: string): string[];
+/** True when two files, or two directory trees, hold the same bytes. A symlink never matches. */
+export declare function sameBytes(a: string, b: string): boolean;
+//# sourceMappingURL=files.d.ts.map

package/dist/asset-manager/src/shared/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/shared/files.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE1E,8EAA8E;AAC9E,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAO7C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAY5F;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAK7F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,GACrD,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAYtD;AAED,8FAA8F;AAC9F,eAAO,MAAM,eAAe,QAAqB,CAAC;AAElD,8GAA8G;AAC9G,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAOlD;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAM5C;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAM7E;AAED,iGAAiG;AACjG,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAgBvD"}

package/dist/asset-manager/src/shared/library-hooks.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The checks one library asset must pass before `add` deploys it, as the lines `skaile validate`
+ * prints for it (`<file> [<tag>] - <text>`). The asset manager does not know the per-kind checks
+ * (they live with `validate`), so the host registers them once at startup; none registered means
+ * `add` runs no such check (library use without the CLI). An asset the check refuses is never
+ * deployed, as one the manifest does not list is not (p1550).
+ */
+export type LibraryAssetCheck = (asset: {
+    kind: string;
+    name: string;
+    source: string;
+}, libraryPath: string) => string[];
+export declare let libraryAssetCheck: LibraryAssetCheck | undefined;
+/** Register (or with `undefined`, remove) the {@link LibraryAssetCheck} `add` runs per library asset. */
+export declare function setLibraryAssetCheck(check: LibraryAssetCheck | undefined): void;
+//# sourceMappingURL=library-hooks.d.ts.map

package/dist/asset-manager/src/shared/library-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-hooks.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/shared/library-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACrD,WAAW,EAAE,MAAM,KAChB,MAAM,EAAE,CAAC;AAEd,eAAO,IAAI,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,CAAC;AAE5D,yGAAyG;AACzG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAE/E"}

package/dist/asset-manager/src/shared/library.d.ts

@@ -0,0 +1,96 @@
+import { type CatalogEntry, type LockEntry, type LockFile } from "@skaile/workspaces/core";
+import { type AssetDefinition } from "@skaile/workspaces/library";
+import type { IAssetKindRegistry } from "@skaile/workspaces/plugins";
+import type { DeployableEntry } from "../installer.js";
+import type { LibraryIndexSnapshot, LibraryMove, LockedLibrary } from "./types.js";
+/**
+ * `kind:name` → sha256 of every asset in the library at `libPath`, hashed from
+ * the files on disk by the same discovery pass `skaile library index` runs. The
+ * publisher only affects refs, never the hash, so a manifest-less library gets a
+ * placeholder. Memoised per root in `cache` for one lock/restore pass.
+ */
+export declare function libraryDiskHashes(libPath: string, cache: Map<string, Map<string, string>>, registry: IAssetKindRegistry): Map<string, string>;
+/**
+ * Give a scanned library entry the file set its content hash covers, so a deploy
+ * copies exactly those bytes (every file under the manifest entry's `root:`, or
+ * its explicit `files:`) instead of the kind's convention filter, which drops a
+ * skill's `build.py` / `template.html` / `example.data/`. Same discovery pass as
+ * {@link libraryDiskHashes} and `skaile library publish`, so the deployed tree
+ * never differs from what the lock hashed. A library without `assets:` in its
+ * `skaile.manifest.yaml` (glob mode), or an entry discovery rejected, keeps the
+ * kind's default filter — the entry is returned untouched.
+ *
+ * @param cache - Per library root: manifest path → asset files relative to the
+ *   manifest's directory. Memoised for one resolution pass.
+ */
+export declare function withLibraryFiles<E extends DeployableEntry>(entry: E, libPath: string, cache: Map<string, Map<string, string[]>>, registry: IAssetKindRegistry): E;
+/**
+ * The highest-versioned indexed definition of `kind:@publisher/name` held by the
+ * library named `libraryName`, or `undefined` when the library is unknown to the
+ * index or has not indexed the asset. Stored publishers may carry the `@` scope
+ * sigil, so both sides are compared bare.
+ */
+export declare function newestLibraryDef(snap: LibraryIndexSnapshot | null, libraryName: string, id: {
+    kind: string;
+    publisher: string;
+    name: string;
+}): AssetDefinition | undefined;
+/** Prefix of the pseudo-version of an asset that declares no version (`0.0.0-sha.<commit>`). */
+export declare const PSEUDO_VERSION_PREFIX = "0.0.0-sha.";
+export declare function isPseudoVersion(version: string): boolean;
+/**
+ * THE version of an asset held by the library named `libraryName`: the one its file declares;
+ * for an asset without one in a source clone (a `reader` library with a remote url) the repo
+ * commit pseudo-version `0.0.0-sha.<commit>`, as the source pass keys it and `search` lists it
+ * (p967); otherwise the indexed one. `add`, the lock, `install --locked`, `check` and
+ * `outdated` all ask here, so a version-less asset has one version everywhere.
+ */
+export declare function libraryAssetVersion(snap: LibraryIndexSnapshot | null | undefined, libraryName: string, id: {
+    kind: string;
+    publisher: string;
+    name: string;
+}, declared: string | undefined): string | undefined;
+/**
+ * Sort order of library candidates for one ref: highest version first; an equal version
+ * goes to the default library, then to the candidates `rank` puts first (lower is better),
+ * then by library name — so the pick never depends on scan order.
+ */
+export declare function libraryPreference(isDefaultLib: Map<string, boolean>, rank?: (c: {
+    entry: CatalogEntry;
+    library: string;
+}) => number): (a: {
+    entry: CatalogEntry;
+    library: string;
+}, b: {
+    entry: CatalogEntry;
+    library: string;
+}) => number;
+/**
+ * The library-origin entries of `next` whose library differs from the one `prev` locked for the
+ * same kind/publisher/name (any version). New assets and `asset install` entries never move.
+ */
+export declare function libraryMoves(prev: LockFile | null, next: Record<string, LockEntry>): LibraryMove[];
+/**
+ * The name to tell the user for a locked library that is not registered: the last name the
+ * library had, as the lock keeps the one it had when the asset was locked (p893).
+ */
+export declare function unregisteredLibraryName(origin: {
+    name: string;
+}): string;
+/**
+ * What to do about a locked library asset whose library is not registered (renamed or removed).
+ * A lock entry that records the library's remote names it too, and registers the library by it:
+ * no registered library has that remote either, or the lookup would have matched it.
+ */
+export declare function unregisteredLibraryFix(origin: {
+    name: string;
+    url?: string;
+}, ref: string): string;
+/** Why a locked library cannot supply its assets, with the fix, for a lookup that is not `ok`. */
+export declare function lockedLibraryProblem(lookup: Exclude<LockedLibrary, {
+    state: "ok";
+}>, origin: {
+    name: string;
+    url?: string;
+}, ref: string): string;
+//# sourceMappingURL=library.d.ts.map

package/dist/asset-manager/src/shared/library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/shared/library.ts"],"names":[],"mappings":"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"}