@mcptoolshop/toolshopstudio 1.1.0-toolshop

package/dist/exec.js

@@ -0,0 +1,87 @@
+import { spawn, execFile } from "node:child_process";
+import { attachProgressParser, calculatePercent } from "./progress-parser.js";
+import { ProbeResultSchema } from "./schemas.js";
+/**
+ * Run ffmpeg with -nostdin, AbortSignal cancellation, and progress parsing.
+ *
+ * @param flags - full argv (everything after `ffmpeg`)
+ * @param signal - AbortSignal for cancellation
+ * @param onProgress - called with percent (0–100), fires at each out_time_us update and on 'end'
+ * @param durationSec - total input duration for percent calculation
+ */
+export async function runFfmpeg(flags, signal, onProgress, durationSec) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+        }
+        const proc = spawn("ffmpeg", ["-nostdin", ...flags], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        // Wire up abort
+        const onAbort = () => {
+            proc.kill("SIGKILL");
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        // Parse progress from stderr
+        let lastEmittedPercent = -1;
+        attachProgressParser(proc.stderr, (key, value) => {
+            if (key === "out_time_us") {
+                const percent = calculatePercent(value, durationSec);
+                if (percent !== lastEmittedPercent) {
+                    lastEmittedPercent = percent;
+                    onProgress(percent);
+                }
+            }
+            if (key === "progress" && value === "end") {
+                if (lastEmittedPercent !== 100) {
+                    lastEmittedPercent = 100;
+                    onProgress(100);
+                }
+            }
+        });
+        proc.on("close", (code) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted) {
+                reject(new DOMException("Aborted", "AbortError"));
+            }
+            else if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`ffmpeg exited with code ${code}`));
+            }
+        });
+        proc.on("error", (err) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(err);
+        });
+    });
+}
+/**
+ * Run ffprobe and return parsed ProbeResult.
+ */
+export async function runProbe(filePath) {
+    return new Promise((resolve, reject) => {
+        execFile("ffprobe", [
+            "-v", "quiet",
+            "-print_format", "json",
+            "-show_format",
+            "-show_streams",
+            filePath,
+        ], { maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
+            if (err) {
+                reject(new Error(`ffprobe failed for "${filePath}": ${err.message}`));
+                return;
+            }
+            try {
+                const raw = JSON.parse(stdout);
+                const result = ProbeResultSchema.parse(raw);
+                resolve(result);
+            }
+            catch (parseErr) {
+                reject(new Error(`ffprobe output parse failed for "${filePath}": ${parseErr}`));
+            }
+        });
+    });
+}

