videobook 0.0.0-stage → 0.2.0

package/dist/tools/create-qart.js

@@ -0,0 +1,253 @@
+import { z } from "zod";
+import QRCode from "qrcode";
+import sharp from "sharp";
+import { findImageFile } from "./_image-inputs.js";
+import { derivedLabel } from "../artifact-label.js";
+const DEFAULT_QART_SIZE = 2520;
+export const QART_QUIET_MODULES = 4;
+const QART_MIN_MODULE_PX = 3;
+export const QART_MIN_VERSION = 20;
+const QART_IMAGE_STRENGTH = 0.46;
+export const QART_DARK_MAX = Math.round(255 * QART_IMAGE_STRENGTH);
+export const QART_LIGHT_MIN = Math.round(255 * (1 - QART_IMAGE_STRENGTH));
+const LANDSCAPE_WIDTH = 1920;
+const LANDSCAPE_HEIGHT = 1080;
+const PORTRAIT_WIDTH = 1080;
+const PORTRAIT_HEIGHT = 1920;
+const SQUARE_SIZE = 1080;
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+function createQr(value) {
+    const automatic = QRCode.create(value, { errorCorrectionLevel: "H" });
+    const version = Math.max(QART_MIN_VERSION, automatic.version);
+    if (version === automatic.version)
+        return automatic;
+    return QRCode.create(value, { errorCorrectionLevel: "H", version });
+}
+async function sampleCover(coverBuffer, moduleCount) {
+    const sampled = await sharp(coverBuffer)
+        .rotate()
+        .sharpen({ sigma: 1.2 })
+        .modulate({ saturation: 1.25 })
+        .resize(moduleCount, moduleCount, { fit: "cover", position: "centre" })
+        .removeAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return { data: sampled.data, channels: sampled.info.channels };
+}
+function luma(r, g, b) {
+    return Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b);
+}
+function moduleColor(qr, sampled, row, col, style) {
+    const dark = qr.modules.get(row, col) === 1;
+    if (qr.modules.isReserved(row, col)) {
+        const channel = dark ? 0 : 255;
+        return [channel, channel, channel];
+    }
+    const sampleIndex = (row * qr.modules.size + col) * sampled.channels;
+    const r = sampled.data[sampleIndex] ?? 255;
+    const g = sampled.data[sampleIndex + 1] ?? 255;
+    const b = sampled.data[sampleIndex + 2] ?? 255;
+    let source;
+    if (style === "monochrome" || style === "inverted") {
+        const l = luma(r, g, b);
+        source = style === "inverted" ? [255 - l, 255 - l, 255 - l] : [l, l, l];
+    }
+    else {
+        source = [r, g, b];
+    }
+    const channels = source.map((channel) => dark
+        ? Math.round(channel * QART_IMAGE_STRENGTH)
+        : Math.round(255 - (255 - channel) * QART_IMAGE_STRENGTH));
+    return [channels[0], channels[1], channels[2]];
+}
+async function renderQart(qr, sampled, style, width, height) {
+    const moduleCount = qr.modules.size;
+    const totalModules = moduleCount + QART_QUIET_MODULES * 2;
+    const modulePx = Math.floor(Math.min(width, height) / totalModules);
+    if (modulePx < QART_MIN_MODULE_PX) {
+        const minimum = totalModules * QART_MIN_MODULE_PX;
+        throw new Error(`size is too small for QR version ${qr.version}; minimum is ${minimum}px`);
+    }
+    const gridSize = totalModules * modulePx;
+    const offsetX = Math.floor((width - gridSize) / 2);
+    const offsetY = Math.floor((height - gridSize) / 2);
+    const output = Buffer.alloc(width * height * 3, 255);
+    for (let row = 0; row < moduleCount; row++) {
+        for (let col = 0; col < moduleCount; col++) {
+            const color = moduleColor(qr, sampled, row, col, style);
+            const originX = offsetX + (col + QART_QUIET_MODULES) * modulePx;
+            const originY = offsetY + (row + QART_QUIET_MODULES) * modulePx;
+            for (let dy = 0; dy < modulePx; dy++) {
+                for (let dx = 0; dx < modulePx; dx++) {
+                    const outputIndex = ((originY + dy) * width + originX + dx) * 3;
+                    output[outputIndex] = color[0];
+                    output[outputIndex + 1] = color[1];
+                    output[outputIndex + 2] = color[2];
+                }
+            }
+        }
+    }
+    const buffer = await sharp(output, { raw: { width, height, channels: 3 } }).png().toBuffer();
+    return { buffer, width, height, modulePx, moduleCount, qrVersion: qr.version };
+}
+async function toJpeg(buffer) {
+    return sharp(buffer)
+        .jpeg({ quality: 98, chromaSubsampling: "4:4:4" })
+        .toBuffer();
+}
+async function buildStyleFiles(qr, sampled, style, size) {
+    const [original, landscapePng, portraitPng, squarePng] = await Promise.all([
+        renderQart(qr, sampled, style, size, size),
+        renderQart(qr, sampled, style, LANDSCAPE_WIDTH, LANDSCAPE_HEIGHT),
+        renderQart(qr, sampled, style, PORTRAIT_WIDTH, PORTRAIT_HEIGHT),
+        renderQart(qr, sampled, style, SQUARE_SIZE, SQUARE_SIZE),
+    ]);
+    const [landscape, portrait, square] = await Promise.all([
+        toJpeg(landscapePng.buffer),
+        toJpeg(portraitPng.buffer),
+        toJpeg(squarePng.buffer),
+    ]);
+    return {
+        original: original.buffer,
+        landscape,
+        portrait,
+        square,
+        modulePx: original.modulePx,
+    };
+}
+export async function buildQartPng(value, coverBuffer, options) {
+    const qr = createQr(value);
+    const sampled = await sampleCover(coverBuffer, qr.modules.size);
+    return renderQart(qr, sampled, options.style, options.size, options.size);
+}
+async function readCoverImage(engine, imageRef) {
+    const assetId = imageRef.replace(/^@/, "");
+    const artifact = engine.artifacts.get(assetId);
+    if (!artifact.ok)
+        return { ok: false, error: artifact.error.message };
+    if (artifact.value.kind !== "image") {
+        return { ok: false, error: `image_ref must be an image artifact, got ${artifact.value.kind}: ${assetId}` };
+    }
+    const manifestResult = await engine.files.manifest(assetId);
+    if (!manifestResult.ok)
+        return { ok: false, error: manifestResult.error.message };
+    const imageFile = findImageFile(manifestResult.value.files);
+    if (!imageFile)
+        return { ok: false, error: `No image file found in asset ${assetId}` };
+    const readResult = await engine.files.read(assetId, imageFile.name);
+    if (!readResult.ok)
+        return { ok: false, error: readResult.error.message };
+    const buffer = Buffer.isBuffer(readResult.value)
+        ? readResult.value
+        : Buffer.from(readResult.value);
+    return { ok: true, assetId, buffer };
+}
+async function persistQartAsset(engine, assetName, files, metadata) {
+    const created = await engine.artifacts.create("img", assetName);
+    if (!created.ok)
+        return { ok: false, error: `Failed to create image asset: ${created.error.message}` };
+    const assetId = created.value.artifactId;
+    const writes = await Promise.all([
+        engine.files.write(assetId, "original.png", files.original),
+        engine.files.write(assetId, "landscape.jpg", files.landscape),
+        engine.files.write(assetId, "portrait.jpg", files.portrait),
+        engine.files.write(assetId, "square.jpg", files.square),
+    ]);
+    const writeFailure = writes.find((result) => !result.ok);
+    if (writeFailure && !writeFailure.ok) {
+        await engine.artifacts.delete(assetId).catch(() => undefined);
+        return { ok: false, error: writeFailure.error.message };
+    }
+    const metadataResult = await engine.metadata.artifacts.write(assetId, "original", metadata);
+    if (!metadataResult.ok) {
+        await engine.artifacts.delete(assetId).catch(() => undefined);
+        return { ok: false, error: metadataResult.error.message };
+    }
+    return { ok: true, assetId };
+}
+export function createQartDef(engine) {
+    return {
+        name: "create_qart",
+        description: "Create scan-safe color and monochrome QR mosaics from a source image artifact. The image is sampled per QR module with protected QR structures and white quiet zones.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            image_ref: z.string().describe("Source image artifact id"),
+            value: z.string().min(1).describe("Text or URL encoded in the QR code"),
+            size: z
+                .number()
+                .int()
+                .min(256)
+                .max(4096)
+                .optional()
+                .describe(`Output edge length in pixels (default ${DEFAULT_QART_SIZE})`),
+            style: z
+                .enum(["color", "monochrome", "inverted"])
+                .optional()
+                .describe("Style of the QArt output. 'color', 'monochrome', or 'inverted' (default)"),
+            name: z.string().optional().describe("Optional base name for the generated assets"),
+        },
+        handler: async (args) => {
+            const { image_ref, value, size, style, name, } = args;
+            const resolvedValue = value.trim();
+            if (!resolvedValue)
+                return error("value must be a non-empty string");
+            const resolvedSize = size ?? DEFAULT_QART_SIZE;
+            const stylesToBuild = style ? [style] : ["inverted", "monochrome"];
+            const cover = await readCoverImage(engine, image_ref);
+            if (!cover.ok)
+                return error(cover.error);
+            const qr = createQr(resolvedValue);
+            const sampled = await sampleCover(cover.buffer, qr.modules.size);
+            const stem = name ?? cover.assetId;
+            const createdAt = new Date().toISOString();
+            const baseMeta = {
+                origin: "create_qart",
+                qart_style: "module_mosaic",
+                created_at: createdAt,
+                value: resolvedValue,
+                source_image: cover.assetId,
+                width: resolvedSize,
+                height: resolvedSize,
+                qr_version: qr.version,
+                error_correction: "H",
+                quiet_zone_modules: QART_QUIET_MODULES,
+                image_strength: QART_IMAGE_STRENGTH,
+                sample_grid: `${qr.modules.size}x${qr.modules.size}`,
+            };
+            const resultIds = {};
+            for (const s of stylesToBuild) {
+                let buildFiles;
+                try {
+                    buildFiles = await buildStyleFiles(qr, sampled, s, resolvedSize);
+                }
+                catch (err) {
+                    return error(`Failed to build QR mosaic: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                const resultAsset = await persistQartAsset(engine, derivedLabel(`qart ${s}`, stem), buildFiles, { ...baseMeta, color_mode: s, module_pixels: buildFiles.modulePx });
+                if (!resultAsset.ok)
+                    return error(resultAsset.error);
+                if (style) {
+                    resultIds.asset_id = resultAsset.assetId;
+                    resultIds.style = s;
+                }
+                else {
+                    resultIds[`${s}_asset_id`] = resultAsset.assetId;
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            ...resultIds,
+                            value: resolvedValue,
+                            size: resolvedSize,
+                            source_image: cover.assetId,
+                            qr_version: qr.version,
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/create-qr-outro.js

@@ -0,0 +1,149 @@
+import { findAudioFile } from "videobook-engine";
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { buildOutroSpec, orientationForAspectRatio, } from "../remotion/qr-outro-spec.js";
+import { findImageFile } from "./_image-inputs.js";
+function toolError(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+function normalizeAssetId(raw) {
+    return raw.trim().replace(/^@/, "");
+}
+async function resolveImageRef(engine, raw, field) {
+    const assetId = normalizeAssetId(raw);
+    const artifact = engine.artifacts.get(assetId);
+    if (!artifact.ok)
+        return { ok: false, error: artifact.error.message };
+    if (artifact.value.kind !== "image") {
+        return { ok: false, error: `${field} must be an image artifact, got ${artifact.value.kind}: ${assetId}` };
+    }
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok)
+        return { ok: false, error: manifest.error.message };
+    const file = findImageFile(manifest.value.files);
+    if (!file)
+        return { ok: false, error: `No image file found in asset ${assetId}` };
+    return { ok: true, value: { assetId, filename: file.name } };
+}
+async function resolveAudioRef(engine, raw) {
+    const assetId = normalizeAssetId(raw);
+    const artifact = engine.artifacts.get(assetId);
+    if (!artifact.ok)
+        return { ok: false, error: artifact.error.message };
+    if (artifact.value.kind !== "audio") {
+        return {
+            ok: false,
+            error: `sound_effect_ref must be an audio artifact, got ${artifact.value.kind}: ${assetId}`,
+        };
+    }
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok)
+        return { ok: false, error: manifest.error.message };
+    const file = findAudioFile(manifest.value.files, "audio");
+    if (!file)
+        return { ok: false, error: `No audio file found in asset ${assetId}` };
+    return { ok: true, value: { assetId, filename: file.name } };
+}
+export function createQrOutroDef(engine) {
+    return {
+        name: "create_qr_outro",
+        description: "Build a standalone animated outro from 1-4 QR image assets with configurable duration and optional impact audio.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            qr_image_refs: z
+                .array(z.string())
+                .min(1)
+                .max(4)
+                .describe("One to four QR code image artifact ids"),
+            sound_effect_ref: z
+                .string()
+                .optional()
+                .describe("Optional impact sound override (audio artifact id); defaults to the bundled sound"),
+            aspect_ratio: z
+                .enum(["16:9", "9:16", "1:1"])
+                .optional()
+                .describe("Output aspect ratio (default: 16:9)"),
+            duration_seconds: z
+                .number()
+                .min(3)
+                .max(60)
+                .optional()
+                .describe("Output duration in seconds from 3 to 60; defaults to the animation minimum"),
+            include_audio: z
+                .boolean()
+                .optional()
+                .describe("Include impact audio (default: true); set false for a silent output"),
+        },
+        handler: async (args) => {
+            const { book_id, qr_image_refs, sound_effect_ref, aspect_ratio = "16:9", duration_seconds, include_audio = true, } = args;
+            if (!include_audio && sound_effect_ref) {
+                return toolError("sound_effect_ref cannot be used when include_audio is false");
+            }
+            const qrImages = [];
+            for (const raw of qr_image_refs) {
+                const resolved = await resolveImageRef(engine, raw, "qr_image_refs entry");
+                if (!resolved.ok)
+                    return toolError(resolved.error);
+                qrImages.push(resolved.value);
+            }
+            let soundEffect = null;
+            if (include_audio && sound_effect_ref) {
+                const resolved = await resolveAudioRef(engine, sound_effect_ref);
+                if (!resolved.ok)
+                    return toolError(resolved.error);
+                soundEffect = resolved.value;
+            }
+            const spec = buildOutroSpec(aspect_ratio, qrImages.length, duration_seconds);
+            const created = await engine.artifacts.create("vid", `qr-outro-${qrImages[0].assetId}`);
+            if (!created.ok) {
+                return toolError(`Failed to create output asset: ${created.error.message}`);
+            }
+            const assetId = created.value.artifactId;
+            const jobId = `render-qr-outro-${assetId}-${Date.now()}`;
+            try {
+                await queue.enqueue(jobId, {
+                    type: "render_qr_outro",
+                    bookId: book_id,
+                    assetId,
+                    orientation: orientationForAspectRatio(aspect_ratio),
+                    qrImages,
+                    soundEffect,
+                    aspectRatio: aspect_ratio,
+                    durationSeconds: spec.totalDurationSeconds,
+                    includeAudio: include_audio,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const deleted = await engine.artifacts.delete(assetId);
+                if (!deleted.ok) {
+                    await engine.jobs.pending.forceFail(assetId, {
+                        message: `Enqueue failed and rollback failed: ${deleted.error.message}`,
+                    });
+                }
+                return toolError(`Failed to enqueue QR outro: ${message}`);
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id: assetId,
+                            job_id: jobId,
+                            status: "enqueued",
+                            aspect_ratio,
+                            duration_seconds: spec.totalDurationSeconds,
+                            qr_image_refs: qrImages.map((image) => image.assetId),
+                            include_audio,
+                            sound_effect_source: include_audio
+                                ? soundEffect ? "asset" : "bundled_default"
+                                : "none",
+                            ...(soundEffect ? { sound_effect_ref: soundEffect.assetId } : {}),
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/create-qrbtf.js

@@ -0,0 +1,215 @@
+import { z } from "zod";
+import sharp from "sharp";
+import { derivedLabel } from "../artifact-label.js";
+import { buildQrbtfSvg, wrapQrbtfSvg, } from "./qrbtf-render.js";
+export const DEFAULT_QRBTF_SIZE = 1024;
+const LANDSCAPE_WIDTH = 1920;
+const LANDSCAPE_HEIGHT = 1080;
+const PORTRAIT_WIDTH = 1080;
+const PORTRAIT_HEIGHT = 1920;
+const SQUARE_SIZE = 1080;
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+async function toJpeg(buffer) {
+    return sharp(buffer).jpeg({ quality: 98, chromaSubsampling: "4:4:4" }).toBuffer();
+}
+async function renderAtSize(content, viewBox, bgColor, width, height) {
+    const svg = wrapQrbtfSvg({ content, viewBox, bgColor }, width, height);
+    return sharp(Buffer.from(svg)).png().toBuffer();
+}
+async function renderVariant(content, viewBox, bgColor, width, height) {
+    const minDim = Math.min(width, height);
+    const qrPng = await renderAtSize(content, viewBox, bgColor, minDim, minDim);
+    const left = Math.floor((width - minDim) / 2);
+    const top = Math.floor((height - minDim) / 2);
+    if (left === 0 && top === 0)
+        return toJpeg(qrPng);
+    return sharp(qrPng)
+        .extend({
+        left,
+        top,
+        right: width - minDim - left,
+        bottom: height - minDim - top,
+        background: bgColor,
+    })
+        .jpeg({ quality: 98, chromaSubsampling: "4:4:4" })
+        .toBuffer();
+}
+async function buildQrbtfFiles(content, viewBox, bgColor, size) {
+    const [original, landscape, portrait, square] = await Promise.all([
+        renderAtSize(content, viewBox, bgColor, size, size),
+        renderVariant(content, viewBox, bgColor, LANDSCAPE_WIDTH, LANDSCAPE_HEIGHT),
+        renderVariant(content, viewBox, bgColor, PORTRAIT_WIDTH, PORTRAIT_HEIGHT),
+        renderVariant(content, viewBox, bgColor, SQUARE_SIZE, SQUARE_SIZE),
+    ]);
+    return {
+        original,
+        landscape,
+        portrait,
+        square,
+    };
+}
+export async function buildQrbtfPng(value, style, params, size) {
+    const r = buildQrbtfSvg(value, style, params);
+    const buffer = await renderAtSize(r.content, r.viewBox, r.bgColor, size, size);
+    return {
+        buffer,
+        width: size,
+        height: size,
+        qrVersion: r.version,
+        moduleCount: r.moduleCount,
+    };
+}
+async function persistQrbtfAsset(engine, assetName, files, metadata) {
+    const created = await engine.artifacts.create("img", assetName);
+    if (!created.ok)
+        return { ok: false, error: `Failed to create image asset: ${created.error.message}` };
+    const assetId = created.value.artifactId;
+    const writes = await Promise.all([
+        engine.files.write(assetId, "original.png", files.original),
+        engine.files.write(assetId, "landscape.jpg", files.landscape),
+        engine.files.write(assetId, "portrait.jpg", files.portrait),
+        engine.files.write(assetId, "square.jpg", files.square),
+    ]);
+    const writeFailure = writes.find((result) => !result.ok);
+    if (writeFailure && !writeFailure.ok) {
+        await engine.artifacts.delete(assetId).catch(() => undefined);
+        return { ok: false, error: writeFailure.error.message };
+    }
+    const metadataResult = await engine.metadata.artifacts.write(assetId, "original", metadata);
+    if (!metadataResult.ok) {
+        await engine.artifacts.delete(assetId).catch(() => undefined);
+        return { ok: false, error: metadataResult.error.message };
+    }
+    return { ok: true, assetId };
+}
+export function createQrbtfDef(engine) {
+    return {
+        name: "create_qrbtf",
+        description: "Generate parametric QR codes in artistic styles (normal, line, dsj, bubble, func) from the qrbtf library. Renders SVG and rasterizes to image assets. Black background with bright modules by default.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            value: z.string().min(1).describe("Text or URL encoded in the QR code"),
+            style: z
+                .enum(["normal", "line", "dsj", "bubble", "func"])
+                .optional()
+                .describe("QR style (default: normal)"),
+            point_type: z
+                .enum(["rect", "round", "rand"])
+                .optional()
+                .describe("Data point shape for normal/func styles"),
+            pos_type: z
+                .enum(["rect", "round", "planet", "roundRect"])
+                .optional()
+                .describe("Position detection pattern shape"),
+            direction: z
+                .enum(["left-right", "up-down", "h-v", "loop", "topLeft-bottomRight", "topRight-bottomLeft", "cross"])
+                .optional()
+                .describe("Line direction for line style"),
+            func_type: z
+                .enum(["A", "B"])
+                .optional()
+                .describe("Function type for func style"),
+            other_color: z
+                .string()
+                .optional()
+                .describe("Data module color (hex, e.g. #FFFFFF)"),
+            other_color_2: z
+                .string()
+                .optional()
+                .describe("Secondary color for func style (hex)"),
+            pos_color: z
+                .string()
+                .optional()
+                .describe("Position pattern color (hex)"),
+            bg_color: z
+                .string()
+                .optional()
+                .describe("Background / quiet-zone color (hex, default #000000)"),
+            size: z
+                .number()
+                .int()
+                .min(256)
+                .max(4096)
+                .optional()
+                .describe(`Output edge length in pixels (default ${DEFAULT_QRBTF_SIZE})`),
+            name: z.string().optional().describe("Optional base name for the generated asset"),
+        },
+        handler: async (args) => {
+            const { value, style, point_type, pos_type, direction, func_type, other_color, other_color_2, pos_color, bg_color, size, name, } = args;
+            const resolvedValue = value.trim();
+            if (!resolvedValue)
+                return error("value must be a non-empty string");
+            const resolvedStyle = style ?? "normal";
+            const resolvedSize = size ?? DEFAULT_QRBTF_SIZE;
+            const params = {};
+            if (point_type)
+                params.pointType = point_type;
+            if (pos_type)
+                params.posType = pos_type;
+            if (direction)
+                params.direction = direction;
+            if (func_type)
+                params.funcType = func_type;
+            if (other_color)
+                params.otherColor = other_color;
+            if (other_color_2)
+                params.otherColor2 = other_color_2;
+            if (pos_color)
+                params.posColor = pos_color;
+            if (bg_color)
+                params.bgColor = bg_color;
+            const r = buildQrbtfSvg(resolvedValue, resolvedStyle, params);
+            let files;
+            try {
+                files = await buildQrbtfFiles(r.content, r.viewBox, r.bgColor, resolvedSize);
+            }
+            catch (err) {
+                return error(`Failed to render QR: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            const stem = name ?? resolvedStyle;
+            const createdAt = new Date().toISOString();
+            const metadata = {
+                origin: "create_qrbtf",
+                qrbtf_style: resolvedStyle,
+                created_at: createdAt,
+                value: resolvedValue,
+                width: resolvedSize,
+                height: resolvedSize,
+                qr_version: r.version,
+                error_correction: "H",
+                bg_color: r.bgColor,
+                module_count: r.moduleCount,
+            };
+            if (other_color)
+                metadata.other_color = other_color;
+            if (pos_color)
+                metadata.pos_color = pos_color;
+            if (point_type)
+                metadata.point_type = point_type;
+            if (pos_type)
+                metadata.pos_type = pos_type;
+            if (direction)
+                metadata.direction = direction;
+            if (func_type)
+                metadata.func_type = func_type;
+            const resultAsset = await persistQrbtfAsset(engine, derivedLabel("qrbtf", stem), files, metadata);
+            if (!resultAsset.ok)
+                return error(resultAsset.error);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id: resultAsset.assetId,
+                            value: resolvedValue,
+                            style: resolvedStyle,
+                            size: resolvedSize,
+                            qr_version: r.version,
+                            bg_color: r.bgColor,
+                        }),
+                    }],
+            };
+        },
+    };
+}