fundus 0.0.2 → 0.0.4

package/dist/server/processing/processor.d.ts

@@ -0,0 +1,50 @@
+import { type AssetId, type AssetRecord, type Library } from '../../core/index.js';
+import type { ResolvedFundusConfig } from '../config-loader.js';
+import type { AssetProxyInfo, ProxyOutputInfo, ServerPluginRegistry } from '../plugins/contract.js';
+export type { AssetProxyInfo, ProxyOutputInfo } from '../plugins/contract.js';
+/** Whether a file name in the proxy directory is (shaped like) a fundus proxy. */
+export declare function isProxyFileName(fileName: string): boolean;
+/** Whether a shaped proxy file belongs to one specific asset id. */
+export declare function isProxyFileNameFor(assetId: string, fileName: string): boolean;
+export interface ProcessingReport {
+    /** Asset ids whose proxy was (re)generated in this run. */
+    processed: string[];
+    /** Asset ids whose proxy was already current (name check hit). */
+    reused: string[];
+    /** Orphaned proxy file names removed from the proxy directory. */
+    pruned: string[];
+    /** Per delivered asset: the current proxy and its output metadata. */
+    proxies: Record<string, AssetProxyInfo>;
+}
+/**
+ * The proxy file name an asset's current raw content + parameters demand.
+ * Throws when the parameters are invalid or reference an unknown preset.
+ *
+ * The hash input is the *effective* processing input: the asset's
+ * processing-relevant parameters (the plugin-declared subset — entry-only data
+ * like chroma-key tuning and references must not rename the proxy)
+ * plus the preset's **resolved settings** — parameters only carry the preset
+ * *name*, so hashing them alone would keep serving stale proxy bytes after a
+ * preset's quality/format is edited in the host config.
+ */
+export declare function expectedProxyFileName(assetId: string, record: AssetRecord, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): string;
+/** Expected proxy path relative to proxyDir, mirroring the raw asset folder. */
+export declare function expectedProxyRelativePath(assetId: string, record: AssetRecord, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): string;
+/**
+ * Output metadata of an existing proxy file, probed per the owning plugin's
+ * strategy: image-backed proxies via sharp, media proxies via ffprobe.
+ */
+export declare function readProxyOutputInfo(type: string, proxyPath: string, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): Promise<ProxyOutputInfo>;
+/** Read one asset's current proxy projection, or null when its expected file is absent. */
+export declare function readCurrentProxy(assetId: string, record: AssetRecord, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): Promise<AssetProxyInfo | null>;
+/**
+ * The delivered set: every explicit or passive member of ≥ 1 manifest —
+ * derived by the shared membership computation. Assets outside
+ * it are inert.
+ */
+export declare function deliveredAssetIds(library: Library, registry?: ServerPluginRegistry): Set<AssetId>;
+/**
+ * Ensure every delivered asset's proxy exists (processing stale/missing ones)
+ * and prune orphans. Assets outside the delivered set are skipped entirely.
+ */
+export declare function processAssets(config: ResolvedFundusConfig, library: Library, registry?: ServerPluginRegistry): Promise<ProcessingReport>;

package/dist/server/processing/processor.js

