@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,40 +0,0 @@
-import { EsrganUpscaler } from '@qvac/diffusion-cpp';
-import { getModel, getModelEntry } from '../../../../../server/bare/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
-// structured error rather than letting a TypeError propagate.
-function asUpscalerModel(model, modelId) {
-    if (model instanceof EsrganUpscaler) {
-        return model;
-    }
-    const entry = getModelEntry(modelId);
-    const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
-    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 });
-    // 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
-    // multi-output variants.
-    let outputIndex = 0;
-    for await (const chunk of response.iterate()) {
-        if (chunk instanceof Uint8Array) {
-            yield {
-                type: 'upscaleStream',
-                data: Buffer.from(chunk).toString('base64'),
-                outputIndex: outputIndex++
-            };
-        }
-    }
-    const responseWithStats = response;
-    yield {
-        type: 'upscaleStream',
-        done: true,
-        stats: responseWithStats.stats ?? undefined
-    };
-}

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

@@ -1,6 +0,0 @@
-import { VideoStableDiffusion } from '@qvac/diffusion-cpp';
-import { type VideoRequest, type VideoStreamResponse } from '../../../../../schemas/sdcpp-config.js';
-export declare function markLtxVideoModel(model: VideoStableDiffusion): void;
-export declare function markMoeCapableVideoModel(model: VideoStableDiffusion): void;
-export declare function video(request: VideoRequest): AsyncGenerator<VideoStreamResponse>;
-//# sourceMappingURL=video.d.ts.map

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

@@ -1,238 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    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 '../../../../../server/bare/registry/model-registry.js';
-import { getRequestRegistry, withRequestContext } from '../../../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../../../server/bare/runtime/request-id.js';
-import { ModelOperationNotSupportedError, PluginRequestValidationFailedError } from '../../../../../utils/errors-server.js';
-import { formatZodError } from '../../../../../utils/zod-error.js';
-import { ModelType } from '../../../../../schemas/index.js';
-import { ltxVideoRequestSchema, singleExpertVideoRequestSchema } from '../../../../../schemas/sdcpp-config.js';
-const ltxVideoModels = new WeakSet();
-const moeCapableVideoModels = new WeakSet();
-export function markLtxVideoModel(model) {
-    ltxVideoModels.add(model);
-}
-export function markMoeCapableVideoModel(model) {
-    moeCapableVideoModels.add(model);
-}
-function parseVideoRequest(schema, request) {
-    const result = schema.safeParse(request);
-    if (!result.success) {
-        throw new PluginRequestValidationFailedError('videoStream', formatZodError(result.error));
-    }
-}
-// The addon reports `hasAudio` as a numeric flag (1/0); the SDK surfaces it as
-// a boolean so consumers get a readable `stats.hasAudio` instead of a magic
-// number. Everything else passes through and is validated client-side.
-function toVideoStats(stats) {
-    if (!stats)
-        return undefined;
-    const { hasAudio, ...rest } = stats;
-    return {
-        ...rest,
-        ...(hasAudio !== undefined && { hasAudio: hasAudio !== 0 })
-    };
-}
-// 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
-// the call upfront with a structured error rather than letting a native-addon
-// error propagate.
-function asVideoModel(model, modelId) {
-    if (model instanceof VideoStableDiffusion) {
-        return model;
-    }
-    const entry = getModelEntry(modelId);
-    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
-        }), true);
-        const requestLogger = withRequestContext(getServerLogger(), ctx);
-        const model = asVideoModel(getModel(request.modelId), request.modelId);
-        if (ltxVideoModels.has(model))
-            parseVideoRequest(ltxVideoRequestSchema, request);
-        if (!moeCapableVideoModels.has(model))
-            parseVideoRequest(singleExpertVideoRequestSchema, request);
-        const onAbort = () => {
-            model.cancel().catch((err) => {
-                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 });
-        if (ctx.signal.aborted)
-            onAbort();
-        ctx.scope.defer(() => {
-            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
-            }),
-            ...(request.width !== undefined && { width: request.width }),
-            ...(request.height !== undefined && { height: request.height }),
-            ...(request.video_frames !== undefined && {
-                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
-            }),
-            ...(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
-            }),
-            ...(request.high_noise_sampler !== undefined && {
-                high_noise_sampler: request.high_noise_sampler
-            }),
-            ...(request.high_noise_scheduler !== undefined && {
-                high_noise_scheduler: request.high_noise_scheduler
-            }),
-            ...(request.high_noise_cfg_scale !== undefined && {
-                high_noise_cfg_scale: request.high_noise_cfg_scale
-            }),
-            ...(request.high_noise_flow_shift !== undefined && {
-                high_noise_flow_shift: request.high_noise_flow_shift
-            }),
-            ...(request.moe_boundary !== undefined && {
-                moe_boundary: request.moe_boundary
-            }),
-            ...(request.vace_strength !== undefined && {
-                vace_strength: request.vace_strength
-            }),
-            ...(request.init_image !== undefined && {
-                init_image: Buffer.from(request.init_image, 'base64')
-            }),
-            ...(request.strength !== undefined && {
-                strength: request.strength
-            }),
-            ...(request.control_frames !== undefined && {
-                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
-            }),
-            ...(request.vae_tile_overlap !== undefined && {
-                vae_tile_overlap: request.vae_tile_overlap
-            }),
-            ...(request.temporal_tiling !== undefined && {
-                temporal_tiling: request.temporal_tiling
-            }),
-            ...(request.cache_mode !== undefined && { cache_mode: request.cache_mode }),
-            ...(request.cache_preset !== undefined && {
-                cache_preset: request.cache_preset
-            }),
-            ...(request.cache_threshold !== undefined && {
-                cache_threshold: request.cache_threshold
-            })
-        });
-        let outputIndex = 0;
-        for await (const chunk of response.iterate()) {
-            if (ctx.signal.aborted)
-                break;
-            if (chunk instanceof Uint8Array) {
-                yield {
-                    type: 'videoStream',
-                    data: Buffer.from(chunk).toString('base64'),
-                    outputIndex: outputIndex++
-                };
-            }
-            else if (typeof chunk === 'string') {
-                try {
-                    const tick = JSON.parse(chunk);
-                    if ('step' in tick) {
-                        yield {
-                            type: 'videoStream',
-                            step: tick['step'],
-                            totalSteps: tick['total'],
-                            elapsedMs: tick['elapsed_ms']
-                        };
-                    }
-                }
-                catch {
-                    // Non-JSON string output — skip
-                }
-            }
-        }
-        const responseWithStats = response;
-        yield {
-            type: 'videoStream',
-            done: true,
-            stats: toVideoStats(responseWithStats.stats)
-        };
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}