@thecodecodex/tools 0.0.0-stage → 0.1.1

package/src/finance/clt.ts

@@ -0,0 +1,189 @@
+// Encargos do empregado CLT em 2026.
+// INSS: Portaria Interministerial MPS/MF nº 13/2026 (teto R$ 8.475,55).
+// IRRF: tabela progressiva mensal + redução da Lei nº 15.270/2025, conforme
+// https://www.gov.br/receitafederal/pt-br/assuntos/meu-imposto-de-renda/tabelas/2026
+
+export interface Bracket {
+  upTo: number
+  rate: number
+}
+
+export const INSS_2026: Bracket[] = [
+  { upTo: 1621.0, rate: 0.075 },
+  { upTo: 2902.84, rate: 0.09 },
+  { upTo: 4354.27, rate: 0.12 },
+  { upTo: 8475.55, rate: 0.14 },
+]
+
+// Tabela progressiva mensal: alíquota e parcela a deduzir por faixa da BASE DE CÁLCULO
+export const IRRF_2026 = [
+  { upTo: 2428.8, rate: 0, deduction: 0 },
+  { upTo: 2826.65, rate: 0.075, deduction: 182.16 },
+  { upTo: 3751.05, rate: 0.15, deduction: 394.16 },
+  { upTo: 4664.68, rate: 0.225, deduction: 675.49 },
+  { upTo: Infinity, rate: 0.275, deduction: 908.73 },
+] as const
+
+export const IRRF_DEPENDENT_2026 = 189.59
+// Desconto simplificado mensal: substitui as deduções legais quando for maior
+export const IRRF_SIMPLIFIED_2026 = 607.2
+
+// Redução (Lei 15.270/2025): calculada sobre os RENDIMENTOS TRIBUTÁVEIS (salário bruto), não sobre a base
+export const REDUCTION_2026 = { exemptUpTo: 5000, max: 312.89, phaseOutUpTo: 7350, constant: 978.62, factor: 0.133145 }
+
+// Arredonda centavos "para cima no meio" como a folha (121,575 → 121,58); toFixed(10) remove o ruído binário (121,57499…)
+const round2 = (value: number) => Math.round(Number(value.toFixed(10)) * 100) / 100
+
+// INSS progressivo: cada alíquota incide só sobre a parcela dentro da sua faixa
+export function inss(gross: number, table: Bracket[] = INSS_2026): number {
+  let total = 0
+  let floor = 0
+  for (const { upTo, rate } of table) {
+    if (gross <= floor) break
+    total += (Math.min(gross, upTo) - floor) * rate
+    floor = upTo
+  }
+  return round2(total)
+}
+
+export function irrfTable(base: number): number {
+  if (base <= 0) return 0
+  const bracket = IRRF_2026.find((b) => base <= b.upTo) ?? IRRF_2026[IRRF_2026.length - 1]
+  return round2(Math.max(0, base * (bracket?.rate ?? 0) - (bracket?.deduction ?? 0)))
+}
+
+export function irrfReduction(taxableIncome: number, taxBeforeReduction: number): number {
+  const { exemptUpTo, max, phaseOutUpTo, constant, factor } = REDUCTION_2026
+  if (taxableIncome <= exemptUpTo) return Math.min(max, taxBeforeReduction)
+  if (taxableIncome <= phaseOutUpTo) return round2(Math.min(Math.max(0, constant - factor * taxableIncome), taxBeforeReduction))
+  return 0
+}
+
+export interface IrrfInput {
+  // rendimentos tributáveis do mês (salário bruto)
+  taxableIncome: number
+  // INSS descontado no mês
+  socialSecurity: number
+  dependents?: number
+  alimony?: number
+}
+
+export interface IrrfResult {
+  base: number
+  deduction: "legal" | "simplified"
+  deductionAmount: number
+  taxBeforeReduction: number
+  reduction: number
+  tax: number
+}
+
+/**
+ * IRRF mensal 2026:
+ * 1. deduções legais (INSS + dependentes + pensão) ou desconto simplificado, o que for maior;
+ * 2. tabela progressiva sobre a base;
+ * 3. redução da Lei 15.270 calculada sobre o rendimento bruto, limitada ao imposto apurado.
+ * Também vale para o 13º (tributação exclusiva): a redução se aplica a ele por força do art. 3º-A, §3º, da Lei 9.250/1995,
+ * incluído pela Lei 15.270/2025. As férias são rendimento do mês e seguem a regra mensal normal.
+ */
+export function irrf({ taxableIncome, socialSecurity, dependents = 0, alimony = 0 }: IrrfInput): IrrfResult {
+  const legal = socialSecurity + dependents * IRRF_DEPENDENT_2026 + alimony
+  const simplified = legal < IRRF_SIMPLIFIED_2026
+  const deductionAmount = simplified ? IRRF_SIMPLIFIED_2026 : legal
+  const base = round2(Math.max(0, taxableIncome - deductionAmount))
+  const taxBeforeReduction = irrfTable(base)
+  const reduction = irrfReduction(taxableIncome, taxBeforeReduction)
+  return { base, deduction: simplified ? "simplified" : "legal", deductionAmount: round2(deductionAmount), taxBeforeReduction, reduction, tax: round2(Math.max(0, taxBeforeReduction - reduction)) }
+}
+
+// Atalho para o caso comum: salário bruto → INSS e IRRF do mês
+export function payrollTaxes(gross: number, options: { dependents?: number, alimony?: number } = {}) {
+  const socialSecurity = inss(gross)
+  const income = irrf({ taxableIncome: gross, socialSecurity, ...options })
+  return { inss: socialSecurity, irrf: income.tax, detail: income }
+}
+
+export const FGTS_RATE = 0.08
+// Desconto máximo do vale-transporte: 6% do salário-base (Lei 7.418/85), limitado ao custo do benefício
+export const TRANSPORT_VOUCHER_RATE = 0.06
+
+export interface CltOptions {
+  dependents?: number
+  // pensão alimentícia judicial: deduz do IR e sai do líquido
+  alimony?: number
+  // custo mensal do vale-transporte; o empregado paga até 6% do salário
+  transportVoucher?: number
+  // outros descontos em folha (coparticipação de plano, empréstimo…)
+  otherDiscounts?: number
+  // benefícios mensais pagos pela empresa e não descontados (VR/VA, parte do plano de saúde, auxílios)
+  monthlyBenefits?: number
+  // PLR, bônus ou RSUs líquidos no ano
+  annualBonus?: number
+  includeFgts?: boolean
+}
+
+export interface CltMonth {
+  gross: number
+  inss: number
+  irrf: IrrfResult
+  transportDiscount: number
+  alimony: number
+  otherDiscounts: number
+  net: number
+}
+
+export function cltMonth(gross: number, options: CltOptions = {}): CltMonth {
+  const { dependents = 0, alimony = 0, transportVoucher = 0, otherDiscounts = 0 } = options
+  const socialSecurity = inss(gross)
+  const income = irrf({ taxableIncome: gross, socialSecurity, dependents, alimony })
+  const transportDiscount = round2(Math.min(transportVoucher, gross * TRANSPORT_VOUCHER_RATE))
+  const net = round2(gross - socialSecurity - income.tax - transportDiscount - alimony - otherDiscounts)
+  return { gross, inss: socialSecurity, irrf: income, transportDiscount, alimony, otherDiscounts, net }
+}
+
+export interface CltYear {
+  month: CltMonth
+  // 13º líquido (tributação exclusiva, mesma tabela e redução)
+  net13th: number
+  // ganho líquido de férias: (salário + 1/3) tributados juntos, menos o salário líquido do mês que ele substitui
+  vacationBonusNet: number
+  fgtsYear: number
+  // benefícios no ano: mensais × 12 + parte do VT paga pela empresa
+  benefitsYear: number
+  bonusYear: number
+  // tudo que entra no ano (salários líquidos, 13º, 1/3 de férias, FGTS, benefícios, bônus)
+  annualTotal: number
+  monthlyEquivalent: number
+}
+
+export function cltYear(gross: number, options: CltOptions = {}): CltYear {
+  const { dependents = 0, monthlyBenefits = 0, annualBonus = 0, includeFgts = true, transportVoucher = 0 } = options
+  const month = cltMonth(gross, options)
+
+  const tax13th = payrollTaxes(gross, { dependents })
+  const net13th = round2(gross - tax13th.inss - tax13th.irrf)
+
+  // no mês de férias o salário vem com o terço constitucional e é tributado junto
+  const vacation = cltMonth(gross + gross / 3, options)
+  const vacationBonusNet = round2(vacation.net - month.net)
+
+  const fgtsYear = includeFgts ? round2(gross * FGTS_RATE * (12 + 1 + 1 / 3)) : 0
+  const benefitsYear = round2(monthlyBenefits * 12 + (transportVoucher - month.transportDiscount) * 11)
+  const annualTotal = round2(month.net * 12 + net13th + vacationBonusNet + fgtsYear + benefitsYear + annualBonus)
+  return { month, net13th, vacationBonusNet, fgtsYear, benefitsYear, bonusYear: annualBonus, annualTotal, monthlyEquivalent: round2(annualTotal / 12) }
+}
+
+// Menor salário bruto cujo pacote anual atinge a meta (busca binária, precisão de centavos)
+export function grossForAnnualTotal(target: number, options: CltOptions = {}): number {
+  if (cltYear(0, options).annualTotal >= target) return 0
+  let low = 0
+  let high = 1_000_000
+  while (high - low > 0.01) {
+    const mid = (low + high) / 2
+    if (cltYear(mid, options).annualTotal >= target) high = mid
+    else low = mid
+  }
+  // menor valor em centavos que atinge a meta (evita 12.000,01 quando 12.000,00 já basta)
+  const cents = Math.floor(high * 100) / 100
+  return cltYear(cents, options).annualTotal >= target ? cents : Math.round((cents + 0.01) * 100) / 100
+}
+

