@tday-com/mcp 0.3.1 → 0.4.2

package/dist/server.js

@@ -1,43 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { loadConfig } from "./config.js";
-import { packageVersion } from "./package-info.js";
-import { registerPrompts } from "./prompts.js";
-import { tools, formatToolResultText, responseFormatFromArgs, toStructuredContent, } from "./tools.js";
-export async function runServer() {
-    const config = await loadConfig();
-    const server = new McpServer({ name: "tday-mcp-server", version: packageVersion() });
-    registerTools(server, tools, config);
-    registerPrompts(server);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-export function registerTools(server, list, config) {
-    const registerTool = server.registerTool.bind(server);
-    for (const tool of list) {
-        registerTool(tool.name, {
-            title: tool.title,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-            outputSchema: tool.outputSchema,
-            annotations: {
-                readOnlyHint: tool.annotations.readOnlyHint,
-                destructiveHint: tool.annotations.destructiveHint,
-                idempotentHint: tool.annotations.idempotentHint,
-                openWorldHint: tool.annotations.openWorldHint,
-            },
-        }, async (args) => {
-            const rawArgs = args ?? {};
-            const result = await tool.handler(rawArgs, config);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: formatToolResultText(tool.name, result, responseFormatFromArgs(rawArgs), tool.markdown),
-                    },
-                ],
-                structuredContent: toStructuredContent(result),
-            };
-        });
-    }
-}

package/dist/tool-schemas.js

@@ -1,175 +0,0 @@
-import { z } from "zod";
-export const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
-const responseFormatSchema = z
-    .enum(["json", "markdown"])
-    .default("json")
-    .describe("Text response format. Defaults to json for backward compatibility; structuredContent is always returned when the MCP client supports it.");
-export const safeIdSchema = z
-    .string()
-    .trim()
-    .min(1)
-    .regex(SAFE_ID, "must contain only letters, numbers, underscores, and hyphens");
-export function argsObject(shape) {
-    return z
-        .object({
-        ...shape,
-        response_format: responseFormatSchema,
-    })
-        .strict();
-}
-export const emptyArgsSchema = argsObject({});
-export const listArgsSchema = argsObject({
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(100)
-        .default(50)
-        .describe("Maximum items to return. Defaults to 50."),
-    offset: z
-        .number()
-        .int()
-        .min(0)
-        .default(0)
-        .describe("Number of items to skip for pagination. Defaults to 0."),
-});
-export function safePath(template, params) {
-    return template.replace(/:(\w+)/g, (_, key) => {
-        const val = String(params[key] ?? "");
-        if (!SAFE_ID.test(val)) {
-            throw new Error(`Invalid ${key}: must contain only letters, numbers, underscores, and hyphens (got "${val}")`);
-        }
-        return encodeURIComponent(val);
-    });
-}
-export function stripPresentationArgs(args) {
-    const { response_format: _responseFormat, ...rest } = args;
-    return rest;
-}
-export function responseFormatFromArgs(args) {
-    return args.response_format === "markdown" ? "markdown" : "json";
-}
-const anyRecord = z.record(z.string(), z.unknown());
-const paginationSchema = z
-    .object({
-    total_count: z.number().optional(),
-    total: z.number().optional(),
-    count: z.number(),
-    offset: z.number(),
-    limit: z.number(),
-    has_more: z.boolean().optional(),
-    hasMore: z.boolean().optional(),
-    next_offset: z.number().optional(),
-    nextOffset: z.number().optional(),
-})
-    .passthrough();
-export const outputSchemas = {
-    whoami: z
-        .object({
-        account: z.unknown().optional(),
-        organizations: z.array(anyRecord).optional(),
-        defaultOrganizationId: z.string().nullable().optional(),
-        features: z.unknown().optional(),
-        links: z.unknown().optional(),
-        notes: z.array(z.string()).optional(),
-    })
-        .passthrough(),
-    creditPrices: z
-        .object({
-        priceVersion: z.number().optional(),
-        actions: z.array(anyRecord).optional(),
-        launchVideos: z.array(anyRecord).optional(),
-        launchVideoRevisions: z.array(anyRecord).optional(),
-        monthlyCredits: z.unknown().optional(),
-        notes: z.array(z.string()).optional(),
-    })
-        .passthrough(),
-    usage: z
-        .object({
-        organization: anyRecord.optional(),
-        balance: z.unknown().optional(),
-        usage: z.unknown().optional(),
-        links: z.unknown().optional(),
-    })
-        .passthrough(),
-    listBrands: z
-        .object({
-        brands: z.array(anyRecord),
-        pagination: paginationSchema.optional(),
-    })
-        .passthrough(),
-    getBrand: z
-        .object({
-        brand: anyRecord.optional(),
-        role: z.string().optional(),
-    })
-        .passthrough(),
-    listDesigns: z
-        .object({
-        designs: z.array(anyRecord),
-        archivedCount: z.number().optional(),
-        pagination: paginationSchema.optional(),
-    })
-        .passthrough(),
-    getDesign: z
-        .object({
-        design: anyRecord.optional(),
-    })
-        .passthrough(),
-    createBrand: z
-        .object({
-        brand: anyRecord.optional(),
-        reviewStatus: z.string().optional(),
-    })
-        .passthrough(),
-    generate: z
-        .object({
-        designId: z.string(),
-        generationId: z.string(),
-        status: z.string(),
-        editorUrl: z.string(),
-        statusUrl: z.string(),
-        format: z.string().optional(),
-        formatNote: z.string().optional(),
-        credits: z.unknown().optional(),
-    })
-        .passthrough(),
-    poll: z
-        .object({
-        designId: z.string(),
-        generationId: z.string(),
-        status: z.string(),
-        editorUrl: z.string(),
-        imageUrl: z.string().optional(),
-        completedAt: z.string().nullable().optional(),
-        platformBadge: z.boolean().optional(),
-        badgeNote: z.string().optional(),
-        failureMessage: z.string().optional(),
-    })
-        .passthrough(),
-    download: z
-        .object({
-        saved: z.boolean(),
-        path: z.string(),
-        size: z.number(),
-    })
-        .passthrough(),
-};
-export const readOnly = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-export const writeRemote = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-export const writeLocal = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: false,
-    openWorldHint: true,
-};

