@hraness/slopcamera 3.2.4

package/apps/desktop/contracts/render.ts

@@ -0,0 +1,334 @@
+import { z } from "zod";
+
+import {
+  ClickEffectSchema,
+  CursorEffectSchema,
+  EasingSchema,
+  KeystrokeEffectSchema,
+  OverlayOperationSchema,
+  SourceIntervalSchema,
+  TypedTextEffectSchema,
+  ZoomIdSchema,
+} from "./edit";
+import {
+  IsoTimestampSchema,
+  MicrosecondsSchema,
+  PointSchema,
+  RecordingIdSchema,
+  RectSchema,
+  RepositoryRelativePathSchema,
+  Sha256Schema,
+  TrackIdSchema,
+  type ReadonlyInferred,
+} from "./recording";
+
+export const FreezeIntervalSchema = z.strictObject({
+  confidence: z.number().finite().min(0).max(1),
+  meanFrameDifference: z.number().finite().nonnegative(),
+  range: SourceIntervalSchema,
+});
+
+export const SilenceIntervalSchema = z.strictObject({
+  peakDb: z.number().finite(),
+  range: SourceIntervalSchema,
+});
+
+function rangesAreOrderedAndDisjoint(
+  intervals: readonly { readonly range: { readonly startUs: number; readonly endUs: number } }[],
+): boolean {
+  let priorEndUs = -1;
+  for (const { range } of intervals) {
+    if (range.startUs < priorEndUs) return false;
+    priorEndUs = range.endUs;
+  }
+  return true;
+}
+
+export const AnalyzerEvidenceV1Schema = z.strictObject({
+  audio: z.array(z.strictObject({
+    intervals: z.array(SilenceIntervalSchema),
+    trackId: TrackIdSchema,
+  })),
+  displays: z.array(z.strictObject({
+    intervals: z.array(FreezeIntervalSchema),
+    trackId: TrackIdSchema,
+  })).min(1),
+  kind: z.union([
+    z.literal("slopcamera.analyzer-evidence"),
+    z.literal("studio.analyzer-evidence"),
+  ]),
+  schemaVersion: z.literal(1),
+  sourceDurationUs: MicrosecondsSchema,
+  tool: z.strictObject({
+    name: z.string().min(1).max(128),
+    version: z.string().min(1).max(128),
+  }),
+}).superRefine((evidence, context) => {
+  const tracks = [...evidence.displays, ...evidence.audio];
+  if (new Set(tracks.map(({ trackId }) => trackId)).size !== tracks.length) {
+    context.addIssue({ code: "custom", message: "Analyzer evidence track IDs must be unique." });
+  }
+  for (const track of tracks) {
+    if (!rangesAreOrderedAndDisjoint(track.intervals)) {
+      context.addIssue({ code: "custom", message: `Analyzer intervals for ${track.trackId} must be sorted and non-overlapping.` });
+    }
+    if (track.intervals.some(({ range }) => range.endUs > evidence.sourceDurationUs)) {
+      context.addIssue({ code: "custom", message: `Analyzer intervals for ${track.trackId} exceed sourceDurationUs.` });
+    }
+  }
+});
+
+export const InactivityPlannerConfigSchema = z.strictObject({
+  cursorMovementThresholdPx: z.number().finite().positive(),
+  edgeHandleUs: MicrosecondsSchema,
+  interactionHandleUs: MicrosecondsSchema,
+  minimumFreezeConfidence: z.number().finite().min(0).max(1).optional(),
+  minimumCutUs: MicrosecondsSchema,
+  requireAudioSilence: z.boolean(),
+});
+
+export const OutputIntervalSchema = z.strictObject({
+  endUs: MicrosecondsSchema,
+  startUs: MicrosecondsSchema,
+}).superRefine((interval, context) => {
+  if (interval.endUs <= interval.startUs) {
+    context.addIssue({ code: "custom", message: "Output interval endUs must be greater than startUs." });
+  }
+});
+
+export const TimeMapSegmentSchema = z.strictObject({
+  output: OutputIntervalSchema,
+  source: SourceIntervalSchema,
+  speed: z.number().finite().positive().max(64),
+});
+
+export const ResolvedSourceSegmentSchema = z.strictObject({
+  bytes: z.number().int().safe().positive(),
+  codec: z.string().min(1).max(128),
+  container: z.string().min(1).max(64),
+  containerTrackIdentity: z.discriminatedUnion("kind", [
+    z.strictObject({ containerTrackId: z.string().min(1).max(256), kind: z.literal("verified") }),
+    z.strictObject({
+      diagnosticCode: z.string().min(1).max(128),
+      expectedRole: z.enum(["display-video", "camera-video", "system-audio", "microphone-audio"]),
+      kind: z.literal("provisional"),
+    }),
+  ]),
+  kind: z.enum(["display-video", "camera-video", "system-audio", "microphone-audio"]),
+  output: OutputIntervalSchema,
+  path: RepositoryRelativePathSchema,
+  source: SourceIntervalSchema,
+  sha256: Sha256Schema,
+  streamIndex: z.number().int().safe().nonnegative(),
+  trackId: TrackIdSchema,
+});
+
+export const CameraKeyframeSchema = z.strictObject({
+  easing: EasingSchema,
+  outputTimeUs: MicrosecondsSchema,
+  scale: z.number().finite().min(1).max(10),
+  sourceTimeUs: MicrosecondsSchema,
+  viewport: RectSchema,
+  zoomId: ZoomIdSchema,
+});
+
+export const ResolvedOverlaySchema = z.strictObject({
+  operation: OverlayOperationSchema,
+  output: OutputIntervalSchema,
+});
+
+export const RenderCursorSampleSchema = z.strictObject({
+  coordinateSpace: z.literal("output-pixels"),
+  displayId: z.string().min(1).max(256),
+  outputTimeUs: MicrosecondsSchema,
+  position: PointSchema,
+  sourceTimeUs: MicrosecondsSchema,
+  visible: z.boolean(),
+});
+
+export const RenderClickCueSchema = z.strictObject({
+  button: z.enum(["left", "right", "middle", "other"]),
+  clickCount: z.number().int().safe().positive().max(16),
+  coordinateSpace: z.literal("output-pixels"),
+  displayId: z.string().min(1).max(256),
+  outputTimeUs: MicrosecondsSchema,
+  phase: z.enum(["down", "up"]),
+  position: PointSchema,
+  sourceTimeUs: MicrosecondsSchema,
+});
+
+export const RenderKeystrokeCueSchema = z.strictObject({
+  activity: z.discriminatedUnion("kind", [
+    z.strictObject({
+      keyCode: z.string().min(1).max(128),
+      kind: z.literal("shortcut"),
+      modifiers: z.array(z.enum(["command", "control", "option", "shift", "caps-lock", "function"])).min(1),
+    }),
+    z.strictObject({
+      control: z.enum(["arrow-up", "arrow-down", "arrow-left", "arrow-right", "escape", "tab", "enter", "delete"]),
+      kind: z.literal("control"),
+      modifiers: z.array(z.enum(["command", "control", "option", "shift", "caps-lock", "function"])),
+    }),
+    z.strictObject({ kind: z.literal("printable"), token: z.literal("[PRINTABLE]") }),
+  ]),
+  outputTimeUs: MicrosecondsSchema,
+  phase: z.enum(["down", "up"]),
+  repeat: z.boolean(),
+  sourceTimeUs: MicrosecondsSchema,
+});
+
+export const RenderTypingSpanSchema = z.discriminatedUnion("secure", [
+  z.strictObject({
+    endOutputUs: MicrosecondsSchema,
+    endSourceUs: MicrosecondsSchema,
+    fieldId: z.string().min(1).max(512),
+    secure: z.literal(false),
+    startOutputUs: MicrosecondsSchema,
+    startSourceUs: MicrosecondsSchema,
+    updates: z.array(z.strictObject({
+      bounds: RectSchema,
+      coordinateSpace: z.literal("output-pixels"),
+      outputTimeUs: MicrosecondsSchema,
+      sourceTimeUs: MicrosecondsSchema,
+      text: z.string(),
+    })).min(1).max(4096),
+    windowId: z.string().min(1).max(256),
+  }),
+  z.strictObject({
+    bounds: RectSchema,
+    endOutputUs: MicrosecondsSchema,
+    endSourceUs: MicrosecondsSchema,
+    fieldId: z.literal("[REDACTED]"),
+    secure: z.literal(true),
+    startOutputUs: MicrosecondsSchema,
+    startSourceUs: MicrosecondsSchema,
+    state: z.literal("hidden"),
+    windowId: z.string().min(1).max(256),
+  }),
+]);
+
+export const RenderEffectsSchema = z.strictObject({
+  clickCues: z.array(RenderClickCueSchema).max(100_000),
+  clicks: ClickEffectSchema,
+  cursor: CursorEffectSchema,
+  cursorSamples: z.array(RenderCursorSampleSchema).max(100_000),
+  keystrokes: KeystrokeEffectSchema,
+  keystrokeCues: z.array(RenderKeystrokeCueSchema).max(100_000),
+  typedText: TypedTextEffectSchema,
+  typingSpans: z.array(RenderTypingSpanSchema).max(100_000),
+});
+
+export const Yuv420pDimensionSchema = z.number().int().safe().positive().max(16_384).refine(
+  value => value % 2 === 0,
+  "YUV 4:2:0 pixel dimensions must be even.",
+);
+
+export const RenderPlanV1Schema = z.strictObject({
+  cameraKeyframes: z.array(CameraKeyframeSchema),
+  effects: RenderEffectsSchema,
+  kind: z.union([
+    z.literal("slopcamera.render-plan"),
+    z.literal("studio.render-plan"),
+  ]),
+  composition: z.strictObject({
+    audioTrackIds: z.array(TrackIdSchema),
+    baseDisplay: z.strictObject({
+      displayId: z.string().min(1).max(256),
+      trackId: TrackIdSchema,
+    }),
+    camera: z.discriminatedUnion("kind", [
+      z.strictObject({ kind: z.literal("none") }),
+    ]),
+    globalToOutput: z.strictObject({
+      displayBoundsPoints: RectSchema,
+      displayScaleFactor: z.number().finite().positive(),
+      outputScaleX: z.number().finite().positive(),
+      outputScaleY: z.number().finite().positive(),
+      sourceSpace: z.literal("global-display-points"),
+      targetSpace: z.literal("output-pixels"),
+    }),
+  }),
+  output: z.strictObject({
+    durationUs: MicrosecondsSchema,
+    frameRate: z.number().finite().positive().max(240),
+    pixelHeight: Yuv420pDimensionSchema,
+    pixelWidth: Yuv420pDimensionSchema,
+  }).superRefine((output, context) => {
+    if (output.pixelWidth * output.pixelHeight > 134_217_728) {
+      context.addIssue({ code: "custom", message: "Render output exceeds the 128-megapixel safety limit." });
+    }
+  }),
+  overlays: z.array(ResolvedOverlaySchema),
+  planSha256: Sha256Schema,
+  recordingId: RecordingIdSchema,
+  schemaVersion: z.literal(1),
+  sourceSegments: z.array(ResolvedSourceSegmentSchema).max(100_000),
+  timeMap: z.array(TimeMapSegmentSchema),
+});
+
+export const RenderInvocationSchema = z.strictObject({
+  arguments: z.array(z.string()),
+  executable: z.literal("ffmpeg"),
+  filterGraph: z.strictObject({
+    bytes: z.number().int().safe().positive().max(32 * 1024 * 1024),
+    path: RepositoryRelativePathSchema,
+    sha256: Sha256Schema,
+  }),
+  outputPath: RepositoryRelativePathSchema,
+  renderPlanSha256: Sha256Schema,
+});
+
+export const RecordingRenderReceiptV1Schema = z.strictObject({
+  createdAt: IsoTimestampSchema,
+  display: z.strictObject({
+    displayId: z.string().min(1).max(256),
+    trackId: TrackIdSchema,
+  }),
+  kind: z.union([
+    z.literal("slopcamera.recording-render-receipt"),
+    z.literal("studio.recording-render-receipt"),
+  ]),
+  output: z.strictObject({
+    bytes: z.number().int().safe().positive(),
+    path: RepositoryRelativePathSchema,
+    sha256: Sha256Schema,
+  }),
+  plan: z.strictObject({
+    path: RepositoryRelativePathSchema,
+    sha256: Sha256Schema,
+  }),
+  recordingId: RecordingIdSchema,
+  schemaVersion: z.literal(1),
+});
+
+export type AnalyzerEvidenceV1 = ReadonlyInferred<typeof AnalyzerEvidenceV1Schema>;
+export type InactivityPlannerConfig = ReadonlyInferred<typeof InactivityPlannerConfigSchema>;
+export type TimeMapSegment = ReadonlyInferred<typeof TimeMapSegmentSchema>;
+export type ResolvedSourceSegment = ReadonlyInferred<typeof ResolvedSourceSegmentSchema>;
+export type RenderCursorSample = ReadonlyInferred<typeof RenderCursorSampleSchema>;
+export type RenderClickCue = ReadonlyInferred<typeof RenderClickCueSchema>;
+export type RenderKeystrokeCue = ReadonlyInferred<typeof RenderKeystrokeCueSchema>;
+export type RenderTypingSpan = ReadonlyInferred<typeof RenderTypingSpanSchema>;
+export type RenderEffects = ReadonlyInferred<typeof RenderEffectsSchema>;
+export type RenderPlanV1 = ReadonlyInferred<typeof RenderPlanV1Schema>;
+export type RenderInvocation = ReadonlyInferred<typeof RenderInvocationSchema>;
+export type RecordingRenderReceiptV1 = ReadonlyInferred<typeof RecordingRenderReceiptV1Schema>;
+
+export interface MotionAnalyzer {
+  readonly name: string;
+  readonly version: string;
+  analyze(input: MotionAnalyzerInput): Promise<AnalyzerEvidenceV1>;
+}
+
+export interface MotionAnalyzerInput {
+  readonly recordingId: z.infer<typeof RecordingIdSchema>;
+  readonly sourceDurationUs: number;
+  readonly displayTracks: readonly MotionAnalyzerTrackInput[];
+  readonly audioTracks: readonly MotionAnalyzerTrackInput[];
+}
+
+export interface MotionAnalyzerTrackInput {
+  readonly path: string;
+  readonly streamIndex: number;
+  readonly trackId: z.infer<typeof TrackIdSchema>;
+}