package/src/finance/compound.ts

@@ -0,0 +1,78 @@
+// Juros compostos com aportes mensais, IR regressivo da renda fixa e correção pela inflação.
+// Taxas anuais são EFETIVAS (como CDI, poupança e Tesouro são cotados): mensal = (1 + anual)^(1/12) − 1.
+
+export interface CompoundInput {
+  initial: number
+  monthly: number
+  months: number
+  // taxa anual efetiva, ex.: 0.1 = 10% a.a.
+  annualRate: number
+  // inflação anual esperada, para o valor real (poder de compra de hoje)
+  annualInflation?: number
+  // aplica o IR regressivo sobre o rendimento no resgate (CDB, Tesouro…); poupança é isenta
+  taxed?: boolean
+}
+
+export interface YearRow {
+  year: number
+  contributed: number
+  interest: number
+  balance: number
+}
+
+export interface CompoundResult {
+  rows: YearRow[]
+  contributed: number
+  interest: number
+  grossBalance: number
+  incomeTax: number
+  netBalance: number
+  // saldo líquido em reais de hoje
+  realBalance: number
+  // renda mensal sustentável pela regra dos 4% ao ano, em reais de hoje
+  monthlyIncome4: number
+}
+
+export const monthlyRate = (annual: number) => Math.pow(1 + annual, 1 / 12) - 1
+
+// Tabela regressiva da renda fixa (Lei 11.033/2004), pelo prazo de cada aporte
+export function regressiveRate(monthsHeld: number): number {
+  if (monthsHeld <= 6) return 0.225
+  if (monthsHeld <= 12) return 0.2
+  if (monthsHeld <= 24) return 0.175
+  return 0.15
+}
+
+export function simulate({ initial, monthly, months, annualRate, annualInflation = 0, taxed = false }: CompoundInput): CompoundResult {
+  const r = monthlyRate(annualRate)
+  const n = Math.max(0, Math.round(months))
+  let balance = initial
+  let contributed = initial
+  const rows: YearRow[] = []
+  // aporte no fim de cada mês, depois do rendimento do mês
+  for (let m = 1; m <= n; m++) {
+    balance = balance * (1 + r) + monthly
+    contributed += monthly
+    if (m % 12 === 0 || m === n) rows.push({ year: Math.ceil(m / 12), contributed, interest: balance - contributed, balance })
+  }
+
+  // IR: cada aporte tem o próprio prazo; o ganho de cada um paga a alíquota do seu prazo
+  let incomeTax = 0
+  if (taxed) {
+    const lots = [{ amount: initial, held: n }, ...Array.from({ length: n }, (_, k) => ({ amount: monthly, held: n - (k + 1) }))]
+    for (const { amount, held } of lots) incomeTax += amount * (Math.pow(1 + r, held) - 1) * regressiveRate(held)
+  }
+
+  const netBalance = balance - incomeTax
+  const realBalance = netBalance / Math.pow(1 + annualInflation, n / 12)
+  return {
+    rows,
+    contributed,
+    interest: balance - contributed,
+    grossBalance: balance,
+    incomeTax,
+    netBalance,
+    realBalance,
+    monthlyIncome4: (realBalance * 0.04) / 12,
+  }
+}

