fundus 0.17.2 → 0.19.0

package/dist/core/dependencies.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The dependency system's public surface: a package declares which assets
+ * (`id` + `type` only) a consuming host library must provide, and derives a
+ * type contract for dependency injection from that declaration. Bytes,
+ * parameters, presets, and manifests always stay in the host library — a
+ * dependency source carries nothing but identity and kind.
+ */
+import type { AudioManifestEntry, ChromaKeyVideoManifestEntry, ImageManifestEntry, SliceManifestEntry, VideoManifestEntry } from './manifest-entry.js';
+export type FundusAssetKind = 'image' | 'slice' | 'video' | 'chroma-key-video' | 'audio';
+export interface Dependency {
+    id: string;
+    type: FundusAssetKind;
+}
+/**
+ * A dependency after aggregation across sources (D3). Adds the `sources` that
+ * declared this id — the npm package names or config paths — so validation can
+ * point back at whoever requires a missing or mistyped asset. This is derived,
+ * not declared: a package still declares only `{ id, type }`.
+ */
+export interface ResolvedDependency extends Dependency {
+    sources: readonly string[];
+}
+/**
+ * Renders declaring dependency sources as `"a", "b"` for a `required by …`
+ * clause. One formatter shared by validation messages, the editor inspector,
+ * and the delete confirmation so the wording never drifts.
+ */
+export declare function formatRequiredBy(sources: readonly string[]): string;
+/** Maps an asset kind onto its runtime manifest-entry type. */
+export type EntryFor<K extends FundusAssetKind> = K extends 'image' ? ImageManifestEntry : K extends 'slice' ? SliceManifestEntry : K extends 'video' ? VideoManifestEntry : K extends 'chroma-key-video' ? ChromaKeyVideoManifestEntry : K extends 'audio' ? AudioManifestEntry : never;
+/**
+ * Identity helper. Its only job is to preserve the literal `id`/`type` of each
+ * entry through `typeof`, so `ManifestContract<typeof deps>` is exact (D9). It
+ * adds no runtime behavior.
+ */
+export declare function defineDependencies<const T extends readonly Dependency[]>(deps: T): T;
+/**
+ * The exact, `readonly`, non-optional entry map a host must supply to satisfy a
+ * dependency list (D5): `{ [id]: EntryFor<type> }`. This is the type asserted at
+ * a package's `inject(manifest: ManifestContract<typeof deps>)` call site.
+ */
+export type ManifestContract<T extends readonly Dependency[]> = {
+    readonly [E in T[number] as E['id']]: EntryFor<E['type']>;
+};
+export declare const FUNDUS_ASSET_KINDS: readonly FundusAssetKind[];
+export declare function isFundusAssetKind(value: unknown): value is FundusAssetKind;
+/**
+ * Runtime validation of one loaded dependency list (one source): an array of
+ * `{ id: non-empty string, type: FundusAssetKind }` with no duplicate id within
+ * the list. Throws with the source name on any violation.
+ */
+export declare function validateDependencyList(source: string, value: unknown): Dependency[];

package/dist/core/dependencies.js

