@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

package/dist/src/config.js

@@ -1,217 +0,0 @@
-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),
-    RENDER_POLL_WAIT_SECONDS: z.coerce.number().int().min(1).default(20),
-    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(),
-    // Platform ElevenLabs key — the fallback used for music / TTS / STT primitives
-    // when the caller opts into `use_wallet_credits` (the default) or has no usable
-    // BYOK audio key. Usage on this key is billed to the customer's vidfarm wallet.
-    ELEVENLABS_API_KEY: z.string().optional(),
-    // Base provider costs for ElevenLabs primitives billed to the wallet (the
-    // billing lambda applies the standard markup on top). Defaults track published
-    // ElevenLabs list pricing: TTS multilingual v2/v3 $0.10 / 1K chars (flash/turbo
-    // is $0.05), Music $0.15 / minute, Scribe STT $0.22 / hour ≈ $0.003667 / min.
-    // Override per-environment as pricing shifts.
-    ELEVENLABS_MUSIC_USD_PER_MIN: z.coerce.number().min(0).default(0.15),
-    ELEVENLABS_TTS_USD_PER_1K_CHARS: z.coerce.number().min(0).default(0.10),
-    ELEVENLABS_STT_USD_PER_MIN: z.coerce.number().min(0).default(0.003667),
-    GHOSTCUT_KEY: z.string().optional(),
-    GHOSTCUT_SECRET: z.string().optional(),
-    GHOSTCUT_USD_PER_30S: z.coerce.number().min(0).default(0.10),
-    // GhostCut caption removal is for SHORT clips, never long-form sources —
-    // clip hunting must select text-free scenes instead of laundering a whole
-    // long video through GhostCut. 15 min default ceiling (per-30s pricing makes
-    // long-form runs absurd anyway).
-    GHOSTCUT_MAX_DURATION_SEC: z.coerce.number().min(0).default(900),
-    // Auto-decompose kicks off GhostCut subtitle removal on the source video, but
-    // GhostCut prices per-30s chunk and is meant for short clips. Skip it entirely
-    // when the decompose source is longer than this — the composition just keeps
-    // the original burned-in captions rather than paying to launder a multi-minute
-    // video. 0 = never skip on length. Distinct from GHOSTCUT_MAX_DURATION_SEC
-    // (the standalone remove-captions primitive's hard ceiling).
-    GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC: z.coerce.number().min(0).default(180),
-    // Inspiration ingest + auto-decompose used to hard-cap sources at 120s (a
-    // short-form-only assumption). Longer inspiration is now allowed. 0 = unlimited;
-    // set a positive ceiling to re-impose a limit. Kept separate from
-    // MAX_PROBE_DURATION_SECONDS (the per-primitive probe cost-guard) so raising the
-    // inspiration ceiling never loosens the generic probe default.
-    INSPIRATION_MAX_DURATION_SEC: z.coerce.number().min(0).default(0),
-    // Cloud passthrough for `vidfarm serve`: the local box keeps editing/render
-    // fully local but lists the upstream (prod) catalog in /discover and
-    // /library, seeds forks on demand, and can hand a render off to the cloud.
-    // Set by the serve command from --host + the ambient cloud VIDFARM_API_KEY;
-    // never set on deployed environments.
-    VIDFARM_UPSTREAM_HOST: z.string().optional(),
-    VIDFARM_UPSTREAM_API_KEY: z.string().optional(),
-    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),
-    // Local sharp chroma-key background removal (no third-party API) — a small
-    // compute/convenience wallet fee, far cheaper than the RapidAPI matting above.
-    GREENSCREEN_CHROMA_KEY_COST_USD: z.coerce.number().min(0).default(0.002),
-    // Two-step "create media overlay": BYOK AI image gen (provider cost rides the
-    // caller's own key) + local chroma key. This fee bills only the platform
-    // convenience/compute leg of the combined primitive.
-    MEDIA_OVERLAY_COST_USD: z.coerce.number().min(0).default(0.008),
-    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(),
-    // Clip-curation scan pipeline (Step Functions). Optional: when unset, the
-    // /clips/scan route records the scan request but doesn't dispatch the machine.
-    VIDFARM_CLIP_SCAN_STATE_MACHINE_ARN: z.string().optional(),
-    VIDFARM_CLIP_VECTOR_BACKEND: z.enum(["dynamo", "s3vectors"]).default("dynamo"),
-    VIDFARM_CLIP_VECTORS_BUCKET: z.string().optional(),
-    VIDFARM_CLIP_VECTORS_INDEX: 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

@@ -1,447 +0,0 @@
-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