@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/schemas/film/film-queue-task-detail.schema.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Film queue task detail + retry — API schemas (PR-A Wave 1).
+ *
+ * Covers:
+ *   - POST /api/film/queue/tasks/[id]/retry
+ *   - GET  /api/film/queue/tasks/[id]    (with sanitized provider job)
+ *
+ * Sanitization contract (server enforces, client trusts):
+ *   - Auth/secret headers stripped from provider_job (Authorization, Cookie,
+ *     X-API-Key, X-Runway-Key, X-Bearer, Proxy-Authorization).
+ *   - Body fields with secret-like keys replaced with "[REDACTED]"
+ *     (api_key, api-key, apikey, secret, token, bearer, password, signature).
+ *   - Signed-URL query params (Signature, X-Amz-Signature, token) masked.
+ *   - `X-Runway-Version` is preserved (not a secret).
+ *   - `redactedHeaders` returns the lowercased header names that were stripped
+ *     from the snapshot, so the UI can show "redacted on server" badges.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilmQueueTaskDetailResponseSchema = exports.FilmSanitizedProviderJobSchema = exports.FilmQueueTaskRetryResponseSchema = exports.FilmQueueTaskRetryInputSchema = void 0;
+const zod_1 = require("zod");
+const film_clip_api_schema_1 = require("./film-clip-api.schema");
+const film_generation_task_schema_1 = require("./film-generation-task.schema");
+const film_provider_job_schema_1 = require("./film-provider-job.schema");
+// ─── Retry ──────────────────────────────────────────────────────────────────
+exports.FilmQueueTaskRetryInputSchema = zod_1.z
+    .object({
+    resetAttempts: zod_1.z.boolean().optional(),
+})
+    .strict();
+exports.FilmQueueTaskRetryResponseSchema = zod_1.z
+    .object({
+    task: film_generation_task_schema_1.FilmGenerationTaskSchema,
+})
+    .strict();
+// ─── Detail (GET) ───────────────────────────────────────────────────────────
+/**
+ * Sanitized provider job snapshot. Mirrors `FilmProviderJobSchema` but the
+ * input/output JSON has already been walked + secret-key values replaced
+ * with the literal string `[REDACTED]`.
+ *
+ * We re-use FilmProviderJobSchema directly because the redaction happens in
+ * the values themselves (still strings/objects), not the shape.
+ */
+exports.FilmSanitizedProviderJobSchema = film_provider_job_schema_1.FilmProviderJobSchema.extend({
+    /** Lower-cased header keys that were stripped before responding. */
+    redactedHeaders: zod_1.z.array(zod_1.z.string()).default([]),
+    /** Dot-paths inside input/output JSON whose values were replaced with [REDACTED]. */
+    redactedBodyPaths: zod_1.z.array(zod_1.z.string()).default([]),
+}).strict();
+exports.FilmQueueTaskDetailResponseSchema = zod_1.z
+    .object({
+    task: film_generation_task_schema_1.FilmGenerationTaskSchema,
+    providerJob: exports.FilmSanitizedProviderJobSchema.nullable(),
+    clip: film_clip_api_schema_1.FilmClipRecordSchema.nullable(),
+})
+    .strict();

package/dist/schemas/film/film-reference-pack.schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const FILM_REFERENCE_PACK_TYPES: readonly ["character", "location", "style", "wardrobe"];
+export declare const FilmReferencePackTypeSchema: z.ZodEnum<["character", "location", "style", "wardrobe"]>;
+export type FilmReferencePackType = z.infer<typeof FilmReferencePackTypeSchema>;
+export declare const FilmReferencePackSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    packType: z.ZodEnum<["character", "location", "style", "wardrobe"]>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    assetIds: z.ZodArray<z.ZodString, "many">;
+    providerCompat: z.ZodArray<z.ZodString, "many">;
+    approved: z.ZodBoolean;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    approvedAt: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    projectId: string;
+    createdAt: string;
+    name: string;
+    approved: boolean;
+    version: number;
+    updatedAt: string;
+    packType: "style" | "location" | "character" | "wardrobe";
+    assetIds: string[];
+    providerCompat: string[];
+    description?: string | undefined;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}, {
+    id: string;
+    projectId: string;
+    createdAt: string;
+    name: string;
+    approved: boolean;
+    version: number;
+    updatedAt: string;
+    packType: "style" | "location" | "character" | "wardrobe";
+    assetIds: string[];
+    providerCompat: string[];
+    description?: string | undefined;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}>;
+export type FilmReferencePack = z.infer<typeof FilmReferencePackSchema>;

