business-as-code 2.1.3 → 2.3.0

package/tests/canvas.test.ts

@@ -1,842 +0,0 @@
-/**
- * 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()
-  })
-})