@mevdragon/vidfarm-devcli 0.5.3 → 0.6.0

package/dist/src/config.js

@@ -0,0 +1,166 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { z } from "zod";
+dotenv.config();
+function normalizeEnvValue(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    const unquoted = ((trimmed.startsWith("\"") && trimmed.endsWith("\""))
+        || (trimmed.startsWith("'") && trimmed.endsWith("'")))
+        ? trimmed.slice(1, -1).trim()
+        : trimmed;
+    return unquoted === "" ? undefined : unquoted;
+}
+const optionalSampleRate = z.preprocess((value) => value === "" || value == null ? undefined : value, z.coerce.number().min(0).max(1).optional());
+const schema = z.object({
+    NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+    VIDFARM_DEPLOYMENT_TARGET: z.string().optional(),
+    VIDFARM_RUNTIME_BACKEND: z.literal("serverless").default("serverless"),
+    VIDFARM_DEBUG_LOGS: z.string().default("false"),
+    VIDFARM_LOAD_LOCAL_TEMPLATES: z.enum(["auto", "true", "false"]).default("auto"),
+    PORT: z.coerce.number().default(3000),
+    VIDFARM_DATA_DIR: z.string().default("./data"),
+    ENCRYPTION_SECRET: z.string().default("development-encryption-secret-change-me"),
+    API_KEY_SALT: z.string().default("development-api-key-salt"),
+    WEBHOOK_SECRET: z.string().default("development-webhook-secret"),
+    DEFAULT_JOB_DELAY_SECONDS: z.coerce.number().default(20),
+    MAX_JOB_WALL_CLOCK_SECONDS: z.coerce.number().default(6 * 60 * 60),
+    STALE_RUNNING_JOB_SECONDS: z.coerce.number().default(60 * 60),
+    PROVIDER_LEASE_WAIT_TIMEOUT_SECONDS: z.coerce.number().default(5 * 60),
+    PROVIDER_LEASE_INLINE_WAIT_SECONDS: z.coerce.number().default(5),
+    PROVIDER_LEASE_STEP_WAIT_SECONDS: z.coerce.number().int().min(1).default(60),
+    PROVIDER_LEASE_MAX_STEP_WAIT_SECONDS: z.coerce.number().int().min(1).default(12 * 60 * 60),
+    MAX_ACTIVE_JOBS_PER_CUSTOMER: z.coerce.number().int().min(1).default(30),
+    STORAGE_DRIVER: z.enum(["local", "s3"]).default("local"),
+    // Records/auth backend. Defaults to `dynamo` so deployed environments are
+    // unaffected; `vidfarm serve` sets this to `local` to run fully on disk.
+    RECORDS_DRIVER: z.enum(["local", "dynamo"]).default("dynamo"),
+    AWS_REGION: z.string().default("us-east-1"),
+    AWS_S3_BUCKET: z.string().default(""),
+    AWS_S3_ENDPOINT: z.string().optional(),
+    AWS_ACCESS_KEY_ID: z.string().optional(),
+    AWS_SECRET_ACCESS_KEY: z.string().optional(),
+    PUBLIC_BASE_URL: z.string().optional(),
+    PUBLIC_EDITOR_CHAT_URL: z.string().url().optional(),
+    VIDFARM_USER_ID: z.string().optional(),
+    VIDFARM_API_KEY: z.string().optional(),
+    VIDFARM_STAGING_BOOTSTRAP_USER_ID: z.string().optional(),
+    VIDFARM_STAGING_BOOTSTRAP_EMAIL: z.string().optional(),
+    VIDFARM_STAGING_BOOTSTRAP_API_KEY: z.string().optional(),
+    EDITOR_CHAT_URL: z.string().url().optional(),
+    RESEND_API_KEY: z.string().optional(),
+    RESEND_FROM_EMAIL: z.string().default("vidfarm@fwd.zoomgtm.com"),
+    FLOCKPOSTER_API_URL: z.string().url().optional(),
+    VIDFARM_ZIP_LAMBDA_URL: z.string().url().optional(),
+    VIDFARM_ZIP_LAMBDA_SECRET: z.string().optional(),
+    VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL: z.string().url().optional(),
+    VIDFARM_PRIMITIVE_MEDIA_LAMBDA_SECRET: z.string().optional(),
+    VIDFARM_BILLING_URL: z.string().url().optional(),
+    VIDFARM_BILLING_SECRET: z.string().optional(),
+    VIDFARM_MIN_RENDER_WALLET_BALANCE_USD: z.coerce.number().default(1),
+    OPENAI_API_KEY: z.string().optional(),
+    OPENROUTER_API_KEY: z.string().optional(),
+    GEMINI_API_KEY: z.string().optional(),
+    PERPLEXITY_API_KEY: z.string().optional(),
+    GHOSTCUT_KEY: z.string().optional(),
+    GHOSTCUT_SECRET: z.string().optional(),
+    GHOSTCUT_USD_PER_30S: z.coerce.number().min(0).default(0.10),
+    RAPIDAPI_KEY: z.string().optional(),
+    RAPIDAPI_VIDEO_DOWNLOAD_URL: z.string().url().default("https://snap-video3.p.rapidapi.com/download"),
+    RAPIDAPI_VIDEO_DOWNLOAD_HOST: z.string().default("snap-video3.p.rapidapi.com"),
+    RAPIDAPI_VIDEO_DOWNLOAD_BASE_COST_USD: z.coerce.number().min(0).default(0.005),
+    RAPIDAPI_VIDEO_DOWNLOAD_LAMBDA_COST_USD: z.coerce.number().min(0).default(0.0002),
+    RAPIDAPI_REMOVE_BACKGROUND_URL: z.string().url().default("https://remove-background18.p.rapidapi.com/public/remove-background/url"),
+    RAPIDAPI_REMOVE_BACKGROUND_HOST: z.string().default("remove-background18.p.rapidapi.com"),
+    RAPIDAPI_REMOVE_BACKGROUND_COST_USD: z.coerce.number().min(0).default(0.005),
+    SUPERAGENCY_KEY: z.string().optional(),
+    ARTIFACT_SIGNING_SECRET: z.string().optional(),
+    HYPERFRAMES_LAMBDA_STACK_NAME: z.string().default("hyperframes-vidfarm-prod"),
+    HYPERFRAMES_RENDER_REGION: z.string().optional(),
+    HYPERFRAMES_RENDER_BUCKET_NAME: z.string().optional(),
+    HYPERFRAMES_LAMBDA_BUCKET_NAME: z.string().optional(),
+    HYPERFRAMES_RENDER_STATE_MACHINE_ARN: z.string().optional(),
+    HYPERFRAMES_STATE_MACHINE_ARN: z.string().optional(),
+    HYPERFRAMES_RENDER_MEMORY_MB: z.coerce.number().int().min(512).default(3072),
+    // Force the in-process (single-machine, headless-Chromium) HyperFrames
+    // renderer even when a cloud render stack is configured. When unset, the
+    // renderer auto-selects local whenever no cloud render stack is wired (the
+    // `vidfarm serve` case). Accepts "1"/"true"/"yes".
+    VIDFARM_LOCAL_RENDER: z
+        .string()
+        .optional()
+        .transform((value) => /^(1|true|yes)$/i.test(String(value ?? ""))),
+    MOCK_PROVIDER_RESPONSES: z.string().optional(),
+    VIDFARM_ADMIN_EMAILS: z.string().default(""),
+    VIDFARM_GITHUB_TOKEN: z.string().optional(),
+    GITHUB_TOKEN: z.string().optional(),
+    TEMPLATE_SOURCE_ROOT: z.string().default("./data/template-sources"),
+    VIDFARM_RATE_LIMITS_TABLE_NAME: z.string().optional(),
+    VIDFARM_SERVERLESS_MAIN_TABLE_NAME: z.string().optional(),
+    VIDFARM_JOB_STATE_MACHINE_ARN: z.string().optional(),
+    SENTRY_DSN: z.string().optional(),
+    SENTRY_ENVIRONMENT: z.string().optional(),
+    SENTRY_RELEASE: z.string().optional(),
+    SENTRY_TRACES_SAMPLE_RATE: optionalSampleRate,
+    SENTRY_ENABLE_LOGS: z.string().default("true"),
+    SENTRY_SEND_DEFAULT_PII: z.string().default("false"),
+    SENTRY_DEBUG_ROUTE: z.string().default("false"),
+    PUBLIC_SENTRY_DSN: z.string().optional(),
+    PUBLIC_SENTRY_TRACES_SAMPLE_RATE: optionalSampleRate,
+    PUBLIC_SENTRY_REPLAYS_SESSION_SAMPLE_RATE: optionalSampleRate,
+    PUBLIC_SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE: optionalSampleRate,
+    PUBLIC_SENTRY_ENABLE_LOGS: z.string().default("true"),
+    PUBLIC_SENTRY_SEND_DEFAULT_PII: z.string().default("true"),
+    PUBLIC_SENTRY_TRACE_PROPAGATION_TARGETS: z.string().default("")
+}).superRefine((data, ctx) => {
+    if (data.NODE_ENV === "production" && data.VIDFARM_RUNTIME_BACKEND === "serverless") {
+        if (!data.VIDFARM_SERVERLESS_MAIN_TABLE_NAME) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["VIDFARM_SERVERLESS_MAIN_TABLE_NAME"],
+                message: "VIDFARM_SERVERLESS_MAIN_TABLE_NAME is required when VIDFARM_RUNTIME_BACKEND=serverless in production"
+            });
+        }
+        if (!data.VIDFARM_RATE_LIMITS_TABLE_NAME) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["VIDFARM_RATE_LIMITS_TABLE_NAME"],
+                message: "VIDFARM_RATE_LIMITS_TABLE_NAME is required when VIDFARM_RUNTIME_BACKEND=serverless in production"
+            });
+        }
+        if (!data.VIDFARM_JOB_STATE_MACHINE_ARN) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["VIDFARM_JOB_STATE_MACHINE_ARN"],
+                message: "VIDFARM_JOB_STATE_MACHINE_ARN is required when VIDFARM_RUNTIME_BACKEND=serverless in production"
+            });
+        }
+    }
+});
+const normalizedEnv = Object.fromEntries(Object.entries(process.env).map(([key, value]) => [key, normalizeEnvValue(value)]));
+const parsed = schema.parse(normalizedEnv);
+const dataDir = path.resolve(parsed.VIDFARM_DATA_DIR);
+mkdirSync(dataDir, { recursive: true });
+const templateSourceRoot = path.resolve(parsed.TEMPLATE_SOURCE_ROOT);
+mkdirSync(templateSourceRoot, { recursive: true });
+const publicBaseUrl = parsed.PUBLIC_BASE_URL || `http://localhost:${parsed.PORT}`;
+export const config = {
+    ...parsed,
+    VIDFARM_DATA_DIR: dataDir,
+    TEMPLATE_SOURCE_ROOT: templateSourceRoot,
+    PUBLIC_BASE_URL: publicBaseUrl,
+    ARTIFACT_SIGNING_SECRET: parsed.ARTIFACT_SIGNING_SECRET || parsed.SUPERAGENCY_KEY || "",
+    isProduction: parsed.NODE_ENV === "production",
+    mockProviders: parsed.MOCK_PROVIDER_RESPONSES === "true" ||
+        (parsed.MOCK_PROVIDER_RESPONSES == null && parsed.NODE_ENV !== "production"),
+    minRenderWalletBalanceUsd: parsed.VIDFARM_MIN_RENDER_WALLET_BALANCE_USD,
+    debugLogs: parsed.VIDFARM_DEBUG_LOGS === "true" || parsed.VIDFARM_DEPLOYMENT_TARGET === "serverless-staging",
+    adminEmails: parsed.VIDFARM_ADMIN_EMAILS
+        .split(",")
+        .map((value) => value.trim().toLowerCase())
+        .filter(Boolean),
+};
+//# sourceMappingURL=config.js.map