package/src/finance/pj.ts

@@ -0,0 +1,146 @@
+import { INSS_2026, irrf } from "./clt"
+
+// Tributação de PJ de serviços (2026). Fontes: LC 123/2006 (Anexos III e V do Simples), Res. CGSN 140/2018,
+// Lei 15.270/2025 (dividendos), DAS-MEI com salário mínimo de R$ 1.621.
+
+export const MINIMUM_WAGE_2026 = 1621
+export const MEI = { annualLimit: 81_000, monthlyDas: 86.05 } // 5% do salário mínimo + R$ 5 de ISS
+// Faixas por receita bruta dos últimos 12 meses (RBT12): alíquota nominal e parcela a deduzir
+// cppShare: parte do DAS que é contribuição previdenciária patronal (repartição do Anexo III)
+export const SIMPLES_ANEXO_III = [
+  { upTo: 180_000, rate: 0.06, deduction: 0, cppShare: 0.434 },
+  { upTo: 360_000, rate: 0.112, deduction: 9_360, cppShare: 0.434 },
+  { upTo: 720_000, rate: 0.135, deduction: 17_640, cppShare: 0.434 },
+  { upTo: 1_800_000, rate: 0.16, deduction: 35_640, cppShare: 0.434 },
+  { upTo: 3_600_000, rate: 0.21, deduction: 125_640, cppShare: 0.434 },
+  { upTo: 4_800_000, rate: 0.33, deduction: 648_000, cppShare: 0.305 },
+]
+export const SIMPLES_ANEXO_V = [
+  { upTo: 180_000, rate: 0.155, deduction: 0 },
+  { upTo: 360_000, rate: 0.18, deduction: 4_500 },
+  { upTo: 720_000, rate: 0.195, deduction: 9_900 },
+  { upTo: 1_800_000, rate: 0.205, deduction: 17_100 },
+  { upTo: 3_600_000, rate: 0.23, deduction: 62_100 },
+  { upTo: 4_800_000, rate: 0.305, deduction: 540_000 },
+]
+export const SIMPLES_LIMIT = 4_800_000
+// Fator R: folha de 12 meses ÷ RBT12 ≥ 28% leva atividades do Anexo V para o Anexo III.
+// A folha inclui o pró-labore E a CPP efetivamente recolhida (LC 123, art. 18, §24) — no Simples, a CPP vem dentro do DAS.
+export const FATOR_R = 0.28
+// Lucro Presumido, serviços: presunção de 32% para IRPJ e CSLL
+export const PRESUMIDO = { presumption: 0.32, irpj: 0.15, irpjSurcharge: 0.1, surchargeMonthlyThreshold: 20_000, csll: 0.09, pis: 0.0065, cofins: 0.03, cpp: 0.2 }
+// Sócio: INSS de 11% sobre o pró-labore, limitado ao teto
+export const PRO_LABORE_INSS_RATE = 0.11
+// Dividendos (Lei 15.270/2025): acima de R$ 50 mil/mês da mesma empresa para a mesma pessoa, 10% sobre o total
+export const DIVIDENDS = { monthlyExemption: 50_000, rate: 0.1 }
+
+type Bracket = { upTo: number, rate: number, deduction: number }
+
+export function simplesEffectiveRate(rbt12: number, table: Bracket[]): number {
+  if (rbt12 <= 0) return table[0]?.rate ?? 0
+  const bracket = table.find((b) => rbt12 <= b.upTo) ?? table[table.length - 1]
+  return bracket ? (rbt12 * bracket.rate - bracket.deduction) / rbt12 : 0
+}
+
+export function simplesCppShare(rbt12: number): number {
+  return (SIMPLES_ANEXO_III.find((b) => rbt12 <= b.upTo) ?? SIMPLES_ANEXO_III[SIMPLES_ANEXO_III.length - 1])?.cppShare ?? 0
+}
+
+// Cooperado de cooperativa de trabalho: contribuinte individual, 20% retidos pela cooperativa até o teto
+// (a alíquota de 11% acabou com o RE 595.838/STF, que derrubou a contribuição de 15% do tomador)
+export const COOPERATIVE_INSS_RATE = 0.2
+export function cooperativeInss(remuneration: number): number {
+  const ceiling = INSS_2026[INSS_2026.length - 1]?.upTo ?? Infinity
+  return Math.min(remuneration, ceiling) * COOPERATIVE_INSS_RATE
+}
+
+export function proLaboreInss(proLabore: number): number {
+  const ceiling = INSS_2026[INSS_2026.length - 1]?.upTo ?? Infinity
+  return Math.min(proLabore, ceiling) * PRO_LABORE_INSS_RATE
+}
+
+export type Regime = "mei" | "simples-iii" | "simples-v" | "presumido"
+
+export interface PjInput {
+  monthlyRevenue: number
+  // pró-labore mensal; no Anexo III ele é ajustado para atingir o Fator R
+  proLabore: number
+  // ISS do município (Lucro Presumido)
+  issRate: number
+  accountant: number
+  otherExpenses: number
+}
+
+export interface RegimeResult {
+  regime: Regime
+  allowed: boolean
+  // tributos da empresa (DAS ou IRPJ+CSLL+PIS+COFINS+ISS+CPP)
+  companyTaxes: number
+  proLabore: number
+  proLaboreInss: number
+  proLaboreIrrf: number
+  dividendsTax: number
+  totalTaxes: number
+  effectiveRate: number
+  // o que sobra para o sócio no mês: faturamento − tributos − contador − despesas
+  net: number
+  // Simples: alíquota efetiva do DAS
+  simplesRate?: number
+}
+
+function partner(proLabore: number) {
+  const inss = proLaboreInss(proLabore)
+  return { inss, irrf: irrf({ taxableIncome: proLabore, socialSecurity: inss }).tax }
+}
+
+function finish(regime: Regime, input: PjInput, companyTaxes: number, proLabore: number, allowed = true, simplesRate?: number): RegimeResult {
+  const { inss, irrf: irrfTax } = partner(proLabore)
+  const profit = input.monthlyRevenue - companyTaxes - proLabore - input.accountant - input.otherExpenses
+  const dividendsTax = profit > DIVIDENDS.monthlyExemption ? profit * DIVIDENDS.rate : 0
+  const totalTaxes = companyTaxes + inss + irrfTax + dividendsTax
+  const result: RegimeResult = {
+    regime,
+    allowed,
+    companyTaxes,
+    proLabore,
+    proLaboreInss: inss,
+    proLaboreIrrf: irrfTax,
+    dividendsTax,
+    totalTaxes,
+    effectiveRate: input.monthlyRevenue > 0 ? totalTaxes / input.monthlyRevenue : 0,
+    net: input.monthlyRevenue - totalTaxes - input.accountant - input.otherExpenses,
+  }
+  if (simplesRate !== undefined) result.simplesRate = simplesRate
+  return result
+}
+
+export function compareRegimes(input: PjInput): RegimeResult[] {
+  const revenue = input.monthlyRevenue
+  const rbt12 = revenue * 12
+  const minimumProLabore = Math.max(input.proLabore, MINIMUM_WAGE_2026)
+
+  // MEI: DAS fixo, sem pró-labore obrigatório; a maioria das atividades de TI não é permitida
+  const mei = finish("mei", { ...input, accountant: 0 }, MEI.monthlyDas, 0, rbt12 <= MEI.annualLimit)
+
+  // Anexo III via Fator R: pró-labore + CPP do DAS precisam somar 28% do faturamento
+  const rateIII = simplesEffectiveRate(rbt12, SIMPLES_ANEXO_III)
+  const fatorRProLabore = Math.max(minimumProLabore, revenue * FATOR_R - revenue * rateIII * simplesCppShare(rbt12))
+  const simplesIII = finish("simples-iii", input, revenue * rateIII, fatorRProLabore, rbt12 <= SIMPLES_LIMIT, rateIII)
+
+  // Anexo V: sem Fator R, pró-labore mínimo
+  const rateV = simplesEffectiveRate(rbt12, SIMPLES_ANEXO_V)
+  const simplesV = finish("simples-v", input, revenue * rateV, minimumProLabore, rbt12 <= SIMPLES_LIMIT, rateV)
+
+  // Lucro Presumido: tributos sobre o faturamento + CPP de 20% sobre o pró-labore (fora do Simples)
+  const p = PRESUMIDO
+  const presumedProfit = revenue * p.presumption
+  const irpj = presumedProfit * p.irpj + Math.max(0, presumedProfit - p.surchargeMonthlyThreshold) * p.irpjSurcharge
+  const presumidoTaxes = irpj + presumedProfit * p.csll + revenue * (p.pis + p.cofins + input.issRate) + minimumProLabore * p.cpp
+  const presumido = finish("presumido", input, presumidoTaxes, minimumProLabore)
+
+  return [mei, simplesIII, simplesV, presumido]
+}
+
+export function bestRegime(results: RegimeResult[]): RegimeResult | undefined {
+  return results.filter((r) => r.allowed).reduce<RegimeResult | undefined>((best, r) => (!best || r.net > best.net ? r : best), undefined)
+}

