Open/Closed, Critically

The edit lands in the function every method shares, so the whole checkout suite has to be re-run and re-reasoned about. Worse, asynchronous confirmation does not fit the flow at all, so a "pending" branch gets threaded through the shared sequence and every existing method now has a state it never uses.

One new implementation, one wiring line. Card and PayPal code is not touched, so it cannot break. The asynchronous confirmation still forces a real design decision — the interface has to be able to say "not settled yet" — but that decision is made once, in the contract, rather than smeared through the flow.

// payments/registry.ts
export class PaymentPluginRegistry {
  private plugins = new Map<string, PaymentPlugin>()
  discover(dir: string) { /* scan, import, validate manifest */ }
  register(p: PaymentPlugin) { /* version check, capability negotiation */ }
  resolve(id: string): PaymentPlugin { /* ... */ }
}

interface PaymentPlugin {
  readonly apiVersion: 2
  readonly capabilities: Capability[]
  charge(ctx: PluginContext, amount: Money): Promise<PluginResult>
}

// Three in-house implementations, in the same repo,
// deployed together, by the same team. Discovery, versioning
// and capability negotiation solve problems nobody has.

// checkout/PaymentMethod.ts  — declared by the core
export interface PaymentMethod {
  charge(amount: Money, ref: OrderRef): Promise<Settlement>
}

// checkout/process.ts — concrete, stable, one screen
export async function process(order: Order, pay: PaymentMethod) {
  const hold = await stock.reserve(order)          // invariant sequence,
  try {                                            // identical for every method
    const s = await pay.charge(order.total, order.ref)
    await confirm(order, s); events.emit(placed(order))
  } catch (e) { await stock.release(hold); throw e }
}

// composition/graph.ts — open along exactly one axis:
// new payment methods. Everything else is a normal edit.
const methods = { card, paypal, bank }