@bitmagic/cli 0.1.64-dev.0 → 0.1.64-dev.10

package/dist/commands/generate.d.ts

@@ -4,7 +4,9 @@ import { type PropVoxelizeResult } from '../generate/prop.js';
 import { type VehicleInstallResult } from '../generate/vehicle.js';
 import { type GenerateModelResult } from '../generate/model.js';
 import { type AnimationFromVideoRun } from '../generate/animation-from-video.js';
+import { type VideoRun } from '../generate/video.js';
 import type { VoxelizeGlb } from '../assets/voxelize-glb.js';
+import type { KeepGlb } from '../assets/keep-glb.js';
 export interface SkyboxArgs {
     description: string;
     referenceImageUrl?: string;
@@ -60,6 +62,10 @@ export interface CharacterArgs {
     headScale?: string;
     /** citty's negative boolean: `--no-library` arrives as `false`; the flag has no positive form. */
     library?: boolean;
+    /** Absent = the generator's default (true); the command fills it from the project's art style. */
+    voxelize?: boolean;
+    /** Asset Forger image-to-mesh model; absent = the Forger default. */
+    meshModel?: string;
 }
 export declare function buildCharacterBody(args: CharacterArgs): Record<string, unknown>;
 export interface AnimationArgs {
@@ -101,7 +107,32 @@ export interface AnimationVideoArgs {
     /** Any of the authored-spec flags, to refuse the two forms being mixed. */
     spec?: string;
     family?: string;
+    /** The prompt lane, to refuse a clip and a description being given at once. */
+    videoPrompt?: string;
 }
+export interface AnimationPromptArgs extends Omit<AnimationVideoArgs, 'video'> {
+    videoPrompt: string;
+    videoDuration?: number;
+    video?: string;
+}
+/** A `--video-prompt` run: everything `--video` carries, plus the clip to generate first. */
+export interface AnimationFromPromptRun {
+    /** What the source clip should show, in the creator's words. */
+    description: string;
+    /** Source clip length in seconds; billed per second by the video leg. */
+    durationSeconds: number;
+    run: AnimationFromVideoRun;
+}
+/**
+ * `--video-prompt` is `--video` with the clip generated instead of filmed, so it
+ * shares every downstream flag and refuses the same combinations. The extra
+ * refusal is the duration floor: `generate video` will happily make a 1 s clip,
+ * and Uthana will then reject it, which would bill the creator for footage that
+ * never had a chance.
+ */
+export declare function buildAnimationFromPromptRun(args: AnimationPromptArgs): AnimationFromPromptRun;
+/** `--video` takes either a local file or an already-public clip URL. */
+export declare function isHttpUrl(value: string): boolean;
 /**
  * `--video` is a different generator from the authored spec: the clip comes from a person, not
  * a parameter file, so the two flag sets cannot be combined and the spec flags are refused here
@@ -111,6 +142,14 @@ export declare function buildAnimationVideoRun(args: AnimationVideoArgs): Animat
 export interface GenerateRunDeps extends CommandRunDeps {
     /** Test-only override for the headless bake, so the lane runs without Chrome. */
     voxelize?: VoxelizeGlb;
+    /** Whether a person is at the keyboard; injected so the clip-review gate is testable. */
+    interactive?: () => boolean;
+    /** Reads one line of confirmation. Injected for the same reason. */
+    ask?: (question: string) => Promise<string>;
+    /** Draws the contact sheet in the terminal when it can. Returns whether it drew. */
+    renderImage?: (bytes: Buffer) => boolean;
+    /** Injected in tests so the kept-mesh lane (`--keep-glb` / low-poly projects) runs without a network. */
+    keepGlbUpload?: KeepGlb;
 }
 /**
  * Runs one `bitmagic generate <subcommand>`: requests the asset, then applies the returned
@@ -221,6 +260,9 @@ export declare function runPropGeneration(options: {
     voxelGrid?: number;
     /** `--no-materials`: leave the asset matte rather than classifying it after the bake. */
     materials?: boolean;
+    /** `--keep-glb` / `--voxelize`; absent follows game.json artStyle. */
+    keepGlb?: boolean;
+    voxelize?: boolean;
     json: boolean;
     deps?: GenerateRunDeps;
 }): Promise<PropVoxelizeResult>;
@@ -270,6 +312,9 @@ export declare function runModelGeneration(options: {
     voxelGrid?: number;
     /** `--no-materials`: leave the asset matte rather than classifying it after the bake. */
     materials?: boolean;
+    /** `--keep-glb` / `--voxelize`; absent follows game.json artStyle. */
+    keepGlb?: boolean;
+    voxelize?: boolean;
     json: boolean;
     deps?: GenerateRunDeps;
 }): Promise<GenerateModelResult>;
@@ -279,4 +324,52 @@ export declare function runModelGeneration(options: {
  * job record, so the dev view shows it beside every other generation.
  */
 export declare function runAnimationFromVideo(run: AnimationFromVideoRun, json: boolean, deps?: GenerateRunDeps): Promise<void>;
+/**
+ * Look at the generated clip before the capture leg spends on it.
+ *
+ * The clip costs a few sparks and the Uthana leg costs fifteen more, so the expensive half is the
+ * one worth gating. What decides "is this usable" is visible in stills — is it one person, are they
+ * whole and centred, did the model cut to a close-up halfway — so the contact sheet
+ * `generate video` already writes is enough to judge it, and the clip is a real asset by now, so a
+ * creator who wants to watch it move can do that in the dev view while this waits.
+ *
+ * Returns whether to go on. Everything except the question is best-effort: a missing ffmpeg or a
+ * failed download costs a note, never the generation that has already been paid for.
+ */
+export declare function confirmSourceClip(options: {
+    root: string;
+    assetId: string;
+    videoUrl: string;
+    durationSeconds: number;
+    /** `--yes`, or any lane with nobody to ask. Skips the question, never the frames. */
+    skipPrompt: boolean;
+    /** `--no-contact-sheet`: skip the download and the frames, keep the question. */
+    contactSheet: boolean;
+    deps: GenerateRunDeps;
+}): Promise<boolean>;
+/**
+ * The `--video-prompt` lane: text -> clip -> motion, the two existing job lanes run back to back.
+ *
+ * There is no chained endpoint behind this — asset-forger has one route that makes a video and
+ * another that reads one, and this is the seam between them. Both legs bill under their own
+ * existing key (`generate-video` per second, `generate-animation-from-video` flat), the way
+ * design-vehicle prices its chained image sub-generations rather than minting a composite.
+ *
+ * Both asset rows are kept. The clip is a real `type: 'video'` asset the creator can play back
+ * or reuse as a cutscene, and keeping it is also what makes a leg-2 failure recoverable: the
+ * footage is already paid for, so the error hands back a `--video <url>` retry instead of asking
+ * for the whole thing again.
+ */
+export declare function runAnimationFromPrompt(prompt: AnimationFromPromptRun, json: boolean, deps?: GenerateRunDeps, creatorPrompt?: string, options?: {
+    yes?: boolean;
+    contactSheet?: boolean;
+}): Promise<void>;
+/**
+ * Job-shaped rather than streamed (see generate/video.ts), so it cannot share `runAssetGeneration`;
+ * it does share the job record, so the dev view shows it beside every other generation.
+ */
+export declare function runVideoGeneration(run: VideoRun, json: boolean, options?: {
+    deps?: GenerateRunDeps;
+    contactSheet?: boolean;
+}): Promise<void>;
 export declare const generateCommand: import("citty").CommandDef<import("citty").ArgsDef>;