@ume-group/contracts 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,1531 @@
+/**
+ * Shared types for Includu Platform
+ *
+ * Used by:
+ * - @includu/editor (timeline editor)
+ * - @includu/cms (video library)
+ */
+/**
+ * Debug flag - true in Vite dev mode, false in production builds.
+ * Can also be set manually for testing.
+ */
+export declare let DEBUG: boolean;
+/** Override the DEBUG flag (useful for testing or manual control) */
+export declare function setDebug(value: boolean): void;
+/** Debug logger - only outputs when DEBUG is true (dev mode by default) */
+export declare function debug(...args: unknown[]): void;
+/**
+ * A video clip from any source (CMS, YouTube, etc.)
+ */
+export interface VideoClip {
+    /** Unique identifier */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Optional description */
+    description?: string;
+    /** Duration in seconds */
+    duration: number;
+    /** Thumbnail URL */
+    thumbnail?: string;
+    /** HLS manifest URL for playback */
+    hlsUrl: string;
+    /** Original source type */
+    sourceType: 'cms' | 'youtube' | 'vimeo' | 'url';
+    /** Source-specific identifier (e.g., Cloudflare Stream UID) */
+    sourceId?: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last updated timestamp */
+    updatedAt: string;
+}
+/**
+ * Video clip with CMS-specific metadata
+ */
+export interface CMSVideoClip extends VideoClip {
+    sourceType: 'cms';
+    /** Cloudflare Stream video UID */
+    streamUid: string;
+    /** Processing status */
+    status: 'uploading' | 'processing' | 'ready' | 'error';
+    /** Upload progress (0-100) */
+    uploadProgress?: number;
+    /** Tags for organization */
+    tags: string[];
+    /** Original filename */
+    originalFilename?: string;
+    /** File size in bytes */
+    fileSize?: number;
+}
+/**
+ * Live stream input
+ */
+export interface LiveStream {
+    id: string;
+    title: string;
+    description?: string;
+    /** SRT ingest URL */
+    srtUrl: string;
+    /** HLS playback URL (when live) */
+    hlsUrl?: string;
+    /** Stream status */
+    status: 'idle' | 'connecting' | 'live' | 'ended';
+    /** Cloudflare Stream live input ID */
+    streamInputId: string;
+    createdAt: string;
+}
+export type OverlayType = 'text' | 'emoji' | 'shape' | 'image' | 'cta' | 'sprite-sequence' | 'video';
+/** Track type for overlays - determines which timeline track they appear on */
+export type OverlayTrack = 'overlays' | 'branding' | 'motion-gfx';
+export interface TextContent {
+    text: string;
+    fontSize: number;
+    fontFamily: string;
+    fontWeight: 'normal' | 'bold';
+    color: string;
+    textAlign: 'left' | 'center' | 'right';
+    /**
+     * Background plane properties (independent from text transform)
+     * When present, background is rendered as a separate layer that can be scaled independently
+     */
+    background?: {
+        /** Background color (hex or rgba) */
+        color: string;
+        /** Background opacity (0-1), default 1 */
+        opacity?: number;
+        /** Padding around text as percentage of overlay size */
+        padding?: {
+            x: number;
+            y: number;
+        };
+        /** Independent scale multiplier for background plane (default 1.0) */
+        scale?: number;
+        /** Corner radius in pixels */
+        borderRadius?: number;
+    };
+    /**
+     * Text offset within the background plane
+     * Allows positioning text independently from its background
+     */
+    textOffset?: {
+        /** Horizontal offset as percentage of background width (-50 to 50) */
+        x: number;
+        /** Vertical offset as percentage of background height (-50 to 50) */
+        y: number;
+    };
+    /** @deprecated Use background.color instead */
+    backgroundColor?: string;
+}
+export interface EmojiContent {
+    emoji: string;
+    size: number;
+}
+export interface ShapeContent {
+    shape: 'rectangle' | 'circle' | 'arrow';
+    fillColor: string;
+    fillOpacity: number;
+    strokeColor: string;
+    strokeWidth: number;
+    cornerRadius?: number;
+}
+export interface ImageContent {
+    src: string;
+    alt?: string;
+    fit: 'contain' | 'cover' | 'fill';
+    opacity?: number;
+    borderRadius?: number;
+    /** Optional click URL to make the image clickable */
+    clickUrl?: string;
+}
+export interface CTAContent {
+    text: string;
+    url: string;
+    newTab: boolean;
+    style: {
+        backgroundColor: string;
+        textColor: string;
+        borderRadius: number;
+        fontSize: number;
+        fontWeight: 'normal' | 'bold';
+        padding: {
+            x: number;
+            y: number;
+        };
+    };
+    hoverStyle?: {
+        backgroundColor?: string;
+        textColor?: string;
+    };
+}
+/**
+ * Sprite sequence overlay content for animated image sequences
+ *
+ * Renders pre-rendered image sequences (sprite sheets) as animated overlays.
+ * Supports both grid layouts (columns × rows) and horizontal strips.
+ *
+ * Animation is driven by CSS background-position, independent of video FPS.
+ *
+ * @example Grid layout (4×4 = 16 frames):
+ * { frameWidth: 256, frameHeight: 256, frameCount: 16, columns: 4 }
+ *
+ * @example Horizontal strip (12 frames in a row):
+ * { frameWidth: 128, frameHeight: 128, frameCount: 12, columns: 12 }
+ */
+export interface SpriteSequenceContent {
+    /**
+     * URL to the sprite sheet image
+     * Supports R2 upload URLs or external URLs
+     */
+    spritesheetUrl: string;
+    /** Width of a single frame in pixels */
+    frameWidth: number;
+    /** Height of a single frame in pixels */
+    frameHeight: number;
+    /** Total number of frames in the sprite sheet */
+    frameCount: number;
+    /**
+     * Number of frames per row (columns)
+     * - For grid layout: columns × rows = frameCount
+     * - For horizontal strip: columns = frameCount
+     */
+    columns: number;
+    /**
+     * Sprite animation frames per second
+     * Independent of video FPS - sprite animates at its own rate
+     */
+    framesPerSecond: number;
+    /** Loop the animation (default: true) */
+    loop: boolean;
+    /**
+     * Play forward then backward (ping-pong)
+     * When true: 0,1,2,3,2,1,0,1,2...
+     */
+    pingPong?: boolean;
+    /**
+     * Which frame to start on (0-indexed, default: 0)
+     */
+    startFrame?: number;
+    /** Opacity 0-1 (default: 1) */
+    opacity?: number;
+    /**
+     * CSS filter for color tinting
+     * Example: "hue-rotate(90deg)" or "sepia(1) saturate(5) hue-rotate(300deg)"
+     */
+    tintFilter?: string;
+}
+/**
+ * Video overlay content - for WebM/MP4 with alpha channel support
+ * Used for motion graphics, animated effects, and video compositing
+ */
+export interface VideoContent {
+    /**
+     * URL to the video file
+     * Supports WebM (VP9 with alpha), MP4, or any browser-supported format
+     */
+    videoUrl: string;
+    /** Loop the video (default: true) */
+    loop: boolean;
+    /** Mute the video audio (default: true for motion graphics) */
+    muted: boolean;
+    /**
+     * Playback rate (1.0 = normal speed)
+     * Range: 0.25 to 4.0
+     */
+    playbackRate?: number;
+    /**
+     * Start time offset in seconds
+     * Use to skip to a specific part of the video
+     */
+    startTime?: number;
+    /** Opacity 0-1 (default: 1) */
+    opacity?: number;
+    /** Object fit mode for video within container */
+    fit?: 'contain' | 'cover' | 'fill';
+    /**
+     * CSS filter for color effects
+     * Example: "brightness(1.2)" or "hue-rotate(90deg)"
+     */
+    filter?: string;
+}
+export type OverlayContent = TextContent | EmojiContent | ShapeContent | ImageContent | CTAContent | SpriteSequenceContent | VideoContent;
+export interface OverlayPosition {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Animation entrance/exit type
+ * - 'none': No animation (instant appear/disappear)
+ * - 'fade': Opacity fade (current default)
+ * - 'slide-left': Slide in from left / out to left
+ * - 'slide-right': Slide in from right / out to right
+ * - 'slide-top': Slide in from top / out to top
+ * - 'slide-bottom': Slide in from bottom / out to bottom
+ */
+export type AnimationType = 'none' | 'fade' | 'scale' | 'slide-left' | 'slide-right' | 'slide-top' | 'slide-bottom';
+export interface OverlayAnimation {
+    opacity: number;
+    fadeIn: number;
+    fadeOut: number;
+    /** Entrance animation type (default: 'fade') */
+    entranceType?: AnimationType;
+    /** Exit animation type (default: 'fade') */
+    exitType?: AnimationType;
+}
+/**
+ * Corner point in normalized coordinates (0-1 range)
+ * Relative to the video content area
+ */
+export interface CornerPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Corner offset - relative adjustment from the natural corner position
+ * Values are in percentage of the overlay's dimensions
+ */
+export interface CornerOffset {
+    dx: number;
+    dy: number;
+}
+/**
+ * Four corner offsets for perspective fine-tuning
+ * These are RELATIVE adjustments on top of the overlay's position/size
+ */
+export interface CornerOffsets {
+    tl: CornerOffset;
+    tr: CornerOffset;
+    br: CornerOffset;
+    bl: CornerOffset;
+}
+/**
+ * Four corners defining perspective quad (absolute positions)
+ * Order: top-left, top-right, bottom-right, bottom-left (clockwise)
+ * @deprecated Use CornerOffsets for new code - corners are computed from position + offsets
+ */
+export interface CornerPoints {
+    tl: CornerPoint;
+    tr: CornerPoint;
+    br: CornerPoint;
+    bl: CornerPoint;
+}
+/**
+ * Perspective transform configuration for corner pinning
+ *
+ * Corner pinning is a FINE-TUNING layer on top of regular transforms:
+ * 1. Position/scale/rotate sets the base overlay bounds
+ * 2. Corner offsets apply small perspective adjustments
+ *
+ * @see https://github.com/uMe-Group/Includu/issues/58
+ */
+export interface PerspectiveTransform {
+    /** Whether perspective transform is enabled */
+    enabled: boolean;
+    /**
+     * Corner offsets - relative adjustments from natural corner positions
+     * Values are percentages of the overlay's dimensions
+     * Default: all zeros (no perspective adjustment)
+     * Optional for backward compatibility - if missing, use corners or default to zeros
+     */
+    cornerOffsets?: CornerOffsets;
+    /**
+     * @deprecated Use cornerOffsets instead
+     * Kept for backward compatibility with existing saved projects
+     */
+    corners?: CornerPoints;
+}
+/**
+ * Creates default corner offsets (no perspective adjustment)
+ */
+export declare function createDefaultCornerOffsets(): CornerOffsets;
+/**
+ * Computes absolute corner positions from overlay position and corner offsets
+ * This is how corners are calculated for rendering
+ */
+export declare function computeCornersFromOffsets(position: OverlayPosition, offsets: CornerOffsets): CornerPoints;
+/**
+ * @deprecated Use createDefaultCornerOffsets instead
+ * Creates default corner points for a rectangular overlay
+ * Uses the overlay's position to calculate initial corner positions
+ */
+export declare function createDefaultCornerPoints(position: OverlayPosition): CornerPoints;
+/**
+ * Migrate old absolute corners to new offset-based format
+ * Call this when loading projects with old corner format
+ */
+export declare function migrateToCornerOffsets(position: OverlayPosition, corners: CornerPoints): CornerOffsets;
+export interface Overlay {
+    id: string;
+    /** Display name in the timeline */
+    label: string;
+    type: OverlayType;
+    /** Which timeline track this overlay belongs to (default: 'overlays') */
+    track?: OverlayTrack;
+    /** First frame where overlay is visible (inclusive) */
+    startFrame: number;
+    /** First frame where overlay is NOT visible (exclusive) */
+    endFrame: number;
+    /** Timeline bar color */
+    color?: string;
+    position: OverlayPosition;
+    animation: OverlayAnimation;
+    content: OverlayContent;
+    /** Optional perspective transform for corner pinning */
+    perspective?: PerspectiveTransform;
+    /**
+     * Z-axis rotation in degrees (0-360)
+     * Only applied when rotationEnabled is true
+     */
+    rotation?: number;
+    /**
+     * X-axis rotation in degrees (-60 to +60)
+     * Tilts forward/backward (CSS rotateX)
+     * Only applied when rotationEnabled is true
+     */
+    rotationX?: number;
+    /**
+     * Y-axis rotation in degrees (-60 to +60)
+     * Tilts left/right (CSS rotateY)
+     * Only applied when rotationEnabled is true
+     */
+    rotationY?: number;
+    /**
+     * Whether rotation is enabled (opt-in toggle)
+     * Default: false
+     */
+    rotationEnabled?: boolean;
+}
+/**
+ * Video source reference stored with a project.
+ * Supports VMS (Cloudflare Stream), local, and R2 sources.
+ */
+export interface VideoSource {
+    type: 'vms' | 'local' | 'r2';
+    vmsClipId?: string;
+    vmsStreamUid?: string;
+    vmsHlsUrl?: string;
+    vmsTitle?: string;
+    vmsThumbnail?: string;
+    vmsWidth?: number;
+    vmsHeight?: number;
+    r2Key?: string;
+}
+/**
+ * Per-project monetization settings (creator-defined).
+ * Distinct from MonetizationConfig which is the published version.
+ */
+export interface MonetizationSettings {
+    enabled: boolean;
+    revenueShare?: number;
+    restrictions?: AdRestrictions;
+    /** Whether 3D ads (Layer 2) are enabled */
+    layer2Enabled?: boolean;
+    /** Whether 2D ads are enabled */
+    layer2DEnabled?: boolean;
+}
+/**
+ * Metadata for multipart upload requests
+ */
+export interface UploadMetadata {
+    projectId: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    type: 'video' | 'proxy';
+}
+/** Subscription/access tier for a creator */
+export type CreatorTier = 'free' | 'pro' | 'enterprise';
+/**
+ * A creator account — the unified identity across Includu and Admetise.
+ *
+ * Auth-agnostic: the account stores profile data only.
+ * Authentication is handled externally (Cloudflare Access today, social login later).
+ *
+ * KV key patterns:
+ * - `creator:{id}` — primary record
+ * - `creator-email:{email}` — email → id index
+ * - `creator-slug:{slug}` — slug → id index
+ */
+export interface CreatorAccount {
+    /** Unique creator ID (generated, URL-safe) */
+    id: string;
+    /** Email address (from auth provider, used as identity key) */
+    email: string;
+    /** Display name shown on channel pages and in the editor */
+    displayName: string;
+    /** URL-friendly slug for public channel (e.g., "jorgen" → play.includu.com/@jorgen) */
+    slug: string;
+    /** Avatar/profile image URL (R2 or external) */
+    avatarUrl?: string;
+    /** Short bio for channel pages */
+    bio?: string;
+    /** Subscription tier */
+    tier: CreatorTier;
+    /** Branding settings for published content */
+    branding?: CreatorBranding;
+    /** ISO 8601 */
+    createdAt: string;
+    /** ISO 8601 */
+    updatedAt: string;
+}
+/**
+ * Per-creator branding for published content.
+ * Stored on CreatorAccount, applied during publish.
+ */
+export interface CreatorBranding {
+    /** Logo URL (R2 or external) — shown on player */
+    logoUrl?: string;
+    /** Watermark URL (R2 or external) — overlaid on recordings */
+    watermarkUrl?: string;
+    /** Primary brand color (hex, e.g. "#E53935") */
+    brandColor?: string;
+    /** Whether to show branding on published content */
+    enabled: boolean;
+}
+/**
+ * An Includu project - a set of overlay events for a video clip.
+ * This is the runtime storage format used by the API worker and KV store.
+ */
+export interface Project {
+    id: string;
+    name: string;
+    /** Creator who owns this project (absent on legacy projects) */
+    creatorId?: string;
+    createdAt: string;
+    updatedAt: string;
+    /** R2 key for uploaded video (legacy) */
+    videoKey?: string;
+    /** R2 key for proxy video (legacy) */
+    proxyKey?: string;
+    /** Frames per second for timeline */
+    fps: number;
+    /** Video duration in seconds */
+    duration: number;
+    /** Overlay events */
+    overlays: Overlay[];
+    /** Video source reference */
+    videoSource?: VideoSource;
+    /** Ad slot placements (template-based, preferred) */
+    adPlacements?: AdSlotPlacement[];
+    /** @deprecated Use adPlacements instead - kept for backwards compatibility */
+    adSlots?: AdSlot[];
+    /** Monetization settings */
+    monetization?: MonetizationSettings;
+    /** Layer 2: 3D Composite scene. null explicitly clears the field. */
+    layer2Scene?: import('./layer2').Layer2Scene | null;
+}
+export interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}
+export interface ApiError {
+    error: string;
+    message: string;
+    status: number;
+}
+/**
+ * An overlay as stored in a published project
+ */
+export interface PublishedOverlay {
+    id: string;
+    type: OverlayType;
+    /** First frame where overlay is visible (inclusive) */
+    startFrame: number;
+    /** First frame where overlay is NOT visible (exclusive) */
+    endFrame: number;
+    position: OverlayPosition;
+    animation: OverlayAnimation;
+    content: OverlayContent;
+    /** Optional perspective transform for corner pinning */
+    perspective?: PerspectiveTransform;
+    /** Z-axis rotation in degrees (0-360) */
+    rotation?: number;
+    /** X-axis rotation in degrees (-60 to +60) */
+    rotationX?: number;
+    /** Y-axis rotation in degrees (-60 to +60) */
+    rotationY?: number;
+    /** Whether rotation is enabled */
+    rotationEnabled?: boolean;
+}
+/**
+ * A published (immutable) version of a project for end-user playback
+ */
+export interface PublishedProject {
+    /** Unique publish ID (nanoid, 10 chars) */
+    publishId: string;
+    /** Source project UUID */
+    projectId: string;
+    /** Display name */
+    name: string;
+    /** Video source information */
+    video: {
+        hlsUrl: string;
+        duration: number;
+        thumbnail?: string;
+        aspectRatio?: string;
+    };
+    /** Frames per second */
+    fps: number;
+    /** Overlay events */
+    overlays: PublishedOverlay[];
+    /** Publication timestamp (ISO 8601) */
+    publishedAt: string;
+    /** Publisher identifier (email or user ID) */
+    publishedBy: string;
+    /** Version number for tracking republishes */
+    version: number;
+    /** Optional branding configuration */
+    branding?: {
+        logo?: string;
+        accentColor?: string;
+        showPoweredBy?: boolean;
+    };
+    /** Monetization configuration (optional, for Admetise integration) */
+    monetization?: MonetizationConfig;
+    /** Layer 2 (3D composite) scene data */
+    layer2Scene?: import('./layer2').Layer2Scene;
+}
+/**
+ * Public manifest returned by the API for player consumption
+ */
+export interface PublishedManifest {
+    publishId: string;
+    name: string;
+    video: {
+        hlsUrl: string;
+        duration: number;
+        thumbnail?: string;
+        aspectRatio?: string;
+    };
+    fps: number;
+    overlays: PublishedOverlay[];
+    branding?: {
+        logo?: string;
+        accentColor?: string;
+        showPoweredBy?: boolean;
+    };
+    links: {
+        player: string;
+        embed: string;
+        embedCode: string;
+        /** Participation URL (only if participation is enabled) */
+        participate?: string;
+    };
+    /** Monetization configuration (optional, for Admetise integration) */
+    monetization?: MonetizationConfig;
+    /** Layer 2 (3D composite) scene data */
+    layer2Scene?: import('./layer2').Layer2Scene;
+    /** Layer 2 player options */
+    layer2Options?: {
+        /** Show 3D ads in view-only mode (when not participating) */
+        show3DAdsInViewMode?: boolean;
+        /** Show participation preview silhouette for non-participants */
+        showParticipationPreview?: boolean;
+    };
+    /**
+     * Creator's webcam runtime settings for preview mode.
+     * When present, the player pre-loads these settings so the creator
+     * can instantly see their work without reconfiguring from scratch.
+     * Only set during preview, never during publish.
+     */
+    previewWebcamSettings?: import('./layer2').PreviewWebcamSettings;
+}
+/**
+ * Session metadata for a recorded participation.
+ *
+ * Captures everything needed to re-publish the participant's recording
+ * as a new monetizable version with dynamic overlays and ads.
+ *
+ * Classify an overlay for recording: should it be burned into the video
+ * (static visual) or kept as dynamic metadata (interactive/monetizable)?
+ *
+ * Some overlays (e.g., clickable images) are BOTH — burned visually into
+ * the recording but also preserved as dynamic metadata so their click URL
+ * can be restored when re-publishing.
+ */
+export declare function classifyOverlayForRecording(overlay: PublishedOverlay): {
+    burnable: boolean;
+    dynamic: boolean;
+};
+/**
+ * Session metadata for a participation recording.
+ *
+ * PRINCIPLES:
+ * - Static visual overlays (text, images, shapes) are BURNED into the recording
+ * - Interactive/monetizable overlays (CTAs) are stored as DYNAMIC REFERENCES
+ * - This preserves the content creator's ability to:
+ *   - Update CTA links, ad content, and text after the fact
+ *   - Serve different ads to different viewers
+ *   - Monetize derivative content through revenue sharing
+ *   - Keep interactive elements (clickable CTAs) working
+ */
+export interface SessionMetadata {
+    /** Schema version for forward compatibility */
+    version: 1;
+    /** When the recording was made (ISO 8601) */
+    recordedAt: string;
+    /** Recording duration in ms */
+    durationMs: number;
+    /** Output format */
+    format: {
+        mimeType: string;
+        codec: string;
+    };
+    /** Output resolution */
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** Recording FPS (matches source video) */
+    fps: number;
+    /** Background video reference (for re-compositing) */
+    background: {
+        hlsUrl: string;
+        startTimeMs: number;
+        durationMs: number;
+        aspectRatio: string;
+    };
+    /** Webcam composite settings (Gausst coordinates) */
+    participation: {
+        position: [number, number, number];
+        rotation: [number, number, number];
+        scale: number;
+        framingType: string;
+        backgroundMethod: string;
+    };
+    /**
+     * Overlay definitions — stored as REFERENCES, not burned in.
+     * These enable re-publishing with dynamic, editable, monetizable overlays.
+     */
+    overlayDefinitions: Array<{
+        id: string;
+        type: string;
+        startFrame: number;
+        endFrame: number;
+        position: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        content: unknown;
+    }>;
+    /** 3D ad placement references — dynamic, can be swapped/updated */
+    adPlacements: Array<{
+        id: string;
+        startFrame: number;
+        endFrame: number;
+        position: [number, number, number];
+        rotation: [number, number, number];
+        scale: number;
+    }>;
+    /** Camera settings (Gausst coordinate system) */
+    camera: {
+        fov: number;
+        position: [number, number, number];
+        rotation: [number, number, number];
+    };
+    /** Source manifest reference */
+    sourceManifest: {
+        publishId: string;
+        name: string;
+        fps: number;
+    };
+    /** Whether audio was captured */
+    hasAudio: boolean;
+    /**
+     * Overlays that were burned into the recording video track.
+     * These are static visual overlays (text, images, shapes, emoji).
+     */
+    burnedOverlays?: Array<{
+        id: string;
+        type: string;
+        startFrame: number;
+        endFrame: number;
+        position: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        content: unknown;
+    }>;
+    /**
+     * Dynamic overlays NOT burned in — interactive/monetizable.
+     * CTAs and clickable images are kept as references for re-publishing.
+     */
+    dynamicOverlays?: Array<{
+        id: string;
+        type: string;
+        startFrame: number;
+        endFrame: number;
+        position: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        content: unknown;
+    }>;
+    /**
+     * Multi-camera shot cuts during the recording window.
+     * Each entry marks a camera/webcam transform change at a frame offset.
+     * Enables NLE editors to recreate camera switches in post-production.
+     */
+    shotCuts?: Array<{
+        /** Frame offset relative to recording start (0 = first frame) */
+        frameOffset: number;
+        /** Shot preset ID from the published manifest */
+        presetId: string;
+        /** Camera settings at this cut */
+        camera: {
+            fov: number;
+            position: [number, number, number];
+            rotation: [number, number, number];
+        };
+        /** Webcam transform at this cut (if different from base) */
+        webcamTransform?: {
+            position: [number, number, number];
+            rotation: [number, number, number];
+            scale: number;
+        };
+    }>;
+}
+/**
+ * Recording tier determines duration and size limits.
+ *
+ * Tier is inherited from the creator's account plan (stored on the published
+ * manifest). Until creator accounts (#134, #136) are implemented, all
+ * recordings default to 'standard'.
+ *
+ * Access model: recordings are "unlisted" — accessible by anyone with the
+ * 12-character random recordingId URL, but not discoverable via browsing
+ * or search. Similar to YouTube unlisted videos.
+ */
+export type RecordingTier = 'free' | 'standard' | 'professional';
+export interface RecordingTierLimits {
+    /** Maximum recording duration in milliseconds */
+    maxDurationMs: number;
+    /** Maximum file size in bytes */
+    maxFileSize: number;
+    /** Human-readable label */
+    label: string;
+}
+export declare const RECORDING_TIER_LIMITS: Record<RecordingTier, RecordingTierLimits>;
+/**
+ * Stored manifest for a participant recording.
+ * Saved in KV when a participant uploads their recording.
+ */
+export interface RecordingManifest {
+    /** Unique recording identifier */
+    recordingId: string;
+    /** Published video this recording was made against */
+    publishId: string;
+    /** Participant display name (optional) */
+    participantName?: string;
+    /** When the recording was uploaded (ISO 8601) */
+    uploadedAt: string;
+    /** Recording duration in ms */
+    durationMs: number;
+    /** File size in bytes */
+    fileSizeBytes: number;
+    /** Output format */
+    format: {
+        mimeType: string;
+        codec: string;
+        extension: string;
+    };
+    /** Output resolution */
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** Whether audio was captured */
+    hasAudio: boolean;
+    /** R2 key for the video file */
+    videoKey: string;
+    /** R2 key for the session metadata JSON */
+    metadataKey: string;
+    /** Full session metadata for re-compositing */
+    sessionMetadata: SessionMetadata;
+    /** Recording tier (determines duration/size limits) */
+    tier?: RecordingTier;
+}
+/**
+ * Type of ad placement slot
+ */
+export type AdSlotType = 'preroll' | 'midroll' | 'postroll' | 'overlay' | 'companion';
+/**
+ * Position for overlay/companion ad slots
+ */
+export type AdSlotPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+/**
+ * Category of ad template
+ */
+export type AdTemplateCategory = 'video' | 'display' | 'companion';
+/**
+ * Ad slot template defined and managed by Admetise
+ *
+ * This is the SOURCE OF TRUTH for ad formats. Admetise defines what
+ * ad placements are available, and Includu content creators select
+ * from these templates when placing ads in their content.
+ *
+ * Templates follow IAB standards where applicable.
+ *
+ * @see https://github.com/uMe-Group/Includu/issues/47
+ */
+export interface AdSlotTemplate {
+    /** Unique template identifier (e.g., "iab-medium-rectangle") */
+    id: string;
+    /** Display name (e.g., "Medium Rectangle (300×250)") */
+    name: string;
+    /** Description of the ad format */
+    description: string;
+    /** Type of ad placement */
+    type: AdSlotType;
+    /** Category for grouping in UI */
+    category: AdTemplateCategory;
+    /** Fixed width in pixels (for display/companion ads) */
+    width?: number;
+    /** Fixed height in pixels (for display/companion ads) */
+    height?: number;
+    /** Position for overlay ads */
+    position?: AdSlotPosition;
+    /** Default duration in seconds (for video ads) */
+    duration?: number;
+    /** Minimum duration in seconds */
+    minDuration?: number;
+    /** Maximum duration in seconds */
+    maxDuration?: number;
+    /** IAB standard size identifier (e.g., "300x250") */
+    iabSize?: string;
+    /** Whether this template is currently active/available */
+    active: boolean;
+    /** Sort order for UI display */
+    sortOrder?: number;
+    /** Icon identifier for UI */
+    icon?: string;
+}
+/**
+ * Ad slot placement by content creator in Includu
+ *
+ * References a template from Admetise and adds timing information.
+ * The creator controls WHEN ads appear, not WHAT format they are.
+ */
+export interface AdSlotPlacement {
+    /** Unique placement identifier */
+    id: string;
+    /** Reference to AdSlotTemplate.id (from Admetise) */
+    templateId: string;
+    /** Frame number when ad should trigger (for midroll/overlay) */
+    triggerFrame?: number;
+    /** Percentage of video when ad should trigger (0-100) */
+    triggerPercent?: number;
+    /** Whether this placement is required (must show ad) */
+    required?: boolean;
+    /**
+     * Center position in normalized coordinates (0-1)
+     * Default: {x: 0.5, y: 0.5} (centered)
+     */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Scale factor relative to template size
+     * 1.0 = template size (minimum), max 3.0 (300%)
+     * Default: 1.0
+     */
+    scale?: number;
+    /**
+     * Z-axis rotation in degrees (0-360)
+     * Only applied when rotationEnabled is true
+     * Default: 0
+     */
+    rotation?: number;
+    /**
+     * X-axis rotation in degrees (-60 to +60)
+     * Tilts forward/backward (CSS rotateX)
+     * Only applied when rotationEnabled is true
+     * Default: 0
+     */
+    rotationX?: number;
+    /**
+     * Y-axis rotation in degrees (-60 to +60)
+     * Tilts left/right (CSS rotateY)
+     * Only applied when rotationEnabled is true
+     * Default: 0
+     */
+    rotationY?: number;
+    /**
+     * Whether rotation is enabled (opt-in toggle)
+     * Default: false
+     */
+    rotationEnabled?: boolean;
+    /**
+     * Custom duration in seconds (creator override)
+     * Must be >= template.maxDuration (can only extend, not shrink)
+     * If not set, uses template.maxDuration
+     */
+    customDuration?: number;
+    /**
+     * Perspective transform for corner pinning (opt-in)
+     * Enables placing ads on surfaces in video (billboards, screens, etc.)
+     * When enabled, overrides position/scale/rotation transforms
+     * @see https://github.com/uMe-Group/Includu/issues/58
+     */
+    perspective?: PerspectiveTransform;
+    /**
+     * Animation settings for ad zone entrance/exit
+     * Similar to overlay animations but simplified
+     */
+    animation?: {
+        /** Entrance animation type (default: 'none') */
+        entranceType?: AnimationType;
+        /** Exit animation type (default: 'none') */
+        exitType?: AnimationType;
+        /** Entrance animation duration in frames (default: 0) */
+        entranceFrames?: number;
+        /** Exit animation duration in frames (default: 0) */
+        exitFrames?: number;
+    };
+}
+/**
+ * @deprecated Use AdSlotPlacement instead. Kept for backwards compatibility.
+ */
+export interface AdSlot {
+    /** Unique slot identifier */
+    id: string;
+    /** Type of ad placement */
+    type: AdSlotType;
+    /** Position for overlay/companion slots */
+    position?: AdSlotPosition;
+    /** Slot width in pixels (for overlay/companion) */
+    width?: number;
+    /** Slot height in pixels (for overlay/companion) */
+    height?: number;
+    /** Frame number when midroll should trigger */
+    triggerFrame?: number;
+    /** Percentage of video when midroll should trigger (0-100) */
+    triggerPercent?: number;
+    /** Maximum ad duration in seconds */
+    maxDuration?: number;
+    /** Whether this slot must be filled with an ad */
+    required?: boolean;
+    /** Reference to template (new field for migration) */
+    templateId?: string;
+}
+/**
+ * Ad zone in Admetise (created when importing from Includu)
+ *
+ * Represents an actual ad placement that can be filled with campaign ads.
+ * Created by importing content from Includu and resolving template references.
+ */
+export interface AdZone {
+    /** Zone identifier (matches source placement ID) */
+    id: string;
+    /** Reference to the template used */
+    templateId: string;
+    /** Type of ad placement (from template) */
+    type: AdSlotType;
+    /** Whether this zone is active */
+    enabled: boolean;
+    /** Preset position for overlay/companion zones (from template, used as fallback) */
+    presetPosition?: AdSlotPosition;
+    /** Zone width in pixels (from template, used for aspect ratio) */
+    width?: number;
+    /** Zone height in pixels (from template, used for aspect ratio) */
+    height?: number;
+    /** Trigger time in seconds (converted from frames) */
+    triggerTime?: number;
+    /** Percentage of video to trigger (0-100) */
+    triggerPercent?: number;
+    /** VAST/VPAID ad tag URL (configured by advertiser) */
+    adTagUrl?: string;
+    /** Max duration in seconds (from template) */
+    maxDuration?: number;
+    /**
+     * Center position in normalized coordinates (0-1)
+     * Takes precedence over presetPosition when set
+     */
+    centerPosition?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Scale factor (1.0 = base size, max 3.0)
+     */
+    scale?: number;
+    /**
+     * Z-axis rotation in degrees (0-360)
+     * Only applied when rotationEnabled is true
+     */
+    rotation?: number;
+    /**
+     * X-axis rotation in degrees (-60 to +60)
+     * Tilts forward/backward (CSS rotateX)
+     * Only applied when rotationEnabled is true
+     */
+    rotationX?: number;
+    /**
+     * Y-axis rotation in degrees (-60 to +60)
+     * Tilts left/right (CSS rotateY)
+     * Only applied when rotationEnabled is true
+     */
+    rotationY?: number;
+    /**
+     * Whether rotation is enabled
+     */
+    rotationEnabled?: boolean;
+    /**
+     * Perspective transform for corner pinning
+     * When set, the ad is rendered with perspective correction to fit surfaces
+     * @see https://github.com/uMe-Group/Includu/issues/58
+     */
+    perspective?: PerspectiveTransform;
+}
+/**
+ * Age rating for content
+ */
+export type AgeRating = 'G' | 'PG' | 'PG-13' | 'R';
+/**
+ * Content restrictions for ad targeting
+ */
+export interface AdRestrictions {
+    /** Categories that should not advertise on this content */
+    blockedCategories?: string[];
+    /** Content age rating */
+    ageRating?: AgeRating;
+}
+/**
+ * Monetization configuration for published content
+ *
+ * Defined by content creator in Includu, consumed by Admetise.
+ * Uses template-based placements for consistency.
+ */
+export interface MonetizationConfig {
+    /** Whether monetization is enabled */
+    enabled: boolean;
+    /** Ad slot placements (references templates) */
+    placements: AdSlotPlacement[];
+    /**
+     * @deprecated Use placements instead. Kept for backwards compatibility.
+     */
+    adSlots?: AdSlot[];
+    /** Creator's revenue share percentage (0-100) */
+    revenueShare?: number;
+    /** Content restrictions for ad targeting */
+    restrictions?: AdRestrictions;
+    /** Whether 3D ads (Layer 2) are enabled */
+    layer2Enabled?: boolean;
+    /** Whether 2D ads are enabled */
+    layer2DEnabled?: boolean;
+}
+/**
+ * Standard ad slot templates following IAB guidelines
+ * These are the default templates that Admetise provides.
+ * Can be extended/modified via Admetise admin.
+ */
+export declare const STANDARD_AD_TEMPLATES: AdSlotTemplate[];
+/**
+ * Find a template by ID
+ *
+ * @param templateId - The template ID to find
+ * @param templates - Array of templates (defaults to STANDARD_AD_TEMPLATES)
+ * @returns The template or undefined
+ */
+export declare function findTemplate(templateId: string, templates?: AdSlotTemplate[]): AdSlotTemplate | undefined;
+/**
+ * Maps an AdSlotPlacement to an AdZone using template data
+ *
+ * @param placement - The placement from Includu
+ * @param template - The template definition from Admetise
+ * @param fps - Frames per second of the video
+ * @returns AdZone for Admetise
+ */
+export declare function mapPlacementToZone(placement: AdSlotPlacement, template: AdSlotTemplate, fps: number): AdZone;
+/**
+ * @deprecated Use mapPlacementToZone instead
+ * Maps an Includu AdSlot to an Admetise AdZone (legacy support)
+ */
+export declare function mapAdSlotToZone(slot: AdSlot, fps: number): AdZone;
+/**
+ * Maps all placements from a manifest to AdZones
+ *
+ * @param manifest - Published manifest with monetization config
+ * @param templates - Available templates (defaults to STANDARD_AD_TEMPLATES)
+ * @returns Array of AdZones, or empty array if monetization disabled
+ */
+export declare function mapManifestToZones(manifest: PublishedManifest, templates?: AdSlotTemplate[]): AdZone[];
+/**
+ * Get templates grouped by category
+ *
+ * @param templates - Array of templates (defaults to STANDARD_AD_TEMPLATES)
+ * @returns Object with templates grouped by category
+ */
+export declare function getTemplatesByCategory(templates?: AdSlotTemplate[]): Record<AdTemplateCategory, AdSlotTemplate[]>;
+/**
+ * Get templates filtered by type
+ *
+ * @param type - The ad slot type to filter by
+ * @param templates - Array of templates (defaults to STANDARD_AD_TEMPLATES)
+ * @returns Filtered templates
+ */
+export declare function getTemplatesByType(type: AdSlotType, templates?: AdSlotTemplate[]): AdSlotTemplate[];
+export { computeMatrix3d, isValidQuad } from './perspective';
+export * from './layer2';
+export * from './campaigns';
+export * from './adserving';
+export * from './gausst';
+/**
+ * Category for overlay templates
+ */
+export type OverlayTemplateCategory = 'titles' | 'lower-thirds' | 'badges' | 'cta' | 'social' | 'graphics' | 'motion-gfx';
+/**
+ * Overlay template preset definition
+ * Used to quickly create common overlay patterns
+ */
+export interface OverlayTemplatePreset {
+    /** Unique template identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Short description */
+    description: string;
+    /** Category for grouping */
+    category: OverlayTemplateCategory;
+    /** Icon/emoji for quick visual identification */
+    icon: string;
+    /** Overlay type */
+    type: 'text' | 'cta' | 'shape' | 'emoji' | 'image' | 'sprite-sequence' | 'video';
+    /** Default position (percentage 0-100) */
+    position: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Default duration in seconds */
+    durationSeconds: number;
+    /** Text content defaults (for text overlays) */
+    textDefaults?: {
+        text: string;
+        fontSize: number;
+        fontFamily: string;
+        fontWeight: 'normal' | 'bold';
+        color: string;
+        textAlign: 'left' | 'center' | 'right';
+        background?: {
+            color: string;
+            opacity: number;
+            padding: {
+                x: number;
+                y: number;
+            };
+            scale: number;
+            borderRadius: number;
+        };
+    };
+    /** CTA content defaults (for CTA overlays) */
+    ctaDefaults?: {
+        text: string;
+        url: string;
+        style: {
+            backgroundColor: string;
+            textColor: string;
+            borderRadius: number;
+            fontSize: number;
+            fontWeight: 'normal' | 'bold';
+            padding: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+    /** Emoji content defaults (for emoji overlays) */
+    emojiDefaults?: {
+        emoji: string;
+        size: number;
+    };
+    /** Image content defaults (for image overlays) */
+    imageDefaults?: {
+        src: string;
+        alt: string;
+        fit: 'contain' | 'cover' | 'fill';
+        opacity: number;
+        borderRadius: number;
+        /** Optional click URL to make the image clickable */
+        clickUrl?: string;
+    };
+    /**
+     * Whether this template should have perspective/corner pinning enabled by default
+     * Used for templates like Picture Frame / Screen Replace
+     */
+    perspectiveEnabled?: boolean;
+    /** Sprite sequence content defaults (for sprite-sequence overlays) */
+    spriteDefaults?: {
+        spritesheetUrl: string;
+        frameWidth: number;
+        frameHeight: number;
+        frameCount: number;
+        columns: number;
+        framesPerSecond: number;
+        loop: boolean;
+        pingPong?: boolean;
+        startFrame?: number;
+        opacity?: number;
+    };
+    /** Video content defaults (for video overlays with alpha) */
+    videoDefaults?: {
+        videoUrl: string;
+        loop: boolean;
+        muted: boolean;
+        playbackRate?: number;
+        startTime?: number;
+        opacity?: number;
+        fit?: 'contain' | 'cover' | 'fill';
+    };
+}
+/**
+ * Standard overlay template presets
+ * Designed for ease of use across all devices
+ */
+export declare const OVERLAY_TEMPLATE_PRESETS: OverlayTemplatePreset[];
+/**
+ * Get overlay templates by category
+ */
+export declare function getOverlayTemplatesByCategory(category: OverlayTemplateCategory): OverlayTemplatePreset[];
+/**
+ * Find an overlay template by ID
+ */
+export declare function findOverlayTemplate(id: string): OverlayTemplatePreset | undefined;
+/**
+ * Get all overlay template categories with their templates
+ */
+export declare function getOverlayTemplateCategoriesWithTemplates(): {
+    category: OverlayTemplateCategory;
+    label: string;
+    templates: OverlayTemplatePreset[];
+}[];
+/**
+ * Get overlay template categories for the Overlays track (excludes branding categories)
+ */
+export declare function getOverlayTrackCategories(): {
+    category: OverlayTemplateCategory;
+    label: string;
+    templates: OverlayTemplatePreset[];
+}[];
+/**
+ * Get branding template categories for the Branding track
+ */
+export declare function getBrandingTrackCategories(): {
+    category: OverlayTemplateCategory;
+    label: string;
+    templates: OverlayTemplatePreset[];
+}[];
+/**
+ * Get Motion Graphics template categories for the Motion GFX track
+ */
+export declare function getMotionGfxTrackCategories(): {
+    category: OverlayTemplateCategory;
+    label: string;
+    templates: OverlayTemplatePreset[];
+}[];
+/**
+ * @deprecated Use getMotionGfxTrackCategories instead
+ */
+export declare function get3DTrackCategories(): {
+    category: OverlayTemplateCategory;
+    label: string;
+    templates: OverlayTemplatePreset[];
+}[];
+/**
+ * Coordinate system constants for Three.js video compositing
+ *
+ * Based on Gausst legacy code (Patent US8761580B2):
+ * - Y-up axis (Three.js default)
+ * - Metric units: 1 unit = 1 meter
+ * - Reference: 1920 video pixels = 1 meter
+ *
+ * @see docs/architecture/coordinate-system-design.md
+ */
+export declare const COORDINATE_SYSTEM: {
+    /**
+     * Reference scale: 1920 pixels = 1 meter in world space
+     * This ensures a standard 1920×1080 video is 1m × 0.5625m
+     */
+    readonly PIXELS_PER_METER: 1920;
+    /**
+     * Layer Z positions in meters
+     * - VIDEO: Background video plane
+     * - THREE_D_MIN/MAX: 3D tracked surfaces, webcam
+     * - HUD_MIN/MAX: HTML overlays via CSS2DRenderer
+     */
+    readonly LAYER_Z: {
+        readonly VIDEO: 0;
+        readonly THREE_D_MIN: 0.01;
+        readonly THREE_D_MAX: 10;
+        readonly HUD_MIN: 10.1;
+        readonly HUD_MAX: 100;
+    };
+    /**
+     * Camera defaults for orthographic rendering (video plane)
+     */
+    readonly CAMERA: {
+        readonly NEAR: 0.01;
+        readonly FAR: 1000;
+        readonly POSITION_Z: 50;
+    };
+    /**
+     * Orthographic camera settings for HUD overlays (Layer 3)
+     * Provides predictable 2D positioning for sprites, text, CTAs
+     *
+     * Bounds are set dynamically based on video dimensions.
+     * Objects are positioned in meters relative to center (0,0).
+     */
+    readonly HUD_CAMERA: {
+        /** Camera Z position (arbitrary for orthographic) */
+        readonly POSITION_Z: 10;
+        /** Near clipping plane */
+        readonly NEAR: 0.1;
+        /** Far clipping plane */
+        readonly FAR: 100;
+        /** Default object Z position */
+        readonly OBJECT_Z: 0;
+    };
+    /**
+     * Perspective camera settings for webcam composite layer (Layer 2)
+     * Camera positioned at eye height for 3D scene placement
+     * Reserved for future webcam/chroma key compositing
+     */
+    readonly SCENE_CAMERA: {
+        /** Camera X position (centered) */
+        readonly POSITION_X: 0;
+        /** Camera Y position (eye height) */
+        readonly POSITION_Y: 1.2;
+        /** Camera Z position (distance from scene) */
+        readonly POSITION_Z: 4;
+        /** Vertical field of view in degrees (~43mm equivalent) */
+        readonly FOV: 47;
+        /** Near clipping plane */
+        readonly NEAR: 0.1;
+        /** Far clipping plane */
+        readonly FAR: 100;
+        /** Look-at target Y position */
+        readonly LOOK_AT_Y: 1.2;
+    };
+    /**
+     * Film gate constants (for future camera matching)
+     * Based on 35mm full-frame sensor
+     */
+    readonly FILM_GATE: {
+        readonly HORIZONTAL_APERTURE: 1.417;
+        readonly VERTICAL_APERTURE: 0.945;
+    };
+};
+/**
+ * Convert video pixel dimensions to world-space meters
+ *
+ * @param pixelWidth - Video width in pixels
+ * @param pixelHeight - Video height in pixels
+ * @returns World-space dimensions in meters
+ */
+export declare function pixelsToMeters(pixelWidth: number, pixelHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Convert world-space meters to video pixels
+ *
+ * @param meterWidth - Width in meters
+ * @param meterHeight - Height in meters
+ * @returns Pixel dimensions
+ */
+export declare function metersToPixels(meterWidth: number, meterHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Convert overlay percentage position (0-100) to world-space meters
+ *
+ * @param percentX - X position as percentage (0-100, left to right)
+ * @param percentY - Y position as percentage (0-100, top to bottom)
+ * @param videoWidthMeters - Video width in meters
+ * @param videoHeightMeters - Video height in meters
+ * @returns World-space position {x, y} in meters, centered at origin
+ */
+export declare function percentToWorldSpace(percentX: number, percentY: number, videoWidthMeters: number, videoHeightMeters: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Convert world-space meters to overlay percentage position (0-100)
+ *
+ * @param worldX - X position in meters (origin = center)
+ * @param worldY - Y position in meters (origin = center)
+ * @param videoWidthMeters - Video width in meters
+ * @param videoHeightMeters - Video height in meters
+ * @returns Percentage position {x, y} (0-100)
+ */
+export declare function worldSpaceToPercent(worldX: number, worldY: number, videoWidthMeters: number, videoHeightMeters: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Camera tracking data format (from Gausst legacy)
+ * Position: mm × 100, Rotation: degrees × 1000
+ */
+export interface TrackingPacket {
+    x: number;
+    y: number;
+    z: number;
+    pan: number;
+    tilt: number;
+    roll: number;
+    fov: number;
+    focus: number;
+}
+/**
+ * Convert Gausst tracking packet to world-space transform
+ *
+ * @param packet - Raw tracking data from hardware
+ * @returns Position in meters, rotation in radians, FOV in degrees
+ */
+export declare function trackingPacketToWorldSpace(packet: TrackingPacket): {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    fov: number;
+};
+/**
+ * Convert FOV to focal length (for matching real camera optics)
+ *
+ * Formula from Gausst: focalLength = (aperture / 2) / tan(fov / 2) * 25.4
+ *
+ * @param fovDegrees - Field of view in degrees
+ * @param filmApertureInches - Horizontal film aperture (default: 1.417" = 36mm)
+ * @returns Focal length in millimeters
+ */
+export declare function fovToFocalLength(fovDegrees: number, filmApertureInches?: number): number;
+/**
+ * Convert focal length to FOV
+ *
+ * @param focalLengthMM - Focal length in millimeters
+ * @param filmApertureInches - Horizontal film aperture (default: 1.417" = 36mm)
+ * @returns Field of view in degrees
+ */
+export declare function focalLengthToFov(focalLengthMM: number, filmApertureInches?: number): number;
+export { webcamVertexShader, webcamFragmentShader, getDefaultPlayerUniforms, getDefaultEditorUniforms, type WebcamShaderUniforms } from './layer2/shaders';
+export { WEBCAM_BASE_HEIGHT_METERS, SILHOUETTE_HEIGHT_RATIO, getWebcamBaseDimensions, getWebcamMeshYOffset, getObjectEuler, getCameraEuler, GAM_PIXELS_TO_METERS, AD_TEMPLATE_DIMENSIONS, getAdDimensions, CHROMA_KEY_COLORS, getChromaKeyColorHex, featherToUV, featherEdgesToUV } from './layer2/webcam-utils';
+//# sourceMappingURL=index.d.ts.map