@@ -0,0 +1,158 @@
+/**
+ * The processing pipeline: every delivered asset gets exactly one
+ * proxy named `<assetId>.<jobHash>.<extension>`. Delivered = explicit or
+ * passive member of ≥ 1 manifest (codegen inlines referenced
+ * entries, so a passive member's proxy must exist even when the asset is in
+ * no manifest itself). Because the name is computable without running the job,
+ * staleness is a name check: expected name exists → up to date, else →
+ * process. Afterwards, files in the proxy directory that no asset expects are
+ * pruned.
+ *
+ * Type-agnostic: every per-type decision (preset resolution, extension, the
+ * sharp/ffmpeg step, proxy probing) lives on the server plugins; this module
+ * only consults the registry — which it takes as a parameter, so tests can
+ * drive the pipeline with fixture asset types.
+ */
+import { existsSync } from 'node:fs';
+import { mkdir, rename, stat, unlink } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import { allDeliveredAssetIds, collectAllReferences, computeLibraryMembership, folderOfRawPath, rawFileNameOfPath } from '../../core/index.js';
+import { jobHash } from '../job-hash.js';
+import { descriptorsByType, processingParametersOf, serverPluginForType, serverPluginsByType } from '../plugins.js';
+import { ensureManagedFolder, listRelativeFiles } from '../folder-filesystem.js';
+/** Proxy file name shape; its id segment is pinned to core's asset-id grammar. */
+const PROXY_FILE_PATTERN = /^[a-z][A-Za-z0-9]*\.[0-9a-f]{8}\.[a-z0-9]+$/;
+/** Whether a file name in the proxy directory is (shaped like) a fundus proxy. */
+export function isProxyFileName(fileName) {
+    return PROXY_FILE_PATTERN.test(fileName);
+}
+/** Whether a shaped proxy file belongs to one specific asset id. */
+export function isProxyFileNameFor(assetId, fileName) {
+    return isProxyFileName(fileName) && fileName.startsWith(`${assetId}.`);
+}
+/**
+ * The proxy file name an asset's current raw content + parameters demand.
+ * Throws when the parameters are invalid or reference an unknown preset.
+ *
+ * The hash input is the *effective* processing input: the asset's
+ * processing-relevant parameters (the plugin-declared subset — entry-only data
+ * like chroma-key tuning and references must not rename the proxy)
+ * plus the preset's **resolved settings** — parameters only carry the preset
+ * *name*, so hashing them alone would keep serving stale proxy bytes after a
+ * preset's quality/format is edited in the host config.
+ */
+export function expectedProxyFileName(assetId, record, config, registry = serverPluginsByType) {
+    const plugin = serverPluginForType(record.type, registry);
+    const parameters = plugin.descriptor.validateParameters(record.parameters);
+    const preset = plugin.resolvePreset(parameters, config);
+    const hash = jobHash(record.rawHash, {
+        parameters: processingParametersOf(plugin.descriptor, parameters),
+        presetSettings: preset
+    });
+    return `${assetId}.${hash}.${plugin.proxyExtension(preset)}`;
+}
+/** Expected proxy path relative to proxyDir, mirroring the raw asset folder. */
+export function expectedProxyRelativePath(assetId, record, config, registry = serverPluginsByType) {
+    const fileName = expectedProxyFileName(assetId, record, config, registry);
+    const folder = folderOfRawPath(record.raw);
+    return folder === '' ? fileName : `${folder}/${fileName}`;
+}
+/**
+ * Output metadata of an existing proxy file, probed per the owning plugin's
+ * strategy: image-backed proxies via sharp, media proxies via ffprobe.
+ */
+export async function readProxyOutputInfo(type, proxyPath, config, registry = serverPluginsByType) {
+    return serverPluginForType(type, registry).readProxyInfo(proxyPath, config);
+}
+/** Read one asset's current proxy projection, or null when its expected file is absent. */
+export async function readCurrentProxy(assetId, record, config, registry = serverPluginsByType) {
+    const fileName = expectedProxyFileName(assetId, record, config, registry);
+    const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+    const proxyPath = join(config.proxyDir, relativePath);
+    if (!existsSync(proxyPath))
+        return null;
+    const [outputInfo, proxyStat] = await Promise.all([
+        readProxyOutputInfo(record.type, proxyPath, config, registry),
+        stat(proxyPath)
+    ]);
+    return { assetId, fileName, relativePath, ...outputInfo, fileSize: proxyStat.size };
+}
+/**
+ * The delivered set: every explicit or passive member of ≥ 1 manifest —
+ * derived by the shared membership computation. Assets outside
+ * it are inert.
+ */
+export function deliveredAssetIds(library, registry = serverPluginsByType) {
+    return allDeliveredAssetIds(computeLibraryMembership(library, collectAllReferences(library, descriptorsByType(registry))));
+}
+/** Run the owning plugin's processing job for one stale/missing proxy. */
+async function processAssetFile(record, rawPath, proxyPath, config, registry) {
+    const plugin = serverPluginForType(record.type, registry);
+    const parameters = plugin.descriptor.validateParameters(record.parameters);
+    const extension = extname(proxyPath);
+    const stem = basename(proxyPath, extension);
+    const temporaryPath = join(dirname(proxyPath), `.${stem}.${crypto.randomUUID()}.tmp${extension}`);
+    try {
+        const output = await plugin.process({
+            sourcePath: rawPath,
+            targetPath: temporaryPath,
+            parameters,
+            preset: plugin.resolvePreset(parameters, config),
+            config
+        });
+        await rename(temporaryPath, proxyPath);
+        return output;
+    }
+    catch (cause) {
+        await unlink(temporaryPath).catch(() => { });
+        throw cause;
+    }
+}
+/**
+ * Ensure every delivered asset's proxy exists (processing stale/missing ones)
+ * and prune orphans. Assets outside the delivered set are skipped entirely.
+ */
+export async function processAssets(config, library, registry = serverPluginsByType) {
+    const report = { processed: [], reused: [], pruned: [], proxies: {} };
+    await mkdir(config.proxyDir, { recursive: true });
+    await Promise.all(library.folders.map((folder) => ensureManagedFolder(config.proxyDir, folder)));
+    const delivered = deliveredAssetIds(library, registry);
+    const expectedRelativePaths = new Set();
+    for (const [assetId, record] of Object.entries(library.assets)) {
+        if (!delivered.has(assetId))
+            continue;
+        const fileName = expectedProxyFileName(assetId, record, config, registry);
+        const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+        expectedRelativePaths.add(relativePath);
+        const proxyPath = join(config.proxyDir, relativePath);
+        const rawPath = join(config.rawDir, record.raw);
+        await mkdir(dirname(proxyPath), { recursive: true });
+        let proxy = await readCurrentProxy(assetId, record, config, registry);
+        if (proxy) {
+            report.reused.push(assetId);
+        }
+        else {
+            if (!existsSync(rawPath)) {
+                throw new Error(`Cannot process "${assetId}": raw file "${record.raw}" is missing.`);
+            }
+            const outputInfo = await processAssetFile(record, rawPath, proxyPath, config, registry);
+            report.processed.push(assetId);
+            const proxyStat = await stat(proxyPath);
+            proxy = { assetId, fileName, relativePath, ...outputInfo, fileSize: proxyStat.size };
+        }
+        report.proxies[assetId] = proxy;
+    }
+    // Prune orphans: only files matching the proxy naming pattern are touched,
+    // so a stray non-fundus file in the directory is left alone.
+    for (const relativePath of await listRelativeFiles(config.proxyDir)) {
+        const fileName = rawFileNameOfPath(relativePath);
+        if (!isProxyFileName(fileName))
+            continue;
+        if (expectedRelativePaths.has(relativePath))
+            continue;
+        await unlink(join(config.proxyDir, relativePath));
+        report.pruned.push(relativePath);
+    }
+    report.pruned.sort();
+    return report;
+}