package/dist/schemas/film/film-reference-pack.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilmReferencePackSchema = exports.FilmReferencePackTypeSchema = exports.FILM_REFERENCE_PACK_TYPES = void 0;
+const zod_1 = require("zod");
+exports.FILM_REFERENCE_PACK_TYPES = ['character', 'location', 'style', 'wardrobe'];
+exports.FilmReferencePackTypeSchema = zod_1.z.enum(exports.FILM_REFERENCE_PACK_TYPES);
+exports.FilmReferencePackSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().uuid(),
+    projectId: zod_1.z.string().uuid(),
+    packType: exports.FilmReferencePackTypeSchema,
+    name: zod_1.z.string().min(1),
+    description: zod_1.z.string().optional(),
+    assetIds: zod_1.z.array(zod_1.z.string().uuid()),
+    providerCompat: zod_1.z.array(zod_1.z.string()),
+    approved: zod_1.z.boolean(),
+    approvedBy: zod_1.z.string().uuid().optional(),
+    approvedAt: zod_1.z.string().datetime().optional(),
+    version: zod_1.z.number().int().nonnegative(),
+    createdAt: zod_1.z.string().datetime(),
+    updatedAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/film/film-regeneration-plan.schema.d.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+export declare const FILM_REGENERATION_ACTIONS: readonly ["patch_prompt", "regenerate_keyframe", "regenerate_video_from_same_keyframe", "switch_provider", "split_shot", "rewrite_shot", "use_insert_cutaway", "human_review"];
+export declare const FilmRegenerationActionSchema: z.ZodEnum<["patch_prompt", "regenerate_keyframe", "regenerate_video_from_same_keyframe", "switch_provider", "split_shot", "rewrite_shot", "use_insert_cutaway", "human_review"]>;
+export type FilmRegenerationAction = z.infer<typeof FilmRegenerationActionSchema>;
+export declare const FILM_REGENERATION_STATUSES: readonly ["proposed", "approved", "executed", "superseded", "cancelled"];
+export declare const FilmRegenerationStatusSchema: z.ZodEnum<["proposed", "approved", "executed", "superseded", "cancelled"]>;
+export type FilmRegenerationStatus = z.infer<typeof FilmRegenerationStatusSchema>;
+export declare const FILM_REGENERATION_SOURCE_KINDS: readonly ["keyframe", "clip"];
+export declare const FilmRegenerationSourceKindSchema: z.ZodEnum<["keyframe", "clip"]>;
+export type FilmRegenerationSourceKind = z.infer<typeof FilmRegenerationSourceKindSchema>;
+export declare const FilmRegenerationPromptPatchSchema: z.ZodObject<{
+    addPositive: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    removePositive: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    addNegative: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    removeNegative: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    boostReferenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    addPositive: string[];
+    removePositive: string[];
+    addNegative: string[];
+    removeNegative: string[];
+    boostReferenceIds: string[];
+    notes?: string | undefined;
+}, {
+    notes?: string | undefined;
+    addPositive?: string[] | undefined;
+    removePositive?: string[] | undefined;
+    addNegative?: string[] | undefined;
+    removeNegative?: string[] | undefined;
+    boostReferenceIds?: string[] | undefined;
+}>;
+export type FilmRegenerationPromptPatch = z.infer<typeof FilmRegenerationPromptPatchSchema>;
+export declare const FilmRegenerationPlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    sourceKind: z.ZodEnum<["keyframe", "clip"]>;
+    sourceKeyframeId: z.ZodNullable<z.ZodString>;
+    sourceClipId: z.ZodNullable<z.ZodString>;
+    sourcePromptId: z.ZodNullable<z.ZodString>;
+    shotId: z.ZodString;
+    reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    action: z.ZodEnum<["patch_prompt", "regenerate_keyframe", "regenerate_video_from_same_keyframe", "switch_provider", "split_shot", "rewrite_shot", "use_insert_cutaway", "human_review"]>;
+    promptPatch: z.ZodDefault<z.ZodObject<{
+        addPositive: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        removePositive: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        addNegative: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        removeNegative: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        boostReferenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        addPositive: string[];
+        removePositive: string[];
+        addNegative: string[];
+        removeNegative: string[];
+        boostReferenceIds: string[];
+        notes?: string | undefined;
+    }, {
+        notes?: string | undefined;
+        addPositive?: string[] | undefined;
+        removePositive?: string[] | undefined;
+        addNegative?: string[] | undefined;
+        removeNegative?: string[] | undefined;
+        boostReferenceIds?: string[] | undefined;
+    }>>;
+    providerRecommendation: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    humanApprovalRequired: z.ZodBoolean;
+    status: z.ZodEnum<["proposed", "approved", "executed", "superseded", "cancelled"]>;
+    executedByTaskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    status: "approved" | "cancelled" | "proposed" | "superseded" | "executed";
+    projectId: string;
+    createdAt: string;
+    version: number;
+    updatedAt: string;
+    action: "regenerate_keyframe" | "human_review" | "patch_prompt" | "regenerate_video_from_same_keyframe" | "switch_provider" | "split_shot" | "rewrite_shot" | "use_insert_cutaway";
+    reasonCodes: string[];
+    shotId: string;
+    sourceKind: "keyframe" | "clip";
+    sourceKeyframeId: string | null;
+    sourceClipId: string | null;
+    sourcePromptId: string | null;
+    promptPatch: {
+        addPositive: string[];
+        removePositive: string[];
+        addNegative: string[];
+        removeNegative: string[];
+        boostReferenceIds: string[];
+        notes?: string | undefined;
+    };
+    humanApprovalRequired: boolean;
+    providerRecommendation?: unknown;
+    executedByTaskId?: string | null | undefined;
+}, {
+    id: string;
+    status: "approved" | "cancelled" | "proposed" | "superseded" | "executed";
+    projectId: string;
+    createdAt: string;
+    version: number;
+    updatedAt: string;
+    action: "regenerate_keyframe" | "human_review" | "patch_prompt" | "regenerate_video_from_same_keyframe" | "switch_provider" | "split_shot" | "rewrite_shot" | "use_insert_cutaway";
+    shotId: string;
+    sourceKind: "keyframe" | "clip";
+    sourceKeyframeId: string | null;
+    sourceClipId: string | null;
+    sourcePromptId: string | null;
+    humanApprovalRequired: boolean;
+    reasonCodes?: string[] | undefined;
+    promptPatch?: {
+        notes?: string | undefined;
+        addPositive?: string[] | undefined;
+        removePositive?: string[] | undefined;
+        addNegative?: string[] | undefined;
+        removeNegative?: string[] | undefined;
+        boostReferenceIds?: string[] | undefined;
+    } | undefined;
+    providerRecommendation?: unknown;
+    executedByTaskId?: string | null | undefined;
+}>;
+export type FilmRegenerationPlan = z.infer<typeof FilmRegenerationPlanSchema>;

