《独立开发者的商业指南·合同、应收与风险》7.2 开源许可证的商业边界

// file: src/contract/oss.ts
// tier: L1
// verify: node --test test/contract/oss.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 LicenseId =
  | "mit"
  | "apache_2"
  | "lgpl"
  | "gpl"
  | "agpl"
  | "proprietary";
export type LicenseTier =
  | "permissive"
  | "weak_copyleft"
  | "strong_copyleft"
  | "proprietary";
export type UseMode =
  | "internal"
  | "saas"
  | "distribute"
  | "distribute_modified";
export type LgplVariant = "separate" | "modified_or_static";

export type LicenseTerm = {
  id: LicenseId;
  label: string;
  tier: LicenseTier;
};

export const LICENSE_TERMS: Record<LicenseId, LicenseTerm> = {
  mit: { id: "mit", label: "MIT", tier: "permissive" },
  apache_2: { id: "apache_2", label: "Apache-2.0", tier: "permissive" },
  lgpl: { id: "lgpl", label: "LGPL", tier: "weak_copyleft" },
  gpl: { id: "gpl", label: "GPL", tier: "strong_copyleft" },
  agpl: { id: "agpl", label: "AGPL", tier: "strong_copyleft" },
  proprietary: {
    id: "proprietary",
    label: "专有许可",
    tier: "proprietary",
  },
};

export const LICENSE_IDS = Object.keys(LICENSE_TERMS) as LicenseId[];

export type BoundaryDecision = {
  license: LicenseId;
  label: string;
  tier: LicenseTier;
  mode: UseMode;
  canCloseSource: boolean;
  mustPublishChanges: boolean;
  mustOfferServiceSource: boolean;
  noticeRequired: boolean;
  note: string;
};

function isUseMode(value: string): value is UseMode {
  return (
    value === "internal" ||
    value === "saas" ||
    value === "distribute" ||
    value === "distribute_modified"
  );
}

/**
 * Commercial reading, not a legal opinion. "Distribute" means the licensed
 * code becomes part of a combined work shipped to users. Using a component as
 * a separate process can move the boundary; that separation has to be real.
 */
export function decideBoundary(
  license: LicenseId,
  mode: UseMode,
  lgplVariant: LgplVariant = "separate",
): Result<BoundaryDecision> {
  if (!Object.hasOwn(LICENSE_TERMS, license)) {
    return fail(`unknown license: ${license}`);
  }
  if (!isUseMode(mode)) {
    return fail(`unknown use mode: ${mode}`);
  }

  const term = LICENSE_TERMS[license];
  let canCloseSource = true;
  let mustPublishChanges = false;
  let mustOfferServiceSource = false;
  let note = "";

  if (license === "mit" || license === "apache_2") {
    note =
      license === "apache_2"
        ? "保留版权与 NOTICE，附带的专利授权随分发生效"
        : "保留版权与许可声明，可闭源分发";
  } else if (license === "lgpl") {
    if (mode === "distribute" || mode === "distribute_modified") {
      if (lgplVariant === "modified_or_static") {
        mustPublishChanges = true;
        note =
          "应用层可闭源；LGPL 库及其修改须提供源码与可重链接目标文件";
      } else {
        note = "动态链接且库未修改时可闭源，须允许用户替换该库";
      }
    } else {
      note = "内部使用或网络服务不触发 LGPL 的分发义务";
    }
  } else if (license === "gpl") {
    if (mode === "distribute" || mode === "distribute_modified") {
      canCloseSource = false;
      mustPublishChanges = true;
      note = "分发组合作品须向接收者提供对应源码";
    } else {
      note = "内部使用或网络服务不触发 GPL 的分发义务";
    }
  } else if (license === "agpl") {
    if (
      mode === "saas" ||
      mode === "distribute" ||
      mode === "distribute_modified"
    ) {
      canCloseSource = false;
      mustPublishChanges = true;
      mustOfferServiceSource = mode === "saas";
      note =
        mode === "saas"
          ? "向网络用户提供服务即须提供对应源码"
          : "分发与网络服务均触发源码义务";
    } else {
      note = "仅内部使用不触发 AGPL 的源码义务";
    }
  } else {
    note = "自有代码可按专有条款分发；第三方专有组件以授权合同为准";
  }

  return ok({
    license,
    label: term.label,
    tier: term.tier,
    mode,
    canCloseSource,
    mustPublishChanges,
    mustOfferServiceSource,
    noticeRequired: license !== "proprietary",
    note,
  });
}

export type AgplCostInput = {
  annualRevenueCents: Cents;
  years: number;
  engineeringHours: number;
  hourlyRateCents: Cents;
  revenueLossBps: Bps;
};

export type AgplCost = {
  engineeringCents: Cents;
  lostRevenueCents: Cents;
  totalCents: Cents;
  revenueShareBps: Bps;
};

/**
 * The AGPL network trigger has two costs: one-time engineering to publish and
 * keep publishing source, and the revenue exposed when competitors can copy the
 * service layer. Both are teaching assumptions.
 */
export function agplComplianceCost(input: AgplCostInput): Result<AgplCost> {
  if (
    !Number.isInteger(input.annualRevenueCents) ||
    input.annualRevenueCents <= 0
  ) {
    return fail("annual revenue must be a positive integer amount in cents");
  }
  if (!Number.isInteger(input.years) || input.years <= 0 || input.years > 10) {
    return fail("years must be an integer between 1 and 10");
  }
  if (
    !Number.isInteger(input.engineeringHours) ||
    input.engineeringHours < 0
  ) {
    return fail("engineering hours must be a non-negative integer");
  }
  if (
    !Number.isInteger(input.hourlyRateCents) ||
    input.hourlyRateCents < 0
  ) {
    return fail("hourly rate must be a non-negative integer amount in cents");
  }
  if (
    !Number.isInteger(input.revenueLossBps) ||
    input.revenueLossBps < 0 ||
    input.revenueLossBps > 10000
  ) {
    return fail("revenue loss must be between 0 and 10000 bps");
  }

  const engineeringCents = input.engineeringHours * input.hourlyRateCents;
  const lostRevenueCents =
    applyRate(input.annualRevenueCents, input.revenueLossBps) * input.years;
  const totalCents = engineeringCents + lostRevenueCents;

  return ok({
    engineeringCents,
    lostRevenueCents,
    totalCents,
    revenueShareBps: divide(totalCents, input.annualRevenueCents),
  });
}