vidspotai-shared 1.0.117 → 1.0.119

package/lib/services/agent/tools/estimateCost.tool.d.ts

@@ -241,6 +241,12 @@ declare const InputSchema: z.ZodObject<{
             }>>;
             backgroundColor: z.ZodOptional<z.ZodString>;
             shadow: z.ZodOptional<z.ZodString>;
+            gradient: z.ZodOptional<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                angle: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            curve: z.ZodOptional<z.ZodNumber>;
             preset: z.ZodOptional<z.ZodEnum<{
                 none: "none";
                 "fade-soft": "fade-soft";
@@ -351,6 +357,68 @@ declare const InputSchema: z.ZodObject<{
             }, z.core.$strip>>;
             locked: z.ZodDefault<z.ZodBoolean>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"shape">;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            shapeKind: z.ZodOptional<z.ZodEnum<{
+                rectangle: "rectangle";
+                ellipse: "ellipse";
+                line: "line";
+                triangle: "triangle";
+                arrow: "arrow";
+            }>>;
+            fill: z.ZodDefault<z.ZodString>;
+            gradient: z.ZodOptional<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                angle: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            borderWidth: z.ZodOptional<z.ZodNumber>;
+            borderColor: z.ZodOptional<z.ZodString>;
+            borderRadius: z.ZodOptional<z.ZodNumber>;
+            maskSrc: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>], "type">>;
         transitions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodString;

package/lib/services/agent/tools/estimateCost.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimateCost.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/estimateCost.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;iBAmBhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAC3C,OAAO,WAAW,EAClB,OAAO,YAAY,CAgEpB,CAAC"}
+{"version":3,"file":"estimateCost.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/estimateCost.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;iBAmBhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAC3C,OAAO,WAAW,EAClB,OAAO,YAAY,CAgEpB,CAAC"}

package/lib/services/agent/tools/planVideo.tool.d.ts

@@ -308,12 +308,12 @@ declare const OutputSchema: z.ZodObject<{
                     y: z.ZodNumber;
                 }, z.core.$strip>>;
                 backgroundFill: z.ZodOptional<z.ZodEnum<{
+                    gradient: "gradient";
                     black: "black";
                     white: "white";
                     "brand-primary": "brand-primary";
                     "brand-secondary": "brand-secondary";
                     "blur-extend": "blur-extend";
-                    gradient: "gradient";
                 }>>;
             }, z.core.$strip>>;
             broll: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/lib/services/agent/tools/render.tool.d.ts

@@ -256,6 +256,12 @@ declare const InputSchema: z.ZodObject<{
             }>>;
             backgroundColor: z.ZodOptional<z.ZodString>;
             shadow: z.ZodOptional<z.ZodString>;
+            gradient: z.ZodOptional<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                angle: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            curve: z.ZodOptional<z.ZodNumber>;
             preset: z.ZodOptional<z.ZodEnum<{
                 none: "none";
                 "fade-soft": "fade-soft";
@@ -366,6 +372,68 @@ declare const InputSchema: z.ZodObject<{
             }, z.core.$strip>>;
             locked: z.ZodDefault<z.ZodBoolean>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"shape">;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            shapeKind: z.ZodOptional<z.ZodEnum<{
+                rectangle: "rectangle";
+                ellipse: "ellipse";
+                line: "line";
+                triangle: "triangle";
+                arrow: "arrow";
+            }>>;
+            fill: z.ZodDefault<z.ZodString>;
+            gradient: z.ZodOptional<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                angle: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            borderWidth: z.ZodOptional<z.ZodNumber>;
+            borderColor: z.ZodOptional<z.ZodString>;
+            borderRadius: z.ZodOptional<z.ZodNumber>;
+            maskSrc: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>], "type">>;
         transitions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodString;

package/lib/services/agent/tools/render.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}
+{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}

package/lib/services/aiGen/aiGenFactory.service.d.ts

@@ -1,5 +1,5 @@
 import { BaseAiGenProviderService } from "./providers/baseAiGenProvider.service";
