@alumbwe/anvil 1.0.42 → 1.0.50

package/vendor/@anvil/common/src/__tests__/anvil-trust.test.ts

@@ -1,526 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import {
-  assessAnvilTrust,
-  ANVIL_TRUST_FALLBACK_LEVEL,
-  ANVIL_TRUST_LEVELS,
-  ANVIL_TRUST_EARNED,
-  ANVIL_TRUST_LIMITS,
-  ANVIL_TRUST_THRESHOLDS,
-  anvilTrustLimits,
-  isAtLeastTrustLevel,
-  toAnvilStandingInfo,
-  type AnvilTrustSignals,
-} from '../constants/anvil-trust'
-
-const NOW = new Date('2026-08-11T00:00:00Z')
-const DAY_MS = 24 * 60 * 60 * 1000
-
-function daysAgo(days: number): Date {
-  return new Date(NOW.getTime() - days * DAY_MS)
-}
-
-/** An account we know nothing about: every optional signal unknown. This is
- *  what most pre-provenance accounts actually look like. */
-const UNKNOWN: AnvilTrustSignals = {
-  accountCreatedAt: null,
-  githubAccountCreatedAt: null,
-  githubOldestRepoCreatedAt: null,
-  githubPublicRepos: null,
-  githubFollowers: null,
-  githubTwoFactorEnabled: null,
-  activeDays: 0,
-  approvedBounties: 0,
-  qualifiedReferrals: 0,
-  hasPaid: false,
-  signupPrivacySignals: null,
-  signupIpSource: null,
-  signupPrefixAccountCount: null,
-  mailboxAccountCount: null,
-  hasUnreversedBanEvent: false,
-  privacyFlaggedAt: null,
-  privacyCorroboratedAt: null,
-  thirdPartyClientAt: null,
-  currentRiskScore: null,
-}
-
-function signals(overrides: Partial<AnvilTrustSignals>) {
-  return { ...UNKNOWN, ...overrides }
-}
-
-describe('level ordering', () => {
-  it('orders least- to most-established', () => {
-    expect(ANVIL_TRUST_LEVELS).toEqual([
-      'new',
-      'verified',
-      'established',
-      'core',
-    ])
-  })
-
-  it('compares by position, not alphabetically', () => {
-    expect(isAtLeastTrustLevel('core', 'new')).toBe(true)
-    expect(isAtLeastTrustLevel('new', 'verified')).toBe(false)
-    expect(isAtLeastTrustLevel('established', 'established')).toBe(true)
-  })
-})
-
-describe('limit matrix', () => {
-  it('reproduces the pre-existing flat limits at established/full', () => {
-    // This is the safety property of the whole rollout: the population that
-    // already looked like ordinary heavy users must keep exactly what it had.
-    const full = anvilTrustLimits('full', 'established')
-    expect(full.messagesPerDay).toBe(5_000)
-    expect(full.messagesPer5Hours).toBe(3_000)
-    expect(full.dailySpendUsd).toBe(50)
-    expect(full.premiumSessionsPerDay).toBe(6)
-
-    const limited = anvilTrustLimits('limited', 'established')
-    expect(limited.messagesPerDay).toBe(3_000)
-    expect(limited.messagesPer5Hours).toBe(2_000)
-  })
-
-  it('is monotonic in level on every axis, in both regions', () => {
-    for (const tier of ['full', 'limited'] as const) {
-      for (let i = 1; i < ANVIL_TRUST_LEVELS.length; i++) {
-        const lower = ANVIL_TRUST_LIMITS[tier][ANVIL_TRUST_LEVELS[i - 1]]
-        const higher = ANVIL_TRUST_LIMITS[tier][ANVIL_TRUST_LEVELS[i]]
-        for (const key of Object.keys(lower) as (keyof typeof lower)[]) {
-          expect(higher[key]).toBeGreaterThanOrEqual(lower[key])
-        }
-      }
-    }
-  })
-
-  it('does not scale session-shape controls, only cost controls', () => {
-    // Browser sessions and Desktop tabs were deliberately removed: an open
-    // session costs nothing until it generates, and the generating is already
-    // bounded. If either reappears here, something re-added a limit that takes
-    // visible capability from new users and saves nothing.
-    expect(Object.keys(ANVIL_TRUST_LIMITS.full.new).sort()).toEqual([
-      'dailySpendUsd',
-      'messagesPer5Hours',
-      'messagesPerDay',
-      'premiumSessionsPerDay',
-      'userMessagesPerDay',
-    ])
-  })
-
-  it('never lets the limited tier reach a premium session', () => {
-    // The model gate already refuses it; a non-zero number here would be a
-    // promise the rest of the system cannot keep.
-    for (const level of ANVIL_TRUST_LEVELS) {
-      expect(ANVIL_TRUST_LIMITS.limited[level].premiumSessionsPerDay).toBe(0)
-    }
-  })
-
-  it('lets a limited-region core member beat a full-region verified user', () => {
-    // The promise the region split has to make to a real developer abroad.
-    const limitedCore = anvilTrustLimits('limited', 'core')
-    const fullVerified = anvilTrustLimits('full', 'verified')
-    expect(limitedCore.messagesPerDay).toBeGreaterThan(
-      fullVerified.messagesPerDay,
-    )
-    expect(limitedCore.userMessagesPerDay).toBeGreaterThan(
-      fullVerified.userMessagesPerDay,
-    )
-    expect(limitedCore.dailySpendUsd).toBeGreaterThan(
-      fullVerified.dailySpendUsd,
-    )
-  })
-
-  it('keeps every new-account daily budget above the measured p90', () => {
-    // Sizing anchor from free-mode-rate-limiter.ts: full-tier per-user-per-day
-    // p90 is 837. A brand-new account doing genuinely heavy work must fit.
-    expect(
-      anvilTrustLimits('full', 'new').messagesPerDay,
-    ).toBeGreaterThanOrEqual(837)
-  })
-})
-
-describe('scoring', () => {
-  it('leaves an unknown account at the floor', () => {
-    const result = assessAnvilTrust(UNKNOWN, NOW)
-    expect(result.level).toBe('new')
-    expect(result.score).toBe(0)
-    expect(result.cappedBy).toBeNull()
-  })
-
-  it('treats null signals as unknown, never as suspicious', () => {
-    // A pre-provenance account (null everything) must score the same as one
-    // explicitly checked and found to share nothing.
-    const unknownProvenance = assessAnvilTrust(
-      signals({ githubAccountCreatedAt: daysAgo(400) }),
-      NOW,
-    )
-    const cleanProvenance = assessAnvilTrust(
-      signals({
-        githubAccountCreatedAt: daysAgo(400),
-        signupPrefixAccountCount: 1,
-        mailboxAccountCount: 1,
-      }),
-      NOW,
-    )
-    expect(unknownProvenance.level).toBe(cleanProvenance.level)
-    expect(unknownProvenance.cappedBy).toBeNull()
-  })
-
-  it('reaches established on GitHub age plus ordinary account history', () => {
-    const result = assessAnvilTrust(
-      signals({
-        accountCreatedAt: daysAgo(120),
-        githubAccountCreatedAt: daysAgo(3 * 365 + 10),
-        githubOldestRepoCreatedAt: daysAgo(400),
-        githubPublicRepos: 12,
-        activeDays: 40,
-      }),
-      NOW,
-    )
-    // 10 linked + 20 age + 10 repo + 5 repos + 15 acct age + 10 active
-    expect(result.score).toBe(70)
-    expect(result.level).toBe('established')
-  })
-
-  it('lets a brand-new limited-region account climb with earned signals alone', () => {
-    // The route that does not require owning an aged GitHub account: this is
-    // what the Earn page has to be able to promise.
-    const result = assessAnvilTrust(
-      signals({
-        accountCreatedAt: daysAgo(10),
-        approvedBounties: 4,
-        qualifiedReferrals: 5,
-      }),
-      NOW,
-    )
-    // 5 acct age + 20 bounties + 15 referrals
-    expect(result.score).toBe(40)
-    expect(result.level).toBe('verified')
-  })
-
-  it('caps bounty and referral contributions', () => {
-    const capped = assessAnvilTrust(
-      signals({ approvedBounties: 50, qualifiedReferrals: 50 }),
-      NOW,
-    )
-    expect(capped.score).toBe(
-      ANVIL_TRUST_EARNED.BOUNTY_POINTS * ANVIL_TRUST_EARNED.BOUNTY_CAP +
-        ANVIL_TRUST_EARNED.REFERRAL_POINTS *
-          ANVIL_TRUST_EARNED.REFERRAL_CAP,
-    )
-  })
-
-  it('lets contribution alone reach core, with no GitHub and no payment', () => {
-    // THE property the earned caps exist for. Before they were raised this
-    // route peaked at 70 against a threshold of 75, so `core` was reachable
-    // only by owning an aged GitHub account or by paying — which is backwards
-    // for a program meant to give developers in unsupported regions a way to
-    // raise their own limits.
-    const earned = assessAnvilTrust(
-      signals({
-        accountCreatedAt: daysAgo(120),
-        activeDays: 40,
-        approvedBounties: ANVIL_TRUST_EARNED.BOUNTY_CAP,
-        qualifiedReferrals: ANVIL_TRUST_EARNED.REFERRAL_CAP,
-        signupPrivacySignals: [],
-        signupIpSource: 'cloudflare',
-      }),
-      NOW,
-    )
-    expect(earned.factors.map((f) => f.id)).not.toContain('github_linked')
-    expect(earned.score).toBeGreaterThanOrEqual(ANVIL_TRUST_THRESHOLDS.core)
-    expect(earned.level).toBe('core')
-  })
-
-  it('keeps paying past the point someone has proved they are real', () => {
-    // A flat incentive is not an incentive. The tenth referral and the sixth
-    // bounty must still be worth something, or the program stops pulling
-    // exactly where it should pull hardest.
-    const few = assessAnvilTrust(
-      signals({ approvedBounties: 4, qualifiedReferrals: 5 }),
-      NOW,
-    )
-    const many = assessAnvilTrust(
-      signals({ approvedBounties: 6, qualifiedReferrals: 10 }),
-      NOW,
-    )
-    expect(many.score).toBeGreaterThan(few.score)
-  })
-
-  it('never returns a score outside 0..100', () => {
-    const maxed = assessAnvilTrust(
-      signals({
-        accountCreatedAt: daysAgo(1000),
-        githubAccountCreatedAt: daysAgo(4000),
-        githubOldestRepoCreatedAt: daysAgo(3000),
-        githubPublicRepos: 100,
-        githubFollowers: 500,
-        githubTwoFactorEnabled: true,
-        activeDays: 300,
-        approvedBounties: 20,
-        qualifiedReferrals: 20,
-        hasPaid: true,
-        signupPrivacySignals: [],
-        signupIpSource: 'cloudflare',
-      }),
-      NOW,
-    )
-    expect(maxed.score).toBe(100)
-    expect(maxed.level).toBe('core')
-  })
-
-  it('ignores a future-dated timestamp rather than crediting it', () => {
-    const skewed = assessAnvilTrust(
-      signals({
-        githubAccountCreatedAt: new Date(NOW.getTime() + 10 * DAY_MS),
-      }),
-      NOW,
-    )
-    // Linked (10) but no age credit.
-    expect(skewed.score).toBe(10)
-  })
-})
-
-describe('caps', () => {
-  const HIGH_SCORE: Partial<AnvilTrustSignals> = {
-    accountCreatedAt: daysAgo(400),
-    githubAccountCreatedAt: daysAgo(2000),
-    githubOldestRepoCreatedAt: daysAgo(1000),
-    githubPublicRepos: 20,
-    githubFollowers: 50,
-    githubTwoFactorEnabled: true,
-    activeDays: 100,
-    approvedBounties: 4,
-  }
-
-  it('caps a live anonymous network at verified however high the score', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, currentRiskScore: 90 }),
-      NOW,
-    )
-    expect(result.uncappedLevel).toBe('core')
-    expect(result.level).toBe('verified')
-    expect(result.cappedBy).toBe('anonymous_network')
-  })
-
-  it('does not cap on a low current risk score', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, currentRiskScore: 10 }),
-      NOW,
-    )
-    expect(result.level).toBe('core')
-    expect(result.cappedBy).toBeNull()
-  })
-
-  it('caps a VPN signup at established, not lower', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, signupPrivacySignals: ['vpn'] }),
-      NOW,
-    )
-    expect(result.level).toBe('established')
-    expect(result.cappedBy).toBe('signup_privacy_egress')
-  })
-
-  it('credits a clean signup rather than capping it', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, signupPrivacySignals: [] }),
-      NOW,
-    )
-    expect(result.cappedBy).toBeNull()
-    expect(result.factors.some((f) => f.id === 'clean_signup')).toBe(true)
-  })
-
-  it('applies the lowest cap when several bind', () => {
-    const result = assessAnvilTrust(
-      signals({
-        ...HIGH_SCORE,
-        signupPrivacySignals: ['vpn'],
-        mailboxAccountCount: 5,
-      }),
-      NOW,
-    )
-    expect(result.level).toBe('verified')
-    expect(result.cappedBy).toBe('shared_mailbox')
-  })
-
-  it('leads the next steps with the cap, since points cannot clear it', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, currentRiskScore: 90 }),
-      NOW,
-    )
-    expect(result.nextSteps[0]?.id).toBe('cap_anonymous_network')
-    expect(result.nextSteps[0]?.label).toMatch(/VPN/i)
-  })
-
-  it('caps an account with unreversed enforcement history', () => {
-    const result = assessAnvilTrust(
-      signals({ ...HIGH_SCORE, hasUnreversedBanEvent: true }),
-      NOW,
-    )
-    expect(result.level).toBe('verified')
-    expect(result.cappedBy).toBe('past_enforcement')
-  })
-})
-
-describe('next steps', () => {
-  it('leads with connecting GitHub for an account that has none', () => {
-    const result = assessAnvilTrust(UNKNOWN, NOW)
-    expect(result.nextSteps[0]?.id).toBe('connect_github')
-    expect(result.nextSteps[0]?.points).toBe(30)
-  })
-
-  it('stops offering steps the user has already exhausted', () => {
-    const result = assessAnvilTrust(
-      signals({
-        approvedBounties: ANVIL_TRUST_EARNED.BOUNTY_CAP,
-        qualifiedReferrals: ANVIL_TRUST_EARNED.REFERRAL_CAP,
-      }),
-      NOW,
-    )
-    expect(result.nextSteps.map((s) => s.id)).not.toContain('bounties')
-    expect(result.nextSteps.map((s) => s.id)).not.toContain('referrals')
-  })
-
-  it('offers the remaining value, not the full value, of a partial step', () => {
-    const result = assessAnvilTrust(signals({ approvedBounties: 2 }), NOW)
-    const remaining =
-      (ANVIL_TRUST_EARNED.BOUNTY_CAP - 2) *
-      ANVIL_TRUST_EARNED.BOUNTY_POINTS
-    expect(result.nextSteps.find((s) => s.id === 'bounties')?.points).toBe(
-      remaining,
-    )
-  })
-})
-
-describe('wire shape', () => {
-  it('never puts a raw limit on the wire', () => {
-    // A published limit is a published target: the abuse pattern here is
-    // sustained pacing just under the caps, so the caps stay server-side. This
-    // asserts the payload rather than the component, because the payload is
-    // what a future surface would reach for.
-    const info = toAnvilStandingInfo(
-      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
-      'limited',
-    )
-    expect(info).not.toHaveProperty('limits')
-
-    // Scoped to the distinctive values. Small ones (a $3 spend cap, 6 premium
-    // sessions) collide with legitimate point values in the copy — "worth 3
-    // points" is not a leaked limit, and asserting on them would fail for the
-    // wrong reason.
-    const serialized = JSON.stringify(info)
-    const distinctive = Object.values(
-      anvilTrustLimits('limited', info.level),
-    ).filter((value) => value >= 100)
-    expect(distinctive.length).toBeGreaterThan(0)
-    for (const value of distinctive) {
-      expect(serialized).not.toContain(String(value))
-    }
-    expect(info.accessTier).toBe('limited')
-  })
-
-  it('describes each axis in words', () => {
-    const info = toAnvilStandingInfo(
-      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
-      'limited',
-    )
-    expect(info.highlights.map((h) => h.label)).toEqual([
-      'Prompts a day',
-      'Work per prompt',
-      'Premium models',
-    ])
-    for (const highlight of info.highlights) {
-      expect(highlight.value).not.toMatch(/\d/)
-    }
-  })
-
-  it('frames premium as a region fact where no level can unlock it', () => {
-    // Every limited-row level has 0 premium sessions, so calling it a
-    // shortfall would send the user chasing points that cannot buy it.
-    const limited = toAnvilStandingInfo(
-      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
-      'limited',
-    )
-    expect(
-      limited.highlights.find((h) => h.label === 'Premium models')?.value,
-    ).toMatch(/region/i)
-
-    const full = toAnvilStandingInfo(
-      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
-      'full',
-    )
-    expect(
-      full.highlights.find((h) => h.label === 'Premium models')?.value,
-    ).not.toMatch(/region/i)
-  })
-
-  it('reports the next threshold, and nothing beyond core', () => {
-    const verified = toAnvilStandingInfo(
-      assessAnvilTrust(
-        signals({ approvedBounties: 4, activeDays: 10 }),
-        NOW,
-      ),
-      'full',
-    )
-    expect(verified.level).toBe('verified')
-    expect(verified.nextLevel).toBe('established')
-    expect(verified.nextLevelAt).toBe(ANVIL_TRUST_THRESHOLDS.established)
-
-    const core = toAnvilStandingInfo(
-      assessAnvilTrust(
-        signals({
-          accountCreatedAt: daysAgo(400),
-          githubAccountCreatedAt: daysAgo(2000),
-          githubOldestRepoCreatedAt: daysAgo(1000),
-          githubPublicRepos: 20,
-          githubFollowers: 50,
-          githubTwoFactorEnabled: true,
-          activeDays: 100,
-          approvedBounties: 4,
-        }),
-        NOW,
-      ),
-      'full',
-    )
-    expect(core.level).toBe('core')
-    expect(core.nextLevel).toBeNull()
-    expect(core.nextLevelAt).toBeNull()
-  })
-
-  it('explains a cap in the copy the client renders', () => {
-    const info = toAnvilStandingInfo(
-      assessAnvilTrust(
-        signals({
-          accountCreatedAt: daysAgo(400),
-          githubAccountCreatedAt: daysAgo(2000),
-          activeDays: 100,
-          currentRiskScore: 99,
-        }),
-        NOW,
-      ),
-      'full',
-    )
-    expect(info.cappedBy).toBe('anonymous_network')
-    expect(info.cappedReason).toMatch(/VPN/i)
-  })
-
-  it('reports no cap when the cap sits at or above the earned level', () => {
-    // An account scoring 'new' is not "capped at verified" — nothing bound.
-    const info = toAnvilStandingInfo(
-      assessAnvilTrust(signals({ currentRiskScore: 99 }), NOW),
-      'full',
-    )
-    expect(info.level).toBe('new')
-    expect(info.cappedBy).toBeNull()
-  })
-})
-
-describe('failure behaviour', () => {
-  it('falls back to the level that reproduces the old flat limits', () => {
-    // A broken resolver must cost us the enforcement, never the users: if this
-    // were 'new', one degraded query would throttle the whole product.
-    expect(ANVIL_TRUST_FALLBACK_LEVEL).toBe('established')
-    expect(anvilTrustLimits('full', ANVIL_TRUST_FALLBACK_LEVEL)).toEqual(
-      anvilTrustLimits('full', 'established'),
-    )
-  })
-})

