Traditional Content Economy:
Creator makes content → Platform takes it → Creator gets nothing

UCI Model:
Creator makes content → Registers with iris → Gets paid every time it's used

┌─────────────────────────────────────────────────────────────────────────┐
│                         UCI FLOW                                        │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   CREATOR                      PLATFORM                    BUYER        │
│   ┌─────────┐                 ┌─────────┐               ┌─────────┐    │
│   │ Creates │                 │ Stores  │               │ Searches│    │
│   │ Content │────Register────▶│ License │◀───Browse─────│ Content │    │
│   └─────────┘                 └─────────┘               └─────────┘    │
│        │                           │                          │         │
│        │                           │                          │         │
│   ┌─────────┐                 ┌─────────┐               ┌─────────┐    │
│   │  Iris   │                 │ Escrow  │               │Purchase │    │
│   │ Verify  │◀───Identity─────│ Payment │◀───Payment────│ License │    │
│   └─────────┘                 └─────────┘               └─────────┘    │
│        │                           │                          │         │
│        ▼                           ▼                          ▼         │
│   ┌─────────┐                 ┌─────────┐               ┌─────────┐    │
│   │ Receive │                 │ Track   │               │  Use    │    │
│   │ Payout  │◀───Distribute───│ Usage   │───License────▶│ Content │    │
│   └─────────┘                 └─────────┘               └─────────┘    │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

CREATE TABLE creator_profiles (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  canonical_id text UNIQUE NOT NULL,
  user_id uuid REFERENCES users(id) UNIQUE,
  
  -- Identity
  display_name text NOT NULL,
  bio text,
  avatar_url text,
  
  -- Verification levels
  verification_level text DEFAULT 'unverified',
  -- 'unverified' → 'email_verified' → 'id_verified' → 'iris_verified'
  
  -- Iris verification
  iris_verified boolean DEFAULT false,
  iris_signature_hash text,               -- Hashed iris data (never store raw)
  iris_verified_at timestamptz,
  iris_provider text,                     -- 'worldcoin', 'internal'
  
  -- Platform connections
  connected_platforms jsonb DEFAULT '{}', -- {"instagram": "@handle", "tiktok": "@handle"}
  
  -- Performance stats
  total_licenses integer DEFAULT 0,
  total_revenue numeric DEFAULT 0,
  avg_license_price numeric,
  
  -- Settings
  payout_method text,                     -- 'stripe', 'paypal', 'crypto'
  payout_threshold numeric DEFAULT 50,    -- Minimum before payout
  
  created_at timestamptz DEFAULT now(),
  updated_at timestamptz DEFAULT now()
);

CREATE TABLE creator_licenses (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  canonical_id text UNIQUE NOT NULL,
  creator_id uuid REFERENCES creator_profiles(id),
  
  -- Content identification
  content_type text NOT NULL,             -- 'video', 'image', 'audio', 'text', 'template'
  content_url text,                       -- Cloudinary or original URL
  thumbnail_url text,
  
  -- Content metadata
  title text,
  description text,
  tags text[],
  
  -- Verification
  content_hash text,                      -- SHA256 for authenticity
  original_platform text,                 -- Where content was first posted
  original_post_url text,
  
  -- License terms
  license_type text NOT NULL,             -- 'single_use', 'unlimited', 'exclusive', 'subscription'
  
  -- Pricing
  price_per_use numeric,                  -- For single_use
  price_unlimited numeric,                -- For unlimited license
  price_exclusive numeric,                -- For exclusive rights
  
  -- Usage limits
  usage_limit integer,                    -- Max uses (null = unlimited)
  usage_count integer DEFAULT 0,
  
  -- Exclusivity
  is_exclusive boolean DEFAULT false,
  exclusive_buyer_id uuid,
  exclusive_until timestamptz,
  
  -- Availability
  is_active boolean DEFAULT true,
  available_until timestamptz,
  
  created_at timestamptz DEFAULT now(),
  updated_at timestamptz DEFAULT now()
);

CREATE INDEX idx_licenses_creator ON creator_licenses(creator_id);
CREATE INDEX idx_licenses_type ON creator_licenses(content_type);
CREATE INDEX idx_licenses_active ON creator_licenses(is_active) WHERE is_active = true;