package/dist/schemas/film/film-regeneration-plan.schema.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilmRegenerationPlanSchema = exports.FilmRegenerationPromptPatchSchema = exports.FilmRegenerationSourceKindSchema = exports.FILM_REGENERATION_SOURCE_KINDS = exports.FilmRegenerationStatusSchema = exports.FILM_REGENERATION_STATUSES = exports.FilmRegenerationActionSchema = exports.FILM_REGENERATION_ACTIONS = void 0;
+const zod_1 = require("zod");
+exports.FILM_REGENERATION_ACTIONS = [
+    "patch_prompt",
+    "regenerate_keyframe",
+    "regenerate_video_from_same_keyframe",
+    "switch_provider",
+    "split_shot",
+    "rewrite_shot",
+    "use_insert_cutaway",
+    "human_review",
+];
+exports.FilmRegenerationActionSchema = zod_1.z.enum(exports.FILM_REGENERATION_ACTIONS);
+exports.FILM_REGENERATION_STATUSES = [
+    "proposed",
+    "approved",
+    "executed",
+    "superseded",
+    "cancelled",
+];
+exports.FilmRegenerationStatusSchema = zod_1.z.enum(exports.FILM_REGENERATION_STATUSES);
+exports.FILM_REGENERATION_SOURCE_KINDS = ["keyframe", "clip"];
+exports.FilmRegenerationSourceKindSchema = zod_1.z.enum(exports.FILM_REGENERATION_SOURCE_KINDS);
+exports.FilmRegenerationPromptPatchSchema = zod_1.z
+    .object({
+    addPositive: zod_1.z.array(zod_1.z.string()).default([]),
+    removePositive: zod_1.z.array(zod_1.z.string()).default([]),
+    addNegative: zod_1.z.array(zod_1.z.string()).default([]),
+    removeNegative: zod_1.z.array(zod_1.z.string()).default([]),
+    boostReferenceIds: zod_1.z.array(zod_1.z.string().uuid()).default([]),
+    notes: zod_1.z.string().optional(),
+})
+    .strict();
+exports.FilmRegenerationPlanSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().uuid(),
+    projectId: zod_1.z.string().uuid(),
+    sourceKind: exports.FilmRegenerationSourceKindSchema,
+    sourceKeyframeId: zod_1.z.string().uuid().nullable(),
+    sourceClipId: zod_1.z.string().uuid().nullable(),
+    sourcePromptId: zod_1.z.string().uuid().nullable(),
+    shotId: zod_1.z.string().uuid(),
+    reasonCodes: zod_1.z.array(zod_1.z.string()).default([]),
+    action: exports.FilmRegenerationActionSchema,
+    promptPatch: exports.FilmRegenerationPromptPatchSchema.default({
+        addPositive: [],
+        removePositive: [],
+        addNegative: [],
+        removeNegative: [],
+        boostReferenceIds: [],
+    }),
+    providerRecommendation: zod_1.z.unknown().nullable().optional(),
+    humanApprovalRequired: zod_1.z.boolean(),
+    status: exports.FilmRegenerationStatusSchema,
+    executedByTaskId: zod_1.z.string().uuid().nullable().optional(),
+    version: zod_1.z.number().int().positive(),
+    createdAt: zod_1.z.string().datetime(),
+    updatedAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/film/film-resolve-ingest.schema.d.ts