package/vendor/@anvil/common/src/__tests__/deepseek-direct.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  DEFAULT_DIRECT_DEEPSEEK_MODEL,
-  remapModelForDirectDeepSeek,
-} from '../constants/deepseek-direct'
-
-describe('remapModelForDirectDeepSeek', () => {
-  test('keeps the model name for DeepSeek lane ids', () => {
-    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro')).toBe(
-      'deepseek-v4-pro',
-    )
-    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-flash')).toBe(
-      'deepseek-v4-flash',
-    )
-  })
-
-  test('normalizes -max context tiers to their base model', () => {
-    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro-max')).toBe(
-      'deepseek-v4-pro',
-    )
-    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-flash-max')).toBe(
-      'deepseek-v4-flash',
-    )
-  })
-
-  test('maps the legacy fireworks lane to flash', () => {
-    expect(remapModelForDirectDeepSeek('fireworks/deepseek-v4-flash')).toBe(
-      'deepseek-v4-flash',
-    )
-  })
-
-  test('falls back to the default model for other providers', () => {
-    // The default base agent requests anthropic/claude-opus-5, which DeepSeek
-    // rejects outright ("The supported API model names are deepseek-v4-pro or
-    // deepseek-v4-flash"). Every non-DeepSeek provider must fall back.
-    for (const model of [
-      'anthropic/claude-opus-5',
-      'openai/gpt-5.4',
-      'google/gemini-3.5-flash-lite',
-      'minimax/minimax-m3',
-      'z-ai/glm-5.2',
-    ]) {
-      expect(remapModelForDirectDeepSeek(model)).toBe(
-        DEFAULT_DIRECT_DEEPSEEK_MODEL,
-      )
-    }
-  })
-
-  test('honors the DEEPSEEK_MODEL override', () => {
-    const previous = process.env.DEEPSEEK_MODEL
-    process.env.DEEPSEEK_MODEL = 'deepseek-chat'
-    try {
-      expect(remapModelForDirectDeepSeek('anthropic/claude-opus-5')).toBe(
-        'deepseek-chat',
-      )
-      expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro')).toBe(
-        'deepseek-chat',
-      )
-    } finally {
-      if (previous === undefined) {
-        delete process.env.DEEPSEEK_MODEL
-      } else {
-        process.env.DEEPSEEK_MODEL = previous
-      }
-    }
-  })
-})