@@ -0,0 +1,56 @@
+/**
+ * Renders declaring dependency sources as `"a", "b"` for a `required by …`
+ * clause. One formatter shared by validation messages, the editor inspector,
+ * and the delete confirmation so the wording never drifts.
+ */
+export function formatRequiredBy(sources) {
+    return sources.map((source) => `"${source}"`).join(', ');
+}
+/**
+ * Identity helper. Its only job is to preserve the literal `id`/`type` of each
+ * entry through `typeof`, so `ManifestContract<typeof deps>` is exact (D9). It
+ * adds no runtime behavior.
+ */
+export function defineDependencies(deps) {
+    return deps;
+}
+export const FUNDUS_ASSET_KINDS = [
+    'image',
+    'slice',
+    'video',
+    'chroma-key-video',
+    'audio'
+];
+export function isFundusAssetKind(value) {
+    return typeof value === 'string' && FUNDUS_ASSET_KINDS.includes(value);
+}
+/**
+ * Runtime validation of one loaded dependency list (one source): an array of
+ * `{ id: non-empty string, type: FundusAssetKind }` with no duplicate id within
+ * the list. Throws with the source name on any violation.
+ */
+export function validateDependencyList(source, value) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Dependency source "${source}" must default-export an array of { id, type } entries.`);
+    }
+    const seen = new Set();
+    const result = [];
+    for (const entry of value) {
+        if (typeof entry !== 'object' || entry === null) {
+            throw new Error(`Dependency source "${source}": every entry must be an { id, type } object.`);
+        }
+        const { id, type } = entry;
+        if (typeof id !== 'string' || id.length === 0) {
+            throw new Error(`Dependency source "${source}": every entry needs a non-empty string "id".`);
+        }
+        if (!isFundusAssetKind(type)) {
+            throw new Error(`Dependency source "${source}": entry "${id}" has unknown type "${String(type)}".`);
+        }
+        if (seen.has(id)) {
+            throw new Error(`Dependency source "${source}": duplicate id "${id}".`);
+        }
+        seen.add(id);
+        result.push({ id, type });
+    }
+    return result;
+}

package/dist/core/dependency-validation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Validates a host library against an aggregated dependency list (D2). Deps are
+ * a lower bound: every declared id must exist with a matching type, but extra,
+ * undeclared assets are allowed. Pure — no environment access — so it can be
+ * fed into `check`, `build`, and the editor issues channel from one source.
+ *
+ * Findings are library-global and carry NO `assetId`: a dependency requirement
+ * isn't tied to an existing asset (a missing dependency has no asset at all), and
+ * the editor's issue banner only renders `assetId`-less issues (state.svelte.ts
+ * `generalIssues`). The declared id is embedded in the message, so nothing is
+ * lost; an `assetId` would route the finding to a possibly-nonexistent asset and
+ * hide it from the editor.
+ */
+import type { ValidationIssueDto } from './api-types.js';
+import { type ResolvedDependency } from './dependencies.js';
+import type { Library } from './library.js';
+export declare function validateDependencies(dependencies: readonly ResolvedDependency[], library: Library): ValidationIssueDto[];

package/dist/core/dependency-validation.js

@@ -0,0 +1,19 @@
+import { formatRequiredBy } from './dependencies.js';
+export function validateDependencies(dependencies, library) {
+    const findings = [];
+    for (const dependency of dependencies) {
+        if (!Object.hasOwn(library.assets, dependency.id)) {
+            findings.push({
+                message: `Missing ${dependency.type} "${dependency.id}" required by ${formatRequiredBy(dependency.sources)}.`
+            });
+            continue;
+        }
+        const record = library.assets[dependency.id];
+        if (record.type !== dependency.type) {
+            findings.push({
+                message: `Type mismatch for "${dependency.id}" required by ${formatRequiredBy(dependency.sources)}: expected ${dependency.type}, library has ${record.type}.`
+            });
+        }
+    }
+    return findings;
+}

package/dist/core/index.d.ts

@@ -1,10 +1,5 @@
-export type { AssetId, ManifestName, AssetRecord, ManifestRecord, ImportSourceRecord, Library, EffectiveAssetRecord, EffectiveLibrary } from './library.js';
-export { createEmptyLibrary, parseLibrary, serializeLibrary, assertSafeKey, isRecord, parseImportSource, parseManifestRecord } from './library.js';
-export type { PackageAssetDeclaration, PackageDeclaration } from './package-declaration.js';
-export { parsePackageDeclaration, validatePackageDeclaration } from './package-declaration.js';
-export type { ParsedPackage, AssetProvenance, MergeProvenance, MergeFinding, MergeResult } from './package-merge.js';
-export { mergePackages, materializeLibrary, deepMergeParameters } from './package-merge.js';
-export { flatLibraryIssues } from './library-validation.js';
+export type { AssetId, ManifestName, AssetRecord, ManifestRecord, ImportSourceRecord, Library } from './library.js';
+export { createEmptyLibrary, parseLibrary, serializeLibrary } from './library.js';
 export { rawFileNameError, rawFilePathError, portableRawPathKey, isFundusTransactionName } from './raw-path.js';
 export { ROOT_FOLDER, FOLDER_SENTINEL, folderNameError, folderPathError, normalizeFolderPath, portableFolderPathKey, parentFolderPath, folderNameOf, joinFolderPath, folderOfRawPath, rawFileNameOfPath, isFolderOrDescendant, replaceFolderPrefix } from './folder-path.js';
 export { RESERVED_ASSET_IDS, isValidAssetId, assetIdError, manifestNameError } from './asset-id.js';
@@ -12,14 +7,17 @@ export type { ManifestColor } from './manifest-appearance.js';
 export { MANIFEST_COLORS, MANIFEST_EMOJIS, isManifestColor, isManifestEmoji, resolveManifestColor, manifestColorError, manifestEmojiError } from './manifest-appearance.js';
 export { acceptedExtensions, acceptedExtensionsForType, typesForFileName, proposeAssetId } from './ingest.js';
 export { canonicalizeParameters, compareCodeUnits } from './canonicalize.js';
-export type { FigmaImportScale, FundusConfig, PackageSource, SourceLocation, AssetReferenceTarget, UsageReference, ReferenceResult, UsageConfig, FundusAssetKind, PackageResourceInput, PackageDeclarationInput, PackageAssets } from './config.js';
-export { defineConfig, definePackage } from './config.js';
+export type { FigmaImportScale, FundusConfig, SourceLocation, AssetReferenceTarget, UsageReference, ReferenceResult, UsageConfig } from './config.js';
+export { defineConfig } from './config.js';
+export type { Dependency, ResolvedDependency, FundusAssetKind, EntryFor, ManifestContract } from './dependencies.js';
+export { defineDependencies, formatRequiredBy, isFundusAssetKind, validateDependencyList, FUNDUS_ASSET_KINDS } from './dependencies.js';
+export { validateDependencies } from './dependency-validation.js';
 export type { SliceMode, SliceInsets, Slicing } from './slice-data.js';
 export { createZeroInsets, defaultInsetsForSize, slicedAxesFor, maxInset, maxOverdraw } from './slice-data.js';
 export type { AssetIdentified, ImageManifestEntry, SliceManifestEntry, VideoManifestEntry, ChromaKeyVideoManifestEntry, AudioManifestEntry, ManifestEntryData, ManifestEntry, ImagePreloadOptions, SlicePreloadOptions, VideoPreloadOptions, ChromaKeyVideoPreloadOptions, AudioPreloadOptions, PreloadOptions } from './manifest-entry.js';
 export type { ChromaKeyParameters } from './chroma-key.js';
 export { DEFAULT_CHROMA_KEY_PARAMETERS, validateChromaKeyParameters } from './chroma-key.js';
-export type { AssetOrigin, AssetStateDto, AssetReferenceLinkDto, AssetReferencesDto, PassiveManifestMembershipDto, PassiveMemberDto, ManifestMembershipDto, ProxyStateDto, PresetCapabilitiesDto, FundusStateDto, ValidationIssueDto, PatchAssetRequestDto, CreateFolderRequestDto, PatchFolderRequestDto, MoveAssetsRequestDto, DeleteAssetsRequestDto, CreateManifestRequestDto, PatchManifestRequestDto, RawIngestionQueueItemDto, NewRawIngestionQueueItemDto, EditedRawIngestionQueueItemDto, UnsupportedRawIngestionQueueItemDto, AdoptRawFileRequestDto, ResolveEditedRawFileRequestDto, ApiErrorDto, AssetUsageStatus, OpenableUsageReferenceDto, AssetUsageRootResultDto, AssetUsageRootDto, AssetUsageDto, UsageAnalysisDto } from './api-types.js';
+export type { AssetStateDto, AssetReferenceLinkDto, AssetReferencesDto, PassiveManifestMembershipDto, PassiveMemberDto, ManifestMembershipDto, ProxyStateDto, PresetCapabilitiesDto, FundusStateDto, ValidationIssueDto, PatchAssetRequestDto, CreateFolderRequestDto, PatchFolderRequestDto, MoveAssetsRequestDto, DeleteAssetsRequestDto, CreateManifestRequestDto, PatchManifestRequestDto, RawIngestionQueueItemDto, NewRawIngestionQueueItemDto, EditedRawIngestionQueueItemDto, UnsupportedRawIngestionQueueItemDto, AdoptRawFileRequestDto, ResolveEditedRawFileRequestDto, ApiErrorDto, AssetUsageStatus, OpenableUsageReferenceDto, AssetUsageRootResultDto, AssetUsageRootDto, AssetUsageDto, UsageAnalysisDto } from './api-types.js';
 export type { SourceImportErrorCode } from './api-types.js';
 export type { AssetReference, CollectedReference } from './asset-reference.js';
 export { isAssetReference } from './asset-reference.js';

package/dist/core/index.js

@@ -1,14 +1,13 @@
-export { createEmptyLibrary, parseLibrary, serializeLibrary, assertSafeKey, isRecord, parseImportSource, parseManifestRecord } from './library.js';
-export { parsePackageDeclaration, validatePackageDeclaration } from './package-declaration.js';
-export { mergePackages, materializeLibrary, deepMergeParameters } from './package-merge.js';
-export { flatLibraryIssues } from './library-validation.js';
+export { createEmptyLibrary, parseLibrary, serializeLibrary } from './library.js';
 export { rawFileNameError, rawFilePathError, portableRawPathKey, isFundusTransactionName } from './raw-path.js';
 export { ROOT_FOLDER, FOLDER_SENTINEL, folderNameError, folderPathError, normalizeFolderPath, portableFolderPathKey, parentFolderPath, folderNameOf, joinFolderPath, folderOfRawPath, rawFileNameOfPath, isFolderOrDescendant, replaceFolderPrefix } from './folder-path.js';
 export { RESERVED_ASSET_IDS, isValidAssetId, assetIdError, manifestNameError } from './asset-id.js';
 export { MANIFEST_COLORS, MANIFEST_EMOJIS, isManifestColor, isManifestEmoji, resolveManifestColor, manifestColorError, manifestEmojiError } from './manifest-appearance.js';
 export { acceptedExtensions, acceptedExtensionsForType, typesForFileName, proposeAssetId } from './ingest.js';
 export { canonicalizeParameters, compareCodeUnits } from './canonicalize.js';
-export { defineConfig, definePackage } from './config.js';
+export { defineConfig } from './config.js';
+export { defineDependencies, formatRequiredBy, isFundusAssetKind, validateDependencyList, FUNDUS_ASSET_KINDS } from './dependencies.js';
+export { validateDependencies } from './dependency-validation.js';
 export { createZeroInsets, defaultInsetsForSize, slicedAxesFor, maxInset, maxOverdraw } from './slice-data.js';
 export { DEFAULT_CHROMA_KEY_PARAMETERS, validateChromaKeyParameters } from './chroma-key.js';
 export { isAssetReference } from './asset-reference.js';

package/dist/core/library.d.ts

@@ -45,27 +45,8 @@ export interface Library {
     assets: Record<AssetId, AssetRecord>;
     manifests: Record<ManifestName, ManifestRecord>;
 }
-/**
- * An asset record in the merged *effective* library, where `raw`/`rawHash` may
- * be absent — an unfilled Package **slot**. Every `Library` record is a valid
- * `EffectiveAssetRecord` (required fields satisfy optional ones), so single-root
- * callers are unaffected. The effective library lives in memory only and is
- * never serialized (a host `Library` always carries `raw`/`rawHash`).
- */
-export interface EffectiveAssetRecord extends Omit<AssetRecord, 'raw' | 'rawHash'> {
-    raw?: string;
-    rawHash?: string;
-}
-/** The host library with all Packages merged under it (host wins). In-memory only. */
-export interface EffectiveLibrary extends Omit<Library, 'assets'> {
-    assets: Record<AssetId, EffectiveAssetRecord>;
-}
 /** A fresh, empty library. */
 export declare function createEmptyLibrary(): Library;
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function assertSafeKey(kind: 'asset' | 'manifest', key: string): void;
-export declare function parseImportSource(id: string, value: unknown): ImportSourceRecord;
-export declare function parseManifestRecord(name: string, value: Record<string, unknown>): ManifestRecord;
 /**
  * Parse and structurally validate a library file's JSON text. Throws with a
  * clear message on any malformed part; plugin parameter validation is a

package/dist/core/library.js

@@ -3,7 +3,7 @@ import { folderPathError } from './folder-path.js';
 export function createEmptyLibrary() {
     return { version: 1, folders: [], assets: {}, manifests: {} };
 }
-export function isRecord(value) {
+function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /**
@@ -13,12 +13,12 @@ export function isRecord(value) {
  * this is a validator concern (reported as issues, not parse failures).
  */
 const DANGEROUS_KEYS = ['__proto__', 'constructor', 'prototype'];
-export function assertSafeKey(kind, key) {
+function assertSafeKey(kind, key) {
     if (DANGEROUS_KEYS.includes(key)) {
         throw new Error(`Library ${kind} key "${key}" is not allowed.`);
     }
 }
-export function parseImportSource(id, value) {
+function parseImportSource(id, value) {
     if (!isRecord(value)) {
         throw new Error(`Library asset "${id}" has a non-object "importSource".`);
     }
@@ -64,7 +64,7 @@ function parseAssetRecord(id, value, version) {
         record.importSource = parseImportSource(id, value.importSource);
     return record;
 }
-export function parseManifestRecord(name, value) {
+function parseManifestRecord(name, value) {
     const record = {};
     if ('color' in value && value.color !== undefined) {
         if (typeof value.color !== 'string') {

package/dist/core/manifest-membership.d.ts

@@ -6,7 +6,7 @@
  * picture is computed; server processing, codegen, delivered-size accounting,
  * and the editor state payload all consume it — no parallel closure walks.
  */
-import type { AssetId, EffectiveLibrary, ManifestName } from './library.js';
+import type { AssetId, Library, ManifestName } from './library.js';
 import { type ReferencesByAsset } from './reference-graph.js';
 /** One derived passive membership, with the attribution that explains it. */
 export interface PassiveMember {
@@ -47,7 +47,7 @@ export type LibraryMembership = Record<ManifestName, ManifestMembership>;
  * (`referenceClosure(explicit) − explicit`) with their via-attribution, and
  * the resulting delivery set.
  */
-export declare function computeLibraryMembership(library: EffectiveLibrary, referencesByAsset: ReferencesByAsset): LibraryMembership;
+export declare function computeLibraryMembership(library: Library, referencesByAsset: ReferencesByAsset): LibraryMembership;
 /**
  * Every asset delivered by at least one manifest, explicitly or passively —
  * the processing set (assets outside it are inert). An asset is

package/dist/core/reference-graph.d.ts

@@ -7,7 +7,7 @@
  * enumerated (`collectAllReferences`) — no fs, no plugin introspection.
  */
 import type { CollectedReference } from './asset-reference.js';
-import type { AssetId, EffectiveLibrary } from './library.js';
+import type { AssetId, Library } from './library.js';
 import type { ValidationIssueDto } from './api-types.js';
 import type { AssetTypePluginDescriptor } from './plugins/contract.js';
 /** The plugin registry shape shared by server and tests: type → descriptor. */
@@ -19,13 +19,13 @@ export type ReferencesByAsset = Record<AssetId, CollectedReference[]>;
  * whose type is unknown or whose parameters do not validate contribute no
  * references — those problems are reported by the regular validation pass.
  */
-export declare function collectAllReferences(library: EffectiveLibrary, plugins: PluginDescriptorRegistry): ReferencesByAsset;
+export declare function collectAllReferences(library: Library, plugins: PluginDescriptorRegistry): ReferencesByAsset;
 /**
  * Reference *errors* (they block build/codegen): a reference to an unknown
  * asset, a target whose type is not among the field's expected types, and
  * cycles (composition is acyclic by nature).
  */
-export declare function referenceErrors(library: EffectiveLibrary, referencesByAsset: ReferencesByAsset): ValidationIssueDto[];
+export declare function referenceErrors(library: Library, referencesByAsset: ReferencesByAsset): ValidationIssueDto[];
 /**
  * The transitive reference closure of a set of assets, including the starting
  * set — the assets that must be delivered so the starting set renders as

package/dist/server/build.js

@@ -6,44 +6,30 @@
 import { loadConfig } from './config-loader.js';
 import { LibraryStore } from './library-store.js';
 import { processAssets } from './processing/processor.js';
-import { generateManifestModules, manifestModuleCollisionIssues } from './codegen.js';
-import { descriptorsByType, serverPluginsByType } from './plugins.js';
-import { formatCheckFinding, packageSlotFindings } from './check.js';
-import { collectAllReferences, computeLibraryMembership, flatLibraryIssues, materializeLibrary, mergePackages, typesForFileName } from '../core/index.js';
+import { generateManifestModules } from './codegen.js';
+import { serverPluginsByType } from './plugins.js';
+import { formatCheckFinding } from './check.js';
+import { typesForFileName, validateDependencies } from '../core/index.js';
 import { classifyRawDirectory } from './raw-reconciliation.js';
 import { rawSafetyIssues } from './raw-safety.js';
 export async function runBuild(projectRoot, registry = serverPluginsByType) {
     const config = await loadConfig(projectRoot);
     const store = new LibraryStore(config, registry);
-    const host = await store.read();
-    // Merge Packages under the host; validate the effective library; process +
-    // generate over the materialized (raw-bearing) subset. Raw scans stay host.
-    const { library: effective, provenance, findings: mergeFindings } = mergePackages(host, config.packages ?? []);
-    const materialized = materializeLibrary(effective);
+    const library = await store.read();
     const descriptors = Object.values(registry).map((plugin) => plugin.descriptor);
     const compatibleTypes = (path) => typesForFileName(path, descriptors);
-    const classification = await classifyRawDirectory(config.rawDir, host, (path) => compatibleTypes(path).length > 0);
-    const referencesByAsset = collectAllReferences(effective, descriptorsByType(registry));
-    const membership = computeLibraryMembership(effective, referencesByAsset);
+    const classification = await classifyRawDirectory(config.rawDir, library, (path) => compatibleTypes(path).length > 0);
     const issues = [
-        ...mergeFindings
-            .filter((finding) => finding.kind !== 'package-overridden')
-            .map((finding) => ({ assetId: finding.assetId, message: finding.message })),
-        ...(await store.validate(host, { flatSpace: false })),
-        ...flatLibraryIssues(effective, descriptorsByType(registry)),
-        ...manifestModuleCollisionIssues(effective.manifests),
-        ...rawSafetyIssues(host, classification, compatibleTypes),
-        ...packageSlotFindings(effective, provenance, membership).map((finding) => ({
-            assetId: finding.assetId,
-            message: finding.message
-        }))
+        ...(await store.validate(library)),
+        ...rawSafetyIssues(library, classification, compatibleTypes),
+        ...validateDependencies(config.dependencies, library)
     ];
     if (issues.length > 0) {
         const lines = issues.map((issue) => `  - ${formatCheckFinding({ kind: 'validation', assetId: issue.assetId, message: issue.message })}`);
         throw new Error(`Library validation failed:\n${lines.join('\n')}`);
     }
-    await store.syncFolders(host);
-    const processing = await processAssets(config, materialized, registry);
-    const codegen = await generateManifestModules(config, materialized, processing.proxies, registry);
+    await store.syncFolders(library);
+    const processing = await processAssets(config, library, registry);
+    const codegen = await generateManifestModules(config, library, processing.proxies, registry);
     return { processing, codegen };
 }

package/dist/server/check.d.ts

@@ -1,10 +1,10 @@
-import { type EffectiveLibrary, type Library, type LibraryMembership, type MergeProvenance, type ValidationIssueDto } from '../core/index.js';
+import { type Library, type ValidationIssueDto } from '../core/index.js';
 import { type RawClassification } from './raw-reconciliation.js';
 import type { ServerPluginRegistry } from './plugins/contract.js';
 /** One machine-readable check finding (the `--json` failure-list shape, M9). */
 export interface CheckFinding {
     /** The failure category. */
-    kind: 'validation' | 'proxy-missing' | 'proxy-unresolvable' | 'proxy-orphaned' | 'module-missing' | 'module-out-of-sync' | 'module-stray' | 'module-regeneration-failed' | 'unreachable-asset' | 'potential-image-duplicate' | 'raw-hash-drift' | 'raw-type-incompatible' | 'raw-scan-incomplete' | 'raw-unmanaged' | 'slot-unfilled' | 'slot-unmaterialized' | 'package-conflict' | 'package-type-mismatch';
+    kind: 'validation' | 'proxy-missing' | 'proxy-unresolvable' | 'proxy-orphaned' | 'module-missing' | 'module-out-of-sync' | 'module-stray' | 'module-regeneration-failed' | 'unreachable-asset' | 'potential-image-duplicate' | 'raw-hash-drift' | 'raw-type-incompatible' | 'raw-scan-incomplete' | 'raw-unmanaged';
     message: string;
     /** The asset the finding concerns, where applicable. */
     assetId?: string;
@@ -26,19 +26,9 @@ export interface CheckReport {
     manifestCount: number;
 }
 export interface CheckAdvisory {
-    kind: 'usage-not-configured' | 'package-overridden';
+    kind: 'usage-not-configured';
     message: string;
-    /** The asset a `package-overridden` advisory concerns. */
-    assetId?: string;
 }
 export declare function runCheck(projectRoot: string, registry?: ServerPluginRegistry): Promise<CheckReport>;
 /** Pure expansion of a raw classification into canonical hard check findings. */
 export declare function rawCheckFindings(library: Library, raw: RawClassification, registry: ServerPluginRegistry, validationIssues: ValidationIssueDto[]): CheckFinding[];
-/**
- * The delivered-slot contract: a Package slot that is delivered (explicit member
- * or in a delivered manifest's reference closure) but has no host-supplied bytes
- * must be filled. A slot with an `importSource` is `slot-unmaterialized` (run
- * import); a slot with nothing is `slot-unfilled`. Inert (undelivered) slots
- * produce no finding.
- */
-export declare function packageSlotFindings(library: EffectiveLibrary, provenance: MergeProvenance, membership: LibraryMembership): CheckFinding[];

package/dist/server/check.js

@@ -10,13 +10,13 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { allDeliveredAssetIds, collectAllReferences, compareCodeUnits, computeLibraryMembership, flatLibraryIssues, materializeLibrary, mergePackages, rawFileNameOfPath, typesForFileName } from '../core/index.js';
+import { collectAllReferences, compareCodeUnits, computeLibraryMembership, rawFileNameOfPath, typesForFileName, validateDependencies } from '../core/index.js';
 import { loadConfig, USAGE_NOT_CONFIGURED_MESSAGE } from './config-loader.js';
 import { LibraryStore } from './library-store.js';
 import { classifyRawDirectory } from './raw-reconciliation.js';
-import { buildManifestEntries, manifestModuleCollisionIssues, manifestModuleFileName, renderManifestModule, strayGeneratedModuleNames } from './codegen.js';
+import { buildManifestEntries, manifestModuleFileName, renderManifestModule, strayGeneratedModuleNames } from './codegen.js';
 import { descriptorsByType, serverPluginsByType } from './plugins.js';
-import { expectedProxyRelativePath, isProxyFileName, readCurrentProxy } from './processing/processor.js';
+import { deliveredAssetIds, expectedProxyRelativePath, isProxyFileName, readCurrentProxy } from './processing/processor.js';
 import { listRelativeFiles } from './folder-filesystem.js';
 import { ImageDuplicateDetector } from './image-duplicates.js';
 /** The human rendering of a finding — `[assetId] message`, as `fundus check` prints it. */
@@ -26,47 +26,18 @@ export function formatCheckFinding(finding) {
 export async function runCheck(projectRoot, registry = serverPluginsByType) {
     const config = await loadConfig(projectRoot);
     const store = new LibraryStore(config, registry);
-    const host = await store.read();
-    // Merge Packages under the host into one in-memory effective library. Raw
-    // scans stay on the host (it owns the bytes); everything id-space runs over
-    // the effective library; processing/codegen run over the materialized subset.
-    const { library: effective, provenance, findings: mergeFindings } = mergePackages(host, config.packages ?? []);
-    const materialized = materializeLibrary(effective);
+    const library = await store.read();
     const report = {
         errors: [],
         warnings: [],
         advisories: config.usage === null
             ? [{ kind: 'usage-not-configured', message: USAGE_NOT_CONFIGURED_MESSAGE }]
             : [],
-        assetCount: Object.keys(effective.assets).length,
-        manifestCount: Object.keys(effective.manifests).length
+        assetCount: Object.keys(library.assets).length,
+        manifestCount: Object.keys(library.manifests).length
     };
-    // Merge findings: collisions/type-mismatches are hard errors; an active
-    // override is an auditable, non-fatal advisory.
-    for (const finding of mergeFindings) {
-        if (finding.kind === 'package-overridden') {
-            report.advisories.push({
-                kind: 'package-overridden',
-                message: finding.message,
-                assetId: finding.assetId
-            });
-        }
-        else {
-            report.errors.push({
-                kind: finding.kind,
-                message: finding.message,
-                assetId: finding.assetId
-            });
-        }
-    }
-    // 1. Library validation. Disk/host checks run on the host library; flat-space
-    // checks (id/type/parameters/membership/appearance/references + module
-    // collisions) run over the effective library.
-    const issues = [
-        ...(await store.validate(host, { flatSpace: false })),
-        ...flatLibraryIssues(effective, descriptorsByType(registry)),
-        ...manifestModuleCollisionIssues(effective.manifests)
-    ];
+    // 1. Library validation (structure, parameters, raw pointers, references).
+    const issues = await store.validate(library);
     const validationKeys = new Set();
     for (const issue of issues) {
         const key = `${issue.assetId ?? ''}|${issue.message}`;
@@ -79,25 +50,26 @@ export async function runCheck(projectRoot, registry = serverPluginsByType) {
             ...(issue.assetId !== undefined ? { assetId: issue.assetId } : {})
         });
     }
+    // Declared dependencies the host library must satisfy (a hard error, but kept
+    // out of `store.validate` so it never gates processing/codegen).
+    for (const finding of validateDependencies(config.dependencies, library)) {
+        report.errors.push({
+            kind: 'validation',
+            message: finding.message,
+            ...(finding.assetId !== undefined ? { assetId: finding.assetId } : {})
+        });
+    }
     const descriptors = Object.values(registry).map((plugin) => plugin.descriptor);
-    const raw = await classifyRawDirectory(config.rawDir, host, (path) => typesForFileName(path, descriptors).length > 0);
-    report.errors.push(...rawCheckFindings(host, raw, registry, issues));
-    // Delivered set + membership over the effective library, so delivered slots
-    // are analysed and cross-Package references resolve.
-    const referencesByAsset = collectAllReferences(effective, descriptorsByType(registry));
-    const membership = computeLibraryMembership(effective, referencesByAsset);
-    const delivered = allDeliveredAssetIds(membership);
-    report.errors.push(...packageSlotFindings(effective, provenance, membership));
+    const raw = await classifyRawDirectory(config.rawDir, library, (path) => typesForFileName(path, descriptors).length > 0);
+    report.errors.push(...rawCheckFindings(library, raw, registry, issues));
     // 2. Proxies: every delivered asset's expected proxy exists (staleness is a
-    // name check), and the proxy directory holds no orphans. Raw-less delivered
-    // slots are covered by the slot findings above and skipped here.
+    // name check), and the proxy directory holds no orphans.
+    const delivered = deliveredAssetIds(library, registry);
     const expectedProxyPaths = new Set();
     const proxies = {};
     let proxiesComplete = true;
     for (const assetId of [...delivered].sort(compareCodeUnits)) {
-        const record = materialized.assets[assetId];
-        if (!record)
-            continue;
+        const record = library.assets[assetId];
         let proxy;
         try {
             proxy = await readCurrentProxy(assetId, record, config, registry);
@@ -145,12 +117,12 @@ export async function runCheck(projectRoot, registry = serverPluginsByType) {
     // regeneration. Only meaningful when validation passed and every proxy
     // exists — otherwise regeneration is impossible and already reported.
     if (report.errors.length === 0 && proxiesComplete) {
-        await checkGeneratedModules(report, materialized, config, proxies, registry);
-        await checkStrayModules(report, materialized, config);
+        await checkGeneratedModules(report, library, config, proxies, registry);
+        await checkStrayModules(report, library, config);
     }
     // 4. Advisory warnings. Raw drift is always a hard CI failure.
-    collectUnreachableAssets(report, effective, provenance, delivered);
-    collectPotentialImageDuplicates(report, await new ImageDuplicateDetector().find(host, config.rawDir));
+    collectUnreachableAssets(report, library, delivered);
+    collectPotentialImageDuplicates(report, await new ImageDuplicateDetector().find(library, config.rawDir));
     report.errors.sort((left, right) => compareCodeUnits(`${left.fileName ?? ''}|${left.assetId ?? ''}|${left.kind}|${left.message}`, `${right.fileName ?? ''}|${right.assetId ?? ''}|${right.kind}|${right.message}`));
     report.warnings.sort((left, right) => compareCodeUnits(`${left.assetId ?? ''}|${left.kind}|${left.message}`, `${right.assetId ?? ''}|${right.kind}|${right.message}`));
     return report;
@@ -291,66 +263,15 @@ async function checkStrayModules(report, library, config) {
  * no explicit membership AND no passive membership in any manifest. An asset
  * that is only passively delivered (referenced by a delivered asset) is fine.
  */
-function collectUnreachableAssets(report, library, provenance, delivered) {
-    for (const [assetId, record] of Object.entries(library.assets)) {
-        if (record.manifests.length !== 0 || delivered.has(assetId))
-            continue;
-        // An inert, unfilled Package slot is not a host mistake — a Package ships
-        // a superset of slots and the app delivers a subset. Only host/override
-        // assets (and filled slots) warn.
-        if (record.raw === undefined && provenance[assetId]?.source === 'package')
-            continue;
-        report.warnings.push({
-            kind: 'unreachable-asset',
-            message: 'In no manifest and not referenced by any delivered asset — ' +
-                'nothing is processed or generated for it.',
-            assetId
-        });
-    }
-}
-/**
- * The delivered-slot contract: a Package slot that is delivered (explicit member
- * or in a delivered manifest's reference closure) but has no host-supplied bytes
- * must be filled. A slot with an `importSource` is `slot-unmaterialized` (run
- * import); a slot with nothing is `slot-unfilled`. Inert (undelivered) slots
- * produce no finding.
- */
-export function packageSlotFindings(library, provenance, membership) {
-    const deliveringManifests = new Map();
-    for (const [name, manifestMembership] of Object.entries(membership)) {
-        for (const assetId of manifestMembership.deliveredAssetIds) {
-            const names = deliveringManifests.get(assetId) ?? [];
-            names.push(name);
-            deliveringManifests.set(assetId, names);
-        }
-    }
-    const findings = [];
+function collectUnreachableAssets(report, library, delivered) {
     for (const [assetId, record] of Object.entries(library.assets)) {
-        if (record.raw !== undefined)
-            continue;
-        const names = deliveringManifests.get(assetId);
-        if (!names || names.length === 0)
-            continue;
-        const originRecord = provenance[assetId];
-        const origin = originRecord && originRecord.source !== 'host' ? originRecord.origin : 'a package';
-        const deliveredBy = [...names]
-            .sort(compareCodeUnits)
-            .map((name) => `"${name}"`)
-            .join(', ');
-        if (record.importSource !== undefined) {
-            findings.push({
-                kind: 'slot-unmaterialized',
-                assetId,
-                message: `Slot "${assetId}" (from ${origin}) has an import source but no bytes yet — run import to fill it. Delivered by: ${deliveredBy}.`
-            });
-        }
-        else {
-            findings.push({
-                kind: 'slot-unfilled',
-                assetId,
-                message: `Slot "${assetId}" (from ${origin}) has no bytes, import source, or host override. Delivered by: ${deliveredBy}.`
+        if (record.manifests.length === 0 && !delivered.has(assetId)) {
+            report.warnings.push({
+                kind: 'unreachable-asset',
+                message: 'In no manifest and not referenced by any delivered asset — ' +
+                    'nothing is processed or generated for it.',
+                assetId
             });
         }
     }
-    return findings;
 }

package/dist/server/codegen.d.ts

@@ -1,4 +1,4 @@
-import { type AssetRecord, type Library, type ManifestEntry, type ManifestEntryData, type ManifestMembership, type ManifestName, type ManifestRecord, type ReferencesByAsset, type ValidationIssueDto } from '../core/index.js';
+import { type AssetRecord, type Library, type ManifestEntry, type ManifestEntryData, type ManifestMembership, type ReferencesByAsset } from '../core/index.js';
 import type { SourceLocation } from '../core/index.js';
 import type { ResolvedFundusConfig } from './config-loader.js';
 import type { ServerPluginRegistry } from './plugins/contract.js';
@@ -10,8 +10,6 @@ export declare function locateGeneratedAssetDeclaration(file: string, source: st
 export declare function kebabCaseFromCamel(name: string): string;
 /** Generated module file name for a manifest. */
 export declare function manifestModuleFileName(manifestName: string): string;
-/** Two manifest names that would generate the same kebab-case module file. */
-export declare function manifestModuleCollisionIssues(manifests: Record<ManifestName, ManifestRecord>): ValidationIssueDto[];
 /**
  * Build the entry data codegen emits for one asset — delegated to
  * the owning server plugin's `buildManifestEntry`. Reference fields