package/apps/desktop/contracts/runtime.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+
+import {
+  CaptureInterruptionSchema,
+  CapturePermissionsSchema,
+  IsoTimestampSchema,
+  MicrosecondsSchema,
+  RecordingIdSchema,
+  RepositoryRelativePathSchema,
+  type ReadonlyInferred,
+} from "./recording";
+
+export const SLOPCAMERA_DESKTOP_PROTOCOL = "slopcamera.desktop";
+export const LEGACY_STUDIO_DESKTOP_PROTOCOL = "studio.desktop";
+export const SLOPCAMERA_DESKTOP_PROTOCOL_VERSION = 3;
+
+const RuntimeRequestIdSchema = z.string().regex(/^request_[a-z0-9][a-z0-9_-]{7,63}$/u);
+const RuntimeCommandIdSchema = z.string().regex(/^command_[a-z0-9][a-z0-9_-]{7,63}$/u);
+const CaptureSourceIdSchema = z.string().min(1).max(256);
+
+export const CaptureRuntimeStateSchema = z.discriminatedUnion("state", [
+  z.strictObject({
+    lastRecording: z.strictObject({
+      durationUs: MicrosecondsSchema,
+      recordingId: RecordingIdSchema,
+      recordingPath: RepositoryRelativePathSchema,
+    }).nullable(),
+    state: z.literal("idle"),
+  }),
+  z.strictObject({ commandId: RuntimeCommandIdSchema, recordingPath: RepositoryRelativePathSchema, state: z.literal("starting") }),
+  z.strictObject({ recordingId: RecordingIdSchema, recordingPath: RepositoryRelativePathSchema, sourceTimeUs: MicrosecondsSchema, state: z.literal("recording") }),
+  z.strictObject({ recordingId: RecordingIdSchema, recordingPath: RepositoryRelativePathSchema, sourceTimeUs: MicrosecondsSchema, state: z.literal("paused") }),
+  z.strictObject({ commandId: RuntimeCommandIdSchema, recordingId: RecordingIdSchema, recordingPath: RepositoryRelativePathSchema, sourceTimeUs: MicrosecondsSchema, state: z.literal("stopping") }),
+  z.strictObject({
+    code: z.string().min(1).max(128),
+    message: z.string().min(1).max(2048),
+    recordingId: RecordingIdSchema.nullable(),
+    recordingPath: RepositoryRelativePathSchema.nullable(),
+    sourceTimeUs: MicrosecondsSchema.nullable(),
+    state: z.literal("failed"),
+  }),
+]);
+
+export const RuntimeSourceSummarySchema = z.strictObject({
+  audioSources: z.array(z.strictObject({
+    id: z.string().min(1).max(256),
+    kind: z.enum(["system", "microphone"]),
+    label: z.string().min(1).max(512),
+  })).max(64),
+  cameras: z.array(z.strictObject({ id: z.string().min(1).max(256), label: z.string().min(1).max(512) })).max(32),
+  displays: z.array(z.strictObject({ id: z.string().min(1).max(256), isPrimary: z.boolean(), label: z.string().min(1).max(512) })).max(32),
+});
+
+export const CaptureRuntimeSnapshotSchema = z.strictObject({
+  availableSources: RuntimeSourceSummarySchema,
+  lastInterruption: CaptureInterruptionSchema.nullable(),
+  permissions: CapturePermissionsSchema,
+  protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+  sources: RuntimeSourceSummarySchema,
+  state: CaptureRuntimeStateSchema,
+  updatedAt: IsoTimestampSchema,
+});
+
+const DisplaySelectionSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("all") }),
+  z.strictObject({
+    displayIds: z.array(CaptureSourceIdSchema).min(1).max(16).superRefine((displayIds, context) => {
+      if (new Set(displayIds).size !== displayIds.length) {
+        context.addIssue({ code: "custom", message: "Selected display IDs must be unique." });
+      }
+    }),
+    kind: z.literal("selected"),
+  }),
+]);
+
+const OptionalDeviceSelectionSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("disabled") }),
+  z.strictObject({ kind: z.literal("default") }),
+  z.strictObject({ deviceId: CaptureSourceIdSchema, kind: z.literal("device") }),
+]);
+
+export const CaptureStartOptionsSchema = z.strictObject({
+  camera: OptionalDeviceSelectionSchema,
+  displays: DisplaySelectionSchema,
+  microphone: OptionalDeviceSelectionSchema,
+  recordingDirectory: RepositoryRelativePathSchema.refine(
+    (path) => path === "artifacts/slopcamera/recordings"
+      || path.startsWith("artifacts/slopcamera/recordings/"),
+    "Recordings must stay under artifacts/slopcamera/recordings/.",
+  ),
+  systemAudio: z.boolean(),
+  typedText: z.enum(["disabled", "enabled"]),
+  windowMetadata: z.literal("titles-and-bounds"),
+});
+
+export const CaptureDomainCommandSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ commandId: RuntimeCommandIdSchema, kind: z.literal("start"), options: CaptureStartOptionsSchema }),
+  z.strictObject({ commandId: RuntimeCommandIdSchema, kind: z.literal("pause") }),
+  z.strictObject({ commandId: RuntimeCommandIdSchema, kind: z.literal("resume") }),
+  z.strictObject({ commandId: RuntimeCommandIdSchema, kind: z.literal("stop") }),
+]);
+
+export const DesktopRequestSchema = z.strictObject({
+  payload: z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("snapshot") }),
+    z.strictObject({ command: CaptureDomainCommandSchema, kind: z.literal("dispatch") }),
+  ]),
+  protocol: z.union([
+    z.literal(SLOPCAMERA_DESKTOP_PROTOCOL),
+    z.literal(LEGACY_STUDIO_DESKTOP_PROTOCOL),
+  ]),
+  protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+  requestId: RuntimeRequestIdSchema,
+});
+
+export const DesktopResponseSchema = z.discriminatedUnion("ok", [
+  z.strictObject({
+    ok: z.literal(true),
+    protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+    requestId: RuntimeRequestIdSchema,
+    snapshot: CaptureRuntimeSnapshotSchema,
+  }),
+  z.strictObject({
+    error: z.strictObject({
+      code: z.string().min(1).max(128),
+      message: z.string().min(1).max(2048),
+      retryable: z.boolean(),
+    }),
+    ok: z.literal(false),
+    protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+    requestId: RuntimeRequestIdSchema,
+  }),
+]);
+
+export const DesktopEventSchema = z.discriminatedUnion("kind", [
+  z.strictObject({
+    kind: z.literal("snapshot-changed"),
+    protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+    snapshot: CaptureRuntimeSnapshotSchema,
+  }),
+  z.strictObject({
+    commandId: RuntimeCommandIdSchema,
+    kind: z.literal("command-settled"),
+    protocolVersion: z.literal(SLOPCAMERA_DESKTOP_PROTOCOL_VERSION),
+    status: z.enum(["succeeded", "failed"]),
+  }),
+]);
+
+export type CaptureRuntimeState = ReadonlyInferred<typeof CaptureRuntimeStateSchema>;
+export type CaptureRuntimeSnapshot = ReadonlyInferred<typeof CaptureRuntimeSnapshotSchema>;
+export type CaptureStartOptions = ReadonlyInferred<typeof CaptureStartOptionsSchema>;
+export type CaptureDomainCommand = ReadonlyInferred<typeof CaptureDomainCommandSchema>;
+export type DesktopRequest = ReadonlyInferred<typeof DesktopRequestSchema>;
+export type DesktopResponse = ReadonlyInferred<typeof DesktopResponseSchema>;
+export type DesktopEvent = ReadonlyInferred<typeof DesktopEventSchema>;