package/dist/src/context.js

@@ -0,0 +1,447 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import * as Sentry from "@sentry/node";
+import { config } from "./config.js";
+import { devErrorFields, devLog } from "./lib/dev-log.js";
+import { createId } from "./lib/ids.js";
+import { estimateNormalizationCostUsd, normalizeVideoAsset } from "./services/video-normalization.js";
+export function createTemplateJobContext(input) {
+    const templateConfig = {};
+    const prefix = input.storage.templateJobPrefix(input.template.id, input.customer.id, input.job.id);
+    const buildArtifactUrl = (storageKey, fallbackUrl) => fallbackUrl ?? input.storage.getPublicUrl(storageKey) ?? buildTemplateMediaUrl(storageKey);
+    const templatePreviewMediaUrls = resolveTemplatePreviewMediaUrls(input.template, input.storage);
+    const jobPreviewMediaPolicy = parseTemplatePreviewMediaPolicy(input.job.payload._templatePreviewMediaPolicy);
+    // Billing records are written after the billable work (render, normalize,
+    // etc.) has already succeeded. A transient billing failure must never fail
+    // the job — the customer would retry and pay for the expensive work twice.
+    const recordBillingNonFatal = async (record) => {
+        try {
+            await input.billing.record(record);
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            devLog("billing.record_failed_nonfatal", {
+                job_id: input.job.id,
+                customer_id: input.customer.id,
+                template_id: input.template.id,
+                cost_center_slug: record.costCenterSlug ?? null,
+                idempotency_key: record.idempotencyKey ?? null,
+                ...devErrorFields(error)
+            }, "warn");
+        }
+    };
+    return {
+        env: config.isProduction ? "production" : "development",
+        customer: input.customer,
+        template: {
+            id: input.template.id,
+            slugId: input.template.slugId,
+            previewMediaUrls: templatePreviewMediaUrls,
+            previewMediaPolicy: jobPreviewMediaPolicy
+        },
+        templateConfig,
+        logger: {
+            debug(message, metadata = {}) {
+                void input.jobs.addLogEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "debug",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null,
+                    createdAt: new Date().toISOString()
+                });
+            },
+            info(message, metadata = {}) {
+                void input.jobs.addLogEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "info",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null,
+                    createdAt: new Date().toISOString()
+                });
+            },
+            warn(message, metadata = {}) {
+                void input.jobs.addLogEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "warn",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null,
+                    createdAt: new Date().toISOString()
+                });
+            },
+            error(message, metadata = {}) {
+                void input.jobs.addLogEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "error",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null,
+                    createdAt: new Date().toISOString()
+                });
+            },
+            progress(progress, message, metadata = {}) {
+                void input.jobs.addLogEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "info",
+                    message,
+                    metadata,
+                    progress,
+                    artifactKey: typeof metadata.artifactKey === "string" ? metadata.artifactKey : null,
+                    createdAt: new Date().toISOString()
+                });
+                void input.jobs.updateJobStatus({
+                    id: input.job.id,
+                    status: "running",
+                    progress
+                });
+            }
+        },
+        jobs: {
+            async enqueueChild({ operationName, workflowName, payload, providerHint }) {
+                const child = await input.jobs.enqueueChildJob({
+                    templateId: input.template.id,
+                    operationName,
+                    workflowName,
+                    tracer: input.job.tracer,
+                    payload,
+                    customerId: input.customer.id,
+                    parentJobId: input.job.id,
+                    providerHint
+                });
+                return { jobId: child.id };
+            }
+        },
+        storage: {
+            async putJson(key, value) {
+                const stored = await input.storage.putJson(`${prefix}/${key}`, value);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact("json", stored.key, artifactUrl, {});
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
+            },
+            async putText(key, value, contentType = "text/plain; charset=utf-8") {
+                const stored = await input.storage.putText(`${prefix}/${key}`, value, contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact("text", stored.key, artifactUrl, { contentType });
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
+            },
+            async putBuffer(key, value, options = {}) {
+                const stored = await input.storage.putBuffer(`${prefix}/${key}`, value, options.contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact(options.kind ?? "binary", stored.key, artifactUrl, {
+                    ...(options.metadata ?? {}),
+                    contentType: options.contentType ?? null
+                });
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
+            },
+            getPublicUrl(key) {
+                const storageKey = `${prefix}/${key}`;
+                return input.storage.getPublicUrl(storageKey) ?? buildTemplateMediaUrl(storageKey);
+            }
+        },
+        billing: {
+            async record(record) {
+                await recordBillingNonFatal({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    tracer: input.job.tracer,
+                    templateId: input.template.id,
+                    type: record.type,
+                    costUsd: record.costUsd,
+                    chargeUsd: record.chargeUsd ?? Number((record.costUsd * 1.2).toFixed(4)),
+                    costCenterSlug: record.costCenterSlug,
+                    idempotencyKey: record.idempotencyKey,
+                    occurredAtMs: record.occurredAtMs,
+                    metadata: record.metadata
+                });
+            }
+        },
+        providers: {
+            listAvailableProviders() {
+                return input.providers.listAvailableProviders(input.customer.id);
+            },
+            async generateText(request) {
+                return input.providers.generateText({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async generateSpeech(request) {
+                return input.providers.generateSpeech({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async generateImage(request) {
+                return input.providers.generateImage({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async analyzeImageLayout(request) {
+                return input.providers.analyzeImageLayout({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async transcribeSpeech(request) {
+                return input.providers.transcribeSpeech({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            }
+        },
+        hyperframes: {
+            async render(request) {
+                const hyperframesOutputKey = `renders/vidfarm/templates/${input.template.id}/${input.customer.id}/${input.job.id}/output.mp4`;
+                const render = await input.hyperframes.render({
+                    ...request,
+                    outputKey: hyperframesOutputKey,
+                    wait: true
+                });
+                let outputUrl = render.outputUrl;
+                let platformOutputKey = null;
+                if (render.outputS3Uri) {
+                    const output = await input.hyperframes.readRenderOutput(render.outputS3Uri);
+                    platformOutputKey = `${prefix}/${request.outputKey || "renders/output.mp4"}`;
+                    const stored = await input.storage.putBuffer(platformOutputKey, output.bytes, output.contentType);
+                    outputUrl = buildArtifactUrl(stored.key, stored.url);
+                    await insertArtifact("video", stored.key, outputUrl, {
+                        operation: "hyperframes-render",
+                        contentType: output.contentType,
+                        renderId: render.renderId,
+                        outputS3Uri: render.outputS3Uri
+                    });
+                }
+                const estimatedCostUsd = typeof render.metadata.estimatedCostUsd === "number" ? render.metadata.estimatedCostUsd : null;
+                const chargeUsd = typeof render.metadata.chargeUsd === "number" ? render.metadata.chargeUsd : null;
+                if (estimatedCostUsd !== null && estimatedCostUsd > 0) {
+                    await recordBillingNonFatal({
+                        customerId: input.customer.id,
+                        jobId: input.job.id,
+                        tracer: input.job.tracer,
+                        templateId: input.template.id,
+                        type: "render",
+                        costUsd: estimatedCostUsd,
+                        chargeUsd: typeof chargeUsd === "number" ? chargeUsd : undefined,
+                        costCenterSlug: "hyperframes_lambda",
+                        idempotencyKey: `hyperframes_lambda:${render.renderId}`,
+                        occurredAtMs: Date.now(),
+                        metadata: {
+                            ...render.metadata,
+                            render_id: render.renderId,
+                            output_url: outputUrl,
+                            signed_output_url: render.outputUrl,
+                            output_s3_uri: render.outputS3Uri,
+                            platform_output_key: platformOutputKey
+                        }
+                    });
+                }
+                return {
+                    renderId: render.renderId,
+                    outputUrl,
+                    outputS3Uri: render.outputS3Uri,
+                    metadata: {
+                        ...render.metadata,
+                        outputUrl,
+                        signedOutputUrl: render.outputUrl,
+                        platformOutputKey
+                    }
+                };
+            }
+        },
+        media: {
+            async normalizeVideo(request) {
+                const normalized = await normalizeVideoAsset({
+                    sourceUrl: request.sourceUrl,
+                    maxWidth: request.maxWidth,
+                    maxHeight: request.maxHeight,
+                    crf: request.crf,
+                    preset: request.preset,
+                    maxVideoBitrateKbps: request.maxVideoBitrateKbps,
+                    audioBitrateKbps: request.audioBitrateKbps
+                });
+                const stored = await input.storage.putBuffer(`${prefix}/${request.outputKey}`, normalized.bytes, normalized.contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact("video", stored.key, artifactUrl, {
+                    ...(request.metadata ?? {}),
+                    operation: "normalize-video",
+                    contentType: normalized.contentType,
+                    normalization: normalized.metadata
+                });
+                await recordBillingNonFatal({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    tracer: input.job.tracer,
+                    templateId: input.template.id,
+                    type: "cpu_estimate",
+                    costUsd: estimateNormalizationCostUsd(normalized.metadata),
+                    costCenterSlug: "video_normalization",
+                    idempotencyKey: `video_normalization:${input.job.id}:${request.outputKey}`,
+                    occurredAtMs: Date.now(),
+                    metadata: {
+                        ...(request.metadata ?? {}),
+                        operation: "normalize-video",
+                        source_url: request.sourceUrl,
+                        output_key: `${prefix}/${request.outputKey}`,
+                        normalization: normalized.metadata
+                    }
+                });
+                return {
+                    ...stored,
+                    url: artifactUrl,
+                    contentType: normalized.contentType,
+                    normalization: normalized.metadata
+                };
+            }
+        }
+    };
+    async function insertArtifact(kind, storageKey, publicUrl, metadata) {
+        await input.jobs.insertArtifact({
+            id: createId("art"),
+            jobId: input.job.id,
+            customerId: input.customer.id,
+            templateId: input.template.id,
+            kind,
+            storageKey,
+            publicUrl,
+            metadata
+        });
+    }
+}
+function parseTemplatePreviewMediaPolicy(value) {
+    if (value === "include" || value === "exclude" || value === "auto") {
+        return value;
+    }
+    if (value === true) {
+        return "include";
+    }
+    if (value === false) {
+        return "exclude";
+    }
+    return "auto";
+}
+function resolveTemplatePreviewMediaUrls(template, storage) {
+    return uniqueStrings(template.about.preview_media
+        .filter(isImagePreviewReference)
+        .map((entry) => resolveTemplatePreviewMediaUrl(template, storage, entry))
+        .filter((entry) => Boolean(entry)));
+}
+function resolveTemplatePreviewMediaUrl(template, storage, entry) {
+    if (/^https?:\/\//i.test(entry)) {
+        return entry;
+    }
+    const normalizedEntry = entry.replace(/^\/+/, "");
+    if (normalizedEntry.startsWith("templates/")) {
+        return resolveBundledTemplateAssetFromStorageKey(template, normalizedEntry)
+            ? buildTemplateMediaUrl(normalizedEntry)
+            : storage.getPublicUrl(normalizedEntry) ?? buildTemplateMediaUrl(normalizedEntry);
+    }
+    const templateAboutPrefix = storage.templateAboutKey(template.id, "");
+    const storageAssetPath = normalizedEntry.startsWith(templateAboutPrefix)
+        ? normalizedEntry.slice(templateAboutPrefix.length)
+        : normalizedEntry.startsWith("about/")
+            ? normalizedEntry.slice("about/".length)
+            : normalizedEntry;
+    const storageKey = storage.templateAboutKey(template.id, storageAssetPath);
+    return resolveBundledTemplateAsset(template, storageAssetPath)
+        ? buildTemplateMediaUrl(storageKey)
+        : storage.getPublicUrl(storageKey) ?? buildTemplateMediaUrl(storageKey);
+}
+function isImagePreviewReference(entry) {
+    return /\.(png|jpe?g|webp)(?:$|[?#])/i.test(entry);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+function buildTemplateMediaUrl(storageKey) {
+    return `${config.PUBLIC_BASE_URL.replace(/\/$/, "")}/template-media?key=${encodeURIComponent(storageKey)}`;
+}
+function resolveBundledTemplateAssetFromStorageKey(template, storageKey) {
+    const match = /^templates\/([^/]+)\/about\/(.+)$/.exec(storageKey.replace(/^\/+/, ""));
+    if (!match || match[1] !== template.id) {
+        return null;
+    }
+    return resolveBundledTemplateAsset(template, match[2]);
+}
+function resolveBundledTemplateAsset(template, assetPath) {
+    if (!template.skillPath || !assetPath) {
+        return null;
+    }
+    const normalizedAssetPath = assetPath.replace(/^\/+/, "");
+    if (!normalizedAssetPath || normalizedAssetPath.includes("\\") || normalizedAssetPath.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+        return null;
+    }
+    let templateRoot = path.resolve(template.skillPath);
+    try {
+        if (existsSync(templateRoot) && !statSync(templateRoot).isDirectory()) {
+            templateRoot = path.dirname(templateRoot);
+        }
+    }
+    catch {
+        return null;
+    }
+    const candidates = normalizedAssetPath.startsWith("about/")
+        ? [normalizedAssetPath]
+        : [`about/${normalizedAssetPath}`, normalizedAssetPath];
+    for (const candidate of candidates) {
+        const resolved = path.resolve(templateRoot, candidate);
+        if ((resolved === templateRoot || resolved.startsWith(`${templateRoot}${path.sep}`)) && existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function findTemplateRoot(modulePath) {
+    let current = path.dirname(modulePath);
+    for (let index = 0; index < 10; index += 1) {
+        if (existsSync(path.join(current, "template.config.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function nonBlank(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizePositiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : undefined;
+}
+//# sourceMappingURL=context.js.map