package/dist/full.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/full.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi } from "vitest";
+import { generateYouTubeThumbnail } from "./generate-thumbnail.js";
+import { createInMemoryCRUD } from "./crud.js";
+import { transcodeForYouTube } from "./transcode.js";
+// ── Fixtures ──────────────────────────────────────────────────────
+const GOOD_PROBE = {
+    streams: [
+        {
+            codec_name: "h264",
+            codec_type: "video",
+            width: 1920,
+            height: 1080,
+            pix_fmt: "yuv420p",
+            field_order: "progressive",
+            profile: "High",
+        },
+        {
+            codec_name: "aac",
+            codec_type: "audio",
+            channels: 2,
+            sample_rate: "48000",
+        },
+    ],
+    format: {
+        filename: "/data/sandbox/user1/input.mp4",
+        format_name: "mov,mp4,m4a,3gp,3g2,mj2",
+        duration: "120.0",
+        size: "50000000",
+        bit_rate: "8000000",
+    },
+};
+// ── Thumbnail tests ───────────────────────────────────────────────
+describe("generateYouTubeThumbnail", () => {
+    it("happy path: generates dual thumbnails", async () => {
+        const mockExtract = vi.fn(async () => { });
+        const mockGenerate = vi.fn(async () => { });
+        const ctx = {
+            signal: new AbortController().signal,
+            userId: "user1",
+            tmpDir: "/data/sandbox/user1/tmp",
+            extractFrame: mockExtract,
+            generateStyledThumbnail: mockGenerate,
+        };
+        const result = await generateYouTubeThumbnail({
+            videoPath: "/data/sandbox/user1/output.mp4",
+            output: {
+                landscape: "/data/sandbox/user1/thumb_16x9.jpg",
+                portrait: "/data/sandbox/user1/thumb_4x5.jpg",
+            },
+        }, ctx);
+        expect(result.landscape).toBe("/data/sandbox/user1/thumb_16x9.jpg");
+        expect(result.portrait).toBe("/data/sandbox/user1/thumb_4x5.jpg");
+        // extractFrame called once (single temp still)
+        expect(mockExtract).toHaveBeenCalledTimes(1);
+        // generateStyledThumbnail called twice (landscape + portrait)
+        expect(mockGenerate).toHaveBeenCalledTimes(2);
+        // Verify dimensions: first call = 1280x720, second = 1080x1350
+        const call0 = mockGenerate.mock.calls[0];
+        expect(call0[2]).toBe(1280);
+        expect(call0[3]).toBe(720);
+        const call1 = mockGenerate.mock.calls[1];
+        expect(call1[2]).toBe(1080);
+        expect(call1[3]).toBe(1350);
+    });
+    it("passes overlay text through to generateStyledThumbnail", async () => {
+        const mockGenerate = vi.fn(async () => { });
+        const result = await generateYouTubeThumbnail({
+            videoPath: "/data/sandbox/user1/output.mp4",
+            output: {
+                landscape: "/data/sandbox/user1/thumb_16x9.jpg",
+                portrait: "/data/sandbox/user1/thumb_4x5.jpg",
+            },
+            overlayText: "MY TITLE",
+        }, {
+            signal: new AbortController().signal,
+            userId: "user1",
+            tmpDir: "/data/sandbox/user1/tmp",
+            extractFrame: vi.fn(async () => { }),
+            generateStyledThumbnail: mockGenerate,
+        });
+        // Both calls should receive overlay text
+        const c0 = mockGenerate.mock.calls[0];
+        const c1 = mockGenerate.mock.calls[1];
+        expect(c0[5]).toBe("MY TITLE");
+        expect(c1[5]).toBe("MY TITLE");
+    });
+});
+// ── Transcode + thumbnail wiring test ─────────────────────────────
+describe("transcode with thumbnail wiring", () => {
+    it("generates thumbnails when generateThumbnail is provided", async () => {
+        const notifications = [];
+        const crud = createInMemoryCRUD();
+        const mockThumbGen = vi.fn(async () => ({
+            landscape: "/data/sandbox/user1/output_thumb_16x9.jpg",
+            portrait: "/data/sandbox/user1/output_thumb_4x5.jpg",
+        }));
+        const ctx = {
+            signal: new AbortController().signal,
+            userId: "user1",
+            notify: (n) => notifications.push(n),
+            createAsset: async (a) => { await crud.create(a); },
+            runFfmpeg: vi.fn(async (_f, _s, onProgress) => {
+                onProgress(50);
+                onProgress(100);
+            }),
+            runProbe: vi.fn(async () => GOOD_PROBE),
+            generateThumbnail: mockThumbGen,
+        };
+        const asset = await transcodeForYouTube({
+            inputPath: "/data/sandbox/user1/input.mp4",
+            outputPath: "/data/sandbox/user1/output.mp4",
+            preset: "yt-1080p-h264",
+        }, ctx);
+        expect(asset.thumbnailPaths.landscape).toBe("/data/sandbox/user1/output_thumb_16x9.jpg");
+        expect(asset.thumbnailPaths.portrait).toBe("/data/sandbox/user1/output_thumb_4x5.jpg");
+        expect(mockThumbGen).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/generate-thumbnail.d.ts

@@ -0,0 +1,21 @@
+import { extractFrame, generateStyledThumbnail } from "./thumbnail.js";
+export interface ThumbnailResult {
+    landscape: string;
+    portrait: string;
+}
+export interface ThumbnailContext {
+    signal: AbortSignal;
+    userId: string;
+    /** Temp directory for intermediate files. Defaults to os.tmpdir(). */
+    tmpDir?: string;
+    /** Injected for testability */
+    extractFrame?: typeof extractFrame;
+    generateStyledThumbnail?: typeof generateStyledThumbnail;
+}
+/**
+ * Generate dual YouTube thumbnails (16:9 landscape + 4:5 portrait).
+ *
+ * Pipeline: validate → extract frame → style + scale to both sizes →
+ * clamp each under 2 MB → cleanup temp still.
+ */
+export declare function generateYouTubeThumbnail(reqRaw: unknown, ctx: ThumbnailContext): Promise<ThumbnailResult>;

package/dist/generate-thumbnail.js

@@ -0,0 +1,42 @@
+import { randomUUID } from "node:crypto";
+import { unlink } from "node:fs/promises";
+import { GenerateYouTubeThumbnailSchema, } from "./schemas.js";
+import { validateSandboxPath } from "./preflight.js";
+import { extractFrame, generateStyledThumbnail } from "./thumbnail.js";
+/**
+ * Generate dual YouTube thumbnails (16:9 landscape + 4:5 portrait).
+ *
+ * Pipeline: validate → extract frame → style + scale to both sizes →
+ * clamp each under 2 MB → cleanup temp still.
+ */
+export async function generateYouTubeThumbnail(reqRaw, ctx) {
+    const req = GenerateYouTubeThumbnailSchema.parse(reqRaw);
+    validateSandboxPath(ctx.userId, req.videoPath);
+    validateSandboxPath(ctx.userId, req.output.landscape);
+    validateSandboxPath(ctx.userId, req.output.portrait);
+    const doExtract = ctx.extractFrame ?? extractFrame;
+    const doGenerate = ctx.generateStyledThumbnail ?? generateStyledThumbnail;
+    // Extract a single frame as temp PNG
+    const tmpDir = ctx.tmpDir ?? "/tmp";
+    const tempStill = `${tmpDir}/${randomUUID()}.png`;
+    try {
+        await doExtract(req.videoPath, req.timestamp, tempStill, ctx.signal);
+        // 16:9 landscape (1280×720) — always generated
+        await doGenerate(tempStill, req.output.landscape, 1280, 720, req.style, req.overlayText);
+        // 4:5 portrait (1080×1350) — always generated
+        await doGenerate(tempStill, req.output.portrait, 1080, 1350, req.style, req.overlayText);
+        return {
+            landscape: req.output.landscape,
+            portrait: req.output.portrait,
+        };
+    }
+    finally {
+        // Cleanup temp still (best-effort)
+        try {
+            await unlink(tempStill);
+        }
+        catch {
+            // ignore — temp file cleanup is best-effort
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./schemas.js";
+export * from "./preset-spec.js";
+export * from "./preflight.js";
+export * from "./types.js";
+export * from "./build-flags.js";
+export * from "./progress-parser.js";
+export * from "./exec.js";
+export * from "./transcode.js";
+export * from "./thumbnail.js";
+export * from "./generate-thumbnail.js";
+export * from "./crud.js";
+export * as pandoc from "./pandoc/index.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./schemas.js";
+export * from "./preset-spec.js";
+export * from "./preflight.js";
+export * from "./types.js";
+export * from "./build-flags.js";
+export * from "./progress-parser.js";
+export * from "./exec.js";
+export * from "./transcode.js";
+export * from "./thumbnail.js";
+export * from "./generate-thumbnail.js";
+export * from "./crud.js";
+export * as pandoc from "./pandoc/index.js";

package/dist/pandoc/build-args.d.ts

@@ -0,0 +1,8 @@
+import type { ConvertDocument } from "./schemas.js";
+/**
+ * Build the full pandoc CLI argument array from a validated request.
+ *
+ * Order: base args → --from/--to → preset extras → optional overrides → -o output → input
+ * This is the Pandoc equivalent of the FFmpeg buildFlags function.
+ */
+export declare function buildPandocArgs(req: ConvertDocument): string[];

package/dist/pandoc/build-args.js

@@ -0,0 +1,31 @@
+import { PANDOC_PRESET_SPECS, buildPandocBaseArgs } from "./preset-spec.js";
+// ── Pure arg builder — no I/O, fully deterministic ───────────────
+/**
+ * Build the full pandoc CLI argument array from a validated request.
+ *
+ * Order: base args → --from/--to → preset extras → optional overrides → -o output → input
+ * This is the Pandoc equivalent of the FFmpeg buildFlags function.
+ */
+export function buildPandocArgs(req) {
+    const spec = PANDOC_PRESET_SPECS[req.preset];
+    const args = [
+        ...buildPandocBaseArgs(),
+        "--from", spec.from,
+        "--to", spec.to,
+        ...spec.extraArgs,
+    ];
+    // ── Optional overrides from request ──────────────────────────
+    if (req.templatePath) {
+        args.push("--template", req.templatePath);
+    }
+    if (req.bibliographyPath) {
+        args.push("--bibliography", req.bibliographyPath);
+    }
+    if (req.cssPath) {
+        args.push("--css", req.cssPath);
+    }
+    // ── Output + input (must be last) ────────────────────────────
+    args.push("-o", req.outputPath);
+    args.push(req.inputPath);
+    return args;
+}

package/dist/pandoc/convert.d.ts

@@ -0,0 +1,38 @@
+import { type PandocDocumentAsset } from "./schemas.js";
+import { type PandocPresetSpec } from "./preset-spec.js";
+import type { PandocNotification } from "./types.js";
+import type { PandocInputCheck, PandocAssertionResult } from "./preflight.js";
+/** Throw if signal is already aborted. */
+export declare function throwIfAborted(signal: AbortSignal): void;
+/** Type guard for AbortError from any source. */
+export declare function isAbortError(err: unknown): boolean;
+/**
+ * Context provided by the caller (MCP handler, CLI, etc).
+ * Keeps the pipeline free of global state and fully testable.
+ */
+export interface ConvertDocumentContext {
+    signal: AbortSignal;
+    notify: (notification: PandocNotification) => void;
+    userId: string;
+    createAsset: (asset: PandocDocumentAsset) => Promise<void>;
+    /** Injected so tests can mock without real pandoc binary */
+    runPandoc: (args: string[], signal: AbortSignal, onProgress: (percent: number) => void, estimatedSteps: number) => Promise<void>;
+    /** Injected preflight — async (stat-based) */
+    checkInput: (filePath: string) => Promise<PandocInputCheck>;
+    /** Injected postflight — async (stat-based) */
+    assertOutput: (spec: PandocPresetSpec, outputPath: string, maxOutputBytes: number) => Promise<PandocAssertionResult>;
+    /** Injected stat for measuring output size */
+    statFile: (filePath: string) => Promise<{
+        size: number;
+    }>;
+}
+/**
+ * Full Pandoc document conversion pipeline.
+ *
+ * 1. Validate (Zod parse + sandbox)
+ * 2. Preflight input check
+ * 3. Build args + run pandoc (with fallback loop for premium presets)
+ * 4. Postflight assertion
+ * 5. Create asset + notify ready
+ */
+export declare function convertDocument(reqRaw: unknown, ctx: ConvertDocumentContext): Promise<PandocDocumentAsset>;

package/dist/pandoc/convert.js

@@ -0,0 +1,172 @@
+import { randomUUID } from "node:crypto";
+import { ConvertDocumentSchema, } from "./schemas.js";
+import { PANDOC_PRESET_SPECS, } from "./preset-spec.js";
+import { buildPandocArgs } from "./build-args.js";
+import { ensureCorrectExtension, buildOutputMetadata, computeExpiresAt, } from "./output-polish.js";
+// ── Abort helpers (same pattern as FFmpeg) ───────────────────────
+/** Throw if signal is already aborted. */
+export function throwIfAborted(signal) {
+    if (signal.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+}
+/** Type guard for AbortError from any source. */
+export function isAbortError(err) {
+    if (err instanceof DOMException && err.name === "AbortError")
+        return true;
+    if (err instanceof Error && err.name === "AbortError")
+        return true;
+    return false;
+}
+// ── Main pipeline ────────────────────────────────────────────────
+/**
+ * Full Pandoc document conversion pipeline.
+ *
+ * 1. Validate (Zod parse + sandbox)
+ * 2. Preflight input check
+ * 3. Build args + run pandoc (with fallback loop for premium presets)
+ * 4. Postflight assertion
+ * 5. Create asset + notify ready
+ */
+export async function convertDocument(reqRaw, ctx) {
+    // ── 1. Validate ─────────────────────────────────────────────────
+    throwIfAborted(ctx.signal);
+    const req = ConvertDocumentSchema.parse(reqRaw);
+    const assetId = randomUUID();
+    // Sandbox validation (throws on escape — imported via preflight re-export)
+    const { validateSandboxPath } = await import("./preflight.js");
+    validateSandboxPath(ctx.userId, req.inputPath);
+    validateSandboxPath(ctx.userId, req.outputPath);
+    // ── 2. Preflight input check ────────────────────────────────────
+    throwIfAborted(ctx.signal);
+    const inputCheck = await ctx.checkInput(req.inputPath);
+    const allWarnings = [...inputCheck.warnings];
+    if (!inputCheck.ok) {
+        throw new Error(`Preflight failed: ${inputCheck.warnings.join("; ")}`);
+    }
+    // Check format compatibility
+    const { checkFormatCompatibility } = await import("./preflight.js");
+    const formatCheck = checkFormatCompatibility(inputCheck.detectedFormat, PANDOC_PRESET_SPECS[req.preset].from);
+    if (formatCheck.warning) {
+        allWarnings.push(formatCheck.warning);
+    }
+    // Check estimated output size (hard reject if over limit)
+    if (req.maxOutputBytes > 0) {
+        const { estimatePandocOutputBytes } = await import("./preflight.js");
+        const est = estimatePandocOutputBytes(inputCheck.sizeBytes, req.preset);
+        if (est > req.maxOutputBytes) {
+            throw new Error(`Estimated output ${est} bytes exceeds maxOutputBytes ${req.maxOutputBytes}.`);
+        }
+    }
+    const inputMetadata = {
+        format: inputCheck.detectedFormat,
+        sizeBytes: inputCheck.sizeBytes,
+    };
+    // ── 3. Convert with fallback loop ───────────────────────────────
+    let currentPreset = req.preset;
+    const initialSpec = PANDOC_PRESET_SPECS[currentPreset];
+    const maxAttempts = initialSpec.isPremium && initialSpec.fallbackTo ? 2 : 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        throwIfAborted(ctx.signal);
+        const spec = PANDOC_PRESET_SPECS[currentPreset];
+        const args = buildPandocArgs({ ...req, preset: currentPreset });
+        // ── Run pandoc (catch errors for fallback) ──────────────────
+        let pandocFailed = false;
+        try {
+            await ctx.runPandoc(args, ctx.signal, (percent) => {
+                ctx.notify({
+                    type: "pandoc:progress",
+                    assetId,
+                    percent,
+                    preset: currentPreset,
+                });
+            }, spec.estimatedSteps);
+        }
+        catch (err) {
+            // AbortError always rethrows — no fallback
+            if (isAbortError(err))
+                throw err;
+            if (!spec.fallbackTo || attempt + 1 >= maxAttempts)
+                throw err;
+            allWarnings.push(`pandoc failed for ${currentPreset}: ${err instanceof Error ? err.message : String(err)}`);
+            pandocFailed = true;
+        }
+        if (!pandocFailed) {
+            // ── 4. Postflight assertion ─────────────────────────────────
+            throwIfAborted(ctx.signal);
+            const assertResult = await ctx.assertOutput(spec, req.outputPath, req.maxOutputBytes);
+            if (assertResult.ok) {
+                allWarnings.push(...assertResult.warnings);
+                // Final 100% progress before asset creation
+                ctx.notify({
+                    type: "pandoc:progress",
+                    assetId,
+                    percent: 100,
+                    preset: currentPreset,
+                });
+                // One last abort check before creating the asset
+                throwIfAborted(ctx.signal);
+                return buildAndNotifyAsset(assetId, req, inputMetadata, currentPreset, allWarnings, ctx);
+            }
+            // Assertion failed
+            allWarnings.push(...assertResult.warnings);
+        }
+        // ── Fallback to guaranteed preset ─────────────────────────────
+        if (spec.fallbackTo && attempt + 1 < maxAttempts) {
+            ctx.notify({
+                type: "pandoc:warning",
+                assetId,
+                warnings: [
+                    `${pandocFailed ? "Conversion" : "Assertion"} failed for ${currentPreset}, ` +
+                        `falling back to ${spec.fallbackTo}.`,
+                ],
+                preset: currentPreset,
+            });
+            currentPreset = spec.fallbackTo;
+            continue;
+        }
+        // No more fallbacks — if pandoc failed, the error was already thrown above
+        // Pandoc succeeded but assertion failed — return with warnings
+        throwIfAborted(ctx.signal);
+        return buildAndNotifyAsset(assetId, req, inputMetadata, currentPreset, allWarnings, ctx);
+    }
+    throw new Error("Convert loop exhausted without result.");
+}
+// ── Helper: build asset + fire notifications ─────────────────────
+async function buildAndNotifyAsset(assetId, req, inputMetadata, preset, warnings, ctx) {
+    const spec = PANDOC_PRESET_SPECS[preset];
+    // ── Output polish ─────────────────────────────────────────────
+    const finalPath = ensureCorrectExtension(req.outputPath, spec);
+    if (finalPath !== req.outputPath) {
+        warnings.push(`Output path auto-corrected from "${req.outputPath}" to "${finalPath}".`);
+    }
+    // Measure output
+    let outputSizeBytes = 0;
+    try {
+        const s = await ctx.statFile(finalPath);
+        outputSizeBytes = s.size;
+    }
+    catch {
+        warnings.push("Could not stat output file for metadata.");
+    }
+    const outputMetadata = buildOutputMetadata(spec, outputSizeBytes);
+    const asset = {
+        id: assetId,
+        inputPath: req.inputPath,
+        outputPath: finalPath,
+        preset,
+        inputMetadata,
+        outputMetadata,
+        warnings,
+        expiresAt: computeExpiresAt(),
+    };
+    await ctx.createAsset(asset);
+    ctx.notify({
+        type: "pandoc:ready",
+        assetId,
+        outputPath: finalPath,
+        preset,
+        sizeBytes: outputSizeBytes,
+    });
+    return asset;
+}

package/dist/pandoc/crud.d.ts

@@ -0,0 +1,10 @@
+import type { PandocDocumentCRUD } from "./types.js";
+/**
+ * Create an in-memory CRUD store for Pandoc document assets.
+ * Optionally persists to a JSON file on every write for dev/debug use.
+ *
+ * Matches the exact factory pattern from FFmpeg's createInMemoryCRUD.
+ *
+ * @param persistPath - optional path to a JSON file for persistence
+ */
+export declare function createPandocCRUD(persistPath?: string): PandocDocumentCRUD;

package/dist/pandoc/crud.js

@@ -0,0 +1,80 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+// ── In-memory Pandoc CRUD ────────────────────────────────────────
+/**
+ * Create an in-memory CRUD store for Pandoc document assets.
+ * Optionally persists to a JSON file on every write for dev/debug use.
+ *
+ * Matches the exact factory pattern from FFmpeg's createInMemoryCRUD.
+ *
+ * @param persistPath - optional path to a JSON file for persistence
+ */
+export function createPandocCRUD(persistPath) {
+    const store = new Map();
+    async function persist() {
+        if (!persistPath)
+            return;
+        await mkdir(path.dirname(persistPath), { recursive: true });
+        const data = JSON.stringify(Array.from(store.values()), null, 2);
+        await writeFile(persistPath, data, "utf8");
+    }
+    async function hydrate() {
+        if (!persistPath)
+            return;
+        try {
+            const data = await readFile(persistPath, "utf8");
+            const items = JSON.parse(data);
+            for (const item of items) {
+                store.set(item.id, item);
+            }
+        }
+        catch {
+            // File doesn't exist yet — start fresh
+        }
+    }
+    // Hydrate on first access (lazy)
+    let hydrated = false;
+    async function ensureHydrated() {
+        if (!hydrated) {
+            await hydrate();
+            hydrated = true;
+        }
+    }
+    return {
+        async create(asset) {
+            await ensureHydrated();
+            store.set(asset.id, asset);
+            await persist();
+            return asset;
+        },
+        async read(id) {
+            await ensureHydrated();
+            return store.get(id) ?? null;
+        },
+        async list(filter) {
+            await ensureHydrated();
+            const all = Array.from(store.values());
+            if (filter?.preset) {
+                return all.filter((a) => a.preset === filter.preset);
+            }
+            return all;
+        },
+        async update(id, patch) {
+            await ensureHydrated();
+            const existing = store.get(id);
+            if (!existing)
+                throw new Error(`Pandoc asset ${id} not found.`);
+            const updated = { ...existing, ...patch, id }; // id is immutable
+            store.set(id, updated);
+            await persist();
+            return updated;
+        },
+        async delete(id) {
+            await ensureHydrated();
+            if (!store.delete(id)) {
+                throw new Error(`Pandoc asset ${id} not found.`);
+            }
+            await persist();
+        },
+    };
+}

package/dist/pandoc/engine.test.d.ts

@@ -0,0 +1 @@
+export {};