《独立开发者的商业指南·资本与退出》8.3 代码、域名与数据交割

// file: src/capital/code-handover.ts
// tier: L1
// verify: node --test test/capital/code-handover.test.ts

import { type Cents } from "../core/money.ts";
import { type Bps, applyRate } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type HandoverArea =
  | "repo-access"
  | "ci-cd"
  | "domain-dns"
  | "database-backup"
  | "secret-rotation";

export const HANDOVER_AREAS: HandoverArea[] = [
  "repo-access",
  "ci-cd",
  "domain-dns",
  "database-backup",
  "secret-rotation",
];

export type HandoverItem = {
  area: HandoverArea;
  label: string;
  hours: number;
  done: boolean;
};

export type HandoverInput = {
  priceCents: Cents;
  dailyRevenueCents: Cents;
  monthlyRevenueCents: Cents;
  downtimeHours: number;
  slaCreditBps: Bps;
  buyerDeductionBps: Bps;
  hourlyRateCents: Cents;
  items: HandoverItem[];
  secretsToRotate: number;
  minutesPerSecret: number;
  accountsToRevoke: number;
  minutesPerAccount: number;
};

export type AreaProgress = {
  total: number;
  done: number;
  pending: number;
};

export type HandoverOutcome = {
  itemCount: number;
  doneCount: number;
  pendingCount: number;
  missingAreas: HandoverArea[];
  areaProgress: Record<HandoverArea, AreaProgress>;
  readyForHandover: boolean;
  laborHours: number;
  laborCostCents: Cents;
  rotationHours: number;
  rotationCostCents: Cents;
  revocationHours: number;
  revocationCostCents: Cents;
  revenueLossCents: Cents;
  slaCreditCents: Cents;
  buyerDeductionCents: Cents;
  totalCostCents: Cents;
  urgentActions: number;
  urgentDeadlineHours: number;
};

function checkAmount(value: Cents, label: string): string | null {
  if (!Number.isInteger(value) || value < 0) {
    return `${label} must be a non-negative integer amount in cents`;
  }
  return null;
}

function checkBps(value: Bps, label: string): string | null {
  if (!Number.isInteger(value) || value < 0 || value > 10000) {
    return `${label} must be between 0 and 10000 bps`;
  }
  return null;
}

function emptyProgress(): Record<HandoverArea, AreaProgress> {
  return {
    "repo-access": { total: 0, done: 0, pending: 0 },
    "ci-cd": { total: 0, done: 0, pending: 0 },
    "domain-dns": { total: 0, done: 0, pending: 0 },
    "database-backup": { total: 0, done: 0, pending: 0 },
    "secret-rotation": { total: 0, done: 0, pending: 0 },
  };
}

/**
 * Code handover cost has a visible layer and a hidden layer. The visible layer
 * is planned labour: repository, CI/CD, DNS, database and secret items, priced
 * at an hourly rate. The hidden layer only appears when the migration goes
 * wrong: one day of downtime, the SLA credit owed to customers, and the price
 * deduction the buyer takes for it. Rotation and revocation are counted
 * separately because they must finish inside 24 hours after closing.
 */
export function codeHandover(input: HandoverInput): Result<HandoverOutcome> {
  const priceError = checkAmount(input.priceCents, "price");
  if (priceError) {
    return fail(priceError);
  }
  if (input.priceCents === 0) {
    return fail("price must be positive");
  }
  for (const [value, label] of [
    [input.dailyRevenueCents, "daily revenue"],
    [input.monthlyRevenueCents, "monthly revenue"],
    [input.hourlyRateCents, "hourly rate"],
  ] as Array<[Cents, string]>) {
    const error = checkAmount(value, label);
    if (error) {
      return fail(error);
    }
  }
  if (
    !Number.isInteger(input.downtimeHours) ||
    input.downtimeHours < 0 ||
    input.downtimeHours > 720
  ) {
    return fail("downtime hours must be an integer between 0 and 720");
  }
  for (const [value, label] of [
    [input.slaCreditBps, "SLA credit"],
    [input.buyerDeductionBps, "buyer deduction"],
  ] as Array<[Bps, string]>) {
    const error = checkBps(value, label);
    if (error) {
      return fail(error);
    }
  }
  if (input.items.length === 0) {
    return fail("handover list must contain at least one item");
  }
  if (
    !Number.isInteger(input.secretsToRotate) ||
    input.secretsToRotate < 0 ||
    !Number.isInteger(input.accountsToRevoke) ||
    input.accountsToRevoke < 0 ||
    !Number.isInteger(input.minutesPerSecret) ||
    input.minutesPerSecret < 0 ||
    !Number.isInteger(input.minutesPerAccount) ||
    input.minutesPerAccount < 0
  ) {
    return fail("rotation and revocation counts must be non-negative integers");
  }

  const areaProgress = emptyProgress();
  let doneCount = 0;
  let laborHours = 0;
  for (const item of input.items) {
    if (!HANDOVER_AREAS.includes(item.area)) {
      return fail(`unknown handover area: ${item.area}`);
    }
    if (!Number.isInteger(item.hours) || item.hours < 0) {
      return fail("item hours must be a non-negative integer");
    }
    const progress = areaProgress[item.area];
    progress.total += 1;
    laborHours += item.hours;
    if (item.done) {
      progress.done += 1;
      doneCount += 1;
    } else {
      progress.pending += 1;
    }
  }

  const missingAreas = HANDOVER_AREAS.filter(
    (area) => areaProgress[area].total === 0,
  );
  const itemCount = input.items.length;
  const rotationHours =
    (input.secretsToRotate * input.minutesPerSecret) / 60;
  const revocationHours =
    (input.accountsToRevoke * input.minutesPerAccount) / 60;
  const laborCostCents = Math.round(laborHours * input.hourlyRateCents);
  const rotationCostCents = Math.round(rotationHours * input.hourlyRateCents);
  const revocationCostCents = Math.round(
    revocationHours * input.hourlyRateCents,
  );
  const revenueLossCents = Math.round(
    (input.dailyRevenueCents * input.downtimeHours) / 24,
  );
  const slaCreditCents =
    input.downtimeHours === 0
      ? 0
      : applyRate(input.monthlyRevenueCents, input.slaCreditBps);
  const buyerDeductionCents = applyRate(
    input.priceCents,
    input.buyerDeductionBps,
  );

  return ok({
    itemCount,
    doneCount,
    pendingCount: itemCount - doneCount,
    missingAreas,
    areaProgress,
    readyForHandover: doneCount === itemCount && missingAreas.length === 0,
    laborHours,
    laborCostCents,
    rotationHours,
    rotationCostCents,
    revocationHours,
    revocationCostCents,
    revenueLossCents,
    slaCreditCents,
    buyerDeductionCents,
    totalCostCents:
      laborCostCents +
      rotationCostCents +
      revocationCostCents +
      revenueLossCents +
      slaCreditCents +
      buyerDeductionCents,
    urgentActions: input.secretsToRotate + input.accountsToRevoke,
    urgentDeadlineHours: 24,
  });
}