@@ -0,0 +1,278 @@
+import { z } from 'zod';
+/** POST /api/film/resolve-ingest — Phase 1 summary + optional PR-K structured timeline report. */
+export declare const FilmResolveIngestBodySchema: z.ZodObject<{
+    projectId: z.ZodString;
+    resolveProjectPath: z.ZodString;
+    timelineName: z.ZodOptional<z.ZodString>;
+    timelineDurationSeconds: z.ZodOptional<z.ZodNumber>;
+    usedClipIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    unusedClipIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    missingMediaClipIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    renderJobId: z.ZodOptional<z.ZodString>;
+    exportPath: z.ZodOptional<z.ZodString>;
+    syncedAt: z.ZodOptional<z.ZodString>;
+    timelineReport: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodString;
+        scriptName: z.ZodEnum<["export", "import", "combined"]>;
+        ranAt: z.ZodString;
+        resolveVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        license: z.ZodOptional<z.ZodNullable<z.ZodEnum<["Studio", "Free"]>>>;
+        timelineId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        projectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stepsExecuted: z.ZodNumber;
+        stepsSucceeded: z.ZodNumber;
+        stepsFailed: z.ZodNumber;
+        errors: z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+            timestamp: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }, {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }>, "many">;
+        warnings: z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+            timestamp: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }, {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }>, "many">;
+        outputs: z.ZodObject<{
+            otioPath: z.ZodOptional<z.ZodString>;
+            fcpxmlPath: z.ZodOptional<z.ZodString>;
+            sidecarJsonPath: z.ZodOptional<z.ZodString>;
+            sidecarCsvPath: z.ZodOptional<z.ZodString>;
+            exportReportPath: z.ZodOptional<z.ZodString>;
+            timelineName: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        }, {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        warnings: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        schemaVersion: string;
+        errors: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        scriptName: "combined" | "export" | "import";
+        ranAt: string;
+        stepsExecuted: number;
+        stepsSucceeded: number;
+        stepsFailed: number;
+        outputs: {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        };
+        projectId?: string | null | undefined;
+        timelineId?: string | null | undefined;
+        resolveVersion?: string | null | undefined;
+        license?: "Studio" | "Free" | null | undefined;
+    }, {
+        warnings: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        schemaVersion: string;
+        errors: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        scriptName: "combined" | "export" | "import";
+        ranAt: string;
+        stepsExecuted: number;
+        stepsSucceeded: number;
+        stepsFailed: number;
+        outputs: {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        };
+        projectId?: string | null | undefined;
+        timelineId?: string | null | undefined;
+        resolveVersion?: string | null | undefined;
+        license?: "Studio" | "Free" | null | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    projectId: string;
+    resolveProjectPath: string;
+    usedClipIds: string[];
+    unusedClipIds: string[];
+    missingMediaClipIds: string[];
+    syncedAt?: string | undefined;
+    timelineName?: string | undefined;
+    timelineDurationSeconds?: number | undefined;
+    renderJobId?: string | undefined;
+    exportPath?: string | undefined;
+    timelineReport?: {
+        warnings: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        schemaVersion: string;
+        errors: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        scriptName: "combined" | "export" | "import";
+        ranAt: string;
+        stepsExecuted: number;
+        stepsSucceeded: number;
+        stepsFailed: number;
+        outputs: {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        };
+        projectId?: string | null | undefined;
+        timelineId?: string | null | undefined;
+        resolveVersion?: string | null | undefined;
+        license?: "Studio" | "Free" | null | undefined;
+    } | undefined;
+}, {
+    projectId: string;
+    resolveProjectPath: string;
+    syncedAt?: string | undefined;
+    timelineName?: string | undefined;
+    timelineDurationSeconds?: number | undefined;
+    usedClipIds?: string[] | undefined;
+    unusedClipIds?: string[] | undefined;
+    missingMediaClipIds?: string[] | undefined;
+    renderJobId?: string | undefined;
+    exportPath?: string | undefined;
+    timelineReport?: {
+        warnings: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        schemaVersion: string;
+        errors: {
+            code: string;
+            message: string;
+            step: string;
+            timestamp: string;
+            details?: unknown;
+        }[];
+        scriptName: "combined" | "export" | "import";
+        ranAt: string;
+        stepsExecuted: number;
+        stepsSucceeded: number;
+        stepsFailed: number;
+        outputs: {
+            otioPath?: string | undefined;
+            fcpxmlPath?: string | undefined;
+            sidecarJsonPath?: string | undefined;
+            sidecarCsvPath?: string | undefined;
+            exportReportPath?: string | undefined;
+            timelineName?: string | undefined;
+        };
+        projectId?: string | null | undefined;
+        timelineId?: string | null | undefined;
+        resolveVersion?: string | null | undefined;
+        license?: "Studio" | "Free" | null | undefined;
+    } | undefined;
+}>;
+export type FilmResolveIngestBody = z.infer<typeof FilmResolveIngestBodySchema>;
+export declare const FilmResolveIngestSuccessDataSchema: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    parsed: z.ZodBoolean;
+    errorsCount: z.ZodNumber;
+    warningsCount: z.ZodNumber;
+    projectId: z.ZodString;
+    syncedAt: z.ZodString;
+    updated: z.ZodArray<z.ZodString, "many">;
+    missingMedia: z.ZodArray<z.ZodString, "many">;
+    usedClips: z.ZodNumber;
+    unusedClips: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    projectId: string;
+    accepted: boolean;
+    syncedAt: string;
+    parsed: boolean;
+    errorsCount: number;
+    warningsCount: number;
+    updated: string[];
+    missingMedia: string[];
+    usedClips: number;
+    unusedClips: number;
+}, {
+    projectId: string;
+    accepted: boolean;
+    syncedAt: string;
+    parsed: boolean;
+    errorsCount: number;
+    warningsCount: number;
+    updated: string[];
+    missingMedia: string[];
+    usedClips: number;
+    unusedClips: number;
+}>;
+export type FilmResolveIngestSuccessData = z.infer<typeof FilmResolveIngestSuccessDataSchema>;

