business-as-code 2.1.1 → 2.1.3

package/tests/canvas.test.ts

@@ -0,0 +1,842 @@
+/**
+ * Business Model Canvas Tests
+ *
+ * Phase 1: RED - All tests should FAIL initially
+ *
+ * Tests cover the 9 building blocks of the Business Model Canvas:
+ * 1. Customer Segments
+ * 2. Value Propositions
+ * 3. Channels
+ * 4. Customer Relationships
+ * 5. Revenue Streams
+ * 6. Key Resources
+ * 7. Key Activities
+ * 8. Key Partnerships
+ * 9. Cost Structure
+ *
+ * Plus: Canvas generation, unit economics, and AI analysis
+ */
+
+import { describe, it, expect } from 'vitest'
+
+// Import from the canvas module (doesn't exist yet - will fail)
+import {
+  // Core Canvas
+  BusinessModelCanvas,
+  createCanvas,
+  validateCanvas,
+
+  // Customer Segments
+  CustomerSegment,
+  createCustomerSegment,
+
+  // Value Propositions
+  ValueProposition,
+  createValueProposition,
+
+  // Channels
+  Channel,
+  createChannel,
+
+  // Customer Relationships
+  CustomerRelationship,
+  createCustomerRelationship,
+
+  // Revenue Streams
+  RevenueStream,
+  createRevenueStream,
+
+  // Key Resources
+  KeyResource,
+  createKeyResource,
+
+  // Key Activities
+  KeyActivity,
+  createKeyActivity,
+
+  // Key Partnerships
+  KeyPartnership,
+  createKeyPartnership,
+
+  // Cost Structure
+  CostItem,
+  createCostItem,
+
+  // Unit Economics
+  UnitEconomics,
+  calculateUnitEconomics,
+  calculateLTV,
+  calculateCAC,
+  calculateMargins,
+
+  // Financial Projections
+  FinancialProjection,
+  createProjection,
+  projectRevenue,
+  projectCosts,
+  projectProfitability,
+
+  // Canvas Generation & Analysis
+  generateCanvasSummary,
+  analyzeCanvasStrength,
+  identifyCanvasGaps,
+} from '../src/canvas/index.js'
+
+// =============================================================================
+// CUSTOMER SEGMENTS (3 tests)
+// =============================================================================
+
+describe('Customer Segments', () => {
+  it('should create a customer segment with required fields', () => {
+    const segment = createCustomerSegment({
+      name: 'Enterprise',
+      description: 'Large enterprises with 1000+ employees',
+      type: 'mass-market',
+    })
+
+    expect(segment.name).toBe('Enterprise')
+    expect(segment.description).toBe('Large enterprises with 1000+ employees')
+    expect(segment.type).toBe('mass-market')
+  })
+
+  it('should support different segment types', () => {
+    const niche = createCustomerSegment({
+      name: 'Crypto Startups',
+      type: 'niche',
+      characteristics: ['high-growth', 'tech-savvy', 'risk-tolerant'],
+    })
+
+    const segmented = createCustomerSegment({
+      name: 'SMB',
+      type: 'segmented',
+      size: 50000,
+      revenuePerCustomer: 500,
+    })
+
+    expect(niche.type).toBe('niche')
+    expect(niche.characteristics).toContain('high-growth')
+    expect(segmented.size).toBe(50000)
+    expect(segmented.revenuePerCustomer).toBe(500)
+  })
+
+  it('should calculate segment potential', () => {
+    const segment = createCustomerSegment({
+      name: 'Enterprise',
+      size: 10000,
+      revenuePerCustomer: 50000,
+      expectedPenetration: 0.05,
+    })
+
+    // 10000 * 50000 * 0.05 = 25,000,000
+    expect(segment.potential).toBe(25000000)
+  })
+})
+
+// =============================================================================
+// VALUE PROPOSITIONS (3 tests)
+// =============================================================================
+
+describe('Value Propositions', () => {
+  it('should create a value proposition', () => {
+    const prop = createValueProposition({
+      name: 'AI-Powered Automation',
+      description: 'Reduce manual work by 80% with AI',
+      benefits: ['Time savings', 'Cost reduction', 'Error elimination'],
+      targetSegments: ['Enterprise', 'SMB'],
+    })
+
+    expect(prop.name).toBe('AI-Powered Automation')
+    expect(prop.benefits).toHaveLength(3)
+    expect(prop.targetSegments).toContain('Enterprise')
+  })
+
+  it('should support different value types', () => {
+    const newness = createValueProposition({
+      name: 'Revolutionary Tech',
+      valueType: 'newness',
+    })
+
+    const performance = createValueProposition({
+      name: '10x Faster',
+      valueType: 'performance',
+      quantifiedValue: '10x speed improvement',
+    })
+
+    const costReduction = createValueProposition({
+      name: 'Save 50%',
+      valueType: 'cost-reduction',
+      quantifiedValue: '50% cost savings',
+    })
+
+    expect(newness.valueType).toBe('newness')
+    expect(performance.valueType).toBe('performance')
+    expect(costReduction.quantifiedValue).toBe('50% cost savings')
+  })
+
+  it('should link value propositions to segments', () => {
+    const prop = createValueProposition({
+      name: 'Enterprise Security',
+      targetSegments: ['Enterprise'],
+      segmentFit: {
+        'Enterprise': 0.95,
+        'SMB': 0.6,
+      },
+    })
+
+    expect(prop.segmentFit?.['Enterprise']).toBe(0.95)
+    expect(prop.segmentFit?.['SMB']).toBe(0.6)
+  })
+})
+
+// =============================================================================
+// CHANNELS (2 tests)
+// =============================================================================
+
+describe('Channels', () => {
+  it('should create channels with phases', () => {
+    const channel = createChannel({
+      name: 'Direct Sales',
+      type: 'direct',
+      phases: ['awareness', 'evaluation', 'purchase', 'delivery', 'support'],
+      costPerAcquisition: 5000,
+    })
+
+    expect(channel.name).toBe('Direct Sales')
+    expect(channel.type).toBe('direct')
+    expect(channel.phases).toContain('purchase')
+    expect(channel.costPerAcquisition).toBe(5000)
+  })
+
+  it('should support different channel types', () => {
+    const partner = createChannel({
+      name: 'Partner Network',
+      type: 'partner',
+      partnerType: 'reseller',
+      revenueShare: 0.2,
+    })
+
+    const digital = createChannel({
+      name: 'Self-Serve',
+      type: 'digital',
+      conversionRate: 0.03,
+    })
+
+    expect(partner.type).toBe('partner')
+    expect(partner.revenueShare).toBe(0.2)
+    expect(digital.conversionRate).toBe(0.03)
+  })
+})
+
+// =============================================================================
+// CUSTOMER RELATIONSHIPS (2 tests)
+// =============================================================================
+
+describe('Customer Relationships', () => {
+  it('should create relationship types', () => {
+    const relationship = createCustomerRelationship({
+      name: 'Dedicated Account Management',
+      type: 'dedicated-assistance',
+      segment: 'Enterprise',
+      touchFrequency: 'weekly',
+    })
+
+    expect(relationship.name).toBe('Dedicated Account Management')
+    expect(relationship.type).toBe('dedicated-assistance')
+    expect(relationship.segment).toBe('Enterprise')
+  })
+
+  it('should support automated relationships', () => {
+    const automated = createCustomerRelationship({
+      name: 'Self-Service Portal',
+      type: 'automated',
+      automationLevel: 0.9,
+      supportChannels: ['chat', 'email', 'docs'],
+    })
+
+    const community = createCustomerRelationship({
+      name: 'User Community',
+      type: 'community',
+      platforms: ['discord', 'forum'],
+    })
+
+    expect(automated.automationLevel).toBe(0.9)
+    expect(community.type).toBe('community')
+    expect(community.platforms).toContain('discord')
+  })
+})
+
+// =============================================================================
+// REVENUE STREAMS (3 tests)
+// =============================================================================
+
+describe('Revenue Streams', () => {
+  it('should create revenue streams', () => {
+    const subscription = createRevenueStream({
+      name: 'SaaS Subscription',
+      type: 'recurring',
+      pricingModel: 'subscription',
+      price: 99,
+      billingCycle: 'monthly',
+    })
+
+    expect(subscription.name).toBe('SaaS Subscription')
+    expect(subscription.type).toBe('recurring')
+    expect(subscription.price).toBe(99)
+    expect(subscription.billingCycle).toBe('monthly')
+  })
+
+  it('should support different pricing mechanisms', () => {
+    const usageBased = createRevenueStream({
+      name: 'API Calls',
+      type: 'recurring',
+      pricingModel: 'usage-based',
+      pricePerUnit: 0.001,
+      unitName: 'API call',
+    })
+
+    const tiered = createRevenueStream({
+      name: 'Plans',
+      type: 'recurring',
+      pricingModel: 'tiered',
+      tiers: [
+        { name: 'Starter', price: 29 },
+        { name: 'Pro', price: 99 },
+        { name: 'Enterprise', price: 499 },
+      ],
+    })
+
+    expect(usageBased.pricePerUnit).toBe(0.001)
+    expect(tiered.tiers).toHaveLength(3)
+    expect(tiered.tiers?.[1]?.price).toBe(99)
+  })
+
+  it('should calculate annual revenue', () => {
+    const stream = createRevenueStream({
+      name: 'SaaS',
+      type: 'recurring',
+      pricingModel: 'subscription',
+      price: 100,
+      billingCycle: 'monthly',
+      activeCustomers: 1000,
+    })
+
+    // 100 * 12 * 1000 = 1,200,000
+    expect(stream.annualRevenue).toBe(1200000)
+  })
+})
+
+// =============================================================================
+// KEY RESOURCES (2 tests)
+// =============================================================================
+
+describe('Key Resources', () => {
+  it('should create different resource types', () => {
+    const physical = createKeyResource({
+      name: 'Data Centers',
+      type: 'physical',
+      cost: 500000,
+      depreciation: 'monthly',
+    })
+
+    const intellectual = createKeyResource({
+      name: 'AI Models',
+      type: 'intellectual',
+      protectionType: 'trade-secret',
+    })
+
+    const human = createKeyResource({
+      name: 'Engineering Team',
+      type: 'human',
+      headcount: 50,
+      averageCost: 150000,
+    })
+
+    expect(physical.type).toBe('physical')
+    expect(intellectual.protectionType).toBe('trade-secret')
+    expect(human.headcount).toBe(50)
+  })
+
+  it('should calculate total resource cost', () => {
+    const resource = createKeyResource({
+      name: 'Engineering Team',
+      type: 'human',
+      headcount: 10,
+      averageCost: 200000,
+    })
+
+    // 10 * 200000 = 2,000,000
+    expect(resource.totalCost).toBe(2000000)
+  })
+})
+
+// =============================================================================
+// KEY ACTIVITIES (2 tests)
+// =============================================================================
+
+describe('Key Activities', () => {
+  it('should create key activities', () => {
+    const activity = createKeyActivity({
+      name: 'Product Development',
+      category: 'production',
+      description: 'Building and improving the core product',
+      resources: ['Engineering Team', 'AI Models'],
+    })
+
+    expect(activity.name).toBe('Product Development')
+    expect(activity.category).toBe('production')
+    expect(activity.resources).toContain('Engineering Team')
+  })
+
+  it('should support different activity categories', () => {
+    const problemSolving = createKeyActivity({
+      name: 'Customer Success',
+      category: 'problem-solving',
+      metrics: ['NPS', 'CSAT', 'Churn Rate'],
+    })
+
+    const platform = createKeyActivity({
+      name: 'Platform Operations',
+      category: 'platform',
+      uptime: 0.999,
+    })
+
+    expect(problemSolving.category).toBe('problem-solving')
+    expect(problemSolving.metrics).toContain('NPS')
+    expect(platform.uptime).toBe(0.999)
+  })
+})
+
+// =============================================================================
+// KEY PARTNERSHIPS (2 tests)
+// =============================================================================
+
+describe('Key Partnerships', () => {
+  it('should create partnerships', () => {
+    const partnership = createKeyPartnership({
+      name: 'AWS',
+      type: 'strategic-alliance',
+      purpose: 'Cloud infrastructure and marketplace distribution',
+      benefits: ['Infrastructure', 'Distribution', 'Credibility'],
+    })
+
+    expect(partnership.name).toBe('AWS')
+    expect(partnership.type).toBe('strategic-alliance')
+    expect(partnership.benefits).toContain('Distribution')
+  })
+
+  it('should support different partnership types', () => {
+    const supplier = createKeyPartnership({
+      name: 'Data Provider',
+      type: 'buyer-supplier',
+      contractValue: 100000,
+      contractTerm: 12,
+    })
+
+    const coopetition = createKeyPartnership({
+      name: 'Industry Competitor',
+      type: 'coopetition',
+      sharedActivities: ['Standards', 'Lobbying'],
+    })
+
+    expect(supplier.type).toBe('buyer-supplier')
+    expect(supplier.contractValue).toBe(100000)
+    expect(coopetition.sharedActivities).toContain('Standards')
+  })
+})
+
+// =============================================================================
+// COST STRUCTURE (3 tests)
+// =============================================================================
+
+describe('Cost Structure', () => {
+  it('should create cost items', () => {
+    const cost = createCostItem({
+      name: 'Engineering Salaries',
+      category: 'fixed',
+      amount: 2000000,
+      period: 'annual',
+    })
+
+    expect(cost.name).toBe('Engineering Salaries')
+    expect(cost.category).toBe('fixed')
+    expect(cost.amount).toBe(2000000)
+  })
+
+  it('should support variable costs', () => {
+    const hosting = createCostItem({
+      name: 'Cloud Hosting',
+      category: 'variable',
+      unitCost: 0.10,
+      unitName: 'active user',
+      volumeEstimate: 100000,
+    })
+
+    // 0.10 * 100000 = 10,000
+    expect(hosting.estimatedTotal).toBe(10000)
+  })
+
+  it('should categorize costs by type', () => {
+    const costs = [
+      createCostItem({ name: 'Salaries', category: 'fixed', amount: 1000000 }),
+      createCostItem({ name: 'Marketing', category: 'fixed', amount: 200000 }),
+      createCostItem({ name: 'Hosting', category: 'variable', unitCost: 0.1, volumeEstimate: 100000 }),
+    ]
+
+    const fixed = costs.filter(c => c.category === 'fixed')
+    const variable = costs.filter(c => c.category === 'variable')
+
+    expect(fixed).toHaveLength(2)
+    expect(variable).toHaveLength(1)
+  })
+})
+
+// =============================================================================
+// UNIT ECONOMICS (3 tests)
+// =============================================================================
+
+describe('Unit Economics', () => {
+  it('should calculate LTV', () => {
+    const ltv = calculateLTV({
+      averageRevenuePerUser: 100,
+      grossMargin: 0.7,
+      churnRate: 0.05,
+    })
+
+    // LTV = ARPU * Gross Margin / Churn Rate
+    // 100 * 0.7 / 0.05 = 1400
+    expect(ltv).toBe(1400)
+  })
+
+  it('should calculate CAC', () => {
+    const cac = calculateCAC({
+      marketingSpend: 50000,
+      salesSpend: 100000,
+      newCustomers: 500,
+    })
+
+    // (50000 + 100000) / 500 = 300
+    expect(cac).toBe(300)
+  })
+
+  it('should calculate comprehensive unit economics', () => {
+    const economics = calculateUnitEconomics({
+      averageRevenuePerUser: 100,
+      grossMargin: 0.7,
+      churnRate: 0.05,
+      marketingSpend: 50000,
+      salesSpend: 100000,
+      newCustomers: 500,
+    })
+
+    expect(economics.ltv).toBe(1400)
+    expect(economics.cac).toBe(300)
+    expect(economics.ltvCacRatio).toBeCloseTo(4.67, 1)
+    expect(economics.paybackMonths).toBeCloseTo(4.29, 1) // CAC / (ARPU * Gross Margin)
+  })
+})
+
+// =============================================================================
+// MARGINS (2 tests)
+// =============================================================================
+
+describe('Margins', () => {
+  it('should calculate gross margin', () => {
+    const margins = calculateMargins({
+      revenue: 1000000,
+      cogs: 300000,
+      operatingExpenses: 500000,
+    })
+
+    expect(margins.grossMargin).toBe(0.7) // (1000000 - 300000) / 1000000
+    expect(margins.grossProfit).toBe(700000)
+  })
+
+  it('should calculate operating and net margins', () => {
+    const margins = calculateMargins({
+      revenue: 1000000,
+      cogs: 300000,
+      operatingExpenses: 500000,
+      taxes: 40000,
+    })
+
+    expect(margins.operatingMargin).toBe(0.2) // (1000000 - 300000 - 500000) / 1000000
+    expect(margins.operatingIncome).toBe(200000)
+    expect(margins.netMargin).toBe(0.16) // (200000 - 40000) / 1000000
+    expect(margins.netIncome).toBe(160000)
+  })
+})
+
+// =============================================================================
+// FINANCIAL PROJECTIONS (3 tests)
+// =============================================================================
+
+describe('Financial Projections', () => {
+  it('should project revenue growth', () => {
+    const projection = projectRevenue({
+      startingMRR: 100000,
+      monthlyGrowthRate: 0.1,
+      months: 12,
+    })
+
+    expect(projection.months).toHaveLength(12)
+    expect(projection.months[0]?.mrr).toBe(100000)
+    expect(projection.months[11]?.mrr).toBeCloseTo(285311, -2) // 100000 * 1.1^11
+    expect(projection.endingARR).toBeCloseTo(3423733, -2) // 285311 * 12
+  })
+
+  it('should project costs', () => {
+    const projection = projectCosts({
+      fixedCosts: 500000,
+      variableCostPerUser: 10,
+      startingUsers: 1000,
+      monthlyUserGrowth: 0.1,
+      months: 12,
+    })
+
+    expect(projection.months).toHaveLength(12)
+    expect(projection.months[0]?.totalCost).toBeCloseTo(510000) // 500000 + 1000*10
+    expect(projection.months[11]?.totalCost).toBeCloseTo(528531, -2) // 500000 + 2853*10
+  })
+
+  it('should project profitability', () => {
+    const projection = projectProfitability({
+      startingMRR: 100000,
+      monthlyGrowthRate: 0.1,
+      fixedCosts: 80000,
+      grossMargin: 0.7,
+      months: 24,
+    })
+
+    expect(projection.months).toHaveLength(24)
+    expect(projection.breakEvenMonth).toBeDefined()
+    expect(projection.totalProfit).toBeGreaterThan(0)
+  })
+})
+
+// =============================================================================
+// CANVAS GENERATION (3 tests)
+// =============================================================================
+
+describe('Business Model Canvas', () => {
+  it('should create a complete canvas', () => {
+    const canvas = createCanvas({
+      name: 'SaaS Startup',
+      customerSegments: [
+        createCustomerSegment({ name: 'Enterprise', type: 'segmented' }),
+        createCustomerSegment({ name: 'SMB', type: 'mass-market' }),
+      ],
+      valuePropositions: [
+        createValueProposition({ name: 'AI Automation', valueType: 'performance' }),
+      ],
+      channels: [
+        createChannel({ name: 'Direct Sales', type: 'direct' }),
+        createChannel({ name: 'Self-Serve', type: 'digital' }),
+      ],
+      customerRelationships: [
+        createCustomerRelationship({ name: 'Account Management', type: 'dedicated-assistance' }),
+      ],
+      revenueStreams: [
+        createRevenueStream({ name: 'Subscription', type: 'recurring', pricingModel: 'subscription' }),
+      ],
+      keyResources: [
+        createKeyResource({ name: 'AI Models', type: 'intellectual' }),
+        createKeyResource({ name: 'Engineering', type: 'human' }),
+      ],
+      keyActivities: [
+        createKeyActivity({ name: 'Product Dev', category: 'production' }),
+      ],
+      keyPartnerships: [
+        createKeyPartnership({ name: 'AWS', type: 'strategic-alliance' }),
+      ],
+      costStructure: [
+        createCostItem({ name: 'Engineering', category: 'fixed', amount: 2000000 }),
+      ],
+    })
+
+    expect(canvas.name).toBe('SaaS Startup')
+    expect(canvas.customerSegments).toHaveLength(2)
+    expect(canvas.valuePropositions).toHaveLength(1)
+    expect(canvas.channels).toHaveLength(2)
+    expect(canvas.revenueStreams).toHaveLength(1)
+    expect(canvas.keyResources).toHaveLength(2)
+  })
+
+  it('should validate canvas completeness', () => {
+    const incomplete = createCanvas({
+      name: 'Incomplete',
+      customerSegments: [],
+      valuePropositions: [],
+      channels: [],
+      customerRelationships: [],
+      revenueStreams: [],
+      keyResources: [],
+      keyActivities: [],
+      keyPartnerships: [],
+      costStructure: [],
+    })
+
+    const validation = validateCanvas(incomplete)
+
+    expect(validation.isComplete).toBe(false)
+    expect(validation.missingBlocks).toContain('customerSegments')
+    expect(validation.missingBlocks).toContain('valuePropositions')
+    expect(validation.missingBlocks).toContain('revenueStreams')
+  })
+
+  it('should generate canvas summary', () => {
+    const canvas = createCanvas({
+      name: 'Test Business',
+      customerSegments: [
+        createCustomerSegment({ name: 'Enterprise', size: 10000, revenuePerCustomer: 10000 }),
+      ],
+      valuePropositions: [
+        createValueProposition({ name: 'Value', benefits: ['Speed', 'Cost'] }),
+      ],
+      channels: [createChannel({ name: 'Direct', type: 'direct' })],
+      customerRelationships: [createCustomerRelationship({ name: 'Support', type: 'automated' })],
+      revenueStreams: [
+        createRevenueStream({ name: 'Sub', type: 'recurring', pricingModel: 'subscription', price: 100, activeCustomers: 1000 }),
+      ],
+      keyResources: [createKeyResource({ name: 'Tech', type: 'intellectual' })],
+      keyActivities: [createKeyActivity({ name: 'Dev', category: 'production' })],
+      keyPartnerships: [createKeyPartnership({ name: 'Partner', type: 'strategic-alliance' })],
+      costStructure: [createCostItem({ name: 'Ops', category: 'fixed', amount: 500000 })],
+    })
+
+    const summary = generateCanvasSummary(canvas)
+
+    expect(summary.totalAddressableMarket).toBe(100000000) // 10000 * 10000
+    expect(summary.projectedAnnualRevenue).toBe(1200000) // 100 * 12 * 1000
+    expect(summary.totalAnnualCosts).toBe(500000)
+    expect(summary.projectedProfit).toBe(700000)
+  })
+})
+
+// =============================================================================
+// CANVAS ANALYSIS (2 tests)
+// =============================================================================
+
+describe('Canvas Analysis', () => {
+  it('should analyze canvas strength', () => {
+    const canvas = createCanvas({
+      name: 'Strong Business',
+      customerSegments: [
+        createCustomerSegment({ name: 'Enterprise', size: 10000, revenuePerCustomer: 50000 }),
+      ],
+      valuePropositions: [
+        createValueProposition({ name: 'Unique Value', valueType: 'newness', benefits: ['A', 'B', 'C'] }),
+      ],
+      channels: [
+        createChannel({ name: 'Sales', type: 'direct', costPerAcquisition: 1000 }),
+        createChannel({ name: 'Marketing', type: 'digital', costPerAcquisition: 100 }),
+      ],
+      customerRelationships: [createCustomerRelationship({ name: 'AM', type: 'dedicated-assistance' })],
+      revenueStreams: [
+        createRevenueStream({ name: 'Sub', type: 'recurring', pricingModel: 'subscription', price: 1000 }),
+      ],
+      keyResources: [
+        createKeyResource({ name: 'IP', type: 'intellectual' }),
+        createKeyResource({ name: 'Team', type: 'human', headcount: 20 }),
+      ],
+      keyActivities: [createKeyActivity({ name: 'R&D', category: 'production' })],
+      keyPartnerships: [createKeyPartnership({ name: 'Tech Partner', type: 'strategic-alliance' })],
+      costStructure: [createCostItem({ name: 'Ops', category: 'fixed', amount: 1000000 })],
+    })
+
+    const analysis = analyzeCanvasStrength(canvas)
+
+    expect(analysis.overallScore).toBeGreaterThan(0)
+    expect(analysis.overallScore).toBeLessThanOrEqual(100)
+    expect(analysis.strengths).toBeDefined()
+    expect(analysis.weaknesses).toBeDefined()
+    expect(analysis.blockScores).toHaveProperty('customerSegments')
+    expect(analysis.blockScores).toHaveProperty('valuePropositions')
+  })
+
+  it('should identify canvas gaps', () => {
+    const canvas = createCanvas({
+      name: 'Gaps Business',
+      customerSegments: [createCustomerSegment({ name: 'Unknown', type: 'mass-market' })],
+      valuePropositions: [], // Gap: no value props
+      channels: [createChannel({ name: 'None', type: 'direct' })],
+      customerRelationships: [], // Gap: no relationships
+      revenueStreams: [createRevenueStream({ name: 'Revenue', type: 'one-time', pricingModel: 'fixed' })],
+      keyResources: [],  // Gap: no resources
+      keyActivities: [createKeyActivity({ name: 'Activity', category: 'production' })],
+      keyPartnerships: [],  // Gap: no partnerships
+      costStructure: [createCostItem({ name: 'Cost', category: 'fixed', amount: 100000 })],
+    })
+
+    const gaps = identifyCanvasGaps(canvas)
+
+    expect(gaps.criticalGaps).toContain('valuePropositions')
+    expect(gaps.warnings).toBeDefined()
+    expect(gaps.recommendations).toBeDefined()
+    expect(gaps.recommendations.length).toBeGreaterThan(0)
+  })
+})
+
+// =============================================================================
+// TYPE DEFINITIONS (verify TypeScript types work)
+// =============================================================================
+
+describe('Type Definitions', () => {
+  it('should export proper TypeScript types', () => {
+    // These should compile without errors
+    const segment: CustomerSegment = {
+      name: 'Test',
+      type: 'mass-market',
+    }
+
+    const value: ValueProposition = {
+      name: 'Test',
+      benefits: [],
+    }
+
+    const channel: Channel = {
+      name: 'Test',
+      type: 'direct',
+    }
+
+    const relationship: CustomerRelationship = {
+      name: 'Test',
+      type: 'automated',
+    }
+
+    const revenue: RevenueStream = {
+      name: 'Test',
+      type: 'recurring',
+      pricingModel: 'subscription',
+    }
+
+    const resource: KeyResource = {
+      name: 'Test',
+      type: 'intellectual',
+    }
+
+    const activity: KeyActivity = {
+      name: 'Test',
+      category: 'production',
+    }
+
+    const partnership: KeyPartnership = {
+      name: 'Test',
+      type: 'strategic-alliance',
+    }
+
+    const cost: CostItem = {
+      name: 'Test',
+      category: 'fixed',
+    }
+
+    expect(segment).toBeDefined()
+    expect(value).toBeDefined()
+    expect(channel).toBeDefined()
+    expect(relationship).toBeDefined()
+    expect(revenue).toBeDefined()
+    expect(resource).toBeDefined()
+    expect(activity).toBeDefined()
+    expect(partnership).toBeDefined()
+    expect(cost).toBeDefined()
+  })
+})