vidspotai-shared 1.0.82 → 1.0.83

package/lib/services/socialPublish/youtube.publish.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YouTubePublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * YouTube publisher — uploads a video via the Data API `videos.insert` resumable
+ * endpoint and sets visibility / native scheduling. Phase 1. See SOCIAL_SUITE_PLAN.md.
+ *
+ * Flow:
+ *   1. POST metadata to the resumable endpoint → get the upload session URL.
+ *   2. PUT the media bytes to that URL → get the video resource (with id).
+ *
+ * Scheduling: when `scheduledAt` is set, YouTube requires `privacyStatus=private`
+ * + `status.publishAt` (RFC3339); it auto-flips to public at that time.
+ *
+ * Quota: `videos.insert` is the expensive call against the shared 10k/day project
+ * quota — the worker should track burn (plan §3). Single-PUT upload is fine for
+ * short-form; switch to chunked upload if we publish very large long-form files.
+ */
+const RESUMABLE_INIT = "https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status";
+class YouTubePublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.YOUTUBE;
+    }
+    async publish(input) {
+        const description = this.buildDescription(input);
+        const privacyStatus = this.resolvePrivacy(input);
+        const metadata = {
+            snippet: {
+                title: (input.title ?? input.caption ?? "VidSpot video").slice(0, 100),
+                description: description.slice(0, 5000),
+            },
+            status: {
+                privacyStatus,
+                selfDeclaredMadeForKids: false,
+                ...(input.scheduledAt
+                    ? { publishAt: new Date(input.scheduledAt).toISOString() }
+                    : {}),
+            },
+        };
+        // 1. Fetch the media bytes (the worker passes a public/rendered URL).
+        const mediaResp = await fetch(input.mediaUrl);
+        if (!mediaResp.ok) {
+            throw new Error(`YouTubePublisher: media fetch ${mediaResp.status} for ${input.mediaUrl}`);
+        }
+        const contentType = mediaResp.headers.get("content-type") ?? "video/mp4";
+        const bytes = Buffer.from(await mediaResp.arrayBuffer());
+        // 2. Init the resumable session.
+        const initResp = await fetch(RESUMABLE_INIT, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${input.accessToken}`,
+                "Content-Type": "application/json; charset=UTF-8",
+                "X-Upload-Content-Type": contentType,
+                "X-Upload-Content-Length": String(bytes.length),
+            },
+            body: JSON.stringify(metadata),
+        });
+        if (!initResp.ok) {
+            const text = await initResp.text();
+            throw new Error(`YouTubePublisher: resumable init ${initResp.status} ${text}`);
+        }
+        const uploadUrl = initResp.headers.get("location");
+        if (!uploadUrl) {
+            throw new Error("YouTubePublisher: no upload session URL returned");
+        }
+        // 3. Upload the bytes.
+        const uploadResp = await fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": contentType,
+                "Content-Length": String(bytes.length),
+            },
+            body: bytes,
+        });
+        const result = (await uploadResp.json());
+        if (!uploadResp.ok || !result.id) {
+            throw new Error(`YouTubePublisher: upload failed ${uploadResp.status} ${result.error?.message ?? ""}`);
+        }
+        logger_1.logger.info("YouTubePublisher: published", {
+            videoId: result.id,
+            scheduled: Boolean(input.scheduledAt),
+        });
+        return {
+            providerPostId: result.id,
+            publishedUrl: `https://www.youtube.com/watch?v=${result.id}`,
+        };
+    }
+    resolvePrivacy(input) {
+        // Native scheduling requires private until publishAt fires.
+        if (input.scheduledAt)
+            return "private";
+        const p = (input.privacy ?? "public").toLowerCase();
+        return ["public", "unlisted", "private"].includes(p) ? p : "public";
+    }
+    buildDescription(input) {
+        const tags = input.hashtags && input.hashtags.length
+            ? "\n\n" +
+                input.hashtags
+                    .map((h) => (h.startsWith("#") ? h : `#${h}`))
+                    .join(" ")
+            : "";
+        return `${input.caption ?? ""}${tags}`;
+    }
+}
+exports.YouTubePublisher = YouTubePublisher;