package/src/fov.ts

@@ -0,0 +1,145 @@
+// Calculadora de FOV para simuladores — porte da lógica de https://github.com/dinex86/FOV-Calculator (MIT)
+// Ideia: o campo de visão "correto" é o ângulo que a tela realmente ocupa na sua visão,
+// assim os objetos no jogo aparecem em escala real.
+
+export interface Setup {
+  aspect: [number, number]
+  // diagonal de UMA tela, em polegadas
+  diagonalIn: number
+  // distância dos olhos até a tela, em cm
+  distanceCm: number
+  screens: 1 | 3
+  // espessura da moldura (bezel) de cada tela, em mm — só conta com 3 telas
+  bezelMm: number
+  curved: boolean
+  // raio da curvatura em mm (ex.: "1800R" = 1800)
+  radiusMm: number
+}
+
+export const DEFAULT_SETUP: Setup = { aspect: [16, 9], diagonalIn: 27, distanceCm: 60, screens: 1, bezelMm: 0, curved: false, radiusMm: 1800 }
+
+export const ASPECTS: [number, number][] = [[16, 9], [16, 10], [21, 9], [24, 10], [32, 9], [32, 10], [5, 4], [4, 3]]
+
+const DEG = 180 / Math.PI
+
+export function screenSizeCm(diagonalIn: number, [x, y]: [number, number]) {
+  const diagonalCm = diagonalIn * 2.54
+  const unit = Math.sqrt((diagonalCm * diagonalCm) / (x * x + y * y))
+  return { width: x * unit, height: y * unit }
+}
+
+function flatAngle(widthCm: number, distanceCm: number): number {
+  return Math.atan2(widthCm / 2, distanceCm) * 2
+}
+
+// Tela curva: usa a corda entre as bordas da tela e a "profundidade" da curva
+function curvedAngle(widthCm: number, radiusMm: number, distanceCm: number): number {
+  const radius = radiusMm / 10
+  const arcAngle = widthCm / radius
+  const depth = radius * (1 - Math.cos(arcAngle / 2))
+  const halfChord = Math.sqrt(2 * radius * depth - depth * depth)
+  return 2 * Math.atan2(halfChord, distanceCm - depth)
+}
+
+export interface Angles {
+  // FOV horizontal de UMA tela, em graus
+  hFovSingle: number
+  // FOV horizontal total (todas as telas), em graus
+  hFov: number
+  // FOV vertical, em graus
+  vFov: number
+  // ângulo para girar cada tela lateral (igual ao hFOV de uma tela)
+  sideScreenAngle: number
+  widthCm: number
+  heightCm: number
+}
+
+export function calculateAngles(setup: Setup): Angles {
+  const [x, y] = setup.aspect
+  const { width, height } = screenSizeCm(setup.diagonalIn, setup.aspect)
+  // a moldura entre telas "rouba" campo de visão: soma 2 bezels (em cm) à largura
+  const effectiveWidth = width + (setup.screens > 1 ? (setup.bezelMm / 10) * 2 : 0)
+  const h = setup.curved ? curvedAngle(effectiveWidth, setup.radiusMm, setup.distanceCm) : flatAngle(effectiveWidth, setup.distanceCm)
+  const v = 2 * Math.atan2(Math.tan(h / 2) * y, x)
+  return { hFovSingle: h * DEG, hFov: h * DEG * setup.screens, vFov: v * DEG, sideScreenAngle: h * DEG, widthCm: width, heightCm: height }
+}
+
+type Kind = "hfov" | "hfov-rad" | "hfov-step" | "vfov" | "vfov-multiplier" | "vfov-step"
+
+interface GameConfig {
+  name: string
+  kind: Kind
+  min?: number
+  max?: number
+  decimals: number
+  factor?: number
+  // jogos com slider relativo: valor = round((fov − base) / incremento) × passo
+  base?: number
+  increment?: number
+  step?: number
+}
+
+// Valores e limites de cada jogo conforme o projeto original
+export const GAMES: GameConfig[] = [
+  { name: "Assetto Corsa / Assetto Corsa Competizione", kind: "vfov", min: 10, max: 120, decimals: 1 },
+  { name: "rFactor 1 & 2, GSC, GSCE, SCE, AMS (ISI)", kind: "vfov", min: 10, max: 100, decimals: 0 },
+  { name: "DiRT Rally 1/2, GRID Autosport", kind: "vfov", min: 10, max: 115, decimals: 0, factor: 2 },
+  { name: "RaceRoom Racing Experience", kind: "hfov", min: 35, max: 180, decimals: 1 },
+  { name: "Project CARS 1/2", kind: "hfov", min: 35, max: 180, decimals: 0 },
+  { name: "Euro & American Truck Simulator", kind: "hfov", min: 35, max: 180, decimals: 0 },
+  { name: "F1 2016–2018", kind: "hfov-step", min: -1, max: 1, decimals: 2, base: 77, increment: 2, step: 0.05 },
+  { name: "F1 2019–2020", kind: "hfov-step", min: -10, max: 10, decimals: 1, base: 77, increment: 2, step: 0.1 },
+  { name: "F1 2021+", kind: "hfov-step", min: -20, max: 20, decimals: 0, base: 77, increment: 2, step: 1 },
+  { name: "EA Sports WRC", kind: "vfov-step", min: 0, max: 100, decimals: 0, base: 18, increment: 0.5, step: 1 },
+  { name: "Richard Burns Rally", kind: "hfov-rad", min: 10, max: 180, decimals: 6 },
+  { name: "GTR2", kind: "vfov-multiplier", min: 0.5, max: 1.5, decimals: 1, base: 58 },
+  { name: "Race 07", kind: "vfov-multiplier", min: 0.4, max: 1.5, decimals: 1, base: 58 },
+]
+
+export type GameUnit = "°" | "rad" | "x" | ""
+
+export interface GameResult {
+  name: string
+  kind: Kind
+  value: string
+  unit: GameUnit
+  // true quando o valor ideal está fora do que o jogo permite e foi limitado
+  clamped: boolean
+}
+
+export function gameSettings(setup: Setup, angles: Angles = calculateAngles(setup)): GameResult[] {
+  return GAMES.map((game) => {
+    let value: number
+    let unit: GameUnit = "°"
+    switch (game.kind) {
+      case "hfov":
+      case "hfov-step":
+        value = angles.hFov
+        break
+      case "hfov-rad": {
+        // RBR usa o FOV horizontal de uma tela 4:3 com a mesma altura
+        const [x, y] = setup.aspect
+        const width4by3 = ((angles.widthCm + (setup.screens > 1 ? (setup.bezelMm / 10) * 2 : 0)) / x) * y / 3 * 4
+        value = flatAngle(width4by3, setup.distanceCm) * DEG
+        unit = "rad"
+        break
+      }
+      default:
+        value = angles.vFov
+    }
+    value *= game.factor ?? 1
+    if (game.kind === "vfov-multiplier") {
+      value /= game.base ?? 1
+      unit = "x"
+    }
+    if (game.kind === "hfov-step" || game.kind === "vfov-step") {
+      value = Math.round((value - (game.base ?? 0)) / (game.increment ?? 1)) * (game.step ?? 1)
+      unit = ""
+    }
+    const limited = Math.min(Math.max(value, game.min ?? -Infinity), game.max ?? Infinity)
+    const clamped = Math.abs(limited - value) > 1e-9
+    const final = unit === "rad" ? limited * (Math.PI / 180) : limited
+    const scale = 10 ** game.decimals
+    return { name: game.name, kind: game.kind, value: (Math.round(final * scale) / scale).toFixed(game.decimals), unit, clamped }
+  })
+}

package/src/hash.ts

@@ -0,0 +1,13 @@
+// Hashes via Web Crypto (nativo do navegador e do Node). MD5 não existe na Web Crypto por ser inseguro.
+export const ALGORITHMS = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"] as const
+export type Algorithm = (typeof ALGORITHMS)[number]
+
+export async function hash(text: string, algorithm: Algorithm): Promise<string> {
+  const digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(text))
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("")
+}
+
+export async function hashAll(text: string): Promise<Record<Algorithm, string>> {
+  const values = await Promise.all(ALGORITHMS.map((algorithm) => hash(text, algorithm)))
+  return Object.fromEntries(ALGORITHMS.map((algorithm, i) => [algorithm, values[i] ?? ""])) as Record<Algorithm, string>
+}