@ethercorps/sveltekit-og 4.3.0-next.1 → 4.3.0-next.10

package/dist/fonts.js

@@ -1,5 +1,4 @@
 import { FONT_CACHE_MAP } from "./helpers/cache.js";
-import { logger } from "./helpers/logger.js";
 /** * Base font class defining the structure required by Satori.
  * All font types inherit from this class.
  */
@@ -64,26 +63,22 @@ export const loadGoogleFont = async (family, { text, weight = 400, style = "norm
     }
     const cssResponse = await fetch(cssUrl);
     if (!cssResponse.ok) {
-        logger.error(`Failed to fetch Google Font CSS for ${family}. Status: ${cssResponse.status}`);
         throw new Error(`Failed to fetch Google Font CSS for ${family}. Status: ${cssResponse.status}`);
     }
     const css = await cssResponse.text();
     // 3. Extract the font file URL (the actual TTF/OTF file)
     const fontUrl = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/)?.[1];
     if (!fontUrl) {
-        logger.error(`Could not find a compatible truetype font source in the CSS for ${family}.`);
         throw new Error(`Could not find a compatible truetype font source in the CSS for ${family}.`);
     }
     // 4. Fetch the font buffer
     const fontResponse = await fetch(fontUrl);
     if (!fontResponse.ok) {
-        logger.error(`Failed to fetch font file from URL. Status: ${fontResponse.status}`);
         throw new Error(`Failed to fetch font file from URL. Status: ${fontResponse.status}`);
     }
     const buffer = await fontResponse.arrayBuffer();
     // 5. CACHE AND RETURN: Store the resolved ArrayBuffer in the Map, keyed by the CSS URL.
     FONT_CACHE_MAP.set(cssUrl, buffer);