package/dist/server/processing/video-processing.d.ts

@@ -0,0 +1,35 @@
+import type { VideoPreset } from '../../core/index.js';
+import type { ResolvedFundusConfig } from '../config-loader.js';
+/**
+ * The delivered width the scale filter must produce, or null when no filter is
+ * needed. `maxWidth` is a downscale-only cap; yuv420p demands even dimensions,
+ * so an odd (capped or source) width rounds down and an odd source height
+ * forces a filter even without a cap (the `-2` idiom rounds it).
+ */
+export declare function videoScaleWidth(sourceWidth: number, sourceHeight: number, maxWidth?: number): number | null;
+/**
+ * The full ffmpeg argument list for one video transcode (pure, testable
+ * without a binary). `-map_metadata -1` + bitexact flags keep the output
+ * byte-stable across runs (no embedded timestamps or encoder version tags);
+ * a source audio track is kept (re-encoded as AAC — a UI video may carry
+ * sound; nothing is stripped silently).
+ */
+export declare function buildVideoTranscodeArguments(options: {
+    sourcePath: string;
+    targetPath: string;
+    preset: VideoPreset;
+    /** From `videoScaleWidth`; null = no scaling. */
+    scaleWidth: number | null;
+}): string[];
+export interface VideoProcessingOutput {
+    width: number;
+    height: number;
+    durationMs: number;
+}
+export declare function processVideoFile(options: {
+    sourcePath: string;
+    targetPath: string;
+    preset: VideoPreset;
+    maxWidth?: number;
+    config: ResolvedFundusConfig;
+}): Promise<VideoProcessingOutput>;

package/dist/server/processing/video-processing.js

