@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/bare/plugins/sdcpp-generation/ops/upscale.js

@@ -1,7 +1,7 @@
-import { EsrganUpscaler } from "@qvac/diffusion-cpp";
-import { getModel, getModelEntry, } from "../../../registry/model-registry.js";
-import { ModelOperationNotSupportedError } from "../../../../../utils/errors-server.js";
-import { ModelType } from "../../../../../schemas/index.js";
+import { EsrganUpscaler } from '@qvac/diffusion-cpp';
+import { getModel, getModelEntry } from '../../../registry/model-registry.js';
+import { ModelOperationNotSupportedError } from '../../../../../utils/errors-server.js';
+import { ModelType } from '../../../../../schemas/index.js';
 // The diffusion plugin instantiates `EsrganUpscaler` when the model is loaded
 // with `modelConfig.mode === "upscale"` and `ImgStableDiffusion` otherwise. The
 // latter has no `.upscale()` method, so we refuse the call upfront with a
@@ -12,11 +12,11 @@ function asUpscalerModel(model, modelId) {
     }
     const entry = getModelEntry(modelId);
     const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
-    throw new ModelOperationNotSupportedError(modelId, modelType, "upscale", ["diffusion"], []);
+    throw new ModelOperationNotSupportedError(modelId, modelType, 'upscale', ['diffusion'], []);
 }
 export async function* upscale(request) {
     const model = asUpscalerModel(getModel(request.modelId), request.modelId);
-    const response = await model.upscale(Buffer.from(request.image, "base64"), request.repeats === undefined ? undefined : { repeats: request.repeats });
+    const response = await model.upscale(Buffer.from(request.image, 'base64'), request.repeats === undefined ? undefined : { repeats: request.repeats });
     // The addon emits exactly one final PNG regardless of `repeats`, so
     // this loop typically iterates once. `outputIndex` is still emitted for
     // wire parity with diffusionStream and to leave headroom for future
@@ -25,16 +25,16 @@ export async function* upscale(request) {
     for await (const chunk of response.iterate()) {
         if (chunk instanceof Uint8Array) {
             yield {
-                type: "upscaleStream",
-                data: Buffer.from(chunk).toString("base64"),
-                outputIndex: outputIndex++,
+                type: 'upscaleStream',
+                data: Buffer.from(chunk).toString('base64'),
+                outputIndex: outputIndex++
             };
         }
     }
     const responseWithStats = response;
     yield {
-        type: "upscaleStream",
+        type: 'upscaleStream',
         done: true,
-        stats: responseWithStats.stats ?? undefined,
+        stats: responseWithStats.stats ?? undefined
     };
 }

package/dist/server/bare/plugins/sdcpp-generation/ops/video.d.ts

@@ -1,3 +1,3 @@
-import type { VideoRequest, VideoStreamResponse } from "../../../../../schemas/sdcpp-config";
+import type { VideoRequest, VideoStreamResponse } from '../../../../../schemas/sdcpp-config';
 export declare function video(request: VideoRequest): AsyncGenerator<VideoStreamResponse>;
 //# sourceMappingURL=video.d.ts.map

package/dist/server/bare/plugins/sdcpp-generation/ops/video.js

@@ -50,13 +50,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { VideoStableDiffusion } from "@qvac/diffusion-cpp";
-import { getServerLogger } from "../../../../../logging/index.js";
-import { getModel, getModelEntry, } from "../../../registry/model-registry.js";
-import { getRequestRegistry, withRequestContext } from "../../../runtime/index.js";
-import { generateServerRequestId } from "../../../runtime/request-id.js";
-import { ModelOperationNotSupportedError } from "../../../../../utils/errors-server.js";
-import { ModelType } from "../../../../../schemas/index.js";
+import { VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import { getServerLogger } from '../../../../../logging/index.js';
+import { getModel, getModelEntry } from '../../../registry/model-registry.js';
+import { getRequestRegistry, withRequestContext } from '../../../runtime/index.js';
+import { generateServerRequestId } from '../../../runtime/request-id.js';
+import { ModelOperationNotSupportedError } from '../../../../../utils/errors-server.js';
+import { ModelType } from '../../../../../schemas/index.js';
 // The diffusion plugin instantiates `VideoStableDiffusion` when the model is
 // loaded with `modelConfig.mode === "video"` and `ImgStableDiffusion` (or
 // `EsrganUpscaler`) otherwise. Those have no video `run()` shape, so we refuse
@@ -67,18 +67,16 @@ function asVideoModel(model, modelId) {
         return model;
     }
     const entry = getModelEntry(modelId);
-    const modelType = entry && !entry.isDelegated
-        ? entry.local.modelType
-        : ModelType.sdcppGeneration;
-    throw new ModelOperationNotSupportedError(modelId, modelType, "video", ["diffusion"], []);
+    const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
+    throw new ModelOperationNotSupportedError(modelId, modelType, 'video', ['diffusion'], []);
 }
 export async function* video(request) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: request.requestId ?? generateServerRequestId(),
-            kind: "diffusion",
-            modelId: request.modelId,
+            kind: 'diffusion',
+            modelId: request.modelId
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
         const model = asVideoModel(getModel(request.modelId), request.modelId);
@@ -87,76 +85,76 @@ export async function* video(request) {
                 requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
             });
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const response = await model.run({
             mode: request.mode,
             prompt: request.prompt,
             ...(request.negative_prompt !== undefined && {
-                negative_prompt: request.negative_prompt,
+                negative_prompt: request.negative_prompt
             }),
             ...(request.width !== undefined && { width: request.width }),
             ...(request.height !== undefined && { height: request.height }),
             ...(request.video_frames !== undefined && {
-                video_frames: request.video_frames,
+                video_frames: request.video_frames
             }),
             ...(request.fps !== undefined && { fps: request.fps }),
             ...(request.seed !== undefined && { seed: request.seed }),
             ...(request.steps !== undefined && { steps: request.steps }),
             ...(request.sampling_method !== undefined && {
-                sampling_method: request.sampling_method,
+                sampling_method: request.sampling_method
             }),
             ...(request.scheduler !== undefined && { scheduler: request.scheduler }),
             ...(request.cfg_scale !== undefined && { cfg_scale: request.cfg_scale }),
             ...(request.flow_shift !== undefined && { flow_shift: request.flow_shift }),
             ...(request.high_noise_steps !== undefined && {
-                high_noise_steps: request.high_noise_steps,
+                high_noise_steps: request.high_noise_steps
             }),
             ...(request.high_noise_sampler !== undefined && {
-                high_noise_sampler: request.high_noise_sampler,
+                high_noise_sampler: request.high_noise_sampler
             }),
             ...(request.high_noise_scheduler !== undefined && {
-                high_noise_scheduler: request.high_noise_scheduler,
+                high_noise_scheduler: request.high_noise_scheduler
             }),
             ...(request.high_noise_cfg_scale !== undefined && {
-                high_noise_cfg_scale: request.high_noise_cfg_scale,
+                high_noise_cfg_scale: request.high_noise_cfg_scale
             }),
             ...(request.high_noise_flow_shift !== undefined && {
-                high_noise_flow_shift: request.high_noise_flow_shift,
+                high_noise_flow_shift: request.high_noise_flow_shift
             }),
             ...(request.moe_boundary !== undefined && {
-                moe_boundary: request.moe_boundary,
+                moe_boundary: request.moe_boundary
             }),
             ...(request.vace_strength !== undefined && {
-                vace_strength: request.vace_strength,
+                vace_strength: request.vace_strength
             }),
             ...(request.init_image !== undefined && {
-                init_image: Buffer.from(request.init_image, "base64"),
+                init_image: Buffer.from(request.init_image, 'base64')
             }),
             ...(request.strength !== undefined && {
-                strength: request.strength,
+                strength: request.strength
             }),
             ...(request.control_frames !== undefined && {
-                control_frames: request.control_frames.map((b64) => Buffer.from(b64, "base64")),
+                control_frames: request.control_frames.map((b64) => Buffer.from(b64, 'base64'))
             }),
             ...(request.vae_tiling !== undefined && { vae_tiling: request.vae_tiling }),
             ...(request.vae_tile_size !== undefined && {
-                vae_tile_size: request.vae_tile_size,
+                vae_tile_size: request.vae_tile_size
             }),
             ...(request.vae_tile_overlap !== undefined && {
-                vae_tile_overlap: request.vae_tile_overlap,
+                vae_tile_overlap: request.vae_tile_overlap
             }),
             ...(request.cache_mode !== undefined && { cache_mode: request.cache_mode }),
             ...(request.cache_preset !== undefined && {
-                cache_preset: request.cache_preset,
+                cache_preset: request.cache_preset
             }),
             ...(request.cache_threshold !== undefined && {
-                cache_threshold: request.cache_threshold,
-            }),
+                cache_threshold: request.cache_threshold
+            })
         });
         let outputIndex = 0;
         for await (const chunk of response.iterate()) {
@@ -164,20 +162,20 @@ export async function* video(request) {
                 break;
             if (chunk instanceof Uint8Array) {
                 yield {
-                    type: "videoStream",
-                    data: Buffer.from(chunk).toString("base64"),
-                    outputIndex: outputIndex++,
+                    type: 'videoStream',
+                    data: Buffer.from(chunk).toString('base64'),
+                    outputIndex: outputIndex++
                 };
             }
-            else if (typeof chunk === "string") {
+            else if (typeof chunk === 'string') {
                 try {
                     const tick = JSON.parse(chunk);
-                    if ("step" in tick) {
+                    if ('step' in tick) {
                         yield {
-                            type: "videoStream",
-                            step: tick["step"],
-                            totalSteps: tick["total"],
-                            elapsedMs: tick["elapsed_ms"],
+                            type: 'videoStream',
+                            step: tick['step'],
+                            totalSteps: tick['total'],
+                            elapsedMs: tick['elapsed_ms']
                         };
                     }
                 }
@@ -188,9 +186,9 @@ export async function* video(request) {
         }
         const responseWithStats = response;
         yield {
-            type: "videoStream",
+            type: 'videoStream',
             done: true,
-            stats: responseWithStats.stats ?? undefined,
+            stats: responseWithStats.stats ?? undefined
         };
     }
     catch (e_1) {

package/dist/server/bare/plugins/sdcpp-generation/plugin.d.ts

@@ -1,5 +1,5 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from "../../../../schemas/index";
-type DiffusionArtifactKey = "clipLModelPath" | "clipGModelPath" | "clipVisionModelPath" | "t5XxlModelPath" | "llmModelPath" | "vaeModelPath" | "highNoiseDiffusionModelPath" | "esrganModelPath";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from '../../../../schemas/index';
+type DiffusionArtifactKey = 'clipLModelPath' | 'clipGModelPath' | 'clipVisionModelPath' | 't5XxlModelPath' | 'llmModelPath' | 'vaeModelPath' | 'highNoiseDiffusionModelPath' | 'esrganModelPath';
 /**
  * Stable-diffusion.cpp plugin for image diffusion, upscaling, and Wan video.
  *
@@ -20,8 +20,8 @@ export declare const diffusionPlugin: {
         }>>;
         threads: import("zod").ZodOptional<import("zod").ZodNumber>;
         device: import("zod").ZodOptional<import("zod").ZodEnum<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
         prediction: import("zod").ZodOptional<import("zod").ZodEnum<{
             auto: "auto";
@@ -593,8 +593,8 @@ export declare const diffusionPlugin: {
                 height: import("zod").ZodOptional<import("zod").ZodNumber>;
                 repeats: import("zod").ZodOptional<import("zod").ZodNumber>;
                 backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    cpu: "cpu";
                     gpu: "gpu";
+                    cpu: "cpu";
                 }>>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>>;

package/dist/server/bare/plugins/sdcpp-generation/plugin.js

@@ -1,11 +1,11 @@
-import ImgStableDiffusion, { EsrganUpscaler, VideoStableDiffusion, } from "@qvac/diffusion-cpp";
-import addonLogging from "@qvac/diffusion-cpp/addonLogging.js";
-import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, videoRequestSchema, videoStreamResponseSchema, upscaleRequestSchema, upscaleStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { diffusion } from "./ops/diffusion.js";
-import { video } from "./ops/video.js";
-import { upscale } from "./ops/upscale.js";
+import ImgStableDiffusion, { EsrganUpscaler, VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import addonLogging from '@qvac/diffusion-cpp/addonLogging.js';
+import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, videoRequestSchema, videoStreamResponseSchema, upscaleRequestSchema, upscaleStreamResponseSchema, ModelType, ADDON_DIFFUSION } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { diffusion } from './ops/diffusion.js';
+import { video } from './ops/video.js';
+import { upscale } from './ops/upscale.js';
 // Single source of truth for `SdcppConfig.upscaler.*` → addon-config key
 // mapping. Used by both the diffusion-mode (post-generation upscaler) and the
 // standalone-upscale-mode branches; keeping the mapping in one place avoids
@@ -15,17 +15,17 @@ function flattenUpscalerKeys(upscaler) {
         return {};
     return {
         ...(upscaler.tile_size !== undefined && {
-            upscaler_tile_size: upscaler.tile_size,
+            upscaler_tile_size: upscaler.tile_size
         }),
         ...(upscaler.direct !== undefined && {
-            upscaler_direct: upscaler.direct,
+            upscaler_direct: upscaler.direct
         }),
         ...(upscaler.offload_params_to_cpu !== undefined && {
-            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu,
+            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu
         }),
         ...(upscaler.threads !== undefined && {
-            upscaler_threads: upscaler.threads,
-        }),
+            upscaler_threads: upscaler.threads
+        })
     };
 }
 // `mode: "upscale"` builds an EsrganUpscaler directly (not via SdCtx), so the
@@ -35,7 +35,7 @@ function toEsrganAddonConfig(config) {
     return {
         ...flattenUpscalerKeys(config.upscaler),
         ...(config.device !== undefined && { device: config.device }),
-        ...(config.verbosity !== undefined && { verbosity: config.verbosity }),
+        ...(config.verbosity !== undefined && { verbosity: config.verbosity })
     };
 }
 /**
@@ -48,34 +48,40 @@ function toEsrganAddonConfig(config) {
  */
 export const diffusionPlugin = definePlugin({
     modelType: ModelType.sdcppGeneration,
-    displayName: "Image Generation & Upscaling (stable-diffusion.cpp)",
+    displayName: 'Image Generation & Upscaling (stable-diffusion.cpp)',
     addonPackage: ADDON_DIFFUSION,
     loadConfigSchema: sdcppConfigSchema,
     async resolveConfig(cfg, ctx) {
         // Standalone-upscaler mode never references auxiliary models: the primary
         // modelSrc IS the ESRGAN file. Skip resolution to avoid downloading
         // unused encoders/VAEs and to keep load fast.
-        if (cfg.mode === "upscale") {
+        if (cfg.mode === 'upscale') {
             return { config: cfg };
         }
         const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, upscaler, ...rest } = cfg;
         // Video jobs do not apply ESRGAN so we drop the whole `upscaler` object.
-        const effectiveUpscaler = cfg.mode === "video" ? undefined : upscaler;
+        const effectiveUpscaler = cfg.mode === 'video' ? undefined : upscaler;
         const { model_src: esrganModelSrc, ...upscalerRuntime } = effectiveUpscaler ?? {};
         const runtimeConfig = {
             ...rest,
-            ...(effectiveUpscaler && { upscaler: upscalerRuntime }),
+            ...(effectiveUpscaler && { upscaler: upscalerRuntime })
         };
         const sources = {
-            clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc,
-            llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, esrganModelSrc,
+            clipLModelSrc,
+            clipGModelSrc,
+            clipVisionModelSrc,
+            t5XxlModelSrc,
+            llmModelSrc,
+            vaeModelSrc,
+            highNoiseDiffusionModelSrc,
+            esrganModelSrc
         };
         const hasSources = Object.values(sources).some(Boolean);
         if (!hasSources) {
             return { config: runtimeConfig };
         }
         const resolve = ctx.resolveModelPath;
-        const [clipLModelPath, clipGModelPath, clipVisionModelPath, t5XxlModelPath, llmModelPath, vaeModelPath, highNoiseDiffusionModelPath, esrganModelPath,] = await Promise.all([
+        const [clipLModelPath, clipGModelPath, clipVisionModelPath, t5XxlModelPath, llmModelPath, vaeModelPath, highNoiseDiffusionModelPath, esrganModelPath] = await Promise.all([
             clipLModelSrc ? resolve(clipLModelSrc) : undefined,
             clipGModelSrc ? resolve(clipGModelSrc) : undefined,
             clipVisionModelSrc ? resolve(clipVisionModelSrc) : undefined,
@@ -83,7 +89,7 @@ export const diffusionPlugin = definePlugin({
             llmModelSrc ? resolve(llmModelSrc) : undefined,
             vaeModelSrc ? resolve(vaeModelSrc) : undefined,
             highNoiseDiffusionModelSrc ? resolve(highNoiseDiffusionModelSrc) : undefined,
-            esrganModelSrc ? resolve(esrganModelSrc) : undefined,
+            esrganModelSrc ? resolve(esrganModelSrc) : undefined
         ]);
         return {
             config: runtimeConfig,
@@ -95,8 +101,8 @@ export const diffusionPlugin = definePlugin({
                 ...(llmModelPath && { llmModelPath }),
                 ...(vaeModelPath && { vaeModelPath }),
                 ...(highNoiseDiffusionModelPath && { highNoiseDiffusionModelPath }),
-                ...(esrganModelPath && { esrganModelPath }),
-            },
+                ...(esrganModelPath && { esrganModelPath })
+            }
         };
     },
     createModel(params) {
@@ -107,45 +113,45 @@ export const diffusionPlugin = definePlugin({
         // the main diffusion checkpoint. Reject early with a clear error
         // instead of letting the native addon fail mid-load. Done before any
         // logger / native side-effects so callers can recover cleanly.
-        if (config.mode === "diffusion" &&
+        if (config.mode === 'diffusion' &&
             config.upscaler !== undefined &&
-            !artifacts?.["esrganModelPath"]) {
-            throw new ModelLoadFailedError("modelConfig.upscaler.model_src is required when modelConfig.upscaler " +
-                "is set in diffusion mode. Provide the ESRGAN model, omit the " +
+            !artifacts?.['esrganModelPath']) {
+            throw new ModelLoadFailedError('modelConfig.upscaler.model_src is required when modelConfig.upscaler ' +
+                'is set in diffusion mode. Provide the ESRGAN model, omit the ' +
                 "upscaler block, or switch to modelConfig.mode = 'upscale' to load " +
-                "a standalone upscaler.");
+                'a standalone upscaler.');
         }
         const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
         registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
-        if (config.mode === "upscale") {
+        if (config.mode === 'upscale') {
             const model = new EsrganUpscaler({
                 files: { esrgan: modelPath },
                 config: toEsrganAddonConfig(config),
                 logger,
-                opts: { stats: true },
+                opts: { stats: true }
             });
             return { model };
         }
-        if (config.mode === "video") {
-            if (!artifacts?.["t5XxlModelPath"]) {
-                throw new ModelLoadFailedError("modelConfig.t5XxlModelSrc is required in video mode. " +
-                    "Provide the Wan text encoder model before loading the video pipeline.");
+        if (config.mode === 'video') {
+            if (!artifacts?.['t5XxlModelPath']) {
+                throw new ModelLoadFailedError('modelConfig.t5XxlModelSrc is required in video mode. ' +
+                    'Provide the Wan text encoder model before loading the video pipeline.');
             }
-            if (!artifacts?.["vaeModelPath"]) {
-                throw new ModelLoadFailedError("modelConfig.vaeModelSrc is required in video mode. " +
-                    "Provide the Wan VAE model before loading the video pipeline.");
+            if (!artifacts?.['vaeModelPath']) {
+                throw new ModelLoadFailedError('modelConfig.vaeModelSrc is required in video mode. ' +
+                    'Provide the Wan VAE model before loading the video pipeline.');
             }
             const files = {
                 model: modelPath,
-                t5Xxl: artifacts["t5XxlModelPath"],
-                vae: artifacts["vaeModelPath"],
-                ...(artifacts?.["highNoiseDiffusionModelPath"] && {
-                    highNoiseDiffusionModel: artifacts["highNoiseDiffusionModelPath"],
+                t5Xxl: artifacts['t5XxlModelPath'],
+                vae: artifacts['vaeModelPath'],
+                ...(artifacts?.['highNoiseDiffusionModelPath'] && {
+                    highNoiseDiffusionModel: artifacts['highNoiseDiffusionModelPath']
                 }),
-                ...(artifacts?.["clipVisionModelPath"] && {
-                    clipVision: artifacts["clipVisionModelPath"],
+                ...(artifacts?.['clipVisionModelPath'] && {
+                    clipVision: artifacts['clipVisionModelPath']
                 }),
-                ...(artifacts?.["esrganModelPath"] && { esrgan: artifacts["esrganModelPath"] }),
+                ...(artifacts?.['esrganModelPath'] && { esrgan: artifacts['esrganModelPath'] })
             };
             /* eslint-disable @typescript-eslint/no-unused-vars */
             const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, upscaler, mode, ...rest } = config;
@@ -154,18 +160,18 @@ export const diffusionPlugin = definePlugin({
                 files,
                 config: rest,
                 logger,
-                opts: { stats: true },
+                opts: { stats: true }
             });
             return { model };
         }
         const files = {
             model: modelPath,
-            ...(artifacts?.["clipLModelPath"] && { clipL: artifacts["clipLModelPath"] }),
-            ...(artifacts?.["clipGModelPath"] && { clipG: artifacts["clipGModelPath"] }),
-            ...(artifacts?.["t5XxlModelPath"] && { t5Xxl: artifacts["t5XxlModelPath"] }),
-            ...(artifacts?.["llmModelPath"] && { llm: artifacts["llmModelPath"] }),
-            ...(artifacts?.["vaeModelPath"] && { vae: artifacts["vaeModelPath"] }),
-            ...(artifacts?.["esrganModelPath"] && { esrgan: artifacts["esrganModelPath"] }),
+            ...(artifacts?.['clipLModelPath'] && { clipL: artifacts['clipLModelPath'] }),
+            ...(artifacts?.['clipGModelPath'] && { clipG: artifacts['clipGModelPath'] }),
+            ...(artifacts?.['t5XxlModelPath'] && { t5Xxl: artifacts['t5XxlModelPath'] }),
+            ...(artifacts?.['llmModelPath'] && { llm: artifacts['llmModelPath'] }),
+            ...(artifacts?.['vaeModelPath'] && { vae: artifacts['vaeModelPath'] }),
+            ...(artifacts?.['esrganModelPath'] && { esrgan: artifacts['esrganModelPath'] })
         };
         // `mode` is consumed by this plugin to select the model class above; the
         // stable-diffusion.cpp native config does not understand it. Strip it
@@ -174,13 +180,13 @@ export const diffusionPlugin = definePlugin({
         const { upscaler, mode, ...rest } = config;
         const addonConfig = {
             ...rest,
-            ...flattenUpscalerKeys(upscaler),
+            ...flattenUpscalerKeys(upscaler)
         };
         const model = new ImgStableDiffusion({
             files,
             config: addonConfig,
             logger,
-            opts: { stats: true },
+            opts: { stats: true }
         });
         return { model };
     },
@@ -191,15 +197,15 @@ export const diffusionPlugin = definePlugin({
             streaming: true,
             // sdcpp diffusion exposes a model-wide hard cancel — compute
             // is interrupted on the currently-running generation.
-            cancel: { scope: "model", hard: true },
-            handler: diffusion,
+            cancel: { scope: 'model', hard: true },
+            handler: diffusion
         }),
         videoStream: defineHandler({
             requestSchema: videoRequestSchema,
             responseSchema: videoStreamResponseSchema,
             streaming: true,
-            cancel: { scope: "model", hard: true },
-            handler: video,
+            cancel: { scope: 'model', hard: true },
+            handler: video
         }),
         upscaleStream: defineHandler({
             requestSchema: upscaleRequestSchema,
@@ -207,12 +213,12 @@ export const diffusionPlugin = definePlugin({
             streaming: true,
             // sdcpp upscale path has no cancel surface today — SDK falls
             // back to soft-cancel.
-            cancel: { scope: "none" },
-            handler: upscale,
-        }),
+            cancel: { scope: 'none' },
+            handler: upscale
+        })
     },
     logging: {
         module: addonLogging,
-        namespace: ModelType.sdcppGeneration,
-    },
+        namespace: ModelType.sdcppGeneration
+    }
 });

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech-stream.d.ts

@@ -1,5 +1,5 @@
-import { type TextToSpeechStreamRequest, type TtsStats } from "../../../../../schemas/index";
-import { type TtsOpYield } from "../../../utils/tts-stats";
+import { type TextToSpeechStreamRequest, type TtsStats } from '../../../../../schemas/index';
+import { type TtsOpYield } from '../../../utils/tts-stats';
 export declare function textToSpeechStream(params: TextToSpeechStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<TtsOpYield, {
     modelExecutionMs: number;
     stats?: TtsStats;

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech-stream.js

@@ -1,14 +1,14 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { textToSpeechStreamRequestSchema, } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
-import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
-import { TextToSpeechStreamFailedError } from "../../../../../utils/errors-server.js";
-import { collectTtsStats, } from "../../../utils/tts-stats.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { textToSpeechStreamRequestSchema } from '../../../../../schemas/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
+import { TextToSpeechStreamFailedError } from '../../../../../utils/errors-server.js';
+import { collectTtsStats } from '../../../utils/tts-stats.js';
 function hasRunStreaming(model) {
-    return (typeof model === "object" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "runStreaming" in model &&
-        typeof model.runStreaming === "function");
+        'runStreaming' in model &&
+        typeof model.runStreaming === 'function');
 }
 function findLastCompleteUtf8End(buf) {
     const len = buf.length;
@@ -38,18 +38,16 @@ async function* buffersToUtf8Fragments(inputStream) {
         const combined = pending.length === 0 ? buf : Buffer.concat([pending, buf]);
         const completeEnd = findLastCompleteUtf8End(combined);
         if (completeEnd > 0) {
-            const s = combined.subarray(0, completeEnd).toString("utf8");
+            const s = combined.subarray(0, completeEnd).toString('utf8');
             if (s.length > 0) {
                 yield s;
             }
         }
         pending =
-            completeEnd < combined.length
-                ? Buffer.from(combined.subarray(completeEnd))
-                : Buffer.alloc(0);
+            completeEnd < combined.length ? Buffer.from(combined.subarray(completeEnd)) : Buffer.alloc(0);
     }
     if (pending.length > 0) {
-        const s = pending.toString("utf8");
+        const s = pending.toString('utf8');
         if (s.length > 0) {
             yield s;
         }
@@ -58,16 +56,16 @@ async function* buffersToUtf8Fragments(inputStream) {
 function buildRunStreamingOptions(request) {
     const o = {};
     if (request.accumulateSentences !== undefined) {
-        o["accumulateSentences"] = request.accumulateSentences;
+        o['accumulateSentences'] = request.accumulateSentences;
     }
     if (request.sentenceDelimiterPreset !== undefined) {
-        o["sentenceDelimiterPreset"] = request.sentenceDelimiterPreset;
+        o['sentenceDelimiterPreset'] = request.sentenceDelimiterPreset;
     }
     if (request.maxBufferScalars !== undefined) {
-        o["maxBufferScalars"] = request.maxBufferScalars;
+        o['maxBufferScalars'] = request.maxBufferScalars;
     }
     if (request.flushAfterMs !== undefined) {
-        o["flushAfterMs"] = request.flushAfterMs;
+        o['flushAfterMs'] = request.flushAfterMs;
     }
     return o;
 }
@@ -76,7 +74,7 @@ export async function* textToSpeechStream(params, inputStream) {
     const model = getModel(request.modelId);
     const modelStart = nowMs();
     if (!hasRunStreaming(model)) {
-        throw new TextToSpeechStreamFailedError("textToSpeechStream requires a TTS model with runStreaming");
+        throw new TextToSpeechStreamFailedError('textToSpeechStream requires a TTS model with runStreaming');
     }
     const textSource = buffersToUtf8Fragments(inputStream);
     const streamOpts = buildRunStreamingOptions(request);
@@ -92,9 +90,9 @@ export async function* textToSpeechStream(params, inputStream) {
         yield {
             buffer: buf,
             ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-            ...(typeof data.sentenceChunk === "string" && data.sentenceChunk.length > 0
+            ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
                 ? { sentenceChunk: data.sentenceChunk }
-                : {}),
+                : {})
         };
     }
     const modelExecutionMs = nowMs() - modelStart;