-import { EImageGenModelKey, EMusicGenModels, ESfxGenModels, ETextGenModels, EVideoGenModels, TAiGenModel } from "../../globals/aiModels";
+import { EImageGenModelKey, EMusicGenModels, ESfxGenModels, ETextGenModels, EUpscaleImageModelKey, EUpscaleVideoModelKey, EVideoGenModels, TAiGenModel } from "../../globals/aiModels";
 type AiGenServiceConstructor = new () => BaseAiGenProviderService;
 export declare const videoServicesMap: Partial<Record<EVideoGenModels, AiGenServiceConstructor>>;
 /**
@@ -26,6 +26,24 @@ export declare const musicServicesMap: Record<EMusicGenModels, AiGenServiceConst
  */
 export declare const sfxServicesMap: Record<ESfxGenModels, AiGenServiceConstructor>;
 export declare const textServicesMap: Record<ETextGenModels, AiGenServiceConstructor>;
+/**
+ * Upscale factories — deliberately separate from `imageServicesMap` /
+ * `videoServicesMap` (and NOT folded into `getAiGenProviderService`): upscale
+ * callers (upscale controller/processors) always know their modality up
+ * front, so a giant shared if-chain would just add an unused branch to every
+ * other caller.
+ *
+ * Currently routed to FalUpscaleService (fal.ai `fal-ai/esrgan` /
+ * `fal-ai/video-upscaler`), NOT TopazService — this is a cost/pricing
+ * evaluation swap, not a model-key change: the enum keys, request schemas,
+ * and credit-estimate formulas are all still the "topaz-*" ones (see
+ * FalUpscaleService.getCreditUsed doc). TopazService itself is untouched and
+ * fully working; revert either line below to switch back.
+ */
+export declare const upscaleImageServicesMap: Record<EUpscaleImageModelKey, AiGenServiceConstructor>;
+export declare const upscaleVideoServicesMap: Record<EUpscaleVideoModelKey, AiGenServiceConstructor>;
+export declare function getUpscaleImageProviderService(modelKey: EUpscaleImageModelKey): BaseAiGenProviderService;
+export declare function getUpscaleVideoProviderService(modelKey: EUpscaleVideoModelKey): BaseAiGenProviderService;
 export declare function getAiGenProviderService(modelKey: TAiGenModel): BaseAiGenProviderService;
 export {};
 //# sourceMappingURL=aiGenFactory.service.d.ts.map

