fundus 0.0.2 → 0.0.3

package/dist/server/http.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedFundusConfig } from './config-loader.js';
+export declare function errorResponse(cause: unknown, status: number): Response;
+export declare function routeNotFound(event: {
+    request: Request;
+    url: URL;
+}): Response;
+export declare function apiResponse(run: () => Promise<unknown>): Promise<Response>;
+export declare function parseByteRange(rangeHeader: string | null, size: number): {
+    start: number;
+    end: number;
+} | null | 'unsatisfiable';
+export declare function serveFundusFile(config: ResolvedFundusConfig, kind: 'raw' | 'proxy', fileName: string, request: Request): Promise<Response>;

package/dist/server/http.js

@@ -0,0 +1,100 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { assertSafeRelativeFilePath } from './library-store.js';
+const CONTENT_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.avif': 'image/avif',
+    '.svg': 'image/svg+xml',
+    '.mp4': 'video/mp4',
+    '.m4v': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.m4a': 'audio/mp4',
+    '.ogg': 'audio/ogg',
+    '.flac': 'audio/flac'
+};
+export function errorResponse(cause, status) {
+    const body = {
+        error: { message: cause instanceof Error ? cause.message : String(cause) }
+    };
+    return Response.json(body, { status });
+}
+export function routeNotFound(event) {
+    return errorResponse(new Error(`No route for ${event.request.method.toUpperCase()} ${event.url.pathname}.`), 404);
+}
+export async function apiResponse(run) {
+    try {
+        return Response.json(await run());
+    }
+    catch (cause) {
+        return errorResponse(cause, 400);
+    }
+}
+export function parseByteRange(rangeHeader, size) {
+    if (!rangeHeader)
+        return null;
+    const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+    if (!match || (match[1] === '' && match[2] === ''))
+        return null;
+    if (size === 0)
+        return 'unsatisfiable';
+    let start;
+    let end;
+    if (match[1] === '') {
+        start = Math.max(0, size - Number(match[2]));
+        end = size - 1;
+    }
+    else {
+        start = Number(match[1]);
+        end = match[2] === '' ? size - 1 : Math.min(Number(match[2]), size - 1);
+    }
+    if (start > end || start >= size)
+        return 'unsatisfiable';
+    return { start, end };
+}
+export async function serveFundusFile(config, kind, fileName, request) {
+    try {
+        assertSafeRelativeFilePath(fileName);
+    }
+    catch (cause) {
+        return errorResponse(cause, 400);
+    }
+    const directory = kind === 'raw' ? config.rawDir : config.proxyDir;
+    const filePath = join(directory, fileName);
+    if (!existsSync(filePath)) {
+        return errorResponse(new Error(`File "${fileName}" not found.`), 404);
+    }
+    const bytes = new Uint8Array(await readFile(filePath));
+    const size = bytes.byteLength;
+    const headers = {
+        'Content-Type': CONTENT_TYPES[extname(fileName).toLowerCase()] ?? 'application/octet-stream',
+        'Cache-Control': 'no-store',
+        'Accept-Ranges': 'bytes'
+    };
+    const range = parseByteRange(request.headers.get('Range'), size);
+    if (range === 'unsatisfiable') {
+        return new Response(null, {
+            status: 416,
+            headers: { ...headers, 'Content-Range': `bytes */${size}` }
+        });
+    }
+    if (range) {
+        const slice = bytes.subarray(range.start, range.end + 1);
+        return new Response(slice, {
+            status: 206,
+            headers: {
+                ...headers,
+                'Content-Range': `bytes ${range.start}-${range.end}/${size}`,
+                'Content-Length': String(slice.byteLength)
+            }
+        });
+    }
+    return new Response(bytes, { headers: { ...headers, 'Content-Length': String(size) } });
+}

package/dist/server/index.d.ts

@@ -0,0 +1,16 @@
+export type { ResolvedFundusConfig, ResolvedPresetPluginConfig, ResolvedVideoPluginConfig, ResolvedAudioPluginConfig } from './config-loader.js';
+export { loadConfig, resolveConfig } from './config-loader.js';
+export { LibraryStore } from './library-store.js';
+export type { IngestOptions } from './library-store.js';
+export type { AssetProxyInfo, ProxyOutputInfo, ProcessingReport } from './processing/processor.js';
+export { processAssets, expectedProxyFileName, expectedProxyRelativePath, deliveredAssetIds, isProxyFileName, readProxyOutputInfo } from './processing/processor.js';
+export { ffmpegBinaryPath, runToolchainBinary } from './processing/ffmpeg.js';
+export type { CodegenReport } from './codegen.js';
+export { generateManifestModules } from './codegen.js';
+export type { BuildReport } from './build.js';
+export { runBuild } from './build.js';
+export type { CheckFinding, CheckReport } from './check.js';
+export { formatCheckFinding, runCheck } from './check.js';
+export type { AssetChangeOptions } from './operations.js';
+export { FundusOperations } from './operations.js';
+export { runStart } from './start.js';

package/dist/server/index.js

@@ -0,0 +1,9 @@
+export { loadConfig, resolveConfig } from './config-loader.js';
+export { LibraryStore } from './library-store.js';
+export { processAssets, expectedProxyFileName, expectedProxyRelativePath, deliveredAssetIds, isProxyFileName, readProxyOutputInfo } from './processing/processor.js';
+export { ffmpegBinaryPath, runToolchainBinary } from './processing/ffmpeg.js';
+export { generateManifestModules } from './codegen.js';
+export { runBuild } from './build.js';
+export { formatCheckFinding, runCheck } from './check.js';
+export { FundusOperations } from './operations.js';
+export { runStart } from './start.js';