@@ -0,0 +1,87 @@
+/**
+ * The ffmpeg transcode step shared by the video and chroma-key-video plugins
+ * (chroma-key-video builds on video's processing; its keying data is
+ * entry-only and never reaches ffmpeg). Deterministic output: all
+ * metadata is stripped and bitexact muxing is forced, so re-running a job
+ * yields byte-identical proxy files.
+ */
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { ffmpegBinaryPath, runToolchainBinary } from './ffmpeg.js';
+import { probeMedia } from './media-probe.js';
+/**
+ * The delivered width the scale filter must produce, or null when no filter is
+ * needed. `maxWidth` is a downscale-only cap; yuv420p demands even dimensions,
+ * so an odd (capped or source) width rounds down and an odd source height
+ * forces a filter even without a cap (the `-2` idiom rounds it).
+ */
+export function videoScaleWidth(sourceWidth, sourceHeight, maxWidth) {
+    const cappedWidth = maxWidth !== undefined ? Math.min(maxWidth, sourceWidth) : sourceWidth;
+    const evenWidth = Math.max(2, cappedWidth - (cappedWidth % 2));
+    if (evenWidth === sourceWidth && sourceHeight % 2 === 0)
+        return null;
+    return evenWidth;
+}
+/**
+ * The full ffmpeg argument list for one video transcode (pure, testable
+ * without a binary). `-map_metadata -1` + bitexact flags keep the output
+ * byte-stable across runs (no embedded timestamps or encoder version tags);
+ * a source audio track is kept (re-encoded as AAC — a UI video may carry
+ * sound; nothing is stripped silently).
+ */
+export function buildVideoTranscodeArguments(options) {
+    const { sourcePath, targetPath, preset, scaleWidth } = options;
+    return [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        '-y',
+        '-i',
+        sourcePath,
+        ...(scaleWidth !== null ? ['-vf', `scale=${scaleWidth}:-2`] : []),
+        '-c:v',
+        'libx264',
+        '-preset',
+        preset.encoderPreset,
+        ...(preset.tune !== undefined ? ['-tune', preset.tune] : []),
+        '-crf',
+        String(preset.crf),
+        '-pix_fmt',
+        preset.pixelFormat,
+        '-c:a',
+        'aac',
+        '-b:a',
+        '128k',
+        '-map_metadata',
+        '-1',
+        '-fflags',
+        '+bitexact',
+        '-flags:v',
+        '+bitexact',
+        '-flags:a',
+        '+bitexact',
+        '-movflags',
+        '+faststart',
+        targetPath
+    ];
+}
+export async function processVideoFile(options) {
+    await mkdir(dirname(options.targetPath), { recursive: true });
+    const source = await probeMedia(options.sourcePath, options.config);
+    if (source.width === undefined || source.height === undefined) {
+        throw new Error(`${options.sourcePath} has no video stream.`);
+    }
+    const scaleWidth = videoScaleWidth(source.width, source.height, options.maxWidth);
+    await runToolchainBinary(ffmpegBinaryPath(options.config), buildVideoTranscodeArguments({
+        sourcePath: options.sourcePath,
+        targetPath: options.targetPath,
+        preset: options.preset,
+        scaleWidth
+    }));
+    // Probe the output — the delivered dimensions/duration are what the entry carries.
+    const output = await probeMedia(options.targetPath, options.config);
+    if (output.width === undefined || output.height === undefined) {
+        throw new Error(`Transcoding ${options.sourcePath} produced no video stream.`);
+    }
+    return { width: output.width, height: output.height, durationMs: output.durationMs };
+}

package/dist/server/server.d.ts

@@ -0,0 +1,13 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+export { parseByteRange } from './http.js';
+export type FundusHandler = (request: IncomingMessage, response: ServerResponse, next: (error?: unknown) => void) => void;
+export interface FundusServerOptions {
+    handler: FundusHandler;
+    port: number;
+    forceCloseAfterMs?: number;
+}
+export interface FundusServer {
+    port: number;
+    stop(): Promise<void>;
+}
+export declare function startServer(options: FundusServerOptions): Promise<FundusServer>;

package/dist/server/server.js

