fundus 0.17.2 → 0.19.0

package/dist/server/codegen.js

@@ -35,24 +35,6 @@ export function kebabCaseFromCamel(name) {
 export function manifestModuleFileName(manifestName) {
     return `${kebabCaseFromCamel(manifestName)}.generated.ts`;
 }
-/** Two manifest names that would generate the same kebab-case module file. */
-export function manifestModuleCollisionIssues(manifests) {
-    const issues = [];
-    const namesByModuleFile = new Map();
-    for (const name of Object.keys(manifests)) {
-        const fileName = manifestModuleFileName(name);
-        const existingName = namesByModuleFile.get(fileName);
-        if (existingName !== undefined) {
-            issues.push({
-                message: `Manifests "${existingName}" and "${name}" would both generate "${fileName}".`
-            });
-        }
-        else {
-            namesByModuleFile.set(fileName, name);
-        }
-    }
-    return issues;
-}
 /**
  * Build the entry data codegen emits for one asset — delegated to
  * the owning server plugin's `buildManifestEntry`. Reference fields

package/dist/server/config-loader.d.ts

@@ -1,4 +1,4 @@
-import { type AudioPreset, type FigmaImportScale, type ImagePreset, type PackageDeclaration, type ResolvedVideoPreset, type UsageConfig } from '../core/index.js';
+import type { AudioPreset, FigmaImportScale, ImagePreset, ResolvedDependency, ResolvedVideoPreset, UsageConfig } from '../core/index.js';
 import type { ServerPluginRegistry } from './plugins/contract.js';
 export interface ResolvedPresetPluginConfig {
     presets: Record<string, ImagePreset>;
@@ -13,27 +13,6 @@ export interface ResolvedVideoPluginConfig {
 export interface ResolvedAudioPluginConfig {
     presets: Record<string, AudioPreset>;
 }
-/**
- * A `packages` entry after pure normalization (no disk): its declared origin,
- * whether it is a package name or a path, the resolved reference (absolute path
- * for the path form; the bare name for the name form), and an optional raw-root
- * override. Package files are read later, in `loadConfig`.
- */
-export interface NormalizedPackageSource {
-    origin: string;
-    kind: 'name' | 'path';
-    reference: string;
-    rawDirOverride?: string;
-}
-/** A fully resolved Package: its parsed declaration plus provenance. */
-export interface ResolvedPackage {
-    origin: string;
-    /** Absolute path of the resolved fundus.package.json. */
-    file: string;
-    /** Absolute raw root (recorded for provenance; unused in v1 slots-only). */
-    rawDir: string;
-    declaration: PackageDeclaration;
-}
 export interface ResolvedFundusConfig {
     /** Absolute host project directory containing fundus.config.ts. */
     projectRoot: string;
@@ -44,6 +23,11 @@ export interface ResolvedFundusConfig {
     manifestsDir: string;
     /** URL prefix baked into generated proxy `src` values; always ends with '/'. */
     proxyBasePath: string;
+    /**
+     * Aggregated, deduplicated dependency declarations from all configured
+     * sources. Empty when none are configured.
+     */
+    dependencies: readonly ResolvedDependency[];
     plugins: {
         image: ResolvedPresetPluginConfig;
         slice: ResolvedPresetPluginConfig;
@@ -61,22 +45,15 @@ export interface ResolvedFundusConfig {
         };
     };
     usage: UsageConfig | null;
-    /** Normalized `packages` entries (from the pure `resolveConfig`, no disk). */
-    packageSources: NormalizedPackageSource[];
-    /** Parsed Packages (filled by `loadConfig`; always [] from `resolveConfig`). */
-    packages: ResolvedPackage[];
 }
 export declare const USAGE_NOT_CONFIGURED_MESSAGE = "Usage analysis is not configured; add usage.referenceProvider and usage.openLocation to fundus.config.ts.";
 /** Pure resolution step (testable without a config file on disk). */
 export declare function resolveConfig(projectRoot: string, value: unknown, registry?: ServerPluginRegistry): ResolvedFundusConfig;
 /**
- * Read and parse every declared Package from disk. Name entries resolve through
- * the host's module resolver (respecting `exports`), then walk up to the nearest
- * `package.json` that declares the name and read its `"fundus"` field. Path
- * entries point directly at a `fundus.package.json`. Throws a clear,
- * origin-tagged error on any resolution/read/parse failure — Package assembly
- * failures are symmetric with a missing `fundus.config.ts`.
+ * Load and aggregate every configured dependency source (D3, D6). `requireAnchor`
+ * anchors npm-name resolution at the host project (injectable for tests). Flat:
+ * the dependencies of a referenced npm package are not resolved recursively.
  */
-export declare function loadPackages(projectRoot: string, sources: NormalizedPackageSource[]): Promise<ResolvedPackage[]>;
+export declare function resolveDependencies(projectRoot: string, specs: readonly string[], requireAnchor?: string): Promise<ResolvedDependency[]>;
 /** Load `fundus.config.ts` from the host project root. */
 export declare function loadConfig(projectRoot: string): Promise<ResolvedFundusConfig>;

package/dist/server/config-loader.js

@@ -4,12 +4,10 @@
  * absolute, and merges the built-in plugin preset defaults under the host's.
  */
 import { existsSync, readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
 import { createJiti } from 'jiti';
-import { parsePackageDeclaration, validatePackageDeclaration } from '../core/index.js';
+import { validateDependencyList } from '../core/index.js';
 import { serverPluginsByType } from './plugins.js';
 import { isRecord } from './plugins/config.js';
 export const USAGE_NOT_CONFIGURED_MESSAGE = 'Usage analysis is not configured; add usage.referenceProvider and usage.openLocation to fundus.config.ts.';
@@ -36,88 +34,6 @@ function configDefinitionsFor(registry) {
     }
     return [...byNamespace.values()];
 }
-/**
- * A string `packages` entry is a *path* when it looks like one (starts with
- * `.`/`/`, is absolute, or ends `.json`), or a bare relative path with a
- * separator; otherwise it is a package *name*. A scoped name (`@scope/pkg`)
- * contains a `/` but is a name.
- */
-function classifyPackageSpec(spec) {
-    if (spec.startsWith('.') || spec.startsWith('/') || isAbsolute(spec))
-        return 'path';
-    if (DECLARATION_FILE_RE.test(spec))
-        return 'path';
-    if (spec.startsWith('@'))
-        return 'name';
-    if (spec.includes('/') || spec.includes('\\'))
-        return 'path';
-    return 'name';
-}
-/** A declaration file is JSON or a JS/TS module (the latter loaded via jiti). */
-const DECLARATION_FILE_RE = /\.(json|[mc]?[jt]s)$/;
-/**
- * Read a package declaration from its resolved file: a JSON `fundus.package.json`
- * (parsed as text) or a JS/TS module (`fundus.package.ts`) whose default export is
- * the declaration — loaded through the same jiti path as `fundus.config.ts`, which
- * keeps the resource `type`s literal for the package's `PackageAssets<…>` derivation.
- */
-async function loadPackageDeclaration(file, origin) {
-    if (/\.[mc]?[jt]s$/.test(file)) {
-        let module;
-        try {
-            const jiti = createJiti(import.meta.url, { interopDefault: false });
-            module = await jiti.import(file);
-        }
-        catch (cause) {
-            throw new Error(`Cannot load fundus package "${origin}" (${file}): ${cause instanceof Error ? cause.message : String(cause)}`);
-        }
-        const value = isRecord(module) && 'default' in module ? module.default : module;
-        return validatePackageDeclaration(value, origin);
-    }
-    let text;
-    try {
-        text = await readFile(file, 'utf8');
-    }
-    catch (cause) {
-        throw new Error(`Cannot read fundus package "${origin}" (${file}): ${cause instanceof Error ? cause.message : String(cause)}`);
-    }
-    return parsePackageDeclaration(text, origin);
-}
-function normalizePackageSource(projectRoot, entry) {
-    let spec;
-    let rawDirOverride;
-    if (typeof entry === 'string') {
-        spec = entry;
-    }
-    else if (isRecord(entry) && typeof entry.package === 'string' && entry.package.length > 0) {
-        spec = entry.package;
-        if (entry.rawDir !== undefined) {
-            if (typeof entry.rawDir !== 'string' || entry.rawDir.length === 0) {
-                throw new Error('fundus.config: a "packages" entry "rawDir" must be a non-empty string.');
-            }
-            rawDirOverride = entry.rawDir;
-        }
-    }
-    else {
-        throw new Error('fundus.config: each "packages" entry must be a package name, a path string, or { package: string; rawDir?: string }.');
-    }
-    const kind = classifyPackageSpec(spec);
-    const reference = kind === 'path' ? resolve(projectRoot, spec) : spec;
-    return {
-        origin: spec,
-        kind,
-        reference,
-        ...(rawDirOverride !== undefined ? { rawDirOverride } : {})
-    };
-}
-function resolvePackageSources(projectRoot, value) {
-    if (value === undefined)
-        return [];
-    if (!Array.isArray(value)) {
-        throw new Error('fundus.config: "packages" must be an array.');
-    }
-    return value.map((entry) => normalizePackageSource(projectRoot, entry));
-}
 /** Pure resolution step (testable without a config file on disk). */
 export function resolveConfig(projectRoot, value, registry = serverPluginsByType) {
     if (!isRecord(value)) {
@@ -161,6 +77,9 @@ export function resolveConfig(projectRoot, value, registry = serverPluginsByType
     if (scale !== 1 && scale !== 2 && scale !== 3 && scale !== 4) {
         throw new Error('fundus.config: "import.figma.defaults.scale" must be 1, 2, 3, or 4.');
     }
+    // Fail fast on a malformed `dependencies` shape; the result is discarded
+    // because the sources are resolved asynchronously in `loadConfig`.
+    dependencySpecs(value);
     const usage = value.usage;
     if (usage !== undefined && !isRecord(usage)) {
         throw new Error('fundus.config: "usage" must be an object.');
@@ -178,6 +97,8 @@ export function resolveConfig(projectRoot, value, registry = serverPluginsByType
         library: resolvePath(projectRoot, requiredString(value, 'library')),
         manifestsDir: resolvePath(projectRoot, requiredString(value, 'manifestsDir')),
         proxyBasePath,
+        // Placeholder; `loadConfig` resolves the sources asynchronously through jiti.
+        dependencies: [],
         plugins: resolvedPlugins,
         import: {
             figma: {
@@ -186,23 +107,43 @@ export function resolveConfig(projectRoot, value, registry = serverPluginsByType
                 defaults: { scale }
             }
         },
-        usage: usage === undefined ? null : usage,
-        packageSources: resolvePackageSources(projectRoot, value.packages),
-        packages: []
+        usage: usage === undefined ? null : usage
     };
 }
-function nearestNamedPackageJson(entryPath, name) {
-    let dir = dirname(entryPath);
+/** Validated dependency source specs (shape only; absent means none). */
+function dependencySpecs(value) {
+    const specs = value.dependencies;
+    if (specs === undefined)
+        return [];
+    if (!Array.isArray(specs) ||
+        specs.some((spec) => typeof spec !== 'string' || spec.length === 0)) {
+        throw new Error('fundus.config: "dependencies" must be an array of non-empty strings.');
+    }
+    return specs;
+}
+/** Reject a `.json` dependency source: JSON carries no literal types (D4). */
+function assertNotJson(spec, context) {
+    if (spec.endsWith('.json')) {
+        throw new Error(`Dependency ${context} "${spec}" must be a .ts or .js module; JSON is not supported.`);
+    }
+}
+/** A dependency spec is a path when it is relative/absolute or names a module file. */
+function isPathSpec(spec) {
+    return (spec.startsWith('.') || spec.startsWith('/') || spec.endsWith('.ts') || spec.endsWith('.js'));
+}
+/** Walk up from `fromPath` to the nearest package.json whose `name` matches. */
+function nearestPackageJson(fromPath, name) {
+    let dir = dirname(fromPath);
     for (;;) {
         const candidate = join(dir, 'package.json');
         if (existsSync(candidate)) {
             try {
                 const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                if (isRecord(pkg) && pkg.name === name)
-                    return { dir, pkg };
+                if (pkg.name === name)
+                    return candidate;
             }
             catch {
-                // Malformed package.json — keep walking up.
+                // Ignore unreadable/malformed package.json and keep walking up.
             }
         }
         const parent = dirname(dir);
@@ -210,78 +151,65 @@ function nearestNamedPackageJson(entryPath, name) {
             break;
         dir = parent;
     }
-    throw new Error(`Cannot find the package.json for fundus package "${name}" (resolved to ${entryPath}).`);
+    throw new Error(`Cannot resolve the package.json of dependency "${name}".`);
 }
-/**
- * Resolve a name-form Package to its root directory + parsed `package.json`. A
- * declaration-only Package ships no JS entry module, so resolving the bare name
- * would throw `MODULE_NOT_FOUND`; resolve its `package.json` subpath first and
- * only fall back to entry resolution when an `exports` map hides it.
- */
-function resolvePackageRoot(require, reference, origin) {
+/** Resolve an npm-name dependency spec to its declared source module path. */
+function resolveNpmDependencyModule(spec, require) {
+    let packageJsonPath;
     try {
-        const manifestPath = require.resolve(`${reference}/package.json`);
-        const pkg = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        if (isRecord(pkg))
-            return { dir: dirname(manifestPath), pkg };
+        packageJsonPath = require.resolve(`${spec}/package.json`);
     }
-    catch {
-        // No resolvable ./package.json subpath — fall back to the entry module.
-    }
-    let entry;
-    try {
-        entry = require.resolve(reference);
+    catch (cause) {
+        if (cause !== null &&
+            typeof cause === 'object' &&
+            cause.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            packageJsonPath = nearestPackageJson(require.resolve(spec), spec);
+        }
+        else {
+            throw cause;
+        }
     }
-    catch {
-        throw new Error(`Cannot resolve fundus package "${origin}": no installed package declares it — is it a dependency?`);
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const field = pkg.fundus?.dependencies;
+    if (typeof field !== 'string' || field.length === 0) {
+        throw new Error(`Dependency "${spec}" is missing a non-empty "fundus".dependencies module path in its package.json.`);
     }
-    return nearestNamedPackageJson(entry, reference);
+    assertNotJson(field, `package.json "fundus".dependencies field of "${spec}"`);
+    return resolve(dirname(packageJsonPath), field);
 }
 /**
- * Read and parse every declared Package from disk. Name entries resolve through
- * the host's module resolver (respecting `exports`), then walk up to the nearest
- * `package.json` that declares the name and read its `"fundus"` field. Path
- * entries point directly at a `fundus.package.json`. Throws a clear,
- * origin-tagged error on any resolution/read/parse failure — Package assembly
- * failures are symmetric with a missing `fundus.config.ts`.
+ * Load and aggregate every configured dependency source (D3, D6). `requireAnchor`
+ * anchors npm-name resolution at the host project (injectable for tests). Flat:
+ * the dependencies of a referenced npm package are not resolved recursively.
  */
-export async function loadPackages(projectRoot, sources) {
-    const require = createRequire(pathToFileURL(join(projectRoot, 'fundus.config.ts')).href);
-    const packages = [];
-    for (const source of sources) {
-        let file;
-        let defaultRawDir;
-        if (source.kind === 'path') {
-            file = source.reference;
-            if (!existsSync(file)) {
-                throw new Error(`Fundus package file not found: ${file} (from "${source.origin}").`);
-            }
-            defaultRawDir = dirname(file);
-        }
-        else {
-            const { dir, pkg } = resolvePackageRoot(require, source.reference, source.origin);
-            const fundusField = pkg.fundus;
-            if (!isRecord(fundusField) ||
-                typeof fundusField.package !== 'string' ||
-                fundusField.package.length === 0) {
-                throw new Error(`Fundus package "${source.origin}" is missing a "fundus.package" field in its package.json.`);
+export async function resolveDependencies(projectRoot, specs, requireAnchor = join(resolve(projectRoot), 'package.json')) {
+    if (specs.length === 0)
+        return [];
+    const jiti = createJiti(import.meta.url, { interopDefault: false });
+    const require = createRequire(requireAnchor);
+    const aggregated = new Map();
+    for (const spec of specs) {
+        assertNotJson(spec, 'source');
+        const modulePath = isPathSpec(spec)
+            ? resolve(resolve(projectRoot), spec)
+            : resolveNpmDependencyModule(spec, require);
+        const loaded = (await jiti.import(modulePath));
+        const value = loaded.default ?? loaded;
+        for (const dependency of validateDependencyList(spec, value)) {
+            const existing = aggregated.get(dependency.id);
+            if (existing === undefined) {
+                aggregated.set(dependency.id, { type: dependency.type, sources: [spec] });
+                continue;
             }
-            file = resolve(dir, fundusField.package);
-            if (!existsSync(file)) {
-                throw new Error(`Fundus package "${source.origin}" declaration not found: ${file}.`);
+            if (existing.type !== dependency.type) {
+                throw new Error(`Dependency "${dependency.id}" is declared as "${existing.type}" by "${existing.sources.join('", "')}" and as "${dependency.type}" by "${spec}".`);
             }
-            defaultRawDir =
-                typeof fundusField.rawDir === 'string' && fundusField.rawDir.length > 0
-                    ? resolve(dir, fundusField.rawDir)
-                    : dir;
+            // Same id + same type from another source: dedupe (D3), keep the source.
+            if (!existing.sources.includes(spec))
+                existing.sources.push(spec);
         }
-        const declaration = await loadPackageDeclaration(file, source.origin);
-        const rawDir = source.rawDirOverride !== undefined
-            ? resolve(projectRoot, source.rawDirOverride)
-            : defaultRawDir;
-        packages.push({ origin: source.origin, file, rawDir, declaration });
     }
-    return packages;
+    return [...aggregated].map(([id, { type, sources }]) => ({ id, type, sources }));
 }
 /** Load `fundus.config.ts` from the host project root. */
 export async function loadConfig(projectRoot) {
@@ -298,6 +226,9 @@ export async function loadConfig(projectRoot) {
     catch (cause) {
         throw new Error(`Cannot load fundus.config.ts: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
-    const config = resolveConfig(root, isRecord(module) && 'default' in module ? module.default : module);
-    return { ...config, packages: await loadPackages(root, config.packageSources) };
+    const value = isRecord(module) && 'default' in module ? module.default : module;
+    const resolved = resolveConfig(root, value);
+    const specs = isRecord(value) ? dependencySpecs(value) : [];
+    const dependencies = await resolveDependencies(root, specs);
+    return { ...resolved, dependencies };
 }

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 export type { ResolvedFundusConfig, ResolvedPresetPluginConfig, ResolvedVideoPluginConfig, ResolvedAudioPluginConfig } from './config-loader.js';
-export { loadConfig, resolveConfig } from './config-loader.js';
+export { loadConfig, resolveConfig, resolveDependencies } from './config-loader.js';
 export { LibraryStore } from './library-store.js';
 export type { IngestOptions, ReplaceRawFileOptions } from './library-store.js';
 export type { AssetProxyInfo, ProxyOutputInfo, ProcessingReport } from './processing/processor.js';

package/dist/server/index.js

@@ -1,4 +1,4 @@
-export { loadConfig, resolveConfig } from './config-loader.js';
+export { loadConfig, resolveConfig, resolveDependencies } from './config-loader.js';
 export { LibraryStore } from './library-store.js';
 export { processAssets, expectedProxyFileName, expectedProxyRelativePath, deliveredAssetIds, isProxyFileName, readProxyOutputInfo } from './processing/processor.js';
 export { ffmpegBinaryPath, runToolchainBinary } from './processing/ffmpeg.js';

package/dist/server/library-store.d.ts

@@ -26,14 +26,6 @@ export interface IngestOptions {
 export interface CreateAssetOptions extends IngestOptions {
     manifests?: string[];
     importSource?: ImportSourceRecord;
-    /**
-     * Fill/override a Package slot: store these parameters verbatim as a host
-     * override record instead of expanding plugin defaults. Partial by design
-     * (only the overridden keys) — the merge deep-merges them over the Package
-     * base, and they are schema-validated over the effective library, not here.
-     * When set, `prepareParameters` is ignored.
-     */
-    parametersOverride?: unknown;
 }
 export interface CreateAssetStaging {
     rawPath: string;
@@ -141,8 +133,6 @@ export declare class LibraryStore {
      * type, dangling raw pointer, invalid parameters, unknown manifest names,
      * and reference errors (dangling target, type mismatch, cycles).
      */
-    validate(library: Library, options?: {
-        flatSpace?: boolean;
-    }): Promise<ValidationIssueDto[]>;
+    validate(library: Library): Promise<ValidationIssueDto[]>;
     syncFolders(library: Library): Promise<void>;
 }

package/dist/server/library-store.js

@@ -8,8 +8,8 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { createHash } from 'node:crypto';
-import { assetIdError, canonicalizeParameters, createEmptyLibrary, flatLibraryIssues, folderNameError, folderNameOf, folderOfRawPath, folderPathError, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, parseLibrary, normalizeFolderPath, parentFolderPath, portableFolderPathKey, rawFilePathError, rawFileNameOfPath, replaceFolderPrefix, manifestNameError, serializeLibrary } from '../core/index.js';
-import { manifestModuleCollisionIssues, manifestModuleFileName } from './codegen.js';
+import { assetIdError, collectAllReferences, canonicalizeParameters, createEmptyLibrary, folderNameError, folderNameOf, folderOfRawPath, folderPathError, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, parseLibrary, referenceErrors, normalizeFolderPath, parentFolderPath, portableFolderPathKey, rawFilePathError, rawFileNameOfPath, replaceFolderPrefix, manifestNameError, serializeLibrary } from '../core/index.js';
+import { manifestModuleFileName } from './codegen.js';
 import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
 import { isProxyFileNameFor } from './processing/processor.js';
 import { ensureManagedFolder, listRelativeFiles, syncManagedFolders } from './folder-filesystem.js';
@@ -135,9 +135,8 @@ export class LibraryStore {
         const folder = options.folder === undefined ? '' : normalizeFolderPath(options.folder);
         this.#requireFolder(library, folder);
         const manifests = [...new Set(options.manifests ?? [])].sort();
-        const validManifests = this.#validManifestNames(library);
         for (const manifest of manifests) {
-            if (!validManifests.has(manifest)) {
+            if (!Object.hasOwn(library.manifests, manifest)) {
                 throw new Error(`Unknown manifest "${manifest}".`);
             }
         }
@@ -150,15 +149,9 @@ export class LibraryStore {
         let installed = false;
         try {
             await writeFile(temporaryPath, options.bytes);
-            let parameters;
-            if (options.parametersOverride !== undefined) {
-                parameters = options.parametersOverride;
-            }
-            else {
-                parameters = plugin.descriptor.validateParameters(plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)));
-                if (prepareParameters) {
-                    parameters = plugin.descriptor.validateParameters(await prepareParameters({ rawPath: temporaryPath, rawFileName: storedName, parameters }));
-                }
+            let parameters = plugin.descriptor.validateParameters(plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)));
+            if (prepareParameters) {
+                parameters = plugin.descriptor.validateParameters(await prepareParameters({ rawPath: temporaryPath, rawFileName: storedName, parameters }));
             }
             const record = {
                 type: options.type,
@@ -446,9 +439,8 @@ export class LibraryStore {
         const library = await this.read();
         const record = this.#requireAsset(library, id);
         const unique = [...new Set(manifests)];
-        const validManifests = this.#validManifestNames(library);
         for (const name of unique) {
-            if (!validManifests.has(name)) {
+            if (!Object.hasOwn(library.manifests, name)) {
                 throw new Error(`Unknown manifest "${name}".`);
             }
         }
@@ -902,14 +894,7 @@ export class LibraryStore {
      * type, dangling raw pointer, invalid parameters, unknown manifest names,
      * and reference errors (dangling target, type mismatch, cycles).
      */
-    async validate(library, options = {}) {
-        // The default preserves single-root behaviour (host === effective). When
-        // merging Packages, disk/host checks run on the host library with
-        // `flatSpace: false`, while the flat-space checks (id/type/parameters/
-        // membership/appearance/references) run separately over the *effective*
-        // library — host override records store partial parameters that only
-        // validate once merged, and references may cross the host/Package boundary.
-        const flatSpace = options.flatSpace ?? true;
+    async validate(library) {
         const issues = [];
         const folderKeys = new Map();
         for (const folder of library.folders) {
@@ -939,7 +924,53 @@ export class LibraryStore {
                 }
             }
         }
+        for (const [name, record] of Object.entries(library.manifests)) {
+            const nameProblem = manifestNameError(name);
+            if (nameProblem)
+                issues.push({ message: nameProblem });
+            if (record.color !== undefined) {
+                const colorProblem = manifestColorError(record.color);
+                if (colorProblem)
+                    issues.push({ message: `Manifest "${name}": ${colorProblem}` });
+            }
+            if (record.emoji !== undefined) {
+                const emojiProblem = manifestEmojiError(record.emoji);
+                if (emojiProblem)
+                    issues.push({ message: `Manifest "${name}": ${emojiProblem}` });
+            }
+        }
+        const namesByModuleFile = new Map();
+        for (const name of Object.keys(library.manifests)) {
+            const fileName = manifestModuleFileName(name);
+            const existingName = namesByModuleFile.get(fileName);
+            if (existingName !== undefined) {
+                issues.push({
+                    message: `Manifests "${existingName}" and "${name}" would both generate "${fileName}".`
+                });
+            }
+            else {
+                namesByModuleFile.set(fileName, name);
+            }
+        }
         for (const [assetId, record] of Object.entries(library.assets)) {
+            const idProblem = assetIdError(assetId);
+            if (idProblem)
+                issues.push({ assetId, message: idProblem });
+            const plugin = this.#registry[record.type];
+            if (!plugin) {
+                issues.push({ assetId, message: `Unknown asset type "${record.type}".` });
+            }
+            else {
+                try {
+                    plugin.descriptor.validateParameters(record.parameters);
+                }
+                catch (cause) {
+                    issues.push({
+                        assetId,
+                        message: `Invalid parameters: ${cause instanceof Error ? cause.message : String(cause)}`
+                    });
+                }
+            }
             try {
                 assertSafeRelativeFilePath(record.raw);
             }
@@ -959,11 +990,13 @@ export class LibraryStore {
                     message: `Raw file "${record.raw}" is missing from the raw directory.`
                 });
             }
+            for (const manifest of record.manifests) {
+                if (!library.manifests[manifest]) {
+                    issues.push({ assetId, message: `Unknown manifest "${manifest}".` });
+                }
+            }
         }
-        if (flatSpace) {
-            issues.push(...flatLibraryIssues(library, descriptorsByType(this.#registry)));
-            issues.push(...manifestModuleCollisionIssues(library.manifests));
-        }
+        issues.push(...referenceErrors(library, collectAllReferences(library, descriptorsByType(this.#registry))));
         return issues;
     }
     async #deleteProxiesOf(assetId) {
@@ -986,21 +1019,6 @@ export class LibraryStore {
         }
         return library.assets[id];
     }
-    /**
-     * Valid manifest names for asset membership: the host library's own manifests
-     * plus any a configured Package introduces. The effective (merged) library
-     * unions both, so a host asset (or slot fill) may be placed into a
-     * Package-introduced manifest — validating against the host manifests alone
-     * would wrongly reject that placement.
-     */
-    #validManifestNames(library) {
-        const names = new Set(Object.keys(library.manifests));
-        for (const pkg of this.#config.packages ?? []) {
-            for (const name of Object.keys(pkg.declaration.manifests))
-                names.add(name);
-        }
-        return names;
-    }
     /** Resolve a non-colliding raw file name, appending `-1`, `-2`, … before the extension. */
     #uniqueRawName(fileName, folder) {
         if (!existsSync(join(this.#config.rawDir, folder, fileName)))