package/lib/services/stock/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./realPersonSafety";
+//# sourceMappingURL=index.d.ts.map

package/lib/services/stock/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/stock/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/lib/services/stock/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./realPersonSafety"), exports);

package/lib/services/stock/realPersonSafety.d.ts

@@ -0,0 +1,99 @@
+/**
+ * S-1 — real-person safety screening for the internal stock library.
+ *
+ * The stock catalog (S-1/S-2/S-3) may surface free-tier user output as public
+ * "made on VidSpot" / inspiration content. Per ToS we must NEVER surface a
+ * video whose prompt or input imagery involves a *real, identifiable person*
+ * (privacy / likeness exposure). This module is the safety gate the candidate
+ * scanner (and later the S-2 tagger) runs before a video is even eligible for
+ * human review.
+ *
+ * Two independent signals, both via Gemini Flash (cheap, ~$0.00002/image):
+ *   1. `detectRealPersonNamesInText` — LLM scan of all prompt/title/VO text for
+ *      proper names of real people (celebrities, politicians, public figures,
+ *      or a specific named private individual). Generic descriptors
+ *      ("a woman", "the CEO", "a doctor"), brand names, and clearly-fictional
+ *      character names are NOT flagged.
+ *   2. `detectRealPersonInImage` — vision pass over an input/reference/poster
+ *      image asking whether it shows a real *photographic* human person (an
+ *      actual individual's likeness) vs. an illustration / 3D-render / clearly
+ *      AI-generated synthetic face.
+ *
+ * Fail-safe posture: any check that errors is reported with `error` set and
+ * `incomplete: true` on the combined result — the caller treats "could not
+ * confirm safe" as NOT cleared (never silently passes a video through).
+ *
+ * Pure + side-effect-free apart from the network call to Gemini. No Firestore,
+ * no writes — see `scripts/scanStockCandidates.ts` for orchestration.
+ */
+export interface RealPersonSafetyConfig {
+    /** Gemini / Google AI Studio API key. */
+    apiKey: string;
+    /** Override the model. Defaults to gemini-2.5-flash. */
+    model?: string;
+    /** Per-call timeout. Defaults to 30s. */
+    timeoutMs?: number;
+}
+export interface NameScanResult {
+    /** True when at least one real, identifiable person's name appears. */
+    flagged: boolean;
+    /** The specific real-person names found (best-effort, may be empty). */
+    names: string[];
+    /** Short rationale from the model. */
+    reason: string;
+    /** Set when the scan could not run; caller treats this as not-cleared. */
+    error?: string;
+}
+export interface ImagePersonResult {
+    imageUrl: string;
+    /** True when the image shows a real photographic human (a real likeness). */
+    containsRealPerson: boolean;
+    /** Model confidence 0..1. */
+    confidence: number;
+    reason: string;
+    /** Set when the check could not run; caller treats this as not-cleared. */
+    error?: string;
+}
+export interface VideoSafetyInput {
+    /** All free-text associated with the video: prompt, originalPrompt, title, ttsText, per-scene prompts. */
+    texts: string[];
+    /** Candidate likeness images: input/reference images + poster still. */
+    imageUrls: string[];
+}
+export interface VideoSafetyResult {
+    /** True once at least one screening signal actually ran. */
+    checked: boolean;
+    nameScan?: NameScanResult;
+    imageScans: ImagePersonResult[];
+    /** Final verdict: a real, identifiable person is involved → must be dropped. */
+    involvesRealPerson: boolean;
+    /** True when some signal errored, so "safe" could not be fully confirmed. */
+    incomplete: boolean;
+    /** Human-readable reasons backing the verdict / incompleteness. */
+    reasons: string[];
+}
+/**
+ * Scan all of a video's free text for references to real, identifiable people.
+ * Returns `flagged:false` for empty input. On error returns `flagged:false`
+ * with `error` set — the caller must treat a set `error` as not-cleared.
+ */
+export declare function detectRealPersonNamesInText(texts: string[], config: RealPersonSafetyConfig): Promise<NameScanResult>;
+/**
+ * Vision pass: does this single image show a real, identifiable photographic
+ * person? On any fetch/model error returns `containsRealPerson:false` with
+ * `error` set — caller treats a set `error` as not-cleared.
+ */
+export declare function detectRealPersonInImage(imageUrl: string, config: RealPersonSafetyConfig): Promise<ImagePersonResult>;
+export interface ScreenOptions {
+    /** Cap how many images get a (paid) vision call. Defaults to 4. */
+    maxImages?: number;
+}
+/**
+ * Run the full real-person screen for one video: name scan + per-image vision.
+ *
+ * `involvesRealPerson` is the OR of every positive signal. `incomplete` is true
+ * when any signal errored — callers must require `checked && !involvesRealPerson
+ * && !incomplete` before treating a video as a cleared stock candidate.
+ */
+export declare function screenForRealPerson(input: VideoSafetyInput, config: RealPersonSafetyConfig, opts?: ScreenOptions): Promise<VideoSafetyResult>;
+//# sourceMappingURL=realPersonSafety.d.ts.map