const pricingMatrix = {
  video: {
    single_use: { min: 25, suggested: 75, max: 500 },
    unlimited: { min: 100, suggested: 300, max: 2000 },
    exclusive: { min: 500, suggested: 1500, max: 10000 }
  },
  image: {
    single_use: { min: 5, suggested: 25, max: 100 },
    unlimited: { min: 25, suggested: 100, max: 500 },
    exclusive: { min: 100, suggested: 500, max: 2500 }
  },
  audio: {
    single_use: { min: 10, suggested: 50, max: 200 },
    unlimited: { min: 50, suggested: 200, max: 1000 },
    exclusive: { min: 200, suggested: 750, max: 5000 }
  },
  template: {
    single_use: { min: 5, suggested: 15, max: 50 },
    unlimited: { min: 25, suggested: 75, max: 200 },
    exclusive: { min: 100, suggested: 300, max: 1000 }
  }
};

Purchase Price: $100
        ↓
Platform Fee (15%): $15
        ↓
Creator Payout: $85

Level 0: Unverified
├── Can browse content
├── Cannot license
└── Cannot earn

Level 1: Email Verified
├── Can license content
├── 15% platform fee
└── $100 payout threshold

Level 2: ID Verified
├── Can license content
├── 12% platform fee
└── $50 payout threshold

Level 3: Iris Verified ⭐
├── Full UCI access
├── 10% platform fee
├── $25 payout threshold
├── Priority support
└── Exclusive features

async function registerContent(creatorId, contentData) {
  // 1. Verify creator is iris-verified
  const creator = await getCreator(creatorId);
  if (!creator.iris_verified) {
    throw new Error('Iris verification required to register content');
  }
  
  // 2. Generate content hash for authenticity
  const contentHash = await generateContentHash(contentData.file);
  
  // 3. Check for duplicates
  const duplicate = await findByHash(contentHash);
  if (duplicate) {
    throw new Error('Content already registered');
  }
  
  // 4. Upload to permanent storage
  const cloudinaryResult = await uploadToCloudinary(contentData.file);
  
  // 5. Create license record
  const license = await supabase
    .from('creator_licenses')
    .insert({
      creator_id: creatorId,
      content_type: contentData.type,
      content_url: cloudinaryResult.secure_url,
      thumbnail_url: cloudinaryResult.thumbnail_url,
      content_hash: contentHash,
      title: contentData.title,
      description: contentData.description,
      tags: contentData.tags,
      license_type: contentData.licenseType,
      price_per_use: contentData.pricePerUse,
      price_unlimited: contentData.priceUnlimited,
      is_active: true
    })
    .select()
    .single();
  
  // 6. Update creator stats
  await supabase.rpc('increment_creator_licenses', { 
    creator_id: creatorId 
  });
  
  return license;
}

-- Find licensable content by type and tags
SELECT 
  cl.id,
  cl.title,
  cl.content_type,
  cl.thumbnail_url,
  cl.price_per_use,
  cl.price_unlimited,
  cp.display_name as creator_name,
  cp.iris_verified
FROM creator_licenses cl
JOIN creator_profiles cp ON cl.creator_id = cp.id
WHERE cl.is_active = true
  AND cl.content_type = 'video'
  AND cl.tags && ARRAY['golf', 'tutorial']
ORDER BY cp.iris_verified DESC, cl.usage_count DESC
LIMIT 20;

-- Find visually similar content
SELECT 
  cl.id,
  cl.title,
  cl.thumbnail_url,
  1 - (ca.visual_embedding <=> target_embedding) as similarity
FROM creator_licenses cl
JOIN content_analysis ca ON cl.content_url = ca.content_url
WHERE cl.is_active = true
ORDER BY ca.visual_embedding <=> target_embedding
LIMIT 10;

// Publisher licenses a video for a blog post
async function licenseForPost(postId, licenseId) {
  const license = await getLicense(licenseId);
  
  // Create purchase record
  const purchase = await createPurchase({
    license_id: licenseId,
    buyer_id: PUBLISHER_SYSTEM_USER,
    usage_context: 'publisher_post',
    context_id: postId
  });
  
  // Link to post
  await linkLicenseToPost(postId, purchase.id);
  
  return purchase;
}