package/lib/services/aiGen/aiGenFactory.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAchC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AASlE,eAAO,MAAM,gBAAgB,EAAE,OAAO,CACpC,MAAM,CAAC,eAAe,EAAE,uBAAuB,CAAC,CAkEjD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAmB1B"}
+{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,qBAAqB,EAErB,qBAAqB,EAErB,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAehC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AASlE,eAAO,MAAM,gBAAgB,EAAE,OAAO,CACpC,MAAM,CAAC,eAAe,EAAE,uBAAuB,CAAC,CAkEjD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAmB1B"}

package/lib/services/aiGen/aiGenFactory.service.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.textServicesMap = exports.sfxServicesMap = exports.musicServicesMap = exports.imageServicesMap = exports.videoServicesMap = void 0;
+exports.upscaleVideoServicesMap = exports.upscaleImageServicesMap = exports.textServicesMap = exports.sfxServicesMap = exports.musicServicesMap = exports.imageServicesMap = exports.videoServicesMap = void 0;
+exports.getUpscaleImageProviderService = getUpscaleImageProviderService;
+exports.getUpscaleVideoProviderService = getUpscaleVideoProviderService;
 exports.getAiGenProviderService = getAiGenProviderService;
 const aiModels_1 = require("../../globals/aiModels");
 const google_service_1 = require("./providers/google/google.service");
@@ -14,6 +16,7 @@ const pixverse_service_1 = require("./providers/pixverse/pixverse.service");
 const bytedance_service_1 = require("./providers/bytedance/bytedance.service");
 const elevenlabs_service_1 = require("./providers/elevenlabs/elevenlabs.service");
 const anthropic_service_1 = require("./providers/anthropic/anthropic.service");
+const falUpscale_service_1 = require("./providers/fal/falUpscale.service");
 // Partial, intentionally: hosted avatar engines (heygen-avatar, tavus-avatar)
 // are NOT generic video models — they're handled by the dedicated avatar seam
 // (getAvatarVideoProvider / IAvatarVideoProvider). getAiGenProviderService gates
@@ -166,6 +169,40 @@ exports.textServicesMap = {
     // "openai-gpt-4o": OpenaiService,
     // "openai-gpt-3.5-turbo": OpenaiService,
 };
+/**
+ * Upscale factories — deliberately separate from `imageServicesMap` /
+ * `videoServicesMap` (and NOT folded into `getAiGenProviderService`): upscale
+ * callers (upscale controller/processors) always know their modality up
+ * front, so a giant shared if-chain would just add an unused branch to every
+ * other caller.
+ *
+ * Currently routed to FalUpscaleService (fal.ai `fal-ai/esrgan` /
+ * `fal-ai/video-upscaler`), NOT TopazService — this is a cost/pricing
+ * evaluation swap, not a model-key change: the enum keys, request schemas,
+ * and credit-estimate formulas are all still the "topaz-*" ones (see
+ * FalUpscaleService.getCreditUsed doc). TopazService itself is untouched and
+ * fully working; revert either line below to switch back.
+ */
+exports.upscaleImageServicesMap = {
+    [aiModels_1.EUpscaleImageModels.TOPAZ_IMAGE_STANDARD_V2]: falUpscale_service_1.FalUpscaleService, // was: TopazService
+};
+exports.upscaleVideoServicesMap = {
+    [aiModels_1.EUpscaleVideoModels.TOPAZ_VIDEO_PROTEUS]: falUpscale_service_1.FalUpscaleService, // was: TopazService
+};
+function getUpscaleImageProviderService(modelKey) {
+    const Service = exports.upscaleImageServicesMap[modelKey];
+    if (!Service) {
+        throw new Error(`Unsupported upscale image model: ${modelKey}`);
+    }
+    return new Service();
+}
+function getUpscaleVideoProviderService(modelKey) {
+    const Service = exports.upscaleVideoServicesMap[modelKey];
+    if (!Service) {
+        throw new Error(`Unsupported upscale video model: ${modelKey}`);
+    }
+    return new Service();
+}
 function getAiGenProviderService(modelKey) {
     const VideoService = exports.videoServicesMap[modelKey];
     if (VideoService) {

package/lib/services/aiGen/providers/baseAiGenProvider.service.d.ts

@@ -1,4 +1,4 @@
-import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult, MusicGenerationParams, MusicGenerationResult, SfxGenerationParams, SfxGenerationResult, StockSearchParams, StockSearchResult, TextGenerationParams, TextGenerationResult, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "./types";
+import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult, MusicGenerationParams, MusicGenerationResult, SfxGenerationParams, SfxGenerationResult, StockSearchParams, StockSearchResult, TextGenerationParams, TextGenerationResult, UpscaleImageParams, UpscaleImageStatusResult, UpscaleStatusParams, UpscaleSubmitResult, UpscaleVideoParams, UpscaleVideoStatusResult, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "./types";
 /**
  * Base class for every AI-generation provider (video, image, text).
  *
@@ -21,6 +21,18 @@ export declare abstract class BaseAiGenProviderService {
     generateSoundEffects(params: SfxGenerationParams): Promise<SfxGenerationResult>;
     /** Stock asset search (T0 tier providers like Pexels/Pixabay). */
     searchStock(params: StockSearchParams): Promise<StockSearchResult>;
+    /** Submit an async image-upscale job. Returns the provider's request id — poll via checkUpscaleImageStatus. */
+    upscaleImage(params: UpscaleImageParams): Promise<UpscaleSubmitResult>;
+    /** Poll an image-upscale job. On completion, `outputUrl` must already be persisted into our own storage. */
+    checkUpscaleImageStatus(params: UpscaleStatusParams): Promise<UpscaleImageStatusResult>;
+    /**
+     * Submit an async video-upscale job. Drives the full submit -> accept ->
+     * upload -> complete-upload sequence and returns the provider's request id
+     * once processing has started — poll via checkUpscaleVideoStatus.
+     */
+    upscaleVideo(params: UpscaleVideoParams): Promise<UpscaleSubmitResult>;
+    /** Poll a video-upscale job. On completion, `outputUrl` must already be persisted into our own storage. */
+    checkUpscaleVideoStatus(params: UpscaleStatusParams): Promise<UpscaleVideoStatusResult>;
     getCreditUsed(params: CreditUsageParams): number;
 }
 //# sourceMappingURL=baseAiGenProvider.service.d.ts.map

package/lib/services/aiGen/providers/baseAiGenProvider.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"baseAiGenProvider.service.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/providers/baseAiGenProvider.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;GASG;AACH,8BAAsB,wBAAwB;IACtC,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAI3B,gBAAgB,CACpB,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,iBAAiB,CAAC;IAIvB,YAAY,CAChB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC;IAIhC,oEAAoE;IAC9D,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAIjC,8FAA8F;IACxF,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAIjC,0DAA0D;IACpD,oBAAoB,CACxB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAI/B,kEAAkE;IAC5D,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIxE,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM;CAGjD"}
+{"version":3,"file":"baseAiGenProvider.service.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/providers/baseAiGenProvider.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;GASG;AACH,8BAAsB,wBAAwB;IACtC,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAI3B,gBAAgB,CACpB,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,iBAAiB,CAAC;IAIvB,YAAY,CAChB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC;IAIhC,oEAAoE;IAC9D,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAIjC,8FAA8F;IACxF,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAIjC,0DAA0D;IACpD,oBAAoB,CACxB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAI/B,kEAAkE;IAC5D,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIxE,+GAA+G;IACzG,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI5E,4GAA4G;IACtG,uBAAuB,CAC3B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,wBAAwB,CAAC;IAMpC;;;;OAIG;IACG,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI5E,2GAA2G;IACrG,uBAAuB,CAC3B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,wBAAwB,CAAC;IAMpC,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM;CAGjD"}

package/lib/services/aiGen/providers/baseAiGenProvider.service.js

@@ -37,6 +37,26 @@ class BaseAiGenProviderService {
     async searchStock(params) {
         throw new Error("searchStock not implemented for this provider");
     }
+    /** Submit an async image-upscale job. Returns the provider's request id — poll via checkUpscaleImageStatus. */
+    async upscaleImage(params) {
+        throw new Error("upscaleImage not implemented for this provider");
+    }
+    /** Poll an image-upscale job. On completion, `outputUrl` must already be persisted into our own storage. */
+    async checkUpscaleImageStatus(params) {
+        throw new Error("checkUpscaleImageStatus not implemented for this provider");
+    }
+    /**
+     * Submit an async video-upscale job. Drives the full submit -> accept ->
+     * upload -> complete-upload sequence and returns the provider's request id
+     * once processing has started — poll via checkUpscaleVideoStatus.
+     */
+    async upscaleVideo(params) {
+        throw new Error("upscaleVideo not implemented for this provider");
+    }
+    /** Poll a video-upscale job. On completion, `outputUrl` must already be persisted into our own storage. */
+    async checkUpscaleVideoStatus(params) {
+        throw new Error("checkUpscaleVideoStatus not implemented for this provider");
+    }
     getCreditUsed(params) {
         throw new Error("getCreditUsed not implemented for this provider");
     }

package/lib/services/aiGen/providers/fal/falUpscale.service.d.ts

@@ -0,0 +1,38 @@
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import { CreditUsageParams, UpscaleImageParams, UpscaleImageStatusResult, UpscaleStatusParams, UpscaleSubmitResult, UpscaleVideoParams, UpscaleVideoStatusResult } from "../types";
+/**
+ * fal.ai upscale provider (image + video) — wired in behind the SAME
+ * EUpscaleImageModels/EUpscaleVideoModels model keys Topaz used
+ * ("topaz-image-standard-v2" / "topaz-video-proteus"), via
+ * upscaleImageServicesMap/upscaleVideoServicesMap in aiGenFactory.service.ts.
+ * TopazService is left fully intact (not deleted, not called) — this is
+ * purely a factory-map swap so the frontend, request schemas, model configs,
+ * and credit estimates are all untouched. Re-point the map back to
+ * TopazService to revert.
+ *
+ * Both fal endpoints (`fal-ai/esrgan`, `fal-ai/video-upscaler`) take a public
+ * URL directly and run over fal's async queue API — no multipart upload or
+ * multi-step accept/upload/complete dance like Topaz's video flow, since fal
+ * fetches the source URL itself (our own already-stored asset, same as
+ * Topaz's inputImageUrl/inputVideoUrl contract).
+ */
+export declare class FalUpscaleService extends BaseAiGenProviderService {
+    private readonly apiKey;
+    constructor();
+    private headers;
+    upscaleImage(params: UpscaleImageParams): Promise<UpscaleSubmitResult>;
+    checkUpscaleImageStatus({ providerRequestId, outputFilename, outputFilePath, }: UpscaleStatusParams): Promise<UpscaleImageStatusResult>;
+    upscaleVideo(params: UpscaleVideoParams): Promise<UpscaleSubmitResult>;
+    checkUpscaleVideoStatus({ providerRequestId, outputFilename, outputFilePath, }: UpscaleStatusParams): Promise<UpscaleVideoStatusResult>;
+    /**
+     * Deliberately IDENTICAL formula to TopazService.getCreditUsed(): cost
+     * config is looked up from aiModelConfigs by modelKey, and the model keys
+     * ("topaz-image-standard-v2" / "topaz-video-proteus") are unchanged — so
+     * credit estimates and billed amounts stay exactly what they were under
+     * Topaz, regardless of which provider actually services the request. Do
+     * NOT diverge this from Topaz's formula without also revisiting
+     * topaz.ts's cost config.
+     */
+    getCreditUsed({ modelKey, outputMegapixels, duration, creditFloor }: CreditUsageParams): number;
+}
+//# sourceMappingURL=falUpscale.service.d.ts.map

package/lib/services/aiGen/providers/fal/falUpscale.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"falUpscale.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/fal/falUpscale.service.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,UAAU,CAAC;AA8BlB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,SAAQ,wBAAwB;IAC7D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;;IAUhC,OAAO,CAAC,OAAO;IAUT,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkCtE,uBAAuB,CAAC,EAC5B,iBAAiB,EACjB,cAAc,EACd,cAAiC,GAClC,EAAE,mBAAmB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAmDpD,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAiCtE,uBAAuB,CAAC,EAC5B,iBAAiB,EACjB,cAAc,EACd,cAAiC,GAClC,EAAE,mBAAmB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IA+C1D;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAY,EAAE,WAAW,EAAE,EAAE,iBAAiB,GAAG,MAAM;CAiBpG"}

package/lib/services/aiGen/providers/fal/falUpscale.service.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FalUpscaleService = void 0;
+const aiModels_1 = require("../../../../globals/aiModels");
+const creditUnit_1 = require("../../../../globals/creditUnit");
+const storage_1 = require("../../../../libs/storage");
+const errors_1 = require("../../../../utils/errors");
+const helpers_1 = require("../../../../utils/helpers");
+const logger_1 = require("../../../../utils/logger");
+const transientRetry_1 = require("../../transientRetry");
+const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
+const QUEUE_BASE_URL = "https://queue.fal.run";
+// fal app ids — fixed one-per-modality, unlike Topaz's per-modelKey `modelId`
+// lookup: today exactly one EUpscaleImageModels / EUpscaleVideoModels key
+// routes here (see aiGenFactory.service.ts upscale*ServicesMap), so there's
+// no per-request model selection to thread through.
+const IMAGE_APP_ID = "fal-ai/esrgan";
+const VIDEO_APP_ID = "fal-ai/video-upscaler";
+/**
+ * Classify a fal.ai HTTP failure (non-2xx). Same shape as every other
+ * provider's classifier (see topaz.service.ts's classifyTopazHttpError) —
+ * 401/403 is a deploy/config bug (fail fast, no Slack noise per job), 5xx/429
+ * is transient and retried by withTransientRetry, everything else is a real
+ * bug worth alerting on. Error body shape per fal docs: {detail, error_type}.
+ */
+function classifyFalHttpError(status, body, op) {
+    if (status === 401 || status === 403) {
+        return new errors_1.UserFacingError(`fal.ai rejected the API key (HTTP ${status}). Ask an operator to verify FAL_KEY.`, errors_1.USER_FACING_ERROR_CODES.PROVIDER_AUTH_ERROR);
+    }
+    if (status >= 500 || status === 429) {
+        return new transientRetry_1.TransientHttpError(status, `fal ${op} transient HTTP ${status}: ${body.slice(0, 200)}`);
+    }
+    return new Error(`fal ${op} failed (${status}): ${body}`);
+}
+/**
+ * fal.ai upscale provider (image + video) — wired in behind the SAME
+ * EUpscaleImageModels/EUpscaleVideoModels model keys Topaz used
+ * ("topaz-image-standard-v2" / "topaz-video-proteus"), via
+ * upscaleImageServicesMap/upscaleVideoServicesMap in aiGenFactory.service.ts.
+ * TopazService is left fully intact (not deleted, not called) — this is
+ * purely a factory-map swap so the frontend, request schemas, model configs,
+ * and credit estimates are all untouched. Re-point the map back to
+ * TopazService to revert.
+ *
+ * Both fal endpoints (`fal-ai/esrgan`, `fal-ai/video-upscaler`) take a public
+ * URL directly and run over fal's async queue API — no multipart upload or
+ * multi-step accept/upload/complete dance like Topaz's video flow, since fal
+ * fetches the source URL itself (our own already-stored asset, same as
+ * Topaz's inputImageUrl/inputVideoUrl contract).
+ */
+class FalUpscaleService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
+    constructor() {
+        super();
+        if (!process.env.FAL_KEY) {
+            throw new Error("Missing FAL_KEY in environment variables");
+        }
+        this.apiKey = process.env.FAL_KEY;
+    }
+    headers(json) {
+        const h = { Authorization: `Key ${this.apiKey}` };
+        if (json)
+            h["Content-Type"] = "application/json";
+        return h;
+    }
+    // ============================================================
+    // IMAGE UPSCALE
+    // ============================================================
+    async upscaleImage(params) {
+        return (0, transientRetry_1.withTransientRetry)("fal:upscaleImage", async () => {
+            const resp = await fetch(`${QUEUE_BASE_URL}/${IMAGE_APP_ID}`, {
+                method: "POST",
+                headers: this.headers(true),
+                body: JSON.stringify({
+                    image_url: params.inputImageUrl,
+                    scale: params.scale,
+                    output_format: params.outputFormat ?? "jpeg",
+                }),
+            });
+            if (!resp.ok) {
+                throw classifyFalHttpError(resp.status, await resp.text(), "upscaleImage");
+            }
+            const data = (await resp.json());
+            if (!data.request_id) {
+                throw new Error("fal image upscale did not return a request_id");
+            }
+            return { providerRequestId: data.request_id };
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("fal upscaleImage transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+    }
+    async checkUpscaleImageStatus({ providerRequestId, outputFilename, outputFilePath = "upscale_images", }) {
+        const statusResp = await fetch(`${QUEUE_BASE_URL}/${IMAGE_APP_ID}/requests/${providerRequestId}/status`, {
+            headers: this.headers(false),
+        });
+        if (!statusResp.ok) {
+            throw classifyFalHttpError(statusResp.status, await statusResp.text(), "checkUpscaleImageStatus");
+        }
+        const statusData = (await statusResp.json());
+        const normalized = (statusData.status ?? "").toUpperCase();
+        // fal's status payload carries an `error` field on the terminal COMPLETED
+        // state when the job actually failed — there is no separate FAILED status.
+        if (normalized === "COMPLETED" && statusData.error) {
+            return { status: "failed", errorMessage: statusData.error };
+        }
+        if (normalized !== "COMPLETED") {
+            return { status: "processing" };
+        }
+        const resultResp = await fetch(`${QUEUE_BASE_URL}/${IMAGE_APP_ID}/requests/${providerRequestId}`, {
+            headers: this.headers(false),
+        });
+        if (!resultResp.ok) {
+            throw classifyFalHttpError(resultResp.status, await resultResp.text(), "checkUpscaleImageStatus:result");
+        }
+        const result = (await resultResp.json());
+        if (!result.image?.url) {
+            return { status: "failed", errorMessage: result.detail ?? result.error ?? "fal image upscale failed" };
+        }
+        const assetResp = await fetch(result.image.url);
+        if (!assetResp.ok) {
+            throw new Error(`Failed to download fal upscaled image: ${assetResp.status}`);
+        }
+        const contentType = result.image.content_type || assetResp.headers.get("content-type") || "image/jpeg";
+        const ext = (contentType.split("/")[1] || "jpeg").toLowerCase();
+        const buffer = Buffer.from(await assetResp.arrayBuffer());
+        // mediaStorage: GCS write + best-effort R2 mirror (zero-egress delivery).
+        const signedUrl = await storage_1.mediaStorage.put(`${outputFilePath}/${outputFilename}.${ext}`, buffer, contentType);
+        return { status: "completed", outputUrl: signedUrl, width: result.image.width, height: result.image.height };
+    }
+    // ============================================================
+    // VIDEO UPSCALE
+    // ============================================================
+    async upscaleVideo(params) {
+        return (0, transientRetry_1.withTransientRetry)("fal:upscaleVideo", async () => {
+            const resp = await fetch(`${QUEUE_BASE_URL}/${VIDEO_APP_ID}`, {
+                method: "POST",
+                headers: this.headers(true),
+                body: JSON.stringify({
+                    video_url: params.inputVideoUrl,
+                    scale: params.scale,
+                }),
+            });
+            if (!resp.ok) {
+                throw classifyFalHttpError(resp.status, await resp.text(), "upscaleVideo");
+            }
+            const data = (await resp.json());
+            if (!data.request_id) {
+                throw new Error("fal video upscale did not return a request_id");
+            }
+            return { providerRequestId: data.request_id };
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("fal upscaleVideo transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+    }
+    async checkUpscaleVideoStatus({ providerRequestId, outputFilename, outputFilePath = "upscale_videos", }) {
+        const statusResp = await fetch(`${QUEUE_BASE_URL}/${VIDEO_APP_ID}/requests/${providerRequestId}/status`, {
+            headers: this.headers(false),
+        });
+        if (!statusResp.ok) {
+            throw classifyFalHttpError(statusResp.status, await statusResp.text(), "checkUpscaleVideoStatus");
+        }
+        const statusData = (await statusResp.json());
+        const normalized = (statusData.status ?? "").toUpperCase();
+        if (normalized === "COMPLETED" && statusData.error) {
+            return { status: "failed", errorMessage: statusData.error };
+        }
+        if (normalized !== "COMPLETED") {
+            return { status: "processing" };
+        }
+        const resultResp = await fetch(`${QUEUE_BASE_URL}/${VIDEO_APP_ID}/requests/${providerRequestId}`, {
+            headers: this.headers(false),
+        });
+        if (!resultResp.ok) {
+            throw classifyFalHttpError(resultResp.status, await resultResp.text(), "checkUpscaleVideoStatus:result");
+        }
+        const result = (await resultResp.json());
+        if (!result.video?.url) {
+            return { status: "failed", errorMessage: result.detail ?? result.error ?? "fal video upscale failed" };
+        }
+        const assetResp = await fetch(result.video.url);
+        if (!assetResp.ok) {
+            throw new Error(`Failed to download fal upscaled video: ${assetResp.status}`);
+        }
+        const buffer = Buffer.from(await assetResp.arrayBuffer());
+        // mediaStorage: GCS write + best-effort R2 mirror (zero-egress delivery).
+        const signedUrl = await storage_1.mediaStorage.put(`${outputFilePath}/${outputFilename}.mp4`, buffer, "video/mp4");
+        return { status: "completed", outputUrl: signedUrl };
+    }
+    // ============================================================
+    // CREDITS
+    // ============================================================
+    /**
+     * Deliberately IDENTICAL formula to TopazService.getCreditUsed(): cost
+     * config is looked up from aiModelConfigs by modelKey, and the model keys
+     * ("topaz-image-standard-v2" / "topaz-video-proteus") are unchanged — so
+     * credit estimates and billed amounts stay exactly what they were under
+     * Topaz, regardless of which provider actually services the request. Do
+     * NOT diverge this from Topaz's formula without also revisiting
+     * topaz.ts's cost config.
+     */
+    getCreditUsed({ modelKey, outputMegapixels, duration = 5, creditFloor }) {
+        const modelConfig = aiModels_1.aiModelConfigs[modelKey];
+        const cost = modelConfig?.cost;
+        if (cost?.perMegapixel !== undefined) {
+            const megapixels = outputMegapixels ?? 24;
+            return (0, helpers_1.getCreditsFromCost)(cost.perMegapixel * megapixels, true, creditFloor ?? creditUnit_1.MIN_CREDITS_PER_IMAGE_OP);
+        }
+        if (cost?.perSecond !== undefined) {
+            return (0, helpers_1.getCreditsFromCost)(cost.perSecond * duration, true, creditFloor);
+        }
+        logger_1.logger.warn(`fal upscale getCreditUsed: no cost config for modelKey="${modelKey}" — returning fallback`, {
+            modelKey,
+        });
+        return (0, helpers_1.getCreditsFromCost)(1.0, true, creditFloor);
+    }
+}
+exports.FalUpscaleService = FalUpscaleService;

package/lib/services/aiGen/providers/fal/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./falImage.service";
+export * from "./falUpscale.service";
 //# sourceMappingURL=index.d.ts.map

package/lib/services/aiGen/providers/fal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/fal/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/fal/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/lib/services/aiGen/providers/fal/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./falImage.service"), exports);
+__exportStar(require("./falUpscale.service"), exports);