package/lib/services/stock/realPersonSafety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPersonSafety.d.ts","sourceRoot":"","sources":["../../../src/services/stock/realPersonSafety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAQH,MAAM,WAAW,sBAAsB;IACrC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,kBAAkB,EAAE,OAAO,CAAC;IAC5B,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,0GAA0G;IAC1G,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,wEAAwE;IACxE,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,gFAAgF;IAChF,kBAAkB,EAAE,OAAO,CAAC;IAC5B,6EAA6E;IAC7E,UAAU,EAAE,OAAO,CAAC;IACpB,mEAAmE;IACnE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAuCD;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,cAAc,CAAC,CA6CzB;AA4BD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,iBAAiB,CAAC,CAyD5B;AAED,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,sBAAsB,EAC9B,IAAI,GAAE,aAAkB,GACvB,OAAO,CAAC,iBAAiB,CAAC,CA8C5B"}

package/lib/services/stock/realPersonSafety.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * S-1 — real-person safety screening for the internal stock library.
+ *
+ * The stock catalog (S-1/S-2/S-3) may surface free-tier user output as public
+ * "made on VidSpot" / inspiration content. Per ToS we must NEVER surface a
+ * video whose prompt or input imagery involves a *real, identifiable person*
+ * (privacy / likeness exposure). This module is the safety gate the candidate
+ * scanner (and later the S-2 tagger) runs before a video is even eligible for
+ * human review.
+ *
+ * Two independent signals, both via Gemini Flash (cheap, ~$0.00002/image):
+ *   1. `detectRealPersonNamesInText` — LLM scan of all prompt/title/VO text for
+ *      proper names of real people (celebrities, politicians, public figures,
+ *      or a specific named private individual). Generic descriptors
+ *      ("a woman", "the CEO", "a doctor"), brand names, and clearly-fictional
+ *      character names are NOT flagged.
+ *   2. `detectRealPersonInImage` — vision pass over an input/reference/poster
+ *      image asking whether it shows a real *photographic* human person (an
+ *      actual individual's likeness) vs. an illustration / 3D-render / clearly
+ *      AI-generated synthetic face.
+ *
+ * Fail-safe posture: any check that errors is reported with `error` set and
+ * `incomplete: true` on the combined result — the caller treats "could not
+ * confirm safe" as NOT cleared (never silently passes a video through).
+ *
+ * Pure + side-effect-free apart from the network call to Gemini. No Firestore,
+ * no writes — see `scripts/scanStockCandidates.ts` for orchestration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRealPersonNamesInText = detectRealPersonNamesInText;
+exports.detectRealPersonInImage = detectRealPersonInImage;
+exports.screenForRealPerson = screenForRealPerson;
+const genai_1 = require("@google/genai");
+const logger_1 = require("../../utils/logger");
+const DEFAULT_MODEL = "gemini-2.5-flash";
+const DEFAULT_TIMEOUT_MS = 30000;
+/** Strip ```json fences / prose and parse the first JSON object in a model reply. */
+function parseJsonLoose(raw) {
+    if (!raw)
+        return null;
+    const fenced = raw.replace(/```(?:json)?/gi, "").trim();
+    const start = fenced.indexOf("{");
+    const end = fenced.lastIndexOf("}");
+    if (start === -1 || end === -1 || end < start)
+        return null;
+    try {
+        return JSON.parse(fenced.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+}
+function newClient(config) {
+    return {
+        ai: new genai_1.GoogleGenAI({ apiKey: config.apiKey }),
+        model: config.model ?? DEFAULT_MODEL,
+        timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    };
+}
+const NAME_SCAN_PROMPT = [
+    "You are a content-safety classifier for a stock-video library.",
+    "Given the combined text written for a generated video, decide whether it references a REAL, IDENTIFIABLE PERSON.",
+    "Flag ONLY proper names of real people: celebrities, athletes, musicians, politicians, business figures,",
+    "other public figures, or a specific named private individual.",
+    "Do NOT flag: generic role/descriptor phrases (e.g. 'a woman', 'the CEO', 'a doctor', 'a young man'),",
+    "company/brand/product names, place names, or clearly fictional or generic character names.",
+    'Reply with STRICT JSON only, no prose: {"flagged": boolean, "names": string[], "reason": string}.',
+    "names = the exact real-person names you found (empty array if none).",
+].join(" ");
+/**
+ * Scan all of a video's free text for references to real, identifiable people.
+ * Returns `flagged:false` for empty input. On error returns `flagged:false`
+ * with `error` set — the caller must treat a set `error` as not-cleared.
+ */
+async function detectRealPersonNamesInText(texts, config) {
+    const joined = texts
+        .map((t) => (t ?? "").trim())
+        .filter(Boolean)
+        .join("\n---\n")
+        .slice(0, 12000);
+    if (!joined) {
+        return { flagged: false, names: [], reason: "no text to scan" };
+    }
+    const { ai, model, timeoutMs } = newClient(config);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await ai.models.generateContent({
+            model,
+            contents: [
+                {
+                    role: "user",
+                    parts: [{ text: `${NAME_SCAN_PROMPT}\n\nTEXT:\n${joined}` }],
+                },
+            ],
+            config: { abortSignal: controller.signal },
+        });
+        const parsed = parseJsonLoose(resp.text ?? "");
+        if (!parsed || typeof parsed.flagged !== "boolean") {
+            return {
+                flagged: false,
+                names: [],
+                reason: "unparseable model reply",
+                error: "parse_failed",
+            };
+        }
+        return {
+            flagged: parsed.flagged,
+            names: Array.isArray(parsed.names) ? parsed.names.filter(Boolean) : [],
+            reason: typeof parsed.reason === "string" ? parsed.reason : "",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.warn("detectRealPersonNamesInText: failed", { error: message });
+        return { flagged: false, names: [], reason: "scan failed", error: message };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+const IMAGE_SCAN_PROMPT = [
+    "You are a content-safety classifier for a stock-video library.",
+    "Decide whether this image shows a REAL, IDENTIFIABLE HUMAN PERSON — i.e. a genuine photograph of a real",
+    "individual whose likeness is recognizable (a real face).",
+    "Answer containsRealPerson=true ONLY for photographic real humans whose face is visible/identifiable.",
+    "Answer false for: illustrations, cartoons, 3D renders, clearly AI-generated or synthetic faces,",
+    "mannequins, statues, silhouettes, heavily-obscured faces, distant crowds with no identifiable face,",
+    "or images with no person at all.",
+    'Reply with STRICT JSON only, no prose: {"containsRealPerson": boolean, "confidence": number, "reason": string}.',
+    "confidence is 0..1.",
+].join(" ");
+function pickImageMimeType(contentType, url) {
+    if (contentType && contentType.startsWith("image/")) {
+        return contentType.split(";")[0].trim();
+    }
+    const lower = url.toLowerCase();
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    return "image/jpeg";
+}
+/**
+ * Vision pass: does this single image show a real, identifiable photographic
+ * person? On any fetch/model error returns `containsRealPerson:false` with
+ * `error` set — caller treats a set `error` as not-cleared.
+ */
+async function detectRealPersonInImage(imageUrl, config) {
+    const { ai, model, timeoutMs } = newClient(config);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const r = await fetch(imageUrl, { signal: controller.signal });
+        if (!r.ok)
+            throw new Error(`fetch ${r.status} ${r.statusText}`);
+        const bytes = Buffer.from(await r.arrayBuffer());
+        const mimeType = pickImageMimeType(r.headers.get("content-type"), imageUrl);
+        const resp = await ai.models.generateContent({
+            model,
+            contents: [
+                {
+                    role: "user",
+                    parts: [
+                        { text: IMAGE_SCAN_PROMPT },
+                        { inlineData: { mimeType, data: bytes.toString("base64") } },
+                    ],
+                },
+            ],
+            config: { abortSignal: controller.signal },
+        });
+        const parsed = parseJsonLoose(resp.text ?? "");
+        if (!parsed || typeof parsed.containsRealPerson !== "boolean") {
+            return {
+                imageUrl,
+                containsRealPerson: false,
+                confidence: 0,
+                reason: "unparseable model reply",
+                error: "parse_failed",
+            };
+        }
+        return {
+            imageUrl,
+            containsRealPerson: parsed.containsRealPerson,
+            confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0,
+            reason: typeof parsed.reason === "string" ? parsed.reason : "",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.warn("detectRealPersonInImage: failed", { imageUrl, error: message });
+        return {
+            imageUrl,
+            containsRealPerson: false,
+            confidence: 0,
+            reason: "image check failed",
+            error: message,
+        };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+/**
+ * Run the full real-person screen for one video: name scan + per-image vision.
+ *
+ * `involvesRealPerson` is the OR of every positive signal. `incomplete` is true
+ * when any signal errored — callers must require `checked && !involvesRealPerson
+ * && !incomplete` before treating a video as a cleared stock candidate.
+ */
+async function screenForRealPerson(input, config, opts = {}) {
+    const maxImages = opts.maxImages ?? 4;
+    const images = Array.from(new Set(input.imageUrls.filter(Boolean))).slice(0, maxImages);
+    const [nameScan, imageScans] = await Promise.all([
+        detectRealPersonNamesInText(input.texts, config),
+        Promise.all(images.map((url) => detectRealPersonInImage(url, config))),
+    ]);
+    const reasons = [];
+    if (nameScan.flagged) {
+        reasons.push(`prompt references real person(s): ${nameScan.names.join(", ") || nameScan.reason}`);
+    }
+    for (const scan of imageScans) {
+        if (scan.containsRealPerson) {
+            reasons.push(`image shows a real person (${scan.confidence.toFixed(2)}): ${scan.imageUrl}`);
+        }
+    }
+    const incomplete = Boolean(nameScan.error) || imageScans.some((s) => Boolean(s.error));
+    if (incomplete) {
+        if (nameScan.error)
+            reasons.push(`name scan incomplete: ${nameScan.error}`);
+        for (const scan of imageScans) {
+            if (scan.error)
+                reasons.push(`image check incomplete: ${scan.imageUrl}`);
+        }
+    }
+    const involvesRealPerson = nameScan.flagged || imageScans.some((s) => s.containsRealPerson);
+    return {
+        checked: true,
+        nameScan,
+        imageScans,
+        involvesRealPerson,
+        incomplete,
+        reasons,
+    };
+}

package/lib/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./errors";
 export * from "./helpers";
 export * from "./logger";
+export * from "./renderTier";
 export * from "./ttsUtils";
 //# sourceMappingURL=index.d.ts.map

package/lib/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/lib/utils/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errors"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./renderTier"), exports);
 __exportStar(require("./ttsUtils"), exports);

package/lib/utils/renderTier.d.ts

@@ -0,0 +1,26 @@
+import type { IUserSubscription } from "../models/user.model";
+/**
+ * Whether a finished render carries the free-tier VidSpot watermark (W-1).
+ *
+ * Deliberately distinct from the model-quality `Tier` ("T0".."T3") used for
+ * cost estimation — this is purely a monetization/IP flag: free renders get a
+ * watermark, paid renders don't.
+ */
+export type RenderTier = "free" | "paid";
+/**
+ * True only when the user holds an *active paid* subscription. The FREE plan,
+ * a missing subscription, and trial / canceled / expired / inactive paid subs
+ * all count as not-paid — their output is watermarked.
+ *
+ * Erring toward watermark is the safe default for IP protection: a brief
+ * status blip (e.g. webhook lag) watermarks one render rather than leaking an
+ * unwatermarked one to a non-paying account.
+ *
+ * NOTE: trials are watermarked by design (W-1: "free credits / free-trial →
+ * watermark"). To make trials unwatermarked instead, add
+ * `ESUBSCRIPTION_STATUS.TRIAL` to the accepted-status check below.
+ */
+export declare function isPaidSubscription(subscription: IUserSubscription | undefined | null): boolean;
+/** Resolve the render tier (watermark flag) for a user's subscription. */
+export declare function resolveRenderTier(subscription: IUserSubscription | undefined | null): RenderTier;
+//# sourceMappingURL=renderTier.d.ts.map

package/lib/utils/renderTier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderTier.d.ts","sourceRoot":"","sources":["../../src/utils/renderTier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAQzC;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,GACjD,OAAO,CAIT;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,GACjD,UAAU,CAEZ"}

package/lib/utils/renderTier.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPaidSubscription = isPaidSubscription;
+exports.resolveRenderTier = resolveRenderTier;
+const types_1 = require("../globals/types");
+const PAID_PLANS = new Set([
+    types_1.ESUBSCRIPTION_PLANS.BASIC,
+    types_1.ESUBSCRIPTION_PLANS.PRO,
+    types_1.ESUBSCRIPTION_PLANS.BUSINESS,
+]);
+/**
+ * True only when the user holds an *active paid* subscription. The FREE plan,
+ * a missing subscription, and trial / canceled / expired / inactive paid subs
+ * all count as not-paid — their output is watermarked.
+ *
+ * Erring toward watermark is the safe default for IP protection: a brief
+ * status blip (e.g. webhook lag) watermarks one render rather than leaking an
+ * unwatermarked one to a non-paying account.
+ *
+ * NOTE: trials are watermarked by design (W-1: "free credits / free-trial →
+ * watermark"). To make trials unwatermarked instead, add
+ * `ESUBSCRIPTION_STATUS.TRIAL` to the accepted-status check below.
+ */
+function isPaidSubscription(subscription) {
+    if (!subscription?.planType)
+        return false;
+    if (!PAID_PLANS.has(subscription.planType))
+        return false;
+    return subscription.status === types_1.ESUBSCRIPTION_STATUS.ACTIVE;
+}
+/** Resolve the render tier (watermark flag) for a user's subscription. */
+function resolveRenderTier(subscription) {
+    return isPaidSubscription(subscription) ? "paid" : "free";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidspotai-shared",
-  "version": "1.0.82",
+  "version": "1.0.83",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "exports": {