Software is the medium.
Useful change is the point.

type ProjectSignal = Readonly<{
  problem: string; audience: readonly string[]; constraints: readonly Constraint[];
}>;
type Constraint = { name: string; severity: "low" | "medium" | "high" };
type Phase = "frame" | "prototype" | "build" | "verify" | "release";
type BuildContext = Readonly<{ owner: string; repository: string; startedAt: string }>;
type Milestone = Readonly<{ id: string; phase: Phase; outcome: string }>;
type BuildPlan = Readonly<{ northStar: string; milestones: readonly Milestone[] }>;
type Prototype = Readonly<{ milestoneId: string; url: string; version: number }>;
type QualityGate = Readonly<{ name: string; required: boolean; threshold: number }>;
type Evidence = Readonly<{ gate: string; passed: boolean; measuredAt: string }>;
type ReleaseCandidate = Readonly<{
  plan: BuildPlan; prototypes: readonly Prototype[]; evidence: readonly Evidence[];
}>;
type BuildResult = Readonly<{
  status: "ready"; plan: BuildPlan; shippedAt: string; evidence: readonly Evidence[];
}>;

interface StudioServices {
  strategy: { frame(signal: ProjectSignal, context: BuildContext): Promise<BuildPlan> };
  product: { prototype(milestone: Milestone, context: BuildContext): Promise<Prototype> };
  quality: { verify(build: Prototype, gates: readonly QualityGate[]): Promise<Evidence[]> };
  delivery: { release(candidate: ReleaseCandidate): Promise<{ shippedAt: string }> };
}

const qualityGates: readonly QualityGate[] = [
  { name: "accessible", required: true, threshold: 1 },
  { name: "observable", required: true, threshold: 1 },
  { name: "responsive", required: true, threshold: 0.98 },
  { name: "maintainable", required: true, threshold: 0.95 },
];

export async function buildProduct(
  signal: ProjectSignal, services: StudioServices, context: BuildContext,
): Promise<BuildResult> {
  const plan = await services.strategy.frame(signal, context);
  const prototypes: Prototype[] = [];
  const evidence: Evidence[] = [];

  for (const milestone of plan.milestones) {
    const prototype = await services.product.prototype(milestone, context);
    const verification = await services.quality.verify(prototype, qualityGates);
    prototypes.push(prototype);
    evidence.push(...verification);
  }

  const failedGate = evidence.find((result) => result.passed === false);
  if (failedGate) throw new Error(`Quality gate failed: ${failedGate.gate}`);

  const release = await services.delivery.release({ plan, prototypes, evidence });
  return { status: "ready", plan, evidence, shippedAt: release.shippedAt };
}