package/dist/tools-account.js

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { api, query } from "./api-client.js";
-import { argsObject, outputSchemas, readOnly, safeIdSchema } from "./tool-schemas.js";
-export const accountTools = [
-    {
-        name: "tday_get_credit_prices",
-        title: "Credit prices",
-        description: "What each thing costs in credits at today's price list: an image design, an edit, design videos, launch videos (every length, with or without music and voiceover, already added up), a launch video revision, scans, and each plan's monthly credits. Use it to tell the person what something will cost BEFORE starting it, next to the balance from tday_whoami.",
-        inputSchema: argsObject({}),
-        outputSchema: outputSchemas.creditPrices,
-        annotations: readOnly,
-        handler: (_args, config) => api(config, "/api/v1/credits/prices"),
-    },
-    {
-        name: "tday_get_usage",
-        title: "Credit usage",
-        description: "One organisation's credit balance and what it has spent this grant period, by action, by brand and by person, plus a link to its usage page. Pass organizationId from tday_whoami; omitted, the organisation the person owns.",
-        inputSchema: argsObject({
-            organizationId: safeIdSchema.optional().describe("Organisation ID from tday_whoami"),
-        }),
-        outputSchema: outputSchemas.usage,
-        annotations: readOnly,
-        handler: (args, config) => api(config, `/api/v1/usage${query({ organizationId: typeof args.organizationId === "string" ? args.organizationId : undefined })}`),
-    },
-];
-export const IMAGE_FORMATS = ["square", "ig_post", "story", "fb_post", "linkedin_post", "desktop", "a4_page"];
-export const imageFormatSchema = z
-    .enum(IMAGE_FORMATS)
-    .optional()
-    .describe("Preset size: square 1080x1080, ig_post 1080x1350 (4:5 portrait), story 1080x1920 (9:16), fb_post 1200x630, linkedin_post 1200x627, desktop 1920x1080, a4_page. Portrait, square and story are on the paid plans where the plan gates sizes (tday_whoami output.allSizes); asking for one that is not included is refused with an upgrade link.");

package/dist/tools-features.js