@@ -0,0 +1,57 @@
+import { createServer } from 'node:http';
+export { parseByteRange } from './http.js';
+export async function startServer(options) {
+    const server = createServer((request, response) => {
+        // adapter-node otherwise assumes HTTPS when a custom server does not
+        // provide protocol metadata, which makes same-origin multipart uploads
+        // fail SvelteKit's CSRF check on this intentionally HTTP-only local server.
+        request.headers['x-fundus-proto'] = 'http';
+        options.handler(request, response, (cause) => {
+            if (response.writableEnded)
+                return;
+            response.statusCode = 500;
+            response.setHeader('Content-Type', 'application/json; charset=utf-8');
+            response.end(JSON.stringify({
+                error: {
+                    message: cause instanceof Error ? cause.message : 'Fundus handler declined the request.'
+                }
+            }));
+        });
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (cause) => {
+            server.off('listening', onListening);
+            reject(cause);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(options.port, '127.0.0.1');
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Fundus server did not expose a TCP listening address.');
+    }
+    let stopping;
+    return {
+        port: address.port,
+        stop() {
+            stopping ??= new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => server.closeAllConnections(), options.forceCloseAfterMs ?? 1000);
+                timeout.unref();
+                server.closeIdleConnections();
+                server.close((cause) => {
+                    clearTimeout(timeout);
+                    if (cause)
+                        reject(cause);
+                    else
+                        resolve();
+                });
+            });
+            return stopping;
+        }
+    };
+}

package/dist/server/start.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_PORT = 7583;
+interface StartBannerOptions {
+    port: number;
+    projectRoot: string;
+    color?: boolean;
+}
+export interface RunStartOptions {
+    openBrowser?: boolean;
+}
+/** Format the human startup summary without pulling a terminal UI dependency into the CLI. */
+export declare function formatStartBanner({ port, projectRoot, color }: StartBannerOptions): string;
+export declare function runStart(projectRoot: string, { openBrowser }?: RunStartOptions): Promise<void>;
+export {};

package/dist/server/start.js

@@ -0,0 +1,80 @@
+/** Start the packaged SvelteKit Node editor and API for one host project. */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import open from 'open';
+import { startServer } from './server.js';
+export const DEFAULT_PORT = 7583;
+function ansi(code, value, enabled) {
+    return enabled ? `\u001b[${code}m${value}\u001b[0m` : value;
+}
+/** Format the human startup summary without pulling a terminal UI dependency into the CLI. */
+export function formatStartBanner({ port, projectRoot, color = false }) {
+    const url = `http://127.0.0.1:${port}`;
+    const brand = '◆ Fundus';
+    const editor = `Editor   ${url}`;
+    const project = `Project  ${projectRoot}`;
+    const ready = 'Ready · press Ctrl+C to stop';
+    const contentWidth = Math.max(42, brand.length, editor.length, project.length, ready.length);
+    const border = (value) => ansi('2', value, color);
+    const row = (plain, styled = plain) => `${border('│')} ${styled}${' '.repeat(contentWidth - plain.length)} ${border('│')}`;
+    const empty = row('');
+    return [
+        '',
+        border(`╭${'─'.repeat(contentWidth + 2)}╮`),
+        empty,
+        row(brand, `${ansi('38;2;24;152;243', '◆', color)} ${ansi('1', 'Fundus', color)}`),
+        empty,
+        row(editor, `${ansi('2', 'Editor', color)}   ${ansi('4;36', url, color)}`),
+        row(project, `${ansi('2', 'Project', color)}  ${projectRoot}`),
+        empty,
+        row(ready, ansi('32', ready, color)),
+        empty,
+        border(`╰${'─'.repeat(contentWidth + 2)}╯`)
+    ].join('\n');
+}
+export async function runStart(projectRoot, { openBrowser = true } = {}) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    process.env.FUNDUS_PROJECT_ROOT = resolvedProjectRoot;
+    process.env.FUNDUS_BODY_SIZE_LIMIT ??= 'Infinity';
+    process.env.FUNDUS_ADAPTER_BODY_SIZE_LIMIT = process.env.FUNDUS_BODY_SIZE_LIMIT;
+    process.env.FUNDUS_ADAPTER_PROTOCOL_HEADER = 'x-fundus-proto';
+    const handlerUrl = new URL('../../build/handler.js', import.meta.url);
+    if (!existsSync(handlerUrl)) {
+        throw new Error(`The packaged Fundus SvelteKit handler is missing from ${fileURLToPath(handlerUrl)}. Reinstall the fundus package or report a packaging error.`);
+    }
+    const module = (await import(handlerUrl.href));
+    if (typeof module.handler !== 'function') {
+        throw new Error(`The packaged Fundus handler at ${fileURLToPath(handlerUrl)} is invalid.`);
+    }
+    const configuredPort = Number(process.env.FUNDUS_API_PORT ?? DEFAULT_PORT);
+    const server = await startServer({ handler: module.handler, port: configuredPort });
+    const editorUrl = `http://127.0.0.1:${server.port}`;
+    console.log(formatStartBanner({
+        port: server.port,
+        projectRoot: resolvedProjectRoot,
+        color: process.stdout.isTTY === true &&
+            process.env.NO_COLOR === undefined &&
+            process.env.TERM !== 'dumb'
+    }));
+    if (openBrowser) {
+        try {
+            await open(editorUrl);
+        }
+        catch (cause) {
+            console.warn(`Fundus could not open the editor in your browser. Open ${editorUrl} manually.\n` +
+                (cause instanceof Error ? cause.message : String(cause)));
+        }
+    }
+    let signalStop;
+    const stopForSignal = () => {
+        signalStop ??= server.stop().then(() => {
+            process.exitCode = 0;
+        }, (cause) => {
+            console.error(cause);
+            process.exitCode = 1;
+        });
+    };
+    process.once('SIGINT', stopForSignal);
+    process.once('SIGTERM', stopForSignal);
+}

