cli-meta-ads 0.1.0

package/dist/config/file-config.js

@@ -0,0 +1,174 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { DEFAULT_AUTH_REDIRECT_URI } from "../auth/constants.js";
+import { AppError, ExitCode } from "../utils/errors.js";
+import { normalizeAdAccountId } from "../utils/ids.js";
+import { normalizeAuthRedirectUri, normalizeHttpsUrl } from "../utils/security.js";
+const fileConfigSchema = z
+    .object({
+    accessToken: z.string().optional(),
+    accessTokenExpiresAt: z.string().optional(),
+    apiVersion: z.string().optional(),
+    approvalWebhook: z.string().optional(),
+    appId: z.string().optional(),
+    authConfigId: z.string().optional(),
+    authRedirectUri: z.string().optional(),
+    defaultAccountId: z.string().optional(),
+    outputFormat: z.enum(["text", "json"]).optional(),
+    permissionMode: z.enum(["read", "write", "admin"]).optional()
+})
+    .strict();
+function defaultConfigDir() {
+    return process.env.XDG_CONFIG_HOME
+        ? path.join(process.env.XDG_CONFIG_HOME, "cli-meta-ads")
+        : path.join(os.homedir(), ".config", "cli-meta-ads");
+}
+export function resolveDefaultConfigPath() {
+    return path.join(defaultConfigDir(), "config.json");
+}
+function normalizeApiVersion(version) {
+    const normalized = version.trim();
+    return normalized.startsWith("v") ? normalized : `v${normalized}`;
+}
+function normalizeOptionalString(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeOptionalIsoDate(value, label) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const parsed = new Date(normalized);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new AppError(`${label} must be a valid ISO-8601 timestamp.`, ExitCode.Config);
+    }
+    return parsed.toISOString();
+}
+async function readFileConfig(configPath) {
+    try {
+        const content = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(content);
+        const config = fileConfigSchema.parse(parsed);
+        return {
+            ...config,
+            accessToken: normalizeOptionalString(config.accessToken),
+            accessTokenExpiresAt: normalizeOptionalIsoDate(config.accessTokenExpiresAt, "accessTokenExpiresAt"),
+            approvalWebhook: config.approvalWebhook
+                ? normalizeHttpsUrl(config.approvalWebhook, "approvalWebhook")
+                : undefined,
+            appId: normalizeOptionalString(config.appId),
+            authConfigId: normalizeOptionalString(config.authConfigId),
+            authRedirectUri: config.authRedirectUri
+                ? normalizeAuthRedirectUri(config.authRedirectUri, "authRedirectUri")
+                : undefined,
+            defaultAccountId: config.defaultAccountId
+                ? normalizeAdAccountId(config.defaultAccountId)
+                : undefined
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {};
+        }
+        if (error instanceof z.ZodError) {
+            throw new AppError("Invalid CLI config file.", ExitCode.Config, {
+                issues: error.issues
+            });
+        }
+        if (error instanceof SyntaxError) {
+            throw new AppError("CLI config file is not valid JSON.", ExitCode.Config);
+        }
+        throw error;
+    }
+}
+export async function detectConfiguredOutputFormat(configPath) {
+    try {
+        const config = await readFileConfig(configPath ?? resolveDefaultConfigPath());
+        return config.outputFormat;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolvePermissionMode(value) {
+    if (!value) {
+        return "read";
+    }
+    if (value !== "read" && value !== "write" && value !== "admin") {
+        throw new AppError(`Invalid META_CLI_MODE: ${value}`, ExitCode.Config);
+    }
+    return value;
+}
+function resolveOutputFormat(value) {
+    if (!value) {
+        return "text";
+    }
+    if (value !== "text" && value !== "json") {
+        throw new AppError(`Invalid output format: ${value}`, ExitCode.Config);
+    }
+    return value;
+}
+export async function loadResolvedConfig(overrides = {}) {
+    const configPath = overrides.configPath ?? resolveDefaultConfigPath();
+    const fileConfig = await readFileConfig(configPath);
+    const envAccessToken = normalizeOptionalString(process.env.META_ACCESS_TOKEN);
+    const envAppId = normalizeOptionalString(process.env.META_APP_ID);
+    const envAppSecret = normalizeOptionalString(process.env.META_APP_SECRET);
+    const envAuthConfigId = normalizeOptionalString(process.env.META_AUTH_CONFIG_ID);
+    const envAuthRedirectUri = normalizeOptionalString(process.env.META_AUTH_REDIRECT_URI);
+    const permissionMode = overrides.permissionMode
+        ?? (process.env.META_CLI_MODE ? resolvePermissionMode(process.env.META_CLI_MODE) : undefined)
+        ?? fileConfig.permissionMode
+        ?? "read";
+    const outputFormat = overrides.outputFormat
+        ?? (process.env.META_OUTPUT_FORMAT ? resolveOutputFormat(process.env.META_OUTPUT_FORMAT) : undefined)
+        ?? fileConfig.outputFormat
+        ?? "text";
+    const defaultAccountId = process.env.META_DEFAULT_ACCOUNT_ID ?? fileConfig.defaultAccountId;
+    const approvalWebhook = process.env.META_APPROVAL_WEBHOOK
+        ? normalizeHttpsUrl(process.env.META_APPROVAL_WEBHOOK, "META_APPROVAL_WEBHOOK")
+        : fileConfig.approvalWebhook;
+    const apiVersion = normalizeApiVersion(overrides.apiVersion
+        ?? process.env.META_API_VERSION
+        ?? fileConfig.apiVersion
+        ?? "v25.0");
+    const accessToken = envAccessToken ?? fileConfig.accessToken;
+    const authRedirectUri = envAuthRedirectUri
+        ? normalizeAuthRedirectUri(envAuthRedirectUri, "META_AUTH_REDIRECT_URI")
+        : fileConfig.authRedirectUri ?? DEFAULT_AUTH_REDIRECT_URI;
+    return {
+        ...fileConfig,
+        accessToken,
+        accessTokenExpiresAt: envAccessToken ? undefined : fileConfig.accessTokenExpiresAt,
+        appId: envAppId ?? fileConfig.appId,
+        appSecret: envAppSecret,
+        approvalWebhook,
+        apiVersion,
+        authConfigId: envAuthConfigId ?? fileConfig.authConfigId,
+        authRedirectUri,
+        configPath,
+        debug: overrides.debug ?? false,
+        defaultAccountId: defaultAccountId ? normalizeAdAccountId(defaultAccountId) : undefined,
+        outputFormat,
+        permissionMode
+    };
+}
+export async function writeFileConfig(configPath, partial) {
+    const existing = await readFileConfig(configPath);
+    const next = fileConfigSchema.parse({
+        ...existing,
+        ...partial
+    });
+    await mkdir(path.dirname(configPath), { mode: 0o700, recursive: true });
+    await writeFile(configPath, `${JSON.stringify(next, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600
+    });
+    await chmod(configPath, 0o600).catch(() => undefined);
+}

package/dist/config/types.d.ts

@@ -0,0 +1,32 @@
+import type { OutputFormat, PermissionMode } from "../types.js";
+export interface FileConfig {
+    accessToken?: string | undefined;
+    accessTokenExpiresAt?: string | undefined;
+    apiVersion?: string | undefined;
+    approvalWebhook?: string | undefined;
+    appId?: string | undefined;
+    authConfigId?: string | undefined;
+    authRedirectUri?: string | undefined;
+    defaultAccountId?: string | undefined;
+    outputFormat?: OutputFormat | undefined;
+    permissionMode?: PermissionMode | undefined;
+}
+export interface ConfigOverrides {
+    apiVersion?: string | undefined;
+    configPath?: string | undefined;
+    debug?: boolean | undefined;
+    outputFormat?: OutputFormat | undefined;
+    permissionMode?: PermissionMode | undefined;
+}
+export interface ResolvedConfig extends FileConfig {
+    accessToken?: string | undefined;
+    appId?: string | undefined;
+    appSecret?: string | undefined;
+    authConfigId?: string | undefined;
+    authRedirectUri?: string | undefined;
+    configPath: string;
+    debug: boolean;
+    outputFormat: OutputFormat;
+    permissionMode: PermissionMode;
+    apiVersion: string;
+}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/account-scope.d.ts

@@ -0,0 +1,7 @@
+import type { CommandContext } from "../cli/context.js";
+import { type ManagedAccount } from "../client/meta-discovery.js";
+export interface ResolvedAccountScope {
+    accounts: ManagedAccount[];
+    selection: string;
+}
+export declare function resolveAccountScope(context: CommandContext, selection?: string | undefined): Promise<ResolvedAccountScope>;

package/dist/domain/account-scope.js

@@ -0,0 +1,28 @@
+import { discoverManagedAccounts } from "../client/meta-discovery.js";
+import { AppError, ExitCode } from "../utils/errors.js";
+import { normalizeAdAccountId } from "../utils/ids.js";
+export async function resolveAccountScope(context, selection) {
+    const requested = selection ?? context.config.defaultAccountId;
+    if (!requested) {
+        throw new AppError("No account specified. Use --account or configure a default account with `meta accounts set-default`.", ExitCode.Usage);
+    }
+    if (requested === "all") {
+        const accounts = await discoverManagedAccounts(context.config, context.client);
+        if (accounts.length === 0) {
+            throw new AppError("No managed accounts could be discovered for this token.", ExitCode.VerificationFailed);
+        }
+        return {
+            accounts,
+            selection: requested
+        };
+    }
+    return {
+        accounts: [
+            {
+                id: normalizeAdAccountId(requested),
+                source: "explicit"
+            }
+        ],
+        selection: requested
+    };
+}

package/dist/domain/analytics.d.ts

@@ -0,0 +1,52 @@
+import type { DateWindow } from "../utils/date-range.js";
+export interface InsightsMetricRow {
+    accountId?: string | undefined;
+    accountName?: string | undefined;
+    adId?: string | undefined;
+    adName?: string | undefined;
+    campaignId?: string | undefined;
+    campaignName?: string | undefined;
+    clicks: number;
+    cpc: number;
+    cpm: number;
+    ctr: number;
+    dateStart?: string | undefined;
+    dateStop?: string | undefined;
+    frequency: number;
+    impressions: number;
+    reach: number;
+    spend: number;
+}
+export declare function summarizePerformance(rows: InsightsMetricRow[]): {
+    avgCtr: number;
+    rows: number;
+    totalClicks: number;
+    totalImpressions: number;
+    totalReach: number;
+    totalSpend: number;
+};
+export declare function buildReport(period: string, window: DateWindow, rows: InsightsMetricRow[]): {
+    period: string;
+    summary: {
+        avgCtr: number;
+        rows: number;
+        totalClicks: number;
+        totalImpressions: number;
+        totalReach: number;
+        totalSpend: number;
+    };
+    window: DateWindow;
+};
+export declare function detectAnomalies(rows: InsightsMetricRow[], thresholdPercent: number): Record<string, unknown>[];
+export declare function analyzeCreativeFatigue(rows: InsightsMetricRow[]): {
+    adId: string;
+    adName: string | undefined;
+    campaignId: string | undefined;
+    campaignName: string | undefined;
+    cpcDelta: number | null;
+    ctrDelta: number | null;
+    fatigueScore: number;
+    frequencyDelta: number | null;
+    impressionVolume: number;
+    status: string;
+}[];

package/dist/domain/analytics.js

@@ -0,0 +1,125 @@
+import { percentChange } from "../utils/date-range.js";
+export function summarizePerformance(rows) {
+    const totals = rows.reduce((accumulator, row) => ({
+        clicks: accumulator.clicks + row.clicks,
+        impressions: accumulator.impressions + row.impressions,
+        reach: accumulator.reach + row.reach,
+        spend: accumulator.spend + row.spend
+    }), {
+        clicks: 0,
+        impressions: 0,
+        reach: 0,
+        spend: 0
+    });
+    return {
+        avgCtr: totals.impressions === 0 ? 0 : (totals.clicks / totals.impressions) * 100,
+        rows: rows.length,
+        totalClicks: totals.clicks,
+        totalImpressions: totals.impressions,
+        totalReach: totals.reach,
+        totalSpend: totals.spend
+    };
+}
+export function buildReport(period, window, rows) {
+    return {
+        period,
+        summary: summarizePerformance(rows),
+        window
+    };
+}
+export function detectAnomalies(rows, thresholdPercent) {
+    const byCampaign = new Map();
+    for (const row of rows) {
+        const key = row.campaignId ?? "unknown";
+        const bucket = byCampaign.get(key) ?? [];
+        bucket.push(row);
+        byCampaign.set(key, bucket);
+    }
+    const anomalies = [];
+    for (const [campaignId, campaignRows] of byCampaign.entries()) {
+        const sorted = [...campaignRows].sort((left, right) => (left.dateStart ?? "").localeCompare(right.dateStart ?? ""));
+        if (sorted.length < 2) {
+            continue;
+        }
+        const latest = sorted[sorted.length - 1];
+        if (!latest) {
+            continue;
+        }
+        const previousRows = sorted.slice(0, -1);
+        const baseline = summarizePerformance(previousRows);
+        const metrics = [
+            {
+                current: latest.spend,
+                name: "spend",
+                previous: baseline.totalSpend / previousRows.length
+            },
+            {
+                current: latest.ctr,
+                name: "ctr",
+                previous: previousRows.reduce((sum, row) => sum + row.ctr, 0) / previousRows.length
+            },
+            {
+                current: latest.clicks,
+                name: "clicks",
+                previous: baseline.totalClicks / previousRows.length
+            }
+        ];
+        for (const metric of metrics) {
+            const delta = percentChange(metric.previous, metric.current);
+            if (delta !== null && Math.abs(delta) >= thresholdPercent) {
+                anomalies.push({
+                    campaignId,
+                    campaignName: latest.campaignName,
+                    current: metric.current,
+                    date: latest.dateStart,
+                    metric: metric.name,
+                    previous: metric.previous,
+                    percentChange: delta
+                });
+            }
+        }
+    }
+    return anomalies.sort((left, right) => Math.abs(Number(right.percentChange)) - Math.abs(Number(left.percentChange)));
+}
+export function analyzeCreativeFatigue(rows) {
+    const byAd = new Map();
+    for (const row of rows) {
+        const key = row.adId ?? "unknown";
+        const bucket = byAd.get(key) ?? [];
+        bucket.push(row);
+        byAd.set(key, bucket);
+    }
+    const fatigue = [];
+    for (const [adId, adRows] of byAd.entries()) {
+        const sorted = [...adRows].sort((left, right) => (left.dateStart ?? "").localeCompare(right.dateStart ?? ""));
+        if (sorted.length < 6) {
+            continue;
+        }
+        const splitIndex = Math.floor(sorted.length / 2);
+        const early = sorted.slice(0, splitIndex);
+        const recent = sorted.slice(splitIndex);
+        const avg = (entries, key) => entries.reduce((sum, entry) => sum + Number(entry[key] ?? 0), 0) / entries.length;
+        const ctrDelta = percentChange(avg(early, "ctr"), avg(recent, "ctr"));
+        const frequencyDelta = percentChange(avg(early, "frequency"), avg(recent, "frequency"));
+        const cpcDelta = percentChange(avg(early, "cpc"), avg(recent, "cpc"));
+        const signals = [
+            ctrDelta !== null && ctrDelta <= -15,
+            frequencyDelta !== null && frequencyDelta >= 15,
+            cpcDelta !== null && cpcDelta >= 15
+        ];
+        const score = Math.round((signals.filter(Boolean).length / signals.length) * 100);
+        fatigue.push({
+            adId,
+            adName: recent[0]?.adName,
+            campaignId: recent[0]?.campaignId,
+            campaignName: recent[0]?.campaignName,
+            cpcDelta,
+            ctrDelta,
+            fatigueScore: score,
+            frequencyDelta,
+            impressionVolume: recent.reduce((sum, entry) => sum + entry.impressions, 0),
+            status: score >= 66 ? "fatigued" : score >= 33 ? "watch" : "healthy"
+        });
+    }
+    return fatigue.sort((left, right) => Number(right.fatigueScore) - Number(left.fatigueScore));
+}

package/dist/domain/approval-service.d.ts

@@ -0,0 +1,10 @@
+import type { CommandContext } from "../cli/context.js";
+import type { ApprovalRequestPayload } from "../types.js";
+export interface ApprovalDecision {
+    changePercent?: number | null | undefined;
+    reason: string;
+    required: boolean;
+}
+export declare function decideCampaignStatusApproval(action: "pause" | "enable"): ApprovalDecision;
+export declare function decideBudgetApproval(changePercent: number | null): ApprovalDecision;
+export declare function submitApprovalRequest(context: CommandContext, payload: ApprovalRequestPayload): Promise<void>;

package/dist/domain/approval-service.js

@@ -0,0 +1,48 @@
+import { AppError, ExitCode } from "../utils/errors.js";
+import { normalizeHttpsUrl } from "../utils/security.js";
+export function decideCampaignStatusApproval(action) {
+    return {
+        reason: `Campaign ${action} always requires approval.`,
+        required: true
+    };
+}
+export function decideBudgetApproval(changePercent) {
+    if (changePercent === null) {
+        return {
+            changePercent,
+            reason: "Current budget is zero or missing; approval required for safety.",
+            required: true
+        };
+    }
+    if (Math.abs(changePercent) > 20) {
+        return {
+            changePercent,
+            reason: "Budget change exceeds the 20% approval threshold.",
+            required: true
+        };
+    }
+    return {
+        changePercent,
+        reason: "Budget change is within the direct-write threshold.",
+        required: false
+    };
+}
+export async function submitApprovalRequest(context, payload) {
+    const approvalWebhook = context.config.approvalWebhook
+        ? normalizeHttpsUrl(context.config.approvalWebhook, "META_APPROVAL_WEBHOOK")
+        : undefined;
+    if (!approvalWebhook) {
+        throw new AppError("META_APPROVAL_WEBHOOK is required for approval-gated writes.", ExitCode.ApprovalRequired);
+    }
+    const fetchImpl = context.fetchImpl ?? fetch;
+    const response = await fetchImpl(approvalWebhook, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+        throw new AppError(`Approval webhook request failed with status ${response.status}.`, ExitCode.Provider);
+    }
+}

package/dist/domain/asset-feed-compiler.d.ts

@@ -0,0 +1,43 @@
+import type { AssetFeedCreativeCreateSpec } from "./meta-ads-service.js";
+import { type LaunchCreativeFormatKey } from "../utils/meta-placement-assets.js";
+export interface CreativeAssetBinding {
+    captionIds?: string[] | undefined;
+    id: string;
+    imageCrops?: Record<string, number[]> | undefined;
+    imageHash?: string | undefined;
+    imageUrl?: string | undefined;
+    kind: "image" | "video";
+    videoId?: string | undefined;
+}
+type AssetFeedBuildBase = {
+    fallback: CreativeAssetBinding;
+    formatBindings: Partial<Record<LaunchCreativeFormatKey, CreativeAssetBinding | undefined>>;
+    includeMatchingFormatRules?: boolean | undefined;
+    kind: "link-image" | "video-link";
+    name?: string | undefined;
+    pageId: string;
+    placementTargets: Partial<Record<LaunchCreativeFormatKey, string[] | undefined>>;
+};
+type ImageAssetFeedBuildInput = AssetFeedBuildBase & {
+    kind: "link-image";
+    linkData: {
+        callToAction?: string | undefined;
+        description?: string | undefined;
+        headline?: string | undefined;
+        link: string;
+        message: string;
+    };
+};
+type VideoAssetFeedBuildInput = AssetFeedBuildBase & {
+    kind: "video-link";
+    videoData: {
+        callToAction?: string | undefined;
+        description?: string | undefined;
+        link: string;
+        message: string;
+        title?: string | undefined;
+    };
+};
+export type AssetFeedBuildInput = ImageAssetFeedBuildInput | VideoAssetFeedBuildInput;
+export declare function buildAssetFeedCreativeSpec(input: AssetFeedBuildInput): AssetFeedCreativeCreateSpec | undefined;
+export {};

package/dist/domain/asset-feed-compiler.js

@@ -0,0 +1,104 @@
+import { buildPlacementCustomizationSpec, launchCreativeFormatKeys } from "../utils/meta-placement-assets.js";
+function sameCreativeAssetBinding(left, right) {
+    if (!left || !right || left.kind !== right.kind || left.id !== right.id) {
+        return false;
+    }
+    return JSON.stringify(left.captionIds ?? []) === JSON.stringify(right.captionIds ?? [])
+        && JSON.stringify(left.imageCrops ?? {}) === JSON.stringify(right.imageCrops ?? {});
+}
+function sanitizeAssetLabel(value) {
+    return value.replace(/[^a-zA-Z0-9_]+/g, "_");
+}
+function buildAssetFeedMediaLabel(creativeName, slot) {
+    return `placement_asset_${sanitizeAssetLabel(creativeName)}_${sanitizeAssetLabel(slot)}`;
+}
+function buildAssetFeedMediaEntry(labelName, binding) {
+    return binding.kind === "image"
+        ? {
+            adlabels: [{ name: labelName }],
+            ...(binding.imageHash ? { hash: binding.imageHash } : {}),
+            ...(binding.imageUrl ? { url: binding.imageUrl } : {}),
+            image_crops: binding.imageCrops
+        }
+        : {
+            adlabels: [{ name: labelName }],
+            caption_ids: binding.captionIds,
+            video_id: binding.videoId
+        };
+}
+export function buildAssetFeedCreativeSpec(input) {
+    const explicitRules = launchCreativeFormatKeys.flatMap((formatKey) => {
+        const binding = input.formatBindings[formatKey];
+        const placementIds = input.placementTargets[formatKey] ?? [];
+        if (!binding
+            || placementIds.length === 0
+            || (!input.includeMatchingFormatRules
+                && sameCreativeAssetBinding(binding, input.fallback))) {
+            return [];
+        }
+        return [{
+                binding,
+                placementIds,
+                slot: formatKey
+            }];
+    });
+    if (explicitRules.length === 0) {
+        return undefined;
+    }
+    const creativeName = input.name ?? input.kind;
+    const fallbackLabelName = buildAssetFeedMediaLabel(creativeName, "default");
+    const assetCustomizationRules = [
+        ...explicitRules.map((rule) => {
+            const labelName = buildAssetFeedMediaLabel(creativeName, rule.slot);
+            return {
+                customization_spec: buildPlacementCustomizationSpec(rule.placementIds),
+                ...(input.kind === "link-image"
+                    ? { image_label: { name: labelName } }
+                    : { video_label: { name: labelName } })
+            };
+        }),
+        {
+            customization_spec: {},
+            ...(input.kind === "link-image"
+                ? { image_label: { name: fallbackLabelName } }
+                : { video_label: { name: fallbackLabelName } })
+        }
+    ];
+    const assetFeedSpec = {
+        ad_formats: [input.kind === "link-image" ? "SINGLE_IMAGE" : "SINGLE_VIDEO"],
+        asset_customization_rules: assetCustomizationRules,
+        bodies: [{ text: input.kind === "link-image" ? input.linkData.message : input.videoData.message }],
+        ...(input.kind === "link-image"
+            ? {
+                call_to_action_types: input.linkData.callToAction ? [input.linkData.callToAction] : undefined,
+                descriptions: input.linkData.description ? [{ text: input.linkData.description }] : undefined,
+                images: [
+                    ...explicitRules
+                        .filter((rule) => rule.binding.kind === "image")
+                        .map((rule) => buildAssetFeedMediaEntry(buildAssetFeedMediaLabel(creativeName, rule.slot), rule.binding)),
+                    buildAssetFeedMediaEntry(fallbackLabelName, input.fallback)
+                ],
+                link_urls: [{ website_url: input.linkData.link }],
+                titles: input.linkData.headline ? [{ text: input.linkData.headline }] : undefined
+            }
+            : {
+                call_to_action_types: input.videoData.callToAction ? [input.videoData.callToAction] : undefined,
+                descriptions: input.videoData.description ? [{ text: input.videoData.description }] : undefined,
+                link_urls: [{ website_url: input.videoData.link }],
+                titles: input.videoData.title ? [{ text: input.videoData.title }] : undefined,
+                videos: [
+                    ...explicitRules
+                        .filter((rule) => rule.binding.kind === "video")
+                        .map((rule) => buildAssetFeedMediaEntry(buildAssetFeedMediaLabel(creativeName, rule.slot), rule.binding)),
+                    buildAssetFeedMediaEntry(fallbackLabelName, input.fallback)
+                ]
+            }),
+        optimization_type: "PLACEMENT"
+    };
+    return {
+        assetFeedSpec,
+        kind: input.kind,
+        name: input.name,
+        pageId: input.pageId
+    };
+}