videobook 0.0.0-stage → 0.2.0

package/dist/media/descriptor.js

@@ -0,0 +1,157 @@
+import { MODEL_DISPLAY } from "@apicity/cost";
+import { modelEntry } from "./catalog.js";
+import { parseModelId } from "./model-id.js";
+import { claimedFields, resolveSlot } from "./ref-fields.js";
+import { wireSpec } from "./wire.js";
+import { enumValues, numberBounds, propertyAt, schemaTypes, stringMaxLength, toJsonSchema, } from "./json-schema.js";
+import { REF_ROLES, } from "./types.js";
+const PROMPT_CANDIDATES = ["prompt", "text", "instruction", "description"];
+const cache = new Map();
+export class UnknownModelError extends Error {
+    constructor(model) {
+        super(`Unknown model ${model}; call list_generation_models for available models`);
+        this.name = "UnknownModelError";
+    }
+}
+function displayTitle(entry, provider, apiId) {
+    if (entry.title)
+        return entry.title;
+    const table = MODEL_DISPLAY;
+    return table[provider]?.[apiId] ?? apiId;
+}
+function resolvePromptField(entry, input) {
+    if (entry.prompt === null)
+        return null;
+    if (entry.prompt !== undefined) {
+        if (!propertyAt(input, entry.prompt))
+            throw new Error(`${entry.id}: prompt field ${entry.prompt} is not in the apicity schema`);
+        return entry.prompt;
+    }
+    return PROMPT_CANDIDATES.find((field) => input.properties?.[field] !== undefined) ?? null;
+}
+function valueType(schema) {
+    const types = new Set(schemaTypes(schema).filter((type) => type !== "null"));
+    if (types.size === 0)
+        return "json";
+    if ([...types].every((type) => type === "boolean"))
+        return "boolean";
+    if ([...types].every((type) => type === "integer"))
+        return "integer";
+    if ([...types].every((type) => type === "integer" || type === "number"))
+        return "number";
+    if (types.has("string") && [...types].every((type) => type === "string" || type === "number" || type === "integer")) {
+        return types.has("number") || types.has("integer") ? "json" : "string";
+    }
+    return "json";
+}
+function readPath(value, path) {
+    let current = value;
+    for (const segment of path.split(".")) {
+        if (current === null || typeof current !== "object")
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function optionSpec(name, path, schema, required, defaults) {
+    const enumList = enumValues(schema);
+    const maxLength = stringMaxLength(schema);
+    const defaultValue = readPath(defaults, path) ?? schema.default;
+    return {
+        name,
+        path,
+        valueType: enumList.length > 0 && enumList.every((value) => typeof value === "string") ? "string" : valueType(schema),
+        required: required && defaultValue === undefined,
+        enumValues: enumList,
+        ...numberBounds(schema),
+        ...(maxLength !== undefined ? { maxLength } : {}),
+        ...(defaultValue !== undefined ? { defaultValue } : {}),
+        description: schema.description ?? "",
+    };
+}
+function resolveOptions(entry, input, excluded, fixed) {
+    const required = new Set(input.required ?? []);
+    const defaults = entry.defaults ?? {};
+    const options = [];
+    for (const [name, schema] of Object.entries(input.properties ?? {})) {
+        if (excluded.has(name) || name in fixed)
+            continue;
+        options.push(optionSpec(name, name, schema, required.has(name), defaults));
+    }
+    for (const [name, path] of Object.entries(entry.aliases ?? {})) {
+        const schema = propertyAt(input, path);
+        if (!schema)
+            throw new Error(`${entry.id}: alias ${name} -> ${path} is not in the apicity schema`);
+        options.push(optionSpec(name, path, schema, false, defaults));
+    }
+    return options;
+}
+function defaultModes(slots) {
+    return [{ id: "default", label: "Default", roles: slots.map((slot) => slot.role) }];
+}
+function resolveSlots(entry, input, promptField) {
+    const slots = [];
+    const used = new Set(promptField ? [promptField.split(".")[0]] : []);
+    for (const role of REF_ROLES) {
+        const slot = resolveSlot(role, input, entry);
+        if (!slot || slot.fields.some((field) => used.has(field.path)))
+            continue;
+        for (const field of slot.fields)
+            used.add(field.path);
+        slots.push(slot);
+    }
+    return slots;
+}
+function build(entry) {
+    const parsed = parseModelId(entry.id);
+    if (!parsed)
+        throw new Error(`Invalid model id in catalog: ${entry.id}`);
+    const wire = wireSpec(parsed);
+    if (!wire)
+        throw new Error(`${entry.id}: apicity has no request schema for this model`);
+    const input = toJsonSchema(wire.input);
+    const promptField = resolvePromptField(entry, input);
+    const slots = resolveSlots(entry, input, promptField);
+    const excluded = claimedFields(slots);
+    const promptTop = promptField?.split(".")[0];
+    if (promptTop && promptField === promptTop)
+        excluded.add(promptTop);
+    const aliasTops = new Set(Object.values(entry.aliases ?? {}).map((path) => path.split(".")[0]));
+    for (const top of aliasTops)
+        excluded.add(top);
+    if (promptTop)
+        excluded.add(promptTop);
+    return {
+        entry,
+        id: entry.id,
+        provider: parsed.provider,
+        apiId: parsed.apiId,
+        media: entry.media,
+        title: displayTitle(entry, parsed.provider, parsed.apiId),
+        wire,
+        promptField,
+        promptRequired: promptTop !== undefined && promptField === promptTop && (input.required ?? []).includes(promptTop),
+        slots,
+        options: resolveOptions(entry, input, excluded, wire.fixed),
+        modes: entry.modes ? [...entry.modes] : defaultModes(slots),
+    };
+}
+export function resolveModel(model) {
+    const cached = cache.get(model);
+    if (cached)
+        return cached;
+    const entry = modelEntry(model);
+    if (!entry)
+        throw new UnknownModelError(model);
+    const resolved = build(entry);
+    cache.set(model, resolved);
+    return resolved;
+}
+export function tryResolveModel(model) {
+    try {
+        return resolveModel(model);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/media/endpoints.js

@@ -0,0 +1,11 @@
+let endpoints = {};
+export function providerEndpoints() {
+    return endpoints;
+}
+export function configureProviderEndpoints(next) {
+    const previous = endpoints;
+    endpoints = { ...next };
+    return () => {
+        endpoints = previous;
+    };
+}

package/dist/media/frame-options.js

@@ -0,0 +1,18 @@
+import { modelEntry } from "./catalog.js";
+export const FRAME_ASPECT_DESCRIPTION = "Frame mode follows the first image’s aspect ratio (adaptive).";
+function hasFrameRefs(refs) {
+    if (refs === null || typeof refs !== "object" || Array.isArray(refs))
+        return false;
+    const record = refs;
+    return [record.first_frame, record.last_frame].some((value) => (typeof value === "string" && value.trim() !== "")
+        || (Array.isArray(value) && value.some((entry) => typeof entry === "string" && entry.trim() !== "")));
+}
+export function frameAspectRatio(model, input) {
+    const aspect = modelEntry(model)?.frameOptions?.aspect_ratio;
+    if (typeof aspect !== "string")
+        return undefined;
+    const mode = input.generationMode ?? input.mode;
+    if (mode === "r2v")
+        return undefined;
+    return mode === "i2v" || hasFrameRefs(input.refs) ? aspect : undefined;
+}

package/dist/media/insert-video-timing.js

@@ -0,0 +1,17 @@
+export function isInsertVideoModel(model) {
+    return model === "fal:minimax/h3-max/insert-video" || model === "minimax/h3-max/insert-video";
+}
+export function insertVideoTimingError(options, sourceDuration) {
+    const start = typeof options.start_time === "string" && options.start_time.trim() ? Number(options.start_time) : options.start_time;
+    const resume = typeof options.resume_time === "string" && options.resume_time.trim() ? Number(options.resume_time) : options.resume_time;
+    if (typeof start !== "number" || typeof resume !== "number" || !Number.isFinite(start) || !Number.isFinite(resume))
+        return null;
+    if (sourceDuration !== undefined && sourceDuration !== null && sourceDuration > 0) {
+        const seconds = Number(sourceDuration.toFixed(3));
+        if (start >= sourceDuration)
+            return `Replace from must be before the source video ends at ${seconds}s (currently ${start}s).`;
+        if (resume > sourceDuration)
+            return `Resume original must be within the ${seconds}s source video (currently ${resume}s).`;
+    }
+    return resume <= start ? "Resume original must be after Replace from. Both times refer to the original video." : null;
+}

package/dist/media/json-schema.js

@@ -0,0 +1,75 @@
+export function toJsonSchema(schema) {
+    const convert = schema.toJSONSchema;
+    if (!convert)
+        return {};
+    return convert.call(schema, { unrepresentable: "any", io: "input" });
+}
+function branches(schema) {
+    return schema.anyOf ?? schema.oneOf ?? [schema];
+}
+export function schemaTypes(schema) {
+    return branches(schema).flatMap((branch) => {
+        if (Array.isArray(branch.type))
+            return branch.type;
+        if (branch.type)
+            return [branch.type];
+        if (branch.const !== undefined)
+            return [typeof branch.const];
+        return [];
+    });
+}
+export function propertyAt(root, path) {
+    let current = root;
+    for (const segment of path.split(".")) {
+        if (!current)
+            return null;
+        if (/^\d+$/.test(segment)) {
+            current = branches(current).find((branch) => branch.items)?.items;
+            continue;
+        }
+        current = branches(current).find((branch) => branch.properties?.[segment])?.properties?.[segment];
+    }
+    return current ?? null;
+}
+export function isUrlObject(schema) {
+    if (!schema)
+        return false;
+    return branches(schema).some((branch) => branch.type === "object" && branch.properties?.url !== undefined);
+}
+export function isArraySchema(schema) {
+    return branches(schema).some((branch) => branch.type === "array");
+}
+export function arrayItems(schema) {
+    return branches(schema).find((branch) => branch.type === "array")?.items;
+}
+export function arrayBounds(schema) {
+    const array = branches(schema).find((branch) => branch.type === "array");
+    return { min: array?.minItems ?? 0, max: array?.maxItems ?? null };
+}
+export function enumValues(schema) {
+    const values = [];
+    for (const branch of branches(schema)) {
+        const literals = [...(branch.enum ?? []), ...(branch.const !== undefined ? [branch.const] : [])];
+        if (literals.length === 0)
+            return [];
+        for (const value of literals) {
+            if (typeof value === "string" || typeof value === "number")
+                values.push(value);
+        }
+    }
+    return [...new Set(values)];
+}
+export function numberBounds(schema) {
+    const numeric = branches(schema).find((branch) => branch.type === "number" || branch.type === "integer");
+    if (!numeric)
+        return {};
+    const minimum = numeric.minimum ?? numeric.exclusiveMinimum;
+    const maximum = numeric.maximum ?? numeric.exclusiveMaximum;
+    return {
+        ...(minimum !== undefined ? { minimum } : {}),
+        ...(maximum !== undefined ? { maximum } : {}),
+    };
+}
+export function stringMaxLength(schema) {
+    return branches(schema).find((branch) => branch.type === "string")?.maxLength;
+}

package/dist/media/legacy-task-types.js

@@ -0,0 +1,129 @@
+const LEGACY_IMAGE_TASK_TYPES = [
+    "nano_banana_image",
+    "fal_nano_banana_pro",
+    "fal_nano_banana_pro_edit",
+    "fal_nano_banana",
+    "fal_nano_banana_edit",
+    "fal_nano_banana_2",
+    "fal_nano_banana_2_edit",
+    "fal_nano_banana_2_lite",
+    "fal_nano_banana_2_lite_edit",
+    "nano_banana_2_1",
+    "qwen2_image_edit",
+    "qwen3_image_edit",
+    "qwen21_text_image",
+    "qwen21_image_edit",
+    "fal_qwen_image",
+    "fal_qwen_image_edit",
+    "fal_qwen3_image_edit",
+    "seedream_text_image",
+    "seedream_image",
+    "fal_seedream_v5_lite",
+    "fal_seedream_v5_lite_edit",
+    "fal_seedream_v5_flash_text_to_image",
+    "fal_seedream_v5_flash_edit",
+    "fal_seedream_v5_flash_layerize",
+    "kie_seedream_v5_flash_text_to_image",
+    "kie_seedream_v5_flash_image_to_image",
+    "kie_seedream_v5_flash_layer_decomposition",
+    "fal_bria_fibo_edit_1_5_product_holding",
+    "fal_bria_fibo_edit_1_5_virtual_try_on",
+    "fal_recraft_v4_1_flash_text_to_image",
+    "fal_ideogram_v4_5_text_to_image",
+    "fal_ideogram_v4_5_edit",
+    "fal_flux_3_text_to_image",
+    "fal_flux_3_edit",
+    "wan27_image",
+    "wan27_image_pro",
+    "fal_wan27",
+    "fal_wan27_edit",
+    "fal_wan27_pro",
+    "fal_wan27_pro_edit",
+    "alibaba_image",
+    "alibaba_image_pro",
+    "alibaba_qwen_image",
+    "alibaba_qwen_image_edit",
+    "grok_imagine_image",
+    "grok_imagine_text",
+    "fal_grok_imagine_image",
+    "fal_grok_imagine_image_edit",
+    "gpt_image",
+    "gpt_image_text",
+];
+const LEGACY_VIDEO_TASK_TYPES = [
+    "seedance2_video",
+    "fal_seedance2_i2v",
+    "fal_seedance2_t2v",
+    "fal_seedance2_r2v",
+    "fal_seedance2_fast_i2v",
+    "fal_seedance2_fast_t2v",
+    "fal_seedance2_fast_r2v",
+    "kling30_video",
+    "kling30_motion_control_video",
+    "kling30_omni_video",
+    "fal_kling_v3_pro_i2v",
+    "fal_kling_v3_pro_t2v",
+    "fal_kling_v3_standard_i2v",
+    "fal_kling_v3_standard_t2v",
+    "fal_wan27_t2v",
+    "fal_wan27_i2v",
+    "fal_wan27_r2v",
+    "fal_wan27_videoedit",
+    "fal_wan30_t2v",
+    "fal_wan30_i2v",
+    "fal_wan30_r2v",
+    "fal_wan30_prime_t2v",
+    "fal_wan30_prime_i2v",
+    "fal_wan30_prime_r2v",
+    "wan30_video",
+    "wan30_prime_video",
+    "wan27_t2v_video",
+    "wan27_i2v_video",
+    "wan27_videoedit_video",
+    "wan27_r2v_video",
+    "wan27_extend_video",
+    "grok_imagine_video",
+    "grok_imagine_t2v_video",
+    "xai_grok_imagine_video",
+    "xai_grok_imagine_ref_video",
+    "grok_imagine_extend_video",
+    "grok_imagine_upscale_video",
+    "fal_grok_imagine_video_i2v",
+    "fal_grok_imagine_video_r2v",
+    "fal_grok_imagine_video_extend",
+    "fal_grok_imagine_video_edit",
+    "fal_grok_imagine_video_v15_lite_image_to_video",
+    "fal_grok_imagine_video_v15_lite_text_to_video",
+    "happyhorse_t2v_video",
+    "happyhorse_i2v_video",
+    "happyhorse_ref_video",
+    "happyhorse_videoedit_video",
+    "minimax_h3_t2v_video",
+    "minimax_h3_i2v_video",
+    "minimax_h3_r2v_video",
+    "fal_minimax_h3_max_insert_video",
+    "fal_minimax_h3_max_recast",
+    "fal_minimax_h3_max_turbo_extend_video",
+    "vidu_q4_image_to_video",
+    "vidu_q4_reference_to_video",
+    "volcengine_lipsync_video",
+    "omnihuman_video",
+    "alibaba_video",
+];
+const LEGACY_MEDIA_BY_TASK_TYPE = new Map([
+    ...LEGACY_IMAGE_TASK_TYPES.map((taskType) => [taskType, "image"]),
+    ...LEGACY_VIDEO_TASK_TYPES.map((taskType) => [taskType, "video"]),
+]);
+export function legacyMediaForTaskType(taskType) {
+    return LEGACY_MEDIA_BY_TASK_TYPE.get(taskType) ?? null;
+}
+export function legacyMediaMeta(taskType, meta) {
+    const media = legacyMediaForTaskType(taskType);
+    if (!media)
+        return meta;
+    return {
+        ...meta,
+        media: meta.media ?? media,
+        model: meta.model ?? meta.apiModel ?? meta.falEndpointId ?? taskType,
+    };
+}

package/dist/media/listing.js

@@ -0,0 +1,24 @@
+import { MODEL_ENTRIES } from "./catalog.js";
+import { resolveModel } from "./descriptor.js";
+export function modelListing(model) {
+    return {
+        id: model.id,
+        title: model.title,
+        provider: model.provider,
+        media: model.media,
+        operations: model.entry.operations,
+        ...(model.entry.description ? { description: model.entry.description } : {}),
+        prompt: model.promptField ? { field: model.promptField, required: model.promptRequired } : null,
+        refs: model.slots.map(({ role, min, max }) => ({ role, min, max })),
+        modes: model.modes,
+        options: model.options,
+        hidden: model.entry.hidden === true,
+    };
+}
+export function listModels(filter = {}) {
+    return MODEL_ENTRIES
+        .filter((entry) => filter.includeHidden || !entry.hidden)
+        .filter((entry) => !filter.media || entry.media === filter.media)
+        .filter((entry) => !filter.operation || entry.operations.includes(filter.operation))
+        .map((entry) => resolveModel(entry.id));
+}

package/dist/media/model-id.js

@@ -0,0 +1,14 @@
+const PROVIDERS = ["kie", "fal", "xai", "alibaba", "elevenlabs"];
+function isProvider(value) {
+    return PROVIDERS.includes(value);
+}
+export function parseModelId(raw) {
+    const index = raw.indexOf(":");
+    if (index <= 0)
+        return null;
+    const provider = raw.slice(0, index);
+    const apiId = raw.slice(index + 1);
+    if (!isProvider(provider) || apiId.trim() === "")
+        return null;
+    return { id: raw, provider, apiId };
+}

package/dist/media/preview.js

@@ -0,0 +1,86 @@
+import { isPreviewPlaceholderUrl, previewPlaceholderUrl } from "../preview-payload.js";
+import { resolveModel, UnknownModelError } from "./descriptor.js";
+import { applyPromptDialect } from "./prompt-dialects.js";
+import { buildWireRequest } from "./request.js";
+import { normalizeRefs } from "./refs.js";
+import { isKieSunoModel, isKieVeoModel } from "./wire.js";
+import { REF_ROLES } from "./types.js";
+const ELEVENLABS_PATHS = {
+    "text-to-speech": "elevenlabs.v1.textToSpeech(voice_id, request)",
+    "sound-generation": "elevenlabs.v1.soundGeneration(request)",
+    music: "elevenlabs.v1.music(request)",
+    "video-to-music": "elevenlabs.v1.music.videoToMusic(request)",
+};
+function providerPath(model) {
+    switch (model.provider) {
+        case "kie":
+            if (isKieVeoModel(model.apiId))
+                return "kie.veo.post.api.v1.veo.generate(request, { otp })";
+            if (isKieSunoModel(model.apiId))
+                return "kie.suno.post.api.v1.generate(request)";
+            return "kie.post.api.v1.jobs.createTask(request, { otp })";
+        case "fal":
+            return "fal.post.v1.queue.submit()";
+        case "xai":
+            return "xai.post.v1.videos.generations(request, { otp })";
+        case "alibaba":
+            return "alibaba.post.api.v1.services.aigc.multimodalGeneration.generation(request)";
+        case "elevenlabs":
+            return ELEVENLABS_PATHS[model.apiId] ?? "elevenlabs";
+    }
+}
+function placeholderRefs(refs) {
+    const placeholders = {};
+    for (const role of REF_ROLES) {
+        const list = refs[role];
+        if (list)
+            placeholders[role] = list.map((ref) => /^https?:\/\//u.test(ref) ? ref : previewPlaceholderUrl(ref));
+    }
+    return placeholders;
+}
+function collectPlaceholders(value, path, found) {
+    if (typeof value === "string") {
+        if (isPreviewPlaceholderUrl(value)) {
+            const reference = decodeURIComponent(new URL(value).pathname.slice(1));
+            found.push({ path, reference: `@${reference}`, url: value });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectPlaceholders(item, `${path}[${index}]`, found));
+        return;
+    }
+    if (value === null || typeof value !== "object")
+        return;
+    for (const [key, child] of Object.entries(value))
+        collectPlaceholders(child, path ? `${path}.${key}` : key, found);
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function optionsOf(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function previewGeneration(args) {
+    let model;
+    try {
+        model = resolveModel(String(args.model ?? ""));
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof UnknownModelError ? error.message : String(error) };
+    }
+    const refs = normalizeRefs(args.refs);
+    const rawPrompt = stringOrUndefined(args.prompt);
+    const built = buildWireRequest(model, {
+        prompt: rawPrompt === undefined ? undefined : applyPromptDialect(model.entry.dialect, rawPrompt, refs),
+        refUrls: placeholderRefs(refs),
+        options: optionsOf(args.options),
+        mode: stringOrUndefined(args.mode),
+    });
+    if (!built.ok)
+        return built;
+    const payload = model.provider === "fal" ? { endpoint_id: model.apiId, input: built.request } : built.request;
+    const placeholders = [];
+    collectPlaceholders(payload, "", placeholders);
+    return { ok: true, preview: { model, providerPath: providerPath(model), payload, placeholders } };
+}

package/dist/media/prompt-dialects.js

@@ -0,0 +1,65 @@
+import { replaceHappyHorseAssetMentions, replaceNaturalAssetMentions, rewriteImageRefMentionsToBrackets, rewriteSeedanceAssetMentions, rewriteViduReferenceMentions, stripRefMentions, } from "../generation-reference-mentions.js";
+const SLOT_TOKEN = /@((image|video|audio)(\d+)|firstframe|lastframe)(?![\w-])/giu;
+function refsFor(refs, role) {
+    return (refs[role] ?? []).filter((ref) => !/^https?:\/\//u.test(ref));
+}
+function slotTarget(refs, token, kind, index) {
+    if (token.toLowerCase() === "firstframe")
+        return refsFor(refs, "first_frame")[0];
+    if (token.toLowerCase() === "lastframe")
+        return refsFor(refs, "last_frame")[0];
+    return refsFor(refs, kind.toLowerCase())[Number(index) - 1];
+}
+function expandSlotTokens(prompt, refs) {
+    return prompt.replace(SLOT_TOKEN, (match, token, kind, index) => {
+        const target = slotTarget(refs, token, kind, index);
+        return target ? `@${target}` : match;
+    });
+}
+function frames(refs) {
+    return [...refsFor(refs, "first_frame"), ...refsFor(refs, "last_frame")];
+}
+function natural(prompt, refs) {
+    return replaceNaturalAssetMentions(prompt, {
+        imageRefs: refsFor(refs, "image"),
+        videoRefs: refsFor(refs, "video"),
+        audioRefs: refsFor(refs, "audio"),
+    });
+}
+function seedance(prompt, refs) {
+    return rewriteSeedanceAssetMentions(prompt, {
+        imageRefs: refsFor(refs, "image"),
+        videoRefs: refsFor(refs, "video"),
+        audioRefs: refsFor(refs, "audio"),
+    });
+}
+function rewrite(dialect, prompt, refs) {
+    switch (dialect) {
+        case "plain":
+            return prompt;
+        case "natural":
+            return natural(prompt, refs);
+        case "natural_numbered":
+            return natural(prompt, refs).replace(/@image([1-9]\d*)\b/giu, "reference image $1");
+        case "natural_kinds":
+            return natural(prompt, refs).replace(/@(image|audio)([1-9]\d*)(?![\w-])/giu, (_match, kind, index) => `reference ${kind.toLowerCase()} ${index}`);
+        case "natural_source_video":
+            return replaceNaturalAssetMentions(prompt, {
+                imageRefs: refsFor(refs, "image"),
+                sourceVideoRef: refsFor(refs, "video")[0] ?? null,
+            });
+        case "seedance":
+            return stripRefMentions(seedance(prompt, refs), frames(refs));
+        case "strip_frames":
+            return stripRefMentions(prompt, [...frames(refs), ...refsFor(refs, "image")]);
+        case "brackets":
+            return rewriteImageRefMentionsToBrackets(prompt, refsFor(refs, "image"));
+        case "vidu":
+            return rewriteViduReferenceMentions(prompt, refsFor(refs, "image"), refsFor(refs, "audio"));
+        case "happyhorse_edit":
+            return replaceHappyHorseAssetMentions(prompt, refsFor(refs, "video")[0] ?? null, refsFor(refs, "image"));
+    }
+}
+export function applyPromptDialect(dialect, prompt, refs) {
+    return rewrite(dialect ?? "natural", expandSlotTokens(prompt, refs), refs).replace(/[ \t]{2,}/gu, " ").trim();
+}