《独立开发者的商业指南·合同、应收与风险》7.1 商标、著作权、专利与商业秘密

// file: src/contract/ip.ts
// tier: L1
// verify: node --test test/contract/ip.test.ts

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

export type IpKind = "trademark" | "copyright" | "patent" | "trade_secret";
export type Acquisition = "registration" | "automatic" | "secrecy";

export type IpProfile = {
  kind: IpKind;
  label: string;
  subject: string;
  acquisition: Acquisition;
  termYears: number | null;
  termNote: string;
  filingCostCents: Cents;
  annualCostCents: Cents;
  renewalEveryYears: number | null;
  renewalCostCents: Cents;
  enforcementCostCents: Cents;
};

/**
 * Costs are teaching assumptions, not quotes. Filing is charged per unit:
 * a trademark class in one jurisdiction, a registered copyright work, a patent
 * jurisdiction, or one secrecy program. Annual cost is per unit per year.
 */
export const IP_PROFILES: Record<IpKind, IpProfile> = {
  trademark: {
    kind: "trademark",
    label: "商标",
    subject: "品牌名称、标识、产品名",
    acquisition: "registration",
    termYears: 10,
    termNote: "10 年一续，可无限续展（教学假设）",
    filingCostCents: 120_000,
    annualCostCents: 30_000,
    renewalEveryYears: 10,
    renewalCostCents: 100_000,
    enforcementCostCents: 2_500_000,
  },
  copyright: {
    kind: "copyright",
    label: "著作权",
    subject: "代码、美术、音乐、文字等原创表达",
    acquisition: "automatic",
    termYears: 70,
    termNote: "创作完成即产生；法人作品按发表后 70 年估算（教学假设）",
    filingCostCents: 30_000,
    annualCostCents: 0,
    renewalEveryYears: null,
    renewalCostCents: 0,
    enforcementCostCents: 1_500_000,
  },
  patent: {
    kind: "patent",
    label: "专利",
    subject: "技术方案、机制、流程（须满足授权条件）",
    acquisition: "registration",
    termYears: 20,
    termNote: "自申请起 20 年，不可续展（教学假设）",
    filingCostCents: 1_200_000,
    annualCostCents: 180_000,
    renewalEveryYears: null,
    renewalCostCents: 0,
    enforcementCostCents: 10_000_000,
  },
  trade_secret: {
    kind: "trade_secret",
    label: "商业秘密",
    subject: "未公开的算法、参数、客户名单、流程",
    acquisition: "secrecy",
    termYears: null,
    termNote: "不设固定期限，保密状态存续期间有效",
    filingCostCents: 0,
    annualCostCents: 250_000,
    renewalEveryYears: null,
    renewalCostCents: 0,
    enforcementCostCents: 2_000_000,
  },
};

export const IP_KINDS: IpKind[] = [
  "trademark",
  "copyright",
  "patent",
  "trade_secret",
];

export type IpCostInput = {
  kind: IpKind;
  years: number;
  units: number;
  expectedDisputes?: number;
  disputeProbabilityBps?: Bps;
};

export type IpCost = {
  kind: IpKind;
  years: number;
  units: number;
  filingCents: Cents;
  annualCents: Cents;
  renewalCents: Cents;
  enforcementCents: Cents;
  totalCents: Cents;
};

export type PortfolioCoverage = {
  total: number;
  registeredBps: Bps;
  automaticBps: Bps;
  secrecyBps: Bps;
};

function isIpKind(value: string): value is IpKind {
  return (IP_KINDS as string[]).includes(value);
}

/**
 * A five-year protection budget combines filing, annual maintenance, renewals
 * inside the horizon, and a probability-weighted enforcement reserve. The
 * horizon is deliberately separate from the legal term: a 20-year patent still
 * needs a decision about how many of those years the business will fund.
 */
export function protectionCost(input: IpCostInput): Result<IpCost> {
  if (!isIpKind(input.kind)) {
    return fail(`unknown IP kind: ${input.kind}`);
  }
  if (
    !Number.isInteger(input.years) ||
    input.years <= 0 ||
    input.years > 50
  ) {
    return fail("years must be an integer between 1 and 50");
  }
  if (!Number.isInteger(input.units) || input.units <= 0 || input.units > 100) {
    return fail("units must be an integer between 1 and 100");
  }
  const disputes = input.expectedDisputes ?? 0;
  const probability = input.disputeProbabilityBps ?? 0;
  if (!Number.isInteger(disputes) || disputes < 0) {
    return fail("expected disputes must be a non-negative integer");
  }
  if (
    !Number.isInteger(probability) ||
    probability < 0 ||
    probability > 10000
  ) {
    return fail("dispute probability must be between 0 and 10000 bps");
  }

  const profile = IP_PROFILES[input.kind];
  const filingCents = profile.filingCostCents * input.units;
  const annualCents =
    profile.annualCostCents * input.years * input.units;
  const renewals =
    profile.renewalEveryYears === null
      ? 0
      : Math.floor(input.years / profile.renewalEveryYears);
  const renewalCents =
    renewals * profile.renewalCostCents * input.units;
  const enforcementCents = applyRate(
    profile.enforcementCostCents * disputes,
    probability,
  );

  return ok({
    kind: input.kind,
    years: input.years,
    units: input.units,
    filingCents,
    annualCents,
    renewalCents,
    enforcementCents,
    totalCents:
      filingCents + annualCents + renewalCents + enforcementCents,
  });
}

/** Trademarks and patents are registered; copyright and secrecy are not. */
export function registrable(kind: IpKind): boolean {
  return kind === "trademark" || kind === "patent";
}

/**
 * A portfolio is not stronger because it has more items. This reports how much
 * of it depends on registration, automatic copyright, or operational secrecy,
 * so a buyer can see which assets need a chain-of-title review.
 */
export function portfolioCoverage(kinds: IpKind[]): Result<PortfolioCoverage> {
  if (kinds.length === 0) {
    return fail("portfolio needs at least one IP item");
  }
  const counts: Record<Acquisition, number> = {
    registration: 0,
    automatic: 0,
    secrecy: 0,
  };
  for (const kind of kinds) {
    if (!isIpKind(kind)) {
      return fail(`unknown IP kind: ${kind}`);
    }
    counts[IP_PROFILES[kind].acquisition] += 1;
  }
  const total = kinds.length;
  return ok({
    total,
    registeredBps: divide(counts.registration, total),
    automaticBps: divide(counts.automatic, total),
    secrecyBps: divide(counts.secrecy, total),
  });
}