package/dist/server/job-hash.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bump when processing behavior or a sharp/ffmpeg toolchain upgrade changes
+ * output bytes; toolchain versions are deliberately not part of each hash.
+ */
+export declare const PIPELINE_VERSION = 1;
+/**
+ * First 8 hex chars of sha256 over rawHash + canonical parameters + pipeline
+ * version — the `<jobHash>` segment of a proxy file name.
+ */
+export declare function jobHash(rawHash: string, parameters: unknown, pipelineVersion?: number): string;

package/dist/server/job-hash.js

@@ -0,0 +1,23 @@
+/**
+ * Deterministic processing identity: a proxy's name derives from
+ * everything that influences its bytes — raw content, canonicalized
+ * parameters (including resolved preset settings), and the pipeline version —
+ * so staleness is a pure name check.
+ */
+import { createHash } from 'node:crypto';
+import { canonicalizeParameters } from '../core/index.js';
+/**
+ * Bump when processing behavior or a sharp/ffmpeg toolchain upgrade changes
+ * output bytes; toolchain versions are deliberately not part of each hash.
+ */
+export const PIPELINE_VERSION = 1;
+/**
+ * First 8 hex chars of sha256 over rawHash + canonical parameters + pipeline
+ * version — the `<jobHash>` segment of a proxy file name.
+ */
+export function jobHash(rawHash, parameters, pipelineVersion = PIPELINE_VERSION) {
+    return createHash('sha256')
+        .update(rawHash + canonicalizeParameters(parameters) + String(pipelineVersion))
+        .digest('hex')
+        .slice(0, 8);
+}

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

@@ -0,0 +1,82 @@
+import { type Library, type ValidationIssueDto } from '../core/index.js';
+import type { ResolvedFundusConfig } from './config-loader.js';
+import type { ServerPluginRegistry } from './plugins/contract.js';
+export declare function assertSafeFileName(fileName: string): void;
+/** Validate a persisted/served file path without allowing traversal outside its root. */
+export declare function assertSafeRelativeFilePath(filePath: string): void;
+/**
+ * Turn an arbitrary uploaded file name (spaces, umlauts, parentheses, nested
+ * paths) into a safe single segment: strip the directory, transliterate to
+ * ASCII-ish, replace runs of disallowed characters with `-`, and lower-case
+ * the extension. Never throws for a normal image name.
+ */
+export declare function sanitizeFileName(original: string): string;
+export declare function sha256Hex(bytes: Uint8Array): string;
+export interface IngestOptions {
+    /** Original file name of the upload (sanitized before storing). */
+    fileName: string;
+    bytes: Uint8Array;
+    /** Asset type (must be a known plugin type). */
+    type: string;
+    /** The chosen asset id (validated; must be unique). */
+    id: string;
+    /** Registered destination folder; empty string means the implicit root. */
+    folder?: string;
+}
+export declare class LibraryStore {
+    #private;
+    constructor(config: ResolvedFundusConfig, registry?: ServerPluginRegistry);
+    get config(): ResolvedFundusConfig;
+    /** Read + parse the library file; a missing file is an empty library. */
+    read(): Promise<Library>;
+    /** Deterministically serialize + write the library file. */
+    write(library: Library): Promise<void>;
+    /**
+     * Ingest a new asset: write the raw file into `rawDir` (under a sanitized,
+     * non-colliding name), hash its content, and create the library record with
+     * the owning plugin's default parameters. Returns the updated library.
+     */
+    ingest(options: IngestOptions): Promise<Library>;
+    /** Replace an asset's parameters (validated by the owning plugin). */
+    updateParameters(id: string, parameters: unknown): Promise<Library>;
+    /** Replace an asset's manifest membership (every name must exist). */
+    setManifests(id: string, manifests: string[]): Promise<Library>;
+    /** Rename an asset id (the raw file keeps its name — ids are the stable key). */
+    renameAsset(id: string, newId: string): Promise<Library>;
+    /** Move an asset's raw file and current proxies without changing its stable id. */
+    moveAsset(id: string, folder: string): Promise<Library>;
+    createFolder(path: string): Promise<Library>;
+    renameFolder(path: string, newName: string): Promise<Library>;
+    /** Move a complete folder subtree below another folder (or the implicit root). */
+    moveFolder(path: string, parent: string): Promise<Library>;
+    /** Recursively delete a folder and every asset stored below it. */
+    deleteFolder(path: string): Promise<{
+        library: Library;
+        deletedAssetIds: string[];
+    }>;
+    /** Delete an asset: remove the record, its raw file, and its proxies. */
+    deleteAsset(id: string): Promise<Library>;
+    /** Delete several assets as one library/file transaction. */
+    deleteAssets(ids: string[]): Promise<Library>;
+    createManifest(name: string): Promise<Library>;
+    /**
+     * Set (or clear) a manifest's editor appearance — its color and/or emoji.
+     * An `undefined` field is left unchanged; a `null` field clears it. Values
+     * are validated against the fixed palettes.
+     */
+    setManifestAppearance(name: string, appearance: {
+        color?: string | null;
+        emoji?: string | null;
+    }): Promise<Library>;
+    /** Rename a manifest and rewrite every asset's membership to the new name. */
+    renameManifest(name: string, newName: string): Promise<Library>;
+    /** Delete a manifest and strip it from every asset's membership. */
+    deleteManifest(name: string): Promise<Library>;
+    /**
+     * Structural + referential validation, listed per asset: invalid id, unknown
+     * type, dangling raw pointer, invalid parameters, unknown manifest names,
+     * and reference errors (dangling target, type mismatch, cycles).
+     */
+    validate(library: Library): Promise<ValidationIssueDto[]>;
+    syncFolders(library: Library): Promise<void>;
+}