Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
/**
* Zod schemas for the FableLoom routes. Length caps come straight from
* LOOM_LIMITS (the sanitizer's constants) so the door check and the
* enforcement layer can never drift — the sprite/creative-commission
* validation modules follow the same import-the-service-constants pattern.
*/
import { z } from 'zod';
import { isShotSpeakerCue } from './fableLoomShots.js';
import { LOOM_LIMITS } from './fableLoomLimits.js';
import { characterEvolutionListSchema } from './characterEvolutionValidation.js';
import { LOOM_FORMATS } from './fableLoomFormats.js';
import {
FABLELOOM_AUDIO_TARGETS,
FABLELOOM_HOLD_ROTATION_MODES,
FABLELOOM_PLAYBACK_MODES,
FABLELOOM_PROTAGONIST_PRESENCE,
} from './fableLoomPlayback.js';
import {
FABLELOOM_AUDIENCE_CONNECTION_STATES,
FABLELOOM_PARTICIPATION_MODES,
} from './fableLoomParticipation.js';
import {
FABLELOOM_ASSET_TYPES,
FABLELOOM_PRODUCTION_MODES,
FABLELOOM_RENDER_FORMAT_IDS,
} from './fableLoomProduction.js';
import {
FABLELOOM_CHALLENGE_PHASES,
FABLELOOM_PLOT_POINT_KINDS,
} from './fableLoomOutline.js';
import { FABLELOOM_PLAYTEST_LIMITS } from './fableLoomPlaytest.js';
import { EFFORT_LEVELS } from './providerModels.js';
import { QUEUEABLE_IMAGE_MODES, VIDEO_GEN_MODES } from './generationModes.js';
import { llmRoutePinSchema } from './llmRoutePin.js';
import { seriesDesignSchema } from './sharedSchemas.js';
const name = z.string().trim().min(1).max(LOOM_LIMITS.NAME_MAX);
const logline = z.string().max(LOOM_LIMITS.LOGLINE_MAX);
const premise = z.string().max(LOOM_LIMITS.PREMISE_MAX);
const styleNotes = z.string().max(LOOM_LIMITS.STYLE_NOTES_MAX);
const participationMode = z.enum(FABLELOOM_PARTICIPATION_MODES);
const audienceCommunicationMedium = z.string().max(LOOM_LIMITS.AUDIENCE_COMMUNICATION_MEDIUM_MAX);
const refId = z.string().max(LOOM_LIMITS.REF_ID_MAX).nullable();
const title = z.string().max(LOOM_LIMITS.EPISODE_TITLE_MAX);
const synopsis = z.string().max(LOOM_LIMITS.SYNOPSIS_MAX);
const nodeIdStr = z.string().min(1).max(80);
const format = z.enum(LOOM_FORMATS);
export const exportOptionsSchema = z.object({
episodeIds: z.array(z.string().min(1).max(80)).min(1).max(LOOM_LIMITS.EPISODES_MAX)
.refine(ids => new Set(ids).size === ids.length, 'Episode selections must be unique.').optional(),
includePlayer: z.boolean().default(false),
includeCharacters: z.boolean().default(false),
includeVoice: z.boolean().default(false),
allowDraft: z.boolean().default(false),
mediaProfile: z.enum(['source', 'web-720p', 'web-1080p']).default('source'),
includeWebm: z.boolean().default(false),
}).strict();
// The loom's pinned play routing is the shared per-record LLM route pin
// (`server/lib/llmRoutePin.js`), nullable as a whole so the UI can clear it
// outright. Its `effort` is the shared ladder enum rather than a free string —
// the runner would clamp an unknown level silently, and the door check is
// where a typo should surface.
const playSettings = llmRoutePinSchema.nullable();
const optionalRenderMode = (values) => z.preprocess(
(value) => value == null || value === '' || value === 'auto' ? null : value,
z.enum(values).nullable().optional(),
);
const optionalRenderModel = z.preprocess(
(value) => value == null || value === '' ? null : value,
z.string().trim().min(1).max(64).nullable().optional(),
);
const optionalRenderEffort = z.preprocess(
(value) => value == null || value === '' ? null : value,
z.enum(EFFORT_LEVELS).nullable().optional(),
);
// Format, provider, and model preferences travel together as one loom-level
// pin. The provider/model fields are nullable so the UI can explicitly return
// to the install default without omitting a sibling preference accidentally.
const renderSettings = z.object({
formatId: z.enum(FABLELOOM_RENDER_FORMAT_IDS),
imageMode: optionalRenderMode(QUEUEABLE_IMAGE_MODES),
imageModel: optionalRenderModel,
videoMode: optionalRenderMode(VIDEO_GEN_MODES),
videoModel: optionalRenderModel,
effort: optionalRenderEffort,
});
const productionStatus = z.object({
editorialApprovedAt: z.string().max(80).nullable().optional(),
editorialApprovalSource: z.enum(['manual', 'autopilot']).nullable().optional(),
deliveryApprovedAt: z.string().max(80).nullable().optional(),
});
const planItemId = z.string().min(1).max(80).optional();
const planEpisodeId = z.string().min(1).max(80).nullable().optional();
const planItemFields = {
id: planItemId,
title: z.string().max(LOOM_LIMITS.PLAN_ITEM_TITLE_MAX),
description: z.string().max(LOOM_LIMITS.PLAN_ITEM_DESCRIPTION_MAX),
};
const seriesPlan = z.object({
storyArc: z.string().max(LOOM_LIMITS.STORY_ARC_MAX),
plotPoints: z.array(z.object({
...planItemFields,
kind: z.enum(FABLELOOM_PLOT_POINT_KINDS).optional(),
episodeId: planEpisodeId,
})).max(LOOM_LIMITS.PLAN_ITEMS_MAX),
sideQuests: z.array(z.object({
...planItemFields,
status: z.enum(['idea', 'planned', 'active', 'resolved']),
startEpisodeId: planEpisodeId,
endEpisodeId: planEpisodeId,
})).max(LOOM_LIMITS.PLAN_ITEMS_MAX),
deliveryOptions: z.object({
overnightVoicemails: z.boolean().optional(),
nextSeasonTeaser: z.boolean().optional(),
}).optional(),
interEpisodeVoicemails: z.array(z.object({
id: planItemId,
fromEpisodeId: planEpisodeId,
toEpisodeId: planEpisodeId,
title: z.string().max(LOOM_LIMITS.PLAN_ITEM_TITLE_MAX),
transcript: z.string().max(LOOM_LIMITS.DELIVERY_MESSAGE_MAX),
})).max(LOOM_LIMITS.EPISODES_MAX).optional(),
nextSeasonTeaser: z.object({
title: z.string().max(LOOM_LIMITS.PLAN_ITEM_TITLE_MAX),
transcript: z.string().max(LOOM_LIMITS.DELIVERY_MESSAGE_MAX),
}).nullable().optional(),
// The OPTIONAL five-stage character evolution lens per character (#6440).
// Optional here so every pre-#6440 client keeps saving a plan unchanged;
// omitting it on a PATCH clears the lenses, because the plan rides a
// wholesale-`seriesPlan` PATCH (the sync path is where an absent key
// preserves — see preserveLegacyCharacterEvolutions).
characterEvolutions: characterEvolutionListSchema.optional(),
// Omission clears on the wholesale plan PATCH; null is also accepted as an
// explicit clear and is preserved on current-version sync payloads.
seriesDesign: seriesDesignSchema.nullable().optional(),
});
const outlineTransitionSchema = z.object({
targetKey: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX),
intent: z.string().max(LOOM_LIMITS.INTENT_MAX),
});
const outlineValidationSchema = z.object({
status: z.enum(['draft', 'valid', 'invalid']).optional(),
issues: z.array(z.object({
code: z.string().max(80).optional(),
severity: z.enum(['error', 'warning']).optional(),
message: z.string().max(LOOM_LIMITS.OUTLINE_ISSUE_MESSAGE_MAX),
sceneKey: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX).optional(),
transitionIndex: z.number().int().min(0).optional(),
})).max(LOOM_LIMITS.OUTLINE_ISSUES_MAX).optional(),
validatedAt: z.string().max(80).optional(),
}).optional();
const storyOutline = z.object({
version: z.number().int().min(1).max(1).optional(),
startKey: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX).nullable().optional(),
scenes: z.array(z.object({
key: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX),
title: z.string().max(LOOM_LIMITS.NODE_TITLE_MAX).optional(),
summary: z.string().max(LOOM_LIMITS.OUTLINE_SUMMARY_MAX).optional(),
plotPointId: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX).nullable().optional(),
challengePhase: z.enum(FABLELOOM_CHALLENGE_PHASES).nullable().optional(),
playbackMode: z.enum(['cut', 'decision']).optional(),
audienceConnection: z.enum(['connected', 'disconnected']).optional(),
protagonistPresence: z.enum(FABLELOOM_PROTAGONIST_PRESENCE).optional(),
isEnding: z.boolean().optional(),
endingLabel: z.string().max(LOOM_LIMITS.ENDING_LABEL_MAX).optional(),
transitions: z.array(outlineTransitionSchema).max(LOOM_LIMITS.OUTLINE_TRANSITIONS_MAX).optional(),
})).max(LOOM_LIMITS.OUTLINE_SCENES_MAX),
validation: outlineValidationSchema,
}).nullable().optional();
// Index filter. `?seriesId=` scopes the list to the looms soft-linked to one
// pipeline series (the series detail page's "Branching narratives" card). An
// empty value is a no-op filter, not a 400 — a UI that builds the query from a
// possibly-unset id should not have to branch on it.
export const loomListQuerySchema = z.object({
seriesId: z.string().max(LOOM_LIMITS.REF_ID_MAX).optional(),
});
export const loomCreateSchema = z.object({
name,
logline: logline.optional(),
premise: premise.optional(),
styleNotes: styleNotes.optional(),
participationMode: participationMode.optional(),
audienceCommunicationMedium: audienceCommunicationMedium.optional(),
format: format.optional(),
playSettings: playSettings.optional(),
renderSettings: renderSettings.optional(),
seriesPlan: seriesPlan.optional(),
protagonistCharacterId: refId.optional(),
protagonistWardrobeId: refId.optional(),
protagonistWardrobeLocked: z.boolean().optional(),
universeId: refId.optional(),
seriesId: refId.optional(),
});
export const loomPatchSchema = z.object({
name: name.optional(),
logline: logline.optional(),
premise: premise.optional(),
styleNotes: styleNotes.optional(),
participationMode: participationMode.optional(),
audienceCommunicationMedium: audienceCommunicationMedium.optional(),
format: format.optional(),
playSettings: playSettings.optional(),
renderSettings: renderSettings.optional(),
productionStatus: productionStatus.optional(),
seriesPlan: seriesPlan.optional(),
protagonistCharacterId: refId.optional(),
protagonistWardrobeId: refId.optional(),
protagonistWardrobeLocked: z.boolean().optional(),
universeId: refId.optional(),
seriesId: refId.optional(),
});
export const episodeCreateSchema = z.object({
title: title.optional(),
synopsis: synopsis.optional(),
});
export const episodePatchSchema = z.object({
title: title.optional(),
synopsis: synopsis.optional(),
number: z.number().int().min(1).max(9999).optional(),
startNodeId: nodeIdStr.nullable().optional(),
storyOutline,
});
const transitionFields = {
targetNodeId: nodeIdStr,
intent: z.string().max(LOOM_LIMITS.INTENT_MAX),
triggers: z.array(z.string().max(LOOM_LIMITS.TRIGGER_MAX)).max(LOOM_LIMITS.TRIGGERS_MAX).optional(),
description: z.string().max(LOOM_LIMITS.TRANSITION_DESC_MAX).optional(),
};
// Whole-array replace on the node PATCH. Kept for back-compat with clients
// that predate the transition sub-resources (`id` is echoed back so a replace
// preserves the rows it did not change); new writers use the sub-resources.
const transitionSchema = z.object({
id: z.string().max(80).optional(),
...transitionFields,
});
const visualCanonSchema = z.object({
mode: z.enum(['locked', 'draft']).optional(),
characterAppearances: z.array(z.object({
characterId: refId.unwrap(),
wardrobeId: refId.unwrap().nullable().optional(),
referenceImage: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*\.(png|jpg|jpeg|webp)$/i).nullable().optional(),
expression: z.string().max(LOOM_LIMITS.VISUAL_NOTE_MAX).optional(),
continuityNotes: z.string().max(LOOM_LIMITS.VISUAL_NOTE_MAX).optional(),
})).max(LOOM_LIMITS.VISUAL_BINDINGS_MAX).optional(),
placeId: refId.optional(),
objectIds: z.array(refId.unwrap()).max(LOOM_LIMITS.VISUAL_BINDINGS_MAX).optional(),
continuitySourceNodeId: nodeIdStr.nullable().optional(),
shotNotes: z.string().max(LOOM_LIMITS.VISUAL_NOTE_MAX).optional(),
storyboardImageApproved: z.boolean().optional(),
}).nullable();
// Sub-resource POST: no `id` — the server mints it.
export const transitionCreateSchema = z.object(transitionFields);
// Sub-resource PATCH: every field optional, but `intent` may be cleared to ''
// (a path can legitimately carry only trigger phrasings), so `.optional()`
// rather than a min length is what distinguishes absent from cleared.
export const transitionPatchSchema = z.object({
targetNodeId: nodeIdStr.optional(),
intent: transitionFields.intent.optional(),
triggers: transitionFields.triggers,
description: transitionFields.description,
});
const audioIntervalSchema = z.object({
startMs: z.number().min(0),
endMs: z.number().min(0),
characterId: z.string().max(80).optional(),
speaker: z.string().max(100).optional(),
blocking: z.boolean().optional(),
name: z.string().max(100).optional(),
});
export const audioOccupancySchema = z.object({
durationMs: z.number().min(0).optional(),
characterDialogue: z.array(audioIntervalSchema).max(LOOM_LIMITS.AUDIO_INTERVALS_MAX).optional(),
music: z.array(audioIntervalSchema).max(LOOM_LIMITS.AUDIO_INTERVALS_MAX).optional(),
effects: z.array(audioIntervalSchema).max(LOOM_LIMITS.AUDIO_INTERVALS_MAX).optional(),
clipping: z.boolean().optional(),
clipped: z.boolean().optional(),
clippingDetected: z.boolean().optional(),
peakDb: z.number().optional(),
truePeakDb: z.number().optional(),
safeForLiveVoice: z.boolean().optional(),
});
export const playbackAssetsSchema = z.object({
entryVideoHistoryId: z.string().max(200).nullable().optional(),
holdLoopVideoHistoryIds: z.array(z.string().max(200)).max(LOOM_LIMITS.HOLD_LOOPS_MAX).optional(),
exitByTransition: z.record(z.string(), z.string().max(200)).optional(),
audioOccupancy: z.record(z.string(), audioOccupancySchema).optional(),
provenance: z.record(z.string(), z.any()).nullable().optional(),
visualConditioningByAsset: z.record(z.string().max(200), z.record(z.string(), z.any())).optional(),
}).nullable();
export const interactionWindowSchema = z.object({
enabled: z.boolean().optional(),
protagonistCharacterId: z.string().max(LOOM_LIMITS.REF_ID_MAX).nullable().optional(),
protagonistPresence: z.enum(FABLELOOM_PROTAGONIST_PRESENCE).optional(),
audioTarget: z.enum(FABLELOOM_AUDIO_TARGETS).optional(),
ambientDuckDb: z.number().min(LOOM_LIMITS.AMBIENT_DUCK_DB_MIN).max(LOOM_LIMITS.AMBIENT_DUCK_DB_MAX).optional(),
holdLoopRotation: z.enum(FABLELOOM_HOLD_ROTATION_MODES).optional(),
}).nullable();
export const shotMetadataSchema = z.object({
dramaticSceneId: z.string().min(1).max(80), dramaticSceneTitle: z.string().max(300),
durationSeconds: z.number().min(5).max(10), framing: z.string().max(500),
});
const nodeFields = {
shot: shotMetadataSchema.nullable().optional(),
title: z.string().max(LOOM_LIMITS.NODE_TITLE_MAX).optional(),
prose: z.string().max(LOOM_LIMITS.PROSE_MAX).optional(),
plotPointId: z.string().max(LOOM_LIMITS.OUTLINE_KEY_MAX).nullable().optional(),
challengePhase: z.enum(FABLELOOM_CHALLENGE_PHASES).nullable().optional(),
imagePrompt: z.string().max(LOOM_LIMITS.IMAGE_PROMPT_MAX).optional(),
videoPrompt: z.string().max(LOOM_LIMITS.VIDEO_PROMPT_MAX).optional(),
cameraMovement: z.string().max(LOOM_LIMITS.CAMERA_MOVEMENT_MAX).optional(),
visualCanon: visualCanonSchema.optional(),
playbackMode: z.enum(FABLELOOM_PLAYBACK_MODES).optional(),
audienceConnection: z.enum(FABLELOOM_AUDIENCE_CONNECTION_STATES).optional(),
protagonistPresence: z.enum(FABLELOOM_PROTAGONIST_PRESENCE).nullable().optional(),
videoHistoryId: z.string().max(200).nullable().optional(),
playbackAssets: playbackAssetsSchema.optional(),
interactionWindow: interactionWindowSchema.optional(),
isEnding: z.boolean().optional(),
endingLabel: z.string().max(LOOM_LIMITS.ENDING_LABEL_MAX).optional(),
pos: z.object({ x: z.number(), y: z.number() }).nullable().optional(),
transitions: z.array(transitionSchema).max(LOOM_LIMITS.TRANSITIONS_MAX).optional(),
};
export const nodeCreateSchema = z.object({
...nodeFields,
// Optionally wire the new scene in as a branch of an existing one.
fromNodeId: nodeIdStr.optional(),
fromIntent: z.string().max(LOOM_LIMITS.INTENT_MAX).optional(),
});
export const nodePatchSchema = z.object(nodeFields);
export const falVideoAutomationSchema = z.object({
// This is the fully composed browser-tool prompt (scene direction, camera,
// style, and avoid block), not just the persisted node.videoPrompt leaf.
prompt: z.string().trim().min(1).max(12_000),
aspectRatio: z.enum(['16:9', '9:16', '1:1', '4:3']).optional(),
});
// A per-call pick carries the same three dimensions as the saved pin.
const llmPickFields = llmRoutePinSchema.shape;
const aiRunFields = { ...llmPickFields, operationId: z.string().uuid().optional() };
export const weaveSchema = z.object({
guidance: z.string().max(4000).optional(),
replace: z.boolean().optional(),
expandFromOutline: z.boolean().optional(),
...aiRunFields,
});
export const outlineGenerateSchema = z.object({
guidance: z.string().max(4000).optional(),
...aiRunFields,
});
export const outlineReviewSchema = z.object({ ...aiRunFields });
export const outlineValidateSchema = z.object({});
export const branchSchema = z.object({
guidance: z.string().max(4000).optional(),
branchCount: z.number().int().min(1).max(4).optional(),
...aiRunFields,
});
export const reviewSchema = z.object({ ...aiRunFields });
// A turn is EITHER a reader's free text (matched to a path by the play stage)
// or a path the reader took outright — a tapped choice needs no intent
// mapping, so it carries the transition id and no LLM call happens at all.
const playMessageSchema = z.string().min(1).max(1000);
export const playTurnSchema = z.object({
nodeId: nodeIdStr,
message: playMessageSchema.optional(),
transitionId: z.string().min(1).max(80).optional(),
transcript: z.array(z.object({
role: z.enum(['reader', 'narrator']),
text: z.string().max(4000),
})).max(50).optional(),
...aiRunFields,
}).refine((body) => body.message || body.transitionId, {
message: 'A play turn needs either a message or a transitionId',
path: ['message'],
});
export const hostedTextTurnSchema = z.object({ text: playMessageSchema });
export const reformatSchema = z.object({
format,
...aiRunFields,
});
export const feedbackSchema = z.object({
feedback: z.string().trim().min(1).max(LOOM_LIMITS.FEEDBACK_MAX),
...aiRunFields,
});
export const seriesPlanReviewSchema = z.object({ ...aiRunFields });
export const seriesPlanGenerateSchema = z.object({ ...aiRunFields });
export const seriesPlanFeedbackSchema = z.object({
feedback: z.string().trim().min(1).max(LOOM_LIMITS.FEEDBACK_MAX),
...aiRunFields,
});
export const editorialRemediateSchema = z.object({
guidance: z.string().max(LOOM_LIMITS.FEEDBACK_MAX).optional(),
...aiRunFields,
});
export const playthroughReviewSchema = z.object({
aiReview: z.boolean().optional().default(true),
maxPaths: z.number().int().min(1).max(FABLELOOM_PLAYTEST_LIMITS.MAX_PATHS).optional(),
...aiRunFields,
});
export const editorialAutopilotStartSchema = z.object({
mode: z.enum(['series', 'planning']).optional(),
maxRounds: z.number().int().min(1).max(LOOM_LIMITS.EDITORIAL_AUTOPILOT_ROUNDS_MAX).optional(),
maxPaths: z.number().int().min(1).max(FABLELOOM_PLAYTEST_LIMITS.MAX_PATHS).optional(),
// Opt-in post-mortem over content-free run counters. A confident PortOS
// verdict queues an approval-gated CoS task; healthy/canceled runs spend
// nothing, and the story itself never crosses into the task brief.
selfImprove: z.boolean().optional(),
...llmPickFields,
});
export const hostedSessionCreateSchema = z.object({
audioTarget: z.enum(FABLELOOM_AUDIO_TARGETS).optional(),
startNodeId: nodeIdStr.optional(),
ttlMinutes: z.number().int().min(1).max(180).optional(),
});
export const hostedSessionPatchSchema = z.object({
audioTarget: z.enum(FABLELOOM_AUDIO_TARGETS).optional(),
currentNodeId: nodeIdStr.optional(),
playbackPhase: z.enum(['entry', 'hold', 'exit', 'ended']).optional(),
activeHoldIndex: z.number().int().min(0).max(10).optional(),
});
export const hostedPlaybackUpdateSchema = z.object({
nodeId: hostedSessionPatchSchema.shape.currentNodeId,
phase: hostedSessionPatchSchema.shape.playbackPhase,
activeHoldIndex: hostedSessionPatchSchema.shape.activeHoldIndex,
});
export const hostedSpeechDoneSchema = z.object({
turnId: z.string().uuid(),
status: z.enum(['ended', 'failed', 'aborted']),
});
export const productionPlanSchema = z.object({
mode: z.enum(FABLELOOM_PRODUCTION_MODES).optional(),
imageMode: z.enum(QUEUEABLE_IMAGE_MODES).optional(),
imageModel: z.string().trim().min(1).max(200).optional(),
videoMode: z.enum(VIDEO_GEN_MODES).optional(),
videoModel: z.string().trim().min(1).max(200).optional(),
effort: z.enum(EFFORT_LEVELS).optional(),
});
export const productionBatchCreateSchema = z.object({
mode: z.enum(FABLELOOM_PRODUCTION_MODES).optional(),
assetTypes: z.array(z.enum(FABLELOOM_ASSET_TYPES)).max(20).optional(),
nodeIds: z.array(nodeIdStr).max(LOOM_LIMITS.NODES_MAX).optional(),
imageMode: z.enum(QUEUEABLE_IMAGE_MODES).optional(),
imageModel: z.string().trim().min(1).max(200).optional(),
videoMode: z.enum(VIDEO_GEN_MODES).optional(),
videoModel: z.string().trim().min(1).max(200).optional(),
effort: z.enum(EFFORT_LEVELS).optional(),
});
export const continuityReviewSchema = z.object({});
export const shotDraftSchema = z.object({
visibleCharacterIds: z.array(z.string().min(1).max(80)).max(32).optional(),
protagonistPresence: z.enum(['onscreen', 'offscreen']).optional(),
title: z.string().min(1).max(300), durationSeconds: z.number().min(5).max(10),
action: z.string().min(1).max(1200), framing: z.string().min(1).max(500),
dialogue: z.array(z.object({ speaker: z.string().min(1).max(70).refine((value) => isShotSpeakerCue(value.toUpperCase()), 'Use a screenplay speaker cue without line breaks or unsupported punctuation'), text: z.string().min(1).max(500) })).max(6),
imagePrompt: z.string().min(1).max(2000), videoPrompt: z.string().min(1).max(4000),
});
export const shotGroupsSchema = z.array(z.object({ sceneId: z.string().min(1).max(80), shots: z.array(shotDraftSchema).min(1).max(40) })).min(1).max(200);
export const shotAutopilotSchema = outlineGenerateSchema.extend({ maxRounds: z.number().int().min(1).max(3).optional(), apply: z.boolean().optional() });
export const shotRunStartSchema = shotAutopilotSchema.extend({ resume: z.boolean().optional() });
export const shotApplySchema = z.object({ sourceFingerprint: z.string().length(64), groups: shotGroupsSchema });