fundus 0.0.2 → 0.0.3

package/dist/server/operations.d.ts

@@ -0,0 +1,87 @@
+import { type FundusStateDto, type PatchAssetRequestDto, type PatchManifestRequestDto } from '../core/index.js';
+import type { ResolvedFundusConfig } from './config-loader.js';
+import { LibraryStore, type IngestOptions } from './library-store.js';
+import type { ServerPluginRegistry } from './plugins/contract.js';
+/**
+ * The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
+ * level onto the current parameters — a nested object value replaces the whole
+ * current object under that key, a top-level `null` clears an optional field,
+ * and an asset reference is set with the normal `{"$asset": "<id>"}` marker.
+ * The merged result still passes the owning plugin's full validation.
+ */
+export declare function mergeParameterPatch(currentParameters: unknown, patch: unknown): Record<string, unknown>;
+/** A CLI-facing asset change: parameter patch and/or explicit membership set. */
+export interface AssetChangeOptions {
+    /** Shallow top-level parameter patch (see mergeParameterPatch). */
+    parametersPatch?: unknown;
+    /** Replacement for the explicit manifest membership set (declarative). */
+    manifests?: string[];
+}
+export declare class FundusOperations {
+    #private;
+    constructor(config: ResolvedFundusConfig, registry?: ServerPluginRegistry);
+    get config(): ResolvedFundusConfig;
+    get store(): LibraryStore;
+    /** Read-only state snapshot (no processing). */
+    state(): Promise<FundusStateDto>;
+    /**
+     * Ingest an upload: store the raw file + record, then let the owning
+     * plugin's optional `seedIngestParameters` derive better starting
+     * parameters from the stored raw file (slices: insets from the image
+     * dimensions, pixel ratio from the file name — the schema default can't
+     * know either). The CLI additionally applies a parameter patch and/or an
+     * explicit membership set in the same operation; a failing application
+     * rolls the whole ingest back, so a failed ingest leaves nothing behind.
+     */
+    ingest(options: IngestOptions & AssetChangeOptions): Promise<FundusStateDto>;
+    /** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
+    patchAsset(id: string, body: PatchAssetRequestDto): Promise<FundusStateDto>;
+    moveAsset(id: string, folder: string): Promise<FundusStateDto>;
+    /** Move a selected asset set as one editor action and roll back on any failure. */
+    moveAssets(assetIds: string[], folder: string): Promise<FundusStateDto>;
+    createFolder(path: string): Promise<FundusStateDto>;
+    renameFolder(path: string, newName: string): Promise<FundusStateDto>;
+    moveFolder(path: string, parent: string): Promise<FundusStateDto>;
+    deleteFolder(path: string): Promise<FundusStateDto>;
+    /**
+     * CLI-facing asset update (M7): shallow-merge a parameter patch and/or
+     * replace the explicit manifest membership — validating the *result* before
+     * anything is persisted, so a change that would leave the library invalid
+     * (dangling or cyclic reference, unknown manifest, invalid parameters) is
+     * rejected with nothing written. The REST `patchAsset` keeps the editor's
+     * lenient replace semantics.
+     */
+    setAsset(id: string, changes: AssetChangeOptions): Promise<FundusStateDto>;
+    /**
+     * CLI-facing rename (M7): rejects a rename that would break references —
+     * a referrer keeps pointing at the old id, so renaming a referenced asset
+     * introduces dangling-reference errors. Update the referrers first.
+     */
+    renameAsset(id: string, newId: string): Promise<FundusStateDto>;
+    /**
+     * Delete an asset: the record, its raw file, and its proxies. With
+     * `failOnIntroducedIssues` (the CLI), a delete that would break references
+     * (the asset is a reference target) is rejected before anything —
+     * including the raw file — is removed; the REST route stays lenient.
+     */
+    deleteAsset(id: string, options?: {
+        failOnIntroducedIssues?: boolean;
+    }): Promise<FundusStateDto>;
+    /** Delete a selected asset set as one lenient editor mutation. */
+    deleteAssets(assetIds: string[]): Promise<FundusStateDto>;
+    createManifest(name: string): Promise<FundusStateDto>;
+    setManifestAppearance(name: string, appearance: {
+        color?: string | null;
+        emoji?: string | null;
+    }): Promise<FundusStateDto>;
+    /** Apply a PATCH body: appearance fields and/or a rename — in that order. */
+    patchManifest(name: string, body: PatchManifestRequestDto): Promise<FundusStateDto>;
+    /**
+     * Rename a manifest: rewrites every asset's membership and replaces the
+     * generated module (the old one is pruned as a stray). Host code importing
+     * the module must be updated by hand — both the file name and the exported
+     * const change with the manifest name.
+     */
+    renameManifest(name: string, newName: string): Promise<FundusStateDto>;
+    deleteManifest(name: string): Promise<FundusStateDto>;
+}