package/apps/desktop/contracts/spatial-compositor.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+
+import { SpatialDigestSchema, SpatialFrameRateSchema, SpatialTimeUsSchema } from "../../../src/spatial-scene/contracts";
+import { reduceSpatialFrameRate, spatialFrameCount } from "../../../src/spatial-scene/time";
+
+export const SPATIAL_COMPOSITOR_LIMITS = Object.freeze({ frames: 864_000, probeBytes: 64 * 1024 * 1024, outputBytes: 256 * 1024 * 1024, timeoutMs: 120_000 });
+
+/** An outer adapter preserves the meaning of all existing V1 numeric plan hashes. */
+export const SpatialCompositorCadenceV1Schema = z.strictObject({
+  kind: z.literal("slopcamera.spatial-compositor-cadence"),
+  schemaVersion: z.literal(1),
+  projectionSha256: SpatialDigestSchema,
+  compositionPlanSha256: SpatialDigestSchema,
+  frameRate: SpatialFrameRateSchema,
+  durationUs: SpatialTimeUsSchema.refine(value => value > 0),
+  frameCount: z.number().int().positive().max(SPATIAL_COMPOSITOR_LIMITS.frames),
+}).superRefine((cadence, context) => {
+  const rate = reduceSpatialFrameRate(cadence.frameRate);
+  // MOV video_track_timescale and FFmpeg AVRational are signed 32-bit integers.
+  if (rate.numerator !== cadence.frameRate.numerator || rate.denominator !== cadence.frameRate.denominator
+    || rate.numerator > 2_147_483_647 || rate.denominator > 2_147_483_647
+    || rate.numerator / rate.denominator > 240
+    || spatialFrameCount(cadence.durationUs, rate) !== cadence.frameCount) {
+    context.addIssue({ code: "custom", message: "Compositor cadence requires a reduced, container-representable rate and exact half-open frame count." });
+  }
+});
+export const SpatialCompositorCadenceBindingV1Schema = z.strictObject({
+  cadence: SpatialCompositorCadenceV1Schema,
+  cadenceSha256: SpatialDigestSchema,
+});
+const UnsignedIntegerString = z.string().regex(/^(?:0|[1-9][0-9]{0,24})$/u);
+export const SpatialCompositorVideoProfileSchema = z.strictObject({
+  pixelWidth: z.number().int().positive().max(16_384).multipleOf(2),
+  pixelHeight: z.number().int().positive().max(16_384).multipleOf(2),
+  pixelFormat: z.literal("yuv420p"),
+}).refine(value => value.pixelWidth * value.pixelHeight <= 33_554_432, "Compositor video exceeds the admitted output pixel budget.");
+export const SpatialCompositorTimingVerificationV1Schema = z.strictObject({
+  kind: z.literal("slopcamera.spatial-compositor-timing-verification"),
+  schemaVersion: z.literal(1),
+  cadenceSha256: SpatialDigestSchema,
+  profile: z.literal("mp4-h264-cfr-integer-pts-v1"),
+  video: SpatialCompositorVideoProfileSchema,
+  frameRate: SpatialFrameRateSchema,
+  frameCount: z.number().int().positive().max(SPATIAL_COMPOSITOR_LIMITS.frames),
+  timeBase: z.strictObject({ numerator: UnsignedIntegerString, denominator: UnsignedIntegerString }),
+  firstPts: UnsignedIntegerString,
+  lastPts: UnsignedIntegerString,
+  stepPts: UnsignedIntegerString,
+  durationTs: UnsignedIntegerString,
+  authoredDurationUs: SpatialTimeUsSchema,
+  encodedVideoDurationUs: z.strictObject({ numerator: UnsignedIntegerString, denominator: UnsignedIntegerString }),
+  audio: z.strictObject({ sampleRate: z.literal(48_000), durationTs: UnsignedIntegerString, timeBase: z.literal("1/48000"), durationToleranceSamples: z.literal(1) }),
+});
+
+export type SpatialCompositorCadenceV1 = Readonly<z.infer<typeof SpatialCompositorCadenceV1Schema>>;
+export type SpatialCompositorCadenceBindingV1 = Readonly<z.infer<typeof SpatialCompositorCadenceBindingV1Schema>>;
+export type SpatialCompositorTimingVerificationV1 = Readonly<z.infer<typeof SpatialCompositorTimingVerificationV1Schema>>;
+export type SpatialCompositorVideoProfile = Readonly<z.infer<typeof SpatialCompositorVideoProfileSchema>>;