package/package.json

@@ -1,17 +1,11 @@
 {
 	"name": "fundus",
-	"version": "0.0.2",
+	"version": "0.0.4",
 	"type": "module",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/grischaerbe/fundus.git"
 	},
-	"imports": {
-		"#fundus/core": {
-			"types": "./dist/core/index.d.ts",
-			"default": "./dist/core/index.js"
-		}
-	},
 	"bin": {
 		"fundus": "./dist/cli.js"
 	},
@@ -23,8 +17,8 @@
 			"default": "./dist/runtime/index.js"
 		},
 		"./server": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
+			"types": "./dist/server/index.d.ts",
+			"default": "./dist/server/index.js"
 		},
 		"./config": {
 			"types": "./dist/config.d.ts",
@@ -32,34 +26,55 @@
 		}
 	},
 	"files": [
-		"dist"
+		"dist",
+		"build"
 	],
 	"engines": {
 		"node": ">=20.19.0"
 	},
 	"scripts": {
-		"build": "tsdown",
-		"prepack": "npm run build --workspace=@fundus/core && npm run build --workspace=@fundus/runtime && npm run build --workspace=@fundus/editor && npm run build",
+		"dev": "vite dev",
+		"build:package": "svelte-package --input src/lib --output dist && node scripts/postbuild-package.mjs && publint",
+		"build:app": "vite build",
+		"build": "npm run build:package && npm run build:app",
 		"test": "npm run build && vitest run",
-		"check": "npm run build && tsc --noEmit",
+		"smoke:pack": "node scripts/smoke-packed.mjs",
+		"smoke:e2e": "npm run build && node scripts/smoke-sveltekit.mjs",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json && tsc --noEmit",
 		"lint": "prettier --check .",
-		"format": "prettier --write ."
+		"format": "prettier --write .",
+		"prepack": "npm run build",
+		"changeset": "changeset",
+		"version-packages": "changeset version",
+		"release": "changeset publish"
 	},
 	"dependencies": {
 		"ffmpeg-static": "^5.3.0",
 		"ffprobe-static": "^3.1.0",
 		"jiti": "^2.5.1",
+		"open": "^11.0.0",
 		"sharp": "^0.34.4"
 	},
 	"peerDependencies": {
 		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
+		"@changesets/changelog-github": "^0.7.0",
+		"@changesets/cli": "^2.31.0",
+		"@sveltejs/adapter-node": "^5.5.7",
+		"@sveltejs/kit": "^2.69.2",
+		"@sveltejs/package": "^2.5.8",
+		"@sveltejs/vite-plugin-svelte": "^7.1.2",
 		"@types/ffprobe-static": "^2.0.3",
-		"@types/node": "^24.0.10",
+		"@types/node": "^24.13.3",
+		"fuse.js": "^7.4.2",
+		"prettier": "^3.8.3",
+		"prettier-plugin-svelte": "^4.1.0",
+		"publint": "^0.3.21",
 		"svelte": "^5.56.1",
-		"tsdown": "^0.21.10",
+		"svelte-check": "^4.6.0",
 		"typescript": "^6.0.3",
+		"vite": "^8.0.16",
 		"vitest": "^3.2.4"
 	}
 }