-    logger.debug(`Loaded Google Font: ${family}`);
     return buffer;
 };
 export class GoogleFont extends BaseFont {

package/dist/helpers/create.js

@@ -2,37 +2,39 @@ import { loadDynamicAsset } from "./emoji.js";
 import { default_fonts, DEFAULT_WIDTH } from "../helpers/defaults.js";
 import { useResvg, useSatori } from "../providers/instances.js";
 import { createVNode } from "./toJSX.js";
-import { logger } from "./logger.js";
+import { createLogger } from "./logger.js";
+import { handleAsyncAll, handleAsync, ErrorCodes } from "./error-handler.js";
 export async function createSvg(element, imageOptions, componentOptions) {
-    const [satori, vnodes] = await Promise.all([
-        useSatori(),
-        createVNode(element, componentOptions),
-    ]);
+    const log = createLogger(imageOptions.debug ?? false);
+    const [satori, vnodes] = await handleAsyncAll([() => useSatori(imageOptions.debug), () => Promise.resolve(createVNode(element, componentOptions))], ErrorCodes.SATORI_RENDER_FAILED, "Failed to initialize Satori or create VNode");
     const satoriOptions = structuredClone(imageOptions);
     if (!Object.hasOwn(satoriOptions, "fonts")) {
-        satoriOptions["fonts"] = await default_fonts();
+        satoriOptions["fonts"] = await handleAsync(() => default_fonts(), ErrorCodes.FONT_LOAD_FAILED, "Failed to load default fonts for Satori");
     }
     satoriOptions["loadAdditionalAsset"] = loadDynamicAsset({
         emoji: imageOptions.emoji,
     });
-    logger.debug("Generating SVG with Satori");
-    logger.info("VNode provided to satori:", JSON.stringify(vnodes, null, 2), "\n");
-    logger.info("Options provided to satori:", imageOptions);
-    return satori(vnodes, satoriOptions);
+    log.debug("Generating SVG with Satori");
+    log.info("VNode provided to satori:", JSON.stringify(vnodes, null, 2), "\n");
+    log.info("Options provided to satori:", imageOptions);
+    return handleAsync(() => satori(vnodes, satoriOptions), ErrorCodes.SATORI_RENDER_FAILED, "Failed to render SVG with Satori");
 }
 export async function createPng(element, imageOptions, componentOptions) {
-    const svg = await createSvg(element, imageOptions, componentOptions);
-    logger.debug("SVG generated by satori for ReSVG: \n", svg, "\n");
-    const resvg_instance = await useResvg();
+    const log = createLogger(imageOptions.debug ?? false);
+    const svg = await handleAsync(() => createSvg(element, imageOptions, componentOptions), ErrorCodes.SATORI_RENDER_FAILED, "Failed to create SVG for PNG rendering");
+    log.debug("SVG generated by satori for ReSVG: \n", svg, "\n");
+    const resvg_instance = await handleAsync(() => useResvg(imageOptions.debug), ErrorCodes.RESVG_INIT_FAILED, "Failed to initialize ReSVG");
     const resvg_options = {
         fitTo: {
             mode: "width",
             value: imageOptions.width || DEFAULT_WIDTH,
         },
     };
-    logger.debug("Rendering PNG with ReSVG");
-    logger.info("Options provided to ReSVG:", resvg_options, "\n");
-    const resvg = new resvg_instance(svg, resvg_options);
-    const png_data = resvg.render();
-    return png_data.asPng();
+    log.debug("Rendering PNG with ReSVG");
+    log.info("Options provided to ReSVG:", resvg_options, "\n");
+    return handleAsync(async () => {
+        const resvg = new resvg_instance(svg, resvg_options);
+        const png_data = resvg.render();
+        return png_data.asPng();
+    }, ErrorCodes.RESVG_RENDER_FAILED, "Failed to render PNG with ReSVG");
 }

package/dist/helpers/defaults.js

@@ -1,16 +1,13 @@
+import { handleAsyncAll, validateResponse, ErrorCodes } from "./error-handler.js";
 export async function default_fonts() {
-    const [noto_sans_regular_font_resp, noto_sans_bold_font_reps] = await Promise.all([
-        fetch("https://cdn-sveltekit-og.ethercorps.io/NotoSans-Regular.ttf"),
-        fetch("https://cdn-sveltekit-og.ethercorps.io/NotoSans-Bold.ttf"),
-    ]);
-    if (!(noto_sans_bold_font_reps.ok || noto_sans_bold_font_reps.ok)) {
-        console.error("Not able to load default fonts");
-        throw new Error("Not able to load default fonts");
-    }
-    const [noto_sans_regular_font, noto_sans_bold_font] = await Promise.all([
-        noto_sans_regular_font_resp.arrayBuffer(),
-        noto_sans_bold_font_reps.arrayBuffer(),
-    ]);
+    const [noto_sans_regular_font_resp, noto_sans_bold_font_reps] = await handleAsyncAll([
+        () => fetch("https://cdn-sveltekit-og.ethercorps.io/NotoSans-Regular.ttf"),
+        () => fetch("https://cdn-sveltekit-og.ethercorps.io/NotoSans-Bold.ttf"),
+    ], ErrorCodes.FONT_LOAD_FAILED, "Failed to fetch default fonts");
+    const [noto_sans_regular_font, noto_sans_bold_font] = await handleAsyncAll([
+        () => validateResponse(noto_sans_regular_font_resp, ErrorCodes.FONT_LOAD_FAILED, "Failed to validate regular font response"),
+        () => validateResponse(noto_sans_bold_font_reps, ErrorCodes.FONT_LOAD_FAILED, "Failed to validate bold font response"),
+    ], ErrorCodes.FONT_LOAD_FAILED, "Failed to process font responses");
     return [
         {
             data: noto_sans_regular_font,

package/dist/helpers/emoji.js

@@ -1,4 +1,5 @@
 import { DEFAULT_EMOJI_PROVIDER } from "../helpers/defaults.js";
+import { handleAsync, ErrorCodes } from "./error-handler.js";
 // Code stolen from @vercel/og and https://github.com/fineshopdesign/cf-wasm
 const U200D = String.fromCharCode(8205);
 const UFE0Fg = /\uFE0F/g;
@@ -37,24 +38,28 @@ const emoji_apis = {
         code.toLowerCase() +
         "_flat.svg",
 };
-function loadEmoji(code, type) {
-    if (!type || !emoji_apis[type]) {
-        type = DEFAULT_EMOJI_PROVIDER;
-    }
-    const api = emoji_apis[type];
-    if (typeof api === "function") {
-        return fetch(api(code));
-    }
-    return fetch(`${api}${code.toUpperCase()}.svg`);
+async function loadEmoji(code, type) {
+    return handleAsync(async () => {
+        if (!type || !emoji_apis[type]) {
+            type = DEFAULT_EMOJI_PROVIDER;
+        }
+        const api = emoji_apis[type];
+        if (typeof api === "function") {
+            return fetch(api(code));
+        }
+        return fetch(`${api}${code.toUpperCase()}.svg`);
+    }, ErrorCodes.EMOJI_LOAD_FAILED, `Failed to load emoji for code: ${code}`);
 }
 export const loadDynamicAsset = ({ emoji }) => {
     const fn = async (code, text) => {
         if (code === "emoji") {
-            const iconCode = getIconCode(text);
-            const emojiResponse = await loadEmoji(iconCode, emoji);
-            const svgText = await emojiResponse.text();
-            const base64Data = btoa(svgText);
-            return `data:image/svg+xml;base64,` + base64Data;
+            return handleAsync(async () => {
+                const iconCode = getIconCode(text);
+                const emojiResponse = await loadEmoji(iconCode, emoji);
+                const svgText = await emojiResponse.text();
+                const base64Data = btoa(svgText);
+                return `data:image/svg+xml;base64,` + base64Data;
+            }, ErrorCodes.EMOJI_LOAD_FAILED, `Failed to process emoji: ${text}`);
         }
     };
     return async (...args) => {

package/dist/helpers/error-handler.d.ts

@@ -0,0 +1,37 @@
+export declare class ImageResponseError extends Error {
+    code: string;
+    originalError?: Error | undefined;
+    constructor(message: string, code: string, originalError?: Error | undefined);
+}
+/** Coerce anything thrown into an ImageResponseError, keeping existing ones as-is. */
+export declare function toImageResponseError(error: unknown): ImageResponseError;
+export declare const ErrorCodes: {
+    readonly FONT_LOAD_FAILED: "FONT_LOAD_FAILED";
+    readonly VNODE_CREATION_FAILED: "VNODE_CREATION_FAILED";
+    readonly SATORI_RENDER_FAILED: "SATORI_RENDER_FAILED";
+    readonly RESVG_INIT_FAILED: "RESVG_INIT_FAILED";
+    readonly RESVG_RENDER_FAILED: "RESVG_RENDER_FAILED";
+    readonly SATORI_INIT_FAILED: "SATORI_INIT_FAILED";
+    readonly EMOJI_LOAD_FAILED: "EMOJI_LOAD_FAILED";
+    readonly TAKUMI_INIT_FAILED: "TAKUMI_INIT_FAILED";
+    readonly TAKUMI_RENDER_FAILED: "TAKUMI_RENDER_FAILED";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+/**
+ * Wraps an async operation with error handling and logging
+ */
+export declare function handleAsync<T = unknown>(operation: () => Promise<T>, errorCode: string, errorMessage: string): Promise<T>;
+/**
+ * Wraps a sync operation with error handling and logging
+ */
+export declare function handleSync<T>(operation: () => T, errorCode: string, errorMessage: string): T;
+/**
+ * Wraps multiple async operations with error handling
+ */
+export declare function handleAsyncAll<T extends readonly unknown[]>(operations: {
+    readonly [K in keyof T]: () => Promise<T[K]>;
+}, errorCode: string, errorMessage: string): Promise<T>;
+/**
+ * Validates a response and throws if not ok
+ */
+export declare function validateResponse(response: Response, errorCode: string, errorMessage: string): Promise<ArrayBuffer>;

package/dist/helpers/error-handler.js

@@ -0,0 +1,75 @@
+export class ImageResponseError extends Error {
+    code;
+    originalError;
+    constructor(message, code, originalError) {
+        super(message);
+        this.code = code;
+        this.originalError = originalError;
+        this.name = "ImageResponseError";
+    }
+}
+/** Coerce anything thrown into an ImageResponseError, keeping existing ones as-is. */
+export function toImageResponseError(error) {
+    if (error instanceof ImageResponseError)
+        return error;
+    const err = error instanceof Error ? error : new Error(String(error));
+    return new ImageResponseError(err.message, ErrorCodes.UNKNOWN_ERROR, err);
+}
+export const ErrorCodes = {
+    FONT_LOAD_FAILED: "FONT_LOAD_FAILED",
+    VNODE_CREATION_FAILED: "VNODE_CREATION_FAILED",
+    SATORI_RENDER_FAILED: "SATORI_RENDER_FAILED",
+    RESVG_INIT_FAILED: "RESVG_INIT_FAILED",
+    RESVG_RENDER_FAILED: "RESVG_RENDER_FAILED",
+    SATORI_INIT_FAILED: "SATORI_INIT_FAILED",
+    EMOJI_LOAD_FAILED: "EMOJI_LOAD_FAILED",
+    TAKUMI_INIT_FAILED: "TAKUMI_INIT_FAILED",
+    TAKUMI_RENDER_FAILED: "TAKUMI_RENDER_FAILED",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR",
+};
+/**
+ * Wraps an async operation with error handling and logging
+ */
+export async function handleAsync(operation, errorCode, errorMessage) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        throw new ImageResponseError(errorMessage, errorCode, err);
+    }
+}
+/**
+ * Wraps a sync operation with error handling and logging
+ */
+export function handleSync(operation, errorCode, errorMessage) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        throw new ImageResponseError(errorMessage, errorCode, err);
+    }
+}
+/**
+ * Wraps multiple async operations with error handling
+ */
+export async function handleAsyncAll(operations, errorCode, errorMessage) {
+    try {
+        return (await Promise.all(operations.map((op) => op())));
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        throw new ImageResponseError(errorMessage, errorCode, err);
+    }
+}
+/**
+ * Validates a response and throws if not ok
+ */
+export async function validateResponse(response, errorCode, errorMessage) {
+    if (!response.ok) {
+        throw new ImageResponseError(`${errorMessage} (HTTP ${response.status})`, errorCode);
+    }
+    const buffer = await response.arrayBuffer();
+    return buffer;
+}

package/dist/helpers/logger.d.ts

@@ -1,13 +1,5 @@
-/**
- * Set the debug flag for the current request context
- * Call this once at the beginning of your request handler
- */
-export declare function setDebug(enabled: boolean): void;
-/**
- * Get the current debug flag from the request context
- */
-export declare function isDebugEnabled(): boolean;
-export declare const logger: {
+export type Logger = ReturnType<typeof createLogger>;
+export declare function createLogger(debug: boolean): {
     debug: (message: string, ...args: unknown[]) => void;
     info: (message: string, ...args: unknown[]) => void;
     warn: (message: string, ...args: unknown[]) => void;

package/dist/helpers/logger.js

@@ -1,39 +1,21 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 const PREFIX = '[SvelteKit-OG]';
-// Store for request-scoped debug flag
-const debugStorage = new AsyncLocalStorage();
-/**
- * Set the debug flag for the current request context
- * Call this once at the beginning of your request handler
- */
-export function setDebug(enabled) {
-    debugStorage.enterWith(enabled);
-}
-/**
- * Get the current debug flag from the request context
- */
-export function isDebugEnabled() {
-    return debugStorage.getStore() ?? false;
-}
-export const logger = {
-    debug: (message, ...args) => {
-        if (isDebugEnabled()) {
-            console.log(`${PREFIX} 🔍 ${message}`, ...args);
-        }
-    },
-    info: (message, ...args) => {
-        if (isDebugEnabled()) {
-            console.info(`${PREFIX} ℹ️ ${message}`, ...args);
+export function createLogger(debug) {
+    return {
+        debug: (message, ...args) => {
+            if (debug)
+                console.log(`${PREFIX} 🔍 ${message}`, ...args);
+        },
+        info: (message, ...args) => {
+            if (debug)
+                console.info(`${PREFIX} ℹ️ ${message}`, ...args);
+        },
+        warn: (message, ...args) => {
+            if (debug)
+                console.warn(`${PREFIX} ⚠️ ${message}`, ...args);
+        },
+        error: (message, ...args) => {
+            if (debug)
+                console.error(`${PREFIX} ❌ ${message}`, ...args);
         }
-    },
-    warn: (message, ...args) => {
-        if (isDebugEnabled()) {
-            console.warn(`${PREFIX} ⚠️ ${message}`, ...args);
-        }
-    },
-    error: (message, ...args) => {
-        if (isDebugEnabled()) {
-            console.error(`${PREFIX} ❌ ${message}`, ...args);
-        }
-    }
-};
+    };
+}

package/dist/helpers/response.d.ts

@@ -0,0 +1,20 @@
+type ImageProducer = () => Promise<Uint8Array | string>;
+interface BuildOptions {
+    /** uppercased format, used in logs e.g. "PNG" */
+    label: string;
+    contentType: string;
+    debug: boolean;
+    headers?: Record<string, string>;
+    status?: number;
+    statusText?: string;
+}
+/**
+ * Shared body + response init for both engines' ImageResponse. Streams the image
+ * out as bytes (a Response stream can't take a raw string), with consistent
+ * cache headers and error handling.
+ */
+export declare function buildImageResponse(produce: ImageProducer, opts: BuildOptions): {
+    body: ReadableStream;
+    init: ResponseInit;
+};
+export {};

package/dist/helpers/response.js

@@ -0,0 +1,39 @@
+import { createLogger } from "./logger.js";
+import { handleAsync, toImageResponseError, ErrorCodes } from "./error-handler.js";
+import { formatBytes } from "./utils.js";
+/**
+ * Shared body + response init for both engines' ImageResponse. Streams the image
+ * out as bytes (a Response stream can't take a raw string), with consistent
+ * cache headers and error handling.
+ */
+export function buildImageResponse(produce, opts) {
+    const log = createLogger(opts.debug);
+    const body = new ReadableStream({
+        async start(controller) {
+            try {
+                const out = await handleAsync(produce, ErrorCodes.UNKNOWN_ERROR, `Failed to generate ${opts.label}`);
+                const bytes = typeof out === "string" ? new TextEncoder().encode(out) : out;
+                log.info(`Generated ${opts.label}: ${formatBytes(bytes.byteLength)}`);
+                controller.enqueue(bytes);
+                controller.close();
+            }
+            catch (error) {
+                const err = toImageResponseError(error);
+                log.error("Failed to create image response:", err.message);
+                controller.error(err);
+            }
+        },
+    });
+    const init = {
+        headers: {
+            "Content-Type": opts.contentType,
+            "Cache-Control": opts.debug
+                ? "no-cache, no-store"
+                : "public, immutable, no-transform, max-age=31536000",
+            ...opts.headers,
+        },
+        status: opts.status || 200,
+        statusText: opts.statusText || "Success",
+    };
+    return { body, init };
+}

package/dist/helpers/to-html.d.ts

@@ -0,0 +1,10 @@
+import type { Component } from "svelte";
+/**
+ * Render a Svelte component to its SSR html parts. Shared by both engines — satori
+ * feeds body+head to satori-html, takumi passes the html string straight in. Use
+ * `<svelte:options css="injected" />` to get component styles into `head`.
+ */
+export declare function renderComponentToHtml(component: Component<any>, props?: Record<string, unknown>): {
+    head: string;
+    body: string;
+};

package/dist/helpers/to-html.js

@@ -0,0 +1,10 @@
+import { render } from "svelte/server";
+import { handleSync, ErrorCodes } from "./error-handler.js";
+/**
+ * Render a Svelte component to its SSR html parts. Shared by both engines — satori
+ * feeds body+head to satori-html, takumi passes the html string straight in. Use
+ * `<svelte:options css="injected" />` to get component styles into `head`.
+ */
+export function renderComponentToHtml(component, props = {}) {
+    return handleSync(() => render(component, { props }), ErrorCodes.VNODE_CREATION_FAILED, "Failed to render Svelte component to HTML");
+}

package/dist/helpers/toJSX.js

@@ -1,11 +1,14 @@
-import { render } from "svelte/server";
 import { html } from "satori-html";
+import { handleSync, ErrorCodes } from "./error-handler.js";
+import { renderComponentToHtml } from "./to-html.js";
 function svelteComponentToHTML(component, props = {}) {
-    const { body, head } = render(component, { props });
-    return html(body + head);
+    return handleSync(() => {
+        const { body, head } = renderComponentToHtml(component, props);
+        return html(body + head);
+    }, ErrorCodes.VNODE_CREATION_FAILED, "Failed to render Svelte component to HTML");
 }
 export function createVNode(element, componentOptions) {
-    return typeof element === "string"
+    return handleSync(() => typeof element === "string"
         ? html(element.replaceAll("\n", "").trim())
-        : svelteComponentToHTML(element, componentOptions?.props);
+        : svelteComponentToHTML(element, componentOptions?.props), ErrorCodes.VNODE_CREATION_FAILED, "Failed to create VNode");
 }

package/dist/helpers/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const formatBytes: (bytes: number, decimals?: number) => string;
+export declare function importWasm(input: any): Promise<any>;

package/dist/helpers/utils.js

@@ -0,0 +1,25 @@
+const sizeFormats = ["Bytes", "KB", "MB", "GB"];
+const kbSize = 1024;
+export const formatBytes = (bytes, decimals = 2) => {
+    if (bytes === 0)
+        return "0 Bytes";
+    const decimalPoint = decimals < 0 ? 0 : decimals;
+    const sizeIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(kbSize)), 3);
+    return (parseFloat((bytes / Math.pow(kbSize, sizeIndex)).toFixed(decimalPoint)) +
+        " " +
+        sizeFormats[sizeIndex]);
+};
+export async function importWasm(input) {
+    // may be a nested await for some reason
+    const _input = await input;
+    const _module = _input.default || _input;
+    // this is from rollup/wasm, it does some magic we need to recover from
+    if (typeof _module === "function") {
+        // empty input is to avoid instantiating the wasm module
+        // this will just compile it
+        const fnRes = await _module();
+        const _instance = fnRes.instance || fnRes;
+        return _instance.exports || _instance || _module;
+    }
+    return _module;
+}

package/dist/image-response.js

@@ -1,31 +1,19 @@
-import { DEFAULT_OPTIONS, DEFAULT_STATUS_CODE, DEFAULT_STATUS_TEXT } from "./helpers/defaults.js";
+import { DEFAULT_OPTIONS } from "./helpers/defaults.js";
 import { createPng, createSvg } from "./helpers/create.js";
-import { isDebugEnabled, logger, setDebug } from "./helpers/logger.js";
+import { buildImageResponse } from "./helpers/response.js";
 export class ImageResponse extends Response {
     constructor(element, options, props) {
-        const extended_options = Object.assign({ ...DEFAULT_OPTIONS }, options);
-        setDebug(extended_options.debug ?? false);
-        logger.debug("Debug mode", isDebugEnabled());
-        const create_image_function = extended_options.format === "png" ? createPng : createSvg;
-        const body = new ReadableStream({
-            async start(controller) {
-                const buffer = await create_image_function(element, extended_options, {
-                    props,
-                });
-                controller.enqueue(buffer);
-                controller.close();
-            },
-        });
-        super(body, {
-            headers: {
-                "Content-Type": `image/${extended_options.format}${extended_options.format === "svg" ? "+xml" : ""}`,
-                "Cache-Control": extended_options.debug
-                    ? "no-cache, no-store"
-                    : "public, immutable, no-transform, max-age=31536000",
-                ...extended_options.headers,
-            },
-            status: extended_options.status || DEFAULT_STATUS_CODE,
-            statusText: extended_options.statusText || DEFAULT_STATUS_TEXT,
+        const opts = Object.assign({ ...DEFAULT_OPTIONS }, options);
+        const format = opts.format ?? "png";
+        const createImage = format === "png" ? createPng : createSvg;
+        const { body, init } = buildImageResponse(() => createImage(element, opts, { props }), {
+            label: format.toUpperCase(),
+            contentType: `image/${format}${format === "svg" ? "+xml" : ""}`,
+            debug: opts.debug ?? false,
+            headers: opts.headers,
+            status: opts.status,
+            statusText: opts.statusText,
         });
+        super(body, init);
     }
 }

package/dist/providers/instances.d.ts

@@ -1,5 +1,5 @@
 import type _satori from "satori";
-export declare function useResvg(): Promise<new (svg: Uint8Array | string, options?: import("@resvg/resvg-wasm").ResvgRenderOptions) => {
+export declare function useResvg(debug?: boolean): Promise<new (svg: Uint8Array | string, options?: import("@resvg/resvg-wasm").ResvgRenderOptions) => {
     free(): void;
     render(): {
         free(): void;
@@ -35,4 +35,4 @@ export declare function useResvg(): Promise<new (svg: Uint8Array | string, optio
     readonly height: number;
     readonly width: number;
 }>;
-export declare function useSatori(): Promise<typeof _satori>;
+export declare function useSatori(debug?: boolean): Promise<typeof _satori>;

package/dist/providers/instances.js

@@ -1,5 +1,6 @@
 import { isEdgeLight, isWorkerd } from "std-env";
-import { logger } from "../helpers/logger.js";
+import { createLogger } from "../helpers/logger.js";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
 // we keep instances alive to avoid re-importing them on every request, maybe not needed but
 // also helps with type inference
 // Code from vue-og-images
@@ -9,24 +10,35 @@ const resvgInstance = {
 const satoriInstance = {
     instance: undefined,
 };
-export async function useResvg() {
+export async function useResvg(debug = false) {
+    const log = createLogger(debug);
     if (resvgInstance.instance) {
         return resvgInstance.instance.Resvg;
     }
-    logger.debug("Initializing Resvg WASM");
+    log.debug("Initializing ReSVG WASM");
     const isWorkerLikeRuntime = isEdgeLight || isWorkerd;
-    logger.info(`Detected runtime: ${isWorkerLikeRuntime ? "Edge Light or Workerd" : "Node.js"}`);
-    const moduleImport = isWorkerLikeRuntime ? import(`./resvg/edge.js`) : import("./resvg/node.js");
-    resvgInstance.instance = await moduleImport.then((m) => m.default);
-    await resvgInstance.instance.initWasmPromise;
+    log.info(`Detected runtime: ${isWorkerLikeRuntime ? "Edge Light or Workerd" : "Node.js"}`);
+    // workers take a precompiled `?module`; node takes raw wasm bytes. keep both
+    // as direct import() expressions so the bundler can emit the wasm chunk.
+    const moduleImport = isWorkerLikeRuntime
+        ? import("./resvg/edge.js")
+        : import("./resvg/node.js");
+    resvgInstance.instance = await handleAsync(() => moduleImport.then((m) => m.default), ErrorCodes.RESVG_INIT_FAILED, "Failed to import ReSVG module");
+    await handleAsync(() => resvgInstance.instance.initWasmPromise, ErrorCodes.RESVG_INIT_FAILED, "Failed to initialize ReSVG WASM");
     return resvgInstance.instance.Resvg;
 }
-export async function useSatori() {
+export async function useSatori(debug = false) {
+    const log = createLogger(debug);
     if (satoriInstance.instance) {
         return satoriInstance.instance.satori;
     }
-    logger.debug("Initializing Satori WASM");
-    satoriInstance.instance = await import(`./satori/node.js`).then((m) => m.default);
-    await satoriInstance.instance.initWasmPromise;
+    log.debug("Initializing Satori");
+    const isWorkerLikeRuntime = isEdgeLight || isWorkerd;
+    log.info(`Detected runtime: ${isWorkerLikeRuntime ? "Edge Light or Workerd" : "Node.js"}`);
+    const moduleImport = isWorkerLikeRuntime
+        ? import("./satori/edge.js")
+        : import("./satori/node.js");
+    satoriInstance.instance = await handleAsync(() => moduleImport.then((m) => m.default), ErrorCodes.SATORI_INIT_FAILED, "Failed to import Satori module");
+    await handleAsync(() => satoriInstance.instance.initWasmPromise, ErrorCodes.SATORI_INIT_FAILED, "Failed to initialize Satori WASM");
     return satoriInstance.instance.satori;
 }

package/dist/providers/resvg/edge.js

@@ -1,9 +1,11 @@
 import { Resvg as _Resvg, initWasm } from "@resvg/resvg-wasm";
 
 export default {
-	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-	// @ts-ignore
+	// load resvg's wasm from the dep (it exports ./index_bg.wasm) via ?module, so we
+	// don't vendor a copy. precompiled module works on node + workers alike.
 	initWasmPromise: initWasm(
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
 		import("@resvg/resvg-wasm/index_bg.wasm?module").then((r) => r.default || r)
 	),
 	Resvg: _Resvg,

package/dist/providers/resvg/node.js

@@ -1,13 +1,22 @@
 import { Resvg as _Resvg, initWasm } from "@resvg/resvg-wasm";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 
-/**
- * Fetch will be called only once whenever you load this file.
- * In vercel serverless functions, fetch will run on cold start.
- * In Node.js (Stateful e.g. Linux servers), Fetch will run once when you start your server.
- * */
-const resvgWasm = fetch("https://unpkg.com/@resvg/resvg-wasm/index_bg.wasm");
+// prefer reading resvg's wasm straight from the installed dependency (no
+// network). some serverless bundlers (vercel/netlify via nft) don't trace the
+// sibling .wasm onto disk, so fall back to fetching it there. either way we hand
+// initWasm raw bytes / a Response — never a `?module` import, which node
+// serverless can't instantiate. runs once when this module first loads.
+async function loadResvgWasm() {
+	try {
+		const require = createRequire(import.meta.url);
+		return await readFile(require.resolve("@resvg/resvg-wasm/index_bg.wasm"));
+	} catch {
+		return fetch("https://unpkg.com/@resvg/resvg-wasm/index_bg.wasm");
+	}
+}
 
 export default {
-	initWasmPromise: initWasm(resvgWasm),
+	initWasmPromise: initWasm(loadResvgWasm()),
 	Resvg: _Resvg,
 };

package/dist/providers/satori/edge.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    export let initWasmPromise: Promise<void>;
+    export { _satori as satori };
+}
+export default _default;
+import _satori from "satori/standalone";

package/dist/providers/satori/edge.js

@@ -0,0 +1,12 @@
+import _satori, { init } from "satori/standalone";
+
+// the default satori entry compiles yoga's wasm at runtime, which workers block
+// ("Wasm code generation disallowed by embedder"). satori/standalone takes a
+// precompiled module via init(), so we hand it satori's own yoga wasm (it exports
+// ./yoga.wasm) through ?module — no vendored copy. mirrors providers/resvg.
+export default {
+	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+	// @ts-ignore
+	initWasmPromise: init(import("satori/yoga.wasm?module").then((r) => r.default || r)),
+	satori: _satori,
+};

package/dist/takumi/fonts.d.ts

@@ -0,0 +1,16 @@
+import type { FontDetails } from "takumi-js/node";
+import { BaseFont } from "../fonts.js";
+import type { MayBePromise } from "../types.js";
+type ByteBuf = Uint8Array | ArrayBuffer | Buffer;
+/** Takumi-native font descriptor; data is the bytes or a lazy loader, like takumi-js wants. */
+export interface TakumiFontDescriptor {
+    name?: string;
+    data: ByteBuf | (() => MayBePromise<ByteBuf>);
+    weight?: number;
+    style?: FontDetails["style"];
+}
+/** What the takumi path accepts: our GoogleFont/CustomFont, or a raw takumi descriptor. */
+export type TakumiFontInput = BaseFont | TakumiFontDescriptor;
+/** Normalize mixed font inputs to FontDetails for registerFont, loaders run in parallel. */
+export declare function resolveTakumiFonts(fonts: TakumiFontInput[]): Promise<FontDetails[]>;
+export {};

package/dist/takumi/fonts.js

@@ -0,0 +1,15 @@
+import { BaseFont } from "../fonts.js";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
+async function normalizeFont(font) {
+    if (font instanceof BaseFont) {
+        // our font classes lazily load + cache through the data getter
+        const data = (await font.data);
+        return { name: font.name, data, weight: font.weight, style: font.style };
+    }
+    const data = typeof font.data === "function" ? await font.data() : await font.data;
+    return { name: font.name, data, weight: font.weight, style: font.style };
+}
+/** Normalize mixed font inputs to FontDetails for registerFont, loaders run in parallel. */
+export async function resolveTakumiFonts(fonts) {
+    return handleAsync(() => Promise.all(fonts.map(normalizeFont)), ErrorCodes.FONT_LOAD_FAILED, "Failed to resolve fonts for Takumi");
+}

package/dist/takumi/image-response.d.ts

@@ -0,0 +1,6 @@
+import type { Component, ComponentProps } from "svelte";
+import type { TakumiImageResponseOptions } from "./types.js";
+/** OG image rendered by Takumi. Takes an HTML string or a Svelte component. */
+export declare class ImageResponse<T extends string | Component<any>> extends Response {
+    constructor(element: T, options?: TakumiImageResponseOptions, props?: T extends Component<any> ? ComponentProps<T> : never);
+}

package/dist/takumi/image-response.js

@@ -0,0 +1,33 @@
+import { createTakumiImage } from "./render.js";
+import { buildImageResponse } from "../helpers/response.js";
+const DEFAULT_OPTIONS = {
+    width: 1200,
+    height: 630,
+    format: "png",
+    emoji: "twemoji",
+    debug: false,
+};
+// takumi can also encode jpeg/webp/ico/raw, plus svg as text
+const CONTENT_TYPES = {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    raw: "application/octet-stream",
+    svg: "image/svg+xml",
+};
+/** OG image rendered by Takumi. Takes an HTML string or a Svelte component. */
+export class ImageResponse extends Response {
+    constructor(element, options, props) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const { body, init } = buildImageResponse(() => createTakumiImage(element, opts, props), {
+            label: opts.format.toUpperCase(),
+            contentType: CONTENT_TYPES[opts.format],
+            debug: opts.debug,
+            headers: opts.headers,
+            status: opts.status,
+            statusText: opts.statusText,
+        });
+        super(body, init);
+    }
+}

package/dist/takumi/index.d.ts

@@ -0,0 +1,5 @@
+export { ImageResponse } from "./image-response.js";
+export type { TakumiImageResponseOptions, TakumiImageOptions, TakumiResponseOptions, TakumiFormat, } from "./types.js";
+export type { TakumiFontInput, TakumiFontDescriptor } from "./fonts.js";
+export { resolveTakumiFonts } from "./fonts.js";
+export { GoogleFont, CustomFont, loadGoogleFont } from "../fonts.js";

package/dist/takumi/index.js

@@ -0,0 +1,4 @@
+export { ImageResponse } from "./image-response.js";
+export { resolveTakumiFonts } from "./fonts.js";
+// re-export the font helpers so the takumi path works from one import
+export { GoogleFont, CustomFont, loadGoogleFont } from "../fonts.js";

package/dist/takumi/render.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from "svelte";
+import type { TakumiImageOptions } from "./types.js";
+/** Render an HTML string or Svelte component to image bytes (or an svg string). */
+export declare function createTakumiImage(element: string | Component, options: TakumiImageOptions, props?: Record<string, unknown>): Promise<Uint8Array | string>;

package/dist/takumi/render.js

@@ -0,0 +1,30 @@
+import { render as takumiRender, renderSvg } from "takumi-js";
+import { renderComponentToHtml } from "../helpers/to-html.js";
+import { useTakumiRenderer, registerTakumiFonts } from "./renderer.js";
+import { resolveTakumiFonts } from "./fonts.js";
+import { createLogger } from "../helpers/logger.js";
+import { handleAsync, handleSync, ErrorCodes } from "../helpers/error-handler.js";
+function elementToHtml(element, props) {
+    if (typeof element === "string")
+        return element.replaceAll("\n", "").trim();
+    // head carries css injected via <svelte:options css="injected" />, so it goes first
+    const { head, body } = renderComponentToHtml(element, props);
+    return head + body;
+}
+/** Render an HTML string or Svelte component to image bytes (or an svg string). */
+export async function createTakumiImage(element, options, props) {
+    const log = createLogger(options.debug ?? false);
+    const html = handleSync(() => elementToHtml(element, props), ErrorCodes.VNODE_CREATION_FAILED, "Failed to create HTML for Takumi");
+    const renderer = await useTakumiRenderer(options.debug);
+    if (options.fonts?.length) {
+        const fonts = await resolveTakumiFonts(options.fonts);
+        await registerTakumiFonts(renderer, fonts);
+    }
+    const { width, height, format = "png", quality, stylesheets, emoji } = options;
+    const shared = { renderer: renderer, width, height, stylesheets, emoji };
+    log.debug(`Rendering ${format.toUpperCase()} with Takumi`);
+    if (format === "svg") {
+        return handleAsync(() => renderSvg(html, shared), ErrorCodes.TAKUMI_RENDER_FAILED, "Failed to render SVG with Takumi");
+    }
+    return handleAsync(() => takumiRender(html, { ...shared, format, quality }), ErrorCodes.TAKUMI_RENDER_FAILED, "Failed to render image with Takumi");
+}

package/dist/takumi/renderer.d.ts

@@ -0,0 +1,6 @@
+import type { Renderer as NodeRenderer, FontDetails } from "takumi-js/node";
+export type TakumiRenderer = NodeRenderer;
+/** Lazily creates and caches the Takumi renderer for the current runtime. */
+export declare function useTakumiRenderer(_debug?: boolean): Promise<TakumiRenderer>;
+/** Register each font once, keyed by name/weight/style. */
+export declare function registerTakumiFonts(renderer: TakumiRenderer, fonts: FontDetails[]): Promise<void>;

package/dist/takumi/renderer.js

@@ -0,0 +1,35 @@
+import autoModule, { init as initTakumiWasm, Renderer } from "takumi-js/wasm";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
+// keep one renderer alive across requests, same as the satori/resvg instances.
+// fonts registered on it stick around, so we dedupe by key.
+let rendererPromise;
+const registeredFontKeys = new Set();
+async function initRenderer() {
+    await handleAsync(async () => {
+        // reuse the wasm that ships with takumi-js instead of vendoring our own.
+        // @takumi-rs/wasm/auto picks the right binary per runtime (workerd, edge,
+        // node, ?module) via export conditions. this is the same dance takumi-js
+        // does internally.
+        const resolved = typeof autoModule === "function" ? await autoModule() : await autoModule;
+        const input = resolved && typeof resolved === "object" && "default" in resolved
+            ? resolved.default
+            : resolved;
+        await initTakumiWasm(input ? { module_or_path: input } : undefined);
+    }, ErrorCodes.TAKUMI_INIT_FAILED, "Failed to initialize Takumi WASM");
+    return new Renderer();
+}
+/** Lazily creates and caches the Takumi renderer for the current runtime. */
+export async function useTakumiRenderer(_debug = false) {
+    rendererPromise ??= initRenderer();
+    return rendererPromise;
+}
+/** Register each font once, keyed by name/weight/style. */
+export async function registerTakumiFonts(renderer, fonts) {
+    for (const font of fonts) {
+        const key = `${font.name ?? "unnamed"}-${font.weight ?? "auto"}-${font.style ?? "normal"}`;
+        if (registeredFontKeys.has(key))
+            continue;
+        await handleAsync(() => renderer.registerFont(font), ErrorCodes.FONT_LOAD_FAILED, `Failed to register Takumi font: ${key}`);
+        registeredFontKeys.add(key);
+    }
+}

package/dist/takumi/types.d.ts

@@ -0,0 +1,64 @@
+import type { EmojiType } from "takumi-js/helpers/emoji";
+import type { OutputFormat } from "takumi-js/node";
+import type { TakumiFontInput } from "./fonts.js";
+/** Static output formats Takumi can encode, plus vector `svg`. */
+export type TakumiFormat = OutputFormat | "svg";
+export type TakumiImageOptions = {
+    /**
+     * Width of the image.
+     * @default 1200
+     * */
+    width?: number;
+    /**
+     * Height of the image.
+     * @default 630
+     * */
+    height?: number;
+    /**
+     * Output format.
+     * @default png
+     * */
+    format?: TakumiFormat;
+    /**
+     * Quality for lossy formats (jpeg, lossy webp), 0-100.
+     * */
+    quality?: number;
+    /**
+     * Fonts to register. Accepts this library's `GoogleFont`/`CustomFont`
+     * helpers or raw Takumi font descriptors. If omitted, Takumi's built-in
+     * sans-serif is used.
+     * */
+    fonts?: TakumiFontInput[];
+    /**
+     * Extra CSS stylesheets applied before rendering.
+     * */
+    stylesheets?: string[];
+    /**
+     * Emoji provider, or `"from-font"` to source emoji glyphs from loaded fonts.
+     * @default twemoji
+     * */
+    emoji?: EmojiType | "from-font";
+    /**
+     * Enable debug logging.
+     * @default false
+     * */
+    debug?: boolean;
+};
+export type TakumiResponseOptions = {
+    /**
+     * Response status code.
+     * @default 200
+     * */
+    status?: number;
+    /**
+     * Response status text.
+     * @default Success
+     * */
+    statusText?: string;
+    /**
+     * Response headers.
+     * */
+    headers?: Record<string, string>;
+};
+/** Options for the Takumi `ImageResponse`. */
+export type TakumiImageResponseOptions = TakumiImageOptions & TakumiResponseOptions;

package/dist/takumi/types.js

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

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { SatoriOptions } from "satori/wasm";
+import type { SatoriOptions } from "satori";
 import type { EmojiType } from "./helpers/emoji.js";
 export type Font = SatoriOptions["fonts"][number];
 export type Fonts = Font[];

package/package.json

@@ -1,117 +1,131 @@
 {
-  "name": "@ethercorps/sveltekit-og",
-  "version": "4.3.0-next.1",
-  "license": "MIT",
-  "homepage": "https://sveltekit-og.dev",
-  "repository": "github:ethercorps/sveltekit-og",
-  "funding": "https://github.com/sponsors/ethercorps",
-  "author": "Shivam Meena <https://github.com/theetherGit>",
-  "description": "Dynamically generate Open Graph images from an HTML, CSS template or Svelte component using fast and efficient conversion from HTML > SVG > PNG",
-  "contributors": [
-    {
-      "name": "Shivam Meena",
-      "github": "https://github.com/theetherGit"
-    },
-    {
-      "name": "Jason",
-      "github": "https://github.com/jasongitmail"
-    },
-    {
-      "name": "Mihkel Martin Kasterpalu",
-      "github": "https://github.com/MihkelMK"
-    },
-    {
-      "name": "Luke Parke",
-      "github": "https://github.com/LukasParke"
-    },
-    {
-      "name": "Willow (GHOST)",
-      "github": "https://github.com/ghostdevv"
-    },
-    {
-      "name": "Minseo Lee",
-      "github": "https://github.com/quiple"
-    }
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "svelte": "./dist/index.js",
-      "import": "./dist/index.js"
-    },
-    "./fonts": {
-      "types": "./dist/fonts.d.ts",
-      "import": "./dist/fonts.js"
-    },
-    "./plugin": {
-      "types": "./dist/plugin.d.ts",
-      "import": "./dist/plugin.js"
-    }
-  },
-  "files": [
-    "dist",
-    "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
-  ],
-  "devDependencies": {
-    "@eslint/compat": "^2.0.3",
-    "@eslint/js": "^9.39.3",
-    "@sveltejs/adapter-vercel": "^5.10.3",
-    "@sveltejs/kit": "^2.53.4",
-    "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^4.0.4",
-    "@types/node": "^24.11.0",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
-    "css-tree": "^2.3.1",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^8.10.2",
-    "eslint-plugin-oxlint": "^1.55.0",
-    "eslint-plugin-svelte": "^2.46.1",
-    "globals": "^16.5.0",
-    "oxlint": "^1.55.0",
-    "prettier": "^3.8.1",
-    "prettier-plugin-svelte": "^3.5.1",
-    "prettier-plugin-tailwindcss": "^0.6.14",
-    "publint": "^0.1.16",
-    "rollup-plugin-visualizer": "^5.14.0",
-    "svelte": "^5.53.10",
-    "svelte-check": "^4.4.5",
-    "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.0",
-    "vite": "^5.4.21",
-    "vitest": "^1.6.1"
-  },
-  "main": "./dist/index.js",
-  "svelte": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "type": "module",
-  "dependencies": {
-    "@resvg/resvg-wasm": "^2.6.2",
-    "satori": "^0.25.0",
-    "satori-html": "0.3.2",
-    "std-env": "^3.10.0",
-    "unwasm": "^0.5.3"
-  },
-  "peerDependencies": {
-    "@sveltejs/kit": ">=2.0.0"
-  },
-  "engines": {
-    "node": ">=22.16.0"
-  },
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build && npm run package",
-    "build:examples": "pnpm -F \"./examples/**\" --parallel --color build",
-    "check:examples": "pnpm -F \"./examples/**\" --parallel --color i",
-    "preview": "vite preview",
-    "package": "svelte-kit sync && svelte-package && publint",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-    "test": "vitest",
-    "lint": "oxlint . && eslint .",
-    "format": "prettier --plugin-search-dir . --write .",
-    "publishBeta": "npm publish --tag beta"
-  }
-}
+	"name": "@ethercorps/sveltekit-og",
+	"version": "4.3.0-next.10",
+	"license": "MIT",
+	"homepage": "https://sveltekit-og.dev",
+	"repository": "github:ethercorps/sveltekit-og",
+	"funding": "https://github.com/sponsors/ethercorps",
+	"author": "Shivam Meena <https://github.com/theetherGit>",
+	"description": "Dynamically generate Open Graph images from an HTML, CSS template or Svelte component using fast and efficient conversion from HTML > SVG > PNG",
+	"contributors": [
+		{
+			"name": "Shivam Meena",
+			"github": "https://github.com/theetherGit"
+		},
+		{
+			"name": "Jason",
+			"github": "https://github.com/jasongitmail"
+		},
+		{
+			"name": "Mihkel Martin Kasterpalu",
+			"github": "https://github.com/MihkelMK"
+		},
+		{
+			"name": "Luke Parke",
+			"github": "https://github.com/LukasParke"
+		},
+		{
+			"name": "Willow (GHOST)",
+			"github": "https://github.com/ghostdevv"
+		},
+		{
+			"name": "Minseo Lee",
+			"github": "https://github.com/quiple"
+		}
+	],
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"build:examples": "pnpm -F \"./examples/**\" --parallel --color build",
+		"check:examples": "pnpm install -r",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "pnpm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest",
+		"bench": "vitest bench --run",
+		"bench:save": "vitest bench --run --outputJson benchmarks/baseline.json",
+		"bench:compare": "vitest bench --run --compare benchmarks/baseline.json",
+		"bench:snapshot": "node scripts/bench-snapshot.mjs",
+		"lint": "oxlint . && eslint .",
+		"format": "prettier --plugin-search-dir . --write .",
+		"publishBeta": "npm publish --tag beta"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"import": "./dist/index.js"
+		},
+		"./fonts": {
+			"types": "./dist/fonts.d.ts",
+			"import": "./dist/fonts.js"
+		},
+		"./takumi": {
+			"types": "./dist/takumi/index.d.ts",
+			"svelte": "./dist/takumi/index.js",
+			"import": "./dist/takumi/index.js"
+		},
+		"./plugin": {
+			"types": "./dist/plugin.d.ts",
+			"import": "./dist/plugin.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"devDependencies": {
+		"@eslint/compat": "^2.0.3",
+		"@eslint/js": "^9.39.3",
+		"@sveltejs/adapter-vercel": "^5.10.3",
+		"@sveltejs/kit": "^2.53.4",
+		"@sveltejs/package": "^2.5.7",
+		"@sveltejs/vite-plugin-svelte": "^4.0.4",
+		"@types/node": "^24.11.0",
+		"@typescript-eslint/eslint-plugin": "^5.62.0",
+		"@typescript-eslint/parser": "^5.62.0",
+		"css-tree": "^2.3.1",
+		"eslint": "^8.57.1",
+		"eslint-config-prettier": "^8.10.2",
+		"eslint-plugin-oxlint": "^1.55.0",
+		"eslint-plugin-svelte": "^2.46.1",
+		"globals": "^16.5.0",
+		"oxlint": "^1.55.0",
+		"prettier": "^3.8.1",
+		"prettier-plugin-svelte": "^3.5.1",
+		"prettier-plugin-tailwindcss": "^0.6.14",
+		"publint": "^0.1.16",
+		"rollup-plugin-visualizer": "^5.14.0",
+		"svelte": "^5.53.10",
+		"svelte-check": "^4.4.5",
+		"tslib": "^2.8.1",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.57.0",
+		"vite": "^5.4.21",
+		"takumi-js": "2.0.0-beta.14",
+		"vitest": "^1.6.1"
+	},
+	"main": "./dist/index.js",
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"dependencies": {
+		"@resvg/resvg-wasm": "^2.6.2",
+		"satori": "^0.25.0",
+		"satori-html": "0.3.2",
+		"std-env": "^4.1.0",
+		"unwasm": "^0.5.3"
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": ">=2.0.0",
+		"takumi-js": "^2.0.0-beta.14"
+	},
+	"peerDependenciesMeta": {
+		"takumi-js": {
+			"optional": true
+		}
+	}
+}