package/dist/server/operations.js

@@ -0,0 +1,427 @@
+/**
+ * The one operations layer: builds the state payload and runs
+ * every mutation through the autosave chain — write library → process affected
+ * assets → regenerate codegen → return fresh state. Both the REST server
+ * and the CLI consume this class, so every
+ * operation has exactly one implementation and there is no other save path.
+ */
+import { join } from 'node:path';
+import { allDeliveredAssetIds, collectAllReferences, compareCodeUnits, computeLibraryMembership, folderOfRawPath, rawFileNameOfPath } from '../core/index.js';
+import { LibraryStore } from './library-store.js';
+import { generateManifestModules } from './codegen.js';
+import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
+import { processAssets, readCurrentProxy } from './processing/processor.js';
+import { encodeRelativePathForUrl } from './folder-filesystem.js';
+/**
+ * The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
+ * level onto the current parameters — a nested object value replaces the whole
+ * current object under that key, a top-level `null` clears an optional field,
+ * and an asset reference is set with the normal `{"$asset": "<id>"}` marker.
+ * The merged result still passes the owning plugin's full validation.
+ */
+export function mergeParameterPatch(currentParameters, patch) {
+    if (typeof patch !== 'object' || patch === null || Array.isArray(patch)) {
+        throw new Error('The parameter patch must be a JSON object, e.g. {"preset": "default"}.');
+    }
+    const merged = typeof currentParameters === 'object' &&
+        currentParameters !== null &&
+        !Array.isArray(currentParameters)
+        ? { ...currentParameters }
+        : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete merged[key];
+        }
+        else {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+export class FundusOperations {
+    #config;
+    #registry;
+    #store;
+    constructor(config, registry = serverPluginsByType) {
+        this.#config = config;
+        this.#registry = registry;
+        this.#store = new LibraryStore(config, registry);
+    }
+    get config() {
+        return this.#config;
+    }
+    get store() {
+        return this.#store;
+    }
+    /** Read-only state snapshot (no processing). */
+    async state() {
+        return this.#buildState(await this.#store.read(), []);
+    }
+    /**
+     * Ingest an upload: store the raw file + record, then let the owning
+     * plugin's optional `seedIngestParameters` derive better starting
+     * parameters from the stored raw file (slices: insets from the image
+     * dimensions, pixel ratio from the file name — the schema default can't
+     * know either). The CLI additionally applies a parameter patch and/or an
+     * explicit membership set in the same operation; a failing application
+     * rolls the whole ingest back, so a failed ingest leaves nothing behind.
+     */
+    async ingest(options) {
+        let library = await this.#store.ingest(options);
+        try {
+            const plugin = serverPluginForType(options.type, this.#registry);
+            if (plugin.seedIngestParameters) {
+                const record = library.assets[options.id];
+                const seeded = await plugin.seedIngestParameters({
+                    rawPath: join(this.#config.rawDir, record.raw),
+                    rawFileName: rawFileNameOfPath(record.raw),
+                    parameters: plugin.descriptor.validateParameters(record.parameters),
+                    config: this.#config
+                });
+                if (seeded !== undefined) {
+                    library = await this.#store.updateParameters(options.id, seeded);
+                }
+            }
+            if (options.parametersPatch !== undefined || options.manifests !== undefined) {
+                library = await this.#applyAssetChanges(library, options.id, {
+                    parametersPatch: options.parametersPatch,
+                    manifests: options.manifests
+                });
+            }
+        }
+        catch (cause) {
+            await this.#store.deleteAsset(options.id);
+            throw cause;
+        }
+        return this.#afterMutation(library);
+    }
+    /** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
+    async patchAsset(id, body) {
+        let library = await this.#store.read();
+        this.#requireAsset(library, id);
+        if (body.parameters !== undefined) {
+            library = await this.#store.updateParameters(id, body.parameters);
+        }
+        if (body.manifests !== undefined) {
+            if (!Array.isArray(body.manifests) ||
+                body.manifests.some((name) => typeof name !== 'string')) {
+                throw new Error('"manifests" must be an array of manifest names.');
+            }
+            library = await this.#store.setManifests(id, body.manifests);
+        }
+        if (body.renameTo !== undefined) {
+            if (typeof body.renameTo !== 'string') {
+                throw new Error('"renameTo" must be a string.');
+            }
+            library = await this.#store.renameAsset(id, body.renameTo);
+        }
+        if (body.folder !== undefined) {
+            if (typeof body.folder !== 'string')
+                throw new Error('"folder" must be a string.');
+            library = await this.#store.moveAsset(body.renameTo ?? id, body.folder);
+        }
+        return this.#afterMutation(library);
+    }
+    async moveAsset(id, folder) {
+        return this.#afterMutation(await this.#store.moveAsset(id, folder));
+    }
+    /** Move a selected asset set as one editor action and roll back on any failure. */
+    async moveAssets(assetIds, folder) {
+        const uniqueIds = [...new Set(assetIds)];
+        if (uniqueIds.length === 0)
+            throw new Error('At least one asset id is required.');
+        const originalFolders = new Map();
+        const library = await this.#store.read();
+        for (const id of uniqueIds) {
+            this.#requireAsset(library, id);
+            originalFolders.set(id, folderOfRawPath(library.assets[id].raw));
+        }
+        const movedIds = [];
+        try {
+            let updated = library;
+            for (const id of uniqueIds) {
+                if (originalFolders.get(id) === folder)
+                    continue;
+                updated = await this.#store.moveAsset(id, folder);
+                movedIds.push(id);
+            }
+            return this.#afterMutation(updated);
+        }
+        catch (cause) {
+            for (const id of movedIds.reverse()) {
+                await this.#store.moveAsset(id, originalFolders.get(id) ?? '');
+            }
+            throw cause;
+        }
+    }
+    async createFolder(path) {
+        return this.#afterMutation(await this.#store.createFolder(path));
+    }
+    async renameFolder(path, newName) {
+        return this.#afterMutation(await this.#store.renameFolder(path, newName));
+    }
+    async moveFolder(path, parent) {
+        return this.#afterMutation(await this.#store.moveFolder(path, parent));
+    }
+    async deleteFolder(path) {
+        const result = await this.#store.deleteFolder(path);
+        return this.#afterMutation(result.library);
+    }
+    /**
+     * CLI-facing asset update (M7): shallow-merge a parameter patch and/or
+     * replace the explicit manifest membership — validating the *result* before
+     * anything is persisted, so a change that would leave the library invalid
+     * (dangling or cyclic reference, unknown manifest, invalid parameters) is
+     * rejected with nothing written. The REST `patchAsset` keeps the editor's
+     * lenient replace semantics.
+     */
+    async setAsset(id, changes) {
+        const library = await this.#store.read();
+        this.#requireAsset(library, id);
+        return this.#afterMutation(await this.#applyAssetChanges(library, id, changes));
+    }
+    /**
+     * CLI-facing rename (M7): rejects a rename that would break references —
+     * a referrer keeps pointing at the old id, so renaming a referenced asset
+     * introduces dangling-reference errors. Update the referrers first.
+     */
+    async renameAsset(id, newId) {
+        const library = await this.#store.read();
+        this.#requireAsset(library, id);
+        // A collision or invalid new id is the store's own (clearer) error; the
+        // candidate check covers what the store cannot see: broken references.
+        if (newId !== id && !Object.hasOwn(library.assets, newId)) {
+            const candidate = structuredClone(library);
+            candidate.assets[newId] = candidate.assets[id];
+            delete candidate.assets[id];
+            await this.#assertNoIntroducedIssues(library, candidate);
+        }
+        return this.#afterMutation(await this.#store.renameAsset(id, newId));
+    }
+    /**
+     * Delete an asset: the record, its raw file, and its proxies. With
+     * `failOnIntroducedIssues` (the CLI), a delete that would break references
+     * (the asset is a reference target) is rejected before anything —
+     * including the raw file — is removed; the REST route stays lenient.
+     */
+    async deleteAsset(id, options) {
+        if (options?.failOnIntroducedIssues) {
+            const library = await this.#store.read();
+            this.#requireAsset(library, id);
+            const candidate = structuredClone(library);
+            delete candidate.assets[id];
+            await this.#assertNoIntroducedIssues(library, candidate);
+        }
+        return this.#afterMutation(await this.#store.deleteAsset(id));
+    }
+    /** Delete a selected asset set as one lenient editor mutation. */
+    async deleteAssets(assetIds) {
+        const uniqueIds = [...new Set(assetIds)];
+        if (uniqueIds.length === 0)
+            throw new Error('At least one asset id is required.');
+        return this.#afterMutation(await this.#store.deleteAssets(uniqueIds));
+    }
+    async createManifest(name) {
+        return this.#afterMutation(await this.#store.createManifest(name));
+    }
+    async setManifestAppearance(name, appearance) {
+        return this.#afterMutation(await this.#store.setManifestAppearance(name, appearance));
+    }
+    /** Apply a PATCH body: appearance fields and/or a rename — in that order. */
+    async patchManifest(name, body) {
+        let library = await this.#store.setManifestAppearance(name, {
+            color: body.color,
+            emoji: body.emoji
+        });
+        if (body.renameTo !== undefined) {
+            if (typeof body.renameTo !== 'string') {
+                throw new Error('"renameTo" must be a string.');
+            }
+            library = await this.#store.renameManifest(name, body.renameTo);
+        }
+        return this.#afterMutation(library);
+    }
+    /**
+     * Rename a manifest: rewrites every asset's membership and replaces the
+     * generated module (the old one is pruned as a stray). Host code importing
+     * the module must be updated by hand — both the file name and the exported
+     * const change with the manifest name.
+     */
+    async renameManifest(name, newName) {
+        return this.#afterMutation(await this.#store.renameManifest(name, newName));
+    }
+    async deleteManifest(name) {
+        return this.#afterMutation(await this.#store.deleteManifest(name));
+    }
+    /** The autosave chain tail: process + regenerate, then report fresh state. */
+    async #afterMutation(library) {
+        const pipelineIssues = [];
+        const issues = await this.#store.validate(library);
+        if (issues.length === 0) {
+            try {
+                const report = await processAssets(this.#config, library, this.#registry);
+                await generateManifestModules(this.#config, library, report.proxies, this.#registry);
+            }
+            catch (cause) {
+                pipelineIssues.push({
+                    message: `Processing failed: ${cause instanceof Error ? cause.message : String(cause)}`
+                });
+            }
+        }
+        return this.#buildState(library, pipelineIssues, issues);
+    }
+    async #buildState(library, extraIssues, precomputedIssues) {
+        const issues = [
+            ...(precomputedIssues ?? (await this.#store.validate(library))),
+            ...extraIssues
+        ];
+        const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
+        const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
+        const delivered = allDeliveredAssetIds(membershipByManifest);
+        // Per asset: the manifests it is a passive member of, with attribution.
+        const passiveManifestsByAsset = new Map();
+        for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
+            for (const passiveMember of membershipByManifest[manifestName].passiveMembers) {
+                const passiveManifests = passiveManifestsByAsset.get(passiveMember.assetId) ?? [];
+                passiveManifests.push({ manifest: manifestName, via: passiveMember.via });
+                passiveManifestsByAsset.set(passiveMember.assetId, passiveManifests);
+            }
+        }
+        const incomingByAsset = new Map();
+        for (const [referrerId, references] of Object.entries(referencesByAsset)) {
+            for (const reference of references) {
+                const incoming = incomingByAsset.get(reference.assetId) ?? [];
+                incoming.push({ field: reference.field, assetId: referrerId });
+                incomingByAsset.set(reference.assetId, incoming);
+            }
+        }
+        const assets = [];
+        for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
+            const record = library.assets[assetId];
+            const warnings = [];
+            for (const issue of issues) {
+                if (issue.assetId === assetId)
+                    warnings.push(issue.message);
+            }
+            // Unreachable: no explicit membership AND no passive membership in any
+            // manifest — nothing delivers the asset. A passively delivered asset is
+            // fine (it ships inlined into its referrers) and must not warn.
+            if (record.manifests.length === 0 && !delivered.has(assetId)) {
+                warnings.push('In no manifest and not referenced by any delivered asset — ' +
+                    'nothing is processed or generated for it.');
+            }
+            let proxy = null;
+            if (delivered.has(assetId)) {
+                try {
+                    const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry);
+                    if (currentProxy) {
+                        proxy = {
+                            url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
+                            upToDate: true,
+                            ...currentProxy
+                        };
+                    }
+                    else {
+                        warnings.push('Proxy is stale or missing — it will be (re)processed on the next save.');
+                    }
+                }
+                catch (cause) {
+                    warnings.push(cause instanceof Error ? cause.message : String(cause));
+                }
+            }
+            assets.push({
+                id: assetId,
+                type: record.type,
+                raw: record.raw,
+                folder: folderOfRawPath(record.raw),
+                rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}`,
+                rawHash: record.rawHash,
+                parameters: record.parameters,
+                manifests: record.manifests,
+                passiveManifests: passiveManifestsByAsset.get(assetId) ?? [],
+                proxy,
+                warnings,
+                references: {
+                    outgoing: referencesByAsset[assetId].map((reference) => ({
+                        field: reference.field,
+                        assetId: reference.assetId
+                    })),
+                    incoming: incomingByAsset.get(assetId) ?? []
+                }
+            });
+        }
+        // Per manifest: the membership picture for the manifests view, and the
+        // delivered bytes over the full delivery set (explicit ∪ passive),
+        // deduplicated — the preload-budget number.
+        const proxySizeByAssetId = new Map(assets.filter((asset) => asset.proxy).map((asset) => [asset.id, asset.proxy?.fileSize ?? 0]));
+        const manifestMemberships = {};
+        const manifestDeliveredBytes = {};
+        for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
+            const membership = membershipByManifest[manifestName];
+            manifestMemberships[manifestName] = {
+                explicitMemberIds: membership.explicitMemberIds,
+                passiveMembers: membership.passiveMembers
+            };
+            let deliveredBytes = 0;
+            for (const deliveredAssetId of membership.deliveredAssetIds) {
+                deliveredBytes += proxySizeByAssetId.get(deliveredAssetId) ?? 0;
+            }
+            manifestDeliveredBytes[manifestName] = deliveredBytes;
+        }
+        // Per plugin type, the available preset names — straight off the registry
+        // Chroma-key-video shares the video preset namespace via its plugin.
+        const presetNames = {};
+        for (const [type, plugin] of Object.entries(this.#registry)) {
+            presetNames[type] = Object.keys(plugin.presets(this.#config)).sort();
+        }
+        return {
+            library,
+            assets,
+            issues,
+            presetNames,
+            manifestMemberships,
+            manifestDeliveredBytes
+        };
+    }
+    #requireAsset(library, id) {
+        // Own-property check — an inherited key ("constructor", "toString", …)
+        // must not pass as an existing asset.
+        if (!Object.hasOwn(library.assets, id)) {
+            throw new Error(`Unknown asset "${id}".`);
+        }
+    }
+    /**
+     * Apply a CLI asset change to the store, validating the resulting library
+     * on an in-memory candidate first — nothing is persisted when the change
+     * would introduce validation issues. Pre-existing issues never block an
+     * unrelated mutation (only *introduced* issues are rejected).
+     */
+    async #applyAssetChanges(library, id, changes) {
+        const candidate = structuredClone(library);
+        const candidateRecord = candidate.assets[id];
+        if (changes.parametersPatch !== undefined) {
+            candidateRecord.parameters = serverPluginForType(candidateRecord.type, this.#registry).descriptor.validateParameters(mergeParameterPatch(candidateRecord.parameters, changes.parametersPatch));
+        }
+        if (changes.manifests !== undefined) {
+            candidateRecord.manifests = [...new Set(changes.manifests)].sort();
+        }
+        await this.#assertNoIntroducedIssues(library, candidate);
+        let updated = library;
+        if (changes.parametersPatch !== undefined) {
+            updated = await this.#store.updateParameters(id, candidateRecord.parameters);
+        }
+        if (changes.manifests !== undefined) {
+            updated = await this.#store.setManifests(id, changes.manifests);
+        }
+        return updated;
+    }
+    /** Reject a candidate library that has validation issues the current one lacks. */
+    async #assertNoIntroducedIssues(library, candidate) {
+        const existingIssueKeys = new Set((await this.#store.validate(library)).map((issue) => `${issue.assetId ?? ''}|${issue.message}`));
+        const introduced = (await this.#store.validate(candidate)).filter((issue) => !existingIssueKeys.has(`${issue.assetId ?? ''}|${issue.message}`));
+        if (introduced.length > 0) {
+            const lines = introduced.map((issue) => `  - ${issue.assetId ? `[${issue.assetId}] ` : ''}${issue.message}`);
+            throw new Error(`Rejected — the change would leave the library invalid (nothing was written):\n${lines.join('\n')}`);
+        }
+    }
+}

package/dist/server/plugins/audio.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Audio plugin (server part): one ffmpeg transcode per preset.
+ * No dimensions — the proxy's only output metadata is its duration.
+ */
+import { type AudioParameters, type AudioPreset } from '../../core/index.js';
+import { type ServerAssetTypePlugin } from './contract.js';
+export declare const audioServerPlugin: ServerAssetTypePlugin<AudioParameters, AudioPreset>;

package/dist/server/plugins/audio.js

@@ -0,0 +1,27 @@
+/**
+ * Audio plugin (server part): one ffmpeg transcode per preset.
+ * No dimensions — the proxy's only output metadata is its duration.
+ */
+import { audioPlugin } from '../../core/index.js';
+import { processAudioFile } from '../processing/audio-processing.js';
+import { probeMedia } from '../processing/media-probe.js';
+import { requireProxyField, resolveNamedPreset } from './contract.js';
+export const audioServerPlugin = {
+    descriptor: audioPlugin,
+    pluginConfig: (config) => config.plugins.audio,
+    presets: (config) => config.plugins.audio.presets,
+    resolvePreset: (parameters, config) => resolveNamedPreset('audio', parameters.preset, config.plugins.audio.presets),
+    proxyExtension: (preset) => preset.container,
+    process: (job) => processAudioFile({
+        sourcePath: job.sourcePath,
+        targetPath: job.targetPath,
+        preset: job.preset,
+        config: job.config
+    }),
+    readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
+    buildManifestEntry: ({ src, proxy }) => ({
+        kind: 'audio',
+        src,
+        durationMs: requireProxyField(proxy, 'durationMs')
+    })
+};

package/dist/server/plugins/chroma-key-video.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Chroma-key-video plugin (server part): shares the video plugin's transcode
+ * pipeline and preset namespace — the keying parameters and the
+ * mask/fallback references never reach ffmpeg, they are entry-only data
+ * (the descriptor's `processingParameters` keeps them out of the job hash).
+ */
+import { type ChromaKeyVideoParameters, type VideoPreset } from '../../core/index.js';
+import { type ServerAssetTypePlugin } from './contract.js';
+export declare const chromaKeyVideoServerPlugin: ServerAssetTypePlugin<ChromaKeyVideoParameters, VideoPreset>;

package/dist/server/plugins/chroma-key-video.js

@@ -0,0 +1,38 @@
+/**
+ * Chroma-key-video plugin (server part): shares the video plugin's transcode
+ * pipeline and preset namespace — the keying parameters and the
+ * mask/fallback references never reach ffmpeg, they are entry-only data
+ * (the descriptor's `processingParameters` keeps them out of the job hash).
+ */
+import { chromaKeyVideoPlugin } from '../../core/index.js';
+import { probeMedia } from '../processing/media-probe.js';
+import { processVideoFile } from '../processing/video-processing.js';
+import { requireProxyField, resolveNamedPreset } from './contract.js';
+export const chromaKeyVideoServerPlugin = {
+    descriptor: chromaKeyVideoPlugin,
+    // One preset namespace with the video plugin — the config slice,
+    // the preset map, and the resolution label are video's.
+    pluginConfig: (config) => config.plugins.video,
+    presets: (config) => config.plugins.video.presets,
+    resolvePreset: (parameters, config) => resolveNamedPreset('video', parameters.preset, config.plugins.video.presets),
+    proxyExtension: (preset) => preset.container,
+    process: (job) => processVideoFile({
+        sourcePath: job.sourcePath,
+        targetPath: job.targetPath,
+        preset: job.preset,
+        maxWidth: job.parameters.maxWidth,
+        config: job.config
+    }),
+    readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
+    buildManifestEntry: ({ parameters, src, proxy }) => ({
+        kind: 'chroma-key-video',
+        src,
+        width: requireProxyField(proxy, 'width'),
+        height: requireProxyField(proxy, 'height'),
+        durationMs: requireProxyField(proxy, 'durationMs'),
+        chromaKey: parameters.chromaKey,
+        // mask/fallback stay `{ $asset }` markers here — codegen inlines them.
+        ...(parameters.mask ? { mask: parameters.mask } : {}),
+        ...(parameters.fallback ? { fallback: parameters.fallback } : {})
+    })
+};