package/dist/schemas/film/film-resolve-ingest.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilmResolveIngestSuccessDataSchema = exports.FilmResolveIngestBodySchema = void 0;
+const zod_1 = require("zod");
+const film_resolve_timeline_report_schema_1 = require("./film-resolve-timeline-report.schema");
+/** POST /api/film/resolve-ingest — Phase 1 summary + optional PR-K structured timeline report. */
+exports.FilmResolveIngestBodySchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    resolveProjectPath: zod_1.z.string().min(1),
+    timelineName: zod_1.z.string().optional(),
+    timelineDurationSeconds: zod_1.z.number().nonnegative().optional(),
+    usedClipIds: zod_1.z.array(zod_1.z.string()).default([]),
+    unusedClipIds: zod_1.z.array(zod_1.z.string()).default([]),
+    missingMediaClipIds: zod_1.z.array(zod_1.z.string()).default([]),
+    renderJobId: zod_1.z.string().optional(),
+    exportPath: zod_1.z.string().optional(),
+    syncedAt: zod_1.z.string().datetime().optional(),
+    timelineReport: film_resolve_timeline_report_schema_1.ResolveTimelineReportSchema.optional(),
+})
+    .strict();
+exports.FilmResolveIngestSuccessDataSchema = zod_1.z
+    .object({
+    accepted: zod_1.z.boolean(),
+    parsed: zod_1.z.boolean(),
+    errorsCount: zod_1.z.number().int().nonnegative(),
+    warningsCount: zod_1.z.number().int().nonnegative(),
+    projectId: zod_1.z.string().uuid(),
+    syncedAt: zod_1.z.string(),
+    updated: zod_1.z.array(zod_1.z.string()),
+    missingMedia: zod_1.z.array(zod_1.z.string()),
+    usedClips: zod_1.z.number().int().nonnegative(),
+    unusedClips: zod_1.z.number().int().nonnegative(),
+})
+    .strict();