@@ -1,39 +0,0 @@
-import { z } from "zod";
-import { api, query } from "./api-client.js";
-import { argsObject, readOnly, safeIdSchema } from "./tool-schemas.js";
-const MAX_FEATURES = 50;
-export const LIST_FEATURES_DESCRIPTION = "List a brand's features (its Launch page catalog), newest added first, with the videos each already has: how many launch videos are finished or being made, and the latest one with its link. " +
-    "Use it for the newest feature, for the features that still have no launch video (without: launch_video), or to find a feature's id for tday_create_launch_video. " +
-    "brandId may be left out when the account has one brand; otherwise pass one from tday_list_brands. `more` counts the features not listed. Spends no credits.";
-const featureListSchema = z
-    .object({
-    brand: z.object({ id: z.string(), name: z.string() }).passthrough(),
-    counts: z.record(z.string(), z.unknown()),
-    features: z.array(z.record(z.string(), z.unknown())),
-    more: z.number(),
-})
-    .passthrough();
-export const featureTools = [
-    {
-        name: "tday_list_features",
-        title: "List features",
-        description: LIST_FEATURES_DESCRIPTION,
-        inputSchema: argsObject({
-            brandId: safeIdSchema.optional().describe("Brand ID from tday_list_brands. Optional when the account has one brand."),
-            without: z
-                .enum(["launch_video"])
-                .optional()
-                .describe("launch_video: only features with no launch video finished or being made."),
-            search: z.string().trim().min(1).max(160).optional().describe("Only features whose title contains this, ignoring case."),
-            limit: z.number().int().min(1).max(MAX_FEATURES).default(20).describe(`How many to list, newest first (at most ${MAX_FEATURES}). Defaults to 20.`),
-        }),
-        outputSchema: featureListSchema,
-        annotations: readOnly,
-        handler: (args, config) => api(config, `/api/v1/features${query({
-            brandId: typeof args.brandId === "string" ? args.brandId : undefined,
-            without: typeof args.without === "string" ? args.without : undefined,
-            q: typeof args.search === "string" ? args.search : undefined,
-            limit: typeof args.limit === "number" ? args.limit : undefined,
-        })}`),
-    },
-];

package/dist/tools-launch.js

