fundus 0.0.2 → 0.0.3

package/dist/runtime/observe-border-box-size.js

@@ -1,12 +1,11 @@
-//#region src/observe-border-box-size.ts
 /** Observe an element's layout border-box size in whole CSS pixels. */
-function observeBorderBoxSize(element, onSize) {
-	const observer = new ResizeObserver((entries) => {
-		const size = entries[0]?.borderBoxSize?.[0];
-		onSize(Math.round(size?.inlineSize ?? element.offsetWidth), Math.round(size?.blockSize ?? element.offsetHeight));
-	});
-	observer.observe(element);
-	return () => observer.disconnect();
+export function observeBorderBoxSize(element, onSize) {
+    const observer = new ResizeObserver((entries) => {
+        // Measure layout, not getBoundingClientRect(): transforms must not freeze
+        // render geometry after an animation because they do not retrigger resize.
+        const size = entries[0]?.borderBoxSize?.[0];
+        onSize(Math.round(size?.inlineSize ?? element.offsetWidth), Math.round(size?.blockSize ?? element.offsetHeight));
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
 }
-//#endregion
-export { observeBorderBoxSize };

package/dist/runtime/preload-registry.d.ts

@@ -1,6 +1,22 @@
-import { PreloadOptions } from "#fundus/core";
-
-//#region src/preload-registry.d.ts
+/**
+ * The module-wide refcounted source registry: one entry per
+ * URL — reference count, in-flight promise, loaded handler resources.
+ *
+ * Guarantees:
+ * - **Once-per-URL fetches across manifests, all kinds** — a URL in flight or
+ *   loaded is never fetched again while held, including image and slice.
+ * - **The reference count counts holding manifests, not calls** — each
+ *   `Manifest` acquires a URL at most once per hold (its held-URL set guards
+ *   idempotent `preload()` calls).
+ * - **Release at zero disposes via the kind handler** — the object URL is
+ *   revoked and the entry cleared, so releasing one of two holders keeps the
+ *   resource fully alive for the other, and a released URL can be re-acquired
+ *   with a fresh fetch.
+ * - **No leak on release-during-in-flight** — dropping the last hold while
+ *   the fetch is still running lets the acquisition complete, then disposes
+ *   immediately (no cancellation, no throw).
+ */
+import type { PreloadOptions } from '../core/index.js';
 /**
  * Acquire one hold on `url` for a manifest: increments the reference count
  * immediately, then loads via the kind handler unless the URL is already
@@ -8,19 +24,17 @@ import { PreloadOptions } from "#fundus/core";
  * load clears the in-flight state so the URL stays retryable; the caller
  * rolls back its own hold via `releaseSource`.
  */
-declare function acquireSource(url: string, kind: string, options: PreloadOptions): Promise<void>;
+export declare function acquireSource(url: string, kind: string, options: PreloadOptions): Promise<void>;
 /**
  * Drop one hold on `url`. At zero holds the kind handler's release strategy
  * runs (object URL revoked) and the entry is cleared — unless the load is
  * still in flight, in which case its completion disposes. Releasing an
  * unknown URL is a no-op.
  */
-declare function releaseSource(url: string): void;
+export declare function releaseSource(url: string): void;
 /**
  * The retained object URL of a source while some manifest holds it, or the
  * source itself when not (or no longer) preloaded — after a full release a
  * consumer falls back to the network URL and simply streams.
  */
-declare function resolveRetainedSource(url: string): string;
-//#endregion
-export { acquireSource, releaseSource, resolveRetainedSource };
+export declare function resolveRetainedSource(url: string): string;

package/dist/runtime/preload-registry.js

@@ -1,68 +1,71 @@
-import { runtimeHandlerFor } from "./kind-handlers.js";
-//#region src/preload-registry.ts
-const registryByUrl = /* @__PURE__ */ new Map();
+import { runtimeHandlerFor } from './kind-handlers.js';
+const registryByUrl = new Map();
 /**
-* Acquire one hold on `url` for a manifest: increments the reference count
-* immediately, then loads via the kind handler unless the URL is already
-* loaded (resolves at once) or in flight (joins the pending load). A failed
-* load clears the in-flight state so the URL stays retryable; the caller
-* rolls back its own hold via `releaseSource`.
-*/
-function acquireSource(url, kind, options) {
-	let entry = registryByUrl.get(url);
-	if (!entry) {
-		entry = {
-			kind,
-			referenceCount: 0,
-			pending: null,
-			resources: null
-		};
-		registryByUrl.set(url, entry);
-	}
-	entry.referenceCount += 1;
-	if (entry.resources !== null) return Promise.resolve();
-	let pending = entry.pending;
-	if (!pending) {
-		const acquired = entry;
-		pending = runtimeHandlerFor(kind).preload(url, options).then((resources) => {
-			acquired.pending = null;
-			if (acquired.referenceCount === 0) {
-				runtimeHandlerFor(acquired.kind).release?.(resources);
-				registryByUrl.delete(url);
-				return;
-			}
-			acquired.resources = resources;
-		}, (cause) => {
-			acquired.pending = null;
-			if (acquired.referenceCount === 0) registryByUrl.delete(url);
-			throw cause;
-		});
-		acquired.pending = pending;
-	}
-	return pending;
+ * Acquire one hold on `url` for a manifest: increments the reference count
+ * immediately, then loads via the kind handler unless the URL is already
+ * loaded (resolves at once) or in flight (joins the pending load). A failed
+ * load clears the in-flight state so the URL stays retryable; the caller
+ * rolls back its own hold via `releaseSource`.
+ */
+export function acquireSource(url, kind, options) {
+    let entry = registryByUrl.get(url);
+    if (!entry) {
+        entry = { kind, referenceCount: 0, pending: null, resources: null };
+        registryByUrl.set(url, entry);
+    }
+    entry.referenceCount += 1;
+    if (entry.resources !== null)
+        return Promise.resolve();
+    let pending = entry.pending;
+    if (!pending) {
+        const acquired = entry;
+        pending = runtimeHandlerFor(kind)
+            .preload(url, options)
+            .then((resources) => {
+            acquired.pending = null;
+            if (acquired.referenceCount === 0) {
+                // Every holder released while the fetch was in flight:
+                // dispose immediately — no leak, no throw.
+                runtimeHandlerFor(acquired.kind).release?.(resources);
+                registryByUrl.delete(url);
+                return;
+            }
+            acquired.resources = resources;
+        }, (cause) => {
+            acquired.pending = null;
+            if (acquired.referenceCount === 0)
+                registryByUrl.delete(url);
+            throw cause;
+        });
+        acquired.pending = pending;
+    }
+    return pending;
 }
 /**
-* Drop one hold on `url`. At zero holds the kind handler's release strategy
-* runs (object URL revoked) and the entry is cleared — unless the load is
-* still in flight, in which case its completion disposes. Releasing an
-* unknown URL is a no-op.
-*/
-function releaseSource(url) {
-	const entry = registryByUrl.get(url);
-	if (!entry) return;
-	if (entry.referenceCount > 0) entry.referenceCount -= 1;
-	if (entry.referenceCount > 0) return;
-	if (entry.pending) return;
-	if (entry.resources !== null) runtimeHandlerFor(entry.kind).release?.(entry.resources);
-	registryByUrl.delete(url);
+ * Drop one hold on `url`. At zero holds the kind handler's release strategy
+ * runs (object URL revoked) and the entry is cleared — unless the load is
+ * still in flight, in which case its completion disposes. Releasing an
+ * unknown URL is a no-op.
+ */
+export function releaseSource(url) {
+    const entry = registryByUrl.get(url);
+    if (!entry)
+        return;
+    if (entry.referenceCount > 0)
+        entry.referenceCount -= 1;
+    if (entry.referenceCount > 0)
+        return;
+    if (entry.pending)
+        return;
+    if (entry.resources !== null)
+        runtimeHandlerFor(entry.kind).release?.(entry.resources);
+    registryByUrl.delete(url);
 }
 /**
-* The retained object URL of a source while some manifest holds it, or the
-* source itself when not (or no longer) preloaded — after a full release a
-* consumer falls back to the network URL and simply streams.
-*/
-function resolveRetainedSource(url) {
-	return registryByUrl.get(url)?.resources?.objectUrl ?? url;
+ * The retained object URL of a source while some manifest holds it, or the
+ * source itself when not (or no longer) preloaded — after a full release a
+ * consumer falls back to the network URL and simply streams.
+ */
+export function resolveRetainedSource(url) {
+    return registryByUrl.get(url)?.resources?.objectUrl ?? url;
 }
-//#endregion
-export { acquireSource, releaseSource, resolveRetainedSource };

package/dist/server/build.d.ts

@@ -0,0 +1,8 @@
+import { type ProcessingReport } from './processing/processor.js';
+import { type CodegenReport } from './codegen.js';
+import type { ServerPluginRegistry } from './plugins/contract.js';
+export interface BuildReport {
+    processing: ProcessingReport;
+    codegen: CodegenReport;
+}
+export declare function runBuild(projectRoot: string, registry?: ServerPluginRegistry): Promise<BuildReport>;

package/dist/server/build.js

@@ -0,0 +1,25 @@
+/**
+ * `fundus build` — headless pipeline run: validate the library, process all
+ * stale/missing proxies, prune orphans, regenerate every manifest module.
+ * Throws on validation errors (the CLI exits non-zero).
+ */
+import { loadConfig } from './config-loader.js';
+import { LibraryStore } from './library-store.js';
+import { processAssets } from './processing/processor.js';
+import { generateManifestModules } from './codegen.js';
+import { serverPluginsByType } from './plugins.js';
+import { formatCheckFinding } from './check.js';
+export async function runBuild(projectRoot, registry = serverPluginsByType) {
+    const config = await loadConfig(projectRoot);
+    const store = new LibraryStore(config, registry);
+    const library = await store.read();
+    await store.syncFolders(library);
+    const issues = await store.validate(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')}`);
+    }
+    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

@@ -0,0 +1,24 @@
+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' | 'raw-hash-drift';
+    message: string;
+    /** The asset the finding concerns, where applicable. */
+    assetId?: string;
+    /** The manifest whose generated module the finding concerns, where applicable. */
+    manifest?: string;
+    /** The concrete file (proxy or generated module), where applicable. */
+    fileName?: string;
+}
+/** The human rendering of a finding — `[assetId] message`, as `fundus check` prints it. */
+export declare function formatCheckFinding(finding: CheckFinding): string;
+export interface CheckReport {
+    /** Hard failures — always fatal. */
+    errors: CheckFinding[];
+    /** Advisory findings — fatal unless the caller allows warnings. */
+    warnings: CheckFinding[];
+    assetCount: number;
+    manifestCount: number;
+}
+export declare function runCheck(projectRoot: string, registry?: ServerPluginRegistry): Promise<CheckReport>;

package/dist/server/check.js

@@ -0,0 +1,199 @@
+/**
+ * `fundus check` — the verify-only CI gate: no writes, ever. It
+ * fails when the library does not validate, when a committed proxy is stale,
+ * missing, or orphaned, or when a generated manifest module differs from an
+ * in-memory regeneration. Warnings (unreachable asset, raw-hash drift) are
+ * treated as errors unless `--allow-warnings` downgrades them — errors are
+ * never downgradable.
+ */
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { collectAllReferences, compareCodeUnits, computeLibraryMembership, rawFileNameOfPath } from '../core/index.js';
+import { loadConfig } from './config-loader.js';
+import { LibraryStore, sha256Hex } from './library-store.js';
+import { buildManifestEntries, manifestModuleFileName, renderManifestModule, strayGeneratedModuleNames } from './codegen.js';
+import { descriptorsByType, serverPluginsByType } from './plugins.js';
+import { deliveredAssetIds, expectedProxyRelativePath, isProxyFileName, readCurrentProxy } from './processing/processor.js';
+import { listRelativeFiles } from './folder-filesystem.js';
+/** The human rendering of a finding — `[assetId] message`, as `fundus check` prints it. */
+export function formatCheckFinding(finding) {
+    return `${finding.assetId ? `[${finding.assetId}] ` : ''}${finding.message}`;
+}
+export async function runCheck(projectRoot, registry = serverPluginsByType) {
+    const config = await loadConfig(projectRoot);
+    const store = new LibraryStore(config, registry);
+    const library = await store.read();
+    const report = {
+        errors: [],
+        warnings: [],
+        assetCount: Object.keys(library.assets).length,
+        manifestCount: Object.keys(library.manifests).length
+    };
+    // 1. Library validation (structure, parameters, raw pointers, references).
+    const issues = await store.validate(library);
+    for (const issue of issues) {
+        report.errors.push({
+            kind: 'validation',
+            message: issue.message,
+            ...(issue.assetId !== undefined ? { assetId: issue.assetId } : {})
+        });
+    }
+    // 2. Proxies: every delivered asset's expected proxy exists (staleness is a
+    // 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 = library.assets[assetId];
+        let proxy;
+        try {
+            proxy = await readCurrentProxy(assetId, record, config, registry);
+        }
+        catch (cause) {
+            if (!issues.some((issue) => issue.assetId === assetId)) {
+                report.errors.push({
+                    kind: 'proxy-unresolvable',
+                    message: cause instanceof Error ? cause.message : String(cause),
+                    assetId
+                });
+            }
+            proxiesComplete = false;
+            continue;
+        }
+        if (!proxy) {
+            const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+            expectedProxyPaths.add(relativePath);
+            report.errors.push({
+                kind: 'proxy-missing',
+                message: `Proxy "${relativePath}" is missing or stale — run \`fundus build\` and commit the result.`,
+                assetId,
+                fileName: relativePath
+            });
+            proxiesComplete = false;
+            continue;
+        }
+        expectedProxyPaths.add(proxy.relativePath);
+        proxies[assetId] = proxy;
+    }
+    if (existsSync(config.proxyDir)) {
+        for (const relativePath of (await listRelativeFiles(config.proxyDir)).sort()) {
+            if (!isProxyFileName(rawFileNameOfPath(relativePath)) ||
+                expectedProxyPaths.has(relativePath)) {
+                continue;
+            }
+            report.errors.push({
+                kind: 'proxy-orphaned',
+                message: `Orphaned proxy "${relativePath}" — no asset expects it; run \`fundus build\` and commit the result.`,
+                fileName: relativePath
+            });
+        }
+    }
+    // 3. Generated manifest modules must be byte-identical to an in-memory
+    // regeneration. Only meaningful when validation passed and every proxy
+    // exists — otherwise regeneration is impossible and already reported.
+    if (issues.length === 0 && proxiesComplete) {
+        await checkGeneratedModules(report, library, config, proxies, registry);
+        await checkStrayModules(report, library, config);
+    }
+    // 4. Warnings: unreachable assets, raw-hash drift.
+    collectUnreachableAssets(report, library, delivered);
+    await collectRawHashDrift(report, library, config);
+    return report;
+}
+async function checkGeneratedModules(report, library, config, proxies, registry) {
+    const referencesByAsset = collectAllReferences(library, descriptorsByType(registry));
+    const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
+    for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
+        const fileName = manifestModuleFileName(manifestName);
+        const modulePath = join(config.manifestsDir, fileName);
+        let expectedContent;
+        try {
+            expectedContent = renderManifestModule(manifestName, buildManifestEntries({
+                membership: membershipByManifest[manifestName],
+                library,
+                proxies,
+                config,
+                referencesByAsset,
+                registry
+            }));
+        }
+        catch (cause) {
+            report.errors.push({
+                kind: 'module-regeneration-failed',
+                message: `Cannot regenerate module "${fileName}": ${cause instanceof Error ? cause.message : String(cause)}`,
+                manifest: manifestName,
+                fileName
+            });
+            continue;
+        }
+        if (!existsSync(modulePath)) {
+            report.errors.push({
+                kind: 'module-missing',
+                message: `Generated module "${fileName}" is missing — run \`fundus build\` and commit the result.`,
+                manifest: manifestName,
+                fileName
+            });
+            continue;
+        }
+        const currentContent = await readFile(modulePath, 'utf8');
+        if (currentContent !== expectedContent) {
+            report.errors.push({
+                kind: 'module-out-of-sync',
+                message: `Generated module "${fileName}" is out of sync with the library — run \`fundus build\` and commit the result.`,
+                manifest: manifestName,
+                fileName
+            });
+        }
+    }
+}
+async function checkStrayModules(report, library, config) {
+    const expectedFileNames = new Set(Object.keys(library.manifests).map((manifestName) => manifestModuleFileName(manifestName)));
+    for (const fileName of await strayGeneratedModuleNames(config.manifestsDir, expectedFileNames)) {
+        report.errors.push({
+            kind: 'module-stray',
+            message: `Stray generated module "${fileName}" — its manifest no longer exists; run \`fundus build\`.`,
+            fileName
+        });
+    }
+}
+/**
+ * The unreachable-asset warning: fires only when nothing delivers the asset —
+ * 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, delivered) {
+    for (const [assetId, record] of Object.entries(library.assets)) {
+        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
+            });
+        }
+    }
+}
+/**
+ * Raw-hash drift: a raw file replaced on disk while the library still pins the
+ * old content hash. The proxy name derives from the *recorded* hash, so the
+ * name check alone would keep passing while the delivered pixels are outdated.
+ */
+async function collectRawHashDrift(report, library, config) {
+    for (const [assetId, record] of Object.entries(library.assets)) {
+        const rawPath = join(config.rawDir, record.raw);
+        if (!existsSync(rawPath))
+            continue; // A missing raw file is a validation error already.
+        const currentHash = sha256Hex(new Uint8Array(await readFile(rawPath)));
+        if (currentHash !== record.rawHash) {
+            report.warnings.push({
+                kind: 'raw-hash-drift',
+                message: `Raw file "${record.raw}" changed since it was ingested (hash drift) — ` +
+                    `re-ingest or update it through the editor, then run \`fundus build\`.`,
+                assetId,
+                fileName: record.raw
+            });
+        }
+    }
+}

package/dist/server/cli-commands.d.ts

@@ -0,0 +1,25 @@
+export declare const STATE_HELP = "fundus state \u2014 the full project state in one document\n\nUsage: fundus state [--json]\n\nThe agent's one-stop overview: every asset (type, raw file, parameters,\nexplicit + passive manifest memberships, proxy status, reference edges,\nwarnings), every manifest (members, delivered bytes), library-level\nvalidation issues, and the available preset names per asset type.\n\nFlags:\n  --json   print {\"ok\": true, \"state\": <FundusStateDto>} on stdout\n  --help   this help\n\nRead-only: nothing is processed or written.\n\nExample:\n  fundus state --json | jq '.state.assets[].id'\n";
+export declare function runStateCommand(argumentList: string[]): Promise<void>;
+export declare const ASSET_HELP = "fundus asset \u2014 inspect and mutate assets\n\nUsage: fundus asset <subcommand> \u2026\n\nEvery mutation runs the full editor autosave chain: write library \u2192\nprocess affected assets \u2192 regenerate manifest modules. There is no\nseparate apply/sync step. All subcommands accept --json (a single JSON\ndocument on stdout) and --help.\n\nSubcommands:\n  list      list assets (--manifest, --type, --warnings-only)\n  show      one asset in detail\n  ingest    copy a file into the raw dir as a typed asset\n  set       merge parameters and/or replace manifest membership\n  rename    rename an asset id\n  move      move an asset to a folder or root\n  delete    delete an asset (record, raw file, proxies)\n\nRun `fundus asset <subcommand> --help` for the focused page (flags,\nsemantics, an example) \u2014 e.g. `fundus asset set --help` documents the\n--parameters merge rules.\n";
+export declare const ASSET_LIST_HELP: string;
+export declare const ASSET_SHOW_HELP = "fundus asset show \u2014 one asset in detail\n\nUsage: fundus asset show <id> [--json]\n\nPrints the asset's raw file, content hash, parameters, explicit +\npassive manifest memberships, proxy status, reference edges (outgoing\nand incoming), and warnings.\n\nFlags:\n  --json   print {\"ok\": true, \"asset\": <AssetStateDto>}\n  --help   this help\n\nRead-only: nothing is processed or written.\n\nExample:\n  fundus asset show navigationPanel --json\n";
+export declare const ASSET_INGEST_HELP: string;
+export declare const ASSET_SET_HELP = "fundus asset set \u2014 update an asset's parameters and/or memberships\n\nUsage: fundus asset set <id> [--parameters <json>] [--manifests <a,b>] [--json]\n\nAt least one of --parameters/--manifests is required. Runs the full\nautosave chain (write library \u2192 process \u2192 regenerate manifest modules).\n\nFlags:\n  --parameters <json>  SHALLOW MERGE at the top level onto the current\n                       parameters, then plugin validation:\n                         {\"preset\": \"webp-hq\"}        sets one field,\n                                                      keeps the others\n                         {\"chromaKey\": {\u2026}}           replaces the whole\n                                                      chromaKey object\n                         {\"mask\": null}               clears an optional\n                                                      field\n                         {\"mask\": {\"$asset\": \"someImage\"}}\n                                                      sets an asset\n                                                      reference\n  --manifests <a,b>    REPLACES the explicit membership set (declarative,\n                       idempotent); --manifests \"\" clears it\n  --json               print {\"ok\": true, \"asset\": <AssetStateDto>, \"issues\": [\u2026]}\n  --help               this help\n\nThe mutation is validated first and rejected (exit 1, nothing written)\nif it would leave the library invalid \u2014 e.g. a reference to a missing\nasset, a reference cycle, or an unknown manifest name. Ingest reference\ntargets before pointing at them.\n\nExample:\n  fundus asset set characterIdle \\\n    --parameters '{\"mask\": {\"$asset\": \"characterIdleMask\"}}' --json\n";
+export declare const ASSET_RENAME_HELP = "fundus asset rename \u2014 rename an asset id\n\nUsage: fundus asset rename <id> <newId> [--json]\n\nRenames the asset's id (the raw file keeps its name \u2014 ids are the\nstable key) and re-hashes its proxy under the new id via the autosave\nchain. Fails if another asset references <id> \u2014 update the referrers\nfirst \u2014 or if <newId> is taken or invalid.\n\nFlags:\n  --json   print {\"ok\": true, \"asset\": <AssetStateDto>, \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus asset rename sidebarPanel navigationPanel --json\n";
+export declare const ASSET_DELETE_HELP = "fundus asset delete \u2014 delete an asset\n\nUsage: fundus asset delete <id> [--json]\n\nDeletes the library record, its raw file, and its proxies, then\nregenerates the affected manifest modules. Fails if another asset\nreferences it \u2014 remove the references first.\n\nFlags:\n  --json   print {\"ok\": true, \"deletedAssetId\": \"<id>\", \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus asset delete obsoleteBanner --json\n";
+export declare const ASSET_MOVE_HELP = "fundus asset move \u2014 move an asset between folders\n\nUsage: fundus asset move <id> <folder|root> [--json]\n\nMoves the raw file and its current proxy without changing the stable asset id,\nthen runs the autosave chain. The destination folder must already exist; use\nthe literal \"root\" for the implicit root.\n\nFlags:\n  --json   print {\"ok\": true, \"asset\": <AssetStateDto>, \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus asset move navigationPanel \"UI/Buttons\" --json\n";
+export declare function runAssetCommand(argumentList: string[]): Promise<void>;
+export declare const FOLDER_HELP = "fundus folder \u2014 manage the mirrored raw/proxy folder tree\n\nUsage: fundus folder <subcommand> \u2026\n\nSubcommands:\n  list      list registered folders and their direct assets\n  create    create a persisted folder (fundus folder create <path>)\n  rename    rename one folder segment and its subtree\n  move      move a complete folder subtree below another folder\n  delete    recursively delete a folder subtree and its assets\n\nAll mutations update rawDir and proxyDir together, maintain .gitkeep files,\nand run the full autosave chain. All subcommands accept --json and --help.\n";
+export declare function runFolderCommand(argumentList: string[]): Promise<void>;
+export declare const MANIFEST_HELP = "fundus manifest \u2014 manage manifests (delivery units & preload groups)\n\nUsage: fundus manifest <subcommand> \u2026\n\nA manifest is a delivery unit and a preload group: only assets in at\nleast one manifest (explicitly, or passively via the reference closure)\nare processed into proxies and reachable from host code. Assets join and\nleave manifests via `fundus asset set <id> --manifests <a,b>`. All\nsubcommands accept --json and --help.\n\nSubcommands:\n  list      list manifests with members and delivered bytes\n  create    create an empty manifest (fundus manifest create <name>)\n  set       set a manifest's editor color / emoji appearance\n  palette   list the selectable appearance colors and emojis\n  rename    rename a manifest (fundus manifest rename <name> <newName>)\n  delete    delete a manifest and strip its memberships\n\nRun `fundus manifest <subcommand> --help` for the focused page.\n";
+export declare const MANIFEST_LIST_HELP = "fundus manifest list \u2014 list manifests\n\nUsage: fundus manifest list [--json]\n\nOne line per manifest: name, delivered bytes (the preload-budget\nnumber, over the full delivery set), explicit members, and passive\nmembers (assets pulled in via the reference closure, with via-\nattribution in the JSON output).\n\nFlags:\n  --json   print {\"ok\": true, \"manifests\": [{\"name\", \"color\", \"emoji\",\n           \"explicitMemberIds\", \"passiveMembers\", \"deliveredBytes\"}, \u2026]}\n  --help   this help\n\nRead-only: nothing is processed or written.\n\nExample:\n  fundus manifest list --json\n";
+export declare const MANIFEST_CREATE_HELP = "fundus manifest create \u2014 create an empty manifest\n\nUsage: fundus manifest create <name> [--json]\n\n<name> must be a camelCase identifier; its kebab-case form names the\ngenerated module (mainCatalog \u2192 main-catalog.generated.ts). Mutations run\nthe autosave chain, so the module is generated immediately.\n\nFlags:\n  --json   print {\"ok\": true, \"manifest\": {\u2026}, \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus manifest create mainCatalog --json\n";
+export declare const MANIFEST_RENAME_HELP = "fundus manifest rename \u2014 rename a manifest\n\nUsage: fundus manifest rename <name> <newName> [--json]\n\n<newName> must be a camelCase identifier whose kebab-case form is\ndistinct from every other manifest's. The rename keeps the manifest's\nappearance, rewrites every asset's membership, and replaces the\ngenerated module (the old file is removed, the new one written). Host\ncode importing the module must be updated by hand \u2014 both the module\nfile name and the exported const change with the manifest name\n(mainCatalog \u2192 main-catalog.generated.ts / `mainCatalog`).\n\nFlags:\n  --json   print {\"ok\": true, \"manifest\": {\u2026}, \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus manifest rename mainCatalog primaryCatalog --json\n";
+export declare const MANIFEST_DELETE_HELP = "fundus manifest delete \u2014 delete a manifest\n\nUsage: fundus manifest delete <name> [--json]\n\nDeletes the manifest, strips it from every asset's membership, and\nremoves its generated module. Assets left in no manifest stop being\ndelivered (they warn as unreachable).\n\nFlags:\n  --json   print {\"ok\": true, \"deletedManifestName\": \"<name>\", \"issues\": [\u2026]}\n  --help   this help\n\nExample:\n  fundus manifest delete obsoleteShelf --json\n";
+export declare const MANIFEST_SET_HELP: string;
+export declare const MANIFEST_PALETTE_HELP = "fundus manifest palette \u2014 list the selectable appearance colors and emojis\n\nUsage: fundus manifest palette [--json]\n\nThe closed sets `fundus manifest set` validates against. Read this first\nto discover valid --color / --emoji values programmatically instead of\nguessing.\n\nFlags:\n  --json   print {\"ok\": true, \"colors\": [{\"name\", \"value\"}, \u2026], \"emojis\": [\u2026]}\n  --help   this help\n\nRead-only: nothing is processed or written.\n\nExample:\n  fundus manifest palette --json | jq '.emojis'\n";
+export declare function runManifestCommand(argumentList: string[]): Promise<void>;
+export declare const BUILD_HELP = "fundus build \u2014 run the headless pipeline\n\nUsage: fundus build [--json]\n\nValidates the library, processes every stale or missing proxy, prunes\norphaned proxies, and regenerates all manifest modules. Deterministic\nand idempotent: a second run on an unchanged project processes nothing\nand rewrites byte-identical modules. Run it in CI, postinstall, or\nbefore the host build; commit the result.\n\nFlags:\n  --json   print {\"ok\": true, \"processed\": [\u2026], \"upToDate\": [\u2026],\n           \"prunedProxies\": [\u2026], \"modulesWritten\": [\u2026],\n           \"modulesRemoved\": [\u2026]} \u2014 asset ids for processing,\n           file names for pruning/codegen\n  --help   this help\n\nA validation failure processes nothing and exits 1 (with --json:\n{\"error\": {\"message\": \u2026}}).\n\nExample:\n  fundus build --json | jq '.processed'\n";
+export declare function runBuildCommand(argumentList: string[]): Promise<void>;
+export declare const CHECK_HELP = "fundus check \u2014 verify the committed state (the CI gate)\n\nUsage: fundus check [--allow-warnings] [--json]\n\nVerify-only, no writes: the library must validate, every delivered\nasset's committed proxy must exist under its expected name (staleness\nis a name check), the proxy directory must hold no orphans, and every\ngenerated manifest module must be byte-identical to an in-memory\nregeneration. Warnings (unreachable asset, raw-hash drift) fail the\ncheck too unless --allow-warnings downgrades them; errors never\ndowngrade.\n\nFlags:\n  --allow-warnings   exit 0 despite warnings (errors still fail)\n  --json             print one report document:\n                     {\"ok\": <pass/fail>, \"assetCount\": \u2026, \"manifestCount\": \u2026,\n                      \"errors\": [<finding>, \u2026], \"warnings\": [<finding>, \u2026]}\n                     where a finding is {\"kind\", \"message\"} plus\n                     \"assetId\" / \"manifest\" / \"fileName\" where applicable\n  --help             this help\n\nExit codes: 0 = clean (or warnings allowed), 1 = failed. A failure to\neven run the check (e.g. no fundus.config.ts) exits 1 with the usual\n{\"error\": {\"message\": \u2026}} envelope under --json.\n\nExample:\n  fundus check --json | jq '.errors[].kind'\n";
+export declare function runCheckCommand(argumentList: string[]): Promise<void>;