@ethercorps/sveltekit-og 4.2.0 → 4.3.0-beta.1

package/dist/helpers/emoji.js

@@ -1,4 +1,5 @@
-import { DEFAULT_EMOJI_PROVIDER } from '../helpers/defaults.js';
+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;
@@ -11,7 +12,7 @@ function toCodePoint(unicodeSurrogates) {
     while (i < unicodeSurrogates.length) {
         c = unicodeSurrogates.charCodeAt(i++);
         if (p) {
-            r.push((65536 + (p - 55296 << 10) + (c - 56320)).toString(16));
+            r.push((65536 + ((p - 55296) << 10) + (c - 56320)).toString(16));
             p = 0;
         }
         else if (55296 <= c && c <= 56319) {
@@ -24,32 +25,41 @@ function toCodePoint(unicodeSurrogates) {
     return r.join("-");
 }
 const emoji_apis = {
-    twemoji: (code) => "https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/" + code.toLowerCase() + ".svg",
+    twemoji: (code) => "https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/" +
+        code.toLowerCase() +
+        ".svg",
     openmoji: "https://cdn.jsdelivr.net/npm/@svgmoji/openmoji@2.0.0/svg/",
     blobmoji: "https://cdn.jsdelivr.net/npm/@svgmoji/blob@2.0.0/svg/",
     noto: "https://cdn.jsdelivr.net/gh/svgmoji/svgmoji/packages/svgmoji__noto/svg/",
-    fluent: (code) => "https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/" + code.toLowerCase() + "_color.svg",
-    fluentFlat: (code) => "https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/" + code.toLowerCase() + "_flat.svg"
+    fluent: (code) => "https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/" +
+        code.toLowerCase() +
+        "_color.svg",
+    fluentFlat: (code) => "https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/" +
+        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) => {
+    return async (code, text) => {
         if (code === "emoji") {
-            return `data:image/svg+xml;base64,` + btoa(await (await loadEmoji(getIconCode(text), emoji)).text());
+            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) => {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return await fn(...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

@@ -0,0 +1,7 @@
+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;
+    error: (message: string, ...args: unknown[]) => void;
+};

package/dist/helpers/logger.js

@@ -0,0 +1,21 @@
+const PREFIX = '[SvelteKit-OG]';
+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);
+        }
+    };
+}

package/dist/helpers/response.d.ts

@@ -0,0 +1,30 @@
+/** format → content type for every format either engine can emit; satori uses the
+ * png/svg subset, takumi the whole map. */
+export declare const CONTENT_TYPES: {
+    readonly png: "image/png";
+    readonly jpeg: "image/jpeg";
+    readonly webp: "image/webp";
+    readonly ico: "image/x-icon";
+    readonly raw: "application/octet-stream";
+    readonly svg: "image/svg+xml";
+};
+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,52 @@
+import { createLogger } from "./logger.js";
+import { handleAsync, toImageResponseError, ErrorCodes } from "./error-handler.js";
+import { DEFAULT_STATUS_CODE, DEFAULT_STATUS_TEXT } from "./defaults.js";
+import { formatBytes } from "./utils.js";
+/** format → content type for every format either engine can emit; satori uses the
+ * png/svg subset, takumi the whole map. */
+export const CONTENT_TYPES = {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    raw: "application/octet-stream",
+    svg: "image/svg+xml",
+};
+// TextEncoder is stateless; one shared instance instead of one per svg response
+const textEncoder = new TextEncoder();
+/**
+ * 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" ? 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 || DEFAULT_STATUS_CODE,
+        statusText: opts.statusText || DEFAULT_STATUS_TEXT,
+    };
+    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.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from "svelte";
+import type { ComponentOptions, VNode } from "../types.js";
+export declare function createVNode(element: string | Component<any>, componentOptions?: ComponentOptions): VNode;

package/dist/helpers/toJSX.js

@@ -0,0 +1,11 @@
+import { html } from "satori-html";
+import { handleSync, ErrorCodes } from "./error-handler.js";
+import { renderComponentToHtml } from "./to-html.js";
+export function createVNode(element, componentOptions) {
+    return handleSync(() => {
+        if (typeof element === "string")
+            return html(element.replaceAll("\n", "").trim());
+        const { body, head } = renderComponentToHtml(element, componentOptions?.props);
+        return html(body + head);
+    }, 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)), sizeFormats.length - 1);
+    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.d.ts

@@ -1,5 +1,5 @@
-import type { Component, ComponentProps } from 'svelte';
-import type { ImageResponseOptions } from './types.js';
+import type { Component, ComponentProps } from "svelte";
+import type { ImageResponseOptions } from "./types.js";
 export declare class ImageResponse<T extends string | Component<any>> extends Response {
     constructor(element: T, options?: ImageResponseOptions, props?: T extends Component<any> ? ComponentProps<T> : never);
 }

package/dist/image-response.js

@@ -1,26 +1,18 @@
-import { DEFAULT_OPTIONS, DEFAULT_STATUS_CODE, DEFAULT_STATUS_TEXT } from './helpers/defaults.js';
-import { createPng, createSvg } from './helpers/create.js';
+import { DEFAULT_OPTIONS } from "./helpers/defaults.js";
+import { createImage } from "./helpers/create.js";
+import { buildImageResponse, CONTENT_TYPES } from "./helpers/response.js";
 export class ImageResponse extends Response {
     constructor(element, options, props) {
-        const extended_options = Object.assign({ ...DEFAULT_OPTIONS }, options);
-        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 = { ...DEFAULT_OPTIONS, ...options };
+        const format = opts.format ?? "png";
+        const { body, init } = buildImageResponse(() => createImage(element, { ...opts, format }, { props }), {
+            label: format.toUpperCase(),
+            contentType: CONTENT_TYPES[format],
+            debug: opts.debug ?? false,
+            headers: opts.headers,
+            status: opts.status,
+            statusText: opts.statusText,
         });
+        super(body, init);
     }
 }

package/dist/plugin.js

@@ -3,20 +3,20 @@ export function rollupWasm(options) {
     return unwasm({
         esmImport: true,
         lazy: true,
-        ...options
+        ...options,
     });
 }
 export function sveltekitOG(options) {
     return {
-        name: 'vite-plugin-sveltekit-og',
+        name: "vite-plugin-sveltekit-og",
         config() {
             return {
                 build: {
                     rollupOptions: {
-                        plugins: [rollupWasm(options)]
-                    }
-                }
+                        plugins: [rollupWasm(options)],
+                    },
+                },
             };
-        }
+        },
     };
 }

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) => {
+import type _satori from "satori";
+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,17 +1,45 @@
-import { isEdgeLight, isWorkerd } from 'std-env';
-// 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
-const resvgInstance = { instance: undefined };
-const satoriInstance = { instance: undefined };
-export async function useResvg() {
-    const moduleImport = isEdgeLight || isWorkerd ? import(`./resvg/edge.js`) : import('./resvg/node.js');
-    resvgInstance.instance = resvgInstance.instance || await moduleImport.then(m => m.default);
-    await resvgInstance.instance.initWasmPromise;
-    return resvgInstance.instance.Resvg;
+import { isEdgeLight, isWorkerd } from "std-env";
+import { createLogger } from "../helpers/logger.js";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
+/**
+ * Lazy singleton around a node/edge wasm module pair. The edge/node choice is
+ * made per-runtime via std-env; both sides stay direct import() expressions so
+ * the bundler can emit the wasm chunk. Memoizes the init promise (like
+ * takumi/renderer.ts) so concurrent first requests share one init, and clears
+ * it on rejection so a failed init can be retried.
+ */
+function createProvider(label, errorCode, imports) {
+    let instancePromise;
+    const init = async (debug) => {
+        const log = createLogger(debug);
+        log.debug(`Initializing ${label}`);
+        const isWorkerLikeRuntime = isEdgeLight || isWorkerd;
+        log.info(`Detected runtime: ${isWorkerLikeRuntime ? "Edge Light or Workerd" : "Node.js"}`);
+        const moduleImport = isWorkerLikeRuntime ? imports.edge() : imports.node();
+        const loaded = await handleAsync(() => moduleImport.then((m) => m.default), errorCode, `Failed to import ${label} module`);
+        await handleAsync(() => loaded.initWasmPromise, errorCode, `Failed to initialize ${label} WASM`);
+        return loaded;
+    };
+    return (debug = false) => {
+        instancePromise ??= init(debug).catch((error) => {
+            instancePromise = undefined;
+            throw error;
+        });
+        return instancePromise;
+    };
 }
-export async function useSatori() {
-    satoriInstance.instance = satoriInstance.instance || await import(`./satori/node.js`).then(m => m.default);
-    await satoriInstance.instance.initWasmPromise;
-    return satoriInstance.instance.satori;
+const useResvgModule = createProvider("ReSVG", ErrorCodes.RESVG_INIT_FAILED, {
+    // workers take a precompiled `?module`; node takes raw wasm bytes
+    edge: () => import("./resvg/edge.js"),
+    node: () => import("./resvg/node.js"),
+});
+const useSatoriModule = createProvider("Satori", ErrorCodes.SATORI_INIT_FAILED, {
+    edge: () => import("./satori/edge.js"),
+    node: () => import("./satori/node.js"),
+});
+export async function useResvg(debug = false) {
+    return (await useResvgModule(debug)).Resvg;
+}
+export async function useSatori(debug = false) {
+    return (await useSatoriModule(debug)).satori;
 }

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

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _Resvg as Resvg };
 }
 export default _default;
-import { Resvg as _Resvg } from '@resvg/resvg-wasm';
+import { Resvg as _Resvg } from "@resvg/resvg-wasm";

package/dist/providers/resvg/edge.js

@@ -1,8 +1,12 @@
-import { Resvg as _Resvg, initWasm } from '@resvg/resvg-wasm'
+import { Resvg as _Resvg, initWasm } from "@resvg/resvg-wasm";
 
 export default {
-	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  initWasmPromise: initWasm(import('./resvg.wasm?module').then(r => r.default || r)),
-  Resvg: _Resvg,
-}
+	// 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.d.ts

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _Resvg as Resvg };
 }
 export default _default;
-import { Resvg as _Resvg } from '@resvg/resvg-wasm';
+import { Resvg as _Resvg } from "@resvg/resvg-wasm";

package/dist/providers/resvg/node.js

@@ -1,13 +1,22 @@
-import { Resvg as _Resvg, initWasm } from '@resvg/resvg-wasm';
+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/providers/satori/node.d.ts

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _satori as satori };
 }
 export default _default;
-import _satori from 'satori';
+import _satori from "satori";

package/dist/providers/satori/node.js

@@ -1,6 +1,6 @@
-import _satori from 'satori'
+import _satori from "satori";
 
 export default {
-  initWasmPromise: Promise.resolve(),
-  satori: _satori,
-}
+	initWasmPromise: Promise.resolve(),
+	satori: _satori,
+};