@@ -1,358 +0,0 @@
-import { constants } from "node:fs";
-import { open, rm } from "node:fs/promises";
-import { z } from "zod";
-import { api } from "./api-client.js";
-import { prepareOutputFilePath, validateImageUrl } from "./download-safety.js";
-import { argsObject, readOnly, safeIdSchema, safePath, writeLocal, writeRemote, } from "./tool-schemas.js";
-const MAX_TITLE_CHARS = 160;
-const MAX_DESCRIPTION_CHARS = 4000;
-const MAX_DIRECTION_CHARS = 600;
-export const MAX_VIDEO_BYTES = 250 * 1024 * 1024;
-const MUSIC_MOODS = ["Cinematic", "Upbeat", "Minimal", "Warm", "Driving"];
-const NARRATION_STYLES = ["talk", "thread", "story", "duo", "team", "launch", "doc"];
-const STYLES = "talk (one person talking to one viewer who has the problem, the default); thread (says how many updates there are, then goes through each by name, the default for a product update); " +
-    "story (a day in the life of one person in your audience); duo (two voices: the viewer's inner voice and a narrator); team (from the team who built it); launch (quick and bright); doc (a calm, third-person documentary)";
-const VOICE_NAMES = ["Reece", "Ivy", "Janet", "Sarah", "Craig"];
-const VOICES = "Reece, warm conversational narrator; Ivy, bright friendly presenter; Janet, warm expressive explainer; " +
-    "Sarah, upbeat lively presenter; Craig, deep polished broadcast voice";
-const POLL_GUIDANCE = "Poll tday_poll_launch_video with this videoId every 20-30 seconds until it is ready.";
-const VOICEOVER_NOT_INCLUDED = "Voiceover is not included on this organisation's plan, so the film is silent and no voice was charged.";
-const videoIdSchema = safeIdSchema.describe("videoId returned by tday_create_launch_video");
-const outputSchemas = {
-    create: z
-        .object({ videoId: z.string(), status: z.string(), narration: z.string(), reviewUrl: z.string() })
-        .passthrough(),
-    poll: z
-        .object({ videoId: z.string(), status: z.string(), state: z.string(), terminal: z.boolean(), reviewUrl: z.string() })
-        .passthrough(),
-    mp4: z
-        .object({
-        videoId: z.string(),
-        versionId: z.string(),
-        fps: z.number(),
-        state: z.enum(["ready", "rendering", "failed"]),
-        mp4Url: z.string().optional(),
-        progress: z.number().nullable().optional(),
-        saved: z.boolean().optional(),
-        path: z.string().optional(),
-        size: z.number().optional(),
-    })
-        .passthrough(),
-    revise: z.object({ videoId: z.string(), status: z.string(), reviewUrl: z.string() }).passthrough(),
-};
-const FIRST_EXPORT = "The first request for a cut at a frame rate renders its file, which usually takes a minute or two";
-export const launchTools = [
-    {
-        name: "tday_create_launch_video",
-        title: "Create launch video",
-        description: "Make a launch video: a short animated film announcing a feature or product, in the brand's own look. tday's pipeline writes the brief, storyboard, motion, music and narration from the title and description; describe the subject well and pick the options. " +
-            "For a feature tday already has (tday_list_features), pass its featureId instead of brandId, title and description: the film is made of that feature, with what tday knows about it. " +
-            "It spends credits from the brand's organisation: a standard (20s), scored, silent film is 40 credits, and a voiceover or another length changes that (tday_get_credit_prices has the full list). " +
-            "A 402 means the balance cannot cover it: nothing was started, so do not retry. Returns a videoId and a reviewUrl at once; the film takes about 2-5 minutes, so poll tday_poll_launch_video.",
-        inputSchema: argsObject({
-            featureId: safeIdSchema
-                .optional()
-                .describe("A feature's id from tday_list_features: the film is made of it, and brandId, title and description are not needed."),
-            brandId: safeIdSchema
-                .optional()
-                .describe("Brand ID from tday_list_brands, for a new subject (without featureId). The film uses this brand's colours, fonts and logo."),
-            title: z
-                .string()
-                .trim()
-                .min(1)
-                .max(MAX_TITLE_CHARS)
-                .optional()
-                .describe("The feature or product the film launches, as a short name (without featureId)."),
-            description: z
-                .string()
-                .trim()
-                .min(1)
-                .max(MAX_DESCRIPTION_CHARS)
-                .optional()
-                .describe("What the feature or product does and who it is for (without featureId). The film's brief is written from this, so be specific."),
-            length: z
-                .enum(["short", "standard", "long"])
-                .default("standard")
-                .describe("short (about 10s), standard (about 20s, the default) or long (about 50s)."),
-            narration: z
-                .enum(["silent", "voiceover"])
-                .default("silent")
-                .describe("silent (music and motion carry it, the default) or voiceover (narrated, with captions; costs more)."),
-            music: z.enum(["score", "none"]).default("score").describe("score (a bed written to the film's length, the default) or none."),
-            musicMood: z.enum(MUSIC_MOODS).optional().describe("A mood for the score. Omit to let the planner choose."),
-            voice: z.enum(VOICE_NAMES).optional().describe(`The narrator of a voiceover film. Omit for the default. One of: ${VOICES}.`),
-            narrationStyle: z.enum(NARRATION_STYLES).optional().describe(`How a voiceover film tells its story. Omit for the default. One of: ${STYLES}.`),
-            direction: z
-                .string()
-                .trim()
-                .min(1)
-                .max(MAX_DIRECTION_CHARS)
-                .optional()
-                .describe("Optional creative notes in plain words, for example 'lead on the scrubbing, end on the call to action'."),
-        }),
-        outputSchema: outputSchemas.create,
-        annotations: writeRemote,
-        handler: async (args, config) => {
-            const existing = typeof args.featureId === "string" ? args.featureId : null;
-            const featureId = existing ?? (await saveSubject(args, config));
-            const created = await api(config, safePath("/api/showcase/features/:id/create-launch-video", { id: featureId }), { method: "POST", body: JSON.stringify(launchAxes(args)) }).catch((error) => {
-                if (existing)
-                    throw error;
-                throw new Error(`${error instanceof Error ? error.message : String(error)} ${subjectSaved(args.title)}`);
-            });
-            const videoId = created?.runFeatureId;
-            if (typeof videoId !== "string")
-                throw new Error("tday could not start that film. Try again in a moment.");
-            const narration = created?.narration === "voiceover" || created?.narration === "silent" ? created.narration : args.narration;
-            return {
-                videoId,
-                status: "queued",
-                length: args.length,
-                narration,
-                music: args.music,
-                reviewUrl: reviewUrl(config, videoId),
-                ...(args.narration === "voiceover" && narration === "silent" ? { note: VOICEOVER_NOT_INCLUDED } : {}),
-                next: `A film takes about 2-5 minutes. ${POLL_GUIDANCE}`,
-            };
-        },
-    },
-    {
-        name: "tday_poll_launch_video",
-        title: "Poll launch video",
-        description: "Check a launch video made with tday_create_launch_video or revised with tday_revise_launch_video. state is in_progress, ready or failed; terminal is true once it is ready or failed. " +
-            "Poll every 20-30 seconds while it is in progress. When it is ready, watch it at reviewUrl or call tday_get_launch_video_mp4 for the MP4 file. Spends no credits.",
-        inputSchema: argsObject({ videoId: videoIdSchema }),
-        outputSchema: outputSchemas.poll,
-        annotations: readOnly,
-        handler: async (args, config) => {
-            const videoId = String(args.videoId);
-            const payload = await api(config, safePath("/api/showcase/videos/:videoId", args));
-            return summarizeLaunchVideo(videoId, payload ?? {}, reviewUrl(config, videoId));
-        },
-    },
-    {
-        name: "tday_get_launch_video_mp4",
-        title: "Get launch video MP4",
-        description: "Get a ready launch video as an MP4 file URL. A launch video is ready before its file: " + FIRST_EXPORT + ", so this answers state rendering " +
-            "(with progress) until the file exists - call it again every 20-30 seconds until state is ready. Later requests return the stored file at once. Spends no credits. " +
-            "If state is failed, call it again with retry: true. versionId defaults to the newest ready cut (readyVersionId from tday_poll_launch_video). " +
-            `Pass download: true to also save it inside the current working directory once it is ready (at most ${MAX_VIDEO_BYTES / 1024 / 1024}MB).`,
-        inputSchema: argsObject({
-            videoId: videoIdSchema,
-            versionId: safeIdSchema.optional().describe("A cut's versionId from tday_poll_launch_video. Omit for the newest ready cut."),
-            fps: z.union([z.literal(60), z.literal(30)]).default(60).describe("The file's frame rate: 60 (the default, smoothest) or 30 (a smaller file). Older cuts that cannot be rendered again offer only 60 and answer 409 for 30."),
-            retry: z.boolean().default(false).describe("Ask again after state failed. Defaults to false."),
-            download: z.boolean().default(false).describe("Also save the MP4 into the current working directory. Defaults to false."),
-            filePath: z
-                .string()
-                .trim()
-                .min(1)
-                .max(500)
-                .optional()
-                .describe("Where to save it, relative to cwd. Defaults to ./tday-launch-videos/<videoId>-<versionId>.mp4 (<videoId>-<versionId>-30fps.mp4 at 30 fps, so both rates can sit side by side). Only used with download."),
-            overwrite: z.boolean().default(false).describe("Whether to overwrite an existing regular file. Defaults to false for safety."),
-        }),
-        outputSchema: outputSchemas.mp4,
-        annotations: writeLocal,
-        handler: async (args, config) => {
-            const videoId = String(args.videoId);
-            const versionId = typeof args.versionId === "string" ? args.versionId : await newestReadyVersion(config, videoId);
-            const fps = args.fps === 30 ? 30 : 60;
-            const answer = await api(config, safePath("/api/showcase/videos/:videoId/render", args), {
-                method: "POST",
-                body: JSON.stringify({ versionId, ...(fps === 30 ? { fps } : {}), ...(args.retry ? { retry: true } : {}) }),
-            });
-            const waiting = exportWaiting(answer, { videoId, versionId, fps, reviewUrl: reviewUrl(config, videoId) });
-            if (waiting)
-                return waiting;
-            const mp4Url = answer?.mp4Url;
-            if (typeof mp4Url !== "string")
-                throw new Error("tday could not prepare the video. Try again in a moment.");
-            const film = { videoId, versionId, fps, state: "ready", mp4Url, reviewUrl: reviewUrl(config, videoId) };
-            if (!args.download)
-                return film;
-            const filePath = typeof args.filePath === "string" ? args.filePath : `./tday-launch-videos/${videoId}-${versionId}${fps === 30 ? "-30fps" : ""}.mp4`;
-            return { ...film, saved: true, ...(await saveVideo(mp4Url, filePath, Boolean(args.overwrite))) };
-        },
-    },
-    {
-        name: "tday_revise_launch_video",
-        title: "Revise launch video",
-        description: "Make a new cut of a ready launch video from notes, for example 'slow the ending down' or 'lead with the search box'. The kept film is edited to the notes, so the rest stays as it was. " +
-            "It spends tweak credits from the brand's organisation (13 credits for a standard film; tday_get_credit_prices has the full list), and a 402 means the balance cannot cover it. " +
-            "A 409 means a cut is already being made: poll until it finishes. The previous cut stays available while the new one is made. " + POLL_GUIDANCE,
-        inputSchema: argsObject({
-            videoId: videoIdSchema,
-            notes: z.string().trim().min(1).max(MAX_DIRECTION_CHARS).describe("What to change, in plain words."),
-        }),
-        outputSchema: outputSchemas.revise,
-        annotations: writeRemote,
-        handler: async (args, config) => {
-            const videoId = String(args.videoId);
-            const cut = await api(config, safePath("/api/showcase/videos/:videoId/regenerate", args), {
-                method: "POST",
-                body: JSON.stringify({ instructions: args.notes }),
-            });
-            return {
-                videoId,
-                ...(typeof cut?.versionId === "string" ? { versionId: cut.versionId } : {}),
-                status: "queued",
-                reviewUrl: reviewUrl(config, videoId),
-                next: `A new cut takes a few minutes. ${POLL_GUIDANCE}`,
-            };
-        },
-    },
-];
-async function saveSubject(args, config) {
-    if (typeof args.brandId !== "string" || typeof args.title !== "string" || typeof args.description !== "string") {
-        throw new Error("Pass featureId (from tday_list_features), or brandId with a title and description for a new subject.");
-    }
-    const saved = await api(config, "/api/showcase/features", {
-        method: "POST",
-        body: JSON.stringify({ brandId: args.brandId, title: args.title, description: args.description, typeId: null }),
-    });
-    const featureId = saved?.feature?.id;
-    if (typeof featureId !== "string")
-        throw new Error("tday could not start that film. Try again in a moment.");
-    return featureId;
-}
-function subjectSaved(title) {
-    return `The subject "${String(title)}" was saved on the brand's Launch page, where a film can be made from it later.`;
-}
-function launchAxes(args) {
-    return {
-        length: args.length,
-        narration: args.narration,
-        music: args.music,
-        ...(args.musicMood ? { musicMood: args.musicMood } : {}),
-        ...(args.voice ? { voiceId: args.voice } : {}),
-        ...(args.narrationStyle ? { narrationStyle: args.narrationStyle } : {}),
-        ...(args.direction ? { direction: args.direction } : {}),
-    };
-}
-function reviewUrl(config, videoId) {
-    return `${config.webBaseUrl}/showcase/review/${encodeURIComponent(videoId)}`;
-}
-async function newestReadyVersion(config, videoId) {
-    const payload = await api(config, safePath("/api/showcase/videos/:videoId", { videoId }));
-    const versionId = payload?.video?.versionId;
-    if (typeof versionId !== "string") {
-        throw new Error("This launch video has no finished cut yet. Poll tday_poll_launch_video until it is ready, then try again.");
-    }
-    return versionId;
-}
-function summarizeLaunchVideo(videoId, payload, url) {
-    const status = stringOr(payload.feature?.status, "unknown");
-    const first = Array.isArray(payload.versions) ? payload.versions[0] : undefined;
-    const latest = typeof first === "object" && first !== null ? first : null;
-    const latestStatus = stringOr(latest?.status, null);
-    const readyVersionId = stringOr(payload.video?.versionId, null);
-    const state = launchState(status, latestStatus);
-    const failureMessage = state === "failed" ? stringOr(latest?.failureMessage, null) : null;
-    const durationMs = typeof payload.video?.durationMs === "number" ? payload.video.durationMs : null;
-    return {
-        videoId,
-        ...(typeof payload.feature?.title === "string" ? { title: payload.feature.title } : {}),
-        status,
-        state,
-        terminal: state !== "in_progress",
-        latestVersion: latest
-            ? { versionId: stringOr(latest.versionId, null), versionNumber: latest.versionNumber ?? null, status: latestStatus }
-            : null,
-        ...(readyVersionId ? { readyVersionId } : {}),
-        ...(durationMs !== null ? { durationMs } : {}),
-        ...(failureMessage ? { failureMessage } : {}),
-        reviewUrl: url,
-        next: nextStep(state, readyVersionId),
-    };
-}
-function exportWaiting(answer, film) {
-    if (answer?.status === "rendering" || answer?.status === "none") {
-        const progress = typeof answer.progress === "number" ? answer.progress : null;
-        return {
-            ...film,
-            state: "rendering",
-            progress,
-            next: `The file is being rendered${progress === null ? "" : ` (${Math.round(progress * 100)}% done)`}. ${FIRST_EXPORT}. Call tday_get_launch_video_mp4 again in 20-30 seconds.`,
-        };
-    }
-    if (answer?.status === "failed") {
-        return {
-            ...film,
-            state: "failed",
-            error: typeof answer.error === "string" ? answer.error : "The file could not be rendered.",
-            next: "The file could not be rendered and spent no credits. Call tday_get_launch_video_mp4 again with retry: true to try again.",
-        };
-    }
-    return null;
-}
-function launchState(featureStatus, latestStatus) {
-    if (latestStatus === "ready")
-        return "ready";
-    if (latestStatus === "failed" || featureStatus === "failed")
-        return "failed";
-    if (!latestStatus && (featureStatus === "review" || featureStatus === "published"))
-        return "ready";
-    return "in_progress";
-}
-function nextStep(state, readyVersionId) {
-    if (state === "ready") {
-        return "Ready. Watch it at reviewUrl, call tday_get_launch_video_mp4 for the MP4 file (its first request renders the file, usually a minute or two), or tday_revise_launch_video to change it.";
-    }
-    if (state === "in_progress")
-        return "Still being made. Poll again in 20-30 seconds.";
-    return readyVersionId
-        ? "This cut failed and was not charged. The previous cut is still available: tday_get_launch_video_mp4 returns it, and tday_revise_launch_video can try the change again."
-        : "This film failed and was not charged. Start a new one with tday_create_launch_video.";
-}
-function stringOr(value, fallback) {
-    return typeof value === "string" && value ? value : fallback;
-}
-async function saveVideo(mp4Url, rawPath, overwrite) {
-    const url = validateImageUrl(mp4Url);
-    const filePath = await prepareOutputFilePath(rawPath, { overwrite });
-    const res = await fetch(url.href);
-    if (res.url)
-        validateImageUrl(res.url);
-    if (!res.ok)
-        throw new Error(`Failed to download the video: ${res.status} ${res.statusText}`);
-    const declared = Number(res.headers.get("content-length") ?? 0);
-    if (Number.isFinite(declared) && declared > MAX_VIDEO_BYTES) {
-        throw new Error(`The video exceeds the ${MAX_VIDEO_BYTES / 1024 / 1024}MB download limit. Use mp4Url instead.`);
-    }
-    const contentType = res.headers.get("content-type")?.toLowerCase();
-    if (contentType && !/^(video\/|application\/octet-stream|binary\/octet-stream)/.test(contentType)) {
-        throw new Error(`The download is not a video (content-type: ${contentType}).`);
-    }
-    const reader = res.body?.getReader();
-    if (!reader)
-        throw new Error("No response body from the video URL.");
-    const flags = constants.O_WRONLY |
-        constants.O_CREAT |
-        (overwrite ? constants.O_TRUNC : constants.O_EXCL) |
-        (constants.O_NOFOLLOW ?? 0);
-    const handle = await open(filePath, flags, 0o600);
-    let size = 0;
-    try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            size += value.byteLength;
-            if (size > MAX_VIDEO_BYTES) {
-                throw new Error(`The video exceeds the ${MAX_VIDEO_BYTES / 1024 / 1024}MB download limit. Use mp4Url instead.`);
-            }
-            await handle.write(value);
-        }
-    }
-    catch (error) {
-        await handle.close();
-        await rm(filePath, { force: true });
-        throw error;
-    }
-    finally {
-        reader.releaseLock();
-    }
-    await handle.close();
-    return { path: filePath, size };
-}